libs/gtkmm2ext/gtkmm2ext/dndvbox.h

   1 /*
   2     Copyright (C) 2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <gtkmm/box.h>
  21 #include "gtkmm2ext/widget_state.h"
  22
  23 namespace Gtkmm2ext {
  24
  25 /** Parent class for children of a DnDVBox */
  26 class DnDVBoxChild
  27 {
  28 public:
  29         virtual ~DnDVBoxChild () {}
  30
  31         /** @return The widget that is to be put into the DnDVBox */
  32         virtual Gtk::Widget& widget () = 0;
  33
  34         /** @return An EventBox containing the widget that should be used for selection, dragging etc. */
  35         virtual Gtk::EventBox& action_widget () = 0;
  36
  37         /** @return Text to use in the icon that is dragged */
  38         virtual std::string drag_text () const = 0;
  39
  40         /** Set the child's visual state */
  41         virtual void set_visual_state (VisualState, bool onoff) = 0;
  42 };
  43
  44 /** A VBox whose contents can be dragged and dropped */
  45 template <class T>
  46 class DnDVBox : public Gtk::EventBox
  47 {
  48 public:
  49         DnDVBox () : _active (0), _drag_icon (0), _expecting_unwanted_button_event (false), _placeholder (0)
  50         {
  51                 _targets.push_back (Gtk::TargetEntry ("processor"));
  52
  53                 add (_internal_vbox);
  54                 add_events (
  55                         Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK |
  56                         Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK |
  57                         Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK
  58                         );
  59
  60                 signal_button_press_event().connect (bind (mem_fun (*this, &DnDVBox::button_press), (T *) 0));
  61                 signal_button_release_event().connect (bind (mem_fun (*this, &DnDVBox::button_release), (T *) 0));
  62                 signal_drag_motion().connect (mem_fun (*this, &DnDVBox::drag_motion));
  63                 signal_drag_leave().connect (mem_fun (*this, &DnDVBox::drag_leave));
  64
  65                 _internal_vbox.show ();
  66
  67                 drag_dest_set (_targets);
  68                 signal_drag_data_received().connect (mem_fun (*this, &DnDVBox::drag_data_received));
  69         }
  70
  71         virtual ~DnDVBox ()
  72         {
  73                 clear ();
  74
  75                 delete _drag_icon;
  76         }
  77
  78         /** Add a child at the end of the widget.  The DnDVBox will take responsibility for deleting the child */
  79         void add_child (T* child)
  80         {
  81                 child->action_widget().drag_source_set (_targets);
  82                 child->action_widget().signal_drag_begin().connect (sigc::bind (mem_fun (*this, &DnDVBox::drag_begin), child));
  83                 child->action_widget().signal_drag_data_get().connect (sigc::bind (mem_fun (*this, &DnDVBox::drag_data_get), child));
  84                 child->action_widget().signal_drag_end().connect (sigc::bind (mem_fun (*this, &DnDVBox::drag_end), child));
  85                 child->action_widget().signal_button_press_event().connect (sigc::bind (mem_fun (*this, &DnDVBox::button_press), child));
  86                 child->action_widget().signal_button_release_event().connect (sigc::bind (mem_fun (*this, &DnDVBox::button_release), child));
  87
  88                 _internal_vbox.pack_start (child->widget(), false, false);
  89
  90                 _children.push_back (child);
  91                 child->widget().show ();
  92         }
  93
  94         /** @return Children, sorted into the order that they are currently being displayed in the widget */
  95         std::list<T*> children ()
  96         {
  97                 std::list<T*> sorted_children;
  98
  99                 std::list<Gtk::Widget*> widget_children = _internal_vbox.get_children ();
 100                 for (std::list<Gtk::Widget*>::iterator i = widget_children.begin(); i != widget_children.end(); ++i) {
 101                         T* c = child_from_widget (*i);
 102
 103                         if (c) {
 104                                 sorted_children.push_back (c);
 105                         }
 106                 }
 107
 108                 return sorted_children;
 109         }
 110
 111         /** @return Selected children */
 112         std::list<T*> selection () const {
 113                 return _selection;
 114         }
 115
 116         /** Set the `active' child; this is simply a child which is set to have the Gtk
 117          *  STATE_ACTIVE for whatever purposes the client may have.
 118          *  @param c Child, or 0 for none.
 119          */
 120         void set_active (T* c) {
 121                 T* old_active = _active;
 122                 _active = c;
 123                 if (old_active) {
 124                         setup_child_state (old_active);
 125                 }
 126                 if (_active) {
 127                         setup_child_state (_active);
 128                 }
 129         }
 130
 131         /** @param child Child
 132          *  @return true if the child is selected, otherwise false.
 133          */
 134         bool selected (T* child) const {
 135                 return (find (_selection.begin(), _selection.end(), child) != _selection.end());
 136         }
 137
 138         /** Clear all children from the widget */
 139         void clear ()
 140         {
 141                 _selection.clear ();
 142
 143                 for (typename std::list<T*>::iterator i = _children.begin(); i != _children.end(); ++i) {
 144                         _internal_vbox.remove ((*i)->widget());
 145                         delete *i;
 146                 }
 147
 148                 _children.clear ();
 149                 _active = 0;
 150         }
 151
 152         void select_all ()
 153         {
 154                 clear_selection ();
 155                 for (typename std::list<T*>::iterator i = _children.begin(); i != _children.end(); ++i) {
 156                         add_to_selection (*i);
 157                 }
 158
 159                 SelectionChanged (); /* EMIT SIGNAL */
 160         }
 161
 162         void select_none ()
 163         {
 164                 clear_selection ();
 165
 166                 SelectionChanged (); /* EMIT SIGNAL */
 167         }
 168
 169         /** @param y y coordinate.
 170          *  @return Pair consisting of the child under y (or 0) and the (fractional) index of the child under y (or -1)
 171          */
 172         std::pair<T*, double> get_child_at_position (int y) const
 173         {
 174                 T* before;
 175                 T* after;
 176
 177                 std::pair<T*, double> r;
 178
 179                 r.second = get_children_around_position (y, &before, &r.first, &after);
 180
 181                 return r;
 182         }
 183
 184         void set_spacing (int s) {
 185                 _internal_vbox.set_spacing (s);
 186         }
 187
 188         void remove_placeholder ()
 189         {
 190                 if (_placeholder) {
 191                         _internal_vbox.remove (*_placeholder);
 192                         _placeholder = 0;
 193                 }
 194         }
 195
 196         /** Add a placeholder where a child would be put if it were added at the given y position.
 197          *  @param y y position within the DnDVBox.
 198          *  @return index of child that the placeholder represents, or -1 if it is at the end of all children.
 199          */
 200         int add_placeholder (double y)
 201         {
 202                 return create_or_update_placeholder (get_child_at_position (y).second);
 203         }
 204
 205         /** Children have been reordered by a drag */
 206         sigc::signal<void> Reordered;
 207
 208         /** A button has been pressed over the widget */
 209         sigc::signal<bool, GdkEventButton*, T*> ButtonPress;
 210
 211         /** A button has been release over the widget */
 212         sigc::signal<bool, GdkEventButton*, T*> ButtonRelease;
 213
 214         /** A child has been dropped onto this DnDVBox from another one;
 215          *  Parameters are the source DnDVBox, our child which the other one was dropped on (or 0) and the DragContext.
 216          */
 217         sigc::signal<void, DnDVBox*, T*, Glib::RefPtr<Gdk::DragContext> const & > DropFromAnotherBox;
 218         sigc::signal<void> SelectionChanged;
 219
 220 private:
 221
 222         /** Look at a y coordinate and find the children below y, and the ones either side.
 223          *  @param y y position.
 224          *  @param before Filled in with the child before, or 0.
 225          *  @param at Filled in with the child under y, or 0.
 226          *  @param after Filled in with the child after, or 0.
 227          *  @return Fractional position in terms of child height, or -1 if not over a child.
 228          */
 229         double get_children_around_position (int y, T** before, T** at, T** after) const
 230         {
 231                 if (_children.empty()) {
 232                         *before = *at = *after = 0;
 233                         return -1;
 234                 }
 235
 236                 *before = 0;
 237
 238                 typename std::list<T*>::const_iterator j = _children.begin ();
 239
 240                 /* index of current child */
 241                 int i = 0;
 242                 /* top of current child */
 243                 double top = 0;
 244                 /* bottom of current child */
 245                 Gtk::Allocation const a = (*j)->widget().get_allocation();
 246                 double bottom = a.get_y() + a.get_height();
 247
 248                 while (y >= bottom && j != _children.end()) {
 249
 250                         top = bottom;
 251
 252                         *before = *j;
 253                         ++i;
 254                         ++j;
 255
 256                         if (j != _children.end()) {
 257                                 Gtk::Allocation const a = (*j)->widget().get_allocation();
 258                                 bottom = a.get_y() + a.get_height();
 259                         }
 260                 }
 261
 262                 if (j == _children.end()) {
 263                         *at = 0;
 264                         *after = 0;
 265                         return -1;
 266                 }
 267
 268                 *at = *j;
 269
 270                 ++j;
 271                 *after = j != _children.end() ? *j : 0;
 272
 273                 return i + ((y - top) / (*at)->widget().get_allocation().get_height());
 274         }
 275
 276         void drag_begin (Glib::RefPtr<Gdk::DragContext> const & context, T* child)
 277         {
 278                 _drag_child = child;
 279
 280                 /* make up an icon for the drag */
 281                 _drag_icon = new Gtk::Window (Gtk::WINDOW_POPUP);
 282
 283                 Gtk::Allocation a = child->widget().get_allocation ();
 284                 _drag_icon->set_size_request (a.get_width(), a.get_height());
 285
 286                 _drag_icon->signal_expose_event().connect (sigc::mem_fun (*this, &DnDVBox::icon_expose));
 287                 _drag_icon->set_name (get_name ());
 288
 289                 /* make the icon transparent if possible */
 290                 Glib::RefPtr<Gdk::Screen const> s = _drag_icon->get_screen ();
 291                 Glib::RefPtr<Gdk::Colormap const> c = s->get_rgba_colormap ();
 292                 if (c) {
 293                         _drag_icon->set_colormap (c);
 294                 }
 295
 296                 int w, h;
 297                 _drag_icon->get_size (w, h);
 298                 _drag_icon->drag_set_as_icon (context, w / 2, h / 2);
 299
 300                 _drag_source = this;
 301         }
 302
 303         /* Draw the drag icon */
 304         bool icon_expose (GdkEventExpose*)
 305         {
 306                 /* Just grab the child's widget and use that */
 307
 308                 int w, h;
 309                 _drag_icon->get_size (w, h);
 310
 311                 cairo_t* cr = gdk_cairo_create (_drag_icon->get_window()->gobj ());
 312
 313                 Glib::RefPtr<Gdk::Pixmap> p = _drag_child->widget().get_snapshot();
 314                 gdk_cairo_set_source_pixmap (cr, p->gobj(), 0, 0);
 315                 cairo_rectangle (cr, 0, 0, w, h);
 316                 cairo_fill (cr);
 317                 cairo_destroy (cr);
 318
 319                 return false;
 320         }
 321
 322         void drag_data_get (Glib::RefPtr<Gdk::DragContext> const &, Gtk::SelectionData & selection_data, guint, guint, T* child)
 323         {
 324                 selection_data.set (selection_data.get_target(), 8, (const guchar *) &child, sizeof (&child));
 325         }
 326
 327         void drag_data_received (
 328                 Glib::RefPtr<Gdk::DragContext> const & context, int /*x*/, int y, Gtk::SelectionData const & selection_data, guint /*info*/, guint time
 329                 )
 330         {
 331                 /* work out where it was dropped */
 332                 std::pair<T*, double> const drop = get_child_at_position (y);
 333
 334                 if (_drag_source == this) {
 335
 336                         /* dropped from ourselves onto ourselves */
 337
 338                         T* child = *((T **) selection_data.get_data());
 339
 340                         if (drop.first == 0) {
 341                                 _internal_vbox.reorder_child (child->widget(), -1);
 342                         } else {
 343
 344                                 /* where in the list this child should be dropped */
 345                                 int target = drop.second + 0.5;
 346
 347                                 /* find out whether the child was `picked up' from before the drop position */
 348                                 int n = 0;
 349                                 typename std::list<T*>::const_iterator i = _children.begin ();
 350                                 while (i != _children.end() && *i != child && n < target) {
 351                                         ++i;
 352                                         ++n;
 353                                 }
 354
 355                                 /* if so, adjust the drop position to account for this */
 356                                 if (n < target) {
 357                                         --target;
 358                                 }
 359
 360                                 _internal_vbox.reorder_child (child->widget(), target);
 361                         }
 362
 363                 } else {
 364
 365                         /* drag started in another DnDVBox; raise a signal to say what happened */
 366
 367                         std::list<T*> dropped = _drag_source->selection ();
 368                         DropFromAnotherBox (_drag_source, drop.first, context);
 369                 }
 370
 371                 context->drag_finish (false, false, time);
 372         }
 373
 374         void drag_end (Glib::RefPtr<Gdk::DragContext> const &, T *)
 375         {
 376                 delete _drag_icon;
 377                 _drag_icon = 0;
 378
 379                 _drag_child = 0;
 380                 remove_placeholder ();
 381
 382                 Reordered (); /* EMIT SIGNAL */
 383         }
 384
 385         /** Insert a placeholder at a given fractional child position, creating it if necessary.
 386          *  @param c Fractional child position.
 387          *  @return index of child that the placeholder represents, or -1 if it is at the end of all children.
 388          */
 389         int create_or_update_placeholder (double c)
 390         {
 391                 if (_placeholder == 0) {
 392                         _placeholder = manage (new Gtk::Label (""));
 393                         _internal_vbox.pack_start (*_placeholder, false, false);
 394                         _placeholder->show ();
 395                 }
 396
 397                 /* round up the index, unless we're off the end of the children */
 398                 int const n = c < 0 ? -1 : int (c + 0.5);
 399                 _internal_vbox.reorder_child (*_placeholder, n);
 400                 return n;
 401         }
 402
 403         bool drag_motion (Glib::RefPtr<Gdk::DragContext> const &, int /*x*/, int y, guint)
 404         {
 405                 if (_children.empty ()) {
 406                         return false;
 407                 }
 408
 409                 T* before;
 410                 T* at;
 411                 T* after;
 412
 413                 /* decide where we currently are */
 414                 double const c = get_children_around_position (y, &before, &at, &after);
 415
 416                 /* whether we're in the top or bottom half of the child that we're over */
 417                 bool top_half = (c - int (c)) < 0.5;
 418
 419                 if (top_half && (before == _drag_child || at == _drag_child)) {
 420                         /* dropping here would have no effect, so remove the visual cue */
 421                         remove_placeholder ();
 422                         return false;
 423                 }
 424
 425                 if (!top_half && (at == _drag_child || after == _drag_child)) {
 426                         /* dropping here would have no effect, so remove the visual cue */
 427                         remove_placeholder ();
 428                         return false;
 429                 }
 430
 431                 create_or_update_placeholder (c);
 432                 return false;
 433         }
 434
 435         void drag_leave (Glib::RefPtr<Gdk::DragContext> const &, guint)
 436         {
 437                 remove_placeholder ();
 438         }
 439
 440         bool button_press (GdkEventButton* ev, T* child)
 441         {
 442                 if (_expecting_unwanted_button_event == true && child == 0) {
 443                         _expecting_unwanted_button_event = false;
 444                         return true;
 445                 }
 446
 447                 if (child) {
 448                         _expecting_unwanted_button_event = true;
 449                 }
 450
 451                 if (ev->button == 1 || ev->button == 3) {
 452
 453                         if (!selected (child)) {
 454
 455                                 if ((ev->state & Gdk::SHIFT_MASK) && !_selection.empty()) {
 456
 457                                         /* Shift-click; select all between the clicked child and any existing selections */
 458
 459                                         bool selecting = false;
 460                                         bool done = false;
 461                                         for (typename std::list<T*>::const_iterator i = _children.begin(); i != _children.end(); ++i) {
 462
 463                                                 bool const was_selected = selected (*i);
 464
 465                                                 if (selecting && !was_selected) {
 466                                                         add_to_selection (*i);
 467                                                 }
 468
 469                                                 if (!selecting && !done) {
 470                                                         if (selected (*i)) {
 471                                                                 selecting = true;
 472                                                         } else if (*i == child) {
 473                                                                 selecting = true;
 474                                                                 add_to_selection (child);
 475                                                         }
 476                                                 } else if (selecting) {
 477                                                         if (was_selected || *i == child) {
 478                                                                 selecting = false;
 479                                                                 done = true;
 480                                                         }
 481                                                 }
 482                                         }
 483
 484                                 } else {
 485
 486                                         if ((ev->state & Gdk::CONTROL_MASK) == 0) {
 487                                                 clear_selection ();
 488                                         }
 489
 490                                         if (child) {
 491                                                 add_to_selection (child);
 492                                         }
 493
 494                                 }
 495
 496                                 SelectionChanged (); /* EMIT SIGNAL */
 497
 498                         } else {
 499                                 /* XXX THIS NEEDS GENERALIZING FOR OS X */
 500                                 if (ev->button == 1 && (ev->state & Gdk::CONTROL_MASK)) {
 501                                         if (child && selected (child)) {
 502                                                 remove_from_selection (child);
 503                                                 SelectionChanged (); /* EMIT SIGNAL */
 504                                         }
 505                                 }
 506                         }
 507                 }
 508
 509                 return ButtonPress (ev, child); /* EMIT SIGNAL */
 510         }
 511
 512         bool button_release (GdkEventButton* ev, T* child)
 513         {
 514                 if (_expecting_unwanted_button_event == true && child == 0) {
 515                         _expecting_unwanted_button_event = false;
 516                         return true;
 517                 }
 518
 519                 if (child) {
 520                         _expecting_unwanted_button_event = true;
 521                 }
 522
 523                 return ButtonRelease (ev, child); /* EMIT SIGNAL */
 524         }
 525
 526         /** Setup a child's GTK state correctly */
 527         void setup_child_state (T* c)
 528         {
 529                 assert (c);
 530                 c->set_visual_state (Selected, selected (c));
 531         }
 532
 533         void clear_selection ()
 534         {
 535                 std::list<T*> old_selection = _selection;
 536                 _selection.clear ();
 537                 for (typename std::list<T*>::iterator i = old_selection.begin(); i != old_selection.end(); ++i) {
 538                         setup_child_state (*i);
 539                 }
 540         }
 541
 542         void add_to_selection (T* child)
 543         {
 544                 _selection.push_back (child);
 545                 setup_child_state (child);
 546         }
 547
 548         void remove_from_selection (T* child)
 549         {
 550                 typename std::list<T*>::iterator x = find (_selection.begin(), _selection.end(), child);
 551                 if (x != _selection.end()) {
 552                         _selection.erase (x);
 553                         setup_child_state (*x);
 554                 }
 555         }
 556
 557         T* child_from_widget (Gtk::Widget const * w) const
 558         {
 559                 typename std::list<T*>::const_iterator i = _children.begin();
 560                 while (i != _children.end() && &(*i)->widget() != w) {
 561                         ++i;
 562                 }
 563
 564                 if (i == _children.end()) {
 565                         return 0;
 566                 }
 567
 568                 return *i;
 569         }
 570
 571         Gtk::VBox _internal_vbox;
 572         std::list<Gtk::TargetEntry> _targets;
 573         std::list<T*> _children;
 574         std::list<T*> _selection;
 575         T* _active;
 576         Gtk::Window* _drag_icon;
 577         bool _expecting_unwanted_button_event;
 578         /** A blank label used as a placeholder to indicate where an item would
 579          *  go if it were dropped or inserted "now".
 580          */
 581         Gtk::Label* _placeholder;
 582         /** Our child being dragged, or 0 */
 583         T* _drag_child;
 584
 585         static DnDVBox* _drag_source;
 586
 587 };
 588
 589 template <class T>
 590 DnDVBox<T>* DnDVBox<T>::_drag_source = 0;
 591
 592 }