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 #if ENABLE_LCMS
 378         //the "too much ink" icon is initially hidden
 379         gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
 380 #endif //ENABLE_LCMS
 381
 382         gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
 383
 384 #ifdef SPCS_PREVIEW
 385         _p = sp_color_preview_new (0xffffffff);
 386         gtk_widget_show (_p);
 387         gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 388 #endif
 389
 390         _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
 391                                                                 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
 392
 393         _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
 394 }
 395
 396 static void
 397 sp_color_notebook_destroy (GtkObject *object)
 398 {
 399         if (((GtkObjectClass *) (parent_class))->destroy)
 400                 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
 401 }
 402
 403 ColorNotebook::~ColorNotebook()
 404 {
 405         if ( _trackerList )
 406         {
 407                 g_ptr_array_free (_trackerList, TRUE);
 408                 _trackerList = 0;
 409         }
 410
 411         if ( _switchId )
 412         {
 413                 if ( _book )
 414                 {
 415                         g_signal_handler_disconnect (_book, _switchId);
 416                         _switchId = 0;
 417                 }
 418         }
 419 }
 420
 421 static void
 422 sp_color_notebook_show_all (GtkWidget *widget)
 423 {
 424         gtk_widget_show (widget);
 425 }
 426
 427 static void
 428 sp_color_notebook_hide_all (GtkWidget *widget)
 429 {
 430         gtk_widget_hide (widget);
 431 }
 432
 433 GtkWidget *
 434 sp_color_notebook_new (void)
 435 {
 436         SPColorNotebook *colorbook;
 437
 438         colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
 439
 440         return GTK_WIDGET (colorbook);
 441 }
 442
 443 ColorNotebook::ColorNotebook( SPColorSelector* csel )
 444     : ColorSelector( csel )
 445 {
 446 }
 447
 448 SPColorSelector* ColorNotebook::getCurrentSelector()
 449 {
 450     SPColorSelector* csel = NULL;
 451     gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
 452
 453     if ( current_page >= 0 )
 454     {
 455         GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
 456         if ( SP_IS_COLOR_SELECTOR (widget) )
 457         {
 458             csel = SP_COLOR_SELECTOR (widget);
 459         }
 460     }
 461
 462     return csel;
 463 }
 464
 465 void ColorNotebook::_colorChanged()
 466 {
 467     SPColorSelector* cselPage = getCurrentSelector();
 468     if ( cselPage )
 469     {
 470         cselPage->base->setColorAlpha( _color, _alpha );
 471     }
 472
 473     _updateRgbaEntry( _color, _alpha );
 474 }
 475
 476 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
 477 {
 478     ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
 479 }
 480
 481 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
 482 {
 483     if (_updating) return;
 484     if (_updatingrgba) return;
 485
 486     const gchar *t = gtk_entry_get_text( entry );
 487
 488     if (t) {
 489         Glib::ustring text = t;
 490         bool changed = false;
 491         if (!text.empty() && text[0] == '#') {
 492             changed = true;
 493             text.erase(0,1);
 494             if (text.size() == 6) {
 495                 // it was a standard RGB hex
 496                 unsigned int alph = SP_COLOR_F_TO_U(_alpha);
 497                 gchar* tmp = g_strdup_printf("%02x", alph);
 498                 text += tmp;
 499                 g_free(tmp);
 500             }
 501         }
 502         gchar* str = g_strdup(text.c_str());
 503         gchar* end = 0;
 504         guint64 rgba = g_ascii_strtoull( str, &end, 16 );
 505         if ( end != str ) {
 506             ptrdiff_t len = end - str;
 507             if ( len < 8 ) {
 508                 rgba = rgba << ( 4 * ( 8 - len ) );
 509             }
 510             _updatingrgba = TRUE;
 511             if ( changed ) {
 512                 gtk_entry_set_text( entry, str );
 513             }
 514             SPColor color( rgba );
 515             setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
 516             _updatingrgba = FALSE;
 517         }
 518         g_free(str);
 519     }
 520 }
 521
 522 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
 523 {
 524     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 525
 526 #if ENABLE_LCMS
 527     /* update color management icon*/
 528     gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
 529
 530     /* update out-of-gamut icon */
 531     gtk_widget_set_sensitive (_box_outofgamut, false);
 532     if (color.icc){
 533         Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
 534         if ( target_profile )
 535             gtk_widget_set_sensitive (_box_outofgamut, target_profile->GamutCheck(color));
 536     }
 537
 538     /* update too-much-ink icon */
 539     gtk_widget_set_sensitive (_box_toomuchink, false);
 540     if (color.icc){
 541         Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
 542         if (prof->getColorSpace() == icSigCmykData || prof->getColorSpace() == icSigCmyData){
 543             gtk_widget_show(GTK_WIDGET(_box_toomuchink));
 544             double ink_sum = 0;
 545             for (unsigned int i=0; i<color.icc->colors.size(); i++){
 546                 ink_sum += color.icc->colors[i];
 547             }
 548
 549             /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color,
 550                 which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues
 551                 such as misalignment and poor quality of printing in general.*/
 552             if ( ink_sum > 3.2 )
 553                 gtk_widget_set_sensitive (_box_toomuchink, true);
 554         } else {
 555             gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
 556         }
 557     }
 558 #endif //ENABLE_LCMS
 559
 560     if ( !_updatingrgba )
 561     {
 562         gchar s[32];
 563         guint32 rgba;
 564
 565         /* Update RGBA entry */
 566         rgba = color.toRGBA32( alpha );
 567
 568         g_snprintf (s, 32, "%08x", rgba);
 569         const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
 570         if ( strcmp( oldText, s ) != 0 )
 571         {
 572             g_signal_handler_block( _rgbae, _entryId );
 573             gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
 574             g_signal_handler_unblock( _rgbae, _entryId );
 575         }
 576     }
 577 }
 578
 579 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
 580 {
 581     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 582     nb->_grabbed();
 583 }
 584
 585 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
 586 {
 587         gboolean oldState;
 588     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 589
 590         oldState = nb->_dragging;
 591
 592         nb->_dragging = TRUE;
 593         nb->_entryModified( csel, colorbook );
 594
 595         nb->_dragging = oldState;
 596 }
 597
 598 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
 599 {
 600     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 601     nb->_released();
 602 }
 603
 604 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
 605 {
 606         gboolean oldState;
 607     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 608
 609         oldState = nb->_dragging;
 610
 611         nb->_dragging = FALSE;
 612         nb->_entryModified( csel, colorbook );
 613
 614         nb->_dragging = oldState;
 615 }
 616
 617 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
 618 {
 619         g_return_if_fail (colorbook != NULL);
 620         g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
 621         g_return_if_fail (csel != NULL);
 622         g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
 623
 624     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 625     SPColor color;
 626     gfloat alpha = 1.0;
 627
 628     csel->base->getColorAlpha( color, &alpha );
 629     nb->_updateRgbaEntry( color, alpha );
 630     nb->_updateInternals( color, alpha, nb->_dragging );
 631 }
 632
 633 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
 634 {
 635         GtkWidget *page;
 636
 637         page = sp_color_selector_new( page_type );
 638         if ( page )
 639         {
 640                 GtkWidget* tab_label = 0;
 641                 SPColorSelector* csel;
 642
 643                 csel = SP_COLOR_SELECTOR (page);
 644                 if ( submode > 0 )
 645                 {
 646                         csel->base->setSubmode( submode );
 647                 }
 648                 gtk_widget_show (page);
 649         int index = csel->base ? csel->base->getSubmode() : 0;
 650         const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
 651 //         g_message( "Hitting up for tab for '%s'", str );
 652                 tab_label = gtk_label_new(_(str));
 653                 gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
 654                 gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
 655                 gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
 656                 gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
 657                 gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
 658         }
 659
 660         return page;
 661 }
 662
 663 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
 664 {
 665         gint count = 0;
 666         gint i = 0;
 667         GtkWidget* page = 0;
 668
 669 //        count = gtk_notebook_get_n_pages (_book);
 670         count = 200;
 671         for ( i = 0; i < count && !page; i++ )
 672         {
 673                 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
 674                 if ( page )
 675                 {
 676                         SPColorSelector* csel;
 677                         guint pagemode;
 678                         csel = SP_COLOR_SELECTOR (page);
 679                         pagemode = csel->base->getSubmode();
 680                         if ( G_TYPE_FROM_INSTANCE (page) == page_type
 681                                  && pagemode == submode )
 682                         {
 683                                 // found it.
 684                                 break;
 685                         }
 686                         else
 687                         {
 688                                 page = 0;
 689                         }
 690                 }
 691                 else
 692                 {
 693                         break;
 694                 }
 695         }
 696         return page;
 697 }
 698
 699 void ColorNotebook::removePage( GType page_type, guint submode )
 700 {
 701         GtkWidget *page = 0;
 702
 703         page = getPage(page_type, submode);
 704         if ( page )
 705         {
 706                 gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
 707                 if ( where >= 0 )
 708                 {
 709                         if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
 710                         {
 711 //                 getColorAlpha(_color, &_alpha);
 712                         }
 713                         gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
 714                 }
 715         }
 716 }
 717
 718 /*
 719   Local Variables:
 720   mode:c++
 721   c-file-style:"stroustrup"
 722   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 723   indent-tabs-mode:nil
 724   fill-column:99
 725   End:
 726 */
 727 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :