synfig-studio/trunk/src/gtkmm/widget_coloredit.cpp

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