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