MatewnckScreen

MatewnckScreen — an object representing a screen.

Stability Level

Unstable, unless otherwise indicated

Synopsis

#include <libmatewnck/libmatewnck.h>

struct              MatewnckScreen;
MatewnckScreen *    matewnck_screen_get_default         (void);
MatewnckScreen *    matewnck_screen_get                 (int index);
MatewnckScreen *    matewnck_screen_get_for_root        (gulong root_window_id);
int                 matewnck_screen_get_number          (MatewnckScreen *screen);
int                 matewnck_screen_get_width           (MatewnckScreen *screen);
int                 matewnck_screen_get_height          (MatewnckScreen *screen);
void                matewnck_screen_force_update        (MatewnckScreen *screen);
const char *        matewnck_screen_get_window_manager_name
                                                        (MatewnckScreen *screen);
gboolean            matewnck_screen_net_wm_supports     (MatewnckScreen *screen,
                                                         const char *atom);
MatewnckWindow *    matewnck_screen_get_active_window   (MatewnckScreen *screen);
MatewnckWindow *    matewnck_screen_get_previously_active_window
                                                        (MatewnckScreen *screen);
GList *             matewnck_screen_get_windows         (MatewnckScreen *screen);
GList *             matewnck_screen_get_windows_stacked (MatewnckScreen *screen);
MatewnckWorkspace * matewnck_screen_get_active_workspace
                                                        (MatewnckScreen *screen);
GList *             matewnck_screen_get_workspaces      (MatewnckScreen *screen);
MatewnckWorkspace * matewnck_screen_get_workspace       (MatewnckScreen *screen,
                                                         int workspace);
int                 matewnck_screen_get_workspace_index (MatewnckScreen *screen,
                                                         MatewnckWorkspace *space);
enum                MatewnckMotionDirection;
MatewnckWorkspace * matewnck_screen_get_workspace_neighbor
                                                        (MatewnckScreen *screen,
                                                         MatewnckWorkspace *space,
                                                         MatewnckMotionDirection direction);
int                 matewnck_screen_get_workspace_count (MatewnckScreen *screen);
void                matewnck_screen_change_workspace_count
                                                        (MatewnckScreen *screen,
                                                         int count);
int                 matewnck_screen_try_set_workspace_layout
                                                        (MatewnckScreen *screen,
                                                         int current_token,
                                                         int rows,
                                                         int columns);
void                matewnck_screen_release_workspace_layout
                                                        (MatewnckScreen *screen,
                                                         int current_token);
struct              MatewnckWorkspaceLayout;
void                matewnck_screen_calc_workspace_layout
                                                        (MatewnckScreen *screen,
                                                         int num_workspaces,
                                                         int space_index,
                                                         MatewnckWorkspaceLayout *layout);
void                matewnck_screen_free_workspace_layout
                                                        (MatewnckWorkspaceLayout *layout);
void                matewnck_screen_move_viewport       (MatewnckScreen *screen,
                                                         int x,
                                                         int y);
gulong              matewnck_screen_get_background_pixmap
                                                        (MatewnckScreen *screen);
gboolean            matewnck_screen_get_showing_desktop (MatewnckScreen *screen);
void                matewnck_screen_toggle_showing_desktop
                                                        (MatewnckScreen *screen,
                                                         gboolean show);

Object Hierarchy

  GObject
   +----MatewnckScreen

Signals

  "active-window-changed"                          : Run Last
  "active-workspace-changed"                       : Run Last
  "application-closed"                             : Run Last
  "application-opened"                             : Run Last
  "background-changed"                             : Run Last
  "class-group-closed"                             : Run Last
  "class-group-opened"                             : Run Last
  "showing-desktop-changed"                        : Run Last
  "viewports-changed"                              : Run Last
  "window-closed"                                  : Run Last
  "window-manager-changed"                         : Run Last
  "window-opened"                                  : Run Last
  "window-stacking-changed"                        : Run Last
  "workspace-created"                              : Run Last
  "workspace-destroyed"                            : Run Last

Description

The MatewnckScreen represents a physical screen. A screen may consist of multiple monitors which are merged to form a large screen area. The MatewnckScreen is at the bottom of the libmatewnck stack of objects: MatewnckWorkspace objects exist a MatewnckScreen and MatewnckWindow objects are displayed on a MatewnckWorkspace.

The MatewnckScreen corresponds to the notion of GdkScreen in GDK.

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

Details

struct MatewnckScreen

struct MatewnckScreen;

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


matewnck_screen_get_default ()

MatewnckScreen *    matewnck_screen_get_default         (void);

Gets the default MatewnckScreen on the default display.

Returns :

the default MatewnckScreen. The returned MatewnckScreen is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

matewnck_screen_get ()

MatewnckScreen *    matewnck_screen_get                 (int index);

Gets the MatewnckScreen for a given screen on the default display.

index :

screen number, starting from 0.

Returns :

the MatewnckScreen for screen index, or NULL if no such screen exists. The returned MatewnckScreen is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

matewnck_screen_get_for_root ()

MatewnckScreen *    matewnck_screen_get_for_root        (gulong root_window_id);

Gets the MatewnckScreen for the root window at root_window_id, or NULL if no MatewnckScreen exists for this root window.

This function does not work if matewnck_screen_get() was not called for the sought MatewnckScreen before, and returns NULL.

root_window_id :

an X window ID.

Returns :

the MatewnckScreen for the root window at root_window_id, or NULL. The returned MatewnckScreen is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

matewnck_screen_get_number ()

int                 matewnck_screen_get_number          (MatewnckScreen *screen);

Gets the index of screen on the display to which it belongs. The first MatewnckScreen has an index of 0.

screen :

a MatewnckScreen.

Returns :

the index of space on screen, or -1 on errors.

Since 2.20


matewnck_screen_get_width ()

int                 matewnck_screen_get_width           (MatewnckScreen *screen);

Gets the width of screen.

screen :

a MatewnckScreen.

Returns :

the width of screen.

matewnck_screen_get_height ()

int                 matewnck_screen_get_height          (MatewnckScreen *screen);

Gets the height of screen.

screen :

a MatewnckScreen.

Returns :

the height of screen.

matewnck_screen_force_update ()

void                matewnck_screen_force_update        (MatewnckScreen *screen);

Synchronously and immediately updates the list of MatewnckWindow on screen. This bypasses the standard update mechanism, where the list of MatewnckWindow is updated in the idle loop.

This is usually a bad idea for both performance and correctness reasons (to get things right, you need to write model-view code that tracks changes, not get a static list of open windows). However, this function can be useful for small applications that just do something and then exit.

screen :

a MatewnckScreen.

matewnck_screen_get_window_manager_name ()

const char *        matewnck_screen_get_window_manager_name
                                                        (MatewnckScreen *screen);

Gets the name of the window manager.

screen :

a MatewnckScreen.

Returns :

the name of the window manager, or NULL if the window manager does not comply with the EWMH specification.

Since 2.20


matewnck_screen_net_wm_supports ()

gboolean            matewnck_screen_net_wm_supports     (MatewnckScreen *screen,
                                                         const char *atom);

Gets whether the window manager for screen supports a certain hint from the Extended Window Manager Hints specification (EWMH).

When using this function, keep in mind that the window manager can change over time; so you should not use this function in a way that impacts persistent application state. A common bug is that your application can start up before the window manager does when the user logs in, and before the window manager starts matewnck_screen_net_wm_supports() will return FALSE for every property.

See also gdk_x11_screen_supports_net_wm_hint() in GDK.

screen :

a MatewnckScreen.

atom :

a property atom.

Returns :

TRUE if the window manager for screen supports the atom hint, FALSE otherwise.

matewnck_screen_get_active_window ()

MatewnckWindow *    matewnck_screen_get_active_window   (MatewnckScreen *screen);

Gets the active MatewnckWindow on screen. May return NULL sometimes, since not all window managers guarantee that a window is always active.

screen :

a MatewnckScreen.

Returns :

the active MatewnckWindow on screen, or NULL. The returned MatewnckWindow is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

matewnck_screen_get_previously_active_window ()

MatewnckWindow *    matewnck_screen_get_previously_active_window
                                                        (MatewnckScreen *screen);

Gets the previously active MatewnckWindow on screen. May return NULL sometimes, since not all window managers guarantee that a window is always active.

screen :

a MatewnckScreen.

Returns :

the previously active MatewnckWindow on screen, or NULL. The returned MatewnckWindow is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

Since 2.8


matewnck_screen_get_windows ()

GList *             matewnck_screen_get_windows         (MatewnckScreen *screen);

Gets the list of MatewnckWindow on screen. The list is not in a defined order, but should be "stable" (windows should not be reordered in it). However, the stability of the list is established by the window manager, so don't blame libmatewnck if it breaks down.

screen :

a MatewnckScreen.

Returns :

the list of MatewnckWindow on screen, or NULL if there is no window on screen. The list should not be modified nor freed, as it is owned by screen. [element-type MatewnckWindow][transfer none]

matewnck_screen_get_windows_stacked ()

GList *             matewnck_screen_get_windows_stacked (MatewnckScreen *screen);

Gets the list of MatewnckWindow on screen in bottom-to-top order.

screen :

a MatewnckScreen.

Returns :

the list of MatewnckWindow in stacking order on screen, or NULL if there is no window on screen. The list should not be modified nor freed, as it is owned by screen. [element-type MatewnckWindow][transfer none]

matewnck_screen_get_active_workspace ()

MatewnckWorkspace * matewnck_screen_get_active_workspace
                                                        (MatewnckScreen *screen);

Gets the active MatewnckWorkspace on screen. May return NULL sometimes, if libmatewnck is in a weird state due to the asynchronous nature of the interaction with the window manager.

screen :

a MatewnckScreen.

Returns :

the active MatewnckWorkspace on screen, or NULL. The returned MatewnckWorkspace is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

matewnck_screen_get_workspaces ()

GList *             matewnck_screen_get_workspaces      (MatewnckScreen *screen);

Gets the list of MatewnckWorkspace on screen. The list is ordered: the first element in the list is the first MatewnckWorkspace, etc..

screen :

a MatewnckScreen.

Returns :

the list of MatewnckWorkspace on screen. The list should not be modified nor freed, as it is owned by screen. [element-type MatewnckWorkspace][transfer none]

Since 2.20


matewnck_screen_get_workspace ()

MatewnckWorkspace * matewnck_screen_get_workspace       (MatewnckScreen *screen,
                                                         int workspace);

Gets the MatewnckWorkspace numbered workspace on screen.

screen :

a MatewnckScreen.

workspace :

a workspace index, starting from 0.

Returns :

the MatewnckWorkspace numbered workspace on screen, or NULL if no such workspace exists. The returned MatewnckWorkspace is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

matewnck_screen_get_workspace_index ()

int                 matewnck_screen_get_workspace_index (MatewnckScreen *screen,
                                                         MatewnckWorkspace *space);

Warning

matewnck_screen_get_workspace_index has been deprecated since version 2.20 and should not be used in newly-written code. Use matewnck_workspace_get_number() instead.

Gets the index of space on screen. The first MatewnckWorkspace has an index of 0. See also matewnck_workspace_get_number().

screen :

a MatewnckScreen.

space :

a MatewnckWorkspace.

Returns :

the index of space on screen, or -1 on errors.

Since 2.14


enum MatewnckMotionDirection

typedef enum {
  MATEWNCK_MOTION_UP = -1,
  MATEWNCK_MOTION_DOWN = -2,
  MATEWNCK_MOTION_LEFT = -3,
  MATEWNCK_MOTION_RIGHT = -4
} MatewnckMotionDirection;

Type defining a direction in which to search a neighbor MatewnckWorkspace.

MATEWNCK_MOTION_UP

search a neighbor MatewnckWorkspace above another MatewnckWorkspace.

MATEWNCK_MOTION_DOWN

search a neighbor MatewnckWorkspace below another MatewnckWorkspace.

MATEWNCK_MOTION_LEFT

search a neighbor MatewnckWorkspace at the left of another MatewnckWorkspace.

MATEWNCK_MOTION_RIGHT

search a neighbor MatewnckWorkspace at the right of another MatewnckWorkspace.

Since 2.14


matewnck_screen_get_workspace_neighbor ()

MatewnckWorkspace * matewnck_screen_get_workspace_neighbor
                                                        (MatewnckScreen *screen,
                                                         MatewnckWorkspace *space,
                                                         MatewnckMotionDirection direction);

Warning

matewnck_screen_get_workspace_neighbor has been deprecated since version 2.20 and should not be used in newly-written code. Use matewnck_workspace_get_neighbor() instead.

Gets the neighbor MatewnckWorkspace of space in the direction direction on screen.

screen :

a MatewnckScreen.

space :

a MatewnckWorkspace.

direction :

direction in which to search the neighbor.

Returns :

the neighbor MatewnckWorkspace of space in the direction direction on screen, or NULL if no such neighbor MatewnckWorkspace exists. The returned MatewnckWorkspace is owned by libmatewnck and must not be referenced or unreferenced. [transfer none]

Since 2.14


matewnck_screen_get_workspace_count ()

int                 matewnck_screen_get_workspace_count (MatewnckScreen *screen);

Gets the number of MatewnckWorkspace on screen.

screen :

a MatewnckScreen.

Returns :

the number of MatewnckWorkspace on screen.

matewnck_screen_change_workspace_count ()

void                matewnck_screen_change_workspace_count
                                                        (MatewnckScreen *screen,
                                                         int count);

Asks the window manager to change the number of MatewnckWorkspace on screen.

screen :

a MatewnckScreen.

count :

the number of MatewnckWorkspace to request.

Since 2.2


matewnck_screen_try_set_workspace_layout ()

int                 matewnck_screen_try_set_workspace_layout
                                                        (MatewnckScreen *screen,
                                                         int current_token,
                                                         int rows,
                                                         int columns);

Tries to modify the layout of MatewnckWorkspace on screen. To do this, tries to acquire ownership of the layout. If the current process is the owner of the layout, current_token is used to determine if the caller is the owner (there might be more than one part of the same process trying to set the layout). Since no more than one application should set this property of screen at a time, setting the layout is not guaranteed to work.

If rows is 0, the actual number of rows will be determined based on columns and the number of MatewnckWorkspace. If columns is 0, the actual number of columns will be determined based on rows and the number of MatewnckWorkspace. rows and columns must not be 0 at the same time.

You have to release the ownership of the layout with matewnck_screen_release_workspace_layout() when you do not need it anymore.

screen :

a MatewnckScreen.

current_token :

a token. Use 0 if you do not called matewnck_screen_try_set_workspace_layout() before, or if you did not keep the old token.

rows :

the number of rows to use for the MatewnckWorkspace layout.

columns :

the number of columns to use for the MatewnckWorkspace layout.

Returns :

a token to use for future calls to matewnck_screen_try_set_workspace_layout() and to matewnck_screen_release_workspace_layout(), or 0 if the layout could not be set.

matewnck_screen_release_workspace_layout ()

void                matewnck_screen_release_workspace_layout
                                                        (MatewnckScreen *screen,
                                                         int current_token);

Releases the ownership of the layout of MatewnckWorkspace on screen. current_token is used to verify that the caller is the owner of the layout. If the verification fails, nothing happens.

screen :

a MatewnckScreen.

current_token :

the token obtained through matewnck_screen_try_set_workspace_layout().

struct MatewnckWorkspaceLayout

struct MatewnckWorkspaceLayout {
  int rows;
  int cols;
  int *grid;
  int grid_area;
  int current_row;
  int current_col;
};

Warning

MatewnckWorkspaceLayout has been deprecated since version 2.20 and should not be used in newly-written code.

The MatewnckWorkspaceLayout struct contains information about the layout of MatewnckWorkspace on a MatewnckScreen, and the exact position of a specific MatewnckWorkspace.

int rows;

number of rows in the layout grid.

int cols;

number of columns in the layout grid.

int *grid;

array of size grid_area containing the index (starting from 0) of the MatewnckWorkspace for each position in the layout grid, or -1 if the position does not correspond to any MatewnckWorkspace.

int grid_area;

size of the grid containing all MatewnckWorkspace. This can be bigger than the number of MatewnckWorskpace because the grid might not be filled.

int current_row;

row of the specific MatewnckWorkspace, starting from 0.

int current_col;

column of the specific MatewnckWorkspace, starting from 0.

Since 2.12


matewnck_screen_calc_workspace_layout ()

void                matewnck_screen_calc_workspace_layout
                                                        (MatewnckScreen *screen,
                                                         int num_workspaces,
                                                         int space_index,
                                                         MatewnckWorkspaceLayout *layout);

Warning

matewnck_screen_calc_workspace_layout has been deprecated since version 2.20 and should not be used in newly-written code.

Calculates the layout of MatewnckWorkspace, with additional information like the row and column of the MatewnckWorkspace with index space_index.

screen :

a MatewnckScreen.

num_workspaces :

the number of MatewnckWorkspace on screen, or -1 to let matewnck_screen_calc_workspace_layout() find this number.

space_index :

the index of a Workspace.

layout :

return location for the layout of MatewnckWorkspace with additional information.

Since 2.12


matewnck_screen_free_workspace_layout ()

void                matewnck_screen_free_workspace_layout
                                                        (MatewnckWorkspaceLayout *layout);

Warning

matewnck_screen_free_workspace_layout has been deprecated since version 2.20 and should not be used in newly-written code.

Frees the content of layout. This does not free layout itself, so you might want to free layout yourself after calling this.

Since 2.12


matewnck_screen_move_viewport ()

void                matewnck_screen_move_viewport       (MatewnckScreen *screen,
                                                         int x,
                                                         int y);

Asks the window manager to move the viewport of the current MatewnckWorkspace on screen.

screen :

a MatewnckScreen.

x :

X offset in pixels of viewport.

y :

Y offset in pixels of viewport.

Since 2.4


matewnck_screen_get_background_pixmap ()

gulong              matewnck_screen_get_background_pixmap
                                                        (MatewnckScreen *screen);

Gets the X window ID of the background pixmap of screen.

screen :

a MatewnckScreen.

Returns :

the X window ID of the background pixmap of screen.

matewnck_screen_get_showing_desktop ()

gboolean            matewnck_screen_get_showing_desktop (MatewnckScreen *screen);

Gets whether screen is in the "showing the desktop" mode. This mode is changed when a "showing-desktop-changed" signal gets emitted.

screen :

a MatewnckScreen.

Returns :

TRUE if window is fullscreen, FALSE otherwise.

Since 2.2


matewnck_screen_toggle_showing_desktop ()

void                matewnck_screen_toggle_showing_desktop
                                                        (MatewnckScreen *screen,
                                                         gboolean show);

Asks the window manager to set the "showing the desktop" mode on screen according to show.

screen :

a MatewnckScreen.

show :

whether to activate the "showing the desktop" mode on screen.

Since 2.2

Signal Details

The "active-window-changed" signal

void                user_function                      (MatewnckScreen *screen,
                                                        MatewnckWindow *previously_active_window,
                                                        gpointer        user_data)                     : Run Last

Emitted when the active window on screen has changed.

screen :

the MatewnckScreen which emitted the signal.

previously_active_window :

the previously active MatewnckWindow before this change.

user_data :

user data set when the signal handler was connected.

The "active-workspace-changed" signal

void                user_function                      (MatewnckScreen    *screen,
                                                        MatewnckWorkspace *previously_active_space,
                                                        gpointer           user_data)                    : Run Last

Emitted when the active workspace on screen has changed.

screen :

the MatewnckScreen which emitted the signal.

previously_active_space :

the previously active MatewnckWorkspace before this change.

user_data :

user data set when the signal handler was connected.

The "application-closed" signal

void                user_function                      (MatewnckScreen      *screen,
                                                        MatewnckApplication *app,
                                                        gpointer             user_data)      : Run Last

Emitted when a MatewnckApplication is closed on screen.

screen :

the MatewnckScreen which emitted the signal.

app :

the closed MatewnckApplication.

user_data :

user data set when the signal handler was connected.

The "application-opened" signal

void                user_function                      (MatewnckScreen      *screen,
                                                        MatewnckApplication *app,
                                                        gpointer             user_data)      : Run Last

Emitted when a new MatewnckApplication is opened on screen.

screen :

the MatewnckScreen which emitted the signal.

app :

the opened MatewnckApplication.

user_data :

user data set when the signal handler was connected.

The "background-changed" signal

void                user_function                      (MatewnckScreen *screen,
                                                        gpointer        user_data)      : Run Last

Emitted when the background on the root window of screen has changed.

screen :

the MatewnckScreen which emitted the signal.

user_data :

user data set when the signal handler was connected.

The "class-group-closed" signal

void                user_function                      (MatewnckScreen     *screen,
                                                        MatewnckClassGroup *class_group,
                                                        gpointer            user_data)        : Run Last

Emitted when a MatewnckClassGroup is closed on screen.

screen :

the MatewnckScreen which emitted the signal.

class_group :

the closed MatewnckClassGroup.

user_data :

user data set when the signal handler was connected.

Since 2.20


The "class-group-opened" signal

void                user_function                      (MatewnckScreen     *screen,
                                                        MatewnckClassGroup *class_group,
                                                        gpointer            user_data)        : Run Last

Emitted when a new MatewnckClassGroup is opened on screen.

screen :

the MatewnckScreen which emitted the signal.

class_group :

the opened MatewnckClassGroup.

user_data :

user data set when the signal handler was connected.

Since 2.20


The "showing-desktop-changed" signal

void                user_function                      (MatewnckScreen *screen,
                                                        gpointer        user_data)      : Run Last

Emitted when "showing the desktop" mode of screen is toggled.

screen :

the MatewnckScreen which emitted the signal.

user_data :

user data set when the signal handler was connected.

Since 2.20


The "viewports-changed" signal

void                user_function                      (MatewnckScreen *screen,
                                                        gpointer        user_data)      : Run Last

Emitted when a viewport position has changed in a MatewnckWorkspace of screen or when a MatewnckWorkspace of screen gets or loses its viewport.

screen :

the MatewnckScreen which emitted the signal.

user_data :

user data set when the signal handler was connected.

Since 2.20


The "window-closed" signal

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

Emitted when a MatewnckWindow is closed on screen.

screen :

the MatewnckScreen which emitted the signal.

window :

the closed MatewnckWindow.

user_data :

user data set when the signal handler was connected.

The "window-manager-changed" signal

void                user_function                      (MatewnckScreen *screen,
                                                        gpointer        user_data)      : Run Last

Emitted when the window manager on screen has changed.

screen :

the MatewnckScreen which emitted the signal.

user_data :

user data set when the signal handler was connected.

Since 2.20


The "window-opened" signal

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

Emitted when a new MatewnckWindow is opened on screen.

screen :

the MatewnckScreen which emitted the signal.

window :

the opened MatewnckWindow.

user_data :

user data set when the signal handler was connected.

The "window-stacking-changed" signal

void                user_function                      (MatewnckScreen *screen,
                                                        gpointer        user_data)      : Run Last

Emitted when the stacking order of MatewnckWindow on screen has changed.

screen :

the MatewnckScreen which emitted the signal.

user_data :

user data set when the signal handler was connected.

The "workspace-created" signal

void                user_function                      (MatewnckScreen    *screen,
                                                        MatewnckWorkspace *space,
                                                        gpointer           user_data)      : Run Last

Emitted when a MatewnckWorkspace is created on screen.

screen :

the MatewnckScreen which emitted the signal.

space :

the workspace that has been created.

user_data :

user data set when the signal handler was connected.

The "workspace-destroyed" signal

void                user_function                      (MatewnckScreen    *screen,
                                                        MatewnckWorkspace *space,
                                                        gpointer           user_data)      : Run Last

Emitted when a MatewnckWorkspace is destroyed on screen.

screen :

the MatewnckScreen which emitted the signal.

space :

the workspace that has been destroyed.

user_data :

user data set when the signal handler was connected.

See Also

MatewnckWindow, MatewnckWorkspace