Drag and Drop
Gtk::Widget has several methods and signals which are prefixed with "drag_". These are used for Drag and Drop.

Sources and Destinations
Things are dragged from sources to be dropped on destinations. Each source and destination has infomation about the data formats that it can send or receive, provided by Gtk::TargetEntry items. A drop destination will only accept a dragged item if they both share a compatible Gtk::TargetEntry item. Appropriate signals will then be emitted, telling the signal handlers which Gtk::TargetEntry was used.
Gtk::TargetEntry objects contain this information:
target: A name, such as "STRING"
info: An identifier which will be sent to your signals to tell you which TargetEntry was used.
flags: Used only for drag and drop, this specifies whether the data may be dragged to other widgets and applications, or only to the same ones.

Methods
Widgets can be identified as sources or destinations using these Gtk::Widget methods:

void drag_source_set(const std::vector<Gtk::TargetEntry>& targets,
      Gdk::ModifierType start_button_mask, Gdk::DragAction actions);

targets is a vector of Gtk::TargetEntry elements.
start_button_mask is an ORed combination of values, which specify which modifier key or mouse button must be pressed to start the drag.
actions is an ORed combination of values, which specified which Drag and Drop operations will be possible from this source - for instance, copy, move, or link. The user can choose between the actions by using modifier keys, such as Shift to change from copy to move, and this will be shown by a different cursor.

void drag_dest_set(const std::vector<Gtk::TargetEntry>& targets,
    Gtk::DestDefaults flags, Gdk::DragAction actions);

flags is an ORed combination of values which indicates how the widget will respond visually to Drag and Drop items.
actions indicates the Drag and Drop actions which this destination can receive - see the description above.

Signals
When a drop destination has accepted a dragged item, certain signals will be emitted, depending on what action has been selected. For instance, the user might have held down the Shift key to specify a move rather than a copy. Remember that the user can only select the actions which you have specified in your calls to drag_dest_set() and drag_source_set().

Copy
The source widget will emit these signals, in this order:
drag_begin: Provides DragContext.
drag_data_get: Provides info about the dragged data format, and a Gtk::SelectionData structure, in which you should put the requested data.
drag_end: Provides DragContext.
The destination widget will emit these signals, in this order:
drag_motion: Provides DragContext and coordinates. You can call the drag_status() method of the DragContext to indicate which action will be accepted.
drag_drop: Provides DragContext and coordinates. You can call drag_get_data(), which triggers the drag_data_get signal in the source widget, and then the drag_data_received signal in the destination widget.
drag_data_received: Provides info about the dragged data format, and a Gtk::SelectionData structure which contains the dropped data. You should call the drag_finish() method of the DragContext to indicate whether the operation was successful.

Move
During a move, the source widget will also emit this signal:
drag_data_delete: Gives the source the opportunity to delete the original data if that's appropriate.

DragContext
The drag and drop signals provide a DragContext, which contains some information about the drag and drop operation and can be used to influence the process. For instance, you can discover the source widget, or change the drag and drop icon, by using the set_icon() methods. More importantly, you should call the drag_finish() method from your drag_data_received signal handler to indicate whether the drop was successful.

Example
Here is a very simple example, demonstrating a drag and drop Copy operation:

Drag and Drop
Source Code
File: dndwindow.h (For use with gtkmm 3, not gtkmm 2)

#ifndef GTKMM_EXAMPLE_DNDWINDOW_H
#define GTKMM_EXAMPLE_DNDWINDOW_H

#include <gtkmm/box.h>
#include <gtkmm/label.h>
#include <gtkmm/window.h>
#include <gtkmm/button.h>

class DnDWindow : public Gtk::Window
{

public:
  DnDWindow();
  virtual ~DnDWindow();

protected:
  //Signal handlers:
  void on_button_drag_data_get(
          const Glib::RefPtr<Gdk::DragContext>& context,
          Gtk::SelectionData& selection_data, guint info, guint time);
  void on_label_drop_drag_data_received(
          const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
          const Gtk::SelectionData& selection_data, guint info, guint time);

  //Member widgets:
  Gtk::Box m_HBox;
  Gtk::Button m_Button_Drag;
  Gtk::Label m_Label_Drop;
};

#endif // GTKMM_EXAMPLE_DNDWINDOW_H

File: main.cc (For use with gtkmm 3, not gtkmm 2)

#include "dndwindow.h"
#include <gtkmm/application.h>

int main (int argc, char *argv[])
{
  Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

  DnDWindow dndWindow;

  //Shows the window and returns when it is closed.
  return app->run(dndWindow);
}

File: dndwindow.cc (For use with gtkmm 3, not gtkmm 2)

#include "dndwindow.h"
#include <iostream>

DnDWindow::DnDWindow()
: m_Button_Drag("Drag Here\n"),
  m_Label_Drop("Drop here\n")
{
  set_title("DnD example");

  add(m_HBox);

  //Targets:
  std::vector<Gtk::TargetEntry> listTargets;
  listTargets.push_back( Gtk::TargetEntry("STRING") );
  listTargets.push_back( Gtk::TargetEntry("text/plain") );

  //Drag site:

  //Make m_Button_Drag a DnD drag source:
  m_Button_Drag.drag_source_set(listTargets);

  //Connect signals:
  m_Button_Drag.signal_drag_data_get().connect(sigc::mem_fun(*this,
              &DnDWindow::on_button_drag_data_get));

  m_HBox.pack_start(m_Button_Drag);

  //Drop site:

  //Make m_Label_Drop a DnD drop destination:
  m_Label_Drop.drag_dest_set(listTargets);

  //Connect signals:
  m_Label_Drop.signal_drag_data_received().connect(sigc::mem_fun(*this,
              &DnDWindow::on_label_drop_drag_data_received) );

  m_HBox.pack_start(m_Label_Drop);

  show_all();
}

DnDWindow::~DnDWindow()
{
}

void DnDWindow::on_button_drag_data_get(
        const Glib::RefPtr<Gdk::DragContext>&,
        Gtk::SelectionData& selection_data, guint, guint)
{
  selection_data.set(selection_data.get_target(), 8 /* 8 bits format */,
          (const guchar*)"I'm Data!",
          9 /* the length of I'm Data! in bytes */);
}

void DnDWindow::on_label_drop_drag_data_received(
        const Glib::RefPtr<Gdk::DragContext>& context, int, int,
        const Gtk::SelectionData& selection_data, guint, guint time)
{
  const int length = selection_data.get_length();
  if((length >= 0) && (selection_data.get_format() == 8))
  {
    std::cout << "Received \"" << selection_data.get_data_as_string()
        << "\" in label " << std::endl;
  }

  context->drag_finish(false, false, time);
}

There is a more complex example in examples/others/dnd.