redirect_display.get_column(0)->set_sizing(TREE_VIEW_COLUMN_FIXED);
redirect_display.get_column(0)->set_fixed_width(48);
redirect_display.add_object_drag (columns.redirect.index(), "redirects");
- redirect_display.signal_object_drop.connect (mem_fun (*this, &RedirectBox::object_drop));
+ redirect_display.signal_drop.connect (mem_fun (*this, &RedirectBox::object_drop));
TreeViewColumn* name_col = redirect_display.get_column(0);
CellRendererText* renderer = dynamic_cast<CellRendererText*>(redirect_display.get_column_cell_renderer (0));
}
void
-RedirectBox::object_drop (string type, uint32_t cnt, const boost::shared_ptr<Redirect>* ptr)
+RedirectBox::object_drop (const list<boost::shared_ptr<Redirect> >& redirects)
{
- cerr << "Object drop, type = " << type << " cnt = " << cnt << endl;
-
- if (type != "redirects" || cnt == 0 || !ptr) {
- return;
- }
-
- /* do something with the dropped redirects */
-
- list<boost::shared_ptr<Redirect> > redirects;
-
- for (uint32_t n = 0; n < cnt; ++n) {
- redirects.push_back (ptr[n]);
- }
-
paste_redirect_list (redirects);
}
redisplay_redirects (0);
}
-
void
RedirectBox::set_width (Width w)
{
}
void
-RedirectBox::paste_redirect_list (list<boost::shared_ptr<Redirect> >& redirects)
+RedirectBox::paste_redirect_list (const list<boost::shared_ptr<Redirect> >& redirects)
{
list<boost::shared_ptr<Redirect> > copies;
- for (list<boost::shared_ptr<Redirect> >::iterator i = redirects.begin(); i != redirects.end(); ++i) {
+ for (list<boost::shared_ptr<Redirect> >::const_iterator i = redirects.begin(); i != redirects.end(); ++i) {
boost::shared_ptr<Redirect> copy = Redirect::clone (*i);
std::list<Gtk::TargetEntry> draggable;
Gdk::DragAction suggested_action;
int data_column;
+ std::string object_type;
+
+ struct DragData {
+ Gtk::TreeView* source;
+ int data_column;
+ std::string object_type;
+ };
+
+ static DragData drag_data;
+
+ void start_object_drag () {
+ drag_data.source = this;
+ drag_data.data_column = data_column;
+ drag_data.object_type = object_type;
+ }
};
template<class DataType>
DnDTreeView() {}
~DnDTreeView() {}
- sigc::signal<void,std::string,uint32_t,const DataType*> signal_object_drop;
+ sigc::signal<void,const std::list<DataType>& > signal_drop;
void on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection_data, guint info, guint time) {
if (selection_data.get_target() == "GTK_TREE_MODEL_ROW") {
TreeView::on_drag_data_get (context, selection_data, info, time);
-
- } else if (data_column >= 0) {
- Gtk::TreeSelection::ListHandle_Path selection = get_selection()->get_selected_rows ();
- SerializedObjectPointers<DataType>* sr = serialize_pointers (get_model(), &selection, selection_data.get_target());
- selection_data.set (8, (guchar*)sr, sr->size);
- /* we don't need the allocated block anymore,
- it will have been copied. this is wierd -
- the objects we put into the block have
- effectively been moved into the copy
- made by Gtk::SelectionData::set(),
- leaving our memory block a mere ghost.
- we're just fixing a memory leak here.
- */
- delete [] (reinterpret_cast<char*>(sr));
+
+ } else if (selection_data.get_target() == object_type) {
+
+ start_object_drag ();
+
+ /* we don't care about the data passed around by DnD, but
+ we have to provide something otherwise it will stop.
+ */
+
+ guchar c;
+ selection_data.set (8, (guchar*)&c, 1);
}
}
TreeView::on_drag_data_received (context, x, y, selection_data, info, time);
- } else if (data_column >= 0) {
-
- /* object D-n-D */
-
- const void* data = selection_data.get_data();
- const SerializedObjectPointers<DataType>* sr = reinterpret_cast<const SerializedObjectPointers<DataType> *>(data);
-
- if (sr) {
- signal_object_drop (sr->type, sr->cnt, sr->data);
-
- /* now clean up the pointers in the blob.
- Note that we make an explicit call
- to the destructor rather than using
- delete - the object does not own
- the memory in which it lives - it
- was allocated as a single contiguous
- block (see below).
- */
-
- for (uint32_t x = 0; x < sr->cnt; ++x) {
- sr->data[x].~DataType();
- }
- }
+
+ } else if (selection_data.get_target() == object_type) {
+ end_object_drag ();
+
} else {
/* some kind of target type added by the app, which will be handled by a signal handler */
}
private:
- SerializedObjectPointers<DataType>* serialize_pointers (Glib::RefPtr<Gtk::TreeModel> model,
- Gtk::TreeSelection::ListHandle_Path* selection,
- Glib::ustring type) {
-
- /* this nasty chunk of code is here because X's DnD protocol (probably other graphics UI's too)
- requires that we package up the entire data collection for DnD in a single contiguous region
- (so that it can be trivially copied between address spaces). We don't know the type of DataType so
- we have to mix-and-match C and C++ programming techniques here to get the right result.
-
- The C trick is to use the "someType foo[0];" declaration trick to create a zero-sized array at the
- end of a SerializedObjectPointers<DataType object. Then we allocate a raw memory buffer that extends
- past that array and thus provides space for however many DataType items we actually want to pass
- around.
-
- The C++ trick is to use the placement operator new() syntax to initialize that extra
- memory properly.
- */
-
- uint32_t cnt = selection->size();
- uint32_t sz = (sizeof (DataType) * cnt) + sizeof (SerializedObjectPointers<DataType>);
-
- char* buf = new char[sz];
- SerializedObjectPointers<DataType>* sr = (SerializedObjectPointers<DataType>*) buf;
-
- for (uint32_t i = 0; i < cnt; ++i) {
- new ((void *) &sr->data[i]) DataType ();
- }
-
- sr->cnt = cnt;
- sr->size = sz;
- snprintf (sr->type, sizeof (sr->type), "%s", type.c_str());
-
- cnt = 0;
+ void end_object_drag () {
+ Glib::RefPtr<Gtk::TreeModel> model = drag_data.source->get_model();
+ DataType v;
+ std::list<DataType> l;
+ Gtk::TreeSelection::ListHandle_Path selection = drag_data.source->get_selection()->get_selected_rows ();
- for (Gtk::TreeSelection::ListHandle_Path::iterator x = selection->begin(); x != selection->end(); ++x, ++cnt) {
- model->get_iter (*x)->get_value (data_column, sr->data[cnt]);
+ for (Gtk::TreeSelection::ListHandle_Path::iterator x = selection.begin(); x != selection.end(); ++x) {
+ model->get_iter (*x)->get_value (drag_data.data_column, v);
+ l.push_back (v);
}
- return sr;
+ signal_drop (l);
}
};