MetaWindow

MetaWindow — Muffin X managed windows

Synopsis

enum                MetaWindowType;
enum                MetaMaximizeFlags;
MetaFrame *         meta_window_get_frame               (MetaWindow *window);
gboolean            meta_window_has_focus               (MetaWindow *window);
gboolean            meta_window_appears_focused         (MetaWindow *window);
gboolean            meta_window_is_shaded               (MetaWindow *window);
gboolean            meta_window_is_override_redirect    (MetaWindow *window);
gboolean            meta_window_is_skip_taskbar         (MetaWindow *window);
MetaRectangle *     meta_window_get_rect                (MetaWindow *window);
void                meta_window_get_input_rect          (const MetaWindow *window,
                                                         MetaRectangle *rect);
void                meta_window_get_outer_rect          (const MetaWindow *window,
                                                         MetaRectangle *rect);
MetaScreen *        meta_window_get_screen              (MetaWindow *window);
MetaDisplay *       meta_window_get_display             (MetaWindow *window);
unsigned long       meta_window_get_xwindow             (MetaWindow *window);
MetaWindowType      meta_window_get_window_type         (MetaWindow *window);
Atom                meta_window_get_window_type_atom    (MetaWindow *window);
MetaWorkspace *     meta_window_get_workspace           (MetaWindow *window);
int                 meta_window_get_monitor             (MetaWindow *window);
gboolean            meta_window_is_on_all_workspaces    (MetaWindow *window);
gboolean            meta_window_is_hidden               (MetaWindow *window);
void                meta_window_activate                (MetaWindow *window,
                                                         guint32 current_time);
void                meta_window_activate_with_workspace (MetaWindow *window,
                                                         guint32 current_time,
                                                         MetaWorkspace *workspace);
const char *        meta_window_get_description         (MetaWindow *window);
const char *        meta_window_get_wm_class            (MetaWindow *window);
const char *        meta_window_get_wm_class_instance   (MetaWindow *window);
gboolean            meta_window_showing_on_its_workspace
                                                        (MetaWindow *window);
const char *        meta_window_get_gtk_application_id  (MetaWindow *window);
const char *        meta_window_get_gtk_unique_bus_name (MetaWindow *window);
const char *        meta_window_get_gtk_application_object_path
                                                        (MetaWindow *window);
const char *        meta_window_get_gtk_window_object_path
                                                        (MetaWindow *window);
const char *        meta_window_get_gtk_app_menu_object_path
                                                        (MetaWindow *window);
const char *        meta_window_get_gtk_menubar_object_path
                                                        (MetaWindow *window);
void                meta_window_move                    (MetaWindow *window,
                                                         gboolean user_op,
                                                         int root_x_nw,
                                                         int root_y_nw);
void                meta_window_move_frame              (MetaWindow *window,
                                                         gboolean user_op,
                                                         int root_x_nw,
                                                         int root_y_nw);
void                meta_window_move_resize_frame       (MetaWindow *window,
                                                         gboolean user_op,
                                                         int root_x_nw,
                                                         int root_y_nw,
                                                         int w,
                                                         int h);
void                meta_window_move_to_monitor         (MetaWindow *window,
                                                         int monitor);
void                meta_window_resize                  (MetaWindow *window,
                                                         gboolean user_op,
                                                         int w,
                                                         int h);
void                meta_window_set_demands_attention   (MetaWindow *window);
void                meta_window_unset_demands_attention (MetaWindow *window);
const char *        meta_window_get_startup_id          (MetaWindow *window);
void                meta_window_change_workspace_by_index
                                                        (MetaWindow *window,
                                                         gint space_index,
                                                         gboolean append,
                                                         guint32 timestamp);
void                meta_window_change_workspace        (MetaWindow *window,
                                                         MetaWorkspace *workspace);
void                meta_window_stick                   (MetaWindow *window);
void                meta_window_unstick                 (MetaWindow *window);
GObject *           meta_window_get_compositor_private  (MetaWindow *window);
void                meta_window_set_compositor_private  (MetaWindow *window,
                                                         GObject *priv);
void                meta_window_configure_notify        (MetaWindow *window,
                                                         XConfigureEvent *event);
const char *        meta_window_get_role                (MetaWindow *window);
MetaStackLayer      meta_window_get_layer               (MetaWindow *window);
MetaWindow *        meta_window_find_root_ancestor      (MetaWindow *window);
gboolean            meta_window_is_ancestor_of_transient
                                                        (MetaWindow *window,
                                                         MetaWindow *transient);
gboolean            (*MetaWindowForeachFunc)            (MetaWindow *window,
                                                         void *data);
void                meta_window_foreach_transient       (MetaWindow *window,
                                                         MetaWindowForeachFunc func,
                                                         void *user_data);
void                meta_window_foreach_ancestor        (MetaWindow *window,
                                                         MetaWindowForeachFunc func,
                                                         void *user_data);
MetaMaximizeFlags   meta_window_get_maximized           (MetaWindow *window);
gboolean            meta_window_is_fullscreen           (MetaWindow *window);
gboolean            meta_window_is_monitor_sized        (MetaWindow *window);
gboolean            meta_window_is_on_primary_monitor   (MetaWindow *window);
gboolean            meta_window_is_demanding_attention  (MetaWindow *window);
gboolean            meta_window_is_urgent               (MetaWindow *window);
gboolean            meta_window_requested_bypass_compositor
                                                        (MetaWindow *window);
gboolean            meta_window_requested_dont_bypass_compositor
                                                        (MetaWindow *window);
gboolean            meta_window_is_mapped               (MetaWindow *window);
gboolean            meta_window_toplevel_is_mapped      (MetaWindow *window);
gboolean            meta_window_get_icon_geometry       (MetaWindow *window,
                                                         MetaRectangle *rect);
void                meta_window_set_icon_geometry       (MetaWindow *window,
                                                         MetaRectangle *rect);
void                meta_window_maximize                (MetaWindow *window,
                                                         MetaMaximizeFlags directions);
void                meta_window_unmaximize              (MetaWindow *window,
                                                         MetaMaximizeFlags directions);
void                meta_window_minimize                (MetaWindow *window);
void                meta_window_unminimize              (MetaWindow *window);
void                meta_window_raise                   (MetaWindow *window);
void                meta_window_lower                   (MetaWindow *window);
void                meta_window_reset_opacity           (MetaWindow *window);
const char *        meta_window_get_title               (MetaWindow *window);
MetaWindow *        meta_window_get_transient_for       (MetaWindow *window);
Window              meta_window_get_transient_for_as_xid
                                                        (MetaWindow *window);
void                meta_window_delete                  (MetaWindow *window,
                                                         guint32 timestamp);
guint               meta_window_get_stable_sequence     (MetaWindow *window);
guint32             meta_window_get_user_time           (MetaWindow *window);
int                 meta_window_get_pid                 (MetaWindow *window);
const char *        meta_window_get_client_machine      (MetaWindow *window);
gboolean            meta_window_is_remote               (MetaWindow *window);
gboolean            meta_window_is_modal                (MetaWindow *window);
gboolean            meta_window_is_attached_dialog      (MetaWindow *window);
const char *        meta_window_get_muffin_hints        (MetaWindow *window);
MetaFrameType       meta_window_get_frame_type          (MetaWindow *window);
cairo_region_t *    meta_window_get_frame_bounds        (MetaWindow *window);
MetaWindow *        meta_window_get_tile_match          (MetaWindow *window);
gboolean            meta_window_can_tile                (MetaWindow *window,
                                                         MetaTileMode mode);
gboolean            meta_window_tile                    (MetaWindow *window,
                                                         MetaTileMode mode,
                                                         gboolean snap);
                    MetaWindowClass;

Description

Details

enum MetaWindowType

typedef enum {
  META_WINDOW_NORMAL,
  META_WINDOW_DESKTOP,
  META_WINDOW_DOCK,
  META_WINDOW_DIALOG,
  META_WINDOW_MODAL_DIALOG,
  META_WINDOW_TOOLBAR,
  META_WINDOW_MENU,
  META_WINDOW_UTILITY,
  META_WINDOW_SPLASHSCREEN,

  /* override redirect window types: */
  META_WINDOW_DROPDOWN_MENU,
  META_WINDOW_POPUP_MENU,
  META_WINDOW_TOOLTIP,
  META_WINDOW_NOTIFICATION,
  META_WINDOW_COMBO,
  META_WINDOW_DND,
  META_WINDOW_OVERRIDE_OTHER
} MetaWindowType;

META_WINDOW_NORMAL

META_WINDOW_DESKTOP

META_WINDOW_DOCK

META_WINDOW_DIALOG

META_WINDOW_MODAL_DIALOG

META_WINDOW_TOOLBAR

META_WINDOW_MENU

META_WINDOW_UTILITY

META_WINDOW_SPLASHSCREEN

META_WINDOW_DROPDOWN_MENU

META_WINDOW_POPUP_MENU

META_WINDOW_TOOLTIP

META_WINDOW_NOTIFICATION

META_WINDOW_COMBO

META_WINDOW_DND

META_WINDOW_OVERRIDE_OTHER


enum MetaMaximizeFlags

typedef enum {
  META_MAXIMIZE_HORIZONTAL = 1 << 0,
  META_MAXIMIZE_VERTICAL   = 1 << 1
} MetaMaximizeFlags;

META_MAXIMIZE_HORIZONTAL

META_MAXIMIZE_VERTICAL


meta_window_get_frame ()

MetaFrame *         meta_window_get_frame               (MetaWindow *window);

meta_window_has_focus ()

gboolean            meta_window_has_focus               (MetaWindow *window);

meta_window_appears_focused ()

gboolean            meta_window_appears_focused         (MetaWindow *window);

Determines if the window should be drawn with a focused appearance. This is true for focused windows but also true for windows with a focused modal dialog attached.

window :

a MetaWindow

Returns :

TRUE if the window should be drawn with a focused frame

meta_window_is_shaded ()

gboolean            meta_window_is_shaded               (MetaWindow *window);

meta_window_is_override_redirect ()

gboolean            meta_window_is_override_redirect    (MetaWindow *window);

window :

A MetaWindow

Returns :

if this window isn't managed by muffin; it will control its own positioning and muffin won't draw decorations among other things. In X terminology this is "override redirect".

meta_window_is_skip_taskbar ()

gboolean            meta_window_is_skip_taskbar         (MetaWindow *window);

Gets whether this window should be ignored by task lists.

window :

A MetaWindow

Returns :

TRUE if the skip bar hint is set.

meta_window_get_rect ()

MetaRectangle *     meta_window_get_rect                (MetaWindow *window);

Gets the rectangle that bounds window, ignoring any window decorations.

window :

a MetaWindow

Returns :

the MetaRectangle for the window. [transfer none]

meta_window_get_input_rect ()

void                meta_window_get_input_rect          (const MetaWindow *window,
                                                         MetaRectangle *rect);

Gets the rectangle that bounds window that is responsive to mouse events. This includes decorations - the visible portion of its border - and (if present) any invisible area that we make make responsive to mouse clicks in order to allow convenient border dragging.

window :

a MetaWindow

rect :

pointer to an allocated MetaRectangle. [out]

meta_window_get_outer_rect ()

void                meta_window_get_outer_rect          (const MetaWindow *window,
                                                         MetaRectangle *rect);

Gets the rectangle that bounds window that is responsive to mouse events. This includes only what is visible; it doesn't include any extra reactive area we add to the edges of windows.

window :

a MetaWindow

rect :

pointer to an allocated MetaRectangle. [out]

meta_window_get_screen ()

MetaScreen *        meta_window_get_screen              (MetaWindow *window);

Gets the MetaScreen that the window is on.

window :

a MetaWindow

Returns :

the MetaScreen for the window. [transfer none]

meta_window_get_display ()

MetaDisplay *       meta_window_get_display             (MetaWindow *window);

window :

A MetaWindow

Returns :

The display for window. [transfer none]

meta_window_get_xwindow ()

unsigned long       meta_window_get_xwindow             (MetaWindow *window);

window :

A MetaWindow

Returns :

The Window id of the window note - we return unsigned long because Window Can't be introspected (but Window *is* a ulong)

meta_window_get_window_type ()

MetaWindowType      meta_window_get_window_type         (MetaWindow *window);

meta_window_get_window_type_atom ()

Atom                meta_window_get_window_type_atom    (MetaWindow *window);

Gets the X atom from the _NET_WM_WINDOW_TYPE property used by the application to set the window type. (Note that this is constrained to be some value that Muffin recognizes - a completely unrecognized type atom will be returned as None.)

window :

a MetaWindow

Returns :

the raw X atom for the window type, or None

meta_window_get_workspace ()

MetaWorkspace *     meta_window_get_workspace           (MetaWindow *window);

Gets the MetaWorkspace that the window is currently displayed on. If the window is on all workspaces, returns the currently active workspace.

window :

a MetaWindow

Returns :

the MetaWorkspace for the window. [transfer none]

meta_window_get_monitor ()

int                 meta_window_get_monitor             (MetaWindow *window);

Gets index of the monitor that this window is on.

window :

a MetaWindow

Returns :

The index of the monitor in the screens monitor list

meta_window_is_on_all_workspaces ()

gboolean            meta_window_is_on_all_workspaces    (MetaWindow *window);

meta_window_is_hidden ()

gboolean            meta_window_is_hidden               (MetaWindow *window);

meta_window_activate ()

void                meta_window_activate                (MetaWindow *window,
                                                         guint32 current_time);

meta_window_activate_with_workspace ()

void                meta_window_activate_with_workspace (MetaWindow *window,
                                                         guint32 current_time,
                                                         MetaWorkspace *workspace);

meta_window_get_description ()

const char *        meta_window_get_description         (MetaWindow *window);

meta_window_get_wm_class ()

const char *        meta_window_get_wm_class            (MetaWindow *window);

Return the current value of the name part of WM_CLASS X property.

window :

a MetaWindow

meta_window_get_wm_class_instance ()

const char *        meta_window_get_wm_class_instance   (MetaWindow *window);

Return the current value of the instance part of WM_CLASS X property.

window :

a MetaWindow

meta_window_showing_on_its_workspace ()

gboolean            meta_window_showing_on_its_workspace
                                                        (MetaWindow *window);

window :

A MetaWindow

Returns :

TRUE if window would be visible, if its workspace was current

meta_window_get_gtk_application_id ()

const char *        meta_window_get_gtk_application_id  (MetaWindow *window);

window :

a MetaWindow

Returns :

the application ID. [transfer none]

meta_window_get_gtk_unique_bus_name ()

const char *        meta_window_get_gtk_unique_bus_name (MetaWindow *window);

window :

a MetaWindow

Returns :

the unique name. [transfer none]

meta_window_get_gtk_application_object_path ()

const char *        meta_window_get_gtk_application_object_path
                                                        (MetaWindow *window);

window :

a MetaWindow

Returns :

the object path. [transfer none]

meta_window_get_gtk_window_object_path ()

const char *        meta_window_get_gtk_window_object_path
                                                        (MetaWindow *window);

window :

a MetaWindow

Returns :

the object path. [transfer none]

meta_window_get_gtk_app_menu_object_path ()

const char *        meta_window_get_gtk_app_menu_object_path
                                                        (MetaWindow *window);

window :

a MetaWindow

Returns :

the object path. [transfer none]

meta_window_get_gtk_menubar_object_path ()

const char *        meta_window_get_gtk_menubar_object_path
                                                        (MetaWindow *window);

window :

a MetaWindow

Returns :

the object path. [transfer none]

meta_window_move ()

void                meta_window_move                    (MetaWindow *window,
                                                         gboolean user_op,
                                                         int root_x_nw,
                                                         int root_y_nw);

Moves the window to the desired location on window's assigned workspace. NOTE: does NOT place according to the origin of the enclosing frame/window-decoration, but according to the origin of the window, itself.

window :

a MetaWindow

user_op :

bool to indicate whether or not this is a user operation

root_x_nw :

desired x pos

root_y_nw :

desired y pos

meta_window_move_frame ()

void                meta_window_move_frame              (MetaWindow *window,
                                                         gboolean user_op,
                                                         int root_x_nw,
                                                         int root_y_nw);

Moves the window to the desired location on window's assigned workspace, using the northwest edge of the frame as the reference, instead of the actual window's origin, but only if a frame is present. Otherwise, acts identically to meta_window_move().

window :

a MetaWindow

user_op :

bool to indicate whether or not this is a user operation

root_x_nw :

desired x pos

root_y_nw :

desired y pos

meta_window_move_resize_frame ()

void                meta_window_move_resize_frame       (MetaWindow *window,
                                                         gboolean user_op,
                                                         int root_x_nw,
                                                         int root_y_nw,
                                                         int w,
                                                         int h);

Resizes the window so that its outer bounds (including frame) fit within the given rect

window :

a MetaWindow

user_op :

bool to indicate whether or not this is a user operation

root_x_nw :

new x

root_y_nw :

new y

w :

desired width

h :

desired height

meta_window_move_to_monitor ()

void                meta_window_move_to_monitor         (MetaWindow *window,
                                                         int monitor);

Moves the window to the monitor with index monitor, keeping the relative position of the window's top left corner.

window :

a MetaWindow

monitor :

desired monitor index

meta_window_resize ()

void                meta_window_resize                  (MetaWindow *window,
                                                         gboolean user_op,
                                                         int w,
                                                         int h);

Resize the window to the desired size.

window :

a MetaWindow

user_op :

bool to indicate whether or not this is a user operation

w :

desired width

h :

desired height

meta_window_set_demands_attention ()

void                meta_window_set_demands_attention   (MetaWindow *window);

meta_window_unset_demands_attention ()

void                meta_window_unset_demands_attention (MetaWindow *window);

meta_window_get_startup_id ()

const char *        meta_window_get_startup_id          (MetaWindow *window);

meta_window_change_workspace_by_index ()

void                meta_window_change_workspace_by_index
                                                        (MetaWindow *window,
                                                         gint space_index,
                                                         gboolean append,
                                                         guint32 timestamp);

meta_window_change_workspace ()

void                meta_window_change_workspace        (MetaWindow *window,
                                                         MetaWorkspace *workspace);

Moves the window to the specified workspace.

window :

a MetaWindow

workspace :

the MetaWorkspace where to put the window

meta_window_stick ()

void                meta_window_stick                   (MetaWindow *window);

meta_window_unstick ()

void                meta_window_unstick                 (MetaWindow *window);

meta_window_get_compositor_private ()

GObject *           meta_window_get_compositor_private  (MetaWindow *window);

Gets the compositor's wrapper object for window.

window :

a MetaWindow

Returns :

the wrapper object. [transfer none]

meta_window_set_compositor_private ()

void                meta_window_set_compositor_private  (MetaWindow *window,
                                                         GObject *priv);

meta_window_configure_notify ()

void                meta_window_configure_notify        (MetaWindow *window,
                                                         XConfigureEvent *event);

This is used to notify us of an unrequested configuration (only applicable to override redirect windows)

window :

a MetaWindow

event :

a XConfigureEvent

meta_window_get_role ()

const char *        meta_window_get_role                (MetaWindow *window);

meta_window_get_layer ()

MetaStackLayer      meta_window_get_layer               (MetaWindow *window);

meta_window_find_root_ancestor ()

MetaWindow *        meta_window_find_root_ancestor      (MetaWindow *window);

Follow the chain of parents of window, skipping transient windows, and return the "root" window which has no non-transient parent.

window :

a MetaWindow

Returns :

The root ancestor window. [transfer none]

meta_window_is_ancestor_of_transient ()

gboolean            meta_window_is_ancestor_of_transient
                                                        (MetaWindow *window,
                                                         MetaWindow *transient);

The function determines whether window is an ancestor of transient; it does so by traversing the transient's ancestors until it either locates window or reaches an ancestor that is not transient.

window :

a MetaWindow

transient :

a MetaWindow

Returns :

TRUE if window is an ancestor of transient.

MetaWindowForeachFunc ()

gboolean            (*MetaWindowForeachFunc)            (MetaWindow *window,
                                                         void *data);

meta_window_foreach_transient ()

void                meta_window_foreach_transient       (MetaWindow *window,
                                                         MetaWindowForeachFunc func,
                                                         void *user_data);

Call func for every window which is either transient for window, or is a transient of a window which is in turn transient for window. The order of window enumeration is not defined.

Iteration will stop if func at any point returns FALSE.

window :

a MetaWindow

func :

Called for each window which is a transient of window (transitively). [scope call][closure user_data]

user_data :

User data

meta_window_foreach_ancestor ()

void                meta_window_foreach_ancestor        (MetaWindow *window,
                                                         MetaWindowForeachFunc func,
                                                         void *user_data);

If window is transient, call func with the window for which it's transient, repeatedly until either we find a non-transient window, or func returns FALSE.

window :

a MetaWindow

func :

Called for each window which is a transient parent of window. [scope call][closure user_data]

user_data :

User data

meta_window_get_maximized ()

MetaMaximizeFlags   meta_window_get_maximized           (MetaWindow *window);

Gets the current maximization state of the window, as combination of the META_MAXIMIZE_HORIZONTAL and META_MAXIMIZE_VERTICAL flags;

Returns :

current maximization state

meta_window_is_fullscreen ()

gboolean            meta_window_is_fullscreen           (MetaWindow *window);

Returns :

TRUE if the window is currently fullscreen

meta_window_is_monitor_sized ()

gboolean            meta_window_is_monitor_sized        (MetaWindow *window);

Returns :

TRUE if the window is occupies an entire monitor or the whole screen.

meta_window_is_on_primary_monitor ()

gboolean            meta_window_is_on_primary_monitor   (MetaWindow *window);

Returns :

TRUE if the window is on the primary monitor

meta_window_is_demanding_attention ()

gboolean            meta_window_is_demanding_attention  (MetaWindow *window);

Returns true if window has the demands-attention flag set.

window :

A MetaWindow

Returns :

TRUE if wm_state_demands_attention is set.

meta_window_is_urgent ()

gboolean            meta_window_is_urgent               (MetaWindow *window);

Returns true if window has the urgent hint set.

window :

A MetaWindow

Returns :

TRUE if wm_hints_urgent is set.

meta_window_requested_bypass_compositor ()

gboolean            meta_window_requested_bypass_compositor
                                                        (MetaWindow *window);

Returns :

TRUE if the window requested to bypass the compositor

meta_window_requested_dont_bypass_compositor ()

gboolean            meta_window_requested_dont_bypass_compositor
                                                        (MetaWindow *window);

Returns :

TRUE if the window requested to opt out of unredirecting

meta_window_is_mapped ()

gboolean            meta_window_is_mapped               (MetaWindow *window);

Determines whether the X window for the MetaWindow is mapped.

window :

a MetaWindow

meta_window_toplevel_is_mapped ()

gboolean            meta_window_toplevel_is_mapped      (MetaWindow *window);

Determines whether the toplevel X window for the MetaWindow is mapped. (The frame window is mapped even without the client window when a window is shaded.)

window :

a MetaWindow

Returns :

TRUE if the toplevel is mapped.

meta_window_get_icon_geometry ()

gboolean            meta_window_get_icon_geometry       (MetaWindow *window,
                                                         MetaRectangle *rect);

meta_window_set_icon_geometry ()

void                meta_window_set_icon_geometry       (MetaWindow *window,
                                                         MetaRectangle *rect);

Sets or unsets the location of the icon corresponding to the window. If set, the location should correspond to a dock, task bar or other user interface element displaying the icon, and is relative to the root window.

window :

a MetaWindow

rect :

rectangle with the desired geometry or NULL. [allow-none]

meta_window_maximize ()

void                meta_window_maximize                (MetaWindow *window,
                                                         MetaMaximizeFlags directions);

meta_window_unmaximize ()

void                meta_window_unmaximize              (MetaWindow *window,
                                                         MetaMaximizeFlags directions);

meta_window_minimize ()

void                meta_window_minimize                (MetaWindow *window);

meta_window_unminimize ()

void                meta_window_unminimize              (MetaWindow *window);

meta_window_raise ()

void                meta_window_raise                   (MetaWindow *window);

meta_window_lower ()

void                meta_window_lower                   (MetaWindow *window);

meta_window_reset_opacity ()

void                meta_window_reset_opacity           (MetaWindow *window);

meta_window_get_title ()

const char *        meta_window_get_title               (MetaWindow *window);

window :

a MetaWindow

Returns :

the current title of the window.

meta_window_get_transient_for ()

MetaWindow *        meta_window_get_transient_for       (MetaWindow *window);

Returns the MetaWindow for the window that is pointed to by the WM_TRANSIENT_FOR hint on this window (see XGetTransientForHint() or XSetTransientForHint()). Metacity keeps transient windows above their parents. A typical usage of this hint is for a dialog that wants to stay above its associated window.

window :

a MetaWindow

Returns :

the window this window is transient for, or NULL if the WM_TRANSIENT_FOR hint is unset or does not point to a toplevel window that Metacity knows about. [transfer none]

meta_window_get_transient_for_as_xid ()

Window              meta_window_get_transient_for_as_xid
                                                        (MetaWindow *window);

Returns the XID of the window that is pointed to by the WM_TRANSIENT_FOR hint on this window (see XGetTransientForHint() or XSetTransientForHint()). Metacity keeps transient windows above their parents. A typical usage of this hint is for a dialog that wants to stay above its associated window.

window :

a MetaWindow

Returns :

the window this window is transient for, or None if the WM_TRANSIENT_FOR hint is unset.

meta_window_delete ()

void                meta_window_delete                  (MetaWindow *window,
                                                         guint32 timestamp);

meta_window_get_stable_sequence ()

guint               meta_window_get_stable_sequence     (MetaWindow *window);

The stable sequence number is a monotonicially increasing unique integer assigned to each MetaWindow upon creation.

This number can be useful for sorting windows in a stable fashion.

window :

A MetaWindow

Returns :

Internal sequence number for this window

meta_window_get_user_time ()

guint32             meta_window_get_user_time           (MetaWindow *window);

The user time represents a timestamp for the last time the user interacted with this window. Note this property is only available for non-override-redirect windows.

The property is set by Muffin initially upon window creation, and updated thereafter on input events (key and button presses) seen by Muffin, client updates to the _NET_WM_USER_TIME property (if later than the current time) and when focusing the window.

Returns :

The last time the user interacted with this window.

meta_window_get_pid ()

int                 meta_window_get_pid                 (MetaWindow *window);

Returns pid of the process that created this window, if known (obtained from the _NET_WM_PID property).

window :

a MetaWindow

Returns :

the pid, or -1 if not known.

meta_window_get_client_machine ()

const char *        meta_window_get_client_machine      (MetaWindow *window);

Returns name of the client machine from which this windows was created, if known (obtained from the WM_CLIENT_MACHINE property).

window :

a MetaWindow

Returns :

the machine name, or NULL; the string is owned by the window manager and should not be freed or modified by the caller. [transfer none]

meta_window_is_remote ()

gboolean            meta_window_is_remote               (MetaWindow *window);

window :

a MetaWindow

Returns :

TRUE if this window originates from a host different from the one running muffin.

meta_window_is_modal ()

gboolean            meta_window_is_modal                (MetaWindow *window);

Queries whether the window is in a modal state as described by the _NET_WM_STATE protocol.

window :

a MetaWindow

Returns :

TRUE if the window is in modal state.

meta_window_is_attached_dialog ()

gboolean            meta_window_is_attached_dialog      (MetaWindow *window);

Tests if window is should be attached to its parent window. (If the "attach_modal_dialogs" option is not enabled, this will always return FALSE.)

window :

a MetaWindow

Returns :

whether window should be attached to its parent

meta_window_get_muffin_hints ()

const char *        meta_window_get_muffin_hints        (MetaWindow *window);

Gets the current value of the _MUFFIN_HINTS property.

The purpose of the hints is to allow fine-tuning of the Window Manager and Compositor behaviour on per-window basis, and is intended primarily for hints that are plugin-specific.

The property is a list of colon-separated key=value pairs. The key names for any plugin-specific hints must be suitably namespaced to allow for shared use; 'muffin-' key prefix is reserved for internal use, and must not be used by plugins.

window :

a MetaWindow

Returns :

the _MUFFIN_HINTS string, or NULL if no hints are set. [transfer none]

meta_window_get_frame_type ()

MetaFrameType       meta_window_get_frame_type          (MetaWindow *window);

Gets the type of window decorations that should be used for this window.

window :

a MetaWindow

Returns :

the frame type

meta_window_get_frame_bounds ()

cairo_region_t *    meta_window_get_frame_bounds        (MetaWindow *window);

Gets a region representing the outer bounds of the window's frame.

Returns :

a cairo_region_t holding the outer bounds of the window, or NULL if the window doesn't have a frame. [transfer none][allow-none]

meta_window_get_tile_match ()

MetaWindow *        meta_window_get_tile_match          (MetaWindow *window);

Returns the matching tiled window on the same monitory as window. This is the topmost tiled window in a complementary tile mode that is:

- on the same monitor; - on the same workspace; - spanning the remaining monitor width; - there is no 3rd window stacked between both tiled windows that's partially visible in the common edge.

Returns :

the matching tiled window or NULL if it doesn't exist. [transfer none][allow-none]

meta_window_can_tile ()

gboolean            meta_window_can_tile                (MetaWindow *window,
                                                         MetaTileMode mode);

Tests if window can be tiled or snapped in the supplied tiling zone

window :

a MetaWindow

mode :

the MetaTileMode to check for

Returns :

whether window can be tiled

meta_window_tile ()

gboolean            meta_window_tile                    (MetaWindow *window,
                                                         MetaTileMode mode,
                                                         gboolean snap);

Tiles or snaps the window in the requested configuration

window :

a MetaWindow

mode :

the MetaTileMode to use

snap :

whether to snap the window (as opposed to simple tile)

Returns :

whether or not window was successfully tiled

MetaWindowClass

typedef struct _MetaWindowClass MetaWindowClass;