|  |  |  | Libwnck Reference Manual |  | 
|---|---|---|---|---|
| Top | Description | Object Hierarchy | Signals | ||||
#include <libwnck/libwnck.h>
                    WnckWindow;
WnckWindow*         wnck_window_get                     (gulong xwindow);
WnckScreen*         wnck_window_get_screen              (WnckWindow *window);
gboolean            wnck_window_has_name                (WnckWindow *window);
const char*         wnck_window_get_name                (WnckWindow *window);
gboolean            wnck_window_has_icon_name           (WnckWindow *window);
const char*         wnck_window_get_icon_name           (WnckWindow *window);
gboolean            wnck_window_get_icon_is_fallback    (WnckWindow *window);
GdkPixbuf*          wnck_window_get_icon                (WnckWindow *window);
GdkPixbuf*          wnck_window_get_mini_icon           (WnckWindow *window);
WnckApplication*    wnck_window_get_application         (WnckWindow *window);
WnckWindow*         wnck_window_get_transient           (WnckWindow *window);
gulong              wnck_window_get_group_leader        (WnckWindow *window);
gulong              wnck_window_get_xid                 (WnckWindow *window);
WnckClassGroup *    wnck_window_get_class_group         (WnckWindow *window);
const char*         wnck_window_get_session_id          (WnckWindow *window);
const char*         wnck_window_get_session_id_utf8     (WnckWindow *window);
int                 wnck_window_get_pid                 (WnckWindow *window);
gint                wnck_window_get_sort_order          (WnckWindow *window);
void                wnck_window_set_sort_order          (WnckWindow *window,
                                                         gint order);
enum                WnckWindowType;
WnckWindowType      wnck_window_get_window_type         (WnckWindow *window);
void                wnck_window_set_window_type         (WnckWindow *window,
                                                         WnckWindowType wintype);
enum                WnckWindowState;
WnckWindowState     wnck_window_get_state               (WnckWindow *window);
gboolean            wnck_window_is_minimized            (WnckWindow *window);
gboolean            wnck_window_is_maximized_horizontally
                                                        (WnckWindow *window);
gboolean            wnck_window_is_maximized_vertically (WnckWindow *window);
gboolean            wnck_window_is_maximized            (WnckWindow *window);
gboolean            wnck_window_is_shaded               (WnckWindow *window);
gboolean            wnck_window_is_pinned               (WnckWindow *window);
gboolean            wnck_window_is_sticky               (WnckWindow *window);
gboolean            wnck_window_is_above                (WnckWindow *window);
gboolean            wnck_window_is_below                (WnckWindow *window);
gboolean            wnck_window_is_skip_pager           (WnckWindow *window);
gboolean            wnck_window_is_skip_tasklist        (WnckWindow *window);
gboolean            wnck_window_is_fullscreen           (WnckWindow *window);
gboolean            wnck_window_needs_attention         (WnckWindow *window);
gboolean            wnck_window_or_transient_needs_attention
                                                        (WnckWindow *window);
enum                WnckWindowActions;
WnckWindowActions   wnck_window_get_actions             (WnckWindow *window);
void                wnck_window_minimize                (WnckWindow *window);
void                wnck_window_unminimize              (WnckWindow *window,
                                                         guint32 timestamp);
void                wnck_window_maximize_horizontally   (WnckWindow *window);
void                wnck_window_unmaximize_horizontally (WnckWindow *window);
void                wnck_window_maximize_vertically     (WnckWindow *window);
void                wnck_window_unmaximize_vertically   (WnckWindow *window);
void                wnck_window_maximize                (WnckWindow *window);
void                wnck_window_unmaximize              (WnckWindow *window);
void                wnck_window_shade                   (WnckWindow *window);
void                wnck_window_unshade                 (WnckWindow *window);
void                wnck_window_pin                     (WnckWindow *window);
void                wnck_window_unpin                   (WnckWindow *window);
void                wnck_window_stick                   (WnckWindow *window);
void                wnck_window_unstick                 (WnckWindow *window);
void                wnck_window_make_above              (WnckWindow *window);
void                wnck_window_unmake_above            (WnckWindow *window);
void                wnck_window_make_below              (WnckWindow *window);
void                wnck_window_unmake_below            (WnckWindow *window);
void                wnck_window_set_skip_pager          (WnckWindow *window,
                                                         gboolean skip);
void                wnck_window_set_skip_tasklist       (WnckWindow *window,
                                                         gboolean skip);
void                wnck_window_set_fullscreen          (WnckWindow *window,
                                                         gboolean fullscreen);
void                wnck_window_close                   (WnckWindow *window,
                                                         guint32 timestamp);
WnckWorkspace*      wnck_window_get_workspace           (WnckWindow *window);
gboolean            wnck_window_is_on_workspace         (WnckWindow *window,
                                                         WnckWorkspace *workspace);
gboolean            wnck_window_is_visible_on_workspace (WnckWindow *window,
                                                         WnckWorkspace *workspace);
void                wnck_window_move_to_workspace       (WnckWindow *window,
                                                         WnckWorkspace *space);
gboolean            wnck_window_is_in_viewport          (WnckWindow *window,
                                                         WnckWorkspace *workspace);
void                wnck_window_activate                (WnckWindow *window,
                                                         guint32 timestamp);
gboolean            wnck_window_is_active               (WnckWindow *window);
gboolean            wnck_window_is_most_recently_activated
                                                        (WnckWindow *window);
void                wnck_window_activate_transient      (WnckWindow *window,
                                                         guint32 timestamp);
gboolean            wnck_window_transient_is_most_recently_activated
                                                        (WnckWindow *window);
void                wnck_window_set_icon_geometry       (WnckWindow *window,
                                                         int x,
                                                         int y,
                                                         int width,
                                                         int height);
enum                WnckWindowGravity;
enum                WnckWindowMoveResizeMask;
void                wnck_window_get_client_window_geometry
                                                        (WnckWindow *window,
                                                         int *xp,
                                                         int *yp,
                                                         int *widthp,
                                                         int *heightp);
void                wnck_window_get_geometry            (WnckWindow *window,
                                                         int *xp,
                                                         int *yp,
                                                         int *widthp,
                                                         int *heightp);
void                wnck_window_set_geometry            (WnckWindow *window,
                                                         WnckWindowGravity gravity,
                                                         WnckWindowMoveResizeMask geometry_mask,
                                                         int x,
                                                         int y,
                                                         int width,
                                                         int height);
void                wnck_window_keyboard_move           (WnckWindow *window);
void                wnck_window_keyboard_size           (WnckWindow *window);
"actions-changed" : Run Last "geometry-changed" : Run Last "icon-changed" : Run Last "name-changed" : Run Last "state-changed" : Run Last "workspace-changed" : Run Last
The WnckWindow objects are always owned by libwnck and must not be referenced or unreferenced.
typedef struct _WnckWindow WnckWindow;
The WnckWindow struct contains only private fields and should not be directly accessed.
WnckWindow*         wnck_window_get                     (gulong xwindow);
Gets a preexisting WnckWindow for the X window xwindow. This will not
create a WnckWindow if none exists. The function is robust against bogus
window IDs.
| 
 | an X window ID. | 
| Returns : | the WnckWindow for xwindow. The returned
WnckWindow is owned by libwnck and must not be referenced or unreferenced. [transfer none] | 
WnckScreen*         wnck_window_get_screen              (WnckWindow *window);
Gets the WnckScreen window is on.
| 
 | a WnckWindow. | 
| Returns : | the WnckScreen windowis on. The returned
WnckScreen is owned by libwnck and must not be referenced or unreferenced. [transfer none] | 
gboolean            wnck_window_has_name                (WnckWindow *window);
Checks whether or not window has a name. wnck_window_get_name()
will always return some value, even if window has no name set;
wnck_window_has_name() can be used to tell if that name is
real or not.
For icons titles, use wnck_window_has_icon_name() instead.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwnck_window_get_name()returnswindow's
name,FALSEif it returns a fallback name. | 
Since 2.16
const char*         wnck_window_get_name                (WnckWindow *window);
Gets the name of window, as it should be displayed in a pager
or tasklist. Always returns some value, even if window has no name
set; use wnck_window_has_name() if you need to know whether the returned
name is "real" or not.
For icons titles, use wnck_window_get_icon_name() instead.
| 
 | a WnckWindow. | 
| Returns : | the name of window, or a fallback name if no name is
available. | 
gboolean            wnck_window_has_icon_name           (WnckWindow *window);
Checks whether or not window has an icon name.
wnck_window_get_icon_name() will always return some value, even if
window has no icon name set; wnck_window_has_icon_name() can
be used to tell if that icon name is real or not.
(Note that if wnck_window_has_icon_name() returns FALSE, but
wnck_window_has_name() returns TRUE, then the name returned by
wnck_window_get_icon_name() is window's name. Only when both
methods return FALSE does wnck_window_get_icon_name() return a
generic fallback name.)
| 
 | a WnckWindow | 
| Returns : | TRUEifwnck_window_get_icon_name()returnswindow's icon name,FALSEif it returns a fallback name. | 
Since 2.16
const char*         wnck_window_get_icon_name           (WnckWindow *window);
Gets the icon name of window, as it should be displayed for an icon
(minimized state). Always returns some value, even if window has no icon
name set; use wnck_window_has_icon_name() if you need to know whether the
returned icon name is "real" or not.
Contrast with wnck_window_get_name(), which returns window's
title, not its icon title.
| 
 | a WnckWindow | 
| Returns : | the icon name of window, or a fallback icon name if no icon
name is available. | 
gboolean            wnck_window_get_icon_is_fallback    (WnckWindow *window);
Gets whether a default fallback icon is used for window (because none
was set on window).
| 
 | a WnckWindow. | 
| Returns : | TRUEif the icon forwindowis a fallback,FALSEotherwise. | 
GdkPixbuf*          wnck_window_get_icon                (WnckWindow *window);
Gets the icon to be used for window. If no icon was found, a fallback
icon is used. wnck_window_get_icon_is_fallback() can be used to tell if the
icon is the fallback icon.
| 
 | a WnckWindow. | 
| Returns : | the icon for window. The caller should
reference the returnedGdkPixbufif it needs to keep
the icon around. [transfer none] | 
GdkPixbuf*          wnck_window_get_mini_icon           (WnckWindow *window);
Gets the mini-icon to be used for window. If no mini-icon was found, a
fallback mini-icon is used. wnck_window_get_icon_is_fallback() can be used
to tell if the mini-icon is the fallback mini-icon.
| 
 | a WnckWindow. | 
| Returns : | the mini-icon for window. The caller should
reference the returnedGdkPixbufif it needs to keep
the icon around. [transfer none] | 
WnckApplication*    wnck_window_get_application         (WnckWindow *window);
Gets the WnckApplication to which window belongs.
| 
 | a WnckWindow. | 
| Returns : | the WnckApplication to which windowbelongs.
The returned WnckApplication is owned by libwnck and must not be referenced
or unreferenced. [transfer none] | 
WnckWindow*         wnck_window_get_transient           (WnckWindow *window);
Gets the WnckWindow for which window is transient.
| 
 | a WnckWindow. | 
| Returns : | the WnckWindow for which windowis
transient, orNULLifwindowis not transient for any WnckWindow.
The returned WnckWindow is owned by libwnck and must not be referenced or
unreferenced. [transfer none] | 
Since 2.12
gulong              wnck_window_get_group_leader        (WnckWindow *window);
Gets the group leader of the group of windows to which window belongs.
| 
 | a WnckWindow. | 
| Returns : | the group leader of the group of windows to which windowbelongs, or the X window ID ofwindowifwindowdoes not belong to any
group. | 
gulong              wnck_window_get_xid                 (WnckWindow *window);
Gets the X window ID of window.
| 
 | a WnckWindow. | 
| Returns : | the X window ID of window. | 
WnckClassGroup *    wnck_window_get_class_group         (WnckWindow *window);
Gets the WnckClassGroup to which window belongs.
| 
 | a WnckWindow. | 
| Returns : | the WnckClassGroup to which windowbelongs.
The returned WnckClassGroup is owned by libwnck and must not be referenced
or unreferenced. [transfer none] | 
Since 2.2
const char*         wnck_window_get_session_id          (WnckWindow *window);
Gets the session ID for window in Latin-1 encoding.
NOTE: this is invalid UTF-8. You can't display this
string in a GTK+ widget without converting to UTF-8.
See wnck_window_get_session_id_utf8().
| 
 | a WnckWindow. | 
| Returns : | the session ID for windowin Latin-1, orNULLifwindowhas
no session ID. | 
const char*         wnck_window_get_session_id_utf8     (WnckWindow *window);
Gets the session ID for window in UTF-8 encoding.
The session ID should be in Latin-1 encoding, so the conversion should work,
but a broken client could set a session ID that might not be convertable to
UTF-8.
| 
 | a WnckWindow. | 
| Returns : | the session ID for windowin UTF-8, orNULLifwindowhas
no session ID. | 
int                 wnck_window_get_pid                 (WnckWindow *window);
Gets the process ID of window.
| 
 | a WnckWindow. | 
| Returns : | the process ID of window, or 0 if none is available. | 
gint                wnck_window_get_sort_order          (WnckWindow *window);
Gets the sort order of window, used for ordering of window in
WnckSelector and WnckTasklist. The sort order is an internal state in
libwnck. The initial value is defined when the window is created.
| 
 | a WnckWindow. | 
| Returns : | the sort order of window, or G_MAXINT if none is available. | 
Since 2.10
void wnck_window_set_sort_order (WnckWindow *window,gint order);
Sets the sort order of window. The sort order is used for ordering of
window in WnckSelector and WnckTasklist.
| 
 | a WnckWindow. | 
| 
 | new sort order for window. | 
Since 2.20
typedef enum
{
  WNCK_WINDOW_NORMAL,       /* document/app window */
  WNCK_WINDOW_DESKTOP,      /* desktop background */
  WNCK_WINDOW_DOCK,         /* panel */
  WNCK_WINDOW_DIALOG,       /* dialog */
  WNCK_WINDOW_TOOLBAR,      /* tearoff toolbar */
  WNCK_WINDOW_MENU,         /* tearoff menu */
  WNCK_WINDOW_UTILITY,      /* palette/toolbox window */
  WNCK_WINDOW_SPLASHSCREEN  /* splash screen */
} WnckWindowType;
Type describing the semantic type of a WnckWindow.
| the window is a normal window. | |
| the window is a desktop. | |
| the window is a dock or a panel. | |
| the window is a dialog window. | |
| the window is a tearoff toolbar. | |
| the window is a tearoff menu. | |
| the window is a small persistent utility window, such as a palette or toolbox. | |
| the window is a splash screen displayed as an application is starting up. | 
WnckWindowType      wnck_window_get_window_type         (WnckWindow *window);
Gets the semantic type of window.
| 
 | a WnckWindow. | 
| Returns : | the semantic type of window. | 
void wnck_window_set_window_type (WnckWindow *window,WnckWindowType wintype);
Sets the semantic type of window to wintype.
| 
 | a WnckWindow. | 
| 
 | a semantic type. | 
Since 2.12
typedef enum
{
  WNCK_WINDOW_STATE_MINIMIZED              = 1 << 0,
  WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY = 1 << 1,
  WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY   = 1 << 2,
  WNCK_WINDOW_STATE_SHADED                 = 1 << 3,
  WNCK_WINDOW_STATE_SKIP_PAGER             = 1 << 4,
  WNCK_WINDOW_STATE_SKIP_TASKLIST          = 1 << 5,
  WNCK_WINDOW_STATE_STICKY                 = 1 << 6,
  WNCK_WINDOW_STATE_HIDDEN                 = 1 << 7,
  WNCK_WINDOW_STATE_FULLSCREEN             = 1 << 8,
  WNCK_WINDOW_STATE_DEMANDS_ATTENTION      = 1 << 9,
  WNCK_WINDOW_STATE_URGENT                 = 1 << 10,
  WNCK_WINDOW_STATE_ABOVE                  = 1 << 11,
  WNCK_WINDOW_STATE_BELOW                  = 1 << 12
} WnckWindowState;
Type used as a bitmask to describe the state of a WnckWindow.
| the window is minimized. | |
| the window is horizontically maximized. | |
| the window is vertically maximized. | |
| the window is shaded. | |
| the window should not be included on pagers. | |
| the window should not be included on tasklists. | |
| the window is sticky (see wnck_window_is_sticky()). | |
| the window is not visible on its WnckWorkspace and viewport (when minimized, for example). | |
| the window is fullscreen. | |
| the window needs attention (because the window requested activation but the window manager refused it, for example). | |
| the window requires a response from the user. | |
| the window is above other windows (see wnck_window_make_above()). | |
| the window is below other windows (see wnck_window_make_below()). | 
WnckWindowState     wnck_window_get_state               (WnckWindow *window);
Gets the state of window.
| 
 | a WnckWindow. | 
| Returns : | bitmask of active states for window. | 
gboolean            wnck_window_is_minimized            (WnckWindow *window);
Gets whether window is minimized. Minimization state may change anytime
a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis minimized,FALSEotherwise. | 
gboolean            wnck_window_is_maximized_horizontally
                                                        (WnckWindow *window);
Gets whether window is maximized horizontally. Horizontal maximization
state may change anytime a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis maximized horizontally,FALSEotherwise. | 
gboolean            wnck_window_is_maximized_vertically (WnckWindow *window);
Gets whether window is maximized vertically. vertiVal maximization
state may change anytime a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis maximized vertically,FALSEotherwise. | 
gboolean            wnck_window_is_maximized            (WnckWindow *window);
Gets whether window is maximized. Maximization state may change
anytime a "state-changed" signal gets emitted.
As for GDK, "maximized" means both vertically and horizontally. If window
is maximized in only one direction, then window is not considered
maximized.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis maximized in both directions,FALSEotherwise. | 
gboolean            wnck_window_is_shaded               (WnckWindow *window);
Gets whether window is shaded. Shade state may change anytime
a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis shaded,FALSEotherwise. | 
gboolean            wnck_window_is_pinned               (WnckWindow *window);
Gets whether window is on all workspace. Pinned state may change
anytime a "workspace-changed" signal gets emitted, but not when
a "state-changed" gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis on all workspaces,FALSEotherwise. | 
gboolean            wnck_window_is_sticky               (WnckWindow *window);
Gets whether window is sticky. Sticky state may change
anytime a "state-changed" signal gets emitted.
Sticky here means "stuck to the glass", i.e. does not scroll with the
viewport. In GDK/GTK+ (e.g. gdk_window_stick()/gtk_window_stick()), sticky
means "stuck to the glass" and also that the window is
on all workspaces. But here it only means the viewport aspect of it.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis "stuck to the glass",FALSEotherwise. | 
gboolean            wnck_window_is_above                (WnckWindow *window);
Gets whether window is above other windows. This state may change
anytime a "state-changed" signal gets emitted.
See wnck_window_make_above() for more details on this state.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis above other windows,FALSEotherwise. | 
Since 2.14
gboolean            wnck_window_is_below                (WnckWindow *window);
Gets whether window is below other windows. This state may change
anytime a "state-changed" signal gets emitted.
See wnck_window_make_below() for more details on this state.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis below other windows,FALSEotherwise. | 
Since 2.20
gboolean            wnck_window_is_skip_pager           (WnckWindow *window);
Gets whether window is included on pagers. This state may change
anytime a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis included on pagers,FALSEotherwise. | 
gboolean            wnck_window_is_skip_tasklist        (WnckWindow *window);
Gets whether window is included on tasklists. This state may change
anytime a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis included on tasklists,FALSEotherwise. | 
gboolean            wnck_window_is_fullscreen           (WnckWindow *window);
Gets whether window is fullscreen. Fullscreen state may change
anytime a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis fullscreen,FALSEotherwise. | 
Since 2.8
gboolean            wnck_window_needs_attention         (WnckWindow *window);
Gets whether window needs attention. This state may change anytime
a "state-changed" signal gets emitted.
This state depends on flags such as the demands_attention and is_urgent hints.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowneeds attention,FALSEotherwise. | 
Since 2.12
gboolean            wnck_window_or_transient_needs_attention
                                                        (WnckWindow *window);
Gets whether window or one of its transients needs attention. This state
may change anytime a "state-changed" signal gets emitted.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowor one of its transients needs attention,FALSEotherwise. | 
Since 2.12
typedef enum
{
  WNCK_WINDOW_ACTION_MOVE                    = 1 << 0,
  WNCK_WINDOW_ACTION_RESIZE                  = 1 << 1,
  WNCK_WINDOW_ACTION_SHADE                   = 1 << 2,
  WNCK_WINDOW_ACTION_STICK                   = 1 << 3,
  WNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY   = 1 << 4,
  WNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY     = 1 << 5,
  WNCK_WINDOW_ACTION_CHANGE_WORKSPACE        = 1 << 6, /* includes pin/unpin */
  WNCK_WINDOW_ACTION_CLOSE                   = 1 << 7,
  WNCK_WINDOW_ACTION_UNMAXIMIZE_HORIZONTALLY = 1 << 8,
  WNCK_WINDOW_ACTION_UNMAXIMIZE_VERTICALLY   = 1 << 9,
  WNCK_WINDOW_ACTION_UNSHADE                 = 1 << 10,
  WNCK_WINDOW_ACTION_UNSTICK                 = 1 << 11,
  WNCK_WINDOW_ACTION_MINIMIZE                = 1 << 12,
  WNCK_WINDOW_ACTION_UNMINIMIZE              = 1 << 13,
  WNCK_WINDOW_ACTION_MAXIMIZE                = 1 << 14,
  WNCK_WINDOW_ACTION_UNMAXIMIZE              = 1 << 15,
  WNCK_WINDOW_ACTION_FULLSCREEN              = 1 << 16,
  WNCK_WINDOW_ACTION_ABOVE                   = 1 << 17,
  WNCK_WINDOW_ACTION_BELOW                   = 1 << 18
} WnckWindowActions;
Type used as a bitmask to describe the actions that can be done for a WnckWindow.
| the window may be moved around the screen. | |
| the window may be resized. | |
| the window may be shaded. | |
| the window may be sticked. | |
| the window may be maximized horizontally. | |
| the window may be maximized vertically. | |
| the window may be moved between workspaces, or (un)pinned. | |
| the window may be closed. | |
| the window may be unmaximized horizontally. | |
| the window may be maximized vertically. | |
| the window may be unshaded. | |
| the window may be unsticked. | |
| the window may be minimized. | |
| the window may be unminimized. | |
| the window may be maximized. | |
| the window may be unmaximized. | |
| the window may be brought to fullscreen. | |
| the window may be made above other windows. | |
| the window may be made below other windows. | 
WnckWindowActions   wnck_window_get_actions             (WnckWindow *window);
Gets the actions that can be done for window.
| 
 | a WnckWindow. | 
| Returns : | bitmask of actions that can be done for window. | 
void                wnck_window_minimize                (WnckWindow *window);
Minimizes window.
| 
 | a WnckWindow. | 
void wnck_window_unminimize (WnckWindow *window,guint32 timestamp);
Unminimizes window by activating it or one of its transients. See
wnck_window_activate_transient() for details on how the activation is done.
| 
 | a WnckWindow. | 
| 
 | the X server timestamp of the user interaction event that caused this call to occur. | 
void                wnck_window_maximize_horizontally   (WnckWindow *window);
Asks the window manager to maximize horizontally window.
| 
 | a WnckWindow. | 
void                wnck_window_unmaximize_horizontally (WnckWindow *window);
Asks the window manager to unmaximize horizontally window.
| 
 | a WnckWindow. | 
void                wnck_window_maximize_vertically     (WnckWindow *window);
Asks the window manager to maximize vertically window.
| 
 | a WnckWindow. | 
void                wnck_window_unmaximize_vertically   (WnckWindow *window);
Asks the window manager to unmaximize vertically window.
| 
 | a WnckWindow. | 
void                wnck_window_maximize                (WnckWindow *window);
Asks the window manager to maximize window.
| 
 | a WnckWindow. | 
void                wnck_window_unmaximize              (WnckWindow *window);
Asks the window manager to unmaximize window.
| 
 | a WnckWindow. | 
void                wnck_window_shade                   (WnckWindow *window);
Asks the window manager to shade window.
| 
 | a WnckWindow. | 
void                wnck_window_unshade                 (WnckWindow *window);
Asks the window manager to unshade window.
| 
 | a WnckWindow. | 
void                wnck_window_pin                     (WnckWindow *window);
Asks the window manager to put window on all workspaces.
| 
 | a WnckWindow. | 
void                wnck_window_unpin                   (WnckWindow *window);
Asks the window manager to put window only in the currently active
workspace, if window was previously pinned. If window was not pinned,
does not change window's workspace. If the active workspace
is not known for some reason (it should not happen much), sets
window's workspace to the first workspace.
| 
 | a WnckWindow. | 
void                wnck_window_stick                   (WnckWindow *window);
Asks the window manager to keep the window's position fixed on the
screen, even when the workspace or viewport scrolls.
| 
 | a WnckWindow. | 
void                wnck_window_unstick                 (WnckWindow *window);
Asks the window manager to not have window's position fixed on the
screen when the workspace or viewport scrolls.
| 
 | a WnckWindow. | 
void                wnck_window_make_above              (WnckWindow *window);
Asks the window manager to put window on top of most windows (window will
not be on top of focused fullscreen windows, of other windows with this
setting and of dock windows).
| 
 | a WnckWindow. | 
Since 2.14
void                wnck_window_unmake_above            (WnckWindow *window);
Asks the window manager to not put window on top of most windows, and to
put it again in the stack with other windows.
| 
 | a WnckWindow. | 
Since 2.14
void                wnck_window_make_below              (WnckWindow *window);
Asks the window manager to put window below most windows.
| 
 | a WnckWindow. | 
Since 2.20
void                wnck_window_unmake_below            (WnckWindow *window);
Asks the window manager to not put window below most windows, and to
put it again in the stack with other windows.
| 
 | a WnckWindow. | 
Since 2.20
void wnck_window_set_skip_pager (WnckWindow *window,gboolean skip);
Asks the window manager to make window included or not included on pagers.
| 
 | a WnckWindow. | 
| 
 | whether windowshould be included on pagers. | 
void wnck_window_set_skip_tasklist (WnckWindow *window,gboolean skip);
Asks the window manager to make window included or not included on
tasklists.
| 
 | a WnckWindow. | 
| 
 | whether windowshould be included on tasklists. | 
void wnck_window_set_fullscreen (WnckWindow *window,gboolean fullscreen);
Asks the window manager to set the fullscreen state of window according to
fullscreen.
| 
 | a WnckWindow. | 
| 
 | whether to make windowfullscreen. | 
Since 2.8
void wnck_window_close (WnckWindow *window,guint32 timestamp);
Closes window.
This function existed before 2.6, but the timestamp argument was missing
in earlier versions.
| 
 | a WnckWindow. | 
| 
 | the X server timestamp of the user interaction event that caused this call to occur. | 
Since 2.6
WnckWorkspace*      wnck_window_get_workspace           (WnckWindow *window);
Gets the current workspace window is on. If the window is pinned (on all
workspaces), or not on any workspaces, NULL may be returned.
| 
 | a WnckWindow. | 
| Returns : | the single current workspace windowis on, orNULL. The returned WnckWorkspace is owned by libwnck and must not be
referenced or unreferenced. [transfer none] | 
gboolean wnck_window_is_on_workspace (WnckWindow *window,WnckWorkspace *workspace);
Gets whether window appears on workspace.
| 
 | a WnckWindow. | 
| 
 | a WnckWorkspace. | 
| Returns : | TRUEifwindowappears onworkspace,FALSEotherwise. | 
gboolean wnck_window_is_visible_on_workspace (WnckWindow *window,WnckWorkspace *workspace);
Like wnck_window_is_on_workspace(), but also checks that
the window is in a visible state (i.e. not minimized or shaded).
| 
 | a WnckWindow. | 
| 
 | a WnckWorkspace. | 
| Returns : | TRUEifwindowappears onworkspacein normal state,FALSEotherwise. | 
void wnck_window_move_to_workspace (WnckWindow *window,WnckWorkspace *space);
Asks the window manager to move window to space. If window was pinned, it
will also result in window being visible only on space.
| 
 | a WnckWindow. | 
| 
 | a WnckWorkspace. | 
gboolean wnck_window_is_in_viewport (WnckWindow *window,WnckWorkspace *workspace);
Gets TRUE if window appears in the current viewport of workspace.
| 
 | a WnckWindow. | 
| 
 | a WnckWorkspace. | 
| Returns : | TRUEifwindowappears in current viewport ofworkspace,FALSEotherwise. | 
Since 2.4
void wnck_window_activate (WnckWindow *window,guint32 timestamp);
Asks the window manager to make window the active window. The
window manager may choose to raise window along with focusing it, and may
decide to refuse the request (to not steal the focus if there is a more
recent user activity, for example).
This function existed before 2.10, but the timestamp argument was missing
in earlier versions.
| 
 | a WnckWindow. | 
| 
 | the X server timestamp of the user interaction event that caused this call to occur. | 
Since 2.10
gboolean            wnck_window_is_active               (WnckWindow *window);
Gets whether window is the active window on its WnckScreen.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowis the active window on its WnckScreen,FALSEotherwise. | 
gboolean            wnck_window_is_most_recently_activated
                                                        (WnckWindow *window);
Gets whether window is the most recently activated window on its
WnckScreen.
The most recently activated window is identical to the active window for click and sloppy focus methods (since a window is always active in those cases) but differs slightly for mouse focus since there often is no active window.
| 
 | a WnckWindow. | 
| Returns : | TRUEifwindowwas the most recently activated window on its
WnckScreen,FALSEotherwise. | 
Since 2.8
void wnck_window_activate_transient (WnckWindow *window,guint32 timestamp);
If window has transients, activates the most likely transient
instead of the window itself. Otherwise activates window.
FIXME the ideal behavior of this function is probably to activate
the most recently active window among window and its transients.
This is probably best implemented on the window manager side.
This function existed before 2.10, but the timestamp argument was missing
in earlier versions.
| 
 | a WnckWindow. | 
| 
 | the X server timestamp of the user interaction event that caused this call to occur. | 
Since 2.10
gboolean            wnck_window_transient_is_most_recently_activated
                                                        (WnckWindow *window);
Gets whether one of the transients of window is the most
recently activated window. See
wnck_window_is_most_recently_activated() for a more complete
description of what is meant by most recently activated.  This
function is needed because clicking on a WnckTasklist once will
activate a transient instead of window itself
(wnck_window_activate_transient), and clicking again should
minimize window and its transients.  (Not doing this can be
especially annoying in the case of modal dialogs that don't appear
in the WnckTasklist).
| 
 | a WnckWindow. | 
| Returns : | TRUEif one of the transients ofwindowis the most recently
activated window,FALSEotherwise. | 
Since 2.12
void wnck_window_set_icon_geometry (WnckWindow *window,int x,int y,int width,int height);
Sets the icon geometry for window. A typical use case for this is the
destination of the minimization animation of window.
| 
 | a WnckWindow. | 
| 
 | X coordinate in pixels. | 
| 
 | Y coordinate in pixels. | 
| 
 | width in pixels. | 
| 
 | height in pixels. | 
typedef enum
{
  WNCK_WINDOW_GRAVITY_CURRENT   = 0,
  WNCK_WINDOW_GRAVITY_NORTHWEST = 1,
  WNCK_WINDOW_GRAVITY_NORTH     = 2,
  WNCK_WINDOW_GRAVITY_NORTHEAST = 3,
  WNCK_WINDOW_GRAVITY_WEST      = 4,
  WNCK_WINDOW_GRAVITY_CENTER    = 5,
  WNCK_WINDOW_GRAVITY_EAST      = 6,
  WNCK_WINDOW_GRAVITY_SOUTHWEST = 7,
  WNCK_WINDOW_GRAVITY_SOUTH     = 8,
  WNCK_WINDOW_GRAVITY_SOUTHEAST = 9,
  WNCK_WINDOW_GRAVITY_STATIC    = 10
} WnckWindowGravity;
Flag used when changing the geometry of a WnckWindow. This is the gravity point to use as a reference for the new position.
| keep the current gravity point. | |
| use the left top corner of the frame window as gravity point. | |
| use the center of the frame window's top side as gravity point. | |
| use the right top corner of the frame window as gravity point. | |
| use the center of the frame window's left side as gravity point. | |
| use the center of the frame window as gravity point. | |
| use the center of the frame window's right side as gravity point. | |
| use the left bottom corner of the frame window as gravity point. | |
| use the center of the frame window's bottom side as gravity point. | |
| use the right bottom corner of the frame window as gravity point. | |
| use the left top corner of the client window as gravity point. | 
Since 2.16
typedef enum
{
  WNCK_WINDOW_CHANGE_X      = 1 << 0,
  WNCK_WINDOW_CHANGE_Y      = 1 << 1,
  WNCK_WINDOW_CHANGE_WIDTH  = 1 << 2,
  WNCK_WINDOW_CHANGE_HEIGHT = 1 << 3
} WnckWindowMoveResizeMask;
Flag used as a bitmask when changing the geometry of a WnckWindow. This indicates which part of the geometry should be changed.
| X coordinate of the window should be changed. | |
| Y coordinate of the window should be changed. | |
| width of the window should be changed. | |
| height of the window should be changed. | 
Since 2.16
void wnck_window_get_client_window_geometry (WnckWindow *window,int *xp,int *yp,int *widthp,int *heightp);
Gets the size and position of window, as last received
in a ConfigureNotify event (i.e. this call does not round-trip
to the server, just gets the last size we were notified of).
The X and Y coordinates are relative to the root window.
The window manager usually adds a frame around windows. If
you need to know the size of window with the frame, use
wnck_window_get_geometry().
| 
 | a WnckWindow. | 
| 
 | return location for X coordinate in pixels of window. | 
| 
 | return location for Y coordinate in pixels of window. | 
| 
 | return location for width in pixels of window. | 
| 
 | return location for height in pixels of window. | 
Since 2.20
void wnck_window_get_geometry (WnckWindow *window,int *xp,int *yp,int *widthp,int *heightp);
Gets the size and position of window, including decorations. This
function uses the information last received in a ConfigureNotify
event and adjusts it according to the size of the frame that is
added by the window manager (this call does not round-trip to the
server, it just gets the last sizes that were notified). The
X and Y coordinates are relative to the root window.
If you need to know the actual size of window ignoring the frame
added by the window manager, use wnck_window_get_client_window_geometry().
| 
 | a WnckWindow. | 
| 
 | return location for X coordinate in pixels of window. | 
| 
 | return location for Y coordinate in pixels of window. | 
| 
 | return location for width in pixels of window. | 
| 
 | return location for height in pixels of window. | 
void wnck_window_set_geometry (WnckWindow *window,WnckWindowGravity gravity,WnckWindowMoveResizeMask geometry_mask,int x,int y,int width,int height);
Sets the size and position of window. The X and Y coordinates should be
relative to the root window.
Note that the new size and position apply to window with its frame added
by the window manager. Therefore, using wnck_window_set_geometry() with
the values returned by wnck_window_get_geometry() should be a no-op, while
using wnck_window_set_geometry() with the values returned by
wnck_window_get_client_window_geometry() should reduce the size of window
and move it.
| 
 | a WnckWindow. | 
| 
 | the gravity point to use as a reference for the new position. | 
| 
 | a bitmask containing flags for what should be set. | 
| 
 | new X coordinate in pixels of window. | 
| 
 | new Y coordinate in pixels of window. | 
| 
 | new width in pixels of window. | 
| 
 | new height in pixels of window. | 
Since 2.16
void                wnck_window_keyboard_move           (WnckWindow *window);
Asks the window manager to start moving window via the keyboard.
| 
 | a WnckWindow. | 
void                wnck_window_keyboard_size           (WnckWindow *window);
Asks the window manager to start resizing window via the keyboard.
| 
 | a WnckWindow. | 
"actions-changed" signalvoid user_function (WnckWindow *window, WnckWindowActions changed_mask, WnckWindowActions new_state, gpointer user_data) : Run Last
Emitted when the actions availabilities for window change.
| 
 | the WnckWindow which emitted the signal. | 
| 
 | the bitmask containing bits set for all actions
availabilities for windowthat have changed. | 
| 
 | the new actions availabilities for window. | 
| 
 | user data set when the signal handler was connected. | 
"geometry-changed" signalvoid user_function (WnckWindow *window, gpointer user_data) : Run Last
Emitted when the geometry of window changes.
| 
 | the WnckWindow which emitted the signal. | 
| 
 | user data set when the signal handler was connected. | 
"icon-changed" signalvoid user_function (WnckWindow *window, gpointer user_data) : Run Last
Emitted when the icon of window changes.
| 
 | the WnckWindow which emitted the signal. | 
| 
 | user data set when the signal handler was connected. | 
"name-changed" signalvoid user_function (WnckWindow *window, gpointer user_data) : Run Last
Emitted when the name of window changes.
| 
 | the WnckWindow which emitted the signal. | 
| 
 | user data set when the signal handler was connected. | 
"state-changed" signalvoid user_function (WnckWindow *window, WnckWindowState changed_mask, WnckWindowState new_state, gpointer user_data) : Run Last
Emitted when the state of window changes. This can happen when window is
(un)minimized, (un)maximized, (un)sticked, (un)shaded, (un)made above,
(un)made below, (un)set fullscreen, when it needs attention, etc. See
WnckWindowState for the complete list of states that might have changed.
| 
 | the WnckWindow which emitted the signal. | 
| 
 | the bitmask containing bits set for all states of windowthat have changed. | 
| 
 | the new state of window. | 
| 
 | user data set when the signal handler was connected. | 
"workspace-changed" signalvoid user_function (WnckWindow *window, gpointer user_data) : Run Last
Emitted when the current workspace of window changes, or if window has
been pinned or unpinned.
| 
 | the WnckWindow which emitted the signal. | 
| 
 | user data set when the signal handler was connected. |