src/gigedit/MacrosSetup.cpp

/*
    Copyright (c) MMXVII Christian Schoenebeck

    This file is part of "gigedit" and released under the terms of the
    GNU General Public License version 2.
*/

#include "MacrosSetup.h"
#include "global.h"
#include <assert.h>
#include <set>
#include <math.h>
#include <gtkmm/stock.h>

MacrosSetup::MacrosSetup() :
    m_modified(false),
    m_clipboardContent(NULL),
    m_addFromClipboardButton("  " + Glib::ustring(_("From Clipboard")) + "  " + UNICODE_PRIMARY_KEY_SYMBOL + "B"),
    m_addFromSelectionButton("  " + Glib::ustring(_("From Selection")) + "  " + UNICODE_PRIMARY_KEY_SYMBOL + "S"),
    m_statusLabel("",  Gtk::ALIGN_START),
    m_deleteButton(Glib::ustring(_("Delete")) + "  " + UNICODE_PRIMARY_KEY_SYMBOL + UNICODE_ERASE_KEY_SYMBOL),
    m_inverseDeleteButton(Glib::ustring(_("Inverse Delete")) + "  " + UNICODE_ALT_KEY_SYMBOL + UNICODE_ERASE_KEY_SYMBOL),
    m_applyButton(_("_Apply"), true),
    m_cancelButton(_("_Cancel"), true),
    m_altKeyDown(false),
    m_primaryKeyDown(false)
{
    add(m_vbox);

    set_title(_("Setup Macros"));

    set_default_size(800, 600);

    m_addFromClipboardButton.set_image(
        *new Gtk::Image(Gtk::Stock::ADD, Gtk::ICON_SIZE_BUTTON)
    );
    m_addFromSelectionButton.set_image(
        *new Gtk::Image(Gtk::Stock::ADD, Gtk::ICON_SIZE_BUTTON)
    );
    m_addFromClipboardButton.set_tooltip_text(_("Create a new macro from the content currently available on the clipboard."));
    m_addFromSelectionButton.set_tooltip_text(_("Create a new macro from the currently selected dimension region's parameters currently shown on the main window."));
    m_addHBox.pack_start(m_addFromClipboardButton);
    m_addHBox.pack_start(m_addFromSelectionButton);
    m_vbox.pack_start(m_addHBox, Gtk::PACK_SHRINK);

    // create Macro list treeview (including its data model)
    m_treeStoreMacros = MacroListTreeStore::create(m_treeModelMacros);
    m_treeViewMacros.set_model(m_treeStoreMacros);
    m_treeViewMacros.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
    //m_treeViewMacro.set_tooltip_text(_(""));
    m_treeViewMacros.append_column(_("Key"), m_treeModelMacros.m_col_key);
    m_treeViewMacros.append_column_editable(_("Name"), m_treeModelMacros.m_col_name);
    m_treeViewMacros.append_column(_("Created"), m_treeModelMacros.m_col_created);
    m_treeViewMacros.append_column(_("Modified"), m_treeModelMacros.m_col_modified);
    m_treeViewMacros.set_tooltip_column(m_treeModelMacros.m_col_comment.index());
    // make all rows gray text, except of "Name" column
    for (int i = 0; i <= 3; ++i) {
        if (i == m_treeModelMacros.m_col_name.index())
            continue;
        Gtk::TreeViewColumn* column = m_treeViewMacros.get_column(i);
        Gtk::CellRendererText* cellrenderer =
            dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
        cellrenderer->property_foreground().set_value("#bababa");
    }
    /*{
        Gtk::TreeViewColumn* column = m_treeViewMacro.get_column(0);
        Gtk::CellRendererText* cellrenderer =
            dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
        column->add_attribute(
            cellrenderer->property_foreground(), m_SamplesModel.m_color
        );
    }*/
    /*{
        Gtk::TreeViewColumn* column = m_treeViewMacro.get_column(1);
        Gtk::CellRendererText* cellrenderer =
            dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
        column->add_attribute(
            cellrenderer->property_foreground(), m_SamplesModel.m_color
        );
    }*/
    m_treeViewMacros.set_headers_visible(true);
    m_treeViewMacros.get_selection()->signal_changed().connect(
        sigc::mem_fun(*this, &MacrosSetup::onTreeViewSelectionChanged)
    );
    m_treeViewMacros.signal_key_release_event().connect_notify(
        sigc::mem_fun(*this, &MacrosSetup::onMacroTreeViewKeyRelease)
    );
    m_treeStoreMacros->signal_row_changed().connect(
        sigc::mem_fun(*this, &MacrosSetup::onMacroTreeViewRowValueChanged)
    );
    m_ignoreTreeViewValueChange = false;

    m_scrolledWindow.add(m_treeViewMacros);
    m_scrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
    m_vbox.pack_start(m_scrolledWindow);

    m_buttonBoxL.set_layout(Gtk::BUTTONBOX_START);
    m_buttonBoxL.pack_start(m_deleteButton);
    m_buttonBoxL.pack_start(m_inverseDeleteButton);
    m_deleteButton.set_sensitive(false);
    m_inverseDeleteButton.set_sensitive(false);

    m_buttonBox.set_layout(Gtk::BUTTONBOX_END);
    m_buttonBox.pack_start(m_applyButton);
    m_buttonBox.pack_start(m_cancelButton);
    m_applyButton.set_can_default();
    m_applyButton.set_sensitive(false);
    m_applyButton.grab_focus();

#if GTKMM_MAJOR_VERSION >= 3
    m_statusLabel.set_margin_left(6);
    m_statusLabel.set_margin_right(6);
#else
    m_statusHBox.set_spacing(6);
#endif

    m_statusHBox.pack_start(m_statusLabel);
    m_statusHBox.show_all_children();

    m_footerHBox.pack_start(m_buttonBoxL, Gtk::PACK_SHRINK);
    m_footerHBox.pack_start(m_statusHBox);
    m_footerHBox.pack_start(m_buttonBox, Gtk::PACK_SHRINK);

    m_vbox.pack_start(m_footerHBox, Gtk::PACK_SHRINK);

    m_addFromClipboardButton.signal_clicked().connect(
        sigc::mem_fun(*this, &MacrosSetup::onButtonAddFromClipboard)
    );

    m_addFromSelectionButton.signal_clicked().connect(
        sigc::mem_fun(*this, &MacrosSetup::onButtonAddFromSelection)
    );

    m_applyButton.signal_clicked().connect(
        sigc::mem_fun(*this, &MacrosSetup::onButtonApply)
    );

    m_cancelButton.signal_clicked().connect(
        sigc::mem_fun(*this, &MacrosSetup::onButtonCancel)
    );

    m_deleteButton.signal_clicked().connect(
        sigc::mem_fun(*this, &MacrosSetup::deleteSelectedRows)
    );

    m_inverseDeleteButton.signal_clicked().connect(
        sigc::mem_fun(*this, &MacrosSetup::inverseDeleteSelectedRows)
    );

    signal_hide().connect(
        sigc::mem_fun(*this, &MacrosSetup::onWindowHide)
    );

    signal_delete_event().connect(
        sigc::mem_fun(*this, &MacrosSetup::onWindowDelete)
    );

    signal_key_press_event().connect(
        sigc::mem_fun(*this, &MacrosSetup::onKeyPressed)
    );
    signal_key_release_event().connect(
        sigc::mem_fun(*this, &MacrosSetup::onKeyReleased)
    );

    show_all_children();
    updateStatus();
}

MacrosSetup::~MacrosSetup() {
    printf("MacrosSetup destruct\n");
}

void MacrosSetup::setMacros(const std::vector<Serialization::Archive>& macros,
                            Serialization::Archive* pClipboardContent,
                            gig::DimensionRegion* pSelectedDimRgn)
{
    // copy for non-destructive editing
    m_macros = macros;

    m_clipboardContent = pClipboardContent;
    m_selectedDimRgn = pSelectedDimRgn;

    reloadTreeView();
}

void MacrosSetup::onButtonAddFromClipboard() {
    printf("+fromClipboard\n");
    if (!m_clipboardContent) return;
    if (!m_clipboardContent->rootObject()) return;
    m_macros.push_back(*m_clipboardContent);
    m_modified = true;
    reloadTreeView();
}

void MacrosSetup::onButtonAddFromSelection() {
    printf("+fromSelection\n");
    if (!m_selectedDimRgn) return;
    std::string errorText;
    try {
        Serialization::Archive archive;
        archive.serialize(m_selectedDimRgn);
        //archive.setName("Unnamed Macro");
        m_macros.push_back(archive);
        m_modified = true;
        reloadTreeView();
    } catch (Serialization::Exception e) {
        errorText = e.Message;
    } catch (...) {
        errorText = _("Unknown exception while creating macro");
    }
    if (!errorText.empty()) {
        Glib::ustring txt = _("Couldn't create macro:\n") + errorText;
        Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
        msg.run();
    }
}

static Glib::ustring indexToAccKey(uint index) {
    if (index >= 12) return "";
    return "F" + ToString(index+1);
}

static int daysAgo(const tm& t) {
    time_t now;
    time(&now);
    tm* pNow = localtime(&now);
    if (!pNow) return 0;
    if (pNow->tm_year == t.tm_year &&
        pNow->tm_mon  == t.tm_mon &&
        pNow->tm_mday == t.tm_mday) return 0;
    time_t past = mktime((tm*)&t);
    return ceil(difftime(now, past) / 60.0 / 60.0 / 24.0);
}

static Glib::ustring humanShortStr(const tm& t) {
    int iDaysAgo = daysAgo(t);
    char buf[70];
    if (iDaysAgo == 0) {
        // C-Time specification for a time somewhere today (see 'man strftime()').
        if (strftime(buf, sizeof buf, _("%R"), &t))
            return buf;
    } else if (iDaysAgo == 1) {
        // C-Time specification for a time somewhere yesterday (see 'man strftime()').
        if (strftime(buf, sizeof buf, _("Yesterday %R"), &t))
            return buf;
    } else if (iDaysAgo == 2) {
        // C-Time specification for a time somewhere 2 days ago (see 'man strftime()').
        if (strftime(buf, sizeof buf, _("2 days ago %R"), &t))
            return buf;
    } else {
        // C-Time specification for a time far more than 2 days ago (see 'man strftime()').
        if (strftime(buf, sizeof buf, "%d %b %Y", &t))
            return buf;
    }
    return "";
}

void MacrosSetup::reloadTreeView() {
    m_ignoreTreeViewValueChange = true;

    m_treeStoreMacros->clear();

    for (int iMacro = 0; iMacro < m_macros.size(); ++iMacro) {
        const Serialization::Archive& macro = m_macros[iMacro];

        Gtk::TreeModel::iterator iter = m_treeStoreMacros->append();
        Gtk::TreeModel::Row row = *iter;
        row[m_treeModelMacros.m_col_key] = indexToAccKey(iMacro);
        row[m_treeModelMacros.m_col_name] = macro.name().empty() ? _("Unnamed Macro") : gig_to_utf8(macro.name());
        row[m_treeModelMacros.m_col_comment] = macro.comment().empty() ? _("No comment assigned yet.") : gig_to_utf8(macro.comment());
        row[m_treeModelMacros.m_col_created] = humanShortStr(macro.dateTimeCreated());
        row[m_treeModelMacros.m_col_modified] = humanShortStr(macro.dateTimeModified());
        row[m_treeModelMacros.m_col_index] = iMacro;
    }

    m_treeViewMacros.expand_all();

    updateStatus();

    m_ignoreTreeViewValueChange = false;
}

void MacrosSetup::onTreeViewSelectionChanged() {
    std::vector<Gtk::TreeModel::Path> v = m_treeViewMacros.get_selection()->get_selected_rows();
    const bool bValidSelection = !v.empty();
    m_deleteButton.set_sensitive(bValidSelection);
    m_inverseDeleteButton.set_sensitive(bValidSelection);
}

// Cmd key on Mac, Ctrl key on all other OSs
static const guint primaryKeyL =
    #if defined(__APPLE__)
    GDK_KEY_Meta_L;
    #else
    GDK_KEY_Control_L;
    #endif

static const guint primaryKeyR =
    #if defined(__APPLE__)
    GDK_KEY_Meta_R;
    #else
    GDK_KEY_Control_R;
    #endif

bool MacrosSetup::onKeyPressed(GdkEventKey* key) {
    //printf("key down 0x%x\n", key->keyval);
    if (key->keyval == GDK_KEY_Alt_L || key->keyval == GDK_KEY_Alt_R)
        m_altKeyDown = true;
    if (key->keyval == primaryKeyL || key->keyval == primaryKeyR)
        m_primaryKeyDown = true;
    return false;
}

bool MacrosSetup::onKeyReleased(GdkEventKey* key) {
    //printf("key up 0x%x\n", key->keyval);
    if (key->keyval == GDK_KEY_Alt_L || key->keyval == GDK_KEY_Alt_R)
        m_altKeyDown = false;
    if (key->keyval == primaryKeyL || key->keyval == primaryKeyR)
        m_primaryKeyDown = false;
    if (m_primaryKeyDown && key->keyval == GDK_KEY_b)
        onButtonAddFromClipboard();
    if (m_primaryKeyDown && key->keyval == GDK_KEY_s)
        onButtonAddFromSelection();
    return false;
}

void MacrosSetup::onMacroTreeViewKeyRelease(GdkEventKey* key) {
    if (key->keyval == GDK_KEY_BackSpace || key->keyval == GDK_KEY_Delete) {
        if (m_altKeyDown)
            inverseDeleteSelectedRows();
        else if (m_primaryKeyDown)
            deleteSelectedRows();
    }
}

void MacrosSetup::onMacroTreeViewRowValueChanged(const Gtk::TreeModel::Path& path,
                                                 const Gtk::TreeModel::iterator& iter)
{
    if (m_ignoreTreeViewValueChange) return;
    if (!iter) return;
    Gtk::TreeModel::Row row = *iter;
    Glib::ustring name = row[m_treeModelMacros.m_col_name];
    int index = row[m_treeModelMacros.m_col_index];
    m_macros[index].setName(name);
    //reloadTreeView();
    m_modified = true;
    updateStatus();
}

void MacrosSetup::deleteSelectedRows() {
    Glib::RefPtr<Gtk::TreeSelection> sel = m_treeViewMacros.get_selection();
    std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
    deleteRows(rows);
}

void MacrosSetup::deleteRows(const std::vector<Gtk::TreeModel::Path>& rows) {
    m_modified = !rows.empty();
    std::set<int> macros;
    for (int r = rows.size() - 1; r >= 0; --r) {
        Gtk::TreeModel::iterator it = m_treeStoreMacros->get_iter(rows[r]);
        if (!it) continue;
        Gtk::TreeModel::Row row = *it;
        macros.insert(
            row[m_treeModelMacros.m_col_index]
        );
    }
    for (std::set<int>::const_reverse_iterator it = macros.rbegin();
         it != macros.rend(); ++it)
    {
        m_macros.erase(m_macros.begin() + *it);
    }
    reloadTreeView();
}

static bool _onEachTreeRow(const Gtk::TreeModel::Path& input, std::vector<Gtk::TreeModel::Path>* output) {
    output->push_back(input);
    return false; // continue walking the tree
}

void MacrosSetup::inverseDeleteSelectedRows() {
    // get all rows of tree view
    std::vector<Gtk::TreeModel::Path> rows;
    m_treeViewMacros.get_model()->foreach_path(
        sigc::bind(
            sigc::ptr_fun(&_onEachTreeRow),
            &rows
        )
    );

    // erase all entries from "rows" which are currently selected
    std::vector<Gtk::TreeModel::Path> vSelected = m_treeViewMacros.get_selection()->get_selected_rows();
    for (int i = rows.size() - 1; i >= 0; --i) {
        bool bIsSelected = std::find(vSelected.begin(), vSelected.end(),
                                     rows[i]) != vSelected.end();
        if (bIsSelected)
            rows.erase(rows.begin() + i);
    }

    // delete those 'inverse' selected rows
    deleteRows(rows);
}

void MacrosSetup::updateStatus() {
    m_addFromClipboardButton.set_sensitive(
        m_clipboardContent && m_clipboardContent->rootObject()
    );
    m_addFromSelectionButton.set_sensitive(m_selectedDimRgn);
    m_applyButton.set_sensitive(isModified());
    updateStatusBar();
}

void MacrosSetup::updateStatusBar() {
    // update status text
    std::string txt;
    m_statusLabel.set_markup(txt);
}

sigc::signal<void, const std::vector<Serialization::Archive>& >& MacrosSetup::signal_macros_changed()
{
    return m_macros_changed;
}

bool MacrosSetup::onWindowDelete(GdkEventAny* e) {
    //printf("onWindowDelete\n");

    if (!isModified()) return false; // propagate event further (which will close this window)

    //gchar* msg = g_strdup_printf(_("Apply changes to macro \"%s\" before closing?"),
    //                             m_macroOriginal->Name.c_str());
    gchar* msg = g_strdup_printf(_("Apply changes to macro list before closing?"));
    Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
    g_free(msg);
    dialog.set_secondary_text(_("If you close without applying, your changes will be lost."));
    dialog.add_button(_("Close _Without Applying"), Gtk::RESPONSE_NO);
    dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
    dialog.add_button(_("_Apply"), Gtk::RESPONSE_YES);
    dialog.set_default_response(Gtk::RESPONSE_YES);
    int response = dialog.run();
    dialog.hide();

    // user decided to close this window without saving
    if (response == Gtk::RESPONSE_NO)
        return false; // propagate event further (which will close this window)

    // user cancelled dialog, thus don't close this window
    if (response == Gtk::RESPONSE_CANCEL) {
        show();
        return true; // drop event (prevents closing this window)
    }

    // user wants to apply the changes, afterwards close window
    if (response == Gtk::RESPONSE_YES) {
        onButtonApply();
        return false; // propagate event further (which will close this window)
    }

    // should never ever make it to this point actually
    return false;
}

bool MacrosSetup::isModified() const {
    if (m_modified) return true;
    bool bModified = false;
    for (int i = 0; i < m_macros.size(); ++i) {
        if (m_macros[i].isModified()) {
            bModified = true;
            break;
        }
    }
    return bModified;
}

void MacrosSetup::onButtonCancel() {
    bool dropEvent = onWindowDelete(NULL);
    if (dropEvent) return;
    hide();
}

void MacrosSetup::onButtonApply() {
    std::string errorText;
    try {
        for (int i = 0; i < m_macros.size(); ++i) {
            if (!m_macros[i].isModified()) continue;
            // enforce re-encoding the abstract object model and resetting the
            // 'modified' state
            m_macros[i].rawData();
        }
        m_modified = false;
    } catch (Serialization::Exception e) {
        errorText = e.Message;
    } catch (...) {
        errorText = _("Unknown exception while applying macro changes");
    }
    if (!errorText.empty()) {
        Glib::ustring txt = _("Couldn't apply macro changes:\n") + errorText;
        Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
        msg.run();
    } else {
        // update MainWindow with edited list of macros
        m_macros_changed.emit(m_macros);
    }
    updateStatus();
}

void MacrosSetup::onWindowHide() {
    delete this; // this is the end, my friend
}
1	/*
2	Copyright (c) MMXVII Christian Schoenebeck
3
4	This file is part of "gigedit" and released under the terms of the
5	GNU General Public License version 2.
6	*/
7
8	#include "MacrosSetup.h"
9	#include "global.h"
10	#include <assert.h>
11	#include <set>
12	#include <math.h>
13	#include <gtkmm/stock.h>
14
15	MacrosSetup::MacrosSetup() :
16	m_modified(false),
17	m_clipboardContent(NULL),
18	m_addFromClipboardButton(" " + Glib::ustring(_("From Clipboard")) + " " + UNICODE_PRIMARY_KEY_SYMBOL + "B"),
19	m_addFromSelectionButton(" " + Glib::ustring(_("From Selection")) + " " + UNICODE_PRIMARY_KEY_SYMBOL + "S"),
20	m_statusLabel("", Gtk::ALIGN_START),
21	m_deleteButton(Glib::ustring(_("Delete")) + " " + UNICODE_PRIMARY_KEY_SYMBOL + UNICODE_ERASE_KEY_SYMBOL),
22	m_inverseDeleteButton(Glib::ustring(_("Inverse Delete")) + " " + UNICODE_ALT_KEY_SYMBOL + UNICODE_ERASE_KEY_SYMBOL),
23	m_applyButton(_("_Apply"), true),
24	m_cancelButton(_("_Cancel"), true),
25	m_altKeyDown(false),
26	m_primaryKeyDown(false)
27	{
28	add(m_vbox);
29
30	set_title(_("Setup Macros"));
31
32	set_default_size(800, 600);
33
34	m_addFromClipboardButton.set_image(
35	*new Gtk::Image(Gtk::Stock::ADD, Gtk::ICON_SIZE_BUTTON)
36	);
37	m_addFromSelectionButton.set_image(
38	*new Gtk::Image(Gtk::Stock::ADD, Gtk::ICON_SIZE_BUTTON)
39	);
40	m_addFromClipboardButton.set_tooltip_text(_("Create a new macro from the content currently available on the clipboard."));
41	m_addFromSelectionButton.set_tooltip_text(_("Create a new macro from the currently selected dimension region's parameters currently shown on the main window."));
42	m_addHBox.pack_start(m_addFromClipboardButton);
43	m_addHBox.pack_start(m_addFromSelectionButton);
44	m_vbox.pack_start(m_addHBox, Gtk::PACK_SHRINK);
45
46	// create Macro list treeview (including its data model)
47	m_treeStoreMacros = MacroListTreeStore::create(m_treeModelMacros);
48	m_treeViewMacros.set_model(m_treeStoreMacros);
49	m_treeViewMacros.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
50	//m_treeViewMacro.set_tooltip_text(_(""));
51	m_treeViewMacros.append_column(_("Key"), m_treeModelMacros.m_col_key);
52	m_treeViewMacros.append_column_editable(_("Name"), m_treeModelMacros.m_col_name);
53	m_treeViewMacros.append_column(_("Created"), m_treeModelMacros.m_col_created);
54	m_treeViewMacros.append_column(_("Modified"), m_treeModelMacros.m_col_modified);
55	m_treeViewMacros.set_tooltip_column(m_treeModelMacros.m_col_comment.index());
56	// make all rows gray text, except of "Name" column
57	for (int i = 0; i <= 3; ++i) {
58	if (i == m_treeModelMacros.m_col_name.index())
59	continue;
60	Gtk::TreeViewColumn* column = m_treeViewMacros.get_column(i);
61	Gtk::CellRendererText* cellrenderer =
62	dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
63	cellrenderer->property_foreground().set_value("#bababa");
64	}
65	/*{
66	Gtk::TreeViewColumn* column = m_treeViewMacro.get_column(0);
67	Gtk::CellRendererText* cellrenderer =
68	dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
69	column->add_attribute(
70	cellrenderer->property_foreground(), m_SamplesModel.m_color
71	);
72	}*/
73	/*{
74	Gtk::TreeViewColumn* column = m_treeViewMacro.get_column(1);
75	Gtk::CellRendererText* cellrenderer =
76	dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
77	column->add_attribute(
78	cellrenderer->property_foreground(), m_SamplesModel.m_color
79	);
80	}*/
81	m_treeViewMacros.set_headers_visible(true);
82	m_treeViewMacros.get_selection()->signal_changed().connect(
83	sigc::mem_fun(*this, &MacrosSetup::onTreeViewSelectionChanged)
84	);
85	m_treeViewMacros.signal_key_release_event().connect_notify(
86	sigc::mem_fun(*this, &MacrosSetup::onMacroTreeViewKeyRelease)
87	);
88	m_treeStoreMacros->signal_row_changed().connect(
89	sigc::mem_fun(*this, &MacrosSetup::onMacroTreeViewRowValueChanged)
90	);
91	m_ignoreTreeViewValueChange = false;
92
93	m_scrolledWindow.add(m_treeViewMacros);
94	m_scrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
95	m_vbox.pack_start(m_scrolledWindow);
96
97	m_buttonBoxL.set_layout(Gtk::BUTTONBOX_START);
98	m_buttonBoxL.pack_start(m_deleteButton);
99	m_buttonBoxL.pack_start(m_inverseDeleteButton);
100	m_deleteButton.set_sensitive(false);
101	m_inverseDeleteButton.set_sensitive(false);
102
103	m_buttonBox.set_layout(Gtk::BUTTONBOX_END);
104	m_buttonBox.pack_start(m_applyButton);
105	m_buttonBox.pack_start(m_cancelButton);
106	m_applyButton.set_can_default();
107	m_applyButton.set_sensitive(false);
108	m_applyButton.grab_focus();
109
110	#if GTKMM_MAJOR_VERSION >= 3
111	m_statusLabel.set_margin_left(6);
112	m_statusLabel.set_margin_right(6);
113	#else
114	m_statusHBox.set_spacing(6);
115	#endif
116
117	m_statusHBox.pack_start(m_statusLabel);
118	m_statusHBox.show_all_children();
119
120	m_footerHBox.pack_start(m_buttonBoxL, Gtk::PACK_SHRINK);
121	m_footerHBox.pack_start(m_statusHBox);
122	m_footerHBox.pack_start(m_buttonBox, Gtk::PACK_SHRINK);
123
124	m_vbox.pack_start(m_footerHBox, Gtk::PACK_SHRINK);
125
126	m_addFromClipboardButton.signal_clicked().connect(
127	sigc::mem_fun(*this, &MacrosSetup::onButtonAddFromClipboard)
128	);
129
130	m_addFromSelectionButton.signal_clicked().connect(
131	sigc::mem_fun(*this, &MacrosSetup::onButtonAddFromSelection)
132	);
133
134	m_applyButton.signal_clicked().connect(
135	sigc::mem_fun(*this, &MacrosSetup::onButtonApply)
136	);
137
138	m_cancelButton.signal_clicked().connect(
139	sigc::mem_fun(*this, &MacrosSetup::onButtonCancel)
140	);
141
142	m_deleteButton.signal_clicked().connect(
143	sigc::mem_fun(*this, &MacrosSetup::deleteSelectedRows)
144	);
145
146	m_inverseDeleteButton.signal_clicked().connect(
147	sigc::mem_fun(*this, &MacrosSetup::inverseDeleteSelectedRows)
148	);
149
150	signal_hide().connect(
151	sigc::mem_fun(*this, &MacrosSetup::onWindowHide)
152	);
153
154	signal_delete_event().connect(
155	sigc::mem_fun(*this, &MacrosSetup::onWindowDelete)
156	);
157
158	signal_key_press_event().connect(
159	sigc::mem_fun(*this, &MacrosSetup::onKeyPressed)
160	);
161	signal_key_release_event().connect(
162	sigc::mem_fun(*this, &MacrosSetup::onKeyReleased)
163	);
164
165	show_all_children();
166	updateStatus();
167	}
168
169	MacrosSetup::~MacrosSetup() {
170	printf("MacrosSetup destruct\n");
171	}
172
173	void MacrosSetup::setMacros(const std::vector<Serialization::Archive>& macros,
174	Serialization::Archive* pClipboardContent,
175	gig::DimensionRegion* pSelectedDimRgn)
176	{
177	// copy for non-destructive editing
178	m_macros = macros;
179
180	m_clipboardContent = pClipboardContent;
181	m_selectedDimRgn = pSelectedDimRgn;
182
183	reloadTreeView();
184	}
185
186	void MacrosSetup::onButtonAddFromClipboard() {
187	printf("+fromClipboard\n");
188	if (!m_clipboardContent) return;
189	if (!m_clipboardContent->rootObject()) return;
190	m_macros.push_back(*m_clipboardContent);
191	m_modified = true;
192	reloadTreeView();
193	}
194
195	void MacrosSetup::onButtonAddFromSelection() {
196	printf("+fromSelection\n");
197	if (!m_selectedDimRgn) return;
198	std::string errorText;
199	try {
200	Serialization::Archive archive;
201	archive.serialize(m_selectedDimRgn);
202	//archive.setName("Unnamed Macro");
203	m_macros.push_back(archive);
204	m_modified = true;
205	reloadTreeView();
206	} catch (Serialization::Exception e) {
207	errorText = e.Message;
208	} catch (...) {
209	errorText = _("Unknown exception while creating macro");
210	}
211	if (!errorText.empty()) {
212	Glib::ustring txt = _("Couldn't create macro:\n") + errorText;
213	Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
214	msg.run();
215	}
216	}
217
218	static Glib::ustring indexToAccKey(uint index) {
219	if (index >= 12) return "";
220	return "F" + ToString(index+1);
221	}
222
223	static int daysAgo(const tm& t) {
224	time_t now;
225	time(&now);
226	tm* pNow = localtime(&now);
227	if (!pNow) return 0;
228	if (pNow->tm_year == t.tm_year &&
229	pNow->tm_mon == t.tm_mon &&
230	pNow->tm_mday == t.tm_mday) return 0;
231	time_t past = mktime((tm*)&t);
232	return ceil(difftime(now, past) / 60.0 / 60.0 / 24.0);
233	}
234
235	static Glib::ustring humanShortStr(const tm& t) {
236	int iDaysAgo = daysAgo(t);
237	char buf[70];
238	if (iDaysAgo == 0) {
239	// C-Time specification for a time somewhere today (see 'man strftime()').
240	if (strftime(buf, sizeof buf, _("%R"), &t))
241	return buf;
242	} else if (iDaysAgo == 1) {
243	// C-Time specification for a time somewhere yesterday (see 'man strftime()').
244	if (strftime(buf, sizeof buf, _("Yesterday %R"), &t))
245	return buf;
246	} else if (iDaysAgo == 2) {
247	// C-Time specification for a time somewhere 2 days ago (see 'man strftime()').
248	if (strftime(buf, sizeof buf, _("2 days ago %R"), &t))
249	return buf;
250	} else {
251	// C-Time specification for a time far more than 2 days ago (see 'man strftime()').
252	if (strftime(buf, sizeof buf, "%d %b %Y", &t))
253	return buf;
254	}
255	return "";
256	}
257
258	void MacrosSetup::reloadTreeView() {
259	m_ignoreTreeViewValueChange = true;
260
261	m_treeStoreMacros->clear();
262
263	for (int iMacro = 0; iMacro < m_macros.size(); ++iMacro) {
264	const Serialization::Archive& macro = m_macros[iMacro];
265
266	Gtk::TreeModel::iterator iter = m_treeStoreMacros->append();
267	Gtk::TreeModel::Row row = *iter;
268	row[m_treeModelMacros.m_col_key] = indexToAccKey(iMacro);
269	row[m_treeModelMacros.m_col_name] = macro.name().empty() ? _("Unnamed Macro") : gig_to_utf8(macro.name());
270	row[m_treeModelMacros.m_col_comment] = macro.comment().empty() ? _("No comment assigned yet.") : gig_to_utf8(macro.comment());
271	row[m_treeModelMacros.m_col_created] = humanShortStr(macro.dateTimeCreated());
272	row[m_treeModelMacros.m_col_modified] = humanShortStr(macro.dateTimeModified());
273	row[m_treeModelMacros.m_col_index] = iMacro;
274	}
275
276	m_treeViewMacros.expand_all();
277
278	updateStatus();
279
280	m_ignoreTreeViewValueChange = false;
281	}
282
283	void MacrosSetup::onTreeViewSelectionChanged() {
284	std::vector<Gtk::TreeModel::Path> v = m_treeViewMacros.get_selection()->get_selected_rows();
285	const bool bValidSelection = !v.empty();
286	m_deleteButton.set_sensitive(bValidSelection);
287	m_inverseDeleteButton.set_sensitive(bValidSelection);
288	}
289
290	// Cmd key on Mac, Ctrl key on all other OSs
291	static const guint primaryKeyL =
292	#if defined(__APPLE__)
293	GDK_KEY_Meta_L;
294	#else
295	GDK_KEY_Control_L;
296	#endif
297
298	static const guint primaryKeyR =
299	#if defined(__APPLE__)
300	GDK_KEY_Meta_R;
301	#else
302	GDK_KEY_Control_R;
303	#endif
304
305	bool MacrosSetup::onKeyPressed(GdkEventKey* key) {
306	//printf("key down 0x%x\n", key->keyval);
307	if (key->keyval == GDK_KEY_Alt_L \|\| key->keyval == GDK_KEY_Alt_R)
308	m_altKeyDown = true;
309	if (key->keyval == primaryKeyL \|\| key->keyval == primaryKeyR)
310	m_primaryKeyDown = true;
311	return false;
312	}
313
314	bool MacrosSetup::onKeyReleased(GdkEventKey* key) {
315	//printf("key up 0x%x\n", key->keyval);
316	if (key->keyval == GDK_KEY_Alt_L \|\| key->keyval == GDK_KEY_Alt_R)
317	m_altKeyDown = false;
318	if (key->keyval == primaryKeyL \|\| key->keyval == primaryKeyR)
319	m_primaryKeyDown = false;
320	if (m_primaryKeyDown && key->keyval == GDK_KEY_b)
321	onButtonAddFromClipboard();
322	if (m_primaryKeyDown && key->keyval == GDK_KEY_s)
323	onButtonAddFromSelection();
324	return false;
325	}
326
327	void MacrosSetup::onMacroTreeViewKeyRelease(GdkEventKey* key) {
328	if (key->keyval == GDK_KEY_BackSpace \|\| key->keyval == GDK_KEY_Delete) {
329	if (m_altKeyDown)
330	inverseDeleteSelectedRows();
331	else if (m_primaryKeyDown)
332	deleteSelectedRows();
333	}
334	}
335
336	void MacrosSetup::onMacroTreeViewRowValueChanged(const Gtk::TreeModel::Path& path,
337	const Gtk::TreeModel::iterator& iter)
338	{
339	if (m_ignoreTreeViewValueChange) return;
340	if (!iter) return;
341	Gtk::TreeModel::Row row = *iter;
342	Glib::ustring name = row[m_treeModelMacros.m_col_name];
343	int index = row[m_treeModelMacros.m_col_index];
344	m_macros[index].setName(name);
345	//reloadTreeView();
346	m_modified = true;
347	updateStatus();
348	}
349
350	void MacrosSetup::deleteSelectedRows() {
351	Glib::RefPtr<Gtk::TreeSelection> sel = m_treeViewMacros.get_selection();
352	std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
353	deleteRows(rows);
354	}
355
356	void MacrosSetup::deleteRows(const std::vector<Gtk::TreeModel::Path>& rows) {
357	m_modified = !rows.empty();
358	std::set<int> macros;
359	for (int r = rows.size() - 1; r >= 0; --r) {
360	Gtk::TreeModel::iterator it = m_treeStoreMacros->get_iter(rows[r]);
361	if (!it) continue;
362	Gtk::TreeModel::Row row = *it;
363	macros.insert(
364	row[m_treeModelMacros.m_col_index]
365	);
366	}
367	for (std::set<int>::const_reverse_iterator it = macros.rbegin();
368	it != macros.rend(); ++it)
369	{
370	m_macros.erase(m_macros.begin() + *it);
371	}
372	reloadTreeView();
373	}
374
375	static bool _onEachTreeRow(const Gtk::TreeModel::Path& input, std::vector<Gtk::TreeModel::Path>* output) {
376	output->push_back(input);
377	return false; // continue walking the tree
378	}
379
380	void MacrosSetup::inverseDeleteSelectedRows() {
381	// get all rows of tree view
382	std::vector<Gtk::TreeModel::Path> rows;
383	m_treeViewMacros.get_model()->foreach_path(
384	sigc::bind(
385	sigc::ptr_fun(&_onEachTreeRow),
386	&rows
387	)
388	);
389
390	// erase all entries from "rows" which are currently selected
391	std::vector<Gtk::TreeModel::Path> vSelected = m_treeViewMacros.get_selection()->get_selected_rows();
392	for (int i = rows.size() - 1; i >= 0; --i) {
393	bool bIsSelected = std::find(vSelected.begin(), vSelected.end(),
394	rows[i]) != vSelected.end();
395	if (bIsSelected)
396	rows.erase(rows.begin() + i);
397	}
398
399	// delete those 'inverse' selected rows
400	deleteRows(rows);
401	}
402
403	void MacrosSetup::updateStatus() {
404	m_addFromClipboardButton.set_sensitive(
405	m_clipboardContent && m_clipboardContent->rootObject()
406	);
407	m_addFromSelectionButton.set_sensitive(m_selectedDimRgn);
408	m_applyButton.set_sensitive(isModified());
409	updateStatusBar();
410	}
411
412	void MacrosSetup::updateStatusBar() {
413	// update status text
414	std::string txt;
415	m_statusLabel.set_markup(txt);
416	}
417
418	sigc::signal<void, const std::vector<Serialization::Archive>& >& MacrosSetup::signal_macros_changed()
419	{
420	return m_macros_changed;
421	}
422
423	bool MacrosSetup::onWindowDelete(GdkEventAny* e) {
424	//printf("onWindowDelete\n");
425
426	if (!isModified()) return false; // propagate event further (which will close this window)
427
428	//gchar* msg = g_strdup_printf(_("Apply changes to macro \"%s\" before closing?"),
429	// m_macroOriginal->Name.c_str());
430	gchar* msg = g_strdup_printf(_("Apply changes to macro list before closing?"));
431	Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
432	g_free(msg);
433	dialog.set_secondary_text(_("If you close without applying, your changes will be lost."));
434	dialog.add_button(_("Close _Without Applying"), Gtk::RESPONSE_NO);
435	dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
436	dialog.add_button(_("_Apply"), Gtk::RESPONSE_YES);
437	dialog.set_default_response(Gtk::RESPONSE_YES);
438	int response = dialog.run();
439	dialog.hide();
440
441	// user decided to close this window without saving
442	if (response == Gtk::RESPONSE_NO)
443	return false; // propagate event further (which will close this window)
444
445	// user cancelled dialog, thus don't close this window
446	if (response == Gtk::RESPONSE_CANCEL) {
447	show();
448	return true; // drop event (prevents closing this window)
449	}
450
451	// user wants to apply the changes, afterwards close window
452	if (response == Gtk::RESPONSE_YES) {
453	onButtonApply();
454	return false; // propagate event further (which will close this window)
455	}
456
457	// should never ever make it to this point actually
458	return false;
459	}
460
461	bool MacrosSetup::isModified() const {
462	if (m_modified) return true;
463	bool bModified = false;
464	for (int i = 0; i < m_macros.size(); ++i) {
465	if (m_macros[i].isModified()) {
466	bModified = true;
467	break;
468	}
469	}
470	return bModified;
471	}
472
473	void MacrosSetup::onButtonCancel() {
474	bool dropEvent = onWindowDelete(NULL);
475	if (dropEvent) return;
476	hide();
477	}
478
479	void MacrosSetup::onButtonApply() {
480	std::string errorText;
481	try {
482	for (int i = 0; i < m_macros.size(); ++i) {
483	if (!m_macros[i].isModified()) continue;
484	// enforce re-encoding the abstract object model and resetting the
485	// 'modified' state
486	m_macros[i].rawData();
487	}
488	m_modified = false;
489	} catch (Serialization::Exception e) {
490	errorText = e.Message;
491	} catch (...) {
492	errorText = _("Unknown exception while applying macro changes");
493	}
494	if (!errorText.empty()) {
495	Glib::ustring txt = _("Couldn't apply macro changes:\n") + errorText;
496	Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
497	msg.run();
498	} else {
499	// update MainWindow with edited list of macros
500	m_macros_changed.emit(m_macros);
501	}
502	updateStatus();
503	}
504
505	void MacrosSetup::onWindowHide() {
506	delete this; // this is the end, my friend
507	}