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