/* $Id: widget.gen_h,v 1.154 2001/11/03 19:32:41 cactus Exp $ */

/* widget.h
 *
 * Copyright (C) 1998-1999 The Gtk-- Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


/* this file is quite critical for our compile times... keep #includes minimal
 */

/* object.h is needed because of derivation */
#include <gtk--/object.h>
//#include <glib.h>
#include <gtk/gtkdnd.h>
#include <gtk/gtkwidget.h>

typedef struct _GtkTargetEntry GtkTargetEntry;
typedef struct _GtkTargetList GtkTargetList;

namespace Gtk {
class Style;
class AccelGroup;
class Adjustment;
class Window;

//: Abstract Widget (Base class for all widgets)
//- As the base class of all widgets this contains all of the properties
//- and methods common to all widgets.  It is an abstract class that
//- can not be instantiated.
//-
//- Important part of widgets is the *_event signals and virtual methods
//- that every widget has. Those are events coming directly from gdk and
//- thus also from XLib. By overriding those virtual methods you can
//- trap everything a widget can ever do.
//- In order to capture events from a widget, the event mask must
//- first be set with {set_events()}.
//-
//- Only widgets with a Gdk_Window on the server side are allowed to
//- capture events.  Widgets in the {Gtk::Misc::} group for example lack
//- a Gdk_Window.
class Widget : public Object {



public:
  typedef Widget          CppObjectType;
  typedef GtkWidget            BaseObjectType;

public:
  //: Returns the underlaying gtk+ object.
  GtkWidget* gtkobj();
  const GtkWidget* gtkobj() const;

  //: Returns true if object is this type.
  static bool isA(Gtk::Object *object);

  virtual ~Widget();

private:

public:
  friend class Main;

/*
  Not implemented:
    signal gint destroy_event(GdkEventAny*)
      This is useless for users, so we dont provide it - saves us
      from confusion.

    void destroyed            (Gtk_Widget* w); ??
      Utility function: sets widget_pointer
      to 0 when widget is destroyed.

    void gtk_widget_modify_style(GtkWidget*,GtkRcStyle*)
      Need to wrap GtkRcStyle with gdk-- first.

    void gtk_widget_set_parent(GtkWidget*,GtkWidget*)
      Set the widgets parent.
      This is better left to the container to which the widget
      gets added.  (Not for application use)

    bool gtk_widget_hide_on_delete(GtkWidget*)
      This doesn't appear to do anything but call hide!

    gboolean gtk_widget_set_scroll_adjustments(GtkWidget*,
                   GtkAdjustment*,GtkAdjustment*),
    gboolean gtk_widget_set_scroll_adjustments(GtkWidget*,
                   GtkAdjustment*,GtkAdjustment*),
      This is gtk+ idea of MI.  They define a function which
      can't be used on most classes here then the impl later. (bad, bad)
      return type is if it worked or not.
*/





  void unparent();



  void show_now();



/* QUEUE DRAWS */

  void queue_draw();

  void queue_draw_area(gint x,gint y,gint width,gint height);



  void queue_clear();

  void queue_clear_area(gint x,gint y,gint width,gint height);



  void queue_resize();



/* ACCELERATORS - none are user callable */

// (internal)
// WRAP_METHOD(
//   guint gtk_widget_accelerator_signal(GtkWidget*,GtkAccelGroup*,guint,guint),
//   guint accelerator_signal(Gtk::AccelGroup &accel_group,
//			   guint                accel_key,
//			   guint                accel_mods));

  void lock_accelerators();


  void unlock_accelerators();

#if GTK_VERSION_GT_MICRO(1,2,0)
  //: (Gtk 1.1)
  bool accelerators_locked();
#endif

  //: (internal) adds a key to an accelerator group for this widget

  void add_accelerator(const nstring& accel_signal,Gtk::AccelGroup& accel_group,guint accel_key,guint accel_mods,GtkAccelFlags accel_flags);

  //: (internal) removes a key to an accelerator group for this widget




  void remove_accelerator(Gtk::AccelGroup& accel_group,guint accel_key,guint accel_mods);

  //: (internal) removes all accelerators to this object



  void remove_accelerators(const nstring& accel_signal,bool visible_only);

  //:


  bool activate();


  //: Change a widgets parent.
  //- Equivalent to removing widget from old parent and adding it to
  //- the new parent, except that the widget will not be temporarily
  //- unrealized if both the old parent and the new parent are realized.
  //-
  //- Use this in place of {set_parent()} in an application.


  void reparent(Gtk::Widget& newparent);




  void popup(gint x,gint y);




  gint intersect(const Gdk_Rectangle& area,const Gdk_Rectangle& intersection) const;



  void grab_default();

  //: Set the name of the widget.
  //- You can name your widgets, so that you can know which one you
  //- have a pointer to. I don't think that this has anything to do
  //- with a text label that is shown on the widget.


  void set_name(const nstring& name);

  //: Return the {name} of the widget.


  Gtk::nstring get_name() const;

  GtkStateType get_state() const;


  void set_state(GtkStateType state);

  //: Change the widgets sensitivty.
  //- The sensitivity of a widget is whether it will accept user
  //- input or not. Usually this also changes the widget's look,
  //- to incicate it's usability. Set true to allow user input on
  //- the widget, false to disable user input.


  void set_sensitive(bool sensitive);



  void set_app_paintable(bool app_paintable);

  //: Return the {parent} of this widget.
  Gtk::Widget* get_parent() const;



  void set_parent_window(const Gdk_Window& parent_window);

  //: Return the parent's Gdk_Window.


  Gdk_Window get_parent_window() const;





  void set_uposition(gint x,gint y);

  //: Set the minumum widget size.
  //- Set either x or y to -1 to keep it's old size.



  void set_usize(gint x,gint y);

  //: Set the events the widget wishs to capture.
  //- The available event masks that the user can select are:
  //- {\enum GDK_EXPOSURE_MASK}, {\enum GDK_POINTER_MOTION_MASK},
  //- {\enum GDK_POINTER_MOTION_HINT_MASK}, {\enum GDK_BUTTON_MOTION_MASK},
  //- {\enum GDK_BUTTON1_MOTION_MASK}, {\enum GDK_BUTTON2_MOTION_MASK},
  //- {\enum GDK_BUTTON3_MOTION_MASK}, {\enum GDK_BUTTON_PRESS_MASK},
  //- {\enum GDK_BUTTON_RELEASE_MASK}, {\enum GDK_KEY_PRESS_MASK},
  //- {\enum GDK_KEY_RELEASE_MASK}, {\enum GDK_ENTER_NOTIFY_MASK},
  //- {\enum GDK_LEAVE_NOTIFY_MASK}, {\enum GDK_FOCUS_CHANGE_MASK},
  //- {\enum GDK_STRUCTURE_MASK}, {\enum GDK_PROPERTY_CHANGE_MASK},
  //- {\enum GDK_VISIBILITY_NOTIFY_MASK}, {\enum GDK_PROXIMITY_IN_MASK},
  //- {\enum GDK_PROXIMITY_OUT_MASK}, {\enum GDK_SUBSTRUCTURE_MASK}
  //-


  void set_events(gint events);

  //: Add additional events to be monitored by the widget.


  void add_events(gint events);



  void set_extension_events(GdkExtensionMode mode);



  GdkExtensionMode get_extension_events() const;

  //:
  //-
  Gtk::Window* get_toplevel ();

  //:
  //-


  Gtk::Widget* get_ancestor(GtkType type) const;

  //: Return the widget's colormap.


  Gdk_Colormap get_colormap() const;

  //: Return the widget's visual.


  Gdk_Visual get_visual() const;

  //: Set colormap prior to realization.
  //  This function must not be called on an already
  //  {realized()} widget. Because it is possible that somebody
  //  can call {get_colormap()} or {get_visual()} and save the
  //  result, this function is only safe to
  //  call in a widget's {\func init}() function.


  void set_colormap(const Gdk_Colormap& colormap);

  //: Set visual prior to realization.
  //  This function must not be called on an already
  //  {realized()} widget. Because it is possible that somebody
  //  can call {get_colormap()} or {get_visual()} and save the
  //  result, this function is only safe to
  //  call in a widget's {\func init}() function.


  void set_visual(const Gdk_Visual& visual);

  //: Get the widget's events (bitwise or'd together).


  gint get_events() const;



  void get_pointer(gint& x,gint& y) const;



  bool is_ancestor(Gtk::Widget& widget) const;

  //: Set the widget's style.
  //- The style of a widget includes font, color, and other
  //- information.


  void set_style(Gtk::Style& style);



  void set_rc_style();



  void ensure_style();

  // GtkStyle* gtk_widget_get_style(GtkWidget*);
  //: Get the widget's style.
  //- Once a style is used it is constant and unchangeable.


  Gtk::Style* get_style() const;



  void restore_default_style();



  void set_composite_name(const nstring& name);



  Gtk::nstring get_composite_name();



  void reset_rc_styles();




/* PUSH/POP */

  //: Sets a new style for the widget, and saves the old one.


  static void push_style(Gtk::Style& style);



  static void push_colormap(const Gdk_Colormap& cmap);



  static void push_visual(const Gdk_Visual& visual);



  static void push_composite_child();

  //: Restores the old style for the widget.


  static void pop_style();



  static void pop_colormap();



  static void pop_visual();



  static void pop_composite_child();




/* DEFAULTS */

  static void set_default_style(Gtk::Style& style);



  static void set_default_colormap(const Gdk_Colormap& colormap);



  static void set_default_visual(const Gdk_Visual& visual);



  static Gtk::Style* get_default_style();



  static Gdk_Colormap get_default_colormap();



  static Gdk_Visual get_default_visual();



//  WRAP_METHOD(
//    GtkStyle*   gtk_widget_peek_style(),
//    static Gtk::Style* get_current_style());

//  WRAP_METHOD(
//    GdkColormap*   gtk_widget_peek_colormap(),
//    static Gdk_Colormap get_current_colormap());

//  WRAP_METHOD(
//    GdkVisual*   gtk_widget_peek_visual(),
//    static Gdk_Visual get_current_visual());



  void shape_combine_mask(const Gdk_Bitmap& shape_mask,gint offset_x,gint offset_y);
private:
  // why is this private??


  void reset_shapes();

public:

  //: (Gtk 1.1)
  // void gtk_widget_path(GtkWidget*,guint*,gchar**,gchar**);
  void path		   (string    &path,
			    string    &path_reversed);

  //: (Gtk 1.1)
  // void gtk_widget_class_path(GtkWidget*,guint*,gchar**,gchar**);
  void class_path	   (string    &path,
			    string    &path_reversed);



  //: Return the Gdk_Window on which the widget is drawn.
  Gdk_Window get_window        () const;



/* DRAG'N DROP */


  GdkDragContext* gtkmm_drag_begin(GtkTargetList* p0,GdkDragAction p1,gint p2,GdkEvent* p3);

  //: (Gtk 1.1)




  void drag_get_data(Gdk_Drag_Context& context,Gdk_Atom target,guint32 time);
  //: (Gtk 1.1)





  static void drag_finish(Gdk_Drag_Context& context,bool success,bool del,guint32 time);

  //: (Gtk 1.1)


  void drag_highlight();

  //: (Gtk 1.1)


  void drag_unhighlight();

  //: (Gtk 1.1)

  void drag_dest_set(GtkDestDefaults flags,const GtkTargetEntry* targets,gint n_targets,GdkDragAction actions);

  //: (Gtk 1.1)





  void drag_dest_set_proxy(Gdk_Window& proxy_window,GdkDragProtocol protocol,bool use_coordinates);

  //: (Gtk 1.1)


  void drag_dest_unset();

  //: (Gtk 1.1)

  void drag_source_set(GdkModifierType start_button_mask,const GtkTargetEntry* targets,gint n_targets,GdkDragAction actions);

  //: (Gtk 1.1)


  void drag_source_unset();


  //: (Gtk 1.1)





  void drag_source_set_icon(Gdk_Colormap& colormap,Gdk_Pixmap& pixmap,Gdk_Bitmap& mask);

  /* these may not belong here, as they don't are widget member
     functions. however, they group nicely with the other
     drag_* functions

     (should move to Gdk_DragContext)
  */


  static Gtk::Widget* drag_get_source_widget(GdkDragContext* context);


  //: (Gtk 1.1)





  static void drag_set_icon_widget(Gdk_Drag_Context& context,Gtk::Widget& widget,gint hot_x,gint hot_y);

  //: (Gtk 1.1)

  static void drag_set_icon_pixmap(Gdk_Drag_Context& context,Gdk_Colormap& colormap,Gdk_Pixmap& pixmap,Gdk_Bitmap& mask,gint hot_x,gint hot_y);

  //: (Gtk 1.1)
  // move to Drag_Context??


  static void drag_set_icon_default(Gdk_Drag_Context& context);

  //: (Gtk 1.1)

  static void drag_set_default_icon(Gdk_Colormap& colormap,Gdk_Pixmap& pixmap,Gdk_Bitmap& mask,gint hot_x,gint hot_y);




/* FLAGS */

  //: Returns property {flags.toplevel}.
  bool is_toplevel() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_TOPLEVEL)?true:false; }

  //: Returns property {flags.nowindow}.
  bool has_no_window() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_NO_WINDOW)?true:false; }

  //: Returns property {flags.realized}.
  bool is_realized() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_REALIZED)?true:false; }

  //: Returns property {flags.mapped}.
  bool is_mapped() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_MAPPED)?true:false; }

  //: Returns property {flags.visible}.
  bool is_visible() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_VISIBLE)?true:false; }

  //: Returns if the widget is ready to be drawn to.
  // Checks to see if the widget is both visible and mapped which
  // makes it possible to perform drawing commands on.
  bool is_drawable() const
    { return (is_visible() && is_mapped())?true:false; }

  //: Returns property {flags.sensitive}. You might want to check
  // is_sensitive instead.
  bool sensitive() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_SENSITIVE)?true:false; }

  bool parent_sensitive() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_PARENT_SENSITIVE)?true:false; }
  bool is_sensitive() const
    { return (GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(gtkobj())))?true:false; }
  bool can_focus() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_CAN_FOCUS)?true:false; }
  bool has_focus() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_HAS_FOCUS)?true:false; }
  bool can_default() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_CAN_DEFAULT)?true:false; }
  bool has_default() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_HAS_DEFAULT)?true:false; }
  bool rc_style() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_RC_STYLE)?true:false; }
  bool has_grab() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_HAS_GRAB)?true:false; }
  bool is_composite_child() const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_COMPOSITE_CHILD)?true:false; }
  bool app_paintable()      const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_APP_PAINTABLE)?true:false; }
  bool recieves_default()   const
    { return (GTK_OBJECT_FLAGS (gtkobj()) & GTK_RECEIVES_DEFAULT)?true:false; }

  //: Set a member of the {flags} field.
  void set_flags(gint flag) { GTK_OBJECT_SET_FLAGS(gtkobj(), flag); }

  //: Clear a member of the {flags} field.
  void unset_flags(gint flag) { GTK_OBJECT_UNSET_FLAGS(gtkobj(), flag); }


/* SIGNALS */

  //: Show a widget.
  //- If the widget is not already destroyed, this will make the widget
  //- visible by setting {flags.visible}.




    emitable signal void show();

  //: Show a widget and all items inserted to it.

  void show_all();
  //: Hide a widget




    emitable signal void hide();

  //: Hide a widget and all items inserted to it

  void hide_all();
  //: Emitted on mapping of a widget to the screen.
  //- See {flags.mapped}.  This should not be called by the user.




    emitable signal void map_();

  //- See {flags.mapped}.  This should not be called by the user.




    emitable signal void unmap_();

  //: Emitted on realization of a widget.
  //- See {flags.realized}.  This is also responsible for
  //- setting {flags.realized} when it is done.  Therefore,
  //- when overriding the impl method, you should call the
  //- default realize method.




    emitable signal void realize();

  //- See {flags.realized}.  This should not be called by the user.
  //SIGNAL_SPEC("unrealize",both,void unrealize_(),gtk_widget_unrealize);





    emitable signal void grab_focus();

  //: Emitted to draw the widget.
  //- This is a gtk virtual function.  It can only be
  //- overriden with the impl method.

  void draw(GdkRectangle* p0);
  //: Emitted to draw the widget in a focused state.




    emitable signal void draw_focus();

  //: Emitted to draw the widget in a normal state.




    emitable signal void draw_default();

    emitable signal void size_request(GtkRequisition*);

    emitable signal void size_allocate(GtkAllocation*);



// Changed signals -- inform widget of internal changes.
// We rename parent_set => parent_changed
//  and      style_set  => style_changed
//  to avoid confusion with set_parent and set_style.

  //: Informs objects that their state has changed.
  //- The old state is passed as the argument.




    signal void state_changed(GtkStateType);

  //: Informs objects that their parent changed.
  //- The widget passed is the former parent, which may be 0 if
  //- there was no parent. (was parent_set in gtk+)





    signal void parent_changed(Gtk::Widget*);

  //: Informs objects that their style has been changed.
  //- The former style is passed as the argument. (was style_set in gtk+)





    signal void style_changed(Gtk::Style*);

    emitable signal gint event(GdkEvent*);

  //: Event triggered by user pressing button.

    emitable signal gint button_press_event(GdkEventButton*);

  //: Event triggered by user releasing button.

    emitable signal gint button_release_event(GdkEventButton*);

  //: Event triggered by user moving pointer.

    emitable signal gint motion_notify_event(GdkEventMotion*);

  //: Event triggered by window begin closed.

    emitable signal gint delete_event(GdkEventAny*);

  //: Event triggered by window requiring a refresh.
  //- Expose events cover a rectangular area that was covered
  //- or obscured by another window.  That area is now exposed
  //- and thus is needs to be redrawn.
  //-
  //- If the application is not capable of redrawing sections
  //- it should watch the count field and only draw on the last
  //- even indicated.  This is important for things such as
  //- {Gtk::DrawingArea::}.

    emitable signal gint expose_event(GdkEventExpose*);

  //: Event triggered by a key press will widget has focus.

    emitable signal gint key_press_event(GdkEventKey*);

  //: Event triggered by a key release will widget has focus.

    emitable signal gint key_release_event(GdkEventKey*);

  //: Event triggered by pointer entering widget area.

    emitable signal gint enter_notify_event(GdkEventCrossing*);

  //: Event triggered by pointer leaving widget area.

    emitable signal gint leave_notify_event(GdkEventCrossing*);

  //: Event triggered by a window resizing.

    emitable signal gint configure_event(GdkEventConfigure*);

    emitable signal gint focus_in_event(GdkEventFocus*);

    emitable signal gint focus_out_event(GdkEventFocus*);

    emitable signal gint map_event(GdkEventAny*);

    emitable signal gint unmap_event(GdkEventAny*);

    emitable signal gint property_notify_event(GdkEventProperty*);

    emitable signal gint selection_clear_event(GdkEventSelection*);

    emitable signal gint selection_request_event(GdkEventSelection*);

    emitable signal gint selection_notify_event(GdkEventSelection*);

    emitable signal gint proximity_in_event(GdkEventProximity*);

    emitable signal gint proximity_out_event(GdkEventProximity*);

    emitable signal gint client_event(GdkEventClient*);

    emitable signal gint no_expose_event(GdkEventAny*);

    emitable signal gint visibility_notify_event(GdkEventVisibility*);

    signal void debug_msg(const gchar*);

    signal void selection_get(GtkSelectionData*,guint,guint);

    signal void selection_received(GtkSelectionData*,guint);



/* DRAG'N DRAW */




    signal void drag_begin(GdkDragContext*);

    signal void drag_end(GdkDragContext*);

    signal void drag_data_get(GdkDragContext*,GtkSelectionData*,guint,guint);

    signal void drag_data_delete(GdkDragContext*);

    signal void drag_leave(GdkDragContext*,guint);

    signal gboolean drag_motion(GdkDragContext*,gint,gint,guint);

    signal gboolean drag_drop(GdkDragContext*,gint,gint,guint);

    signal void drag_data_received(GdkDragContext*,gint,gint,GtkSelectionData*,guint,guint32);

  //: Returns width of widget.
  gint width() const { return gtkobj()->allocation.width; }

  //: Returns height of widget.
  gint height() const { return gtkobj()->allocation.height; }

protected:
  void realize_if_needed();
  Widget();



protected:
  // impl functions
    virtual void show_impl();
    virtual void show_all_impl();
    virtual void hide_impl();
    virtual void hide_all_impl();
    virtual void map__impl();
    virtual void unmap__impl();
    virtual void realize_impl();
    virtual void grab_focus_impl();
    virtual void draw_impl(GdkRectangle* p0);
    virtual void draw_focus_impl();
    virtual void draw_default_impl();
    virtual void size_request_impl(GtkRequisition* p0);
    virtual void size_allocate_impl(GtkAllocation* p0);
    virtual void state_changed_impl(GtkStateType p0);
    virtual void parent_changed_impl(Gtk::Widget* p0);
    virtual void style_changed_impl(Gtk::Style* p0);
    virtual gint event_impl(GdkEvent* p0);
    virtual gint button_press_event_impl(GdkEventButton* p0);
    virtual gint button_release_event_impl(GdkEventButton* p0);
    virtual gint motion_notify_event_impl(GdkEventMotion* p0);
    virtual gint delete_event_impl(GdkEventAny* p0);
    virtual gint expose_event_impl(GdkEventExpose* p0);
    virtual gint key_press_event_impl(GdkEventKey* p0);
    virtual gint key_release_event_impl(GdkEventKey* p0);
    virtual gint enter_notify_event_impl(GdkEventCrossing* p0);
    virtual gint leave_notify_event_impl(GdkEventCrossing* p0);
    virtual gint configure_event_impl(GdkEventConfigure* p0);
    virtual gint focus_in_event_impl(GdkEventFocus* p0);
    virtual gint focus_out_event_impl(GdkEventFocus* p0);
    virtual gint map_event_impl(GdkEventAny* p0);
    virtual gint unmap_event_impl(GdkEventAny* p0);
    virtual gint property_notify_event_impl(GdkEventProperty* p0);
    virtual gint selection_clear_event_impl(GdkEventSelection* p0);
    virtual gint selection_request_event_impl(GdkEventSelection* p0);
    virtual gint selection_notify_event_impl(GdkEventSelection* p0);
    virtual gint proximity_in_event_impl(GdkEventProximity* p0);
    virtual gint proximity_out_event_impl(GdkEventProximity* p0);
    virtual gint client_event_impl(GdkEventClient* p0);
    virtual gint no_expose_event_impl(GdkEventAny* p0);
    virtual gint visibility_notify_event_impl(GdkEventVisibility* p0);
    virtual void debug_msg_impl(const gchar* p0);
    virtual void selection_get_impl(GtkSelectionData* p0,guint p1,guint p2);
    virtual void selection_received_impl(GtkSelectionData* p0,guint p1);
    virtual void drag_begin_impl(GdkDragContext* p0);
    virtual void drag_end_impl(GdkDragContext* p0);
    virtual void drag_data_get_impl(GdkDragContext* p0,GtkSelectionData* p1,guint p2,guint p3);
    virtual void drag_data_delete_impl(GdkDragContext* p0);
    virtual void drag_leave_impl(GdkDragContext* p0,guint p1);
    virtual gboolean drag_motion_impl(GdkDragContext* p0,gint p1,gint p2,guint p3);
    virtual gboolean drag_drop_impl(GdkDragContext* p0,gint p1,gint p2,guint p3);
    virtual void drag_data_received_impl(GdkDragContext* p0,gint p1,gint p2,GtkSelectionData* p3,guint p4,guint32 p5);

};

//+ PROPERTIES(GTK_WIDGET)
//. name: allocation
//. type: GtkAllocation
//. get:
//. set:  {size_allocate()}
//. desc: The widgets actual size.

//. name: flags
//. type: GTK_OBJECT_FLAGS
//. get:  See below.
//. set:  {set_flags()}, {unset_flags()}
//. desc: A large set of flags controlling the behaviors of the widget.

//. name: flags.can_focus
//. type: bool
//. get:  {can_focus()}
//. set:  NA
//. desc: This flag determines whether a widget is able to handle focus grabs.
//. There are no directly corresponding functions for setting/unsetting
//. this flag, but it can be affected by the {has_focus()} argument
//. via {set_arg()}.

//. name: flags.can_default
//. type: bool
//. get:  {can_focus()}
//. set:  NA
//. desc: Same as {can_focus} for the default widget.

//. name: flags.has_focus
//. type: bool
//. get:  {has_focus()}
//. set:  {grab_focus()}
//. desc:
//. This flag will be set by {grab_focus()} for widgets that also
//. have {\enum GTK_CAN_FOCUS} set. The flag will be unset once another widget
//. grabs the focus.

//. name: flags.has_default
//. type: bool
//. get:  {has_default()}
//. set:  NA
//. desc: Same as {has_focus} for the default widget.

//. name: flags.has_grab
//. type: bool
//. get:  {has_grab()}
//. set:  NA
//. desc: This flag indicated the widget is in the grab_widgets stack,
//. and will be the preferred
//. one for receiving events other than ones of cosmetic value.

//. name: flags.mapped
//. type: bool
//. get:  {mapped()}
//. set:  NA
//. desc: Indicates that {show()} has been called on the widgets window(s).
//. Mapping follows realization.

//. name: flags.no_window
//. type: bool
//. get:  {no_window()}
//. set:  NA
//. desc:  This flag is indicative for a widget that does not provide
//. its own GdkWindow. Visible action (e.g. drawing) is performed
//. on the parent's GdkWindow.
//.
//. See {Gtk::EventBox::} and {Gtk::Misc::}
//. for more details.

//. name: flags.realized
//. type: bool
//. get:  {realized()}
//. set:  NA
//. desc: Indicates if a widget has been realized on the
//. server.  A widget may be constructed, but not yet mapped
//. into the X server yet.  The process of constructing a
//. server side object is called realization.  After realization
//. the widget has a GdkWindow (or its parent does in the case of
//. {flags.no_window} )

//. name: flags.sensitive
//. type: bool
//. get:  {sensitive()}
//. set:  NA
//. desc:
//. The sensitivity of a widget determines whether it will receive
//. certain events (e.g. button or key presses). One premise for
//. the widgets sensitivity is to have {flags.sensitive} set.

//. name: flags.parent_sensitive
//. type: bool
//. get:  {parent_sensitive()}
//. set:  NA
//. desc:
//. This is the second premise for the widgets sensitivity. Once
//. it has {flags.sensitive} and {flags.parent_sensitive}
//. set, its state is
//. effectively sensitive.

//. name: flags.visible
//. type: bool
//. get:  {visible()}
//. set:  {show()}, {hide()}
//. desc:
//. Implies that a widget will be flagged {flags.mapped} as soon as its
//. parent is mapped. If not set, implies that a widget is not onscreen,
//. therefore !{flags.mapped}.

//. name: name
//. type: string
//. get:  {get_name()}
//. set:  {set_name()}
//. desc: The widgets name. If the widget does not have a name
//.   then its name is its classes name.
//.   Among other things, the widget name is used to determine
//.   the style to use for a widget.

//. name: parent
//. type: Gtk_Widget *
//. get:
//. set:  {set_parent()}, {reparent()}
//. desc: Parent of this widget.
//.
//. This is normally set by the
//. container to which the widget is added.

//. name: requisition
//. type: GtkRequisition
//. get:
//. set:  {size_request()}
//. desc: The widgets desired size.

//. name: state
//. type: GtkStateType
//. get:  {get_state()}
//. set:  {set_state()}
//. desc: The saved state of the widget. When a widgets state
//.     is changed to {\enum GTK_STATE_INSENSITIVE} via
//.     set_state or set_sensitive
//.     the old state is kept around in this field. The state
//.     will be restored once the widget gets sensitive again.
//.
//.     Available states:
//.     {\enum GTK_STATE_NORMAL, GTK_STATE_ACTIVE, GTK_STATE_PRELIGHT,
//.     GTK_STATE_SELECTED, GTK_STATE_INSENSITIVE }

//. name: style
//. type: Gtk::Style *
//. get:  {get_style()}
//. set:  {set_style()}
//. desc:  The style for the widget. The style contains the
//.      colors the widget should be drawn in for each state
//.      along with graphics contexts used to draw with and
//.      the font to use for text.
//.
//.      Set {Gtk::Style::} for more info.

//. name: window
//. type: Gdk_Window
//. get:  {get_window()}
//. set:
//. desc: The widgets window or its parent window if it does
//.   not have a window, which will be indicated
//.   {no_window()}.



}