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