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         /* Create color management icons */
 333         _box_colormanaged = gtk_event_box_new ();
 334         GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
 335         gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged);
 336         GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
 337         gtk_tooltips_set_tip (tooltips_colormanaged, _box_colormanaged, _("Color Managed"), "");
 338         gtk_widget_set_sensitive (_box_colormanaged, false);
 339         gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, TRUE, FALSE, 2);
 340
 341         _box_outofgamut = gtk_event_box_new ();
 342         GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
 343         gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut);
 344         GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
 345         gtk_tooltips_set_tip (tooltips_outofgamut, _box_outofgamut, _("Out of gamut!"), "");
 346         gtk_widget_set_sensitive (_box_outofgamut, false);
 347         gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, TRUE, FALSE, 2);
 348
 349         /* Create RGBA entry and color preview */
 350         _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
 351         gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
 352         gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
 353
 354         _rgbae = gtk_entry_new ();
 355         sp_dialog_defocus_on_enter (_rgbae);
 356         gtk_entry_set_max_length (GTK_ENTRY (_rgbae), 8);
 357         gtk_entry_set_width_chars (GTK_ENTRY (_rgbae), 8);
 358         gtk_tooltips_set_tip (tt, _rgbae, _("Hexadecimal RGBA value of the color"), NULL);
 359         gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
 360         gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
 361
 362         sp_set_font_size_smaller (rgbabox);
 363         gtk_widget_show_all (rgbabox);
 364         gtk_table_attach (GTK_TABLE (table), rgbabox, 1, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
 365
 366 #ifdef SPCS_PREVIEW
 367         _p = sp_color_preview_new (0xffffffff);
 368         gtk_widget_show (_p);
 369         gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 370 #endif
 371
 372         _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
 373                                                                 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
 374
 375         _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
 376 }
 377
 378 static void
 379 sp_color_notebook_destroy (GtkObject *object)
 380 {
 381         if (((GtkObjectClass *) (parent_class))->destroy)
 382                 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
 383 }
 384
 385 ColorNotebook::~ColorNotebook()
 386 {
 387         if ( _trackerList )
 388         {
 389                 g_ptr_array_free (_trackerList, TRUE);
 390                 _trackerList = 0;
 391         }
 392
 393         if ( _switchId )
 394         {
 395                 if ( _book )
 396                 {
 397                         g_signal_handler_disconnect (_book, _switchId);
 398                         _switchId = 0;
 399                 }
 400         }
 401 }
 402
 403 static void
 404 sp_color_notebook_show_all (GtkWidget *widget)
 405 {
 406         gtk_widget_show (widget);
 407 }
 408
 409 static void
 410 sp_color_notebook_hide_all (GtkWidget *widget)
 411 {
 412         gtk_widget_hide (widget);
 413 }
 414
 415 GtkWidget *
 416 sp_color_notebook_new (void)
 417 {
 418         SPColorNotebook *colorbook;
 419
 420         colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
 421
 422         return GTK_WIDGET (colorbook);
 423 }
 424
 425 ColorNotebook::ColorNotebook( SPColorSelector* csel )
 426     : ColorSelector( csel )
 427 {
 428 }
 429
 430 SPColorSelector* ColorNotebook::getCurrentSelector()
 431 {
 432     SPColorSelector* csel = NULL;
 433     gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
 434
 435     if ( current_page >= 0 )
 436     {
 437         GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
 438         if ( SP_IS_COLOR_SELECTOR (widget) )
 439         {
 440             csel = SP_COLOR_SELECTOR (widget);
 441         }
 442     }
 443
 444     return csel;
 445 }
 446
 447 void ColorNotebook::_colorChanged()
 448 {
 449     SPColorSelector* cselPage = getCurrentSelector();
 450     if ( cselPage )
 451     {
 452         cselPage->base->setColorAlpha( _color, _alpha );
 453     }
 454
 455     _updateRgbaEntry( _color, _alpha );
 456 }
 457
 458 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
 459 {
 460     ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
 461 }
 462
 463 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
 464 {
 465     if (_updating) return;
 466     if (_updatingrgba) return;
 467
 468     const gchar *t = gtk_entry_get_text( entry );
 469
 470     if (t) {
 471         Glib::ustring text = t;
 472         bool changed = false;
 473         if (!text.empty() && text[0] == '#') {
 474             changed = true;
 475             text.erase(0,1);
 476             if (text.size() == 6) {
 477                 // it was a standard RGB hex
 478                 unsigned int alph = SP_COLOR_F_TO_U(_alpha);
 479                 gchar* tmp = g_strdup_printf("%02x", alph);
 480                 text += tmp;
 481                 g_free(tmp);
 482             }
 483         }
 484         gchar* str = g_strdup(text.c_str());
 485         gchar* end = 0;
 486         guint64 rgba = g_ascii_strtoull( str, &end, 16 );
 487         if ( end != str ) {
 488             ptrdiff_t len = end - str;
 489             if ( len < 8 ) {
 490                 rgba = rgba << ( 4 * ( 8 - len ) );
 491             }
 492             _updatingrgba = TRUE;
 493             if ( changed ) {
 494                 gtk_entry_set_text( entry, str );
 495             }
 496             SPColor color( rgba );
 497             setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
 498             _updatingrgba = FALSE;
 499         }
 500         g_free(str);
 501     }
 502 }
 503
 504 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
 505 {
 506     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 507
 508     /* update color management icon*/
 509     gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
 510
 511     /* update out-of-gamut icon */
 512     gtk_widget_set_sensitive (_box_outofgamut, false);
 513     if (color.icc){
 514         BYTE outofgamut;
 515         cmsSetAlarmCodes(255, 255, 255);
 516         static cmsHPROFILE hNULL = cmsCreateNULLProfile();
 517         static cmsHPROFILE hsRGB = cmsCreate_sRGBProfile();
 518
 519         cmsHTRANSFORM trans;
 520         Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
 521         if ( target_profile ) {
 522             trans = cmsCreateProofingTransform(hsRGB, TYPE_RGB_DBL, hNULL, TYPE_GRAY_8, target_profile->profHandle,
 523              INTENT_RELATIVE_COLORIMETRIC, INTENT_RELATIVE_COLORIMETRIC, (cmsFLAGS_GAMUTCHECK|cmsFLAGS_SOFTPROOFING));
 524
 525             if ( trans ) {
 526                 guint32 val = color.toRGBA32(0);
 527                 guchar check_color[4] = {
 528                     SP_RGBA32_R_U(val),
 529                     SP_RGBA32_G_U(val),
 530                     SP_RGBA32_B_U(val),
 531                     255};
 532
 533                 cmsDoTransform(trans, &check_color, &outofgamut, 1);
 534                 gtk_widget_set_sensitive (_box_outofgamut, outofgamut == 255);
 535             }
 536         }
 537     }
 538
 539
 540     if ( !_updatingrgba )
 541     {
 542         gchar s[32];
 543         guint32 rgba;
 544
 545         /* Update RGBA entry */
 546         rgba = color.toRGBA32( alpha );
 547
 548         g_snprintf (s, 32, "%08x", rgba);
 549         const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
 550         if ( strcmp( oldText, s ) != 0 )
 551         {
 552             g_signal_handler_block( _rgbae, _entryId );
 553             gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
 554             g_signal_handler_unblock( _rgbae, _entryId );
 555         }
 556     }
 557 }
 558
 559 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
 560 {
 561     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 562     nb->_grabbed();
 563 }
 564
 565 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
 566 {
 567         gboolean oldState;
 568     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 569
 570         oldState = nb->_dragging;
 571
 572         nb->_dragging = TRUE;
 573         nb->_entryModified( csel, colorbook );
 574
 575         nb->_dragging = oldState;
 576 }
 577
 578 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
 579 {
 580     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 581     nb->_released();
 582 }
 583
 584 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
 585 {
 586         gboolean oldState;
 587     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 588
 589         oldState = nb->_dragging;
 590
 591         nb->_dragging = FALSE;
 592         nb->_entryModified( csel, colorbook );
 593
 594         nb->_dragging = oldState;
 595 }
 596
 597 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
 598 {
 599         g_return_if_fail (colorbook != NULL);
 600         g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
 601         g_return_if_fail (csel != NULL);
 602         g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
 603
 604     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 605     SPColor color;
 606     gfloat alpha = 1.0;
 607
 608     csel->base->getColorAlpha( color, &alpha );
 609     nb->_updateRgbaEntry( color, alpha );
 610     nb->_updateInternals( color, alpha, nb->_dragging );
 611 }
 612
 613 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
 614 {
 615         GtkWidget *page;
 616
 617         page = sp_color_selector_new( page_type );
 618         if ( page )
 619         {
 620                 GtkWidget* tab_label = 0;
 621                 SPColorSelector* csel;
 622
 623                 csel = SP_COLOR_SELECTOR (page);
 624                 if ( submode > 0 )
 625                 {
 626                         csel->base->setSubmode( submode );
 627                 }
 628                 gtk_widget_show (page);
 629         int index = csel->base ? csel->base->getSubmode() : 0;
 630         const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
 631 //         g_message( "Hitting up for tab for '%s'", str );
 632                 tab_label = gtk_label_new(_(str));
 633                 gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
 634                 gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
 635                 gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
 636                 gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
 637                 gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
 638         }
 639
 640         return page;
 641 }
 642
 643 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
 644 {
 645         gint count = 0;
 646         gint i = 0;
 647         GtkWidget* page = 0;
 648
 649 //        count = gtk_notebook_get_n_pages (_book);
 650         count = 200;
 651         for ( i = 0; i < count && !page; i++ )
 652         {
 653                 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
 654                 if ( page )
 655                 {
 656                         SPColorSelector* csel;
 657                         guint pagemode;
 658                         csel = SP_COLOR_SELECTOR (page);
 659                         pagemode = csel->base->getSubmode();
 660                         if ( G_TYPE_FROM_INSTANCE (page) == page_type
 661                                  && pagemode == submode )
 662                         {
 663                                 // found it.
 664                                 break;
 665                         }
 666                         else
 667                         {
 668                                 page = 0;
 669                         }
 670                 }
 671                 else
 672                 {
 673                         break;
 674                 }
 675         }
 676         return page;
 677 }
 678
 679 void ColorNotebook::removePage( GType page_type, guint submode )
 680 {
 681         GtkWidget *page = 0;
 682
 683         page = getPage(page_type, submode);
 684         if ( page )
 685         {
 686                 gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
 687                 if ( where >= 0 )
 688                 {
 689                         if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
 690                         {
 691 //                 getColorAlpha(_color, &_alpha);
 692                         }
 693                         gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
 694                 }
 695         }
 696 }
 697
 698 /*
 699   Local Variables:
 700   mode:c++
 701   c-file-style:"stroustrup"
 702   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 703   indent-tabs-mode:nil
 704   fill-column:99
 705   End:
 706 */
 707 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :