// -*- c++ -*-
/*  Generated by gensig from widget.gen_h. DO NOT MODIFY!!! */
#ifndef GTKMM_WIDGET_HEADER
#define GTKMM_WIDGET_HEADER
/* $Id: widget.gen_h,v 1.93.2.6 1999/06/04 02:53:31 tdukes Exp $ */

/* widget.h
 * 
 * Copyright (C) 1998-1999 
 *
 * 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 <gtk--/style.h> /* needed because of Gtk_ObjectHandle uses delete */
#include <glib.h>

class Gtk_Style;
typedef struct _GtkTargetEntry GtkTargetEntry;
typedef struct _GtkTargetList GtkTargetList;
#line 35 "widget.gen_h"
class Gtk_AccelGroup;
#line 39 "widget.gen_h"

class Gtk_Widget_Class;
#line 40 "widget.gen_h"

//: 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 are the *_event signals and virtual methods
//- that every widget have. 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 {\page Gtk_Misc} group for example lack
//- a Gdk_Window.
class Gtk_Widget : public Gtk_Object {
  
public:
protected:
  typedef Gtk_Widget_Class    CppClassType;
  typedef GtkWidget           BaseObjectType;
  typedef GtkWidgetClass      BaseClassType;

  virtual void *get_parent_class();

private:
  friend CppClassType;
  static CppClassType widget_class; 
  GtkType get_type(); 

public:


  friend class Gtk_Main;
  friend class Gtk_Tooltips;
  Gtk_Widget(GtkWidget *castitem);
  
  //: Destroy and hides widget.
  //- Destroys widget by adding to the trashcan.  Calls {hide()}
  //- prior to deleting widget.  
  //-
  //- See {\page Gtk_Trashcan}
  virtual void delete_self();
    
  void unparent             ();

  //: 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             (const Gtk_Widget & newparent);

  void activate             ();
  void popup                (gint x, 
			     gint y);
  bool intersect            (const Gdk_Rectangle &area,
			     const Gdk_Rectangle &intersection) const;

#line 94 "widget.gen_h"

  void grab_focus           ();
  void grab_default         ();
  void set_uposition        (gint x, 
			     gint y);

  //: Set minumum widget size.
  void set_usize            (gint width, 
			     gint height);

  //: 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);

  void set_extension_events (GdkExtensionMode mode);
  GdkExtensionMode get_extension_events () const;

  //:
  //-
  Gtk_Widget* get_toplevel  ();

  //:
  //-
  Gtk_Widget* get_ancestor  (gint type) const ;

  //: Return current widget colormap.
  Gdk_Colormap get_colormap () const;
 
  //: Return current widget visual.
  Gdk_Visual get_visual     () const;

  gint get_events           () const;
  void get_pointer          (gint *x, gint *y) const;
  bool is_ancestor          (const Gtk_Widget &widget) const;

  void set_style            (const Gtk_Style &style);
  void set_rc_style         ();
  void ensure_style         ();
  const Gtk_Style* get_style() const;
  Gtk_Style* get_style();
  void restore_default_style();

  static void push_style	 (const Gtk_Style &style);
  static void push_colormap	 (const Gdk_Colormap &cmap);
  static void push_visual	 (const Gdk_Visual &visual);
  static void pop_style	         ();
  static void pop_colormap	 ();
  static void pop_visual	 ();
   
  static void set_default_style            (const 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     ();

#line 162 "widget.gen_h"
  //: 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);
#line 178 "widget.gen_h"

  //: Set the {name} of the widget.
  void set_name                (const _gtk_string &name);

  //: Return the {name} of the widget.
  _gtk_string get_name              () const;

  void set_state               (GtkStateType state);
  void set_sensitive           (bool sensitive);

  //: Return the {parent} of this widget.
  const Gtk_Widget* get_parent () const { return _get_parent(); }
  Gtk_Widget* get_parent ()             { return _get_parent(); }

  //: Set the widgets parent.  
  //- This is better left to the container to which the widget
  //- gets added.  (Not for application use)
  void set_parent              (const Gtk_Widget &parent);
  void set_parent_window       (const Gdk_Window &parent_window);

  //: Return the parent's Gdk_Window.
  Gdk_Window get_parent_window () const;

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

  // Not implemented
  // Utility function: sets widget_pointer 
  // to NULL when widget is destroyed.
  // void destroyed            (Gtk_Widget* w);
  

  void queue_draw();
  void queue_resize();

  void shape_combine_mask   (const Gdk_Bitmap &shape_mask,
			     gint       offset_x,
			     gint       offset_y);

#line 218 "widget.gen_h"
  //: (Gtk 1.1)
  bool hide_on_delete();
  guint accelerator_signal(const Gtk_AccelGroup &accel_group,
			   guint                accel_key,
			   guint                accel_mods);

  //: (Gtk 1.1)
  void lock_accelerators  ();

  //: (Gtk 1.1)
  void unlock_accelerators();

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

  //: (Gtk 1.1)
  void set_app_paintable  (bool app_paintable);

  // Should be signals
  //: (Gtk 1.1)
  void add_accelerator	  (const _gtk_string    &accel_signal,
			   const Gtk_AccelGroup &accel_group,
			   guint                accel_key,
			   guint                accel_mods,
			   GtkAccelFlags        accel_flags);
  //: (Gtk 1.1)
  void remove_accelerator  (const Gtk_AccelGroup &accel_group,
			    guint                accel_key,
			    guint                accel_mods);

  //: (Gtk 1.1)
  void remove_accelerators (const _gtk_string   &accel_signal,
			    bool		visible_only);

  //: (Gtk 1.1)
  void add_events          (gint	        events);

  //: (Gtk 1.1)
  void path		   (string    *path,
			    string    *path_reversed);

  //: (Gtk 1.1)
  void class_path	   (string    *path,
			    string    *path_reversed);

//   void modify_style      (GtkRcStyle     *style);

  //: (Gtk 1.1)
  static void pop_composite_child();
  //: (Gtk 1.1)
  static void push_composite_child();

  //: (Gtk 1.1)
  void queue_clear();
  //: (Gtk 1.1)
  void queue_clear_area   (gint                 x,
			   gint                 y,
			   gint                 width,
			   gint                 height);
  //: (Gtk 1.1)
  void queue_draw_area	  (gint                 x,
			   gint                 y,
			   gint                 width,
			   gint                 height);

  //: (Gtk 1.1)
  void   set_composite_name (const _gtk_string &name);
  //: (Gtk 1.1)
  _gtk_string get_composite_name ();
  
  //: (Gtk 1.1)
  void reset_rc_styles();

  //: (Gtk 1.1)
  void get_child_requisition (GtkRequisition *req) const;


  //: (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   (int                 flags,
			GtkTargetEntry     *targets,
			gint                n_targets,
			int                 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 (int             start_button_mask, 
			GtkTargetEntry  *targets,
			gint            n_targets,
			int             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);

  /* drag_begin is a signal, see below */

  /* these may not belong here, as they don't are widget member
     functions. however, they group nicely with the other
     drag_* functions
  */
  //: (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)
  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);
#line 388 "widget.gen_h"

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

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

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

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

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

  //: 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(); }
  
  //: Returns property {flags.sensitive}. You might want to check
  // is_sensitive instead.
  bool sensitive() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_SENSITIVE; }

  bool parent_sensitive() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_PARENT_SENSITIVE; }
  bool is_sensitive() const { return GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(gtkobj())); }
  bool can_focus() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_CAN_FOCUS; }
  bool has_focus() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_HAS_FOCUS; }
  bool can_default() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_CAN_DEFAULT; }
  bool has_default() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_HAS_DEFAULT; }
#line 422 "widget.gen_h"
  bool rc_style() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_RC_STYLE; }
  bool has_grab() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_HAS_GRAB; }
#line 425 "widget.gen_h"
  bool is_composite_child() const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_COMPOSITE_CHILD; }
  bool app_paintable()      const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_APP_PAINTABLE; }
  bool recieves_default()   const { return GTK_OBJECT_FLAGS (gtkobj()) & GTK_RECEIVES_DEFAULT; }
#line 429 "widget.gen_h"

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

  //: Clear a member of the {flags} field.
  void unset_flags(gint flag) const { GTK_OBJECT_UNSET_FLAGS(gtkobj(), flag); }
    
  //: Show a widget.
  //- If the widget is not already destroyed, this will make the widget
  //- visible by setting {flags.visible}.
  Signal_proxy0<BaseObjectType> show;

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

  Signal_proxy0<GtkWidget> show_all;

  //: Hide a widget
  Signal_proxy0<BaseObjectType> hide;

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

  Signal_proxy0<GtkWidget> hide_all;

  //: Emitted on mapping of a widget to the screen.
  //- See {flags.mapped}.  This should not be called by the user.
  Signal_proxy0<BaseObjectType> map;
  //- See {flags.mapped}.  This should not be called by the user.
  Signal_proxy0<BaseObjectType> 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 
  //- deafault realize method.
  Signal_proxy0<BaseObjectType> realize;
  //- See {flags.realized}.  This should not be called by the user.
  Signal_proxy0<BaseObjectType> unrealize;
 
  //: Emitted to draw the widget.
  //- This is a gtk virtual function.  It can only be
  //- overriden with the impl method.  

  Signal_proxy1<GtkWidget,GdkRectangle*> draw;

  //: Emitted to draw the widget in a focused state.
  Signal_proxy0<BaseObjectType> draw_focus;

  //: Emitted to draw the widget in a normal state.
  Signal_proxy0<BaseObjectType> draw_default;
    
  // should this be signal? not a signal in docs
#line 484 "widget.gen_h"
	
    
  Signal_proxy1<BaseObjectType,GtkRequisition*> size_request;
    
  Signal_proxy1<BaseObjectType,GtkAllocation*> size_allocate;

  //: Emitted on a change of widget state.
#line 492 "widget.gen_h"
  Signal_proxy1<BaseObjectType,GtkStateType> state_changed;
#line 496 "widget.gen_h"

  Signal_proxy1<BaseObjectType,GtkWidget*> parent_set_c;
  Signal1<Gtk_Widget*> parent_set;
  void parent_set_callback(Gtk_Widget *p1);

  Signal_proxy1<BaseObjectType,GtkStyle*> style_set_c;
  Signal1<Gtk_Style*> style_set;
  void style_set_callback(Gtk_Style *p1);

#line 516 "widget.gen_h"
	
  Signal_proxy1_r<gint,BaseObjectType,GdkEvent*> event;
  //: Event triggered by user pressing button.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventButton*> button_press_event;

  //: Event triggered by user releasing button.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventButton*> button_release_event;

  //: Event triggered by user moving pointer.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventMotion*> motion_notify_event;

  //: Event triggered by window begin closed. 
  Signal_proxy1_r<gint,BaseObjectType,GdkEventAny*> delete_event;
/* This is useless for users, so we dont provide it - saves us
   from confusion.
  SIGNAL_COMMENTED_SPEC(gint destroy_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 
  //- {\page Gtk_DrawingArea}. 
  Signal_proxy1_r<gint,BaseObjectType,GdkEventExpose*> expose_event;

  //: Event triggered by a key press will widget has focus.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventKey*> key_press_event;

  //: Event triggered by a key release will widget has focus.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventKey*> key_release_event;

  //: Event triggered by pointer entering widget area.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventCrossing*> enter_notify_event;

  //: Event triggered by pointer leaving widget area.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventCrossing*> leave_notify_event;
 
  //: Event triggered by a window resizing.
  Signal_proxy1_r<gint,BaseObjectType,GdkEventConfigure*> configure_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventFocus*> focus_in_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventFocus*> focus_out_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventAny*> map_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventAny*> unmap_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventProperty*> property_notify_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventSelection*> selection_clear_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventSelection*> selection_request_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventSelection*> selection_notify_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventProximity*> proximity_in_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventProximity*> proximity_out_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventClient*> client_event;
  Signal_proxy1_r<gint,BaseObjectType,GdkEventAny*> no_expose_event;
#line 571 "widget.gen_h"
  Signal_proxy1_r<gint,BaseObjectType,GdkEventVisibility*> visibility_notify_event;
  Signal_proxy1<BaseObjectType,const gchar*> debug_msg;
  
  Signal_proxy3<BaseObjectType,GtkSelectionData*, guint, guint> selection_get;
  Signal_proxy2<BaseObjectType,GtkSelectionData*, guint> selection_received;

  Signal_proxy1<BaseObjectType,GdkDragContext*> drag_begin;
  Signal_proxy1<BaseObjectType,GdkDragContext*> drag_end;
  Signal_proxy4<BaseObjectType,GdkDragContext*, GtkSelectionData*, guint, guint32> drag_data_get;
  Signal_proxy1<BaseObjectType,GdkDragContext*> drag_data_delete;
  Signal_proxy2<BaseObjectType,GdkDragContext*, guint> drag_leave;
  Signal_proxy4_r<gboolean,BaseObjectType,GdkDragContext*, gint, gint, guint> drag_motion;
  Signal_proxy4_r<gboolean,BaseObjectType,GdkDragContext*, gint, gint, guint> drag_drop;
  Signal_proxy6<BaseObjectType,GdkDragContext*, gint, gint, GtkSelectionData*, guint, guint32> drag_data_received;
#line 594 "widget.gen_h"
    
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 unrealize_impl();
  virtual void draw_impl(GdkRectangle* p1);
  virtual void draw_focus_impl();
  virtual void draw_default_impl();
  virtual void size_request_impl(GtkRequisition* p1);
  virtual void size_allocate_impl(GtkAllocation* p1);
  virtual void state_changed_impl(GtkStateType p1);
  virtual void parent_set_c_impl(GtkWidget* p1);
  virtual void style_set_c_impl(GtkStyle* p1);
  virtual gint event_impl(GdkEvent* p1);
  virtual gint button_press_event_impl(GdkEventButton* p1);
  virtual gint button_release_event_impl(GdkEventButton* p1);
  virtual gint motion_notify_event_impl(GdkEventMotion* p1);
  virtual gint delete_event_impl(GdkEventAny* p1);
  virtual gint expose_event_impl(GdkEventExpose* p1);
  virtual gint key_press_event_impl(GdkEventKey* p1);
  virtual gint key_release_event_impl(GdkEventKey* p1);
  virtual gint enter_notify_event_impl(GdkEventCrossing* p1);
  virtual gint leave_notify_event_impl(GdkEventCrossing* p1);
  virtual gint configure_event_impl(GdkEventConfigure* p1);
  virtual gint focus_in_event_impl(GdkEventFocus* p1);
  virtual gint focus_out_event_impl(GdkEventFocus* p1);
  virtual gint map_event_impl(GdkEventAny* p1);
  virtual gint unmap_event_impl(GdkEventAny* p1);
  virtual gint property_notify_event_impl(GdkEventProperty* p1);
  virtual gint selection_clear_event_impl(GdkEventSelection* p1);
  virtual gint selection_request_event_impl(GdkEventSelection* p1);
  virtual gint selection_notify_event_impl(GdkEventSelection* p1);
  virtual gint proximity_in_event_impl(GdkEventProximity* p1);
  virtual gint proximity_out_event_impl(GdkEventProximity* p1);
  virtual gint client_event_impl(GdkEventClient* p1);
  virtual gint no_expose_event_impl(GdkEventAny* p1);
  virtual gint visibility_notify_event_impl(GdkEventVisibility* p1);
  virtual void debug_msg_impl(const gchar* p1);
  virtual void selection_get_impl(GtkSelectionData* p1, guint p2, guint p3);
  virtual void selection_received_impl(GtkSelectionData* p1, guint p2);
  virtual void drag_begin_impl(GdkDragContext* p1);
  virtual void drag_end_impl(GdkDragContext* p1);
  virtual void drag_data_get_impl(GdkDragContext* p1, GtkSelectionData* p2, guint p3, guint32 p4);
  virtual void drag_data_delete_impl(GdkDragContext* p1);
  virtual void drag_leave_impl(GdkDragContext* p1, guint p2);
  virtual gboolean drag_motion_impl(GdkDragContext* p1, gint p2, gint p3, guint p4);
  virtual gboolean drag_drop_impl(GdkDragContext* p1, gint p2, gint p3, guint p4);
  virtual void drag_data_received_impl(GdkDragContext* p1, gint p2, gint p3, GtkSelectionData* p4, guint p5, guint32 p6);
public:
  GtkWidget* gtkobj() { return GTK_WIDGET(gtkobject); }
  const GtkWidget* gtkobj() const { return GTK_WIDGET(gtkobject); }
  static bool isGtkWidget(Gtk_Object *checkcast);
#line 595 "widget.gen_h"


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

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

protected:
  static Gtk_Style *default_style_;
  Gtk_Style* _get_style() const;
  Gtk_Widget* _get_parent() const;
  void realize_if_needed();
  Gtk_Widget();
  
  mutable Gtk_ObjectHandle<Gtk_Widget> toplevel_; // can not be set
  mutable Gtk_ObjectHandle<Gtk_Widget> ancestor_; // can not be set
  mutable Gtk_ObjectHandle<Gtk_Widget> parent_;
  mutable Gtk_ObjectHandle<Gtk_Style> style_;
};

#endif
