MatewnckWindow

## MatewnckWindow MatewnckWindow — an object representing a window. |

## Stability Level

Unstable, unless otherwise indicated

## Synopsis

    #include <libmatewnck/libmatewnck.h>

                        MatewnckWindow;
    MatewnckWindow *    matewnck_window_get                 (gulong xwindow);
    MatewnckScreen *    matewnck_window_get_screen          (MatewnckWindow *window);
    gboolean            matewnck_window_has_name            (MatewnckWindow *window);
    const char *        matewnck_window_get_name            (MatewnckWindow *window);
    gboolean            matewnck_window_has_icon_name       (MatewnckWindow *window);
    const char *        matewnck_window_get_icon_name       (MatewnckWindow *window);
    gboolean            matewnck_window_get_icon_is_fallback
                                                            (MatewnckWindow *window);
    GdkPixbuf *         matewnck_window_get_icon            (MatewnckWindow *window);
    GdkPixbuf *         matewnck_window_get_mini_icon       (MatewnckWindow *window);
    MatewnckApplication * matewnck_window_get_application   (MatewnckWindow *window);
    MatewnckWindow *    matewnck_window_get_transient       (MatewnckWindow *window);
    gulong              matewnck_window_get_group_leader    (MatewnckWindow *window);
    gulong              matewnck_window_get_xid             (MatewnckWindow *window);
    MatewnckClassGroup * matewnck_window_get_class_group    (MatewnckWindow *window);
    const char *        matewnck_window_get_session_id      (MatewnckWindow *window);
    const char *        matewnck_window_get_session_id_utf8 (MatewnckWindow *window);
    int                 matewnck_window_get_pid             (MatewnckWindow *window);
    gint                matewnck_window_get_sort_order      (MatewnckWindow *window);
    void                matewnck_window_set_sort_order      (MatewnckWindow *window,
                                                             gint order);
    enum                MatewnckWindowType;
    MatewnckWindowType  matewnck_window_get_window_type     (MatewnckWindow *window);
    void                matewnck_window_set_window_type     (MatewnckWindow *window,
                                                             MatewnckWindowType wintype);
    enum                MatewnckWindowState;
    MatewnckWindowState matewnck_window_get_state           (MatewnckWindow *window);
    gboolean            matewnck_window_is_minimized        (MatewnckWindow *window);
    gboolean            matewnck_window_is_maximized_horizontally
                                                            (MatewnckWindow *window);
    gboolean            matewnck_window_is_maximized_vertically
                                                            (MatewnckWindow *window);
    gboolean            matewnck_window_is_maximized        (MatewnckWindow *window);
    gboolean            matewnck_window_is_shaded           (MatewnckWindow *window);
    gboolean            matewnck_window_is_pinned           (MatewnckWindow *window);
    gboolean            matewnck_window_is_sticky           (MatewnckWindow *window);
    gboolean            matewnck_window_is_above            (MatewnckWindow *window);
    gboolean            matewnck_window_is_below            (MatewnckWindow *window);
    gboolean            matewnck_window_is_skip_pager       (MatewnckWindow *window);
    gboolean            matewnck_window_is_skip_tasklist    (MatewnckWindow *window);
    gboolean            matewnck_window_is_fullscreen       (MatewnckWindow *window);
    gboolean            matewnck_window_needs_attention     (MatewnckWindow *window);
    gboolean            matewnck_window_or_transient_needs_attention
                                                            (MatewnckWindow *window);
    enum                MatewnckWindowActions;
    MatewnckWindowActions matewnck_window_get_actions       (MatewnckWindow *window);
    void                matewnck_window_minimize            (MatewnckWindow *window);
    void                matewnck_window_unminimize          (MatewnckWindow *window,
                                                             guint32 timestamp);
    void                matewnck_window_maximize_horizontally
                                                            (MatewnckWindow *window);
    void                matewnck_window_unmaximize_horizontally
                                                            (MatewnckWindow *window);
    void                matewnck_window_maximize_vertically (MatewnckWindow *window);
    void                matewnck_window_unmaximize_vertically
                                                            (MatewnckWindow *window);
    void                matewnck_window_maximize            (MatewnckWindow *window);
    void                matewnck_window_unmaximize          (MatewnckWindow *window);
    void                matewnck_window_shade               (MatewnckWindow *window);
    void                matewnck_window_unshade             (MatewnckWindow *window);
    void                matewnck_window_pin                 (MatewnckWindow *window);
    void                matewnck_window_unpin               (MatewnckWindow *window);
    void                matewnck_window_stick               (MatewnckWindow *window);
    void                matewnck_window_unstick             (MatewnckWindow *window);
    void                matewnck_window_make_above          (MatewnckWindow *window);
    void                matewnck_window_unmake_above        (MatewnckWindow *window);
    void                matewnck_window_make_below          (MatewnckWindow *window);
    void                matewnck_window_unmake_below        (MatewnckWindow *window);
    void                matewnck_window_set_skip_pager      (MatewnckWindow *window,
                                                             gboolean skip);
    void                matewnck_window_set_skip_tasklist   (MatewnckWindow *window,
                                                             gboolean skip);
    void                matewnck_window_set_fullscreen      (MatewnckWindow *window,
                                                             gboolean fullscreen);
    void                matewnck_window_close               (MatewnckWindow *window,
                                                             guint32 timestamp);
    MatewnckWorkspace * matewnck_window_get_workspace       (MatewnckWindow *window);
    gboolean            matewnck_window_is_on_workspace     (MatewnckWindow *window,
                                                             MatewnckWorkspace *workspace);
    gboolean            matewnck_window_is_visible_on_workspace
                                                            (MatewnckWindow *window,
                                                             MatewnckWorkspace *workspace);
    void                matewnck_window_move_to_workspace   (MatewnckWindow *window,
                                                             MatewnckWorkspace *space);
    gboolean            matewnck_window_is_in_viewport      (MatewnckWindow *window,
                                                             MatewnckWorkspace *workspace);
    void                matewnck_window_activate            (MatewnckWindow *window,
                                                             guint32 timestamp);
    gboolean            matewnck_window_is_active           (MatewnckWindow *window);
    gboolean            matewnck_window_is_most_recently_activated
                                                            (MatewnckWindow *window);
    void                matewnck_window_activate_transient  (MatewnckWindow *window,
                                                             guint32 timestamp);
    gboolean            matewnck_window_transient_is_most_recently_activated
                                                            (MatewnckWindow *window);
    void                matewnck_window_set_icon_geometry   (MatewnckWindow *window,
                                                             int x,
                                                             int y,
                                                             int width,
                                                             int height);
    enum                MatewnckWindowGravity;
    enum                MatewnckWindowMoveResizeMask;
    void                matewnck_window_get_client_window_geometry
                                                            (MatewnckWindow *window,
                                                             int *xp,
                                                             int *yp,
                                                             int *widthp,
                                                             int *heightp);
    void                matewnck_window_get_geometry        (MatewnckWindow *window,
                                                             int *xp,
                                                             int *yp,
                                                             int *widthp,
                                                             int *heightp);
    void                matewnck_window_set_geometry        (MatewnckWindow *window,
                                                             MatewnckWindowGravity gravity,
                                                             MatewnckWindowMoveResizeMask geometry_mask,
                                                             int x,
                                                             int y,
                                                             int width,
                                                             int height);
    void                matewnck_window_keyboard_move       (MatewnckWindow *window);
    void                matewnck_window_keyboard_size       (MatewnckWindow *window);

## Object Hierarchy

      GObject
       +----MatewnckWindow

## Signals

      "actions-changed"                                : Run Last
      "geometry-changed"                               : Run Last
      "icon-changed"                                   : Run Last
      "name-changed"                                   : Run Last
      "state-changed"                                  : Run Last
      "workspace-changed"                              : Run Last

## Description

The MatewnckWindow objects are always owned by libmatewnck and must not be referenced or unreferenced.

## Details

### MatewnckWindow

    typedef struct _MatewnckWindow MatewnckWindow;

The MatewnckWindow struct contains only private fields and should not be directly accessed.

### matewnck_window_get ()

    MatewnckWindow *    matewnck_window_get                 (gulong xwindow);

Gets a preexisting MatewnckWindow for the X window `xwindow`. This will not create a MatewnckWindow if none exists. The function is robust against bogus window IDs.

`xwindow` : | an X window ID.
Returns : | the MatewnckWindow for `xwindow`. The returned MatewnckWindow is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

### matewnck_window_get_screen ()

    MatewnckScreen *    matewnck_window_get_screen          (MatewnckWindow *window);

Gets the MatewnckScreen `window` is on.

`window` : | a MatewnckWindow.
Returns : | the MatewnckScreen `window` is on. The returned MatewnckScreen is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

### matewnck_window_has_name ()

    gboolean            matewnck_window_has_name            (MatewnckWindow *window);

Checks whether or not `window` has a name. `matewnck_window_get_name()` will always return some value, even if `window` has no name set; `matewnck_window_has_name()` can be used to tell if that name is real or not.

For icons titles, use `matewnck_window_has_icon_name()` instead.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `matewnck_window_get_name()` returns `window`'s name, `FALSE` if it returns a fallback name.

Since 2.16

### matewnck_window_get_name ()

    const char *        matewnck_window_get_name            (MatewnckWindow *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 `matewnck_window_has_name()` if you need to know whether the returned name is "real" or not.

For icons titles, use `matewnck_window_get_icon_name()` instead.

`window` : | a MatewnckWindow.
Returns : | the name of `window`, or a fallback name if no name is available.

### matewnck_window_has_icon_name ()

    gboolean            matewnck_window_has_icon_name       (MatewnckWindow *window);

Checks whether or not `window` has an icon name. `matewnck_window_get_icon_name()` will always return some value, even if `window` has no icon name set; `matewnck_window_has_icon_name()` can be used to tell if that icon name is real or not.

(Note that if `matewnck_window_has_icon_name()` returns `FALSE`, but `matewnck_window_has_name()` returns `TRUE`, then the name returned by `matewnck_window_get_icon_name()` is `window`'s name. Only when both methods return `FALSE` does `matewnck_window_get_icon_name()` return a generic fallback name.)

`window` : | a MatewnckWindow
Returns : | `TRUE` if `matewnck_window_get_icon_name()` returns `window`'s icon name, `FALSE` if it returns a fallback name.

Since 2.16

### matewnck_window_get_icon_name ()

    const char *        matewnck_window_get_icon_name       (MatewnckWindow *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 `matewnck_window_has_icon_name()` if you need to know whether the returned icon name is "real" or not.

Contrast with `matewnck_window_get_name()`, which returns `window`'s title, not its icon title.

`window` : | a MatewnckWindow
Returns : | the icon name of `window`, or a fallback icon name if no icon name is available.

### matewnck_window_get_icon_is_fallback ()

    gboolean            matewnck_window_get_icon_is_fallback
                                                            (MatewnckWindow *window);

Gets whether a default fallback icon is used for `window` (because none was set on `window`).

`window` : | a MatewnckWindow.
Returns : | `TRUE` if the icon for `window` is a fallback, `FALSE` otherwise.

### matewnck_window_get_icon ()

    GdkPixbuf *         matewnck_window_get_icon            (MatewnckWindow *window);

Gets the icon to be used for `window`. If no icon was found, a fallback icon is used. `matewnck_window_get_icon_is_fallback()` can be used to tell if the icon is the fallback icon.

`window` : | a MatewnckWindow.
Returns : | the icon for `window`. The caller should reference the returned `GdkPixbuf` if it needs to keep the icon around.

### matewnck_window_get_mini_icon ()

    GdkPixbuf *         matewnck_window_get_mini_icon       (MatewnckWindow *window);

Gets the mini-icon to be used for `window`. If no mini-icon was found, a fallback mini-icon is used. `matewnck_window_get_icon_is_fallback()` can be used to tell if the mini-icon is the fallback mini-icon.

`window` : | a MatewnckWindow.
Returns : | the mini-icon for `window`. The caller should reference the returned `GdkPixbuf` if it needs to keep the icon around.

### matewnck_window_get_application ()

    MatewnckApplication * matewnck_window_get_application   (MatewnckWindow *window);

Gets the MatewnckApplication to which `window` belongs.

`window` : | a MatewnckWindow.
Returns : | the MatewnckApplication to which `window` belongs. The returned MatewnckApplication is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

### matewnck_window_get_transient ()

    MatewnckWindow *    matewnck_window_get_transient       (MatewnckWindow *window);

Gets the MatewnckWindow for which `window` is transient.

`window` : | a MatewnckWindow.
Returns : | the MatewnckWindow for which `window` is transient, or `NULL` if `window` is not transient for any MatewnckWindow.

Since 2.12

### matewnck_window_get_group_leader ()

    gulong              matewnck_window_get_group_leader    (MatewnckWindow *window);

Gets the group leader of the group of windows to which `window` belongs.

`window` : | a MatewnckWindow.
Returns : | the group leader of the group of windows to which `window` belongs, or the X window ID of `window` if `window` does not belong to any group.

### matewnck_window_get_xid ()

    gulong              matewnck_window_get_xid             (MatewnckWindow *window);

Gets the X window ID of `window`.

`window` : | a MatewnckWindow.
Returns : | the X window ID of `window`.

### matewnck_window_get_class_group ()

    MatewnckClassGroup * matewnck_window_get_class_group    (MatewnckWindow *window);

Gets the MatewnckClassGroup to which `window` belongs.

`window` : | a MatewnckWindow.
Returns : | the MatewnckClassGroup to which `window` belongs. The returned MatewnckClassGroup is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

Since 2.2

### matewnck_window_get_session_id ()

    const char *        matewnck_window_get_session_id      (MatewnckWindow *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 `matewnck_window_get_session_id_utf8()`.

`window` : | a MatewnckWindow.
Returns : | the session ID for `window` in Latin-1, or `NULL` if `window` has no session ID.

### matewnck_window_get_session_id_utf8 ()

    const char *        matewnck_window_get_session_id_utf8 (MatewnckWindow *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.

`window` : | a MatewnckWindow.
Returns : | the session ID for `window` in UTF-8, or `NULL` if `window` has no session ID.

### matewnck_window_get_pid ()

    int                 matewnck_window_get_pid             (MatewnckWindow *window);

Gets the process ID of `window`.

`window` : | a MatewnckWindow.
Returns : | the process ID of `window`, or 0 if none is available.

### matewnck_window_get_sort_order ()

    gint                matewnck_window_get_sort_order      (MatewnckWindow *window);

Gets the sort order of `window`, used for ordering of `window` in MatewnckSelector and MatewnckTasklist. The sort order is an internal state in libmatewnck. The initial value is defined when the window is created.

`window` : | a MatewnckWindow.
Returns : | the sort order of `window`, or G_MAXINT if none is available.

Since 2.10

### matewnck_window_set_sort_order ()

    void                matewnck_window_set_sort_order      (MatewnckWindow *window,
                                                             gint order);

Sets the sort order of `window`. The sort order is used for ordering of `window` in MatewnckSelector and MatewnckTasklist.

`window` : | a MatewnckWindow.
`order` : | new sort order for `window`.

Since 2.20

### enum MatewnckWindowType

    typedef enum {
      MATEWNCK_WINDOW_NORMAL,       /* document/app window */
      MATEWNCK_WINDOW_DESKTOP,      /* desktop background */
      MATEWNCK_WINDOW_DOCK,         /* panel */
      MATEWNCK_WINDOW_DIALOG,       /* dialog */
      MATEWNCK_WINDOW_TOOLBAR,      /* tearoff toolbar */
      MATEWNCK_WINDOW_MENU,         /* tearoff menu */
      MATEWNCK_WINDOW_UTILITY,      /* palette/toolbox window */
      MATEWNCK_WINDOW_SPLASHSCREEN  /* splash screen */
    } MatewnckWindowType;

Type describing the semantic type of a MatewnckWindow.

`MATEWNCK_WINDOW_NORMAL` | the window is a normal window.
`MATEWNCK_WINDOW_DESKTOP` | the window is a desktop.
`MATEWNCK_WINDOW_DOCK` | the window is a dock or a panel.
`MATEWNCK_WINDOW_DIALOG` | the window is a dialog window.
`MATEWNCK_WINDOW_TOOLBAR` | the window is a tearoff toolbar.
`MATEWNCK_WINDOW_MENU` | the window is a tearoff menu.
`MATEWNCK_WINDOW_UTILITY` | the window is a small persistent utility window, such as a palette or toolbox.
`MATEWNCK_WINDOW_SPLASHSCREEN` | the window is a splash screen displayed as an application is starting up.

### matewnck_window_get_window_type ()

    MatewnckWindowType  matewnck_window_get_window_type     (MatewnckWindow *window);

Gets the semantic type of `window`.

`window` : | a MatewnckWindow.
Returns : | the semantic type of `window`.

### matewnck_window_set_window_type ()

    void                matewnck_window_set_window_type     (MatewnckWindow *window,
                                                             MatewnckWindowType wintype);

Sets the semantic type of `window` to `wintype`.

`window` : | a MatewnckWindow.
`wintype` : | a semantic type.

Since 2.12

### enum MatewnckWindowState

    typedef enum {
      MATEWNCK_WINDOW_STATE_MINIMIZED              = 1 << 0,
      MATEWNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY = 1 << 1,
      MATEWNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY   = 1 << 2,
      MATEWNCK_WINDOW_STATE_SHADED                 = 1 << 3,
      MATEWNCK_WINDOW_STATE_SKIP_PAGER             = 1 << 4,
      MATEWNCK_WINDOW_STATE_SKIP_TASKLIST          = 1 << 5,
      MATEWNCK_WINDOW_STATE_STICKY                 = 1 << 6,
      MATEWNCK_WINDOW_STATE_HIDDEN                 = 1 << 7,
      MATEWNCK_WINDOW_STATE_FULLSCREEN             = 1 << 8,
      MATEWNCK_WINDOW_STATE_DEMANDS_ATTENTION      = 1 << 9,
      MATEWNCK_WINDOW_STATE_URGENT                 = 1 << 10,
      MATEWNCK_WINDOW_STATE_ABOVE                  = 1 << 11,
      MATEWNCK_WINDOW_STATE_BELOW                  = 1 << 12
    } MatewnckWindowState;

Type used as a bitmask to describe the state of a MatewnckWindow.

`MATEWNCK_WINDOW_STATE_MINIMIZED` | the window is minimized.
`MATEWNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY` | the window is horizontically maximized.
`MATEWNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY` | the window is vertically maximized.
`MATEWNCK_WINDOW_STATE_SHADED` | the window is shaded.
`MATEWNCK_WINDOW_STATE_SKIP_PAGER` | the window should not be included on pagers.
`MATEWNCK_WINDOW_STATE_SKIP_TASKLIST` | the window should not be included on tasklists.
`MATEWNCK_WINDOW_STATE_STICKY` | the window is sticky (see `matewnck_window_is_sticky()`).
`MATEWNCK_WINDOW_STATE_HIDDEN` | the window is not visible on its MatewnckWorkspace and viewport (when minimized, for example).
`MATEWNCK_WINDOW_STATE_FULLSCREEN` | the window is fullscreen.
`MATEWNCK_WINDOW_STATE_DEMANDS_ATTENTION` | the window needs attention (because the window requested activation but the window manager refused it, for example).
`MATEWNCK_WINDOW_STATE_URGENT` | the window requires a response from the user.
`MATEWNCK_WINDOW_STATE_ABOVE` | the window is above other windows (see `matewnck_window_make_above()`).
`MATEWNCK_WINDOW_STATE_BELOW` | the window is below other windows (see `matewnck_window_make_below()`).

### matewnck_window_get_state ()

    MatewnckWindowState matewnck_window_get_state           (MatewnckWindow *window);

Gets the state of `window`.

`window` : | a MatewnckWindow.
Returns : | bitmask of active states for `window`.

### matewnck_window_is_minimized ()

    gboolean            matewnck_window_is_minimized        (MatewnckWindow *window);

Gets whether `window` is minimized. Minimization state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is minimized, `FALSE` otherwise.

### matewnck_window_is_maximized_horizontally ()

    gboolean            matewnck_window_is_maximized_horizontally
                                                            (MatewnckWindow *window);

Gets whether `window` is maximized horizontally. Horizontal maximization state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is maximized horizontally, `FALSE` otherwise.

### matewnck_window_is_maximized_vertically ()

    gboolean            matewnck_window_is_maximized_vertically
                                                            (MatewnckWindow *window);

Gets whether `window` is maximized vertically. vertiVal maximization state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is maximized vertically, `FALSE` otherwise.

### matewnck_window_is_maximized ()

    gboolean            matewnck_window_is_maximized        (MatewnckWindow *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.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is maximized in both directions, `FALSE` otherwise.

### matewnck_window_is_shaded ()

    gboolean            matewnck_window_is_shaded           (MatewnckWindow *window);

Gets whether `window` is shaded. Shade state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is shaded, `FALSE` otherwise.

### matewnck_window_is_pinned ()

    gboolean            matewnck_window_is_pinned           (MatewnckWindow *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.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is on all workspaces, `FALSE` otherwise.

### matewnck_window_is_sticky ()

    gboolean            matewnck_window_is_sticky           (MatewnckWindow *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.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is "stuck to the glass", `FALSE` otherwise.

### matewnck_window_is_above ()

    gboolean            matewnck_window_is_above            (MatewnckWindow *window);

Gets whether `window` is above other windows. This state may change anytime a "state-changed" signal gets emitted.

See `matewnck_window_make_above()` for more details on this state.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is above other windows, `FALSE` otherwise.

Since 2.14

### matewnck_window_is_below ()

    gboolean            matewnck_window_is_below            (MatewnckWindow *window);

Gets whether `window` is below other windows. This state may change anytime a "state-changed" signal gets emitted.

See `matewnck_window_make_below()` for more details on this state.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is below other windows, `FALSE` otherwise.

Since 2.20

### matewnck_window_is_skip_pager ()

    gboolean            matewnck_window_is_skip_pager       (MatewnckWindow *window);

Gets whether `window` is included on pagers. This state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is included on pagers, `FALSE` otherwise.

### matewnck_window_is_skip_tasklist ()

    gboolean            matewnck_window_is_skip_tasklist    (MatewnckWindow *window);

Gets whether `window` is included on tasklists. This state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is included on tasklists, `FALSE` otherwise.

### matewnck_window_is_fullscreen ()

    gboolean            matewnck_window_is_fullscreen       (MatewnckWindow *window);

Gets whether `window` is fullscreen. Fullscreen state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is fullscreen, `FALSE` otherwise.

Since 2.8

### matewnck_window_needs_attention ()

    gboolean            matewnck_window_needs_attention     (MatewnckWindow *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.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` needs attention, `FALSE` otherwise.

Since 2.12

### matewnck_window_or_transient_needs_attention ()

    gboolean            matewnck_window_or_transient_needs_attention
                                                            (MatewnckWindow *window);

Gets whether `window` or one of its transients needs attention. This state may change anytime a "state-changed" signal gets emitted.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` or one of its transients needs attention, `FALSE` otherwise.

Since 2.12

### enum MatewnckWindowActions

    typedef enum {
      MATEWNCK_WINDOW_ACTION_MOVE                    = 1 << 0,
      MATEWNCK_WINDOW_ACTION_RESIZE                  = 1 << 1,
      MATEWNCK_WINDOW_ACTION_SHADE                   = 1 << 2,
      MATEWNCK_WINDOW_ACTION_STICK                   = 1 << 3,
      MATEWNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY   = 1 << 4,
      MATEWNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY     = 1 << 5,
      MATEWNCK_WINDOW_ACTION_CHANGE_WORKSPACE        = 1 << 6, /* includes pin/unpin */
      MATEWNCK_WINDOW_ACTION_CLOSE                   = 1 << 7,
      MATEWNCK_WINDOW_ACTION_UNMAXIMIZE_HORIZONTALLY = 1 << 8,
      MATEWNCK_WINDOW_ACTION_UNMAXIMIZE_VERTICALLY   = 1 << 9,
      MATEWNCK_WINDOW_ACTION_UNSHADE                 = 1 << 10,
      MATEWNCK_WINDOW_ACTION_UNSTICK                 = 1 << 11,
      MATEWNCK_WINDOW_ACTION_MINIMIZE                = 1 << 12,
      MATEWNCK_WINDOW_ACTION_UNMINIMIZE              = 1 << 13,
      MATEWNCK_WINDOW_ACTION_MAXIMIZE                = 1 << 14,
      MATEWNCK_WINDOW_ACTION_UNMAXIMIZE              = 1 << 15,
      MATEWNCK_WINDOW_ACTION_FULLSCREEN              = 1 << 16,
      MATEWNCK_WINDOW_ACTION_ABOVE                   = 1 << 17,
      MATEWNCK_WINDOW_ACTION_BELOW                   = 1 << 18
    } MatewnckWindowActions;

Type used as a bitmask to describe the actions that can be done for a MatewnckWindow.

`MATEWNCK_WINDOW_ACTION_MOVE` | the window may be moved around the screen.
`MATEWNCK_WINDOW_ACTION_RESIZE` | the window may be resized.
`MATEWNCK_WINDOW_ACTION_SHADE` | the window may be shaded.
`MATEWNCK_WINDOW_ACTION_STICK` | the window may be sticked.
`MATEWNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY` | the window may be maximized horizontally.
`MATEWNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY` | the window may be maximized vertically.
`MATEWNCK_WINDOW_ACTION_CHANGE_WORKSPACE` | the window may be moved between workspaces, or (un)pinned.
`MATEWNCK_WINDOW_ACTION_CLOSE` | the window may be closed.
`MATEWNCK_WINDOW_ACTION_UNMAXIMIZE_HORIZONTALLY` | the window may be unmaximized horizontally.
`MATEWNCK_WINDOW_ACTION_UNMAXIMIZE_VERTICALLY` | the window may be maximized vertically.
`MATEWNCK_WINDOW_ACTION_UNSHADE` | the window may be unshaded.
`MATEWNCK_WINDOW_ACTION_UNSTICK` | the window may be unsticked.
`MATEWNCK_WINDOW_ACTION_MINIMIZE` | the window may be minimized.
`MATEWNCK_WINDOW_ACTION_UNMINIMIZE` | the window may be unminimized.
`MATEWNCK_WINDOW_ACTION_MAXIMIZE` | the window may be maximized.
`MATEWNCK_WINDOW_ACTION_UNMAXIMIZE` | the window may be unmaximized.
`MATEWNCK_WINDOW_ACTION_FULLSCREEN` | the window may be brought to fullscreen.
`MATEWNCK_WINDOW_ACTION_ABOVE` | the window may be made above other windows.
`MATEWNCK_WINDOW_ACTION_BELOW` | the window may be made below other windows.

### matewnck_window_get_actions ()

    MatewnckWindowActions matewnck_window_get_actions       (MatewnckWindow *window);

Gets the actions that can be done for `window`.

`window` : | a MatewnckWindow.
Returns : | bitmask of actions that can be done for `window`.

### matewnck_window_minimize ()

    void                matewnck_window_minimize            (MatewnckWindow *window);

Minimizes `window`.

`window` : | a MatewnckWindow.

### matewnck_window_unminimize ()

    void                matewnck_window_unminimize          (MatewnckWindow *window,
                                                             guint32 timestamp);

Unminimizes `window` by activating it or one of its transients. See `matewnck_window_activate_transient()` for details on how the activation is done.

`window` : | a MatewnckWindow.
`timestamp` : | the X server timestamp of the user interaction event that caused this call to occur.

### matewnck_window_maximize_horizontally ()

    void                matewnck_window_maximize_horizontally
                                                            (MatewnckWindow *window);

Asks the window manager to maximize horizontally `window`.

`window` : | a MatewnckWindow.

### matewnck_window_unmaximize_horizontally ()

    void                matewnck_window_unmaximize_horizontally
                                                            (MatewnckWindow *window);

Asks the window manager to unmaximize horizontally `window`.

`window` : | a MatewnckWindow.

### matewnck_window_maximize_vertically ()

    void                matewnck_window_maximize_vertically (MatewnckWindow *window);

Asks the window manager to maximize vertically `window`.

`window` : | a MatewnckWindow.

### matewnck_window_unmaximize_vertically ()

    void                matewnck_window_unmaximize_vertically
                                                            (MatewnckWindow *window);

Asks the window manager to unmaximize vertically `window`.

`window` : | a MatewnckWindow.

### matewnck_window_maximize ()

    void                matewnck_window_maximize            (MatewnckWindow *window);

Asks the window manager to maximize `window`.

`window` : | a MatewnckWindow.

### matewnck_window_unmaximize ()

    void                matewnck_window_unmaximize          (MatewnckWindow *window);

Asks the window manager to unmaximize `window`.

`window` : | a MatewnckWindow.

### matewnck_window_shade ()

    void                matewnck_window_shade               (MatewnckWindow *window);

Asks the window manager to shade `window`.

`window` : | a MatewnckWindow.

### matewnck_window_unshade ()

    void                matewnck_window_unshade             (MatewnckWindow *window);

Asks the window manager to unshade `window`.

`window` : | a MatewnckWindow.

### matewnck_window_pin ()

    void                matewnck_window_pin                 (MatewnckWindow *window);

Asks the window manager to put `window` on all workspaces.

`window` : | a MatewnckWindow.

### matewnck_window_unpin ()

    void                matewnck_window_unpin               (MatewnckWindow *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.

`window` : | a MatewnckWindow.

### matewnck_window_stick ()

    void                matewnck_window_stick               (MatewnckWindow *window);

Asks the window manager to keep the `window`'s position fixed on the screen, even when the workspace or viewport scrolls.

`window` : | a MatewnckWindow.

### matewnck_window_unstick ()

    void                matewnck_window_unstick             (MatewnckWindow *window);

Asks the window manager to not have `window`'s position fixed on the screen when the workspace or viewport scrolls.

`window` : | a MatewnckWindow.

### matewnck_window_make_above ()

    void                matewnck_window_make_above          (MatewnckWindow *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).

`window` : | a MatewnckWindow.

Since 2.14

### matewnck_window_unmake_above ()

    void                matewnck_window_unmake_above        (MatewnckWindow *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.

`window` : | a MatewnckWindow.

Since 2.14

### matewnck_window_make_below ()

    void                matewnck_window_make_below          (MatewnckWindow *window);

Asks the window manager to put `window` below most windows.

`window` : | a MatewnckWindow.

Since 2.20

### matewnck_window_unmake_below ()

    void                matewnck_window_unmake_below        (MatewnckWindow *window);

Asks the window manager to not put `window` below most windows, and to put it again in the stack with other windows.

`window` : | a MatewnckWindow.

Since 2.20

### matewnck_window_set_skip_pager ()

    void                matewnck_window_set_skip_pager      (MatewnckWindow *window,
                                                             gboolean skip);

Asks the window manager to make `window` included or not included on pagers.

`window` : | a MatewnckWindow.
`skip` : | whether `window` should be included on pagers.

### matewnck_window_set_skip_tasklist ()

    void                matewnck_window_set_skip_tasklist   (MatewnckWindow *window,
                                                             gboolean skip);

Asks the window manager to make `window` included or not included on tasklists.

`window` : | a MatewnckWindow.
`skip` : | whether `window` should be included on tasklists.

### matewnck_window_set_fullscreen ()

    void                matewnck_window_set_fullscreen      (MatewnckWindow *window,
                                                             gboolean fullscreen);

Asks the window manager to set the fullscreen state of `window` according to `fullscreen`.

`window` : | a MatewnckWindow.
`fullscreen` : | whether to make `window` fullscreen.

Since 2.8

### matewnck_window_close ()

    void                matewnck_window_close               (MatewnckWindow *window,
                                                             guint32 timestamp);

Closes `window`.

This function existed before 2.6, but the `timestamp` argument was missing in earlier versions.

`window` : | a MatewnckWindow.
`timestamp` : | the X server timestamp of the user interaction event that caused this call to occur.

Since 2.6

### matewnck_window_get_workspace ()

    MatewnckWorkspace * matewnck_window_get_workspace       (MatewnckWindow *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.

`window` : | a MatewnckWindow.
Returns : | the single current workspace `window` is on, or `NULL`. The returned MatewnckWorkspace is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

### matewnck_window_is_on_workspace ()

    gboolean            matewnck_window_is_on_workspace     (MatewnckWindow *window,
                                                             MatewnckWorkspace *workspace);

Gets whether `window` appears on `workspace`.

`window` : | a MatewnckWindow.
`workspace` : | a MatewnckWorkspace.
Returns : | `TRUE` if `window` appears on `workspace`, `FALSE` otherwise.

### matewnck_window_is_visible_on_workspace ()

    gboolean            matewnck_window_is_visible_on_workspace
                                                            (MatewnckWindow *window,
                                                             MatewnckWorkspace *workspace);

Like `matewnck_window_is_on_workspace()`, but also checks that the window is in a visible state (i.e. not minimized or shaded).

`window` : | a MatewnckWindow.
`workspace` : | a MatewnckWorkspace.
Returns : | `TRUE` if `window` appears on `workspace` in normal state, `FALSE` otherwise.

### matewnck_window_move_to_workspace ()

    void                matewnck_window_move_to_workspace   (MatewnckWindow *window,
                                                             MatewnckWorkspace *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`.

`window` : | a MatewnckWindow.
`space` : | a MatewnckWorkspace.

### matewnck_window_is_in_viewport ()

    gboolean            matewnck_window_is_in_viewport      (MatewnckWindow *window,
                                                             MatewnckWorkspace *workspace);

Gets `TRUE` if `window` appears in the current viewport of `workspace`.

`window` : | a MatewnckWindow.
`workspace` : | a MatewnckWorkspace.
Returns : | `TRUE` if `window` appears in current viewport of `workspace`, `FALSE` otherwise.

Since 2.4

### matewnck_window_activate ()

    void                matewnck_window_activate            (MatewnckWindow *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.

`window` : | a MatewnckWindow.
`timestamp` : | the X server timestamp of the user interaction event that caused this call to occur.

Since 2.10

### matewnck_window_is_active ()

    gboolean            matewnck_window_is_active           (MatewnckWindow *window);

Gets whether `window` is the active window on its MatewnckScreen.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` is the active window on its MatewnckScreen, `FALSE` otherwise.

### matewnck_window_is_most_recently_activated ()

    gboolean            matewnck_window_is_most_recently_activated
                                                            (MatewnckWindow *window);

Gets whether `window` is the most recently activated window on its MatewnckScreen.

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.

`window` : | a MatewnckWindow.
Returns : | `TRUE` if `window` was the most recently activated window on its MatewnckScreen, `FALSE` otherwise.

Since 2.8

### matewnck_window_activate_transient ()

    void                matewnck_window_activate_transient  (MatewnckWindow *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.

`window` : | a MatewnckWindow.
`timestamp` : | the X server timestamp of the user interaction event that caused this call to occur.

Since 2.10

### matewnck_window_transient_is_most_recently_activated ()

    gboolean            matewnck_window_transient_is_most_recently_activated
                                                            (MatewnckWindow *window);

Gets whether one of the transients of `window` is the most recently activated window. See `matewnck_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 MatewnckTasklist once will activate a transient instead of `window` itself (matewnck_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 MatewnckTaslist).

`window` : | a MatewnckWindow.
Returns : | `TRUE` if one of the transients of `window` is the most recently activated window, `FALSE` otherwise.

Since 2.12

### matewnck_window_set_icon_geometry ()

    void                matewnck_window_set_icon_geometry   (MatewnckWindow *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`.

`window` : | a MatewnckWindow.
`x` : | X coordinate in pixels.
`y` : | Y coordinate in pixels.
`width` : | width in pixels.
`height` : | height in pixels.

### enum MatewnckWindowGravity

    typedef enum {
      MATEWNCK_WINDOW_GRAVITY_CURRENT   = 0,
      MATEWNCK_WINDOW_GRAVITY_NORTHWEST = 1,
      MATEWNCK_WINDOW_GRAVITY_NORTH     = 2,
      MATEWNCK_WINDOW_GRAVITY_NORTHEAST = 3,
      MATEWNCK_WINDOW_GRAVITY_WEST      = 4,
      MATEWNCK_WINDOW_GRAVITY_CENTER    = 5,
      MATEWNCK_WINDOW_GRAVITY_EAST      = 6,
      MATEWNCK_WINDOW_GRAVITY_SOUTHWEST = 7,
      MATEWNCK_WINDOW_GRAVITY_SOUTH     = 8,
      MATEWNCK_WINDOW_GRAVITY_SOUTHEAST = 9,
      MATEWNCK_WINDOW_GRAVITY_STATIC    = 10
    } MatewnckWindowGravity;

Flag used when changing the geometry of a MatewnckWindow. This is the gravity point to use as a reference for the new position.

`MATEWNCK_WINDOW_GRAVITY_CURRENT` | keep the current gravity point.
`MATEWNCK_WINDOW_GRAVITY_NORTHWEST` | use the left top corner of the frame window as gravity point.
`MATEWNCK_WINDOW_GRAVITY_NORTH` | use the center of the frame window's top side as gravity point.
`MATEWNCK_WINDOW_GRAVITY_NORTHEAST` | use the right top corner of the frame window as gravity point.
`MATEWNCK_WINDOW_GRAVITY_WEST` | use the center of the frame window's left side as gravity point.
`MATEWNCK_WINDOW_GRAVITY_CENTER` | use the center of the frame window as gravity point.
`MATEWNCK_WINDOW_GRAVITY_EAST` | use the center of the frame window's right side as gravity point.
`MATEWNCK_WINDOW_GRAVITY_SOUTHWEST` | use the left bottom corner of the frame window as gravity point.
`MATEWNCK_WINDOW_GRAVITY_SOUTH` | use the center of the frame window's bottom side as gravity point.
`MATEWNCK_WINDOW_GRAVITY_SOUTHEAST` | use the right bottom corner of the frame window as gravity point.
`MATEWNCK_WINDOW_GRAVITY_STATIC` | use the left top corner of the client window as gravity point.

Since 2.16

### enum MatewnckWindowMoveResizeMask

    typedef enum {
      MATEWNCK_WINDOW_CHANGE_X      = 1 << 0,
      MATEWNCK_WINDOW_CHANGE_Y      = 1 << 1,
      MATEWNCK_WINDOW_CHANGE_WIDTH  = 1 << 2,
      MATEWNCK_WINDOW_CHANGE_HEIGHT = 1 << 3
    } MatewnckWindowMoveResizeMask;

Flag used as a bitmask when changing the geometry of a MatewnckWindow. This indicates which part of the geometry should be changed.

`MATEWNCK_WINDOW_CHANGE_X` | X coordinate of the window should be changed.
`MATEWNCK_WINDOW_CHANGE_Y` | Y coordinate of the window should be changed.
`MATEWNCK_WINDOW_CHANGE_WIDTH` | width of the window should be changed.
`MATEWNCK_WINDOW_CHANGE_HEIGHT` | height of the window should be changed.

Since 2.16

### matewnck_window_get_client_window_geometry ()

    void                matewnck_window_get_client_window_geometry
                                                            (MatewnckWindow *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 `matewnck_window_get_geometry()`.

`window` : | a MatewnckWindow.
`xp` : | return location for X coordinate in pixels of `window`.
`yp` : | return location for Y coordinate in pixels of `window`.
`widthp` : | return location for width in pixels of `window`.
`heightp` : | return location for height in pixels of `window`.

Since 2.20

### matewnck_window_get_geometry ()

    void                matewnck_window_get_geometry        (MatewnckWindow *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 `matewnck_window_get_client_window_geometry()`.

`window` : | a MatewnckWindow.
`xp` : | return location for X coordinate in pixels of `window`.
`yp` : | return location for Y coordinate in pixels of `window`.
`widthp` : | return location for width in pixels of `window`.
`heightp` : | return location for height in pixels of `window`.

### matewnck_window_set_geometry ()

    void                matewnck_window_set_geometry        (MatewnckWindow *window,
                                                             MatewnckWindowGravity gravity,
                                                             MatewnckWindowMoveResizeMask 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 `matewnck_window_set_geometry()` with the values returned by `matewnck_window_get_geometry()` should be a no-op, while using `matewnck_window_set_geometry()` with the values returned by `matewnck_window_get_client_window_geometry()` should reduce the size of `window` and move it.

`window` : | a MatewnckWindow.
`gravity` : | the gravity point to use as a reference for the new position.
`geometry_mask` : | a bitmask containing flags for what should be set.
`x` : | new X coordinate in pixels of `window`.
`y` : | new Y coordinate in pixels of `window`.
`width` : | new width in pixels of `window`.
`height` : | new height in pixels of `window`.

Since 2.16

### matewnck_window_keyboard_move ()

    void                matewnck_window_keyboard_move       (MatewnckWindow *window);

Asks the window manager to start moving `window` via the keyboard.

`window` : | a MatewnckWindow.

### matewnck_window_keyboard_size ()

    void                matewnck_window_keyboard_size       (MatewnckWindow *window);

Asks the window manager to start resizing `window` via the keyboard.

`window` : | a MatewnckWindow.

## Signal Details

### The `"actions-changed"` signal

    void                user_function                      (MatewnckWindow       *window,
                                                            MatewnckWindowActions changed_mask,
                                                            MatewnckWindowActions new_state,
                                                            gpointer              user_data)         : Run Last

Emitted when the actions availabilities for `window` change.

`window` : | the MatewnckWindow which emitted the signal.
`changed_mask` : | the bitmask containing bits set for all actions availabilities for `window` that have changed.
`new_state` : | the new actions availabilities for `window`.
`user_data` : | user data set when the signal handler was connected.

### The `"geometry-changed"` signal

    void                user_function                      (MatewnckWindow *window,
                                                            gpointer        user_data)      : Run Last

Emitted when the geometry of `window` changes.

`window` : | the MatewnckWindow which emitted the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"icon-changed"` signal

    void                user_function                      (MatewnckWindow *window,
                                                            gpointer        user_data)      : Run Last

Emitted when the icon of `window` changes.

`window` : | the MatewnckWindow which emitted the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"name-changed"` signal

    void                user_function                      (MatewnckWindow *window,
                                                            gpointer        user_data)      : Run Last

Emitted when the name of `window` changes.

`window` : | the MatewnckWindow which emitted the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"state-changed"` signal

    void                user_function                      (MatewnckWindow     *window,
                                                            MatewnckWindowState changed_mask,
                                                            MatewnckWindowState 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 MatewnckWindowState for the complete list of states that might have changed.

`window` : | the MatewnckWindow which emitted the signal.
`changed_mask` : | the bitmask containing bits set for all states of `window` that have changed.
`new_state` : | the new state of `window`.
`user_data` : | user data set when the signal handler was connected.

### The `"workspace-changed"` signal

    void                user_function                      (MatewnckWindow *window,
                                                            gpointer        user_data)      : Run Last

Emitted when the current workspace of `window` changes, or if `window` has been pinned or unpinned.

`window` : | the MatewnckWindow which emitted the signal.
`user_data` : | user data set when the signal handler was connected.

## See Also

MatewnckWorkspace, MatewnckApplication, MatewnckClassGroup