mirrors
/
fltk
mirror of https://github.com/fltk/fltk
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
fltk/examples/draggable-group.cxx

271 lines
8.0 KiB
C++
Raw Blame History

//
// Demonstrate deriving a class with draggable children.
//
// Copyright 2017 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file. If this
// file is missing or damaged, see the license at:
//
// https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
// https://www.fltk.org/bugs.php
//
// K Dmitrij <kdiman@...> wrote on Wed, 26 Jul 2017 19:54:12 +0000 in
// fltk.general, thread "[fltk.general] Draggable Group for examples FLTK":
//
// "Here is class for drag widgets and/or their children inside its parent
// widget. You can include it into examples of FLTK (and to adapt/modify
// if needs)".
//
// Thanks to Dmitrij for this contribution.
// Use `fltk-config --compile draggable-group.cxx' to build this example.
#include <FL/Fl.H>
#include <FL/Fl_Double_Window.H>
#include <FL/Fl_Box.H>
#include <FL/Fl_Button.H>
#include <stdio.h>
/** \class DraggableGroup
\brief Class with draggable children, derived from Fl_Group.
Use this class if you want the user to be able to drag the children
of a group inside the borders of the group. DraggableGroup widgets
can be nested, but only direct children of the DraggableGroup widget
can be dragged.
Design decisions:
- Widgets can be dragged with the right mouse button.
This was chosen to avoid conflicts with other mouse button
events such as clicking a button.
- The dragged widget is raised to the top within its group for better
visual feedback while dragging by making it the last child of the group.
- The order of widgets is restored when the mouse button is released.
This can result in hiding the widget behind another widget, but this
was chosen to keep the order given by the programmer. If this
is not desired it can be changed easily.
*/
class DraggableGroup : public Fl_Group {
protected:
int xoff, yoff; // start offsets while dragging
int drag_index; // index of dragged child
Fl_Widget *drag_widget; // dragged child widget
public:
DraggableGroup(int X, int Y, int W, int H, const char *L = 0)
: Fl_Group(X, Y, W, H, L)
, xoff(0)
, yoff(0)
, drag_index(0)
, drag_widget(0) {
box(FL_UP_BOX);
}
/** Raise the dragged widget to the top (last child) of its group.
This ensures that the widget is always visible while it is dragged.
The original index is saved in 'drag_index' and restored when the
mouse button is released.
\internal
Since we allow only direct children of the DraggableGroup widget
to be dragged the argument 'q' is always a child of 'this'.
Note: add(q) first removes the widget from its parent group ('this')
and then adds it again as its last child.
This is the same as insert(*q, children()).
*/
void top_level(Fl_Widget *q) {
drag_index = find(q); // save the widget's current index
add(q); // raise to top (make it the last child)
}
/** Handle FL_PUSH, FL_DRAG, and FL_RELEASE events.
All other events are handled in Fl_Group::handle().
Dragged widgets are limited inside the borders of their parent group.
*/
int handle(int e) FL_OVERRIDE {
switch (e) {
case FL_PUSH: {
if (Fl::event_button() == FL_RIGHT_MOUSE) {
if (Fl::belowmouse()->parent() == this) {
drag_widget = Fl::belowmouse();
// save pointer offsets relative to drag_widget's x/y position
xoff = Fl::event_x() - drag_widget->x();
yoff = Fl::event_y() - drag_widget->y();
top_level(drag_widget); // raise to top for visible feedback
redraw();
return 1;
}
}
break;
}
case FL_DRAG: {
if (!drag_widget)
break;
int nX = Fl::event_x() - xoff; // new x coordinate
int nY = Fl::event_y() - yoff; // new y coordinate
int bbx = Fl::box_dx(box()); // left and right border width
int bby = Fl::box_dy(box()); // top and bottom border width
// keep the widget inside its parent's borders
if (nX < x() + bbx) {
nX = x() + bbx;
} else if (nX + drag_widget->w() > x() + w() - bbx) {
nX = x() + w() - drag_widget->w() - bbx;
}
if (nY < y() + bby) {
nY = y() + bby;
} else if (nY + drag_widget->h() > y() + h() - bby) {
nY = y() + h() - drag_widget->h() - bby;
}
drag_widget->position(nX, nY); // set the new position
redraw();
return 1;
}
case FL_RELEASE: {
if (drag_widget && Fl::event_button() == FL_RIGHT_MOUSE) {
// Optional: restore the original widget order in the group.
// Remove the next statement (or comment it out) if not desired.
insert(*drag_widget, drag_index);
init_sizes(); // save widget positions for later resizing
drag_widget = 0;
redraw();
if (parent())
parent()->redraw();
return 1;
}
break;
}
default:
break;
} // switch(e)
return Fl_Group::handle(e);
}
};
// clear status message box after timeout
void clear_status(void *v) {
Fl_Box *status = (Fl_Box *)v;
status->label("");
status->redraw();
}
// button callback: display status message for two seconds
void button_cb(Fl_Widget *w, void *v) {
static char buf[128];
sprintf(buf, "button_cb: '%s'.\n", w->label());
Fl_Box *status = (Fl_Box *)v;
status->label(buf);
status->redraw();
Fl::remove_timeout(clear_status); // remove any pending timeout
Fl::add_timeout(2.0, clear_status, v);
}
// tooltips:
const char *tt_drag = "Drag this DraggableGroup and/or its child groups and squares. "
"Use the right mouse button (MB3) to drag objects.";
const char *tt_group = "You can drag this Fl_Group, but not its children (squares).";
const char *tt_button = "You can drag this button with the right mouse button "
"and you can click it with the left mouse button.";
// main program:
int main() {
Fl_Double_Window win(500, 500, "Drag children within their parent group");
DraggableGroup area(0, 0, 500, 400, "Use the right mouse button (MB3)\nto drag objects");
area.align(FL_ALIGN_INSIDE);
area.tooltip(tt_drag);
// draggable group inside draggable area
DraggableGroup dobj(5, 5, 140, 140, "DraggableGroup");
dobj.align(FL_ALIGN_INSIDE);
Fl_Box b1(25, 25, 20, 20);
b1.color(FL_RED);
b1.box(FL_FLAT_BOX);
Fl_Box b2(105, 105, 20, 20);
b2.color(FL_GREEN);
b2.box(FL_FLAT_BOX);
dobj.end();
dobj.tooltip(tt_drag);
// regular group inside draggable area
Fl_Group dobj2(5, 280, 110, 110, "Fl_Group");
dobj2.box(FL_DOWN_BOX);
dobj2.align(FL_ALIGN_INSIDE);
Fl_Box b3(15, 290, 20, 20);
b3.color(FL_BLUE);
b3.box(FL_FLAT_BOX);
Fl_Box b4(85, 360, 20, 20);
b4.color(FL_YELLOW);
b4.box(FL_FLAT_BOX);
dobj2.end();
dobj2.tooltip(tt_group);
// draggable group inside draggable area
DraggableGroup dobj3(245, 5, 150, 150, "DraggableGroup");
dobj3.align(FL_ALIGN_INSIDE);
dobj3.tooltip(tt_drag);
// nested draggable group
DraggableGroup dobj4(250, 10, 50, 50);
Fl_Box b5(255, 15, 15, 15);
b5.color(FL_BLACK);
b5.box(FL_FLAT_BOX);
Fl_Box b6(275, 30, 15, 15);
b6.color(FL_WHITE);
b6.box(FL_FLAT_BOX);
dobj4.end();
dobj4.tooltip(tt_drag);
dobj3.end();
Fl_Button button1(200, 350, 180, 40, "Fl_Button inside DraggableGroup");
button1.align(FL_ALIGN_INSIDE | FL_ALIGN_WRAP);
button1.tooltip(tt_button);
area.end();
Fl_Button button2(200, 410, 180, 40, "Fl_Button outside DraggableGroup");
button2.align(FL_ALIGN_INSIDE | FL_ALIGN_WRAP);
button2.tooltip("This is a normal button and can't be dragged.");
Fl_Box *status = new Fl_Box(0, 460, win.w(), 40, "Messages ...");
status->box(FL_DOWN_BOX);
button1.callback(button_cb, status);
button2.callback(button_cb, status);
win.end();
win.resizable(win);
win.show();
return Fl::run();
}
Reference in New Issue View Git Blame Copy Permalink