Windows

Name

Windows -- 

Synopsis


#include <gdk/gdk.h>


struct      GdkWindowAttr;
struct      GdkWindow;
enum        GdkWindowType;
enum        GdkWindowClass;
enum        GdkWindowAttributesType;
enum        GdkWindowHints;
struct      GdkGeometry;
enum        GdkGravity;
enum        GdkWindowEdge;
enum        GdkWindowTypeHint;
GdkWindow*  gdk_window_new                  (GdkWindow *parent,
                                             GdkWindowAttr *attributes,
                                             gint attributes_mask);
void        gdk_window_destroy              (GdkWindow *window);
#define     gdk_window_ref
#define     gdk_window_unref
GdkWindowType gdk_window_get_window_type    (GdkWindow *window);
GdkWindow*  gdk_window_at_pointer           (gint *win_x,
                                             gint *win_y);
void        gdk_window_show                 (GdkWindow *window);
void        gdk_window_hide                 (GdkWindow *window);
gboolean    gdk_window_is_visible           (GdkWindow *window);
gboolean    gdk_window_is_viewable          (GdkWindow *window);
GdkWindowState gdk_window_get_state         (GdkWindow *window);
void        gdk_window_withdraw             (GdkWindow *window);
void        gdk_window_iconify              (GdkWindow *window);
void        gdk_window_deiconify            (GdkWindow *window);
void        gdk_window_stick                (GdkWindow *window);
void        gdk_window_unstick              (GdkWindow *window);
void        gdk_window_maximize             (GdkWindow *window);
void        gdk_window_unmaximize           (GdkWindow *window);
void        gdk_window_move                 (GdkWindow *window,
                                             gint x,
                                             gint y);
void        gdk_window_resize               (GdkWindow *window,
                                             gint width,
                                             gint height);
void        gdk_window_move_resize          (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);
void        gdk_window_scroll               (GdkWindow *window,
                                             gint dx,
                                             gint dy);
void        gdk_window_reparent             (GdkWindow *window,
                                             GdkWindow *new_parent,
                                             gint x,
                                             gint y);
void        gdk_window_clear                (GdkWindow *window);
void        gdk_window_clear_area           (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);
void        gdk_window_clear_area_e         (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);
#define     gdk_window_copy_area            (drawable,gc,x,y,source_drawable,source_x,source_y,width,height)
void        gdk_window_raise                (GdkWindow *window);
void        gdk_window_lower                (GdkWindow *window);
void        gdk_window_focus                (GdkWindow *window,
                                             guint32 timestamp);
void        gdk_window_register_dnd         (GdkWindow *window);
void        gdk_window_begin_resize_drag    (GdkWindow *window,
                                             GdkWindowEdge edge,
                                             gint button,
                                             gint root_x,
                                             gint root_y,
                                             guint32 timestamp);
void        gdk_window_begin_move_drag      (GdkWindow *window,
                                             gint button,
                                             gint root_x,
                                             gint root_y,
                                             guint32 timestamp);
void        gdk_window_constrain_size       (GdkGeometry *geometry,
                                             guint flags,
                                             gint width,
                                             gint height,
                                             gint *new_width,
                                             gint *new_height);

void        gdk_window_begin_paint_rect     (GdkWindow *window,
                                             GdkRectangle *rectangle);
void        gdk_window_begin_paint_region   (GdkWindow *window,
                                             GdkRegion *region);
void        gdk_window_end_paint            (GdkWindow *window);

void        gdk_window_invalidate_rect      (GdkWindow *window,
                                             GdkRectangle *rect,
                                             gboolean invalidate_children);
void        gdk_window_invalidate_region    (GdkWindow *window,
                                             GdkRegion *region,
                                             gboolean invalidate_children);
GdkRegion*  gdk_window_get_update_area      (GdkWindow *window);
void        gdk_window_freeze_updates       (GdkWindow *window);
void        gdk_window_thaw_updates         (GdkWindow *window);
void        gdk_window_process_all_updates  (void);
void        gdk_window_process_updates      (GdkWindow *window,
                                             gboolean update_children);
void        gdk_window_set_debug_updates    (gboolean setting);

void        gdk_window_set_user_data        (GdkWindow *window,
                                             gpointer user_data);
void        gdk_window_set_override_redirect
                                            (GdkWindow *window,
                                             gboolean override_redirect);
void        gdk_window_add_filter           (GdkWindow *window,
                                             GdkFilterFunc function,
                                             gpointer data);
void        gdk_window_remove_filter        (GdkWindow *window,
                                             GdkFilterFunc function,
                                             gpointer data);
GdkFilterReturn (*GdkFilterFunc)            (GdkXEvent *xevent,
                                             GdkEvent *event,
                                             gpointer data);
enum        GdkFilterReturn;
typedef     GdkXEvent;
void        gdk_window_shape_combine_mask   (GdkWindow *window,
                                             GdkBitmap *shape_mask,
                                             gint offset_x,
                                             gint offset_y);
void        gdk_window_shape_combine_region (GdkWindow *window,
                                             GdkRegion *shape_region,
                                             gint offset_x,
                                             gint offset_y);
void        gdk_window_set_child_shapes     (GdkWindow *window);
void        gdk_window_merge_child_shapes   (GdkWindow *window);
gboolean    gdk_window_set_static_gravities (GdkWindow *window,
                                             gboolean use_static);
void        gdk_window_set_hints            (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint min_width,
                                             gint min_height,
                                             gint max_width,
                                             gint max_height,
                                             gint flags);
void        gdk_window_set_title            (GdkWindow *window,
                                             const gchar *title);
void        gdk_window_set_background       (GdkWindow *window,
                                             GdkColor *color);
void        gdk_window_set_back_pixmap      (GdkWindow *window,
                                             GdkPixmap *pixmap,
                                             gboolean parent_relative);
#define     GDK_PARENT_RELATIVE
void        gdk_window_set_cursor           (GdkWindow *window,
                                             GdkCursor *cursor);
#define     gdk_window_set_colormap
void        gdk_window_get_user_data        (GdkWindow *window,
                                             gpointer *data);
void        gdk_window_get_geometry         (GdkWindow *window,
                                             gint *x,
                                             gint *y,
                                             gint *width,
                                             gint *height,
                                             gint *depth);
void        gdk_window_set_geometry_hints   (GdkWindow *window,
                                             GdkGeometry *geometry,
                                             GdkWindowHints flags);
void        gdk_window_set_icon_list        (GdkWindow *window,
                                             GList *pixbufs);
void        gdk_window_set_modal_hint       (GdkWindow *window,
                                             gboolean modal);
void        gdk_window_set_type_hint        (GdkWindow *window,
                                             GdkWindowTypeHint hint);
void        gdk_window_get_position         (GdkWindow *window,
                                             gint *x,
                                             gint *y);
void        gdk_window_get_root_origin      (GdkWindow *window,
                                             gint *x,
                                             gint *y);
void        gdk_window_get_frame_extents    (GdkWindow *window,
                                             GdkRectangle *rect);
#define     gdk_window_get_size
#define     gdk_window_get_visual
#define     gdk_window_get_colormap
#define     gdk_window_get_type
gint        gdk_window_get_origin           (GdkWindow *window,
                                             gint *x,
                                             gint *y);
gboolean    gdk_window_get_deskrelative_origin
                                            (GdkWindow *window,
                                             gint *x,
                                             gint *y);
GdkWindow*  gdk_window_get_pointer          (GdkWindow *window,
                                             gint *x,
                                             gint *y,
                                             GdkModifierType *mask);
enum        GdkModifierType;
GdkWindow*  gdk_window_get_parent           (GdkWindow *window);
GdkWindow*  gdk_window_get_toplevel         (GdkWindow *window);
GList*      gdk_window_get_children         (GdkWindow *window);
GList*      gdk_window_peek_children        (GdkWindow *window);
GdkEventMask gdk_window_get_events          (GdkWindow *window);
void        gdk_window_set_events           (GdkWindow *window,
                                             GdkEventMask event_mask);
void        gdk_window_set_icon             (GdkWindow *window,
                                             GdkWindow *icon_window,
                                             GdkPixmap *pixmap,
                                             GdkBitmap *mask);
void        gdk_window_set_icon_name        (GdkWindow *window,
                                             const gchar *name);
void        gdk_window_set_transient_for    (GdkWindow *window,
                                             GdkWindow *leader);
void        gdk_window_set_role             (GdkWindow *window,
                                             const gchar *role);
void        gdk_window_set_group            (GdkWindow *window,
                                             GdkWindow *leader);
void        gdk_window_set_decorations      (GdkWindow *window,
                                             GdkWMDecoration decorations);
gboolean    gdk_window_get_decorations      (GdkWindow *window,
                                             GdkWMDecoration *decorations);
enum        GdkWMDecoration;
void        gdk_window_set_functions        (GdkWindow *window,
                                             GdkWMFunction functions);
enum        GdkWMFunction;
GList*      gdk_window_get_toplevels        (void);


Description

Details

struct GdkWindowAttr

struct GdkWindowAttr
{
  gchar *title;
  gint event_mask;
  gint x, y;
  gint width;
  gint height;
  GdkWindowClass wclass;
  GdkVisual *visual;
  GdkColormap *colormap;
  GdkWindowType window_type;
  GdkCursor *cursor;
  gchar *wmclass_name;
  gchar *wmclass_class;
  gboolean override_redirect;
};


struct GdkWindow

struct GdkPixmap
{
  gpointer user_data;
};


enum GdkWindowType

typedef enum
{
  GDK_WINDOW_ROOT,
  GDK_WINDOW_TOPLEVEL,
  GDK_WINDOW_CHILD,
  GDK_WINDOW_DIALOG,
  GDK_WINDOW_TEMP,
  GDK_WINDOW_FOREIGN
} GdkWindowType;


enum GdkWindowClass

typedef enum
{
  GDK_INPUT_OUTPUT,
  GDK_INPUT_ONLY
} GdkWindowClass;


enum GdkWindowAttributesType

typedef enum
{
  GDK_WA_TITLE	  = 1 << 1,
  GDK_WA_X	  = 1 << 2,
  GDK_WA_Y	  = 1 << 3,
  GDK_WA_CURSOR	  = 1 << 4,
  GDK_WA_COLORMAP = 1 << 5,
  GDK_WA_VISUAL	  = 1 << 6,
  GDK_WA_WMCLASS  = 1 << 7,
  GDK_WA_NOREDIR  = 1 << 8
} GdkWindowAttributesType;


enum GdkWindowHints

typedef enum
{
  GDK_HINT_POS	       = 1 << 0,
  GDK_HINT_MIN_SIZE    = 1 << 1,
  GDK_HINT_MAX_SIZE    = 1 << 2,
  GDK_HINT_BASE_SIZE   = 1 << 3,
  GDK_HINT_ASPECT      = 1 << 4,
  GDK_HINT_RESIZE_INC  = 1 << 5,
  GDK_HINT_WIN_GRAVITY = 1 << 6,
  GDK_HINT_USER_POS    = 1 << 7,
  GDK_HINT_USER_SIZE   = 1 << 8
} GdkWindowHints;


struct GdkGeometry

struct GdkGeometry
{
  gint min_width;
  gint min_height;
  gint max_width;
  gint max_height;
  gint base_width;
  gint base_height;
  gint width_inc;
  gint height_inc;
  gdouble min_aspect;
  gdouble max_aspect;
  GdkGravity win_gravity;
};


enum GdkGravity

typedef enum
{
  GDK_GRAVITY_NORTH_WEST = 1,
  GDK_GRAVITY_NORTH,
  GDK_GRAVITY_NORTH_EAST,
  GDK_GRAVITY_WEST,
  GDK_GRAVITY_CENTER,
  GDK_GRAVITY_EAST,
  GDK_GRAVITY_SOUTH_WEST,
  GDK_GRAVITY_SOUTH,
  GDK_GRAVITY_SOUTH_EAST,
  GDK_GRAVITY_STATIC
} GdkGravity;


enum GdkWindowEdge

typedef enum
{
  GDK_WINDOW_EDGE_NORTH_WEST,
  GDK_WINDOW_EDGE_NORTH,
  GDK_WINDOW_EDGE_NORTH_EAST,
  GDK_WINDOW_EDGE_WEST,
  GDK_WINDOW_EDGE_EAST,
  GDK_WINDOW_EDGE_SOUTH_WEST,
  GDK_WINDOW_EDGE_SOUTH,
  GDK_WINDOW_EDGE_SOUTH_EAST  
} GdkWindowEdge;


enum GdkWindowTypeHint

typedef enum
{
  GDK_WINDOW_TYPE_HINT_NORMAL,
  GDK_WINDOW_TYPE_HINT_DIALOG,
  GDK_WINDOW_TYPE_HINT_MENU,
  GDK_WINDOW_TYPE_HINT_TOOLBAR
} GdkWindowTypeHint;


gdk_window_new ()

GdkWindow*  gdk_window_new                  (GdkWindow *parent,
                                             GdkWindowAttr *attributes,
                                             gint attributes_mask);

parent : 
attributes : 
attributes_mask : 
Returns : 


gdk_window_destroy ()

void        gdk_window_destroy              (GdkWindow *window);

window : 


gdk_window_ref

#define     gdk_window_ref

Returns : 


gdk_window_unref

#define     gdk_window_unref


gdk_window_get_window_type ()

GdkWindowType gdk_window_get_window_type    (GdkWindow *window);

window : 
Returns : 


gdk_window_at_pointer ()

GdkWindow*  gdk_window_at_pointer           (gint *win_x,
                                             gint *win_y);

win_x : 
win_y : 
Returns : 


gdk_window_show ()

void        gdk_window_show                 (GdkWindow *window);

window : 


gdk_window_hide ()

void        gdk_window_hide                 (GdkWindow *window);

window : 


gdk_window_is_visible ()

gboolean    gdk_window_is_visible           (GdkWindow *window);

window : 
Returns : 


gdk_window_is_viewable ()

gboolean    gdk_window_is_viewable          (GdkWindow *window);

window : 
Returns : 


gdk_window_get_state ()

GdkWindowState gdk_window_get_state         (GdkWindow *window);

Gets the bitwise OR of the currently active window state flags, from the GdkWindowState enumeration.

window : a GdkWindow
Returns : window state bitfield


gdk_window_withdraw ()

void        gdk_window_withdraw             (GdkWindow *window);

window : 


gdk_window_iconify ()

void        gdk_window_iconify              (GdkWindow *window);

window : 


gdk_window_deiconify ()

void        gdk_window_deiconify            (GdkWindow *window);

window : 


gdk_window_stick ()

void        gdk_window_stick                (GdkWindow *window);

window : 


gdk_window_unstick ()

void        gdk_window_unstick              (GdkWindow *window);

window : 


gdk_window_maximize ()

void        gdk_window_maximize             (GdkWindow *window);

window : 


gdk_window_unmaximize ()

void        gdk_window_unmaximize           (GdkWindow *window);

window : 


gdk_window_move ()

void        gdk_window_move                 (GdkWindow *window,
                                             gint x,
                                             gint y);

window : 
x : 
y : 


gdk_window_resize ()

void        gdk_window_resize               (GdkWindow *window,
                                             gint width,
                                             gint height);

window : 
width : 
height : 


gdk_window_move_resize ()

void        gdk_window_move_resize          (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);

window : 
x : 
y : 
width : 
height : 


gdk_window_scroll ()

void        gdk_window_scroll               (GdkWindow *window,
                                             gint dx,
                                             gint dy);

Scroll the contents of its window, both pixels and children, by the given amount. Portions of the window that the scroll operation brings in from offscreen areas are invalidated. The invalidated region may be bigger than what would strictly be necessary. (For X11, a minimum area will be invalidated if the window has no subwindows, or if the edges of the window's parent do not extend beyond the edges of the window. In other cases, a multi-step process is used to scroll the window which may produce temporary visual artifacts and unnecessary invalidations.)

window : a GdkWindow
dx : Amount to scroll in the X direction
dy : Amount to scroll in the Y direction


gdk_window_reparent ()

void        gdk_window_reparent             (GdkWindow *window,
                                             GdkWindow *new_parent,
                                             gint x,
                                             gint y);

window : 
new_parent : 
x : 
y : 


gdk_window_clear ()

void        gdk_window_clear                (GdkWindow *window);

window : 


gdk_window_clear_area ()

void        gdk_window_clear_area           (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);

window : 
x : 
y : 
width : 
height : 


gdk_window_clear_area_e ()

void        gdk_window_clear_area_e         (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);

window : 
x : 
y : 
width : 
height : 


gdk_window_copy_area()

#define     gdk_window_copy_area(drawable,gc,x,y,source_drawable,source_x,source_y,width,height)

drawable : 
gc : 
x : 
y : 
source_drawable : 
source_x : 
source_y : 
width : 
height : 


gdk_window_raise ()

void        gdk_window_raise                (GdkWindow *window);

window : 


gdk_window_lower ()

void        gdk_window_lower                (GdkWindow *window);

window : 


gdk_window_focus ()

void        gdk_window_focus                (GdkWindow *window,
                                             guint32 timestamp);

window : 
timestamp : 


gdk_window_register_dnd ()

void        gdk_window_register_dnd         (GdkWindow *window);

window : 


gdk_window_begin_resize_drag ()

void        gdk_window_begin_resize_drag    (GdkWindow *window,
                                             GdkWindowEdge edge,
                                             gint button,
                                             gint root_x,
                                             gint root_y,
                                             guint32 timestamp);

window : 
edge : 
button : 
root_x : 
root_y : 
timestamp : 


gdk_window_begin_move_drag ()

void        gdk_window_begin_move_drag      (GdkWindow *window,
                                             gint button,
                                             gint root_x,
                                             gint root_y,
                                             guint32 timestamp);

window : 
button : 
root_x : 
root_y : 
timestamp : 


gdk_window_constrain_size ()

void        gdk_window_constrain_size       (GdkGeometry *geometry,
                                             guint flags,
                                             gint width,
                                             gint height,
                                             gint *new_width,
                                             gint *new_height);

Constrains a desired width and height according to a set of geometry hints (such as minimum and maximum size).

geometry : a GdkGeometry structure
flags : a mask indicating what portions of geometry are set
width : desired width of window
height : desired height of the window
new_width : location to store resulting width
new_height : location to store resulting height


gdk_window_begin_paint_rect ()

void        gdk_window_begin_paint_rect     (GdkWindow *window,
                                             GdkRectangle *rectangle);

A convenience wrapper around gdk_window_begin_paint_region() which creates a rectangular region for you. See gdk_window_begin_paint_region() for details.

window : a GdkWindow
rectangle : rectangle you intend to draw to


gdk_window_begin_paint_region ()

void        gdk_window_begin_paint_region   (GdkWindow *window,
                                             GdkRegion *region);

Indicates that you are beginning the process of redrawing region. A backing store (offscreen buffer) large enough to contain region will be created. The backing store will be initialized with the background color or background pixmap for window. Then, all drawing operations performed on window will be diverted to the backing store. When you call gdk_window_end_paint(), the backing store will be copied to window, making it visible onscreen. Only the part of window contained in region will be modified; that is, drawing operations are clipped to region.

The net result of all this is to remove flicker, because the user sees the finished product appear all at once when you call gdk_window_end_paint(). If you draw to window directly without calling gdk_window_begin_paint_region(), the user may see flicker as individual drawing operations are performed in sequence. The clipping and background-initializing features of gdk_window_begin_paint_region() are conveniences for the programmer, so you can avoid doing that work yourself.

When using GTK+, the widget system automatically places calls to gdk_window_begin_paint_region() and gdk_window_end_paint() around emissions of the expose_event signal. That is, if you're writing an expose event handler, you can assume that the exposed area in GdkEventExpose has already been cleared to the window background, is already set as the clip region, and already has a backing store. Therefore in most cases, application code need not call gdk_window_begin_paint_region(). (You can disable the automatic calls around expose events on a widget-by-widget basis by calling gtk_widget_set_double_buffered().)

If you call this function multiple times before calling the matching gdk_window_end_paint(), the backing stores are pushed onto a stack. gdk_window_end_paint() copies the topmost backing store onscreen, subtracts the topmost region from all other regions in the stack, and pops the stack. All drawing operations affect only the topmost backing store in the stack. One matching call to gdk_window_end_paint() is required for each call to gdk_window_begin_paint_region().

window : a GdkWindow
region : region you intend to draw to


gdk_window_end_paint ()

void        gdk_window_end_paint            (GdkWindow *window);

Indicates that the backing store created by the most recent call to gdk_window_begin_paint_region() should be copied onscreen and deleted, leaving the next-most-recent backing store or no backing store at all as the active paint region. See gdk_window_begin_paint_region() for full details. It is an error to call this function without a matching gdk_window_begin_paint_region() first.

window : a GdkWindow


gdk_window_invalidate_rect ()

void        gdk_window_invalidate_rect      (GdkWindow *window,
                                             GdkRectangle *rect,
                                             gboolean invalidate_children);

A convenience wrapper around gdk_window_invalidate_region() which invalidates a rectangular region. See gdk_window_invalidate_region() for details.

window : a GdkWindow
rect : rectangle to invalidate
invalidate_children : whether to also invalidate child windows


gdk_window_invalidate_region ()

void        gdk_window_invalidate_region    (GdkWindow *window,
                                             GdkRegion *region,
                                             gboolean invalidate_children);

Adds region to the update area for window. The update area is the region that needs to be redrawn, or "dirty region." The call gdk_window_process_updates() sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of window in response to those expose events.

GDK will call gdk_window_process_all_updates() on your behalf whenever your program returns to the main loop and becomes idle, so normally there's no need to do that manually, you just need to invalidate regions that you know should be redrawn.

The invalidate_children parameter controls whether the region of each child window that intersects region will also be invalidated. If FALSE, then the update area for child windows will remain unaffected.

window : a GdkWindow
region : a GdkRegion
invalidate_children : TRUE to also invalidate child windows


gdk_window_get_update_area ()

GdkRegion*  gdk_window_get_update_area      (GdkWindow *window);

Transfers ownership of the update area from window to the caller of the function. That is, after calling this function, window will no longer have an invalid/dirty region; the update area is removed from window and handed to you. If a window has no update area, gdk_window_get_update_area() returns NULL. You are responsible for calling gdk_region_destroy() on the returned region if it's non-NULL.

window : a GdkWindow
Returns : the update area for window


gdk_window_freeze_updates ()

void        gdk_window_freeze_updates       (GdkWindow *window);

window : 


gdk_window_thaw_updates ()

void        gdk_window_thaw_updates         (GdkWindow *window);

window : 


gdk_window_process_all_updates ()

void        gdk_window_process_all_updates  (void);

Calls gdk_window_process_updates() for all windows (see GdkWindow) in the application.


gdk_window_process_updates ()

void        gdk_window_process_updates      (GdkWindow *window,
                                             gboolean update_children);

Sends one or more expose events to window. The areas in each expose event will cover the entire update area for the window (see gdk_window_invalidate_region() for details). Normally GDK calls gdk_window_process_all_updates() on your behalf, so there's no need to call this function unless you want to force expose events to be delivered immediately and synchronously (vs. the usual case, where GDK delivers them in an idle handler). Occasionally this is useful to produce nicer scrolling behavior, for example.

window : a GdkWindow
update_children : whether to also process updates for child windows


gdk_window_set_debug_updates ()

void        gdk_window_set_debug_updates    (gboolean setting);

With update debugging enabled, calls to gdk_window_invalidate_region() clear the invalidated region of the screen to a noticeable color, and GDK pauses for a short time before sending exposes to windows during gdk_window_process_updates(). The net effect is that you can see the invalid region for each window and watch redraws as they occur. This allows you to diagnose inefficiencies in your application.

In essence, because the GDK rendering model prevents all flicker, if you are redrawing the same region 400 times you may never notice, aside from noticing a speed problem. Enabling update debugging causes GTK to flicker slowly and noticeably, so you can see exactly what's being redrawn when, in what order.

The --gtk-debug=updates command line option passed to GTK+ programs enables this debug option at application startup time. That's usually more useful than calling gdk_window_set_debug_updates() yourself, though you might want to use this function to enable updates sometime after application startup time.

setting : TRUE to turn on update debugging


gdk_window_set_user_data ()

void        gdk_window_set_user_data        (GdkWindow *window,
                                             gpointer user_data);

window : 
user_data : 


gdk_window_set_override_redirect ()

void        gdk_window_set_override_redirect
                                            (GdkWindow *window,
                                             gboolean override_redirect);

window : 
override_redirect : 


gdk_window_add_filter ()

void        gdk_window_add_filter           (GdkWindow *window,
                                             GdkFilterFunc function,
                                             gpointer data);

window : 
function : 
data : 


gdk_window_remove_filter ()

void        gdk_window_remove_filter        (GdkWindow *window,
                                             GdkFilterFunc function,
                                             gpointer data);

window : 
function : 
data : 


GdkFilterFunc ()

GdkFilterReturn (*GdkFilterFunc)            (GdkXEvent *xevent,
                                             GdkEvent *event,
                                             gpointer data);

xevent : 
event : 
data : 
Returns : 


enum GdkFilterReturn

typedef enum {
  GDK_FILTER_CONTINUE,	  /* Event not handled, continue processesing */
  GDK_FILTER_TRANSLATE,	  /* Translated event stored */
  GDK_FILTER_REMOVE	  /* Terminate processing, removing event */
} GdkFilterReturn;


GdkXEvent

typedef void GdkXEvent;	  /* Can be cast to window system specific


gdk_window_shape_combine_mask ()

void        gdk_window_shape_combine_mask   (GdkWindow *window,
                                             GdkBitmap *shape_mask,
                                             gint offset_x,
                                             gint offset_y);

window : 
shape_mask : 
offset_x : 
offset_y : 


gdk_window_shape_combine_region ()

void        gdk_window_shape_combine_region (GdkWindow *window,
                                             GdkRegion *shape_region,
                                             gint offset_x,
                                             gint offset_y);

window : 
shape_region : 
offset_x : 
offset_y : 


gdk_window_set_child_shapes ()

void        gdk_window_set_child_shapes     (GdkWindow *window);

window : 


gdk_window_merge_child_shapes ()

void        gdk_window_merge_child_shapes   (GdkWindow *window);

window : 


gdk_window_set_static_gravities ()

gboolean    gdk_window_set_static_gravities (GdkWindow *window,
                                             gboolean use_static);

window : 
use_static : 
Returns : 


gdk_window_set_hints ()

void        gdk_window_set_hints            (GdkWindow *window,
                                             gint x,
                                             gint y,
                                             gint min_width,
                                             gint min_height,
                                             gint max_width,
                                             gint max_height,
                                             gint flags);

window : 
x : 
y : 
min_width : 
min_height : 
max_width : 
max_height : 
flags : 


gdk_window_set_title ()

void        gdk_window_set_title            (GdkWindow *window,
                                             const gchar *title);

window : 
title : 


gdk_window_set_background ()

void        gdk_window_set_background       (GdkWindow *window,
                                             GdkColor *color);

window : 
color : 


gdk_window_set_back_pixmap ()

void        gdk_window_set_back_pixmap      (GdkWindow *window,
                                             GdkPixmap *pixmap,
                                             gboolean parent_relative);

window : 
pixmap : 
parent_relative : 


GDK_PARENT_RELATIVE

#define GDK_PARENT_RELATIVE  1L


gdk_window_set_cursor ()

void        gdk_window_set_cursor           (GdkWindow *window,
                                             GdkCursor *cursor);

window : 
cursor : 


gdk_window_set_colormap

#define     gdk_window_set_colormap


gdk_window_get_user_data ()

void        gdk_window_get_user_data        (GdkWindow *window,
                                             gpointer *data);

window : 
data : 


gdk_window_get_geometry ()

void        gdk_window_get_geometry         (GdkWindow *window,
                                             gint *x,
                                             gint *y,
                                             gint *width,
                                             gint *height,
                                             gint *depth);

window : 
x : 
y : 
width : 
height : 
depth : 


gdk_window_set_geometry_hints ()

void        gdk_window_set_geometry_hints   (GdkWindow *window,
                                             GdkGeometry *geometry,
                                             GdkWindowHints flags);

window : 
geometry : 
flags : 


gdk_window_set_icon_list ()

void        gdk_window_set_icon_list        (GdkWindow *window,
                                             GList *pixbufs);

Sets a list of icons for the window. One of these will be used to represent the window when it has been iconified. The icon is usually shown in an icon box or some sort of task bar. Which icon size is shown depends on the window manager. The window manager can scale the icon but setting several size icons can give better image quality since the window manager may only need to scale the icon by a small amount or not at all.

window : The GdkWindow toplevel window to set the icon of.
pixbufs : A list of pixbufs, of different sizes.


gdk_window_set_modal_hint ()

void        gdk_window_set_modal_hint       (GdkWindow *window,
                                             gboolean modal);

The application can use this hint to tell the window manager that a certain window has modal behaviour. The window manager can use this information to handle modal windows in a special way.

You should only use this on windows for which you have previously called #gdk_window_set_transient_for()

window : A GdkWindow
modal : TRUE if the window is modal, FALSE otherwise.


gdk_window_set_type_hint ()

void        gdk_window_set_type_hint        (GdkWindow *window,
                                             GdkWindowTypeHint hint);

The application can use this call to provide a hint to the window manager about the functionality of a window. The window manager can use this information when determining the decoration and behaviour of the window.

The hint must be set before the window is mapped.

window : A GdkWindow
hint : A hint of the function this window will have


gdk_window_get_position ()

void        gdk_window_get_position         (GdkWindow *window,
                                             gint *x,
                                             gint *y);

window : 
x : 
y : 


gdk_window_get_root_origin ()

void        gdk_window_get_root_origin      (GdkWindow *window,
                                             gint *x,
                                             gint *y);

Obtains the top-left corner of the window manager frame in root window coordinates.

window : a GdkWindow
x : return location for X position of window frame
y : return location for Y position of window frame


gdk_window_get_frame_extents ()

void        gdk_window_get_frame_extents    (GdkWindow *window,
                                             GdkRectangle *rect);

Obtains the bounding box of the window, including window manager titlebar/borders if any. The frame position is given in root window coordinates. To get the position of the window itself (rather than the frame) in root window coordinates, use gdk_window_get_origin().

window : a GdkWindow
rect : rectangle to fill with bounding box of the window frame


gdk_window_get_size

#define     gdk_window_get_size


gdk_window_get_visual

#define     gdk_window_get_visual

Returns : 


gdk_window_get_colormap

#define     gdk_window_get_colormap

Returns : 


gdk_window_get_type

#define     gdk_window_get_type

Returns : 


gdk_window_get_origin ()

gint        gdk_window_get_origin           (GdkWindow *window,
                                             gint *x,
                                             gint *y);

Obtains the position of a window in root window coordinates. (Compare with gdk_window_get_position() and gdk_window_get_geometry() which return the position of a window relative to its parent window.)

window : a GdkWindow
x : return location for X coordinate
y : return location for Y coordinate
Returns : not meaningful, ignore


gdk_window_get_deskrelative_origin ()

gboolean    gdk_window_get_deskrelative_origin
                                            (GdkWindow *window,
                                             gint *x,
                                             gint *y);

This gets the origin of a GdkWindow relative to an Enlightenment-window-manager desktop. As long as you don't assume that the user's desktop/workspace covers the entire root window (i.e. you don't assume that the desktop begins at root window coordinate 0,0) this function is not necessary. It's deprecated for that reason.

window : a GdkWindow
x : return location for X coordinate
y : return location for Y coordinate
Returns : not meaningful


gdk_window_get_pointer ()

GdkWindow*  gdk_window_get_pointer          (GdkWindow *window,
                                             gint *x,
                                             gint *y,
                                             GdkModifierType *mask);

window : 
x : 
y : 
mask : 
Returns : 


enum GdkModifierType

typedef enum
{
  GDK_SHIFT_MASK    = 1 << 0,
  GDK_LOCK_MASK	    = 1 << 1,
  GDK_CONTROL_MASK  = 1 << 2,
  GDK_MOD1_MASK	    = 1 << 3,
  GDK_MOD2_MASK	    = 1 << 4,
  GDK_MOD3_MASK	    = 1 << 5,
  GDK_MOD4_MASK	    = 1 << 6,
  GDK_MOD5_MASK	    = 1 << 7,
  GDK_BUTTON1_MASK  = 1 << 8,
  GDK_BUTTON2_MASK  = 1 << 9,
  GDK_BUTTON3_MASK  = 1 << 10,
  GDK_BUTTON4_MASK  = 1 << 11,
  GDK_BUTTON5_MASK  = 1 << 12,
  /* The next few modifiers are used by XKB, so we skip to the end
   */
  GDK_RELEASE_MASK  = 1 << 31,
  GDK_MODIFIER_MASK = GDK_RELEASE_MASK | 0x1fff
} GdkModifierType;


gdk_window_get_parent ()

GdkWindow*  gdk_window_get_parent           (GdkWindow *window);

window : 
Returns : 


gdk_window_get_toplevel ()

GdkWindow*  gdk_window_get_toplevel         (GdkWindow *window);

window : 
Returns : 


gdk_window_get_children ()

GList*      gdk_window_get_children         (GdkWindow *window);

window : 
Returns : 


gdk_window_peek_children ()

GList*      gdk_window_peek_children        (GdkWindow *window);

window : 
Returns : 


gdk_window_get_events ()

GdkEventMask gdk_window_get_events          (GdkWindow *window);

window : 
Returns : 


gdk_window_set_events ()

void        gdk_window_set_events           (GdkWindow *window,
                                             GdkEventMask event_mask);

window : 
event_mask : 


gdk_window_set_icon ()

void        gdk_window_set_icon             (GdkWindow *window,
                                             GdkWindow *icon_window,
                                             GdkPixmap *pixmap,
                                             GdkBitmap *mask);

window : 
icon_window : 
pixmap : 
mask : 


gdk_window_set_icon_name ()

void        gdk_window_set_icon_name        (GdkWindow *window,
                                             const gchar *name);

window : 
name : 


gdk_window_set_transient_for ()

void        gdk_window_set_transient_for    (GdkWindow *window,
                                             GdkWindow *leader);

window : 
leader : 


gdk_window_set_role ()

void        gdk_window_set_role             (GdkWindow *window,
                                             const gchar *role);

window : 
role : 


gdk_window_set_group ()

void        gdk_window_set_group            (GdkWindow *window,
                                             GdkWindow *leader);

window : 
leader : 


gdk_window_set_decorations ()

void        gdk_window_set_decorations      (GdkWindow *window,
                                             GdkWMDecoration decorations);

window : 
decorations : 


gdk_window_get_decorations ()

gboolean    gdk_window_get_decorations      (GdkWindow *window,
                                             GdkWMDecoration *decorations);

Returns the decorations set on the GdkWindow with gdk_window_set_decorations

window : The GdkWindow to get the decorations from
decorations : The window decorations will be written here
Returns : TRUE if the window has decorations set, FALSE otherwise.


enum GdkWMDecoration

typedef enum
{
  GDK_DECOR_ALL		= 1 << 0,
  GDK_DECOR_BORDER	= 1 << 1,
  GDK_DECOR_RESIZEH	= 1 << 2,
  GDK_DECOR_TITLE	= 1 << 3,
  GDK_DECOR_MENU	= 1 << 4,
  GDK_DECOR_MINIMIZE	= 1 << 5,
  GDK_DECOR_MAXIMIZE	= 1 << 6
} GdkWMDecoration;


gdk_window_set_functions ()

void        gdk_window_set_functions        (GdkWindow *window,
                                             GdkWMFunction functions);

window : 
functions : 


enum GdkWMFunction

typedef enum
{
  GDK_FUNC_ALL		= 1 << 0,
  GDK_FUNC_RESIZE	= 1 << 1,
  GDK_FUNC_MOVE		= 1 << 2,
  GDK_FUNC_MINIMIZE	= 1 << 3,
  GDK_FUNC_MAXIMIZE	= 1 << 4,
  GDK_FUNC_CLOSE	= 1 << 5
} GdkWMFunction;


gdk_window_get_toplevels ()

GList*      gdk_window_get_toplevels        (void);

Returns :