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

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file widget_gradient.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_gradient.h"
  33 #include "app.h"
  34 #include <gtkmm/menu.h>
  35 #include <synfig/exception.h>
  36 #include <ETL/misc>
  37
  38 #endif
  39
  40 /* === U S I N G =========================================================== */
  41
  42 using namespace std;
  43 using namespace etl;
  44 using namespace synfig;
  45 using namespace studio;
  46
  47 /* === M A C R O S ========================================================= */
  48
  49 /* === G L O B A L S ======================================================= */
  50
  51 /* === P R O C E D U R E S ================================================= */
  52
  53 void
  54 studio::render_gradient_to_window(const Glib::RefPtr<Gdk::Drawable>& window,const Gdk::Rectangle& ca,const synfig::Gradient &gradient)
  55 {
  56         int     height = ca.get_height();
  57         int     width = ca.get_width()-4;
  58
  59         float sample_width(1.0f/(float)width);
  60         Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(window));
  61         const Color bg1(0.25, 0.25, 0.25);
  62         const Color bg2(0.5, 0.5, 0.5);
  63         Gdk::Color gdk_c;
  64         int i;
  65         for(i=0;i<width;i++)
  66         {
  67                 const Color c(gradient(float(i)/float(width),sample_width));
  68                 const Color c1(Color::blend(c,bg1,1.0).clamped());
  69                 const Color c2(Color::blend(c,bg2,1.0).clamped());
  70                 gushort r1(256*App::gamma.r_F32_to_U8(c1.get_r()));
  71                 gushort g1(256*App::gamma.g_F32_to_U8(c1.get_g()));
  72                 gushort b1(256*App::gamma.b_F32_to_U8(c1.get_b()));
  73                 gushort r2(256*App::gamma.r_F32_to_U8(c2.get_r()));
  74                 gushort g2(256*App::gamma.g_F32_to_U8(c2.get_g()));
  75                 gushort b2(256*App::gamma.b_F32_to_U8(c2.get_b()));
  76
  77                 if((i*2/height)&1)
  78                 {
  79                         gdk_c.set_rgb(r1,g1,b1);
  80                         gc->set_rgb_fg_color(gdk_c);
  81                         window->draw_rectangle(gc, true, ca.get_x()+i+2, ca.get_y(), 1, height/2);
  82
  83                         gdk_c.set_rgb(r2,g2,b2);
  84                         gc->set_rgb_fg_color(gdk_c);
  85                         window->draw_rectangle(gc, true, ca.get_x()+i+2, ca.get_y()+height/2, 1, height/2);
  86                 }
  87                 else
  88                 {
  89                         gdk_c.set_rgb(r2,g2,b2);
  90                         gc->set_rgb_fg_color(gdk_c);
  91                         window->draw_rectangle(gc, true, ca.get_x()+i+2, ca.get_y(), 1, height/2);
  92
  93                         gdk_c.set_rgb(r1,g1,b1);
  94                         gc->set_rgb_fg_color(gdk_c);
  95                         window->draw_rectangle(gc, true, ca.get_x()+i+2, ca.get_y()+height/2, 1, height/2);
  96                 }
  97         }
  98         gc->set_rgb_fg_color(Gdk::Color("#ffffff"));
  99         window->draw_rectangle(gc, false, ca.get_x()+1, ca.get_y()+1, ca.get_width()-3, height-3);
 100         gc->set_rgb_fg_color(Gdk::Color("#000000"));
 101         window->draw_rectangle(gc, false, ca.get_x(), ca.get_y(), ca.get_width()-1, height-1);
 102 }
 103
 104 /* === M E T H O D S ======================================================= */
 105
 106 Widget_Gradient::Widget_Gradient():
 107         editable_(false)
 108 {
 109         set_size_request(-1,64);
 110         signal_expose_event().connect(sigc::mem_fun(*this, &studio::Widget_Gradient::redraw));
 111         add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
 112         add_events(Gdk::BUTTON1_MOTION_MASK);
 113
 114 }
 115
 116 Widget_Gradient::~Widget_Gradient()
 117 {
 118 }
 119
 120 #define CONTROL_HEIGHT          16
 121 bool
 122 Widget_Gradient::redraw(GdkEventExpose */*bleh*/)
 123 {
 124         const int h(get_height());
 125         const int w(get_width());
 126
 127         Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(get_window()));
 128         Gdk::Rectangle area(0,0,w,h);
 129         if(!editable_)
 130         {
 131                 render_gradient_to_window(get_window(),area,gradient_);
 132                 return true;
 133         }
 134
 135         render_gradient_to_window(get_window(),Gdk::Rectangle(0,0,w,h-CONTROL_HEIGHT),gradient_);
 136
 137         gc->set_rgb_fg_color(Gdk::Color("#7f7f7f"));
 138         get_window()->draw_rectangle(gc, false, 0, h-CONTROL_HEIGHT, w, CONTROL_HEIGHT);
 139
 140         Gradient::iterator iter,selected_iter;
 141         bool show_selected(false);
 142         for(iter=gradient_.begin();iter!=gradient_.end();iter++)
 143         {
 144                 if(*iter!=selected_cpoint)
 145                 get_style()->paint_arrow(
 146                         get_window(),
 147                         (*iter==selected_cpoint)?Gtk::STATE_SELECTED:Gtk::STATE_ACTIVE,
 148                         Gtk::SHADOW_OUT,
 149                         area,
 150                         *this,
 151                         " ",
 152                         Gtk::ARROW_UP,
 153                         1,
 154                         int(iter->pos*w)-CONTROL_HEIGHT/2+1,
 155                         h-CONTROL_HEIGHT,
 156                         CONTROL_HEIGHT,
 157                         CONTROL_HEIGHT
 158                 );
 159                 else
 160                 {
 161                         selected_iter=iter;
 162                         show_selected=true;
 163                 }
 164         }
 165
 166         // we do this so that we can be sure that
 167         // the selected marker is shown on top
 168         if(show_selected)
 169         {
 170                 get_style()->paint_arrow(
 171                         get_window(),
 172                         Gtk::STATE_SELECTED,
 173                         Gtk::SHADOW_OUT,
 174                         area,
 175                         *this,
 176                         " ",
 177                         Gtk::ARROW_UP,
 178                         1,
 179                         round_to_int(selected_iter->pos*w)-CONTROL_HEIGHT/2+1,
 180                         h-CONTROL_HEIGHT,
 181                         CONTROL_HEIGHT,
 182                         CONTROL_HEIGHT
 183                 );
 184         }
 185
 186         return true;
 187 }
 188
 189 void
 190 Widget_Gradient::insert_cpoint(float x)
 191 {
 192         Gradient::CPoint new_cpoint;
 193         new_cpoint.pos=x;
 194         new_cpoint.color=gradient_(x);
 195         gradient_.push_back(new_cpoint);
 196         gradient_.sort();
 197         gradient_.sort();
 198         set_selected_cpoint(new_cpoint);
 199         queue_draw();
 200 }
 201
 202 void
 203 Widget_Gradient::remove_cpoint(float x)
 204 {
 205         gradient_.erase(gradient_.proximity(x));
 206         signal_value_changed_();
 207         queue_draw();
 208 }
 209
 210 void
 211 Widget_Gradient::popup_menu(float x)
 212 {
 213         Gtk::Menu* menu(manage(new Gtk::Menu()));
 214
 215         menu->items().clear();
 216
 217         menu->items().push_back(
 218                 Gtk::Menu_Helpers::MenuElem(
 219                         _("Insert CPoint"),
 220                         sigc::bind(
 221                                 sigc::mem_fun(*this,&studio::Widget_Gradient::insert_cpoint),
 222                                 x
 223                         )
 224                 )
 225         );
 226
 227         if(!gradient_.empty())
 228         {
 229                 menu->items().push_back(
 230                         Gtk::Menu_Helpers::MenuElem(
 231                                 _("Remove CPoint"),
 232                                 sigc::bind(
 233                                         sigc::mem_fun(*this,&studio::Widget_Gradient::remove_cpoint),
 234                                         x
 235                                 )
 236                         )
 237                 );
 238         }
 239
 240         menu->popup(0,0);
 241 }
 242
 243 void
 244 Widget_Gradient::set_value(const synfig::Gradient& x)
 245 {
 246         gradient_=x;
 247         if(gradient_.size())
 248                 set_selected_cpoint(*gradient_.proximity(0.0f));
 249         queue_draw();
 250 }
 251
 252 void
 253 Widget_Gradient::set_selected_cpoint(const synfig::Gradient::CPoint &x)
 254 {
 255         selected_cpoint=x;
 256         signal_cpoint_selected_(selected_cpoint);
 257         queue_draw();
 258 }
 259
 260 void
 261 Widget_Gradient::update_cpoint(const synfig::Gradient::CPoint &x)
 262 {
 263         try
 264         {
 265                 Gradient::iterator iter(gradient_.find(x));
 266                 iter->pos=x.pos;
 267                 iter->color=x.color;
 268                 gradient_.sort();
 269                 queue_draw();
 270         }
 271         catch(synfig::Exception::NotFound)
 272         {
 273                 // Yotta...
 274         }
 275 }
 276
 277 bool
 278 Widget_Gradient::on_event(GdkEvent *event)
 279 {
 280         //if(editable_)
 281         {
 282                 const int x(static_cast<int>(event->button.x));
 283                 const int y(static_cast<int>(event->button.y));
 284
 285                 float pos((float)x/(float)get_width());
 286                 if(pos<0.0f)pos=0.0f;
 287                 if(pos>1.0f)pos=1.0f;
 288
 289                 switch(event->type)
 290                 {
 291                 case GDK_MOTION_NOTIFY:
 292                         if(editable_ && y>get_height()-CONTROL_HEIGHT)
 293                         {
 294                                 Gradient::iterator iter(gradient_.find(selected_cpoint));
 295
 296                                 if(event->button.state&GDK_SHIFT_MASK)
 297                                 {
 298                                         float begin(-100000000),end(100000000);
 299                                         Gradient::iterator before(iter),after(iter);
 300                                         after++;
 301                                         if(iter!=gradient_.begin())
 302                                         {
 303                                                 before--;
 304                                                 begin=before->pos;
 305                                         }
 306                                         if(after!=gradient_.end())
 307                                         {
 308                                                 end=after->pos;
 309                                         }
 310
 311                                         if(pos>end)
 312                                                 pos=end;
 313                                         if(pos<begin)
 314                                                 pos=begin;
 315
 316                                         iter->pos=pos;
 317                                 }
 318                                 else
 319                                 {
 320                                         iter->pos=pos;
 321                                         gradient_.sort();
 322                                 }
 323
 324 //                              signal_value_changed_();
 325                                 changed_=true;
 326                                 queue_draw();
 327                                 return true;
 328                         }
 329                         break;
 330                 case GDK_BUTTON_PRESS:
 331                         changed_=false;
 332                         if(event->button.button==1)
 333                         {
 334                                 if(editable_ && y>get_height()-CONTROL_HEIGHT)
 335                                 {
 336                                         set_selected_cpoint(*gradient_.proximity(pos));
 337                                         queue_draw();
 338                                         return true;
 339                                 }
 340                                 else
 341                                 {
 342                                         signal_clicked_();
 343                                         return true;
 344                                 }
 345                         }
 346                         else if(editable_ && event->button.button==3)
 347                         {
 348                                 popup_menu(pos);
 349                                 return true;
 350                         }
 351                         break;
 352                 case GDK_BUTTON_RELEASE:
 353                         if(editable_ && event->button.button==1 && y>get_height()-CONTROL_HEIGHT)
 354                         {
 355                                 set_selected_cpoint(*gradient_.proximity(pos));
 356                                 if(changed_)signal_value_changed_();
 357                                 return true;
 358                         }
 359                 default:
 360                         break;
 361                 }
 362         }
 363
 364         return false;
 365 }