src/widgets/sp-color-notebook.cpp

   1 #define __SP_COLOR_NOTEBOOK_C__
   2
   3 /*
   4  * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
   5  *
   6  * Author:
   7  *       Lauris Kaplinski <lauris@kaplinski.com>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *
  10  * Copyright (C) 2001-2002 Lauris Kaplinski
  11  *
  12  * This code is in public domain
  13  */
  14
  15 #undef SPCS_PREVIEW
  16 #define noDUMP_CHANGE_INFO
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include "config.h"
  20 #endif
  21
  22 #include <cstring>
  23 #include <string>
  24 #include <cstdlib>
  25 #include <gtk/gtk.h>
  26 #include <glibmm/i18n.h>
  27
  28 #include "../dialogs/dialog-events.h"
  29 #include "../preferences.h"
  30 #include "sp-color-notebook.h"
  31 #include "spw-utilities.h"
  32 #include "sp-color-scales.h"
  33 #include "sp-color-icc-selector.h"
  34 #include "sp-color-wheel-selector.h"
  35
  36 struct SPColorNotebookTracker {
  37         const gchar* name;
  38         const gchar* className;
  39         GType type;
  40         guint submode;
  41         gboolean enabledFull;
  42         gboolean enabledBrief;
  43         SPColorNotebook *backPointer;
  44 };
  45
  46 static void sp_color_notebook_class_init (SPColorNotebookClass *klass);
  47 static void sp_color_notebook_init (SPColorNotebook *colorbook);
  48 static void sp_color_notebook_destroy (GtkObject *object);
  49
  50 static void sp_color_notebook_show_all (GtkWidget *widget);
  51 static void sp_color_notebook_hide_all (GtkWidget *widget);
  52
  53 static SPColorSelectorClass *parent_class;
  54
  55 #define XPAD 4
  56 #define YPAD 1
  57
  58 GType sp_color_notebook_get_type(void)
  59 {
  60     static GtkType type = 0;
  61     if (!type) {
  62         GTypeInfo info = {
  63             sizeof(SPColorNotebookClass),
  64             0, // base_init
  65             0, // base_finalize
  66             (GClassInitFunc)sp_color_notebook_class_init,
  67             0, // class_finalize
  68             0, // class_data
  69             sizeof(SPColorNotebook),
  70             0, // n_preallocs
  71             (GInstanceInitFunc)sp_color_notebook_init,
  72             0 // value_table
  73         };
  74         type = g_type_register_static(SP_TYPE_COLOR_SELECTOR, "SPColorNotebook", &info, static_cast<GTypeFlags>(0));
  75     }
  76     return type;
  77 }
  78
  79 static void
  80 sp_color_notebook_class_init (SPColorNotebookClass *klass)
  81 {
  82         GtkObjectClass *object_class;
  83         GtkWidgetClass *widget_class;
  84         SPColorSelectorClass *selector_class;
  85
  86         object_class = (GtkObjectClass *) klass;
  87         widget_class = (GtkWidgetClass *) klass;
  88         selector_class = SP_COLOR_SELECTOR_CLASS (klass);
  89
  90         parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
  91
  92         object_class->destroy = sp_color_notebook_destroy;
  93
  94         widget_class->show_all = sp_color_notebook_show_all;
  95         widget_class->hide_all = sp_color_notebook_hide_all;
  96 }
  97
  98 static void
  99 sp_color_notebook_switch_page(GtkNotebook *notebook,
 100                               GtkNotebookPage *page,
 101                               guint page_num,
 102                               SPColorNotebook *colorbook)
 103 {
 104     if ( colorbook )
 105     {
 106         ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 107         nb->switchPage( notebook, page, page_num );
 108
 109         // remember the page we seitched to
 110         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 111         prefs->setInt("/colorselector/page", page_num);
 112     }
 113 }
 114
 115 void ColorNotebook::switchPage(GtkNotebook*,
 116                               GtkNotebookPage*,
 117                               guint page_num)
 118 {
 119     SPColorSelector* csel;
 120     GtkWidget* widget;
 121
 122     if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) >= 0 )
 123     {
 124         csel = getCurrentSelector();
 125         csel->base->getColorAlpha(_color, &_alpha);
 126     }
 127     widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), page_num);
 128     if ( widget && SP_IS_COLOR_SELECTOR (widget) )
 129     {
 130         csel = SP_COLOR_SELECTOR (widget);
 131         csel->base->setColorAlpha( _color, _alpha );
 132
 133         // Temporary workaround to undo a spurious GRABBED
 134         _released();
 135     }
 136 }
 137
 138 static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event )
 139 {
 140     if (event->type == GDK_BUTTON_PRESS)
 141     {
 142         SPColorSelector* csel = SP_COLOR_SELECTOR(widget);
 143         ((ColorNotebook*)(csel->base))->menuHandler( event );
 144
 145         /* Tell calling code that we have handled this event; the buck
 146          * stops here. */
 147         return TRUE;
 148     }
 149
 150     /* Tell calling code that we have not handled this event; pass it on. */
 151     return FALSE;
 152 }
 153
 154 gint ColorNotebook::menuHandler( GdkEvent* event )
 155 {
 156     GdkEventButton *bevent = (GdkEventButton *) event;
 157     gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL,
 158                     bevent->button, bevent->time);
 159     return TRUE;
 160 }
 161
 162 static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
 163 {
 164         gboolean active = FALSE;
 165
 166         active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
 167         SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
 168         if ( entry )
 169         {
 170                 if ( active )
 171                 {
 172                         ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
 173                 }
 174                 else
 175                 {
 176                         ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
 177                 }
 178         }
 179 }
 180
 181 static void
 182 sp_color_notebook_init (SPColorNotebook *colorbook)
 183 {
 184     SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) );
 185
 186     if ( SP_COLOR_SELECTOR(colorbook)->base )
 187     {
 188         SP_COLOR_SELECTOR(colorbook)->base->init();
 189     }
 190 }
 191
 192 void ColorNotebook::init()
 193 {
 194         GtkWidget* table = 0;
 195         guint row = 0;
 196         guint i = 0;
 197         guint j = 0;
 198         GType *selector_types = 0;
 199         guint   selector_type_count = 0;
 200
 201         GtkTooltips *tt = gtk_tooltips_new ();
 202
 203         /* tempory hardcoding to get types loaded */
 204         SP_TYPE_COLOR_SCALES;
 205         SP_TYPE_COLOR_WHEEL_SELECTOR;
 206 #if ENABLE_LCMS
 207         SP_TYPE_COLOR_ICC_SELECTOR;
 208 #endif // ENABLE_LCMS
 209
 210         /* REJON: Comment out the next line to not use the normal GTK Color
 211            wheel. */
 212
 213 //        SP_TYPE_COLOR_GTKSELECTOR;
 214
 215         _updating = FALSE;
 216         _updatingrgba = FALSE;
 217         _btn = 0;
 218         _popup = 0;
 219         _trackerList = g_ptr_array_new ();
 220
 221         _book = gtk_notebook_new ();
 222         gtk_widget_show (_book);
 223
 224         selector_types = g_type_children (SP_TYPE_COLOR_SELECTOR, &selector_type_count);
 225
 226         for ( i = 0; i < selector_type_count; i++ )
 227         {
 228                 if (!g_type_is_a (selector_types[i], SP_TYPE_COLOR_NOTEBOOK))
 229                 {
 230                         guint howmany = 1;
 231                         gpointer klass = gtk_type_class (selector_types[i]);
 232                         if ( klass && SP_IS_COLOR_SELECTOR_CLASS (klass) )
 233                         {
 234                                 SPColorSelectorClass *ck = SP_COLOR_SELECTOR_CLASS (klass);
 235                                 howmany = MAX (1, ck->submode_count);
 236                                 for ( j = 0; j < howmany; j++ )
 237                                 {
 238                                         SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (malloc(sizeof(SPColorNotebookTracker)));
 239                                         if ( entry )
 240                                         {
 241                                                 memset( entry, 0, sizeof(SPColorNotebookTracker) );
 242                                                 entry->name = ck->name[j];
 243                                                 entry->type = selector_types[i];
 244                                                 entry->submode = j;
 245                                                 entry->enabledFull = TRUE;
 246                                                 entry->enabledBrief = TRUE;
 247                                                 entry->backPointer = SP_COLOR_NOTEBOOK(_csel);
 248
 249                                                 g_ptr_array_add (_trackerList, entry);
 250                                         }
 251                                 }
 252                         }
 253                 }
 254         }
 255
 256         for ( i = 0; i < _trackerList->len; i++ )
 257         {
 258                 SPColorNotebookTracker *entry =
 259           reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
 260                 if ( entry )
 261                 {
 262                         addPage(entry->type, entry->submode);
 263                 }
 264         }
 265
 266         table = gtk_table_new (2, 3, FALSE);
 267         gtk_widget_show (table);
 268
 269         gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
 270
 271         gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1,
 272                       static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
 273                       static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
 274                       XPAD, YPAD);
 275
 276         // restore the last active page
 277         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 278         gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs->getInt("/colorselector/page", 0));
 279
 280         {
 281                 gboolean found = FALSE;
 282
 283                 _popup = gtk_menu_new();
 284                 GtkMenu *menu = GTK_MENU (_popup);
 285
 286                 for ( i = 0; i < _trackerList->len; i++ )
 287                 {
 288                         SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
 289                         if ( entry )
 290                         {
 291                                 GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name));
 292                                 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull);
 293                                 gtk_widget_show (item);
 294                                 gtk_menu_append (menu, item);
 295
 296                                 g_signal_connect (G_OBJECT (item), "activate",
 297                                                                   G_CALLBACK (sp_color_notebook_menuitem_response),
 298                                                                   reinterpret_cast< gpointer > (entry) );
 299                                 found = TRUE;
 300                         }
 301                 }
 302
 303                 GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
 304                 gtk_widget_show (arrow);
 305
 306                 _btn = gtk_button_new ();
 307                 gtk_widget_show (_btn);
 308                 gtk_container_add (GTK_CONTAINER (_btn), arrow);
 309
 310                 GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0);
 311                 gtk_widget_show (align);
 312                 gtk_container_add (GTK_CONTAINER (align), _btn);
 313
 314                 // uncomment to reenable the "show/hide modes" menu,
 315                 // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!)
 316                 //gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 317
 318                 gtk_signal_connect_object(GTK_OBJECT(_btn), "event", GTK_SIGNAL_FUNC (sp_color_notebook_menu_handler), GTK_OBJECT(_csel));
 319                 if ( !found )
 320                 {
 321                         gtk_widget_set_sensitive (_btn, FALSE);
 322                 }
 323         }
 324
 325         row++;
 326
 327         GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
 328         /* Create color management icons */
 329         _box_colormanaged = gtk_event_box_new ();
 330         GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
 331         gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged);
 332         GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
 333         gtk_tooltips_set_tip (tooltips_colormanaged, _box_colormanaged, _("Color Managed"), "");
 334         gtk_widget_set_sensitive (_box_colormanaged, false);
 335         gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, TRUE, FALSE, 2);
 336
 337         _box_outofgamut = gtk_event_box_new ();
 338         GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
 339         gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut);
 340         GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
 341         gtk_tooltips_set_tip (tooltips_outofgamut, _box_outofgamut, _("Out of gamut!"), "");
 342         gtk_widget_set_sensitive (_box_outofgamut, false);
 343         gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, TRUE, FALSE, 2);
 344
 345         /* Create RGBA entry and color preview */
 346         _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
 347         gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
 348         gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
 349
 350         _rgbae = gtk_entry_new ();
 351         sp_dialog_defocus_on_enter (_rgbae);
 352         gtk_entry_set_max_length (GTK_ENTRY (_rgbae), 8);
 353         gtk_entry_set_width_chars (GTK_ENTRY (_rgbae), 8);
 354         gtk_tooltips_set_tip (tt, _rgbae, _("Hexadecimal RGBA value of the color"), NULL);
 355         gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
 356         gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
 357
 358         sp_set_font_size_smaller (rgbabox);
 359         gtk_widget_show_all (rgbabox);
 360         gtk_table_attach (GTK_TABLE (table), rgbabox, 1, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
 361
 362 #ifdef SPCS_PREVIEW
 363         _p = sp_color_preview_new (0xffffffff);
 364         gtk_widget_show (_p);
 365         gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 366 #endif
 367
 368         _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
 369                                                                 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
 370
 371         _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
 372 }
 373
 374 static void
 375 sp_color_notebook_destroy (GtkObject *object)
 376 {
 377         if (((GtkObjectClass *) (parent_class))->destroy)
 378                 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
 379 }
 380
 381 ColorNotebook::~ColorNotebook()
 382 {
 383         if ( _trackerList )
 384         {
 385                 g_ptr_array_free (_trackerList, TRUE);
 386                 _trackerList = 0;
 387         }
 388
 389         if ( _switchId )
 390         {
 391                 if ( _book )
 392                 {
 393                         g_signal_handler_disconnect (_book, _switchId);
 394                         _switchId = 0;
 395                 }
 396         }
 397 }
 398
 399 static void
 400 sp_color_notebook_show_all (GtkWidget *widget)
 401 {
 402         gtk_widget_show (widget);
 403 }
 404
 405 static void
 406 sp_color_notebook_hide_all (GtkWidget *widget)
 407 {
 408         gtk_widget_hide (widget);
 409 }
 410
 411 GtkWidget *
 412 sp_color_notebook_new (void)
 413 {
 414         SPColorNotebook *colorbook;
 415
 416         colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
 417
 418         return GTK_WIDGET (colorbook);
 419 }
 420
 421 ColorNotebook::ColorNotebook( SPColorSelector* csel )
 422     : ColorSelector( csel )
 423 {
 424 }
 425
 426 SPColorSelector* ColorNotebook::getCurrentSelector()
 427 {
 428     SPColorSelector* csel = NULL;
 429     gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
 430
 431     if ( current_page >= 0 )
 432     {
 433         GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
 434         if ( SP_IS_COLOR_SELECTOR (widget) )
 435         {
 436             csel = SP_COLOR_SELECTOR (widget);
 437         }
 438     }
 439
 440     return csel;
 441 }
 442
 443 void ColorNotebook::_colorChanged()
 444 {
 445     SPColorSelector* cselPage = getCurrentSelector();
 446     if ( cselPage )
 447     {
 448         cselPage->base->setColorAlpha( _color, _alpha );
 449     }
 450
 451     _updateRgbaEntry( _color, _alpha );
 452 }
 453
 454 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
 455 {
 456     ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
 457 }
 458
 459 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
 460 {
 461     if (_updating) return;
 462     if (_updatingrgba) return;
 463
 464     const gchar *t = gtk_entry_get_text( entry );
 465
 466     if (t) {
 467         Glib::ustring text = t;
 468         bool changed = false;
 469         if (!text.empty() && text[0] == '#') {
 470             changed = true;
 471             text.erase(0,1);
 472             if (text.size() == 6) {
 473                 // it was a standard RGB hex
 474                 unsigned int alph = SP_COLOR_F_TO_U(_alpha);
 475                 gchar* tmp = g_strdup_printf("%02x", alph);
 476                 text += tmp;
 477                 g_free(tmp);
 478             }
 479         }
 480         gchar* str = g_strdup(text.c_str());
 481         gchar* end = 0;
 482         guint64 rgba = g_ascii_strtoull( str, &end, 16 );
 483         if ( end != str ) {
 484             ptrdiff_t len = end - str;
 485             if ( len < 8 ) {
 486                 rgba = rgba << ( 4 * ( 8 - len ) );
 487             }
 488             _updatingrgba = TRUE;
 489             if ( changed ) {
 490                 gtk_entry_set_text( entry, str );
 491             }
 492             SPColor color( rgba );
 493             setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
 494             _updatingrgba = FALSE;
 495         }
 496         g_free(str);
 497     }
 498 }
 499
 500 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
 501 {
 502     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 503
 504     /* update color management icon*/
 505     gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
 506
 507     if ( !_updatingrgba )
 508     {
 509         gchar s[32];
 510         guint32 rgba;
 511
 512         /* Update RGBA entry */
 513         rgba = color.toRGBA32( alpha );
 514
 515         g_snprintf (s, 32, "%08x", rgba);
 516         const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
 517         if ( strcmp( oldText, s ) != 0 )
 518         {
 519             g_signal_handler_block( _rgbae, _entryId );
 520             gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
 521             g_signal_handler_unblock( _rgbae, _entryId );
 522         }
 523     }
 524 }
 525
 526 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
 527 {
 528     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 529     nb->_grabbed();
 530 }
 531
 532 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
 533 {
 534         gboolean oldState;
 535     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 536
 537         oldState = nb->_dragging;
 538
 539         nb->_dragging = TRUE;
 540         nb->_entryModified( csel, colorbook );
 541
 542         nb->_dragging = oldState;
 543 }
 544
 545 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
 546 {
 547     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 548     nb->_released();
 549 }
 550
 551 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
 552 {
 553         gboolean oldState;
 554     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 555
 556         oldState = nb->_dragging;
 557
 558         nb->_dragging = FALSE;
 559         nb->_entryModified( csel, colorbook );
 560
 561         nb->_dragging = oldState;
 562 }
 563
 564 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
 565 {
 566         g_return_if_fail (colorbook != NULL);
 567         g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
 568         g_return_if_fail (csel != NULL);
 569         g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
 570
 571     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 572     SPColor color;
 573     gfloat alpha = 1.0;
 574
 575     csel->base->getColorAlpha( color, &alpha );
 576     nb->_updateRgbaEntry( color, alpha );
 577     nb->_updateInternals( color, alpha, nb->_dragging );
 578 }
 579
 580 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
 581 {
 582         GtkWidget *page;
 583
 584         page = sp_color_selector_new( page_type );
 585         if ( page )
 586         {
 587                 GtkWidget* tab_label = 0;
 588                 SPColorSelector* csel;
 589
 590                 csel = SP_COLOR_SELECTOR (page);
 591                 if ( submode > 0 )
 592                 {
 593                         csel->base->setSubmode( submode );
 594                 }
 595                 gtk_widget_show (page);
 596         int index = csel->base ? csel->base->getSubmode() : 0;
 597         const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
 598 //         g_message( "Hitting up for tab for '%s'", str );
 599                 tab_label = gtk_label_new(_(str));
 600                 gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
 601                 gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
 602                 gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
 603                 gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
 604                 gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
 605         }
 606
 607         return page;
 608 }
 609
 610 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
 611 {
 612         gint count = 0;
 613         gint i = 0;
 614         GtkWidget* page = 0;
 615
 616 //        count = gtk_notebook_get_n_pages (_book);
 617         count = 200;
 618         for ( i = 0; i < count && !page; i++ )
 619         {
 620                 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
 621                 if ( page )
 622                 {
 623                         SPColorSelector* csel;
 624                         guint pagemode;
 625                         csel = SP_COLOR_SELECTOR (page);
 626                         pagemode = csel->base->getSubmode();
 627                         if ( G_TYPE_FROM_INSTANCE (page) == page_type
 628                                  && pagemode == submode )
 629                         {
 630                                 // found it.
 631                                 break;
 632                         }
 633                         else
 634                         {
 635                                 page = 0;
 636                         }
 637                 }
 638                 else
 639                 {
 640                         break;
 641                 }
 642         }
 643         return page;
 644 }
 645
 646 void ColorNotebook::removePage( GType page_type, guint submode )
 647 {
 648         GtkWidget *page = 0;
 649
 650         page = getPage(page_type, submode);
 651         if ( page )
 652         {
 653                 gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
 654                 if ( where >= 0 )
 655                 {
 656                         if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
 657                         {
 658 //                 getColorAlpha(_color, &_alpha);
 659                         }
 660                         gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
 661                 }
 662         }
 663 }
 664
 665 /*
 666   Local Variables:
 667   mode:c++
 668   c-file-style:"stroustrup"
 669   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 670   indent-tabs-mode:nil
 671   fill-column:99
 672   End:
 673 */
 674 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :