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.

matewnck_window_get_screen ()

MatewnckScreen *    matewnck_window_get_screen          (MatewnckWindow *window);

Gets the MatewnckScreen window is on.

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.

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.

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.)

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.

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).

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.

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.

matewnck_window_get_application ()

MatewnckApplication * matewnck_window_get_application   (MatewnckWindow *window);

Gets the MatewnckApplication to which window belongs.

matewnck_window_get_transient ()

MatewnckWindow *    matewnck_window_get_transient       (MatewnckWindow *window);

Gets the MatewnckWindow for which window is transient.

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.

matewnck_window_get_xid ()

gulong              matewnck_window_get_xid             (MatewnckWindow *window);

Gets 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.

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().

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.

matewnck_window_get_pid ()

int                 matewnck_window_get_pid             (MatewnckWindow *window);

Gets the process ID of window.

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.

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.

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_get_window_type ()

MatewnckWindowType  matewnck_window_get_window_type     (MatewnckWindow *window);

Gets 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.

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_get_state ()

MatewnckWindowState matewnck_window_get_state           (MatewnckWindow *window);

Gets the state of 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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_get_actions ()

MatewnckWindowActions matewnck_window_get_actions       (MatewnckWindow *window);

Gets the actions that can be done for window.

matewnck_window_minimize ()

void                matewnck_window_minimize            (MatewnckWindow *window);

Minimizes window.

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.

matewnck_window_maximize_horizontally ()

void                matewnck_window_maximize_horizontally
                                                        (MatewnckWindow *window);

Asks the window manager to maximize horizontally window.

matewnck_window_unmaximize_horizontally ()

void                matewnck_window_unmaximize_horizontally
                                                        (MatewnckWindow *window);

Asks the window manager to unmaximize horizontally window.

matewnck_window_maximize_vertically ()

void                matewnck_window_maximize_vertically (MatewnckWindow *window);

Asks the window manager to maximize vertically window.

matewnck_window_unmaximize_vertically ()

void                matewnck_window_unmaximize_vertically
                                                        (MatewnckWindow *window);

Asks the window manager to unmaximize vertically window.

matewnck_window_maximize ()

void                matewnck_window_maximize            (MatewnckWindow *window);

Asks the window manager to maximize window.

matewnck_window_unmaximize ()

void                matewnck_window_unmaximize          (MatewnckWindow *window);

Asks the window manager to unmaximize window.

matewnck_window_shade ()

void                matewnck_window_shade               (MatewnckWindow *window);

Asks the window manager to shade window.

matewnck_window_unshade ()

void                matewnck_window_unshade             (MatewnckWindow *window);

Asks the window manager to unshade window.

matewnck_window_pin ()

void                matewnck_window_pin                 (MatewnckWindow *window);

Asks the window manager to put window on all workspaces.

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.

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.

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.

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).

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.

Since 2.14

matewnck_window_make_below ()

void                matewnck_window_make_below          (MatewnckWindow *window);

Asks the window manager to put window below most windows.

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.

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.

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.

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.

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.

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.

matewnck_window_is_on_workspace ()

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

Gets whether window appears on workspace.

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).

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.

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.

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.

Since 2.10

matewnck_window_is_active ()

gboolean            matewnck_window_is_active           (MatewnckWindow *window);

Gets whether window is the active window on its MatewnckScreen.

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.

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.

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).

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.

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.

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.

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().

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().

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.

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.

matewnck_window_keyboard_size ()

void                matewnck_window_keyboard_size       (MatewnckWindow *window);

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

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.

The "geometry-changed" signal

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

Emitted when the geometry of window changes.

The "icon-changed" signal

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

Emitted when the icon of window changes.

The "name-changed" signal

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

Emitted when the name of window changes.

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.

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.