moved ColorNotebook to ui/widget

(bzr r13341.6.51)

4 files changed, 828 insertions, 1 deletions

diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert
index f39236da7..ddb641069 100644
--- a/src/ui/widget/Makefile_insert
+++ b/src/ui/widget/Makefile_insert
@@ -10,6 +10,8 @@ ink_common_sources +=	\
 	ui/widget/color-entry.h     \
 	ui/widget/color-icc-selector.cpp	\
 	ui/widget/color-icc-selector.h	\
+	ui/widget/color-notebook.cpp   \
+	ui/widget/color-notebook.h  \
 	ui/widget/color-wheel-selector.cpp    \
 	ui/widget/color-wheel-selector.h    \
 	ui/widget/color-picker.cpp     \
diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp
new file mode 100644
index 000000000..2b592e620
--- /dev/null
+++ b/src/ui/widget/color-notebook.cpp
@@ -0,0 +1,675 @@
+/*
+ * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
+ *
+ * Author:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   bulia byak <buliabyak@users.sf.net>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ *
+ * This code is in public domain
+ */
+
+#undef SPCS_PREVIEW
+#define noDUMP_CHANGE_INFO
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "widgets/icon.h"
+#include <cstring>
+#include <string>
+#include <cstdlib>
+#include <cstddef>
+#include <gtk/gtk.h>
+#include <glibmm/i18n.h>
+#include <gtkmm/label.h>
+
+#include "dialogs/dialog-events.h"
+#include "preferences.h"
+#include "widgets/spw-utilities.h"
+#include "svg/svg-icc-color.h"
+#include "inkscape.h"
+#include "document.h"
+#include "profile-manager.h"
+#include "color-profile.h"
+#include "cms-system.h"
+#include "tools-switch.h"
+#include "ui/tools/tool-base.h"
+#include "ui/widget/color-entry.h"
+#include "ui/widget/color-icc-selector.h"
+#include "ui/widget/color-notebook.h"
+#include "ui/widget/color-scales.h"
+#include "ui/widget/color-wheel-selector.h"
+
+using Inkscape::CMSSystem;
+
+using namespace Inkscape::UI;
+using namespace Inkscape::UI::Widget;
+
+struct SPColorNotebookTracker {
+    const gchar* name;
+    const gchar* className;
+    GType type;
+    guint submode;
+    gboolean enabledFull;
+    gboolean enabledBrief;
+    SPColorNotebook *backPointer;
+};
+
+
+static void sp_color_notebook_class_init (SPColorNotebookClass *klass);
+static void sp_color_notebook_init (SPColorNotebook *colorbook);
+static void sp_color_notebook_dispose(GObject *object);
+
+static void sp_color_notebook_show_all (GtkWidget *widget);
+static void sp_color_notebook_hide(GtkWidget *widget);
+
+static SPColorSelectorClass *parent_class;
+
+#define XPAD 4
+#define YPAD 1
+
+GType sp_color_notebook_get_type(void)
+{
+    static GType type = 0;
+    if (!type) {
+        GTypeInfo info = {
+            sizeof(SPColorNotebookClass),
+            0, // base_init
+            0, // base_finalize
+            (GClassInitFunc)sp_color_notebook_class_init,
+            0, // class_finalize
+            0, // class_data
+            sizeof(SPColorNotebook),
+            0, // n_preallocs
+            (GInstanceInitFunc)sp_color_notebook_init,
+            0 // value_table
+        };
+        type = g_type_register_static(SP_TYPE_COLOR_SELECTOR, "SPColorNotebook", &info, static_cast<GTypeFlags>(0));
+    }
+    return type;
+}
+
+static void sp_color_notebook_class_init(SPColorNotebookClass *klass)
+{
+    GObjectClass *object_class = reinterpret_cast<GObjectClass *>(klass);
+    GtkWidgetClass *widget_class = reinterpret_cast<GtkWidgetClass *>(klass);
+
+    parent_class = SP_COLOR_SELECTOR_CLASS(g_type_class_peek_parent(klass));
+
+    object_class->dispose = sp_color_notebook_dispose;
+
+    widget_class->show_all = sp_color_notebook_show_all;
+    widget_class->hide = sp_color_notebook_hide;
+}
+
+static void
+sp_color_notebook_switch_page(GtkNotebook *notebook,
+                              GtkWidget   *page,
+                              guint page_num,
+                              SPColorNotebook *colorbook)
+{
+    if ( colorbook )
+    {
+        // remember the page we switched to
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        prefs->setInt("/colorselector/page", page_num);
+    }
+}
+
+static void
+sp_color_notebook_init (SPColorNotebook *colorbook)
+{
+    SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) );
+
+    if ( SP_COLOR_SELECTOR(colorbook)->base )
+    {
+        SP_COLOR_SELECTOR(colorbook)->base->init();
+    }
+}
+
+void ColorNotebook::init()
+{
+    guint row = 0;
+
+    _updating = false;
+
+    _book = gtk_notebook_new ();
+    gtk_widget_show (_book);
+
+    // Dont show the notebook tabs, use radiobuttons instead
+    gtk_notebook_set_show_border (GTK_NOTEBOOK (_book), false);
+    gtk_notebook_set_show_tabs (GTK_NOTEBOOK (_book), false);
+
+#if GTK_CHECK_VERSION(3,0,0)
+    _buttonbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
+    gtk_box_set_homogeneous(GTK_BOX(_buttonbox), TRUE);
+#else
+    _buttonbox = gtk_hbox_new (TRUE, 2);
+#endif
+
+    gtk_widget_show (_buttonbox);
+    _buttons = new GtkWidget *[_available_pages.size()];
+
+    for (int i = 0; static_cast<size_t>(i) < _available_pages.size(); i++ )
+    {
+        _addPage(_available_pages[i]);
+    }
+
+#if GTK_CHECK_VERSION(3,0,0)
+    GtkWidget* table = gtk_grid_new();
+#else
+    GtkWidget* table = gtk_table_new(2, 3, FALSE);
+#endif
+
+    gtk_widget_show (table);
+
+    gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
+
+    sp_set_font_size_smaller (_buttonbox);
+
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_margin_left(_buttonbox, XPAD);
+    gtk_widget_set_margin_right(_buttonbox, XPAD);
+    gtk_widget_set_margin_top(_buttonbox, YPAD);
+    gtk_widget_set_margin_bottom(_buttonbox, YPAD);
+    gtk_widget_set_hexpand(_buttonbox, TRUE);
+    gtk_widget_set_valign(_buttonbox, GTK_ALIGN_CENTER);
+    gtk_grid_attach(GTK_GRID(table), _buttonbox, 0, row, 2, 1);
+#else
+    gtk_table_attach (GTK_TABLE (table), _buttonbox, 0, 2, row, row + 1,
+                      static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
+                      static_cast<GtkAttachOptions>(0),
+                      XPAD, YPAD);
+#endif
+
+    row++;
+
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_margin_left(_book, XPAD*2);
+    gtk_widget_set_margin_right(_book, XPAD*2);
+    gtk_widget_set_margin_top(_book, YPAD);
+    gtk_widget_set_margin_bottom(_book, YPAD);
+    gtk_widget_set_hexpand(_book, TRUE);
+    gtk_widget_set_vexpand(_book, TRUE);
+    gtk_grid_attach(GTK_GRID(table), _book, 0, row, 2, 1);
+#else
+    gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1,
+                      static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
+                      static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
+                      XPAD*2, YPAD);
+#endif
+
+    // restore the last active page
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    _setCurrentPage(prefs->getInt("/colorselector/page", 0));
+
+
+    /* Commented out: see comment at the bottom of the header file
+    {
+        gboolean found = FALSE;
+
+        _popup = gtk_menu_new();
+        GtkMenu *menu = GTK_MENU (_popup);
+
+        for (int i = 0; i < _trackerList->len; i++ )
+        {
+            SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
+            if ( entry )
+            {
+                GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name));
+                gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull);
+                gtk_widget_show (item);
+                gtk_menu_shell_append (GTK_MENU_SHELL(menu), item);
+
+                g_signal_connect (G_OBJECT (item), "activate",
+                                  G_CALLBACK (sp_color_notebook_menuitem_response),
+                                  reinterpret_cast< gpointer > (entry) );
+                found = TRUE;
+            }
+        }
+
+        GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
+        gtk_widget_show (arrow);
+
+        _btn = gtk_button_new ();
+        gtk_widget_show (_btn);
+        gtk_container_add (GTK_CONTAINER (_btn), arrow);
+
+        GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0);
+        gtk_widget_show (align);
+        gtk_container_add (GTK_CONTAINER (align), _btn);
+
+        // uncomment to reenable the "show/hide modes" menu,
+        // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!)
+        gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
+
+        g_signal_connect_swapped(G_OBJECT(_btn), "event", G_CALLBACK (sp_color_notebook_menu_handler), G_OBJECT(_csel));
+        if ( !found )
+        {
+            gtk_widget_set_sensitive (_btn, FALSE);
+        }
+    }
+    */
+
+    row++;
+
+#if GTK_CHECK_VERSION(3,0,0)
+    GtkWidget *rgbabox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+#else
+    GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
+#endif
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    /* Create color management icons */
+    _box_colormanaged = gtk_event_box_new ();
+    GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged);
+    gtk_widget_set_tooltip_text (_box_colormanaged, _("Color Managed"));
+    gtk_widget_set_sensitive (_box_colormanaged, false);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2);
+
+    _box_outofgamut = gtk_event_box_new ();
+    GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut);
+    gtk_widget_set_tooltip_text (_box_outofgamut, _("Out of gamut!"));
+    gtk_widget_set_sensitive (_box_outofgamut, false);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2);
+
+    _box_toomuchink = gtk_event_box_new ();
+    GtkWidget *toomuchink = gtk_image_new_from_icon_name ("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    gtk_container_add (GTK_CONTAINER (_box_toomuchink), toomuchink);
+    gtk_widget_set_tooltip_text (_box_toomuchink, _("Too much ink!"));
+    gtk_widget_set_sensitive (_box_toomuchink, false);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2);
+#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+
+    /* Color picker */
+    GtkWidget *picker = gtk_image_new_from_icon_name ("color-picker", GTK_ICON_SIZE_SMALL_TOOLBAR);
+    _btn_picker = gtk_button_new ();
+    gtk_button_set_relief(GTK_BUTTON(_btn_picker), GTK_RELIEF_NONE);
+    gtk_container_add (GTK_CONTAINER (_btn_picker), picker);
+    gtk_widget_set_tooltip_text (_btn_picker, _("Pick colors from image"));
+    gtk_box_pack_start(GTK_BOX(rgbabox), _btn_picker, FALSE, FALSE, 2);
+    g_signal_connect(G_OBJECT(_btn_picker), "clicked", G_CALLBACK(ColorNotebook::_picker_clicked), _csel);
+
+    /* Create RGBA entry and color preview */
+    _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
+    gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
+    gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
+
+    ColorEntry* rgba_entry = Gtk::manage(new ColorEntry(_selected_color));
+    sp_dialog_defocus_on_enter (GTK_WIDGET(rgba_entry->gobj()));
+    gtk_box_pack_start(GTK_BOX(rgbabox), GTK_WIDGET(rgba_entry->gobj()), FALSE, FALSE, 0);
+    gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), GTK_WIDGET(rgba_entry->gobj()));
+
+    sp_set_font_size_smaller (rgbabox);
+    gtk_widget_show_all (rgbabox);
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    //the "too much ink" icon is initially hidden
+    gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
+#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_margin_left(rgbabox, XPAD);
+    gtk_widget_set_margin_right(rgbabox, XPAD);
+    gtk_widget_set_margin_top(rgbabox, YPAD);
+    gtk_widget_set_margin_bottom(rgbabox, YPAD);
+    gtk_grid_attach(GTK_GRID(table), rgbabox, 0, row, 2, 1);
+#else
+    gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
+#endif
+
+#ifdef SPCS_PREVIEW
+    _p = sp_color_preview_new (0xffffffff);
+    gtk_widget_show (_p);
+    gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
+#endif
+
+    _switchId = g_signal_connect(G_OBJECT (_book), "switch-page",
+                                 G_CALLBACK (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
+
+    _selected_color.signal_changed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged));
+    _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorDragged));
+    _selected_color.signal_grabbed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorGrabbed));
+    _selected_color.signal_released.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorReleased));
+}
+
+static void sp_color_notebook_dispose(GObject *object)
+{
+    if (((GObjectClass *) (parent_class))->dispose)
+        (* ((GObjectClass *) (parent_class))->dispose) (object);
+}
+
+ColorNotebook::~ColorNotebook()
+{
+    if ( _switchId )
+    {
+        if ( _book )
+        {
+            g_signal_handler_disconnect (_book, _switchId);
+            _switchId = 0;
+        }
+    }
+
+    if ( _buttons )
+    {
+        delete [] _buttons;
+        _buttons = 0;
+    }
+
+}
+
+static void
+sp_color_notebook_show_all (GtkWidget *widget)
+{
+    gtk_widget_show (widget);
+}
+
+static void sp_color_notebook_hide(GtkWidget *widget)
+{
+    gtk_widget_hide(widget);
+}
+
+GtkWidget *sp_color_notebook_new()
+{
+    SPColorNotebook *colorbook = SP_COLOR_NOTEBOOK(g_object_new (SP_TYPE_COLOR_NOTEBOOK, NULL));
+
+    return GTK_WIDGET(colorbook);
+}
+
+ColorNotebook::ColorNotebook( SPColorSelector* csel )
+    : ColorSelector( csel )
+    , _selected_color(_selected_color_tmp)
+{
+    Page *page;
+
+    page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_RGB), true);
+    _available_pages.push_back(page);
+    page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_HSV), true);
+    _available_pages.push_back(page);
+    page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_CMYK), true);
+    _available_pages.push_back(page);
+    page = new Page(new ColorWheelSelectorFactory, true);
+    _available_pages.push_back(page);
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    page = new Page(new ColorICCSelectorFactory, true);
+    _available_pages.push_back(page);
+#endif
+}
+
+Gtk::Widget *ColorNotebook::create(SelectedColor &color) {
+    GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK);
+    SPColorSelector *s = SP_COLOR_SELECTOR(w);
+    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(s->base);
+    return Glib::wrap(w);
+}
+
+ColorNotebook::Page::Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full)
+    : selector_factory(selector_factory)
+    , enabled_full(enabled_full)
+{
+}
+
+void ColorNotebook::_colorChanged()
+{
+    _updating = true;
+    _selected_color.setColorAlpha(_color, _alpha);
+    _updateICCButtons();
+    _updating = false;
+}
+
+void ColorNotebook::_picker_clicked(GtkWidget * /*widget*/, SPColorNotebook * /*colorbook*/)
+{
+    // Set the dropper into a "one click" mode, so it reverts to the previous tool after a click
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setBool("/tools/dropper/onetimepick", true);
+    Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP);
+}
+
+// TODO pass in param so as to avoid the need for SP_ACTIVE_DOCUMENT
+void ColorNotebook::_updateICCButtons()
+{
+    SPColor color = _selected_color.color();
+    gfloat alpha = _selected_color.alpha();
+
+    g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    /* update color management icon*/
+    gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
+
+    /* update out-of-gamut icon */
+    gtk_widget_set_sensitive (_box_outofgamut, false);
+    if (color.icc){
+        Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
+        if ( target_profile )
+            gtk_widget_set_sensitive(_box_outofgamut, target_profile->GamutCheck(color));
+    }
+
+    /* update too-much-ink icon */
+    gtk_widget_set_sensitive (_box_toomuchink, false);
+    if (color.icc){
+        Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
+        if ( prof && CMSSystem::isPrintColorSpace(prof) ) {
+            gtk_widget_show(GTK_WIDGET(_box_toomuchink));
+            double ink_sum = 0;
+            for (unsigned int i=0; i<color.icc->colors.size(); i++){
+                ink_sum += color.icc->colors[i];
+            }
+
+            /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color,
+                which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues
+                such as misalignment and poor quality of printing in general.*/
+            if ( ink_sum > 3.2 )
+                gtk_widget_set_sensitive (_box_toomuchink, true);
+        } else {
+            gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
+        }
+    }
+#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+}
+
+void ColorNotebook::_setCurrentPage(int i)
+{
+    gtk_notebook_set_current_page(GTK_NOTEBOOK(_book), i);
+
+    if (_buttons && (static_cast<size_t>(i) < _available_pages.size())) {
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_buttons[i]), TRUE);
+    }
+}
+
+void ColorNotebook::_buttonClicked(GtkWidget *widget,  SPColorNotebook *colorbook)
+{
+    ColorNotebook* nb = dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(colorbook)->base);
+
+    if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget))) {
+        return;
+    }
+
+    for(gint i = 0; i < gtk_notebook_get_n_pages (GTK_NOTEBOOK (nb->_book)); i++) {
+        if (nb->_buttons[i] == widget) {
+            gtk_notebook_set_current_page (GTK_NOTEBOOK (nb->_book), i);
+        }
+    }
+}
+
+void ColorNotebook::_onSelectedColorChanged() {
+    if (_updating) {
+        return;
+    }
+
+    SPColor color;
+    gfloat alpha = 1.0;
+    _selected_color.colorAlpha(color, alpha);
+    _updateInternals(color, alpha, false);
+    _updateICCButtons();
+}
+
+void ColorNotebook::_onSelectedColorDragged() {
+    if (_updating) {
+        return;
+    }
+    SPColor color;
+    gfloat alpha = 1.0;
+    _selected_color.colorAlpha(color, alpha);
+    _updateInternals(color, alpha, true);
+    _updateICCButtons();
+}
+
+void ColorNotebook::_onSelectedColorGrabbed() {
+    if (_updating) {
+        return;
+    }
+
+    _grabbed();
+}
+
+void ColorNotebook::_onSelectedColorReleased() {
+    if (_updating) {
+        return;
+    }
+    _released();
+}
+
+GtkWidget* ColorNotebook::_addPage(Page& page) {
+    Gtk::Widget *selector_widget;
+
+    selector_widget = page.selector_factory->createWidget(_selected_color);
+    if (selector_widget) {
+        selector_widget->show();
+
+        Glib::ustring mode_name = page.selector_factory->modeName();
+        Gtk::Widget* tab_label = Gtk::manage(new Gtk::Label(mode_name));
+        gint page_num = gtk_notebook_append_page( GTK_NOTEBOOK(_book), selector_widget->gobj(), tab_label->gobj());
+
+        _buttons[page_num] = gtk_radio_button_new_with_label(NULL, mode_name.c_str());
+        gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(_buttons[page_num]), FALSE);
+        if (page_num > 0) {
+            GSList *group =  gtk_radio_button_get_group (GTK_RADIO_BUTTON(_buttons[0]));
+            gtk_radio_button_set_group (GTK_RADIO_BUTTON(_buttons[page_num]), group);
+        }
+        gtk_widget_show (_buttons[page_num]);
+        gtk_box_pack_start (GTK_BOX (_buttonbox), _buttons[page_num], TRUE, TRUE, 0);
+
+        g_signal_connect (G_OBJECT (_buttons[page_num]), "clicked", G_CALLBACK (_buttonClicked), _csel);
+    }
+
+    return selector_widget->gobj();
+}
+
+
+/* Commented out: see comment at the bottom of the header file
+
+GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
+{
+    gint count = 0;
+    gint i = 0;
+    GtkWidget* page = 0;
+
+//     count = gtk_notebook_get_n_pages (_book);
+    count = 200;
+    for ( i = 0; i < count && !page; i++ )
+    {
+        page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
+        if ( page )
+        {
+            SPColorSelector* csel;
+            guint pagemode;
+            csel = SP_COLOR_SELECTOR (page);
+            pagemode = csel->base->getSubmode();
+            if ( G_TYPE_FROM_INSTANCE (page) == page_type
+                 && pagemode == submode )
+            {
+                // found it.
+                break;
+            }
+            else
+            {
+                page = 0;
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+    return page;
+}
+
+void ColorNotebook::removePage( GType page_type, guint submode )
+{
+    GtkWidget *page = 0;
+
+    page = getPage(page_type, submode);
+    if ( page )
+    {
+        gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
+        if ( where >= 0 )
+        {
+            if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
+            {
+//                 getColorAlpha(_color, &_alpha);
+            }
+            gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
+        }
+    }
+}
+
+
+static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event )
+{
+    if (event->type == GDK_BUTTON_PRESS)
+    {
+        SPColorSelector* csel = SP_COLOR_SELECTOR(widget);
+        (dynamic_cast<ColorNotebook*>(csel->base))->menuHandler( event );
+
+        // Tell calling code that we have handled this event; the buck
+        // stops here.
+        return TRUE;
+    }
+
+   //Tell calling code that we have not handled this event; pass it on.
+    return FALSE;
+}
+
+gint ColorNotebook::menuHandler( GdkEvent* event )
+{
+    GdkEventButton *bevent = (GdkEventButton *) event;
+    gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL,
+                    bevent->button, bevent->time);
+    return TRUE;
+}
+
+static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
+{
+    gboolean active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
+    SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
+    if ( entry )
+    {
+        if ( active )
+        {
+            (dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
+        }
+        else
+        {
+            (dynamic_cast<ColorNotebook*>(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
+        }
+    }
+}
+*/
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h
new file mode 100644
index 000000000..177519e25
--- /dev/null
+++ b/src/ui/widget/color-notebook.h
@@ -0,0 +1,150 @@
+#ifndef SEEN_SP_COLOR_NOTEBOOK_H
+#define SEEN_SP_COLOR_NOTEBOOK_H
+
+/*
+ * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
+ *
+ * Author:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ *
+ * This code is in public domain
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H
+#include <glibmm/threads.h>
+#endif
+
+#include <boost/ptr_container/ptr_vector.hpp>
+#include <gtk/gtk.h>
+#include <glib.h>
+#include <gtkmm/table.h>
+
+#include "color.h"
+#include "widgets/sp-color-selector.h"
+#include "ui/selected-color.h"
+
+
+struct SPColorNotebook;
+
+class ColorNotebook: public ColorSelector
+{
+public:
+    ColorNotebook( SPColorSelector* csel );
+    virtual ~ColorNotebook();
+
+    //Temporary factory method - transition from SPColorSelector
+    static Gtk::Widget* create(Inkscape::UI::SelectedColor &color);
+
+    virtual void init();
+
+protected:
+    struct Page {
+        Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full);
+
+        Inkscape::UI::ColorSelectorFactory *selector_factory;
+        bool enabled_full;
+    };
+
+    static void _buttonClicked(GtkWidget *widget,  SPColorNotebook *colorbook);
+    static void _picker_clicked(GtkWidget *widget,  SPColorNotebook *colorbook);
+
+    virtual void _colorChanged();
+
+    virtual void _onSelectedColorChanged();
+    virtual void _onSelectedColorDragged();
+    virtual void _onSelectedColorGrabbed();
+    virtual void _onSelectedColorReleased();
+
+    void _updateICCButtons();
+    void _setCurrentPage(int i);
+
+    GtkWidget* _addPage(Page& page);
+
+    Inkscape::UI::SelectedColor _selected_color_tmp;
+    Inkscape::UI::SelectedColor &_selected_color;
+    gboolean _updating : 1;
+    gulong _switchId;
+    gulong _entryId;
+    GtkWidget *_book;
+    GtkWidget *_buttonbox;
+    GtkWidget **_buttons;
+    GtkWidget *_rgbal; /* RGBA entry */
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    GtkWidget *_box_outofgamut, *_box_colormanaged, *_box_toomuchink;
+#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+    GtkWidget *_btn_picker;
+    GtkWidget *_p; /* Color preview */
+    boost::ptr_vector<Page> _available_pages;
+
+private:
+    // By default, disallow copy constructor and assignment operator
+    ColorNotebook( const ColorNotebook& obj );
+    ColorNotebook& operator=( const ColorNotebook& obj );
+
+    /* Following methods support the pop-up menu to choose
+     * active color selectors (notebook tabs). This function
+     * is not used in Inkscape. If you want to re-enable it you have to
+     *  * port the code to c++
+     *  * fix it so it remembers its settings in prefs
+     *  * fix it so it does not take that much space (entire vertical column!)
+     * Current class design supports dynamic addtion and removal of color selectors
+     *
+    GtkWidget* addPage( GType page_type, guint submode );
+    void removePage( GType page_type, guint submode );
+    GtkWidget* getPage( GType page_type, guint submode );
+    gint menuHandler( GdkEvent* event );
+
+    */
+};
+
+
+
+
+
+#define SP_TYPE_COLOR_NOTEBOOK (sp_color_notebook_get_type ())
+#define SP_COLOR_NOTEBOOK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_NOTEBOOK, SPColorNotebook))
+#define SP_COLOR_NOTEBOOK_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_NOTEBOOK, SPColorNotebookClass))
+#define SP_IS_COLOR_NOTEBOOK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_NOTEBOOK))
+#define SP_IS_COLOR_NOTEBOOK_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_NOTEBOOK))
+
+struct SPColorNotebook {
+    SPColorSelector parent;    /* Parent */
+};
+
+struct SPColorNotebookClass {
+    SPColorSelectorClass parent_class;
+
+    void (* grabbed) (SPColorNotebook *rgbsel);
+    void (* dragged) (SPColorNotebook *rgbsel);
+    void (* released) (SPColorNotebook *rgbsel);
+    void (* changed) (SPColorNotebook *rgbsel);
+};
+
+GType sp_color_notebook_get_type(void);
+
+GtkWidget *sp_color_notebook_new (void);
+
+/* void sp_color_notebook_set_mode (SPColorNotebook *csel, SPColorNotebookMode mode); */
+/* SPColorNotebookMode sp_color_notebook_get_mode (SPColorNotebook *csel); */
+
+
+
+#endif // SEEN_SP_COLOR_NOTEBOOK_H
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
+
diff --git a/src/ui/widget/color-picker.cpp b/src/ui/widget/color-picker.cpp
index f909535b1..dc827f377 100644
--- a/src/ui/widget/color-picker.cpp
+++ b/src/ui/widget/color-picker.cpp
@@ -17,7 +17,7 @@
 #include "document-undo.h"
 #include "dialogs/dialog-events.h"
 
-#include "widgets/sp-color-notebook.h"
+#include "ui/widget/color-notebook.h"
 #include "verbs.h"