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