*/
#include <gtkmm/box.h>
+#include "gtkmm2ext/widget_state.h"
namespace Gtkmm2ext {
virtual std::string drag_text () const = 0;
/** Set the child's visual state */
- virtual void set_visual_state (Gtk::StateType) = 0;
+ virtual void set_visual_state (VisualState, bool onoff) = 0;
};
/** A VBox whose contents can be dragged and dropped */
class DnDVBox : public Gtk::EventBox
{
public:
- DnDVBox () : _active (0), _drag_icon (0), _expecting_unwanted_button_event (false), _drag_placeholder (0)
+ DnDVBox () : _active (0), _drag_icon (0), _expecting_unwanted_button_event (false), _placeholder (0)
{
_targets.push_back (Gtk::TargetEntry ("processor"));
Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK
);
- 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));
+ 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));
return _selection;
}
- /** Set the `active' child; this is simply a child which is set to have the Gtk
- * STATE_ACTIVE for whatever purposes the client may have.
+ /** 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) {
}
}
- /** @param Child
+ /** @param child Child
* @return true if the child is selected, otherwise false.
*/
bool selected (T* child) const {
SelectionChanged (); /* EMIT SIGNAL */
}
+ /** @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*, double> get_child_at_position (int y) const
+ {
+ 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;
+ }
+ }
+
+ /** 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;
+
+ /** A button has been pressed over the widget */
+ sigc::signal<bool, GdkEventButton*, T*> ButtonPress;
+
+ /** A button has been release over the widget */
+ sigc::signal<bool, GdkEventButton*, T*> ButtonRelease;
+
+ /** A child has been dropped onto this DnDVBox from another one;
+ * 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> 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.
/* top of current child */
double top = 0;
/* bottom of current child */
- double bottom = (*j)->widget().get_allocation().get_height ();
+ double bottom = bottom_of_child_ignoring_placeholder (*j);
while (y >= bottom && j != _children.end()) {
++j;
if (j != _children.end()) {
- bottom += (*j)->widget().get_allocation().get_height ();
+ bottom = bottom_of_child_ignoring_placeholder (*j);
}
}
++j;
*after = j != _children.end() ? *j : 0;
- return i + ((y - top) / (*at)->widget().get_allocation().get_height());
- }
-
- /** @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*, double> get_child_at_position (int y) const
- {
- T* before;
- T* after;
-
- std::pair<T*, double> r;
-
- r.second = get_children_around_position (y, &before, &r.first, &after);
-
- return r;
+ return i + ((y - top) / (bottom - top));
}
- void set_spacing (int s) {
- _internal_vbox.set_spacing (s);
- }
-
- /** Children have been reordered by a drag */
- sigc::signal<void> Reordered;
-
- /** A button has been pressed over the widget */
- sigc::signal<bool, GdkEventButton*, T*> ButtonPress;
-
- /** A button has been release over the widget */
- sigc::signal<bool, GdkEventButton*, T*> ButtonRelease;
-
- /** A child has been dropped onto this DnDVBox from another one;
- * 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> SelectionChanged;
-
-private:
void drag_begin (Glib::RefPtr<Gdk::DragContext> const & context, T* child)
{
_drag_child = child;
Glib::RefPtr<Gdk::Colormap const> c = s->get_rgba_colormap ();
if (c) {
_drag_icon->set_colormap (c);
- _have_alpha = true;
- } else {
- _have_alpha = false;
}
int w, h;
}
/* Draw the drag icon */
- bool icon_expose (GdkEventExpose* ev)
+ bool icon_expose (GdkEventExpose*)
{
/* Just grab the child's widget and use that */
}
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*, double> const drop = get_child_at_position (y);
-
-
if (_drag_source == this) {
_drag_icon = 0;
_drag_child = 0;
- remove_drag_placeholder ();
+ remove_placeholder ();
Reordered (); /* EMIT SIGNAL */
}
- void remove_drag_placeholder ()
+ /** 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 (_drag_placeholder) {
- _internal_vbox.remove (*_drag_placeholder);
- _drag_placeholder = 0;
+ 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 &, int x, int y, guint)
+ bool drag_motion (Glib::RefPtr<Gdk::DragContext> const &, int /*x*/, int y, guint)
{
if (_children.empty ()) {
return false;
/* whether we're in the top or bottom half of the child that we're over */
bool top_half = (c - int (c)) < 0.5;
- if (top_half && (before == _drag_child || at == _drag_child)) {
+ /* 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_drag_placeholder ();
+ remove_placeholder ();
return false;
}
- if (!top_half && (at == _drag_child || after == _drag_child)) {
+ if (!top_half && _drag_child && (at == _drag_child || after == _drag_child)) {
/* dropping here would have no effect, so remove the visual cue */
- remove_drag_placeholder ();
+ remove_placeholder ();
return false;
}
- /* the index that the placeholder should be put at */
- int const n = int (c + 0.5);
-
- if (_drag_placeholder == 0) {
- _drag_placeholder = manage (new Gtk::Label (""));
- _internal_vbox.pack_start (*_drag_placeholder, false, false);
- _drag_placeholder->show ();
- }
-
- if (c < 0) {
- _internal_vbox.reorder_child (*_drag_placeholder, -1);
- } else {
- _internal_vbox.reorder_child (*_drag_placeholder, n);
- }
-
+ create_or_update_placeholder (c);
return false;
}
void drag_leave (Glib::RefPtr<Gdk::DragContext> const &, guint)
{
- remove_drag_placeholder ();
+ remove_placeholder ();
}
bool button_press (GdkEventButton* ev, T* child)
}
}
-
return ButtonPress (ev, child); /* EMIT SIGNAL */
}
return ButtonRelease (ev, child); /* EMIT SIGNAL */
}
- /** Setup a child's GTK state correctly */
+ /** Setup a child's visual state correctly */
void setup_child_state (T* c)
{
assert (c);
-
- if (c == _active) {
- c->set_visual_state (Gtk::STATE_ACTIVE);
- } else if (selected (c)) {
- c->set_visual_state (Gtk::STATE_SELECTED);
- } else {
- c->set_visual_state (Gtk::STATE_NORMAL);
- }
+ c->set_visual_state (Selected, (selected (c) || (_active == c)));
}
void clear_selection ()
{
typename std::list<T*>::iterator x = find (_selection.begin(), _selection.end(), child);
if (x != _selection.end()) {
+ T* c = *x;
_selection.erase (x);
- setup_child_state (*x);
+ setup_child_state (c);
}
}
T* _active;
Gtk::Window* _drag_icon;
bool _expecting_unwanted_button_event;
- /** A blank label used as a placeholder to indicate where a dragged item would
- * go if it were dropped now.
+ /** A blank label used as a placeholder to indicate where an item would
+ * go if it were dropped or inserted "now".
*/
- Gtk::Label* _drag_placeholder;
+ Gtk::Label* _placeholder;
/** Our child being dragged, or 0 */
T* _drag_child;
- /** true if we can have an alpha-blended drag icon */
- bool _have_alpha;
static DnDVBox* _drag_source;
projects / ardour.git / blobdiff