synfig-studio/tags/synfigstudio_0_61_07_rc1/src/gtkmm/widget_coloredit.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file widget_coloredit.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2007 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === H E A D E R S ======================================================= */
  25
  26 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "widget_coloredit.h"
  34 #include <cmath>
  35 #include "app.h"
  36 #include <gtkmm/drawingarea.h>
  37 #include <pangomm/attributes.h>
  38 #include <pangomm/attrlist.h>
  39 #include <algorithm>
  40 #include <gtkmm/notebook.h>
  41 #include <gtkmm/box.h>
  42
  43 #endif
  44
  45 /* === U S I N G =========================================================== */
  46
  47 using namespace std;
  48 using namespace etl;
  49 using namespace synfig;
  50 using namespace studio;
  51
  52 /* === M A C R O S ========================================================= */
  53
  54 /* === G L O B A L S ======================================================= */
  55
  56 /* === P R O C E D U R E S ================================================= */
  57
  58 /* === C L A S S E S ======================================================= */
  59
  60 ColorSlider::ColorSlider(const ColorSlider::Type &x):
  61         type(x)
  62 {
  63         signal_expose_event().connect(sigc::mem_fun(*this, &ColorSlider::redraw));
  64         set_size_request(-1,12);
  65         add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
  66         add_events(Gdk::BUTTON1_MOTION_MASK);
  67 }
  68
  69 void
  70 ColorSlider::set_type(Type x) { type=x; queue_draw(); }
  71
  72 void
  73 ColorSlider::set_color(Color x) { color_=x; queue_draw(); }
  74
  75 void
  76 ColorSlider::slider_color_TYPE_R(Color &color, float amount) { color.set_r(amount); }
  77 void
  78 ColorSlider::slider_color_TYPE_G(Color &color, float amount) { color.set_g(amount); }
  79 void
  80 ColorSlider::slider_color_TYPE_B(Color &color, float amount) { color.set_b(amount); }
  81 void
  82 ColorSlider::slider_color_TYPE_Y(Color &color, float amount) { color.set_y(amount); }
  83 void
  84 ColorSlider::slider_color_TYPE_U(Color &color, float amount) { color.set_u(amount-0.5f); }
  85 void
  86 ColorSlider::slider_color_TYPE_V(Color &color, float amount) { color.set_v(amount-0.5f); }
  87 void
  88 ColorSlider::slider_color_TYPE_HUE(Color &color, float amount) { color.set_uv_angle(Angle::rot(amount)); }
  89 void
  90 ColorSlider::slider_color_TYPE_SAT(Color &color, float amount) { color.set_s(amount*0.5f); }
  91 void
  92 ColorSlider::slider_color_TYPE_A(Color &color, float amount) { color.set_a(amount); }
  93
  94 void
  95 ColorSlider::adjust_color(Type type, Color &color, float amount)
  96 {
  97         static const slider_color_func jump_table[int(TYPE_END)] =
  98         {
  99                 slider_color_TYPE_R,
 100                 slider_color_TYPE_G,
 101                 slider_color_TYPE_B,
 102                 slider_color_TYPE_Y,
 103                 slider_color_TYPE_U,
 104                 slider_color_TYPE_V,
 105                 slider_color_TYPE_HUE,
 106                 slider_color_TYPE_SAT,
 107                 slider_color_TYPE_A,
 108         };
 109         jump_table[int(type)](color,amount);
 110 }
 111
 112 bool
 113 ColorSlider::redraw(GdkEventExpose */*bleh*/)
 114 {
 115         Color color(color_);
 116
 117         static const slider_color_func jump_table[int(TYPE_END)] =
 118         {
 119                 slider_color_TYPE_R,
 120                 slider_color_TYPE_G,
 121                 slider_color_TYPE_B,
 122                 slider_color_TYPE_Y,
 123                 slider_color_TYPE_U,
 124                 slider_color_TYPE_V,
 125                 slider_color_TYPE_HUE,
 126                 slider_color_TYPE_SAT,
 127                 slider_color_TYPE_A,
 128         };
 129
 130         slider_color_func color_func(jump_table[int(type)]);
 131
 132         float amount;
 133         switch(type)
 134         {
 135                 case TYPE_R: amount=color.get_r(); break;
 136                 case TYPE_G: amount=color.get_g(); break;
 137                 case TYPE_B: amount=color.get_b(); break;
 138                 case TYPE_Y: amount=color.get_y(); break;
 139                 case TYPE_U: amount=color.get_u()+0.5; break;
 140                 case TYPE_V: amount=color.get_v()+0.5; break;
 141                 case TYPE_HUE: amount=Angle::rot(color.get_uv_angle()).get(); amount-=floor(amount); break;
 142                 case TYPE_SAT: amount=color.get_s()*2.0; break;
 143                 case TYPE_A: amount=color.get_a(); break;
 144                 default: amount=0; break;
 145         }
 146         if(use_colorspace_gamma() && (type<TYPE_U))
 147                 amount=gamma_in(amount);
 148
 149         const int height(get_height());
 150         const int width(get_width());
 151
 152         Gdk::Rectangle ca(0,0,width,height);
 153
 154         Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(get_window()));
 155         const Color bg1(0.75, 0.75, 0.75);
 156         const Color bg2(0.5, 0.5, 0.5);
 157         int i;
 158         for(i=width-1;i>=0;i--)
 159         {
 160                 color_func(color,
 161                                    (use_colorspace_gamma() && type<TYPE_U)
 162                                    ? gamma_out(float(i)/float(width))
 163                                    :              (float(i)/float(width)));
 164                 const Color c1(Color::blend(color,bg1,1.0).clamped());
 165                 const Color c2(Color::blend(color,bg2,1.0).clamped());
 166                 assert(c1.is_valid());
 167                 assert(c2.is_valid());
 168
 169                 if((i*2/height)&1)
 170                 {
 171                         gc->set_rgb_fg_color(colorconv_synfig2gdk(c1));
 172                         get_window()->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y(), 1, height/2);
 173
 174                         gc->set_rgb_fg_color(colorconv_synfig2gdk(c2));
 175                         get_window()->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y()+height/2, 1, height/2);
 176                 }
 177                 else
 178                 {
 179                         gc->set_rgb_fg_color(colorconv_synfig2gdk(c2));
 180                         get_window()->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y(), 1, height/2);
 181
 182                         gc->set_rgb_fg_color(colorconv_synfig2gdk(c1));
 183                         get_window()->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y()+height/2, 1, height/2);
 184                 }
 185         }
 186
 187         get_style()->paint_arrow(
 188                 get_window(),
 189                 Gtk::STATE_SELECTED,
 190                 Gtk::SHADOW_OUT,
 191                 ca,
 192                 *this,
 193                 " ",
 194                 Gtk::ARROW_UP,
 195                 1,
 196                 int(amount*width)-height/2,
 197                 0,
 198                 height,
 199                 height
 200         );
 201
 202         gc->set_rgb_fg_color(Gdk::Color("#ffffff"));
 203         get_window()->draw_rectangle(gc, false, ca.get_x()+1, ca.get_y()+1, width-3, height-3);
 204         gc->set_rgb_fg_color(Gdk::Color("#000000"));
 205         get_window()->draw_rectangle(gc, false, ca.get_x(), ca.get_y(), width-1, height-1);
 206         return true;
 207 }
 208
 209 bool
 210 ColorSlider::on_event(GdkEvent *event)
 211 {
 212         float pos(event->button.x/(float)get_width());
 213         if(pos<0 || event->button.x<=0)pos=0;
 214         if(pos>1)pos=1;
 215
 216         if(use_colorspace_gamma() && (type<TYPE_U))
 217                 pos=gamma_out(pos);
 218         if(pos<0 || event->button.x<=0)pos=0;
 219         if(pos>1)pos=1;
 220
 221         switch(event->type)
 222         {
 223         case GDK_BUTTON_RELEASE:
 224                 signal_activated_();
 225                 return true;
 226
 227         case GDK_MOTION_NOTIFY:
 228 //              adjust_color(type,color_,pos);
 229                 signal_slider_moved_(type,pos);
 230                 queue_draw();
 231                 return true;
 232                 break;
 233         default:
 234                 break;
 235         }
 236         return false;
 237 }
 238
 239 /* === M E T H O D S ======================================================= */
 240
 241 Widget_ColorEdit::Widget_ColorEdit():
 242         R_adjustment(0,-10000000,10000000,1,10,0),
 243         G_adjustment(0,-10000000,10000000,1,10,0),
 244         B_adjustment(0,-10000000,10000000,1,10,0),
 245         A_adjustment(0,-10000000,10000000,1,10,0)
 246 {
 247         notebook=manage(new Gtk::Notebook);
 248
 249         Gtk::Table* rgb_table(manage(new Gtk::Table()));
 250         Gtk::Table* yuv_table(manage(new Gtk::Table()));
 251         Gtk::Table* main_table(this);
 252
 253         {
 254                 Gtk::VBox* rgb_box(manage(new Gtk::VBox()));
 255                 Gtk::VBox* yuv_box(manage(new Gtk::VBox()));
 256                 rgb_box->pack_start(*rgb_table,false,false);
 257                 yuv_box->pack_start(*yuv_table,false,false);
 258                 notebook->append_page(*rgb_box,_("RGB"));
 259                 notebook->append_page(*yuv_box,_("YUV"));
 260         }
 261
 262         color=Color(0,0,0,0);
 263
 264         set_size_request(150,-1);
 265         hold_signals=true;
 266
 267         Gtk::Label *label;
 268
 269         R_adjustment.set_lower(-10000000);
 270         G_adjustment.set_lower(-10000000);
 271         B_adjustment.set_lower(-10000000);
 272         A_adjustment.set_lower(-10000000);
 273
 274         clamp_=true;
 275
 276         Pango::AttrList attr_list;
 277         Pango::AttrInt pango_size(Pango::Attribute::create_attr_size(Pango::SCALE*7));
 278         pango_size.set_start_index(0);
 279         pango_size.set_end_index(64);
 280         attr_list.change(pango_size);
 281
 282         widget_color.set_size_request(-1,16);
 283         attach(widget_color, 0, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 284         attach(*notebook, 0, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 285
 286 #define SLIDER_ROW(i,n,l) \
 287         slider_##n=manage(new ColorSlider(ColorSlider::TYPE_##n));      \
 288         slider_##n->signal_slider_moved().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::on_slider_moved)); \
 289         /*slider_##n->signal_activated().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::activated));*/ \
 290         slider_##n->signal_activated().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::on_value_changed)); \
 291         label=manage(new class Gtk::Label(l,0.0,0.5)); \
 292         label->set_use_markup(false); \
 293         label->set_use_underline(false); \
 294         label->set_attributes(attr_list); \
 295         table->attach(*label, 0, 1, 1+2*i, 2+2*i, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);  \
 296         table->attach(*slider_##n, 0, 1, 2+2*i, 3+2*i, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0)
 297
 298 #define ATTACH_SPIN_BUTTON(i,n) \
 299         spinbutton_##n=manage(new class Gtk::SpinButton(n##_adjustment,1,0)); \
 300         spinbutton_##n->set_update_policy(Gtk::UPDATE_ALWAYS); \
 301         spinbutton_##n->set_size_request(48,-1); \
 302         spinbutton_##n->show(); \
 303         table->attach(*spinbutton_##n, 1, 2, 1+2*i, 3+2*i, Gtk::SHRINK, Gtk::EXPAND, 2, 0)
 304
 305         {
 306                 Gtk::Table* table(rgb_table);
 307                 SLIDER_ROW(0,R,_("Red"));
 308                 ATTACH_SPIN_BUTTON(0,R);
 309                 SLIDER_ROW(1,G,_("Green"));
 310                 ATTACH_SPIN_BUTTON(1,G);
 311                 SLIDER_ROW(2,B,_("Blue"));
 312                 ATTACH_SPIN_BUTTON(2,B);
 313
 314                 hex_color_label = manage(new Gtk::Label(_("HTML code"), 0.0, 0.5));
 315                 hex_color_label->set_use_markup(false);
 316                 hex_color_label->set_use_underline(false);
 317                 hex_color_label->set_attributes(attr_list);
 318                 table->attach(*hex_color_label, 0, 1, 7, 8, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 319
 320                 hex_color = manage(new Gtk::Entry());
 321                 hex_color->set_width_chars(8);
 322                 hex_color->signal_activate().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::on_hex_edited));
 323                 table->attach(*hex_color, 0, 1, 8, 9, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 324         }
 325         {
 326                 Gtk::Table* table(yuv_table);
 327                 SLIDER_ROW(0,Y,_("Luma"));
 328                 SLIDER_ROW(1,HUE,_("Hue"));
 329                 SLIDER_ROW(2,SAT,_("Saturation"));
 330                 SLIDER_ROW(3,U,_("U"));
 331                 SLIDER_ROW(4,V,_("V"));
 332         }
 333         {
 334                 Gtk::Table* table(main_table);
 335                 SLIDER_ROW(1,A,_("Alpha"));
 336                 ATTACH_SPIN_BUTTON(1,A);
 337         }
 338
 339 #undef SLIDER_ROW
 340 #undef ATTACH_SPIN_BUTTON
 341
 342         spinbutton_R->signal_activate().connect(sigc::mem_fun(*spinbutton_G,&Gtk::SpinButton::grab_focus));
 343         spinbutton_G->signal_activate().connect(sigc::mem_fun(*spinbutton_B,&Gtk::SpinButton::grab_focus));
 344         spinbutton_B->signal_activate().connect(sigc::mem_fun(*spinbutton_A,&Gtk::SpinButton::grab_focus));
 345         spinbutton_A->signal_activate().connect(sigc::mem_fun(*spinbutton_R,&Gtk::SpinButton::grab_focus));
 346
 347         R_adjustment.signal_value_changed().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::on_value_changed));
 348         G_adjustment.signal_value_changed().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::on_value_changed));
 349         B_adjustment.signal_value_changed().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::on_value_changed));
 350         A_adjustment.signal_value_changed().connect(sigc::mem_fun(*this,&studio::Widget_ColorEdit::on_value_changed));
 351
 352         show_all_children();
 353
 354         set_value(color);
 355
 356         hold_signals=false;
 357 }
 358
 359 Widget_ColorEdit::~Widget_ColorEdit()
 360 {
 361 }
 362
 363 void
 364 Widget_ColorEdit::on_slider_moved(ColorSlider::Type type, float amount)
 365 {
 366         Color color(get_value_raw());
 367
 368         assert(color.is_valid());
 369         ColorSlider::adjust_color(type,color,amount);
 370         assert(color.is_valid());
 371
 372         // If a non-primary colorslider is adjusted,
 373         // we want to make sure that we clamp
 374         if(type>ColorSlider::TYPE_B && (color.get_r()<0 ||color.get_g()<0 ||color.get_b()<0))
 375                 clamp_=true;
 376
 377         /*
 378         if(type==ColorSlider::TYPE_R && color.get_r()<0)clamp_=false;
 379         if(type==ColorSlider::TYPE_G && color.get_g()<0)clamp_=false;
 380         if(type==ColorSlider::TYPE_B && color.get_b()<0)clamp_=false;
 381         */
 382         clamp_=false;
 383
 384         set_value(color);
 385         assert(color.is_valid());
 386 }
 387
 388 void
 389 Widget_ColorEdit::on_hex_edited()
 390 {
 391         Color color(get_value_raw());
 392         String s = hex_color->get_text();
 393         color.set_hex(s);
 394         set_value(color);
 395         signal_value_changed_();
 396 }
 397
 398 void
 399 Widget_ColorEdit::on_value_changed()
 400 {
 401         if(hold_signals)
 402                 return;
 403
 404         const Color color(get_value_raw());
 405         assert(color.is_valid());
 406         slider_R->set_color(color);
 407         slider_G->set_color(color);
 408         slider_B->set_color(color);
 409         slider_Y->set_color(color);
 410         slider_U->set_color(color);
 411         slider_V->set_color(color);
 412         slider_HUE->set_color(color);
 413         slider_SAT->set_color(color);
 414         slider_A->set_color(color);
 415         hex_color->set_text(color.get_hex());
 416         widget_color.set_value(color);
 417
 418         activate();
 419         signal_value_changed_();
 420 }
 421
 422 void
 423 Widget_ColorEdit::set_has_frame(bool x)
 424 {
 425         spinbutton_R->set_has_frame(x);
 426         spinbutton_G->set_has_frame(x);
 427         spinbutton_B->set_has_frame(x);
 428         spinbutton_A->set_has_frame(x);
 429         spinbutton_R->set_size_request(48,-1);
 430         spinbutton_G->set_size_request(48,-1);
 431         spinbutton_B->set_size_request(48,-1);
 432         spinbutton_A->set_size_request(48,-1);
 433 }
 434
 435 void
 436 Widget_ColorEdit::set_digits(int x)
 437 {
 438         spinbutton_R->set_digits(x);
 439         spinbutton_G->set_digits(x);
 440         spinbutton_B->set_digits(x);
 441         spinbutton_A->set_digits(x);
 442         spinbutton_R->set_size_request(48,-1);
 443         spinbutton_G->set_size_request(48,-1);
 444         spinbutton_B->set_size_request(48,-1);
 445         spinbutton_A->set_size_request(48,-1);
 446 }
 447
 448 void
 449 Widget_ColorEdit::set_value(const synfig::Color &data)
 450 {
 451         assert(data.is_valid());
 452         hold_signals=true;
 453         clamp_=false;
 454
 455         color=data;
 456
 457         if(use_colorspace_gamma())
 458         {
 459                 R_adjustment.set_value(gamma_in(color.get_r())*100);
 460                 G_adjustment.set_value(gamma_in(color.get_g())*100);
 461                 B_adjustment.set_value(gamma_in(color.get_b())*100);
 462         }
 463         else
 464         {
 465                 R_adjustment.set_value(color.get_r()*100);
 466                 G_adjustment.set_value(color.get_g()*100);
 467                 B_adjustment.set_value(color.get_b()*100);
 468         }
 469         A_adjustment.set_value(color.get_a()*100);
 470
 471         slider_R->set_color(color);
 472         slider_G->set_color(color);
 473         slider_B->set_color(color);
 474         slider_Y->set_color(color);
 475         slider_U->set_color(color);
 476         slider_V->set_color(color);
 477         slider_HUE->set_color(color);
 478         slider_SAT->set_color(color);
 479         slider_A->set_color(color);
 480         hex_color->set_text(color.get_hex());
 481         widget_color.set_value(color);
 482
 483         hold_signals=false;
 484 }
 485
 486 synfig::Color
 487 Widget_ColorEdit::get_value_raw()
 488 {
 489         Color color;
 490         if(use_colorspace_gamma())
 491         {
 492                 color.set_r(gamma_out(R_adjustment.get_value()/100.0f));
 493                 color.set_g(gamma_out(G_adjustment.get_value()/100.0f));
 494                 color.set_b(gamma_out(B_adjustment.get_value()/100.0f));
 495         }
 496         else
 497         {
 498                 color.set_r(R_adjustment.get_value()/100);
 499                 color.set_g(G_adjustment.get_value()/100);
 500                 color.set_b(B_adjustment.get_value()/100);
 501         }
 502         color.set_a(A_adjustment.get_value()/100);
 503         assert(color.is_valid());
 504
 505         return color;
 506 }
 507
 508 const synfig::Color &
 509 Widget_ColorEdit::get_value()
 510 {
 511         if(use_colorspace_gamma())
 512         {
 513                 color.set_r(gamma_out(R_adjustment.get_value()/100.0f));
 514                 color.set_g(gamma_out(G_adjustment.get_value()/100.0f));
 515                 color.set_b(gamma_out(B_adjustment.get_value()/100.0f));
 516                 assert(color.is_valid());
 517         }
 518         else
 519         {
 520                 color.set_r(R_adjustment.get_value()/100);
 521                 color.set_g(G_adjustment.get_value()/100);
 522                 color.set_b(B_adjustment.get_value()/100);
 523                 assert(color.is_valid());
 524         }
 525         color.set_a(A_adjustment.get_value()/100);
 526         assert(color.is_valid());
 527
 528         if(notebook->get_current_page()!=0)
 529                 color=color.clamped();
 530
 531         /*{
 532                 // Clamp out negative values
 533                 color.set_r(std::max(0.0f,(float)color.get_r()));
 534                 color.set_g(std::max(0.0f,(float)color.get_g()));
 535                 color.set_b(std::max(0.0f,(float)color.get_b()));
 536         }*/
 537
 538         return color;
 539 }