ydkmm/ydkmm/gdkmm/window.h

Go to the documentation of this file.

// -*- c++ -*-
// Generated by gmmproc 2.45.3 -- DO NOT MODIFY!
#ifndef _GDKMM_WINDOW_H
#define _GDKMM_WINDOW_H
 
#include <gdkmmconfig.h>
 
 
#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>
 
/* Copyright(C) 1998-2002 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 <gdkmm/region.h>
#include <gdkmm/drawable.h>
#include <gdkmm/bitmap.h>
//#include <gdkmm/cursor.h>
#include <gdkmm/dragcontext.h>
#include <gdkmm/types.h>
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
extern "C" {
// Custom struct prototype, because this isn't what the code-generator expects:
typedef struct _GdkDrawable GdkWindow;
} // extern "C"
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Gdk
{ class Window_Class; } // namespace Gdk
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
namespace Gdk
{
 
enum EventMask
{
  EXPOSURE_MASK = 1 << 1,
  POINTER_MOTION_MASK = 1 << 2,
  POINTER_MOTION_HINT_MASK = 1 << 3,
  BUTTON_MOTION_MASK = 1 << 4,
  BUTTON1_MOTION_MASK = 1 << 5,
  BUTTON2_MOTION_MASK = 1 << 6,
  BUTTON3_MOTION_MASK = 1 << 7,
  BUTTON_PRESS_MASK = 1 << 8,
  BUTTON_RELEASE_MASK = 1 << 9,
  KEY_PRESS_MASK = 1 << 10,
  KEY_RELEASE_MASK = 1 << 11,
  ENTER_NOTIFY_MASK = 1 << 12,
  LEAVE_NOTIFY_MASK = 1 << 13,
  FOCUS_CHANGE_MASK = 1 << 14,
  STRUCTURE_MASK = 1 << 15,
  PROPERTY_CHANGE_MASK = 1 << 16,
  VISIBILITY_NOTIFY_MASK = 1 << 17,
  PROXIMITY_IN_MASK = 1 << 18,
  PROXIMITY_OUT_MASK = 1 << 19,
  SUBSTRUCTURE_MASK = 1 << 20,
  SCROLL_MASK = 1 << 21,
  TOUCH_BEGIN_MASK = 1 << 22,
  TOUCH_UPDATE_MASK = 1 << 23,
  TOUCH_END_MASK = 1 << 24,
  ALL_EVENTS_MASK = 0x3FFFFE
};
 
inline EventMask operator|(EventMask lhs, EventMask rhs)
  { return static_cast<EventMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline EventMask operator&(EventMask lhs, EventMask rhs)
  { return static_cast<EventMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline EventMask operator^(EventMask lhs, EventMask rhs)
  { return static_cast<EventMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline EventMask operator~(EventMask flags)
  { return static_cast<EventMask>(~static_cast<unsigned>(flags)); }
 
inline EventMask& operator|=(EventMask& lhs, EventMask rhs)
  { return (lhs = static_cast<EventMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline EventMask& operator&=(EventMask& lhs, EventMask rhs)
  { return (lhs = static_cast<EventMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline EventMask& operator^=(EventMask& lhs, EventMask rhs)
  { return (lhs = static_cast<EventMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::EventMask> : public Glib::Value_Flags<Gdk::EventMask>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WindowState
{
  WINDOW_STATE_WITHDRAWN = 1 << 0,
  WINDOW_STATE_ICONIFIED = 1 << 1,
  WINDOW_STATE_MAXIMIZED = 1 << 2,
  WINDOW_STATE_STICKY = 1 << 3,
  WINDOW_STATE_FULLSCREEN = 1 << 4,
  WINDOW_STATE_ABOVE = 1 << 5,
  WINDOW_STATE_BELOW = 1 << 6
};
 
inline WindowState operator|(WindowState lhs, WindowState rhs)
  { return static_cast<WindowState>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline WindowState operator&(WindowState lhs, WindowState rhs)
  { return static_cast<WindowState>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline WindowState operator^(WindowState lhs, WindowState rhs)
  { return static_cast<WindowState>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline WindowState operator~(WindowState flags)
  { return static_cast<WindowState>(~static_cast<unsigned>(flags)); }
 
inline WindowState& operator|=(WindowState& lhs, WindowState rhs)
  { return (lhs = static_cast<WindowState>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline WindowState& operator&=(WindowState& lhs, WindowState rhs)
  { return (lhs = static_cast<WindowState>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline WindowState& operator^=(WindowState& lhs, WindowState rhs)
  { return (lhs = static_cast<WindowState>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WindowState> : public Glib::Value_Flags<Gdk::WindowState>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WindowType
{
  WINDOW_ROOT,
  WINDOW_TOPLEVEL,
  WINDOW_CHILD,
  WINDOW_DIALOG,
  WINDOW_TEMP,
  WINDOW_FOREIGN,
  WINDOW_OFFSCREEN
};
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WindowType> : public Glib::Value_Enum<Gdk::WindowType>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WindowAttributesType
{
  WA_TITLE = 1 << 1,
  WA_X = 1 << 2,
  WA_Y = 1 << 3,
  WA_CURSOR = 1 << 4,
  WA_COLORMAP = 1 << 5,
  WA_VISUAL = 1 << 6,
  WA_WMCLASS = 1 << 7,
  WA_NOREDIR = 1 << 8,
  WA_TYPE_HINT = 1 << 9
};
 
inline WindowAttributesType operator|(WindowAttributesType lhs, WindowAttributesType rhs)
  { return static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline WindowAttributesType operator&(WindowAttributesType lhs, WindowAttributesType rhs)
  { return static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline WindowAttributesType operator^(WindowAttributesType lhs, WindowAttributesType rhs)
  { return static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline WindowAttributesType operator~(WindowAttributesType flags)
  { return static_cast<WindowAttributesType>(~static_cast<unsigned>(flags)); }
 
inline WindowAttributesType& operator|=(WindowAttributesType& lhs, WindowAttributesType rhs)
  { return (lhs = static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline WindowAttributesType& operator&=(WindowAttributesType& lhs, WindowAttributesType rhs)
  { return (lhs = static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline WindowAttributesType& operator^=(WindowAttributesType& lhs, WindowAttributesType rhs)
  { return (lhs = static_cast<WindowAttributesType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WindowAttributesType> : public Glib::Value_Flags<Gdk::WindowAttributesType>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WindowHints
{
  HINT_POS = 1 << 0,
  HINT_MIN_SIZE = 1 << 1,
  HINT_MAX_SIZE = 1 << 2,
  HINT_BASE_SIZE = 1 << 3,
  HINT_ASPECT = 1 << 4,
  HINT_RESIZE_INC = 1 << 5,
  HINT_WIN_GRAVITY = 1 << 6,
  HINT_USER_POS = 1 << 7,
  HINT_USER_SIZE = 1 << 8
};
 
inline WindowHints operator|(WindowHints lhs, WindowHints rhs)
  { return static_cast<WindowHints>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline WindowHints operator&(WindowHints lhs, WindowHints rhs)
  { return static_cast<WindowHints>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline WindowHints operator^(WindowHints lhs, WindowHints rhs)
  { return static_cast<WindowHints>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline WindowHints operator~(WindowHints flags)
  { return static_cast<WindowHints>(~static_cast<unsigned>(flags)); }
 
inline WindowHints& operator|=(WindowHints& lhs, WindowHints rhs)
  { return (lhs = static_cast<WindowHints>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline WindowHints& operator&=(WindowHints& lhs, WindowHints rhs)
  { return (lhs = static_cast<WindowHints>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline WindowHints& operator^=(WindowHints& lhs, WindowHints rhs)
  { return (lhs = static_cast<WindowHints>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WindowHints> : public Glib::Value_Flags<Gdk::WindowHints>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WindowTypeHint
{
  WINDOW_TYPE_HINT_NORMAL,
  WINDOW_TYPE_HINT_DIALOG,
  WINDOW_TYPE_HINT_MENU,
  WINDOW_TYPE_HINT_TOOLBAR,
  WINDOW_TYPE_HINT_SPLASHSCREEN,
  WINDOW_TYPE_HINT_UTILITY,
  WINDOW_TYPE_HINT_DOCK,
  WINDOW_TYPE_HINT_DESKTOP,
  WINDOW_TYPE_HINT_DROPDOWN_MENU,
  WINDOW_TYPE_HINT_POPUP_MENU,
  WINDOW_TYPE_HINT_TOOLTIP,
  WINDOW_TYPE_HINT_NOTIFICATION,
  WINDOW_TYPE_HINT_COMBO,
  WINDOW_TYPE_HINT_DND
};
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WindowTypeHint> : public Glib::Value_Enum<Gdk::WindowTypeHint>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WMDecoration
{
  DECOR_ALL = 1 << 0,
  DECOR_BORDER = 1 << 1,
  DECOR_RESIZEH = 1 << 2,
  DECOR_TITLE = 1 << 3,
  DECOR_MENU = 1 << 4,
  DECOR_MINIMIZE = 1 << 5,
  DECOR_MAXIMIZE = 1 << 6
};
 
inline WMDecoration operator|(WMDecoration lhs, WMDecoration rhs)
  { return static_cast<WMDecoration>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline WMDecoration operator&(WMDecoration lhs, WMDecoration rhs)
  { return static_cast<WMDecoration>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline WMDecoration operator^(WMDecoration lhs, WMDecoration rhs)
  { return static_cast<WMDecoration>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline WMDecoration operator~(WMDecoration flags)
  { return static_cast<WMDecoration>(~static_cast<unsigned>(flags)); }
 
inline WMDecoration& operator|=(WMDecoration& lhs, WMDecoration rhs)
  { return (lhs = static_cast<WMDecoration>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline WMDecoration& operator&=(WMDecoration& lhs, WMDecoration rhs)
  { return (lhs = static_cast<WMDecoration>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline WMDecoration& operator^=(WMDecoration& lhs, WMDecoration rhs)
  { return (lhs = static_cast<WMDecoration>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WMDecoration> : public Glib::Value_Flags<Gdk::WMDecoration>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WMFunction
{
  FUNC_ALL = 1 << 0,
  FUNC_RESIZE = 1 << 1,
  FUNC_MOVE = 1 << 2,
  FUNC_MINIMIZE = 1 << 3,
  FUNC_MAXIMIZE = 1 << 4,
  FUNC_CLOSE = 1 << 5
};
 
inline WMFunction operator|(WMFunction lhs, WMFunction rhs)
  { return static_cast<WMFunction>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
 
inline WMFunction operator&(WMFunction lhs, WMFunction rhs)
  { return static_cast<WMFunction>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
 
inline WMFunction operator^(WMFunction lhs, WMFunction rhs)
  { return static_cast<WMFunction>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
 
inline WMFunction operator~(WMFunction flags)
  { return static_cast<WMFunction>(~static_cast<unsigned>(flags)); }
 
inline WMFunction& operator|=(WMFunction& lhs, WMFunction rhs)
  { return (lhs = static_cast<WMFunction>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
 
inline WMFunction& operator&=(WMFunction& lhs, WMFunction rhs)
  { return (lhs = static_cast<WMFunction>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
 
inline WMFunction& operator^=(WMFunction& lhs, WMFunction rhs)
  { return (lhs = static_cast<WMFunction>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WMFunction> : public Glib::Value_Flags<Gdk::WMFunction>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum WindowEdge
{
  WINDOW_EDGE_NORTH_WEST,
  WINDOW_EDGE_NORTH,
  WINDOW_EDGE_NORTH_EAST,
  WINDOW_EDGE_WEST,
  WINDOW_EDGE_EAST,
  WINDOW_EDGE_SOUTH_WEST,
  WINDOW_EDGE_SOUTH,
  WINDOW_EDGE_SOUTH_EAST
};
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::WindowEdge> : public Glib::Value_Enum<Gdk::WindowEdge>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum Gravity
{
  GRAVITY_NORTH_WEST = 1,
  GRAVITY_NORTH,
  GRAVITY_NORTH_EAST,
  GRAVITY_WEST,
  GRAVITY_CENTER,
  GRAVITY_EAST,
  GRAVITY_SOUTH_WEST,
  GRAVITY_SOUTH,
  GRAVITY_SOUTH_EAST,
  GRAVITY_STATIC
};
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::Gravity> : public Glib::Value_Enum<Gdk::Gravity>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
enum GrabStatus
{
  GRAB_SUCCESS,
  GRAB_ALREADY_GRABBED,
  GRAB_INVALID_TIME,
  GRAB_NOT_VIEWABLE,
  GRAB_FROZEN
};
 
} // namespace Gdk
 
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
 
template <>
class Value<Gdk::GrabStatus> : public Glib::Value_Enum<Gdk::GrabStatus>
{
public:
  static GType value_type() G_GNUC_CONST;
};
 
} // namespace Glib
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
namespace Gdk
{
 
 
class Cursor;
 
class Window : public Gdk::Drawable
{
  // GdkWindow is a typedef to GdkDrawable, but it's actually a GdkWindowObject.
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
public:
  typedef Window CppObjectType;
  typedef Window_Class CppClassType;
  typedef GdkWindow BaseObjectType;
  typedef GdkWindowObjectClass BaseClassType;
 
private:  friend class Window_Class;
  static CppClassType window_class_;
 
private:
  // noncopyable
  Window(const Window&);
  Window& operator=(const Window&);
 
protected:
  explicit Window(const Glib::ConstructParams& construct_params);
  explicit Window(GdkWindow* castitem);
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
public:
  virtual ~Window();
 
  static GType get_type()      G_GNUC_CONST;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
 
  static GType get_base_type() G_GNUC_CONST;
#endif
 
  GdkWindow*       gobj()       { return reinterpret_cast<GdkWindow*>(gobject_); }
 
  const GdkWindow* gobj() const { return reinterpret_cast<GdkWindow*>(gobject_); }
 
  GdkWindow* gobj_copy();
 
private:
 
  
protected:
  Window(const Glib::RefPtr<Window>& parent, GdkWindowAttr* attributes, int attributes_mask);
 
public:
  
  static Glib::RefPtr<Window> create(const Glib::RefPtr<Window>& parent, GdkWindowAttr* attributes, int attributes_mask);
 
 
  WindowType get_window_type() const;
  
  
  Glib::RefPtr<Visual> get_visual();
  
  Glib::RefPtr<const Visual> get_visual() const;
 
  
  Glib::RefPtr<Screen> get_screen();
  
  Glib::RefPtr<const Screen> get_screen() const;
  
  
  Glib::RefPtr<Display> get_display();
  
  Glib::RefPtr<const Display> get_display() const;
 
  
  void show();
  
  void hide();
  
  void withdraw();
  
  void show_unraised();
  
  void move(int x, int y);
  
  void resize(int width, int height);
  
  void move_resize(int x, int y, int width, int height);
  
  void reparent(const Glib::RefPtr<Window>& new_parent, int x, int y);
  
  void clear();
  
  void clear_area(int x, int y, int width, int height);
  
  void clear_area_e(int x, int y, int width, int height);
  
  void raise();
  
  void lower();
 
  
  void restack(const Glib::RefPtr<Window>& sibling, bool above);
 
  void restack(bool above);
 
  
  void focus(guint32 timestamp);
  
  void set_user_data(gpointer user_data);
  
  void set_override_redirect(bool override_redirect =  true);
 
  //We could wrap these with a Slot instead of a C callback, but these methods are very low-level anyway.
  
  void add_filter(GdkFilterFunc function, gpointer data);
  
  void remove_filter(GdkFilterFunc function, gpointer data);
 
  
  void scroll(int dx, int dy);
  
  void move_region(const Region& region, int dx, int dy);
  
  bool ensure_native();
 
  
  void shape_combine_mask(const Glib::RefPtr<Bitmap>& mask, int x, int y);
  void unset_shape_combine_mask();
 
  
  void shape_combine_region(const Region& shape_region, int offset_x, int offset_y);
  
  void set_child_shapes();
  
  bool get_composited() const;
  
  void set_composited(bool composited =  TRUE);
  
  void merge_child_shapes();
 
  
  void input_shape_combine_mask(const Glib::RefPtr<Bitmap>& mask, int x, int y);
  
  void input_shape_combine_region(const Region& shape_region, int offset_x, int offset_y);
  
  void set_child_input_shapes();
  
  void merge_child_input_shapes();
 
  
  bool is_visible() const;
  
  bool is_viewable() const;
  
  bool is_input_only() const;
  
  bool is_shaped() const;
  
  WindowState get_state() const;
  
  bool set_static_gravities(bool use_static =  true);
  
  bool has_native() const;
  
  void set_type_hint(WindowTypeHint hint);
  
  WindowTypeHint get_type_hint();
  
  bool get_modal_hint() const;
  
  void set_modal_hint(bool modal =  true);
  
  void set_geometry_hints(const Geometry& geometry, WindowHints geom_mask);
  
  static void set_sm_client_id(const Glib::ustring& sm_client_id);
  static void unset_sm_client_id();
 
  //Note: The rectangle parameter was made const in GTK+ 2.16, but we can't change that in our C++ API. TODO: Change it when we can do an ABI break.
   
 
  void begin_paint_rect(Rectangle& rectangle);
  
  void begin_paint_region(const Region& region);
  
  void end_paint();
  
  void flush();
  
  void set_title(const Glib::ustring& title);
  
  void set_role(const Glib::ustring& role);
  
  void set_startup_id(const Glib::ustring& startup_id);
  
  void set_transient_for(const Glib::RefPtr<Window>& parent);
  
  void set_background(const Color& color);
  
  void set_back_pixmap(const Glib::RefPtr<Pixmap>& pixmap, bool parent_relative =  true);
 
  void unset_back_pixmap();
 
   
  ::Cairo::RefPtr< ::Cairo::Pattern> get_background_pattern();
   
 
  ::Cairo::RefPtr<const ::Cairo::Pattern> get_background_pattern() const;
 
 
  void set_cursor(const Cursor& cursor);
 
  void set_cursor();
 
  //TODO: GdkCursor is a ref-counted boxed type,
  //so we could add a copy constructor and then return by value.
  //We would also need a Cursor::operator bool() to check for a null value.
  //TODO: _WRAP_METHOD(Cursor get_cursor(), gdk_window_get_cursor)
 
  
  void get_user_data(gpointer* data);
  
  void get_geometry(int& x, int& y, int& width, int& height, int& depth) const;
  
  int get_width() const;
  
  int get_height() const;
  
  void get_position(int& x, int& y) const;
  
  int get_origin(int& x, int& y) const;
  
  void get_root_coords(int x, int y, int& root_x, int& root_y);
  
  void coords_to_parent(double x, double y, double& parent_x, double& parent_y);
  
  void coords_from_parent(double parent_x, double parent_y, double& x, double& y);
 
  
  void get_root_origin(int& x, int& y) const;
  
  void get_frame_extents(Rectangle& rect);
  
  Glib::RefPtr<Window> get_pointer(int& x, int& y, ModifierType& mask);
  
  Glib::RefPtr<Window> get_parent();
  
  Glib::RefPtr<const Window> get_parent() const;
  
  Glib::RefPtr<Window> get_toplevel();
  
  Glib::RefPtr<const Window> get_toplevel() const;
 
  
  Glib::RefPtr<Window> get_effective_parent();
  
  Glib::RefPtr<const Window> get_effective_parent() const;
  
  Glib::RefPtr<Window> get_effective_toplevel();
  //gtkmmproc error: gdk_window_effective_get_toplevel : method defs lookup failed (1)
 
  
  Glib::ListHandle< Glib::RefPtr<Window> > get_children();
  
  Glib::ListHandle< Glib::RefPtr<const Window> > get_children() const;
   //gdk_window_peek_children() is the same as gdk_window_get_children() with different memory mangement of the list.
 
  
  EventMask get_events() const;
  
  void set_events(EventMask event_mask);
 
  
  void set_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& pixbufs);
  
  void set_icon(const Glib::RefPtr<Window>& icon_window, const Glib::RefPtr<Pixmap>& pixmap, const Glib::RefPtr<Bitmap>& mask);
  void set_icon(const Glib::RefPtr<Window>& icon_window, const Glib::RefPtr<Pixmap>& pixmap);
  void unset_icon();
  
  void set_icon_name(const Glib::ustring& name);
 
  
  void set_group(const Glib::RefPtr<Window>& leader);
  
  Glib::RefPtr<Window> get_group();
  
  Glib::RefPtr<const Window> get_group() const;
 
  
  void set_decorations(WMDecoration decorations);
  
  bool get_decorations(WMDecoration& decorations) const;
  
  void set_functions(WMFunction functions);
 
  
#ifndef GDKMM_DISABLE_DEPRECATED
 
  static Glib::ListHandle< Glib::RefPtr<Window> > get_toplevels();
#endif // GDKMM_DISABLE_DEPRECATED
 
 
  ::Cairo::RefPtr< ::Cairo::Surface> create_similar_surface(::Cairo::Content content, int width, int height);
 
  
  void beep();
 
  
  void iconify();
  
  void deiconify();
  
  void stick();
  
  void unstick();
  
  void maximize();
  
  void unmaximize();
  
  void register_dnd();
  
  void begin_resize_drag(WindowEdge edge, int button, int root_x, int root_y, guint32 timestamp);
  
  void begin_move_drag(int button, int root_x, int root_y, guint32 timestamp);
 
  Glib::RefPtr<DragContext> drag_begin(const Glib::StringArrayHandle& targets);
  
 
  void invalidate_rect(const Rectangle& rect, bool invalidate_children);
 
  void invalidate(bool invalidate_children);
 
  
  void invalidate_region(const Region& region, bool invalidate_children =  true);
 
  
  Region get_update_area();
  //This method should not have a const version - see the docs.
 
  
  void freeze_updates();
  
  void thaw_updates();
  
  static void process_all_updates();
  
  void process_updates(bool update_children);
  
  static void set_debug_updates(bool setting =  true);
  
  static void constrain_size(const Geometry& geometry, guint flags, int width, int height, int& new_width, int& new_height);
  void get_internal_paint_info(Glib::RefPtr<Drawable>& real_drawable, int& x_offset, int& y_offset) const;
 
  
  void enable_synchronized_configure();
  
  void configure_finished();
 
  
  void set_skip_taskbar_hint(bool skips_taskbar =  true);
  
  void set_skip_pager_hint(bool skips_pager =  true);
 
  
  void set_urgency_hint(bool urgent =  true);
 
  
  void fullscreen();
  
  void unfullscreen();
 
  
  GrabStatus pointer_grab(bool owner_events, EventMask event_mask, const Glib::RefPtr<const Window>& confine_to, const Cursor& cursor, guint32 time_);
 
  GrabStatus pointer_grab(bool owner_events, EventMask event_mask, const Cursor& cursor, guint32 timestamp);
 
  GrabStatus pointer_grab(bool owner_events, EventMask event_mask, guint32 timestamp);
 
  
  static void pointer_ungrab(guint32 timestamp);
  
  GrabStatus keyboard_grab(bool owner_events, guint32 timestamp);
  
  static void keyboard_ungrab(guint32 timestamp);
 
  
  void set_keep_above(bool setting =  true);
  
  void set_keep_below(bool setting =  true);
 
  
  void set_opacity(double opacity);
 
  
  bool get_accept_focus() const;
  
  void set_accept_focus(bool accept_focus =  true);
 
  
  bool get_focus_on_map() const;
  
  void set_focus_on_map(bool focus_on_map);
 
  
  static Glib::RefPtr<Window> get_default_root_window();
 
  
  Glib::RefPtr<Pixmap> get_offscreen_pixmap();
  
  Glib::RefPtr<const Pixmap> get_offscreen_pixmap() const;
 
  
  Glib::RefPtr<Window> get_offscreen_embedder();
  
  Glib::RefPtr<const Window> get_offscreen_embedder() const;
 
  
  void set_offscreen_embedder(const Glib::RefPtr<Window>& embedder);
 
  
  void redirect_to_drawable(const Glib::RefPtr<Drawable>& drawable, int src_x, int src_y, int dest_x, int dest_y, int width, int height);
  
  void remove_redirection();
 
  
  void geometry_changed();
  
  //TODO: Wrap these? Find out when they are emitted and if they are useful outside of GTK+, and improve the C docs.
  //_WRAP_SIGNAL(Glib::RefPtr<Gdk::Window> pick_embedded_child(double x, double y), pick-embedded-child, no_default_handler)
  //_WRAP_SIGNAL(Glib::RefPtr<Gdk::Window> to_embedder(double offscreen_x, double offscreen_y, double& embedder_x, double& embedder_y), to-embedder, no_default_handler)
  //_WRAP_SIGNAL(Glib::RefPtr<Gdk::Window> from_embedder(double embedder_x, double embedder_y, double& offscreen_x, double& offscreen_y), from-embedder, no_default_handler)
 
 
  //TODO: _WRAP_PROPERTY("cursor", Cursor)
 
 
public:
 
public:
  //C++ methods used to invoke GTK+ virtual functions:
 
protected:
  //GTK+ Virtual Functions (override these to change behaviour):
 
  //Default Signal Handlers::
 
 
};
 
} // namespace Gdk
 
 
namespace Glib
{
  Glib::RefPtr<Gdk::Window> wrap(GdkWindowObject* object, bool take_copy = false);
}
 
 
#endif /* _GDKMM_WINDOW_H */