/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <gtkmm/box.h>
+#include "gtkmm2ext/visibility.h"
+#include "gtkmm2ext/widget_state.h"
+
namespace Gtkmm2ext {
-/** Parent class for children of a DnDVBox */
-class DnDVBoxChild
+/** Parent class for children of a DnDVBox */
+class /*LIBGTKMM2EXT_API*/ DnDVBoxChild
{
public:
virtual ~DnDVBoxChild () {}
-
+
/** @return The widget that is to be put into the DnDVBox */
virtual Gtk::Widget& widget () = 0;
-
+
/** @return An EventBox containing the widget that should be used for selection, dragging etc. */
virtual Gtk::EventBox& action_widget () = 0;
/** @return Text to use in the icon that is dragged */
virtual std::string drag_text () const = 0;
+
+ /** Set the child's visual state */
+ virtual void set_visual_state (VisualState, bool onoff) = 0;
+
+ /** @return True if the child can be selected in the list ( if you don't want it to copy/paste/drag then turn this off ) */
+ virtual bool is_selectable () const = 0;
+
+ virtual bool drag_data_get (Glib::RefPtr<Gdk::DragContext> const, Gtk::SelectionData &) { return false; }
+
+ virtual bool can_copy_state (DnDVBoxChild*) const = 0;
};
/** A VBox whose contents can be dragged and dropped */
template <class T>
-class DnDVBox : public Gtk::EventBox
+class /*LIBGTKMM2EXT_API*/ DnDVBox : public Gtk::EventBox
{
public:
- DnDVBox () : _drag_icon (0), _expecting_unwanted_button_event (false)
+ DnDVBox (std::list<Gtk::TargetEntry> targets)
+ : _targets (targets)
+ , _active (0)
+ , _drag_icon (0)
+ , _expecting_unwanted_button_event (false)
+ , _placeholder (0)
+ , _drag_child (0)
{
- _targets.push_back (Gtk::TargetEntry ("processor"));
add (_internal_vbox);
- add_events (Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK | Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
+ add_events (
+ Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK |
+ Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK |
+ Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK
+ );
+
+ signal_button_press_event().connect (sigc::bind (mem_fun (*this, &DnDVBox::button_press), (T *) 0));
+ signal_button_release_event().connect (sigc::bind (mem_fun (*this, &DnDVBox::button_release), (T *) 0));
+ signal_drag_motion().connect (mem_fun (*this, &DnDVBox::drag_motion));
+ signal_drag_leave().connect (mem_fun (*this, &DnDVBox::drag_leave));
- signal_button_press_event().connect (bind (mem_fun (*this, &DnDVBox::button_press), (T *) 0));
- signal_button_release_event().connect (bind (mem_fun (*this, &DnDVBox::button_release), (T *) 0));
-
- drag_dest_set (_targets);
+ _internal_vbox.show ();
+
+ drag_dest_set (_targets, Gtk::DEST_DEFAULT_ALL, Gdk::DragAction (Gdk::ACTION_COPY | Gdk::ACTION_MOVE | Gdk::ACTION_LINK));
signal_drag_data_received().connect (mem_fun (*this, &DnDVBox::drag_data_received));
}
-
+
virtual ~DnDVBox ()
{
clear ();
-
+
delete _drag_icon;
}
/** Add a child at the end of the widget. The DnDVBox will take responsibility for deleting the child */
- void add_child (T* child)
+ void add_child (T* child, std::list<Gtk::TargetEntry> targets = std::list<Gtk::TargetEntry>())
{
- child->action_widget().drag_source_set (_targets);
+ if (targets.empty ()) {
+ child->action_widget().drag_source_set (_targets);
+ } else {
+ child->action_widget().drag_source_set (targets);
+ }
child->action_widget().signal_drag_begin().connect (sigc::bind (mem_fun (*this, &DnDVBox::drag_begin), child));
child->action_widget().signal_drag_data_get().connect (sigc::bind (mem_fun (*this, &DnDVBox::drag_data_get), child));
child->action_widget().signal_drag_end().connect (sigc::bind (mem_fun (*this, &DnDVBox::drag_end), child));
child->action_widget().signal_button_press_event().connect (sigc::bind (mem_fun (*this, &DnDVBox::button_press), child));
child->action_widget().signal_button_release_event().connect (sigc::bind (mem_fun (*this, &DnDVBox::button_release), child));
-
+
_internal_vbox.pack_start (child->widget(), false, false);
-
+
_children.push_back (child);
- child->widget().show_all ();
+ child->widget().show ();
}
/** @return Children, sorted into the order that they are currently being displayed in the widget */
return _selection;
}
- /** @param Child
- * @return true if the child is selected, otherwise false */
+ /** Set the `active' child; this is simply a child which is set to have the
+ * visual state "active" for whatever purposes the client may have.
+ * @param c Child, or 0 for none.
+ */
+ void set_active (T* c) {
+ T* old_active = _active;
+ _active = c;
+ if (old_active) {
+ setup_child_state (old_active);
+ }
+ if (_active) {
+ setup_child_state (_active);
+ }
+ }
+
+ /** @param child Child
+ * @return true if the child is selected, otherwise false.
+ */
bool selected (T* child) const {
return (find (_selection.begin(), _selection.end(), child) != _selection.end());
}
}
_children.clear ();
+ _active = 0;
}
-
void select_all ()
{
clear_selection ();
SelectionChanged (); /* EMIT SIGNAL */
}
- /** @param x x coordinate.
- * @param y y coordinate.
- * @return Pair consisting of the child under (x, y) (or 0) and the index of the child under (x, y) (or -1)
+ /** @param y y coordinate.
+ * @return Pair consisting of the child under y (or 0) and the (fractional) index of the child under y (or -1)
*/
- std::pair<T*, int> get_child_at_position (int /*x*/, int y) const
+ std::pair<T*, double> get_child_at_position (int y) const
{
- std::list<Gtk::Widget const *> children = _internal_vbox.get_children ();
- std::list<Gtk::Widget const *>::iterator i = children.begin();
-
- int n = 0;
- while (i != children.end()) {
- Gdk::Rectangle const a = (*i)->get_allocation ();
- if (y >= a.get_y() && y <= (a.get_y() + a.get_height())) {
- break;
- }
- ++i;
- ++n;
- }
-
- if (i == children.end()) {
- return std::make_pair ((T *) 0, -1);
+ T* before;
+ T* after;
+
+ std::pair<T*, double> r;
+
+ r.second = get_children_around_position (y, &before, &r.first, &after);
+
+ return r;
+ }
+
+ void set_spacing (int s) {
+ _internal_vbox.set_spacing (s);
+ }
+
+ void remove_placeholder ()
+ {
+ if (_placeholder) {
+ _internal_vbox.remove (*_placeholder);
+ _placeholder = 0;
}
+ }
- return std::make_pair (child_from_widget (*i), n);
- }
+ /** Add a placeholder where a child would be put if it were added at the given y position.
+ * @param y y position within the DnDVBox.
+ * @return index of child that the placeholder represents, or -1 if it is at the end of all children.
+ */
+ int add_placeholder (double y)
+ {
+ return create_or_update_placeholder (get_child_at_position (y).second);
+ }
/** Children have been reordered by a drag */
sigc::signal<void> Reordered;
* Parameters are the source DnDVBox, our child which the other one was dropped on (or 0) and the DragContext.
*/
sigc::signal<void, DnDVBox*, T*, Glib::RefPtr<Gdk::DragContext> const & > DropFromAnotherBox;
+ sigc::signal<void, Gtk::SelectionData const &, T*, Glib::RefPtr<Gdk::DragContext> const & > DropFromExternal;
sigc::signal<void> SelectionChanged;
private:
+
+ /** @return the bottom y position of a child, pretending any placeholder
+ * is not there.
+ */
+ double bottom_of_child_ignoring_placeholder (T* child) const
+ {
+ Gtk::Allocation const a = child->widget().get_allocation ();
+ double bottom = a.get_y() + a.get_height();
+
+ if (_placeholder) {
+ Gtk::Allocation const b = _placeholder->get_allocation ();
+ if (b.get_y() < a.get_y()) {
+ bottom -= (b.get_height () + _internal_vbox.get_spacing ());
+ }
+ }
+
+ return bottom;
+ }
+
+ /** Look at a y coordinate and find the children below y, and the ones either side.
+ * @param y y position.
+ * @param before Filled in with the child before, or 0.
+ * @param at Filled in with the child under y, or 0.
+ * @param after Filled in with the child after, or 0.
+ * @return Fractional position in terms of child height, or -1 if not over a child.
+ */
+ double get_children_around_position (int y, T** before, T** at, T** after) const
+ {
+ if (_children.empty()) {
+ *before = *at = *after = 0;
+ return -1;
+ }
+
+ *before = 0;
+
+ typename std::list<T*>::const_iterator j = _children.begin ();
+
+ /* index of current child */
+ int i = 0;
+ /* top of current child */
+ double top = 0;
+ /* bottom of current child */
+ double bottom = bottom_of_child_ignoring_placeholder (*j);
+
+ while (y >= bottom && j != _children.end()) {
+
+ top = bottom;
+
+ *before = *j;
+ ++i;
+ ++j;
+
+ if (j != _children.end()) {
+ bottom = bottom_of_child_ignoring_placeholder (*j);
+ }
+ }
+
+ if (j == _children.end()) {
+ *at = 0;
+ *after = 0;
+ return -1;
+ }
+
+ *at = *j;
+
+ ++j;
+ *after = j != _children.end() ? *j : 0;
+
+ return i + ((y - top) / (bottom - top));
+ }
+
void drag_begin (Glib::RefPtr<Gdk::DragContext> const & context, T* child)
{
+ _drag_child = child;
+
/* make up an icon for the drag */
- Gtk::Window* _drag_icon = new Gtk::Window (Gtk::WINDOW_POPUP);
+ _drag_icon = new Gtk::Window (Gtk::WINDOW_POPUP);
+
+ Gtk::Allocation a = child->action_widget().get_allocation ();
+ _drag_icon->set_size_request (a.get_width(), a.get_height());
+
+ _drag_icon->signal_expose_event().connect (sigc::mem_fun (*this, &DnDVBox::icon_expose));
_drag_icon->set_name (get_name ());
- Gtk::Label* l = new Gtk::Label (child->drag_text ());
- l->set_padding (4, 4);
- _drag_icon->add (*Gtk::manage (l));
- _drag_icon->show_all_children ();
+
+ /* make the icon transparent if possible */
+ Glib::RefPtr<Gdk::Screen const> s = _drag_icon->get_screen ();
+ Glib::RefPtr<Gdk::Colormap const> c = s->get_rgba_colormap ();
+ if (c) {
+ _drag_icon->set_colormap (c);
+ }
+
int w, h;
_drag_icon->get_size (w, h);
- _drag_icon->drag_set_as_icon (context, w / 2, h);
-
+ _drag_icon->drag_set_as_icon (context, w / 2, h / 2);
+
_drag_source = this;
}
-
- void drag_data_get (Glib::RefPtr<Gdk::DragContext> const &, Gtk::SelectionData & selection_data, guint, guint, T* child)
+
+ /* Draw the drag icon */
+ bool icon_expose (GdkEventExpose*)
{
- selection_data.set (selection_data.get_target(), 8, (const guchar *) &child, sizeof (&child));
+ /* Just grab the child's widget and use that */
+
+ int w, h;
+ _drag_icon->get_size (w, h);
+
+ cairo_t* cr = gdk_cairo_create (_drag_icon->get_window()->gobj ());
+
+ Glib::RefPtr<Gdk::Pixmap> p = _drag_child->action_widget().get_snapshot();
+ gdk_cairo_set_source_pixmap (cr, p->gobj(), 0, 0);
+ cairo_rectangle (cr, 0, 0, w, h);
+ cairo_fill (cr);
+ cairo_destroy (cr);
+
+ return false;
+ }
+
+ void drag_data_get (Glib::RefPtr<Gdk::DragContext> const &context, Gtk::SelectionData & selection_data, guint, guint, T* child)
+ {
+ if (!child->drag_data_get(context, selection_data)) {
+ selection_data.set (selection_data.get_target(), 8, (const guchar *) &child, sizeof (&child));
+ }
}
-
+
void drag_data_received (
- Glib::RefPtr<Gdk::DragContext> const & context, int x, int y, Gtk::SelectionData const & selection_data, guint /*info*/, guint time
+ Glib::RefPtr<Gdk::DragContext> const & context, int /*x*/, int y, Gtk::SelectionData const & selection_data, guint /*info*/, guint time
)
{
/* work out where it was dropped */
- std::pair<T*, int> const drop = get_child_at_position (x, y);
-
+ std::pair<T*, double> const drop = get_child_at_position (y);
+
+ if (selection_data.get_target () != _targets.front ().get_target ()) {
+ DropFromExternal (selection_data, drop.first, context);
+ context->drag_finish (false, false, time);
+ return;
+ }
+
if (_drag_source == this) {
/* dropped from ourselves onto ourselves */
-
- T* child = *((T **) selection_data.get_data());
-
- /* reorder child widgets accordingly */
+
+ T* child = *((T * const *) selection_data.get_data());
+
if (drop.first == 0) {
_internal_vbox.reorder_child (child->widget(), -1);
} else {
- _internal_vbox.reorder_child (child->widget(), drop.second);
+
+ /* where in the list this child should be dropped */
+ int target = drop.second + 0.5;
+
+ /* find out whether the child was `picked up' from before the drop position */
+ int n = 0;
+ typename std::list<T*>::const_iterator i = _children.begin ();
+ while (i != _children.end() && *i != child && n < target) {
+ ++i;
+ ++n;
+ }
+
+ /* if so, adjust the drop position to account for this */
+ if (n < target) {
+ --target;
+ }
+
+ _internal_vbox.reorder_child (child->widget(), target);
}
-
+
} else {
-
+
/* drag started in another DnDVBox; raise a signal to say what happened */
-
+
std::list<T*> dropped = _drag_source->selection ();
DropFromAnotherBox (_drag_source, drop.first, context);
}
-
+
context->drag_finish (false, false, time);
}
-
+
void drag_end (Glib::RefPtr<Gdk::DragContext> const &, T *)
{
delete _drag_icon;
_drag_icon = 0;
+ _drag_child = 0;
+ remove_placeholder ();
+
Reordered (); /* EMIT SIGNAL */
}
-
+
+ /** Insert a placeholder at a given fractional child position, creating it if necessary.
+ * @param c Fractional child position.
+ * @return index of child that the placeholder represents, or -1 if it is at the end of all children.
+ */
+ int create_or_update_placeholder (double c)
+ {
+ if (_placeholder == 0) {
+ _placeholder = manage (new Gtk::Label (""));
+ _internal_vbox.pack_start (*_placeholder, false, false);
+ _placeholder->show ();
+ }
+
+ /* round up the index, unless we're off the end of the children */
+ int const n = c < 0 ? -1 : int (c + 0.5);
+ _internal_vbox.reorder_child (*_placeholder, n);
+ return n;
+ }
+
+ bool drag_motion (Glib::RefPtr<Gdk::DragContext> const & ctx, int /*x*/, int y, guint tme)
+ {
+ if (_children.empty ()) {
+ return false;
+ }
+
+ T* before;
+ T* at = NULL;
+ T* after;
+
+ /* decide where we currently are */
+ double const c = get_children_around_position (y, &before, &at, &after);
+
+ /* whether we're in the top or bottom half of the child that we're over */
+ bool top_half = (c - int (c)) < .5;
+ bool bottom_half = !top_half;
+
+ if (_drag_source != this /* re-order */
+ && _drag_source && at
+ && _drag_source->_drag_child
+ && _drag_source->selection ().size () == 1
+ && at != _drag_source->_drag_child // can't happen or can it?
+ && at->can_copy_state (_drag_source->_drag_child))
+ {
+ top_half = (c - int (c)) < 0.33;
+ bottom_half = (c - int (c)) > 0.8; // increase area >> 0.66; plugin below will move, or there's space
+ }
+
+ /* Note that when checking on whether to remove a placeholder, we never do
+ so if _drag_child is 0 as this means that the child being dragged is
+ coming from a different DnDVBox, so it will never be the same as any
+ of our children.
+ */
+
+ if (top_half && _drag_child && (before == _drag_child || at == _drag_child)) {
+ /* dropping here would have no effect, so remove the visual cue */
+ remove_placeholder ();
+ return false;
+ }
+
+ if (bottom_half && _drag_child && (at == _drag_child || after == _drag_child)) {
+ /* dropping here would have no effect, so remove the visual cue */
+ remove_placeholder ();
+ return false;
+ }
+
+ if (top_half || bottom_half) {
+ create_or_update_placeholder (c);
+ if (_drag_source == this /* re-order */) {
+ ctx->drag_status (Gdk::ACTION_MOVE, tme);
+ } else {
+ ctx->drag_status (Gdk::ACTION_COPY, tme);
+ }
+ } else {
+ ctx->drag_status (Gdk::ACTION_LINK, tme);
+ remove_placeholder ();
+ }
+ return true;
+ }
+
+ void drag_leave (Glib::RefPtr<Gdk::DragContext> const &, guint)
+ {
+ remove_placeholder ();
+ }
+
bool button_press (GdkEventButton* ev, T* child)
{
if (_expecting_unwanted_button_event == true && child == 0) {
if (child) {
_expecting_unwanted_button_event = true;
}
-
+
if (ev->button == 1 || ev->button == 3) {
+
if (!selected (child)) {
- clear_selection ();
- if (child) {
- add_to_selection (child);
+
+ if ((ev->state & Gdk::SHIFT_MASK) && !_selection.empty()) {
+
+ /* Shift-click; select all between the clicked child and any existing selections */
+
+ bool selecting = false;
+ bool done = false;
+ for (typename std::list<T*>::const_iterator i = _children.begin(); i != _children.end(); ++i) {
+
+ bool const was_selected = selected (*i);
+
+ if (selecting && !was_selected) {
+ add_to_selection (*i);
+ }
+
+ if (!selecting && !done) {
+ if (selected (*i)) {
+ selecting = true;
+ } else if (*i == child) {
+ selecting = true;
+ add_to_selection (child);
+ }
+ } else if (selecting) {
+ if (was_selected || *i == child) {
+ selecting = false;
+ done = true;
+ }
+ }
+ }
+
+ } else {
+
+ if ((ev->state & Gdk::CONTROL_MASK) == 0) {
+ clear_selection ();
+ }
+
+ if (child) {
+ add_to_selection (child);
+ }
+
}
+
SelectionChanged (); /* EMIT SIGNAL */
+
} else {
/* XXX THIS NEEDS GENERALIZING FOR OS X */
if (ev->button == 1 && (ev->state & Gdk::CONTROL_MASK)) {
}
}
-
return ButtonPress (ev, child); /* EMIT SIGNAL */
}
-
+
bool button_release (GdkEventButton* ev, T* child)
{
if (_expecting_unwanted_button_event == true && child == 0) {
return ButtonRelease (ev, child); /* EMIT SIGNAL */
}
+ /** Setup a child's visual state correctly */
+ void setup_child_state (T* c)
+ {
+ assert (c);
+ c->set_visual_state (Selected, (selected (c) || (_active == c)));
+ }
+
void clear_selection ()
{
- for (typename std::list<T*>::iterator i = _selection.begin(); i != _selection.end(); ++i) {
- (*i)->action_widget().set_state (Gtk::STATE_NORMAL);
- }
+ std::list<T*> old_selection = _selection;
_selection.clear ();
+ for (typename std::list<T*>::iterator i = old_selection.begin(); i != old_selection.end(); ++i) {
+ setup_child_state (*i);
+ }
}
-
+
void add_to_selection (T* child)
{
- child->action_widget().set_state (Gtk::STATE_SELECTED);
+ if ( !child->is_selectable() )
+ return;
_selection.push_back (child);
+ setup_child_state (child);
}
-
-
+
void remove_from_selection (T* child)
{
typename std::list<T*>::iterator x = find (_selection.begin(), _selection.end(), child);
if (x != _selection.end()) {
- child->action_widget().set_state (Gtk::STATE_NORMAL);
+ T* c = *x;
_selection.erase (x);
+ setup_child_state (c);
}
}
-
+
T* child_from_widget (Gtk::Widget const * w) const
{
typename std::list<T*>::const_iterator i = _children.begin();
while (i != _children.end() && &(*i)->widget() != w) {
++i;
}
-
+
if (i == _children.end()) {
return 0;
}
return *i;
}
-
+
Gtk::VBox _internal_vbox;
std::list<Gtk::TargetEntry> _targets;
std::list<T*> _children;
std::list<T*> _selection;
+ T* _active;
Gtk::Window* _drag_icon;
bool _expecting_unwanted_button_event;
+ /** A blank label used as a placeholder to indicate where an item would
+ * go if it were dropped or inserted "now".
+ */
+ Gtk::Label* _placeholder;
+ /** Our child being dragged, or 0 */
+ T* _drag_child;
static DnDVBox* _drag_source;
+
};
template <class T>
DnDVBox<T>* DnDVBox<T>::_drag_source = 0;
-
+
}
projects / ardour.git / blobdiff