tk/ytkmm/ytkmm/gtkmm/widget.h

Go to the documentation of this file.

// -*- c++ -*-
// Generated by gmmproc 2.45.3 -- DO NOT MODIFY!
#ifndef _GTKMM_WIDGET_H
#define _GTKMM_WIDGET_H
 
#include <gtkmmconfig.h>
 
 
#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>
 
/* Copyright (C) 2002, 2003 The gtkmm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
 
#include <pangomm/context.h>
#include <pangomm/layout.h>
 
#ifdef GTKMM_ATKMM_ENABLED
#include <atkmm/object.h>
#include <atkmm/implementor.h>
#endif //GTKMM_ATKMM_ENABLED
 
#include <gdkmm/event.h>
#include <gdkmm/types.h>
#include <gdkmm/window.h>
#include <gdkmm/dragcontext.h>
#include <gdkmm/pixbuf.h>
#include <gdkmm/screen.h>
#include <gtkmm/enums.h>
#include <gdkmm/display.h>
//#include <gtkmm/style.h>
#include <gtkmm/targetlist.h>
#include <gtkmm/rc.h>
#include <gtkmm/object.h>
#include <gtkmm/clipboard.h>
//#include <gtkmm/action.h>
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
extern "C"
{
typedef struct _GtkTargetEntry GtkTargetEntry;
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GtkWidget GtkWidget;
typedef struct _GtkWidgetClass GtkWidgetClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{ class Widget_Class; } // namespace Gtk
namespace Gtk
{
 
 
enum DestDefaults
{
  DEST_DEFAULT_MOTION = 1 << 0,
  DEST_DEFAULT_HIGHLIGHT = 1 << 1,
  DEST_DEFAULT_DROP = 1 << 2,
  DEST_DEFAULT_ALL = 0x07
};
 
inline DestDefaults operator|(DestDefaults lhs, DestDefaults rhs)
  { return static_cast<DestDefaults>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline DestDefaults operator&(DestDefaults lhs, DestDefaults rhs)
  { return static_cast<DestDefaults>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline DestDefaults operator^(DestDefaults lhs, DestDefaults rhs)
  { return static_cast<DestDefaults>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline DestDefaults operator~(DestDefaults flags)
  { return static_cast<DestDefaults>(~static_cast<unsigned>(flags)); }
 
inline DestDefaults& operator|=(DestDefaults& lhs, DestDefaults rhs)
  { return (lhs = static_cast<DestDefaults>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline DestDefaults& operator&=(DestDefaults& lhs, DestDefaults rhs)
  { return (lhs = static_cast<DestDefaults>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline DestDefaults& operator^=(DestDefaults& lhs, DestDefaults rhs)
  { return (lhs = static_cast<DestDefaults>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gtk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gtk::DestDefaults> : public Glib::Value_Flags<Gtk::DestDefaults>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{
 
enum WidgetFlags
{
  TOPLEVEL = 1 << 4,
  NO_WINDOW = 1 << 5,
  REALIZED = 1 << 6,
  MAPPED = 1 << 7,
  VISIBLE = 1 << 8,
  SENSITIVE = 1 << 9,
  PARENT_SENSITIVE = 1 << 10,
  CAN_FOCUS = 1 << 11,
  HAS_FOCUS = 1 << 12,
  CAN_DEFAULT = 1 << 13,
  HAS_DEFAULT = 1 << 14,
  HAS_GRAB = 1 << 15,
  RC_STYLE = 1 << 16,
  COMPOSITE_CHILD = 1 << 17,
  NO_REPARENT = 1 << 18,
  APP_PAINTABLE = 1 << 19,
  RECEIVES_DEFAULT = 1 << 20,
  DOUBLE_BUFFERED = 1 << 21,
  NO_SHOW_ALL = 1 << 22
};
 
inline WidgetFlags operator|(WidgetFlags lhs, WidgetFlags rhs)
  { return static_cast<WidgetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline WidgetFlags operator&(WidgetFlags lhs, WidgetFlags rhs)
  { return static_cast<WidgetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline WidgetFlags operator^(WidgetFlags lhs, WidgetFlags rhs)
  { return static_cast<WidgetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline WidgetFlags operator~(WidgetFlags flags)
  { return static_cast<WidgetFlags>(~static_cast<unsigned>(flags)); }
 
inline WidgetFlags& operator|=(WidgetFlags& lhs, WidgetFlags rhs)
  { return (lhs = static_cast<WidgetFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline WidgetFlags& operator&=(WidgetFlags& lhs, WidgetFlags rhs)
  { return (lhs = static_cast<WidgetFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline WidgetFlags& operator^=(WidgetFlags& lhs, WidgetFlags rhs)
  { return (lhs = static_cast<WidgetFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gtk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gtk::WidgetFlags> : public Glib::Value_Flags<Gtk::WidgetFlags>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{
 
enum WidgetHelpType
{
  WIDGET_HELP_TOOLTIP,
  WIDGET_HELP_WHATS_THIS
};
 
} // namespace Gtk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gtk::WidgetHelpType> : public Glib::Value_Enum<Gtk::WidgetHelpType>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{
 
enum DragResult
{
  DRAG_RESULT_SUCCESS,
  DRAG_RESULT_NO_TARGET,
  DRAG_RESULT_USER_CANCELLED,
  DRAG_RESULT_TIMEOUT_EXPIRED,
  DRAG_RESULT_GRAB_BROKEN,
  DRAG_RESULT_ERROR
};
 
} // namespace Gtk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gtk::DragResult> : public Glib::Value_Enum<Gtk::DragResult>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gtk
{
 
 
class Action;
class Style;
class AccelGroup;
class Adjustment;
class Window;
class Container;
class Settings;
class Tooltip;
 
typedef GtkRequisition Requisition;
 
// Gtk::Allocation is a typedef of Gdk::Rectangle because GtkAllocation is
// a typedef of GdkRectangle.
typedef Gdk::Rectangle Allocation;
 
class Widget
: public Object
#ifdef GTKMM_ATKMM_ENABLED
  ,public Atk::Implementor
#endif //GTKMM_ATKMM_ENABLED
{
  public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  typedef Widget CppObjectType;
  typedef Widget_Class CppClassType;
  typedef GtkWidget BaseObjectType;
  typedef GtkWidgetClass BaseClassType;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
  virtual ~Widget();
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
private:
  friend class Widget_Class;
  static CppClassType widget_class_;
 
  // noncopyable
  Widget(const Widget&);
  Widget& operator=(const Widget&);
 
protected:
  explicit Widget(const Glib::ConstructParams& construct_params);
  explicit Widget(GtkWidget* castitem);
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;
 
 
  static GType get_base_type() G_GNUC_CONST;
#endif
 
  GtkWidget*       gobj()       { return reinterpret_cast<GtkWidget*>(gobject_); }
 
  const GtkWidget* gobj() const { return reinterpret_cast<GtkWidget*>(gobject_); }
 
 
public:
  //C++ methods used to invoke GTK+ virtual functions:
 
protected:
  //GTK+ Virtual Functions (override these to change behaviour):
 
  //Default Signal Handlers::
  virtual void on_show();
  virtual void on_hide();
  virtual void on_map();
  virtual void on_unmap();
  virtual void on_realize();
  virtual void on_unrealize();
  virtual void on_size_request(Requisition* requisition);
  virtual void on_size_allocate(Allocation& allocation);
  virtual void on_state_changed(Gtk::StateType previous_state);
  virtual void on_parent_changed(Widget* previous_parent);
  virtual void on_hierarchy_changed(Widget* previous_toplevel);
  virtual void on_style_changed(const Glib::RefPtr<Gtk::Style>& previous_style);
  virtual void on_direction_changed(TextDirection direction);
  virtual void on_grab_notify(bool was_grabbed);
  virtual void on_child_notify(GParamSpec* pspec);
  virtual bool on_mnemonic_activate(bool group_cycling);
  virtual void on_grab_focus();
  virtual bool on_focus(DirectionType direction);
  virtual bool on_event(GdkEvent* event);
  virtual bool on_button_press_event(GdkEventButton* event);
  virtual bool on_button_release_event(GdkEventButton* event);
  virtual bool on_scroll_event(GdkEventScroll* event);
  virtual bool on_motion_notify_event(GdkEventMotion* event);
  virtual bool on_delete_event(GdkEventAny* event);
  virtual bool on_expose_event(GdkEventExpose* event);
  virtual bool on_key_press_event(GdkEventKey* event);
  virtual bool on_key_release_event(GdkEventKey* event);
  virtual bool on_enter_notify_event(GdkEventCrossing* event);
  virtual bool on_leave_notify_event(GdkEventCrossing* event);
  virtual bool on_configure_event(GdkEventConfigure* event);
  virtual bool on_focus_in_event(GdkEventFocus* event);
  virtual bool on_focus_out_event(GdkEventFocus* event);
  virtual bool on_map_event(GdkEventAny* event);
  virtual bool on_unmap_event(GdkEventAny* event);
  virtual bool on_property_notify_event(GdkEventProperty* event);
  virtual bool on_selection_clear_event(GdkEventSelection* event);
  virtual bool on_selection_request_event(GdkEventSelection* event);
  virtual bool on_selection_notify_event(GdkEventSelection* event);
  virtual bool on_proximity_in_event(GdkEventProximity* event);
  virtual bool on_proximity_out_event(GdkEventProximity* event);
  virtual bool on_visibility_notify_event(GdkEventVisibility* event);
  virtual bool on_client_event(GdkEventClient* event);
  virtual bool on_no_expose_event(GdkEventAny* event);
  virtual bool on_window_state_event(GdkEventWindowState* event);
  virtual void on_selection_get(SelectionData& selection_data, guint info, guint time);
  virtual void on_selection_received(const SelectionData& selection_data, guint time);
  virtual void on_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
  virtual void on_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
  virtual void on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, SelectionData& selection_data, guint info, guint time);
  virtual void on_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context);
  virtual void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time);
  virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
  virtual bool on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
  virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const SelectionData& selection_data, guint info, guint time);
  virtual bool on_touch_begin_event(GdkEventTouch* event);
  virtual bool on_touch_update_event(GdkEventTouch* event);
  virtual bool on_touch_end_event(GdkEventTouch* event);
#ifdef GTKMM_ATKMM_ENABLED
  virtual Glib::RefPtr<Atk::Object> on_get_accessible();
#endif // GTKMM_ATKMM_ENABLED
  virtual void on_screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_screen);
 
 
private:
 
  
  //gtkmmproc error: gtk_widget_set_visual : ignored method defs lookup failed//gtkmmproc error: gtk_widget_push_visual : ignored method defs lookup failed//gtkmmproc error: gtk_widget_pop_visual : ignored method defs lookup failed//gtkmmproc error: gtk_widget_set_default_visual : ignored method defs lookup failed//gtkmmproc error: gtk_widget_set_rc_style : ignored method defs lookup failed//gtkmmproc error: gtk_widget_restore_default_style : ignored method defs lookup failed
  
public:
  friend class Main;
  
 
  bool set_scroll_adjustments(Adjustment& hadjustment, Adjustment& vadjustment);
 
  
  void show();
  
  void show_now();
  
  void hide();
 
  
  void show_all();
 
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void hide_all();
#endif // GTKMM_DISABLE_DEPRECATED
 
 
/* QUEUE DRAWS */
 
  
  void queue_draw();
  
  void queue_draw_area(int x, int y, int width, int height);
  
  void queue_resize();
 
  Requisition size_request() const;
  
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void size_request(const Requisition& requisition);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  void size_allocate(const Allocation& allocation);
 
 
  void add_accelerator(const Glib::ustring& accel_signal, const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods, AccelFlags accel_flags);
 
  
  bool remove_accelerator(const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods);
  
  void set_accel_path(const Glib::ustring& accel_path, const Glib::RefPtr<AccelGroup>& accel_group);
 
  //GList* gtk_widget_list_accel_closures();
 
  //TODO: Or maybe it is useless: gboolean gtk_widget_can_activate_accel(GtkWidget *widget, guint signal_id)
 
  
  bool mnemonic_activate(bool group_cycling);
 
  
  //Probably not useful. Too C-specific: _WRAP_METHOD(bool can_activate_accel(guint signal_id) const, gtk_widget_can_activate_accel)
 
  //TODO: Use C++ type
  
  bool event(GdkEvent* event);
  
  int send_expose(GdkEvent* event);
  
  bool send_focus_change(GdkEvent* event);
  
  bool activate();
 
  
  void reparent(Widget & new_parent);
 
  bool intersect(const Gdk::Rectangle& area) const;
  
  bool intersect(const Gdk::Rectangle& area, Gdk::Rectangle& intersection) const;
 
  
  Gdk::Region region_intersect(const Gdk::Region& region) const;
 
  
  void freeze_child_notify();
  
  void child_notify(const Glib::ustring& child_property);
  
  void thaw_child_notify();
 
  
  void set_can_focus(bool can_focus =  true);
  
  bool get_can_focus() const;
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  bool can_focus() const;
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  bool has_focus() const;
 
  
  bool is_focus() const;
  
  void grab_focus();
  
  void set_can_default(bool can_default =  true);
  
  bool get_can_default() const;
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  bool can_default() const;
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  bool has_default() const;
  
  void grab_default();
  
  void set_receives_default(bool receives_default =  true);
  
  bool get_receives_default() const;
  
  bool has_grab() const;
 
  void add_modal_grab();
 
  void remove_modal_grab();
 
  static Widget* get_current_modal_grab();
 
  
  void set_name(const Glib::ustring& name);
  void unset_name();
  
  Glib::ustring get_name() const;
 
  
  void set_state(StateType state);
  
  StateType get_state() const;
  
  void set_sensitive(bool sensitive =  true);
  
  bool get_sensitive() const;
  
  bool is_sensitive() const;
  
  void set_visible(bool visible =  true);
  
  bool get_visible() const;
  
  void set_has_window(bool has_window =  true);
  
  bool get_has_window() const;
  
  bool get_is_toplevel() const;
  
  bool get_is_drawable() const;
  
  bool get_realized() const;
  
  bool get_mapped() const;
  
  void set_app_paintable(bool app_paintable =  true);
  
  bool get_app_paintable() const;
  
  void set_double_buffered(bool double_buffered =  true);
  
  bool get_double_buffered() const;
 
  
  void set_redraw_on_allocate(bool redraw_on_allocate =  true);
 
  
  void set_child_visible(bool is_visible =  true);
  
  bool get_child_visible() const;
 
  void set_window(const Glib::RefPtr<Gdk::Window>& window);
  
 
  Glib::RefPtr<Gdk::Window> get_window();
  
  Glib::RefPtr<const Gdk::Window> get_window() const;
 
  Allocation get_allocation() const;
  
 
  void set_allocation(const Allocation& allocation);
 
  
  Container* get_parent();
  
  const Container* get_parent() const;
 
  
  Glib::RefPtr<Gdk::Window> get_parent_window();
  
  Glib::RefPtr<const Gdk::Window> get_parent_window() const;
  
  void set_parent_window(const Glib::RefPtr<const Gdk::Window>& parent_window);
 
  
  bool child_focus(DirectionType direction);
 
  
  bool keynav_failed(DirectionType direction);
  
  void error_bell();
 
  
  void set_size_request(int width =  -1, int height =  -1);
  
  void get_size_request(int& width, int& height) const;
 
  
  void set_events(Gdk::EventMask events);
  
  void add_events(Gdk::EventMask events);
  
  void set_extension_events(Gdk::ExtensionMode mode);
 
  
  Gdk::ExtensionMode get_extension_events() const;
 
  
  Container* get_toplevel();
  
  const Container* get_toplevel() const;
 
  
  Widget* get_ancestor(GType widget_type);
  
  const Widget* get_ancestor(GType widget_type) const;
 
  
  Glib::RefPtr<Gdk::Colormap> get_colormap();
 
  
  Glib::RefPtr<Gdk::Visual> get_visual();
 
  
  Glib::RefPtr<Gdk::Screen> get_screen();
  
  Glib::RefPtr<const Gdk::Screen> get_screen() const;
 
  
  bool has_screen() const;
 
  
  Glib::RefPtr<Gdk::Display> get_display();
  
  Glib::RefPtr<const Gdk::Display> get_display() const;
 
  
  Glib::RefPtr<Gdk::Window> get_root_window();
  
  Glib::RefPtr<const Gdk::Window> get_root_window() const;
 
  
  Glib::RefPtr<Settings> get_settings();
 
  
  Glib::RefPtr<Clipboard> get_clipboard(const Glib::ustring& selection);
  
  Glib::RefPtr<const Clipboard> get_clipboard(const Glib::ustring& selection) const;
 
  
  Glib::RefPtr<Gdk::Pixmap> get_snapshot(Gdk::Rectangle& clip_rect) const;
 
  Glib::RefPtr<Gdk::Pixmap> get_snapshot() const;
 
  
#ifdef  GTKMM_ATKMM_ENABLED
 
  Glib::RefPtr<Atk::Object> get_accessible();
#endif //  GTKMM_ATKMM_ENABLED
 
  
#ifdef  GTKMM_ATKMM_ENABLED
 
  Glib::RefPtr<const Atk::Object> get_accessible() const;
#endif //  GTKMM_ATKMM_ENABLED
 
 
  void set_colormap(const Glib::RefPtr<const Gdk::Colormap> & colormap);
  
  Gdk::EventMask get_events() const;
  
  void get_pointer(int & x, int & y) const;
  
  bool is_ancestor(Widget & ancestor) const;
 
  
  bool translate_coordinates(Widget& dest_widget, int src_x, int src_y, int& dest_x, int& dest_y);
 
/* STYLE */
  
  bool has_rc_style() const;
  
  void set_style(const Glib::RefPtr<Style>& style);
  void unset_style();
 
  
  void ensure_style();
  
  Glib::RefPtr<Style> get_style();
  
  Glib::RefPtr<const Style> get_style() const;
  
  void modify_style(const Glib::RefPtr<RcStyle>& style);
  
  Glib::RefPtr<RcStyle> get_modifier_style();
  
  Glib::RefPtr<const RcStyle> get_modifier_style() const;
 
  // we need custom documentation because modify_* can take a NULL pointer
  // (which we wrap with unset_*)
  
  void modify_fg(StateType state, const Gdk::Color& color);
 
 
  void modify_bg(StateType state, const Gdk::Color& color);
 
  // TODO: Document this, and perhaps add unset_bg_pixmap
  void modify_bg_pixmap(StateType state, const Glib::ustring& pixmap_name);
 
  
  void modify_text(StateType state, const Gdk::Color& color);
 
  
  void modify_base(StateType state, const Gdk::Color& color);
 
  
  void modify_cursor(const Gdk::Color& primary, const Gdk::Color& secondary);
 
  void unset_cursor();
 
  
  void modify_font(const Pango::FontDescription& font_desc);
 
  void unset_fg(StateType state);
 
  void unset_bg(StateType state);
 
  void unset_text(StateType state);
 
  void unset_base(StateType state);
 
  void unset_font();
 
  //The parameter name is "the_property_name" to avoid a warning because there is a method with the "property_name" name.
  template <class PropertyType>
  void get_style_property(const Glib::ustring& the_property_name, PropertyType& value) const;
 
  
  Glib::RefPtr<Pango::Context> create_pango_context();
  
  Glib::RefPtr<Pango::Context> get_pango_context();
  
  Glib::RefPtr<Pango::Layout> create_pango_layout(const Glib::ustring& text);
 
  
  Glib::RefPtr<Gdk::Pixbuf> render_icon(const StockID& stock_id, IconSize size, const Glib::ustring& detail =  Glib::ustring());
 
  
  void set_composite_name(const Glib::ustring& name);
  void unset_composite_name();
  
  Glib::ustring get_composite_name() const;
 
  
  void reset_rc_styles();
 
  // PUSH/POP - these are used to create widgets.  Hidden arguments to override the defaults.
  
  static void push_colormap(const Glib::RefPtr<const Gdk::Colormap>& cmap);
  
  static void pop_colormap();
 
  
  static void push_composite_child();
  
  static void pop_composite_child();
 
/* DEFAULTS */
 
  
  static void set_default_colormap(const Glib::RefPtr<const Gdk::Colormap>& colormap);
  
  static Glib::RefPtr<Style> get_default_style();
  
  static Glib::RefPtr<Gdk::Colormap> get_default_colormap();
  
  static Glib::RefPtr<Gdk::Visual> get_default_visual();
 
/* Directionality of Text */
 
  
  void set_direction(TextDirection dir);
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  TextDirection get_direction();
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  TextDirection get_direction() const;
 
  
  static void set_default_direction(TextDirection dir);
  
  static TextDirection get_default_direction();
 
/* Shape masking */
  
  void shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y);
  void unset_shape_combine_mask();
  
  void input_shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y);
  void unset_input_shape_combine_mask();
 
  // must be realized
  
  void reset_shapes();
 
/* Paths */
  void path(Glib::ustring& path, Glib::ustring& path_reversed);
  void class_path(Glib::ustring& path, Glib::ustring& path_reversed);
  
 
  Glib::ListHandle<Widget*> list_mnemonic_labels();
 
  Glib::ListHandle<const Widget*> list_mnemonic_labels() const;
 
  void add_mnemonic_label(Widget& label);
 
  void remove_mnemonic_label(Widget& label);
 
  //TODO: Should drag_get_data() be const?
  
#ifndef GTKMM_DISABLE_DEPRECATED
 
  void drag_get_data(const Glib::RefPtr<Gdk::DragContext>& context, Glib::ustring& target, guint32 time);
#endif // GTKMM_DISABLE_DEPRECATED
 
 
  void drag_get_data(const Glib::RefPtr<Gdk::DragContext>& context, const Glib::ustring& target, guint32 time);
 
  
  void drag_highlight();
  
  void drag_unhighlight();
 
  //TODO: Change the defaults? Maybe we should use ALL for DestDefaults. See other drag_dest_set() methods here and in other widgets.
  void drag_dest_set(DestDefaults flags = DestDefaults(0), Gdk::DragAction actions = Gdk::DragAction(0));
  void drag_dest_set(const ArrayHandle_TargetEntry& targets, DestDefaults flags = DEST_DEFAULT_ALL, Gdk::DragAction actions = Gdk::ACTION_COPY);
  
 
  void drag_dest_set_proxy(const Glib::RefPtr<Gdk::Window>& proxy_window, Gdk::DragProtocol protocol, bool use_coordinates);
  
  void drag_dest_unset();
  
  Glib::ustring drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context, const Glib::RefPtr<TargetList>& target_list) const;
  Glib::ustring drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context) const;
 
  
  Glib::RefPtr<TargetList> drag_dest_get_target_list();
  
  Glib::RefPtr<const TargetList> drag_dest_get_target_list() const;
  
  void drag_dest_set_target_list(const Glib::RefPtr<TargetList>& target_list);
 
  
  void drag_dest_add_text_targets();
  
  void drag_dest_add_image_targets();
  
  void drag_dest_add_uri_targets();
 
  void drag_source_set(const ArrayHandle_TargetEntry& targets, Gdk::ModifierType start_button_mask = Gdk::MODIFIER_MASK, Gdk::DragAction actions = Gdk::ACTION_COPY);
  
 
  void drag_source_unset();
 
  
  void drag_source_set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask);
  
  void drag_source_set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
  
  void drag_source_set_icon(const StockID& stock_id);
  
  void drag_source_set_icon(const Glib::ustring& icon_name);
 
  
  void drag_source_add_text_targets();
  
  void drag_source_add_uri_targets();
  
  void drag_source_add_image_targets();
 
  
  Glib::RefPtr<Gdk::DragContext> drag_begin(const Glib::RefPtr<TargetList>& targets, Gdk::DragAction actions, int button, GdkEvent* event);
  
  bool drag_check_threshold(int start_x, int start_y, int current_x, int current_y);
  //gtkmmproc error: _gtk_drag_source_handle_event : ignored method defs lookup failed//gtkmmproc error: _gtk_drag_dest_handle_event : ignored method defs lookup failed
 
  //These should be a method of Gdk::DragContext, but gdkmm can't depend on gtkmm.
  static Widget* drag_get_source_widget(const Glib::RefPtr<Gdk::DragContext>& context);
  void drag_set_as_icon(const Glib::RefPtr<Gdk::DragContext>& context, int hot_x, int hot_y);
 
  
  void queue_resize_no_redraw();
  
  bool get_no_show_all() const;
  
  void set_no_show_all(bool no_show_all =  true);
 
  //Used when implementing containers:
  
  void set_parent(Widget& parent);
  
  void unparent();
 
  //TODO: When exactly do we need to custom containers need to call map() on the child widgets?
  //Most containers that derive from GtkContainer do not need to, but GtkNotebook does.
  
  void map();
  
  void unmap();
 
  //TODO: The drawable should be passed by reference, when we can break API/ABI, but it's not the end of the world. murrayc.
  void draw_insertion_cursor(Glib::RefPtr<Gdk::Drawable> drawable, const Gdk::Rectangle& area, const Gdk::Rectangle& location, bool is_primary, TextDirection direction, bool draw_arrow = true);
  
 
  // Gtk+ 2.12 tooltip API
  
  void set_tooltip_window(Window& window);
  
  Window* get_tooltip_window();
  
  void trigger_tooltip_query();
  
  void set_tooltip_text(const Glib::ustring& text);
  
  Glib::ustring get_tooltip_text() const;
  
  void set_tooltip_markup(const Glib::ustring& markup);
  
  Glib::ustring get_tooltip_markup() const;
  
  void set_has_tooltip(bool has_tooltip =  TRUE);
  
  bool get_has_tooltip() const;
 
#ifndef GTKMM_DISABLE_DEPRECATED
 
  bool has_no_window() const;
 
  bool is_realized() const;
 
  bool is_mapped() const;
 
  bool is_toplevel() const;
 
  bool is_drawable() const;
 
  bool is_visible() const;
 
  bool sensitive() const;
 
  bool app_paintable() const;
 
  bool receives_default() const;
 
  bool double_buffered() const;
 
  bool parent_sensitive() const;
 
  bool rc_style() const;
 
  bool is_composite_child() const;
 
  WidgetFlags get_flags() const;
 
  void set_flags(WidgetFlags flags);
 
  void unset_flags(WidgetFlags flags);
 
  //TODO: Remove this when we can break ABI:
   Gtk::StateType get_saved_state() const;
 
  #endif // GTKMM_DISABLE_DEPRECATED
 
 
  int get_width() const;
  int get_height() const;
 
  
  bool is_composited() const;
 
  //TODO: Deprecate this when the other widgets can derive from Gtk::Activatable.
  
  Glib::RefPtr<Action> get_action();
  
  Glib::RefPtr<const Action> get_action() const;
 
  //TODO: Move this to protected when we can break API:
  Requisition get_requisition() const;
  
 
  Glib::SignalProxy0< void > signal_show();
 
  
  Glib::SignalProxy0< void > signal_hide();
 
 
  //- See {flags.mapped}.
  
  Glib::SignalProxy0< void > signal_map();
 
 
  //- See {flags.mapped}.
  
  Glib::SignalProxy0< void > signal_unmap();
 
 
  //- 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.
  
  Glib::SignalProxy0< void > signal_realize();
 
 
  //- See {flags.realized}.  This should not be called by the user.
  //__WRAP(meth|sig|impl,void unrealize_(),gtk_widget_unrealize,"unrealize")
  
  Glib::SignalProxy0< void > signal_unrealize();
 
 
  Glib::SignalProxy1< void,Requisition* > signal_size_request();
 
  
  Glib::SignalProxy1< void,Allocation& > signal_size_allocate();
 
 
// 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.
 
  
  Glib::SignalProxy1< void,Gtk::StateType > signal_state_changed();
 
 
  //- The widget passed is the former parent, which may be 0 if
  //- there was no parent. (was parent_set in GTK+)
  
  Glib::SignalProxy1< void,Widget* > signal_parent_changed();
 
 
  Glib::SignalProxy1< void,Widget* > signal_hierarchy_changed();
 
 
//Note: We use Gtk::Style instead of Style here, to fix a build problem on MacOS X
//that we don't fully understand. See bug #493057.
 
 
  Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::Style>& > signal_style_changed();
 
 
  Glib::SignalProxy1< void,TextDirection > signal_direction_changed();
 
 
  Glib::SignalProxy1< void,bool > signal_grab_notify();
 
 
  Glib::SignalProxy1< void,GParamSpec* > signal_child_notify();
 
 
  //_WRAP_SIGNAL(void add_accelerator(guint, GtkAccelGroup*, guint accel_key, Gdk::ModifierType, AccelFlags), "add-accelerator")
  //_WRAP_SIGNAL(void remove_accelerator(GtkAccelGroup* accel_group, guint, Gdk::ModifierType), "remove-accelerator")
  
  Glib::SignalProxy1< bool,bool > signal_mnemonic_activate();
 
  
  Glib::SignalProxy0< void > signal_grab_focus();
 
  
  Glib::SignalProxy1< bool,DirectionType > signal_focus();
 
  
  Glib::SignalProxy1< bool,GdkEvent* > signal_event();
 
  
  Glib::SignalProxy1< void,GdkEvent* > signal_event_after();
 
 
  Glib::SignalProxy1< bool,GdkEventButton* > signal_button_press_event();
 
 
  Glib::SignalProxy1< bool,GdkEventButton* > signal_button_release_event();
 
 
  Glib::SignalProxy1< bool,GdkEventScroll* > signal_scroll_event();
 
 
  Glib::SignalProxy1< bool,GdkEventMotion* > signal_motion_notify_event();
 
 
  Glib::SignalProxy1< bool,GdkEventAny* > signal_delete_event();
 
 
  //- 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.
  
  Glib::SignalProxy1< bool,GdkEventExpose* > signal_expose_event();
 
 
  Glib::SignalProxy1< bool,GdkEventKey* > signal_key_press_event();
 
 
  Glib::SignalProxy1< bool,GdkEventKey* > signal_key_release_event();
 
 
  Glib::SignalProxy1< bool,GdkEventCrossing* > signal_enter_notify_event();
 
 
  Glib::SignalProxy1< bool,GdkEventCrossing* > signal_leave_notify_event();
 
 
  Glib::SignalProxy1< bool,GdkEventConfigure* > signal_configure_event();
 
  
  Glib::SignalProxy1< bool,GdkEventFocus* > signal_focus_in_event();
 
  
  Glib::SignalProxy1< bool,GdkEventFocus* > signal_focus_out_event();
 
  
  Glib::SignalProxy1< bool,GdkEventAny* > signal_map_event();
 
  
  Glib::SignalProxy1< bool,GdkEventAny* > signal_unmap_event();
 
  
  Glib::SignalProxy1< bool,GdkEventProperty* > signal_property_notify_event();
 
  
  Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_clear_event();
 
  
  Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_request_event();
 
  
  Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_notify_event();
 
  
  Glib::SignalProxy1< bool,GdkEventProximity* > signal_proximity_in_event();
 
  
  Glib::SignalProxy1< bool,GdkEventProximity* > signal_proximity_out_event();
 
  
  Glib::SignalProxy1< bool,GdkEventVisibility* > signal_visibility_notify_event();
 
  
  Glib::SignalProxy1< bool,GdkEventClient* > signal_client_event();
 
  
  Glib::SignalProxy1< bool,GdkEventAny* > signal_no_expose_event();
 
  
  Glib::SignalProxy1< bool,GdkEventWindowState* > signal_window_state_event();
 
 
  //We use the optional custom_c_callback parameter with _WRAP_SIGNAL() for some of these,
  //so that we can write special code to wrap the non-const SelectionData& output parameters:
  
  Glib::SignalProxy3< void,SelectionData&,guint,guint > signal_selection_get();
 
  
  Glib::SignalProxy2< void,const SelectionData&,guint > signal_selection_received();
 
 
  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_begin();
 
 
  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_end();
 
 
  Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > signal_drag_data_get();
 
 
  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_data_delete();
 
 
  Glib::SignalProxy2< bool,const Glib::RefPtr<Gdk::DragContext>&,DragResult > signal_drag_failed();
 
 
  Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint > signal_drag_leave();
 
 
  Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > signal_drag_motion();
 
 
  Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > signal_drag_drop();
 
 
  Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > signal_drag_data_received();
 
 
  //Note that the deprecated keyword has no effect on _WRAP_SIGNAL() yet.
  //It doesn't seem like a good idea to put virtual functions in #ifdefs, because that would change the size of the class instances.
  
#ifdef GTKMM_ATKMM_ENABLED
#ifndef GTKMM_DISABLE_DEPRECATED
 
  Glib::SignalProxy0< Glib::RefPtr<Atk::Object> > signal_get_accessible();
#endif // GTKMM_DISABLE_DEPRECATED
 
#endif // GTKMM_ATKMM_ENABLED
 
 
  Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& > signal_screen_changed();
 
 
  Glib::SignalProxy0< void > signal_composited_changed();
 
 
//TODO: The signal_id is very C-like here:
  //_WRAP_SIGNAL(bool can_activate_accel(guint signal_id), "can_activate_accel")
 
  
  Glib::SignalProxy0< bool > signal_popup_menu();
 //Note that popup-menu is a keybinding signal, but is really meant to be wrapped.
 
  //Keybinding signals:
  
  
  // Tooltip signal
  
  Glib::SignalProxy4< bool,int,int,bool,const Glib::RefPtr<Tooltip>& > signal_query_tooltip();
 
 
  //(This was added to GTK+ 2.8 but forgotten by us until gtkmm 2.13/14):
  
  Glib::SignalProxy1< bool,GdkEventGrabBroken* > signal_grab_broken_event();
 
 
  Glib::SignalProxy1< bool,GdkEventExpose* > signal_damage_event();
 
 
  Glib::PropertyProxy< Glib::ustring > property_name() ;
 
  Glib::PropertyProxy_ReadOnly< Glib::ustring > property_name() const;
 
  Glib::PropertyProxy< Container* > property_parent() ;
 
  Glib::PropertyProxy_ReadOnly< Container* > property_parent() const;
 
  Glib::PropertyProxy< int > property_width_request() ;
 
  Glib::PropertyProxy_ReadOnly< int > property_width_request() const;
 
  Glib::PropertyProxy< int > property_height_request() ;
 
  Glib::PropertyProxy_ReadOnly< int > property_height_request() const;
 
  Glib::PropertyProxy< bool > property_visible() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_visible() const;
 
  Glib::PropertyProxy< bool > property_sensitive() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_sensitive() const;
 
  Glib::PropertyProxy< bool > property_app_paintable() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_app_paintable() const;
 
  Glib::PropertyProxy< bool > property_can_focus() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_can_focus() const;
 
  Glib::PropertyProxy< bool > property_has_focus() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_has_focus() const;
 
  Glib::PropertyProxy< bool > property_is_focus() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_is_focus() const;
 
  Glib::PropertyProxy< bool > property_can_default() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_can_default() const;
 
  Glib::PropertyProxy< bool > property_has_default() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_has_default() const;
 
  Glib::PropertyProxy< bool > property_receives_default() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_receives_default() const;
 
  Glib::PropertyProxy_ReadOnly< bool > property_composite_child() const;
 
 
  Glib::PropertyProxy< Glib::RefPtr<Style> > property_style() ;
 
  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> > property_style() const;
 
  Glib::PropertyProxy< Gdk::EventMask > property_events() ;
 
  Glib::PropertyProxy_ReadOnly< Gdk::EventMask > property_events() const;
 
  Glib::PropertyProxy< Gdk::ExtensionMode > property_extension_events() ;
 
  Glib::PropertyProxy_ReadOnly< Gdk::ExtensionMode > property_extension_events() const;
 
  Glib::PropertyProxy< bool > property_has_tooltip() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_has_tooltip() const;
 
  Glib::PropertyProxy< Glib::ustring > property_tooltip_markup() ;
 
  Glib::PropertyProxy_ReadOnly< Glib::ustring > property_tooltip_markup() const;
 
  Glib::PropertyProxy< Glib::ustring > property_tooltip_text() ;
 
  Glib::PropertyProxy_ReadOnly< Glib::ustring > property_tooltip_text() const;
 
  Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Window> > property_window() const;
 
 
  Glib::PropertyProxy< bool > property_no_show_all() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_no_show_all() const;
 
  Glib::PropertyProxy< bool > property_double_buffered() ;
 
  Glib::PropertyProxy_ReadOnly< bool > property_double_buffered() const;
 
 
protected:
  //comment in GTK+ header: "seldomly overidden"
    virtual void dispatch_child_properties_changed_vfunc(guint p1, GParamSpec** p2);
 
 
    virtual void show_all_vfunc();
 
    virtual void hide_all_vfunc();
 
 
#ifdef  GTKMM_ATKMM_ENABLED
  virtual Glib::RefPtr<Atk::Object> get_accessible_vfunc();
 
#endif //  GTKMM_ATKMM_ENABLED
 
 
protected:
  Widget();
 
  
  void realize();
  
  void unrealize();
 
  
  void set_mapped(bool mapped =  true);
  
  void set_realized(bool realized =  true);
  
  void style_attach();
 
  
  void get_child_requisition(Requisition& requisition) const;
 
  //The parameter name is "the_property_name" to avoid a warning because there is a method with the "property_name" name.
  
  void get_style_property_value(const Glib::ustring& the_property_name, Glib::ValueBase& value) const;
 
  void realize_if_needed();
 
 
};
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
//The parameter name is "the_property_name" to avoid a warning because there is a method with the "property_name" name.
template <class PropertyType>
void Widget::get_style_property(const Glib::ustring& the_property_name, PropertyType& value) const
{
  Glib::Value<PropertyType> property_value;
  property_value.init(Glib::Value<PropertyType>::value_type());
 
  this->get_style_property_value(the_property_name, property_value);
 
  value = property_value.get();
}
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
} // namespace Gtk
 
 
namespace Glib
{
  Gtk::Widget* wrap(GtkWidget* object, bool take_copy = false);
} //namespace Glib
 
 
#endif /* _GTKMM_WIDGET_H */