1 #define __SP_COLOR_NOTEBOOK_C__
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 */
15 #undef SPCS_PREVIEW
16 #define noDUMP_CHANGE_INFO
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
22 #include <cstring>
23 #include <string>
24 #include <cstdlib>
25 #include <gtk/gtk.h>
26 #include <glibmm/i18n.h>
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"
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 };
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);
54 static void sp_color_notebook_show_all (GtkWidget *widget);
55 static void sp_color_notebook_hide_all (GtkWidget *widget);
57 static SPColorSelectorClass *parent_class;
59 #define XPAD 4
60 #define YPAD 1
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 }
83 static void
84 sp_color_notebook_class_init (SPColorNotebookClass *klass)
85 {
86 GtkObjectClass *object_class;
87 GtkWidgetClass *widget_class;
88 SPColorSelectorClass *selector_class;
90 object_class = (GtkObjectClass *) klass;
91 widget_class = (GtkWidgetClass *) klass;
92 selector_class = SP_COLOR_SELECTOR_CLASS (klass);
94 parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
96 object_class->destroy = sp_color_notebook_destroy;
98 widget_class->show_all = sp_color_notebook_show_all;
99 widget_class->hide_all = sp_color_notebook_hide_all;
100 }
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 );
113 // remember the page we seitched to
114 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
115 prefs->setInt("/colorselector/page", page_num);
116 }
117 }
119 void ColorNotebook::switchPage(GtkNotebook*,
120 GtkNotebookPage*,
121 guint page_num)
122 {
123 SPColorSelector* csel;
124 GtkWidget* widget;
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 );
137 // Temporary workaround to undo a spurious GRABBED
138 _released();
139 }
140 }
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 );
149 /* Tell calling code that we have handled this event; the buck
150 * stops here. */
151 return TRUE;
152 }
154 /* Tell calling code that we have not handled this event; pass it on. */
155 return FALSE;
156 }
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 }
166 static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
167 {
168 gboolean active = FALSE;
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 }
185 static void
186 sp_color_notebook_init (SPColorNotebook *colorbook)
187 {
188 SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) );
190 if ( SP_COLOR_SELECTOR(colorbook)->base )
191 {
192 SP_COLOR_SELECTOR(colorbook)->base->init();
193 }
194 }
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;
205 GtkTooltips *tt = gtk_tooltips_new ();
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
214 /* REJON: Comment out the next line to not use the normal GTK Color
215 wheel. */
217 // SP_TYPE_COLOR_GTKSELECTOR;
219 _updating = FALSE;
220 _updatingrgba = FALSE;
221 _btn = 0;
222 _popup = 0;
223 _trackerList = g_ptr_array_new ();
225 _book = gtk_notebook_new ();
226 gtk_widget_show (_book);
228 selector_types = g_type_children (SP_TYPE_COLOR_SELECTOR, &selector_type_count);
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);
253 g_ptr_array_add (_trackerList, entry);
254 }
255 }
256 }
257 }
258 }
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 }
270 table = gtk_table_new (2, 3, FALSE);
271 gtk_widget_show (table);
273 gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
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);
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));
284 {
285 gboolean found = FALSE;
287 _popup = gtk_menu_new();
288 GtkMenu *menu = GTK_MENU (_popup);
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);
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 }
307 GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
308 gtk_widget_show (arrow);
310 _btn = gtk_button_new ();
311 gtk_widget_show (_btn);
312 gtk_container_add (GTK_CONTAINER (_btn), arrow);
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);
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);
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 }
329 row++;
331 GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
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);
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);
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);
359 #endif //ENABLE_LCMS
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);
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);
374 sp_set_font_size_smaller (rgbabox);
375 gtk_widget_show_all (rgbabox);
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
382 gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
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
390 _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
391 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
393 _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
394 }
396 static void
397 sp_color_notebook_destroy (GtkObject *object)
398 {
399 if (((GtkObjectClass *) (parent_class))->destroy)
400 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
401 }
403 ColorNotebook::~ColorNotebook()
404 {
405 if ( _trackerList )
406 {
407 g_ptr_array_free (_trackerList, TRUE);
408 _trackerList = 0;
409 }
411 if ( _switchId )
412 {
413 if ( _book )
414 {
415 g_signal_handler_disconnect (_book, _switchId);
416 _switchId = 0;
417 }
418 }
419 }
421 static void
422 sp_color_notebook_show_all (GtkWidget *widget)
423 {
424 gtk_widget_show (widget);
425 }
427 static void
428 sp_color_notebook_hide_all (GtkWidget *widget)
429 {
430 gtk_widget_hide (widget);
431 }
433 GtkWidget *
434 sp_color_notebook_new (void)
435 {
436 SPColorNotebook *colorbook;
438 colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
440 return GTK_WIDGET (colorbook);
441 }
443 ColorNotebook::ColorNotebook( SPColorSelector* csel )
444 : ColorSelector( csel )
445 {
446 }
448 SPColorSelector* ColorNotebook::getCurrentSelector()
449 {
450 SPColorSelector* csel = NULL;
451 gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
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 }
462 return csel;
463 }
465 void ColorNotebook::_colorChanged()
466 {
467 SPColorSelector* cselPage = getCurrentSelector();
468 if ( cselPage )
469 {
470 cselPage->base->setColorAlpha( _color, _alpha );
471 }
473 _updateRgbaEntry( _color, _alpha );
474 }
476 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
477 {
478 ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
479 }
481 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
482 {
483 if (_updating) return;
484 if (_updatingrgba) return;
486 const gchar *t = gtk_entry_get_text( entry );
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 }
522 // TODO pass in param so as to avoid the need for SP_ACTIVE_DOCUMENT
523 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
524 {
525 g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
527 #if ENABLE_LCMS
528 /* update color management icon*/
529 gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
531 /* update out-of-gamut icon */
532 gtk_widget_set_sensitive (_box_outofgamut, false);
533 if (color.icc){
534 Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
535 if ( target_profile )
536 gtk_widget_set_sensitive (_box_outofgamut, target_profile->GamutCheck(color));
537 }
539 /* update too-much-ink icon */
540 gtk_widget_set_sensitive (_box_toomuchink, false);
541 if (color.icc){
542 Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
543 if ( prof && ( (prof->getColorSpace() == icSigCmykData) || (prof->getColorSpace() == icSigCmyData) ) ) {
544 gtk_widget_show(GTK_WIDGET(_box_toomuchink));
545 double ink_sum = 0;
546 for (unsigned int i=0; i<color.icc->colors.size(); i++){
547 ink_sum += color.icc->colors[i];
548 }
550 /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color,
551 which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues
552 such as misalignment and poor quality of printing in general.*/
553 if ( ink_sum > 3.2 )
554 gtk_widget_set_sensitive (_box_toomuchink, true);
555 } else {
556 gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
557 }
558 }
559 #endif //ENABLE_LCMS
561 if ( !_updatingrgba )
562 {
563 gchar s[32];
564 guint32 rgba;
566 /* Update RGBA entry */
567 rgba = color.toRGBA32( alpha );
569 g_snprintf (s, 32, "%08x", rgba);
570 const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
571 if ( strcmp( oldText, s ) != 0 )
572 {
573 g_signal_handler_block( _rgbae, _entryId );
574 gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
575 g_signal_handler_unblock( _rgbae, _entryId );
576 }
577 }
578 }
580 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
581 {
582 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
583 nb->_grabbed();
584 }
586 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
587 {
588 gboolean oldState;
589 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
591 oldState = nb->_dragging;
593 nb->_dragging = TRUE;
594 nb->_entryModified( csel, colorbook );
596 nb->_dragging = oldState;
597 }
599 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
600 {
601 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
602 nb->_released();
603 }
605 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
606 {
607 gboolean oldState;
608 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
610 oldState = nb->_dragging;
612 nb->_dragging = FALSE;
613 nb->_entryModified( csel, colorbook );
615 nb->_dragging = oldState;
616 }
618 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
619 {
620 g_return_if_fail (colorbook != NULL);
621 g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
622 g_return_if_fail (csel != NULL);
623 g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
625 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
626 SPColor color;
627 gfloat alpha = 1.0;
629 csel->base->getColorAlpha( color, alpha );
630 nb->_updateRgbaEntry( color, alpha );
631 nb->_updateInternals( color, alpha, nb->_dragging );
632 }
634 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
635 {
636 GtkWidget *page;
638 page = sp_color_selector_new( page_type );
639 if ( page )
640 {
641 GtkWidget* tab_label = 0;
642 SPColorSelector* csel;
644 csel = SP_COLOR_SELECTOR (page);
645 if ( submode > 0 )
646 {
647 csel->base->setSubmode( submode );
648 }
649 gtk_widget_show (page);
650 int index = csel->base ? csel->base->getSubmode() : 0;
651 const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
652 // g_message( "Hitting up for tab for '%s'", str );
653 tab_label = gtk_label_new(_(str));
654 gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
655 gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
656 gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
657 gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
658 gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
659 }
661 return page;
662 }
664 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
665 {
666 gint count = 0;
667 gint i = 0;
668 GtkWidget* page = 0;
670 // count = gtk_notebook_get_n_pages (_book);
671 count = 200;
672 for ( i = 0; i < count && !page; i++ )
673 {
674 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
675 if ( page )
676 {
677 SPColorSelector* csel;
678 guint pagemode;
679 csel = SP_COLOR_SELECTOR (page);
680 pagemode = csel->base->getSubmode();
681 if ( G_TYPE_FROM_INSTANCE (page) == page_type
682 && pagemode == submode )
683 {
684 // found it.
685 break;
686 }
687 else
688 {
689 page = 0;
690 }
691 }
692 else
693 {
694 break;
695 }
696 }
697 return page;
698 }
700 void ColorNotebook::removePage( GType page_type, guint submode )
701 {
702 GtkWidget *page = 0;
704 page = getPage(page_type, submode);
705 if ( page )
706 {
707 gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
708 if ( where >= 0 )
709 {
710 if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
711 {
712 // getColorAlpha(_color, &_alpha);
713 }
714 gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
715 }
716 }
717 }
719 /*
720 Local Variables:
721 mode:c++
722 c-file-style:"stroustrup"
723 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
724 indent-tabs-mode:nil
725 fill-column:99
726 End:
727 */
728 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :