Move code related to SwatchesPanel where it belongs

panel.cpp contains a lot of code which is actually used to build the
SwatchesPanel. Move it to swatches.cpp.

This is mostly just a cut-n-paste, plus some includes cleanup.

1 files changed, 434 insertions, 4 deletions

diff --git a/src/ui/dialog/swatches.cpp b/src/ui/dialog/swatches.cpp
index 684074150..c6ab06507 100644
--- a/src/ui/dialog/swatches.cpp
+++ b/src/ui/dialog/swatches.cpp
@@ -21,6 +21,11 @@
 #include "swatches.h"
 #include <gtkmm/radiomenuitem.h>
 
+#include <gtkmm/menu.h>
+#include <gtkmm/checkmenuitem.h>
+#include <gtkmm/radiomenuitem.h>
+#include <gtkmm/separatormenuitem.h>
+
 #include <glibmm/i18n.h>
 #include <glibmm/main.h>
 #include <glibmm/timer.h>
@@ -51,6 +56,14 @@
 #include "gradient-chemistry.h"
 #include "helper/action.h"
 
+static const int PANEL_SETTING_SIZE = 0;
+static const int PANEL_SETTING_MODE = 1;
+static const int PANEL_SETTING_SHAPE = 2;
+static const int PANEL_SETTING_WRAP = 3;
+static const int PANEL_SETTING_BORDER = 4;
+static const int PANEL_SETTING_NEXTFREE = 5;
+
+
 namespace Inkscape {
 namespace UI {
 namespace Dialogs {
@@ -547,7 +560,10 @@ SwatchesPanel& SwatchesPanel::getInstance()
  * Constructor
  */
 SwatchesPanel::SwatchesPanel(gchar const* prefsPath) :
-    Inkscape::UI::Widget::Panel(prefsPath, SP_VERB_DIALOG_SWATCHES, true),
+    Inkscape::UI::Widget::Panel(prefsPath, SP_VERB_DIALOG_SWATCHES),
+    _temp_arrow(),
+    _menu(0),
+    _fillable(0),
     _holder(0),
     _clear(0),
     _remove(0),
@@ -555,6 +571,8 @@ SwatchesPanel::SwatchesPanel(gchar const* prefsPath) :
     _currentDesktop(0),
     _currentDocument(0)
 {
+    init();
+
     set_name( "SwatchesPanel" );
     Gtk::RadioMenuItem* hotItem = 0;
     _holder = new PreviewHolder();
@@ -627,7 +645,7 @@ SwatchesPanel::SwatchesPanel(gchar const* prefsPath) :
         }
     }
 
-    _getContents()->pack_start(*_holder, Gtk::PACK_EXPAND_WIDGET);
+    _boxy.pack_start(*_holder, Gtk::PACK_EXPAND_WIDGET);
     _setTargetFillable(_holder);
 
     show_all_children();
@@ -654,13 +672,256 @@ SwatchesPanel::~SwatchesPanel()
     if ( _holder ) {
         delete _holder;
     }
+
+    delete _menu;
+}
+
+void SwatchesPanel::_popper(GdkEventButton* event)
+{
+    if ( (event->type == GDK_BUTTON_PRESS) && (event->button == 3 || event->button == 1) ) {
+        if (_menu) {
+#if GTKMM_CHECK_VERSION(3,22,0)
+            _menu->popup_at_pointer(reinterpret_cast<GdkEvent *>(event));
+#else
+             _menu->popup(event->button, event->time);
+#endif
+        }
+    }
+}
+
+void SwatchesPanel::init()
+{
+    _anchor = SP_ANCHOR_CENTER;
+
+    guint panel_size = 0, panel_mode = 0, panel_ratio = 100, panel_border = 0;
+    bool panel_wrap = 0;
+    if (!_prefs_path.empty()) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        panel_wrap = prefs->getBool(_prefs_path + "/panel_wrap");
+        panel_size = prefs->getIntLimited(_prefs_path + "/panel_size", 1, 0, PREVIEW_SIZE_HUGE);
+        panel_mode = prefs->getIntLimited(_prefs_path + "/panel_mode", 1, 0, 10);
+        panel_ratio = prefs->getIntLimited(_prefs_path + "/panel_ratio", 100, 0, 500 );
+        panel_border = prefs->getIntLimited(_prefs_path + "/panel_border", BORDER_NONE, 0, 2 );
+    }
+
+    _menu = new Gtk::Menu();
+
+    {
+        Gtk::RadioMenuItem::Group group;
+        Glib::ustring one_label(_("List"));
+        Glib::ustring two_label(_("Grid"));
+        Gtk::RadioMenuItem *one = Gtk::manage(new Gtk::RadioMenuItem(group, one_label));
+        Gtk::RadioMenuItem *two = Gtk::manage(new Gtk::RadioMenuItem(group, two_label));
+
+        if (panel_mode == 0) {
+            one->set_active(true);
+        } else if (panel_mode == 1) {
+            two->set_active(true);
+        }
+
+        _menu->append(*one);
+        _non_horizontal.push_back(one);
+        _menu->append(*two);
+        _non_horizontal.push_back(two);
+        Gtk::MenuItem* sep = Gtk::manage(new Gtk::SeparatorMenuItem());
+        _menu->append(*sep);
+        _non_horizontal.push_back(sep);
+        one->signal_activate().connect(sigc::bind<int, int>(sigc::mem_fun(*this, &SwatchesPanel::_bounceCall), PANEL_SETTING_MODE, 0));
+        two->signal_activate().connect(sigc::bind<int, int>(sigc::mem_fun(*this, &SwatchesPanel::_bounceCall), PANEL_SETTING_MODE, 1));
+    }
+
+    {
+        Glib::ustring heightItemLabel(C_("Swatches", "Size"));
+
+        //TRANSLATORS: Indicates size of colour swatches
+        const gchar *heightLabels[] = {
+            NC_("Swatches height", "Tiny"),
+            NC_("Swatches height", "Small"),
+            NC_("Swatches height", "Medium"),
+            NC_("Swatches height", "Large"),
+            NC_("Swatches height", "Huge")
+        };
+
+        Gtk::MenuItem *sizeItem = Gtk::manage(new Gtk::MenuItem(heightItemLabel));
+        Gtk::Menu *sizeMenu = Gtk::manage(new Gtk::Menu());
+        sizeItem->set_submenu(*sizeMenu);
+
+        Gtk::RadioMenuItem::Group heightGroup;
+        for (unsigned int i = 0; i < G_N_ELEMENTS(heightLabels); i++) {
+            Glib::ustring _label(g_dpgettext2(NULL, "Swatches height", heightLabels[i]));
+            Gtk::RadioMenuItem* _item = Gtk::manage(new Gtk::RadioMenuItem(heightGroup, _label));
+            sizeMenu->append(*_item);
+            if (i == panel_size) {
+                _item->set_active(true);
+            }
+            _item->signal_activate().connect(sigc::bind<int, int>(sigc::mem_fun(*this, &SwatchesPanel::_bounceCall), PANEL_SETTING_SIZE, i));
+       }
+
+       _menu->append(*sizeItem);
+    }
+
+    {
+        Glib::ustring widthItemLabel(C_("Swatches", "Width"));
+
+        //TRANSLATORS: Indicates width of colour swatches
+        const gchar *widthLabels[] = {
+            NC_("Swatches width", "Narrower"),
+            NC_("Swatches width", "Narrow"),
+            NC_("Swatches width", "Medium"),
+            NC_("Swatches width", "Wide"),
+            NC_("Swatches width", "Wider")
+        };
+
+        Gtk::MenuItem *item = Gtk::manage( new Gtk::MenuItem(widthItemLabel));
+        Gtk::Menu *type_menu = Gtk::manage(new Gtk::Menu());
+        item->set_submenu(*type_menu);
+        _menu->append(*item);
+
+        Gtk::RadioMenuItem::Group widthGroup;
+
+        guint values[] = {0, 25, 50, 100, 200, 400};
+        guint hot_index = 3;
+        for ( guint i = 0; i < G_N_ELEMENTS(widthLabels); ++i ) {
+            // Assume all values are in increasing order
+            if ( values[i] <= panel_ratio ) {
+                hot_index = i;
+            }
+        }
+        for ( guint i = 0; i < G_N_ELEMENTS(widthLabels); ++i ) {
+            Glib::ustring _label(g_dpgettext2(NULL, "Swatches width", widthLabels[i]));
+            Gtk::RadioMenuItem *_item = Gtk::manage(new Gtk::RadioMenuItem(widthGroup, _label));
+            type_menu->append(*_item);
+            if ( i <= hot_index ) {
+                _item->set_active(true);
+            }
+            _item->signal_activate().connect(sigc::bind<int, int>(sigc::mem_fun(*this, &SwatchesPanel::_bounceCall), PANEL_SETTING_SHAPE, values[i]));
+        }
+    }
+
+    {
+        Glib::ustring widthItemLabel(C_("Swatches", "Border"));
+
+        //TRANSLATORS: Indicates border of colour swatches
+        const gchar *widthLabels[] = {
+            NC_("Swatches border", "None"),
+            NC_("Swatches border", "Solid"),
+            NC_("Swatches border", "Wide"),
+        };
+
+        Gtk::MenuItem *item = Gtk::manage( new Gtk::MenuItem(widthItemLabel));
+        Gtk::Menu *type_menu = Gtk::manage(new Gtk::Menu());
+        item->set_submenu(*type_menu);
+        _menu->append(*item);
+
+        Gtk::RadioMenuItem::Group widthGroup;
+
+        guint values[] = {0, 1, 2};
+        guint hot_index = 0;
+        for ( guint i = 0; i < G_N_ELEMENTS(widthLabels); ++i ) {
+            // Assume all values are in increasing order
+            if ( values[i] <= panel_border ) {
+                hot_index = i;
+            }
+        }
+        for ( guint i = 0; i < G_N_ELEMENTS(widthLabels); ++i ) {
+            Glib::ustring _label(g_dpgettext2(NULL, "Swatches border", widthLabels[i]));
+            Gtk::RadioMenuItem *_item = Gtk::manage(new Gtk::RadioMenuItem(widthGroup, _label));
+            type_menu->append(*_item);
+            if ( i <= hot_index ) {
+                _item->set_active(true);
+            }
+            _item->signal_activate().connect(sigc::bind<int, int>(sigc::mem_fun(*this, &SwatchesPanel::_bounceCall), PANEL_SETTING_BORDER, values[i]));
+        }
+    }
+
+    {
+        //TRANSLATORS: "Wrap" indicates how colour swatches are displayed
+        Glib::ustring wrap_label(C_("Swatches","Wrap"));
+        Gtk::CheckMenuItem *check = Gtk::manage(new Gtk::CheckMenuItem(wrap_label));
+        check->set_active(panel_wrap);
+        _menu->append(*check);
+        _non_vertical.push_back(check);
+
+        check->signal_toggled().connect(sigc::bind<Gtk::CheckMenuItem*>(sigc::mem_fun(*this, &SwatchesPanel::_wrapToggled), check));
+    }
+
+    Gtk::SeparatorMenuItem *sep;
+    sep = Gtk::manage(new Gtk::SeparatorMenuItem());
+    _menu->append(*sep);
+
+    _menu->show_all_children();
+    for ( std::vector<Gtk::Widget*>::iterator iter = _non_vertical.begin(); iter != _non_vertical.end(); ++iter ) {
+        (*iter)->hide();
+    }
+
+    if (true) {
+        _top_bar.pack_end(_menu_popper, false, false);
+        gint width = 0;
+        gint height = 0;
+        gtk_image_set_from_icon_name(_temp_arrow.gobj(),
+                                     "pan-start-symbolic",
+                                     GTK_ICON_SIZE_SMALL_TOOLBAR);
+        _menu_popper.add(_temp_arrow);
+        _menu_popper.signal_button_press_event().connect_notify(sigc::mem_fun(*this, &SwatchesPanel::_popper));
+    }
+
+
+    _boxy.set_name( "PanelBoxY" );
+    _getContents()->set_name( "PanelContents" );
+    _right_bar.set_name( "PanelRightBar" );
+    _top_bar.set_name( "PanelTopBar" );
+    _boxy.pack_end(_right_bar, false, true);
+
+    _getContents()->pack_start(_top_bar, false, false);
+    _getContents()->pack_start(_boxy, true, true);
+
+
+    _bounceCall(PANEL_SETTING_SIZE, panel_size);
+    _bounceCall(PANEL_SETTING_MODE, panel_mode);
+    _bounceCall(PANEL_SETTING_SHAPE, panel_ratio);
+    _bounceCall(PANEL_SETTING_WRAP, panel_wrap);
+    _bounceCall(PANEL_SETTING_BORDER, panel_border);
 }
 
 void SwatchesPanel::setOrientation(SPAnchorType how)
 {
-    // Must call the parent class or bad things might happen
-    Inkscape::UI::Widget::Panel::setOrientation( how );
+    if (_anchor != how) {
+        _anchor = how;
+        switch (_anchor) {
+            case SP_ANCHOR_NORTH:
+            case SP_ANCHOR_SOUTH:
+            {
+                if (true) {
+                    _menu_popper.reference();
+                    _top_bar.remove(_menu_popper);
+                    _right_bar.pack_start(_menu_popper, false, false);
+                    _menu_popper.unreference();
+
+                    for (std::vector<Gtk::Widget*>::iterator iter = _non_horizontal.begin(); iter != _non_horizontal.end(); ++iter) {
+                        (*iter)->hide();
+                    }
+                    for (std::vector<Gtk::Widget*>::iterator iter = _non_vertical.begin(); iter != _non_vertical.end(); ++iter) {
+                        (*iter)->show();
+                    }
+                }
+                // Ensure we are not in "list" mode
+                _bounceCall(PANEL_SETTING_MODE, 1);
+            }
+            break;
 
+            default:
+            {
+                if (true) {
+                    for (std::vector<Gtk::Widget*>::iterator iter = _non_horizontal.begin(); iter != _non_horizontal.end(); ++iter) {
+                        (*iter)->show();
+                    }
+                    for (std::vector<Gtk::Widget*>::iterator iter = _non_vertical.begin(); iter != _non_vertical.end(); ++iter) {
+                        (*iter)->hide();
+                    }
+                }
+            }
+        }
+    }
     if ( _holder )
     {
         _holder->setOrientation(SP_ANCHOR_SOUTH);
@@ -700,6 +961,175 @@ void SwatchesPanel::setDesktop( SPDesktop* desktop )
 }
 
 
+void SwatchesPanel::restorePanelPrefs()
+{
+    guint panel_size = 0, panel_mode = 0, panel_ratio = 100, panel_border = 0;
+    bool panel_wrap = 0;
+    if (!_prefs_path.empty()) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        panel_wrap = prefs->getBool(_prefs_path + "/panel_wrap");
+        panel_size = prefs->getIntLimited(_prefs_path + "/panel_size", 1, 0, PREVIEW_SIZE_HUGE);
+        panel_mode = prefs->getIntLimited(_prefs_path + "/panel_mode", 1, 0, 10);
+        panel_ratio = prefs->getIntLimited(_prefs_path + "/panel_ratio", 000, 0, 500 );
+        panel_border = prefs->getIntLimited(_prefs_path + "/panel_border", BORDER_NONE, 0, 2 );
+    }
+    _bounceCall(PANEL_SETTING_SIZE, panel_size);
+    _bounceCall(PANEL_SETTING_MODE, panel_mode);
+    _bounceCall(PANEL_SETTING_SHAPE, panel_ratio);
+    _bounceCall(PANEL_SETTING_WRAP, panel_wrap);
+    _bounceCall(PANEL_SETTING_BORDER, panel_border);
+}
+
+void SwatchesPanel::_bounceCall(int i, int j)
+{
+    _menu->set_active(0);
+    switch (i) {
+    case PANEL_SETTING_SIZE:
+        if (!_prefs_path.empty()) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setInt(_prefs_path + "/panel_size", j);
+        }
+        if (_fillable) {
+            ViewType curr_type = _fillable->getPreviewType();
+            guint curr_ratio = _fillable->getPreviewRatio();
+            ::BorderStyle curr_border = _fillable->getPreviewBorder();
+
+            switch (j) {
+            case 0:
+            {
+                _fillable->setStyle(::PREVIEW_SIZE_TINY, curr_type, curr_ratio, curr_border);
+            }
+            break;
+            case 1:
+            {
+                _fillable->setStyle(::PREVIEW_SIZE_SMALL, curr_type, curr_ratio, curr_border);
+            }
+            break;
+            case 2:
+            {
+                _fillable->setStyle(::PREVIEW_SIZE_MEDIUM, curr_type, curr_ratio, curr_border);
+            }
+            break;
+            case 3:
+            {
+                _fillable->setStyle(::PREVIEW_SIZE_BIG, curr_type, curr_ratio, curr_border);
+            }
+            break;
+            case 4:
+            {
+                _fillable->setStyle(::PREVIEW_SIZE_HUGE, curr_type, curr_ratio, curr_border);
+            }
+            break;
+            default:
+                ;
+            }
+        }
+        break;
+    case PANEL_SETTING_MODE:
+        if (!_prefs_path.empty()) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setInt(_prefs_path + "/panel_mode", j);
+        }
+        if (_fillable) {
+            ::PreviewSize curr_size = _fillable->getPreviewSize();
+            guint curr_ratio = _fillable->getPreviewRatio();
+            ::BorderStyle curr_border = _fillable->getPreviewBorder();
+            switch (j) {
+            case 0:
+            {
+                _fillable->setStyle(curr_size, VIEW_TYPE_LIST, curr_ratio, curr_border);
+            }
+            break;
+            case 1:
+            {
+                _fillable->setStyle(curr_size, VIEW_TYPE_GRID, curr_ratio, curr_border);
+            }
+            break;
+            default:
+                break;
+            }
+        }
+        break;
+    case PANEL_SETTING_SHAPE:
+        if (!_prefs_path.empty()) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setInt(_prefs_path + "/panel_ratio", j);
+        }
+        if ( _fillable ) {
+            ViewType curr_type = _fillable->getPreviewType();
+            ::PreviewSize curr_size = _fillable->getPreviewSize();
+            ::BorderStyle curr_border = _fillable->getPreviewBorder();
+
+            _fillable->setStyle(curr_size, curr_type, j, curr_border);
+        }
+        break;
+    case PANEL_SETTING_BORDER:
+        if (!_prefs_path.empty()) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setInt(_prefs_path + "/panel_border", j);
+        }
+        if ( _fillable ) {
+            ::PreviewSize curr_size = _fillable->getPreviewSize();
+            ViewType curr_type = _fillable->getPreviewType();
+            guint curr_ratio = _fillable->getPreviewRatio();
+
+            switch (j) {
+            case 0:
+            {
+                _fillable->setStyle(curr_size, curr_type, curr_ratio, BORDER_NONE);
+            }
+            break;
+            case 1:
+            {
+                _fillable->setStyle(curr_size, curr_type, curr_ratio, BORDER_SOLID);
+            }
+            break;
+            case 2:
+            {
+                _fillable->setStyle(curr_size, curr_type, curr_ratio, BORDER_WIDE);
+            }
+            break;
+            default:
+                break;
+            }
+        }
+        break;
+    case PANEL_SETTING_WRAP:
+        if (!_prefs_path.empty()) {
+            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+            prefs->setBool(_prefs_path + "/panel_wrap", j);
+        }
+        if ( _fillable ) {
+            _fillable->setWrap(j);
+        }
+        break;
+    default:
+        _handleAction(i - PANEL_SETTING_NEXTFREE, j);
+    }
+}
+
+
+void SwatchesPanel::_wrapToggled(Gtk::CheckMenuItem* toggler)
+{
+    if (toggler) {
+        _bounceCall(PANEL_SETTING_WRAP, toggler->get_active() ? 1 : 0);
+    }
+}
+
+void SwatchesPanel::_setTargetFillable(PreviewFillable *target)
+{
+    _fillable = target;
+}
+
+void SwatchesPanel::_regItem(Gtk::MenuItem* item, int group, int id)
+{
+    _menu->append(*item);
+    item->signal_activate().connect(sigc::bind<int, int>(sigc::mem_fun(*this, &SwatchesPanel::_bounceCall), group + PANEL_SETTING_NEXTFREE, id));
+    item->show();
+
+}
+
+
 class DocTrack
 {
 public: