Mutter Reference Manual: MetaWindow

## MetaWindow MetaWindow — Mutter X managed windows |

## Synopsis

                        MetaWindow;
                        MetaWindowClass;
    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_monitor_sized        (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_frame_rect          (const MetaWindow *window,
                                                             MetaRectangle *rect);
    void                meta_window_get_outer_rect          (const MetaWindow *window,
                                                             MetaRectangle *rect);
    void                meta_window_client_rect_to_frame_rect
                                                            (MetaWindow *window,
                                                             MetaRectangle *client_rect,
                                                             MetaRectangle *frame_rect);
    void                meta_window_frame_rect_to_client_rect
                                                            (MetaWindow *window,
                                                             MetaRectangle *frame_rect,
                                                             MetaRectangle *client_rect);
    MetaScreen *        meta_window_get_screen              (MetaWindow *window);
    MetaDisplay *       meta_window_get_display             (MetaWindow *window);
    Window              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_located_on_workspace    (MetaWindow *window,
                                                             MetaWorkspace *workspace);
    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);
    void                meta_window_change_workspace        (MetaWindow *window,
                                                             MetaWorkspace *workspace);
    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 *user_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_on_primary_monitor   (MetaWindow *window);
    gboolean            meta_window_requested_bypass_compositor
                                                            (MetaWindow *window);
    gboolean            meta_window_requested_dont_bypass_compositor
                                                            (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);
    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_mutter_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);
    void                meta_window_make_fullscreen         (MetaWindow *window);
    void                meta_window_unmake_fullscreen       (MetaWindow *window);
    void                meta_window_make_above              (MetaWindow *window);
    void                meta_window_unmake_above            (MetaWindow *window);
    void                meta_window_shade                   (MetaWindow *window,
                                                             guint32 timestamp);
    void                meta_window_unshade                 (MetaWindow *window,
                                                             guint32 timestamp);
    void                meta_window_stick                   (MetaWindow *window);
    void                meta_window_unstick                 (MetaWindow *window);
    void                meta_window_kill                    (MetaWindow *window);
    void                meta_window_focus                   (MetaWindow *window,
                                                             guint32 timestamp);
    void                meta_window_check_alive             (MetaWindow *window,
                                                             guint32 timestamp);
    void                meta_window_get_work_area_current_monitor
                                                            (MetaWindow *window,
                                                             MetaRectangle *area);
    void                meta_window_get_work_area_for_monitor
                                                            (MetaWindow *window,
                                                             int which_monitor,
                                                             MetaRectangle *area);
    void                meta_window_get_work_area_all_monitors
                                                            (MetaWindow *window,
                                                             MetaRectangle *area);
    void                meta_window_begin_grab_op           (MetaWindow *window,
                                                             MetaGrabOp op,
                                                             gboolean frame_action,
                                                             guint32 timestamp);

## Object Hierarchy

      GObject
       +----MetaWindow

## Properties

      "above"                    gboolean              : Read
      "appears-focused"          gboolean              : Read
      "decorated"                gboolean              : Read
      "demands-attention"        gboolean              : Read
      "fullscreen"               gboolean              : Read
      "gtk-app-menu-object-path" gchar*                : Read
      "gtk-application-id"       gchar*                : Read
      "gtk-application-object-path" gchar*                : Read
      "gtk-menubar-object-path"  gchar*                : Read
      "gtk-unique-bus-name"      gchar*                : Read
      "gtk-window-object-path"   gchar*                : Read
      "icon"                     GdkPixbuf*            : Read
      "maximized-horizontally"   gboolean              : Read
      "maximized-vertically"     gboolean              : Read
      "mini-icon"                GdkPixbuf*            : Read
      "minimized"                gboolean              : Read
      "mutter-hints"             gchar*                : Read
      "resizeable"               gboolean              : Read
      "skip-taskbar"             gboolean              : Read
      "title"                    gchar*                : Read
      "urgent"                   gboolean              : Read
      "user-time"                guint                 : Read
      "window-type"              MetaWindowType        : Read
      "wm-class"                 gchar*                : Read

## Signals

      "focus"                                          : Run Last
      "position-changed"                               : Run Last
      "raised"                                         : Run Last
      "size-changed"                                   : Run Last
      "unmanaged"                                      : Run Last
      "workspace-changed"                              : Run Last

## Description

## Details

### MetaWindow

    typedef struct _MetaWindow MetaWindow;

### MetaWindowClass

    typedef struct _MetaWindowClass MetaWindowClass;

### 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` | Normal
`META_WINDOW_DESKTOP` | Desktop
`META_WINDOW_DOCK` | Dock
`META_WINDOW_DIALOG` | Dialog
`META_WINDOW_MODAL_DIALOG` | Modal dialog
`META_WINDOW_TOOLBAR` | Toolbar
`META_WINDOW_MENU` | Menu
`META_WINDOW_UTILITY` | Utility
`META_WINDOW_SPLASHSCREEN` | Splashcreen
`META_WINDOW_DROPDOWN_MENU` | Dropdown menu
`META_WINDOW_POPUP_MENU` | Popup menu
`META_WINDOW_TOOLTIP` | Tooltip
`META_WINDOW_NOTIFICATION` | Notification
`META_WINDOW_COMBO` | Combobox
`META_WINDOW_DND` | Drag and drop
`META_WINDOW_OVERRIDE_OTHER` | Other override-redirect window type

### enum MetaMaximizeFlags

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

`META_MAXIMIZE_HORIZONTAL` | Horizontal
`META_MAXIMIZE_VERTICAL` | Vertical

### meta_window_get_frame ()

    MetaFrame *         meta_window_get_frame               (MetaWindow *window);

`window` : | a MetaWindow

### 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_monitor_sized ()

    gboolean            meta_window_is_monitor_sized        (MetaWindow *window);

`window` : | a MetaWindow
Returns : | `TRUE` if the window is occupies an entire monitor or the whole screen.

### meta_window_is_override_redirect ()

    gboolean            meta_window_is_override_redirect    (MetaWindow *window);

`window` : | A MetaWindow
Returns : | `TRUE` if this window isn't managed by mutter; it will control its own positioning and mutter 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_frame_rect ()

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

Gets the rectangle that bounds `window` that is what the user thinks of as the edge of the window. This doesn't include any extra reactive area that we or the client adds to the window, or any area that the client adds to draw a client-side shadow.

`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);

### Warning

`meta_window_get_outer_rect` has been deprecated since version 3.12 and should not be used in newly-written code. Use `meta_window_get_frame_rect()` instead.

Gets the rectangle that bounds `window` that is what the user thinks of as the edge of the window. This doesn't include any extra reactive area that we or the client adds to the window, or any area that the client adds to draw a client-side shadow.

`window` : | a MetaWindow
`rect` : | pointer to an allocated MetaRectangle. [out]

### meta_window_client_rect_to_frame_rect ()

    void                meta_window_client_rect_to_frame_rect
                                                            (MetaWindow *window,
                                                             MetaRectangle *client_rect,
                                                             MetaRectangle *frame_rect);

Converts a desired bounds of the client window - what is passed to `meta_window_move_resize()` - into the corresponding bounds of the window frame (excluding invisible borders and client side shadows.)

`window` : | a MetaWindow
`client_rect` : | client rectangle in root coordinates
`frame_rect` : | location to store the computed corresponding frame bounds. [out]

### meta_window_frame_rect_to_client_rect ()

    void                meta_window_frame_rect_to_client_rect
                                                            (MetaWindow *window,
                                                             MetaRectangle *frame_rect,
                                                             MetaRectangle *client_rect);

Converts a desired frame bounds for a window into the bounds of the client window - what is passed to `meta_window_move_resize()`.

`window` : | a MetaWindow
`frame_rect` : | desired frame bounds for the window
`client_rect` : | location to store the computed corresponding client rectangle. [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 ()

    Window              meta_window_get_xwindow             (MetaWindow *window);

`window` : | a MetaWindow

### 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 Mutter 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_located_on_workspace ()

    gboolean            meta_window_located_on_workspace    (MetaWindow *window,
                                                             MetaWorkspace *workspace);

`window` : | a MetaWindow
`workspace` : | a MetaWorkspace
Returns : | whether `window` is displayed on `workspace`, or whether it will be displayed on all workspaces.

### 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);

### meta_window_change_workspace ()

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

### 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. [transfer none]

### MetaWindowForeachFunc ()

    gboolean            (*MetaWindowForeachFunc)            (MetaWindow *window,
                                                             void *user_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;

`window` : | a MetaWindow
Returns : | current maximization state

### meta_window_is_fullscreen ()

    gboolean            meta_window_is_fullscreen           (MetaWindow *window);

`window` : | a MetaWindow
Returns : | `TRUE` if the window is currently fullscreen

### meta_window_is_on_primary_monitor ()

    gboolean            meta_window_is_on_primary_monitor   (MetaWindow *window);

`window` : | a MetaWindow
Returns : | `TRUE` if the window is on the primary monitor

### meta_window_requested_bypass_compositor ()

    gboolean            meta_window_requested_bypass_compositor
                                                            (MetaWindow *window);

`window` : | a MetaWindow
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);

`window` : | a MetaWindow
Returns : | `TRUE` if the window requested to opt out of unredirecting

### meta_window_get_icon_geometry ()

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

Gets the location of the icon corresponding to the window. The location will be provided set by the task bar or other user interface element displaying the icon, and is relative to the root window.

`window` : | a MetaWindow
`rect` : | rectangle into which to store the returned geometry. [out]
Returns : | `TRUE` if the icon geometry was succesfully retrieved.

### 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_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. [transfer none]

### 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 Mutter initially upon window creation, and updated thereafter on input events (key and button presses) seen by Mutter, client updates to the _NET_WM_USER_TIME property (if later than the current time) and when focusing the window.

`window` : | a MetaWindow
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. [transfer none]

### 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 mutter.

### 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. [transfer none]

### 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_mutter_hints ()

    const char *        meta_window_get_mutter_hints        (MetaWindow *window);

Gets the current value of the _MUTTER_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; 'mutter-' key prefix is reserved for internal use, and must not be used by plugins.

`window` : | a MetaWindow
Returns : | the _MUTTER_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.

`window` : | a MetaWindow
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 monitor 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.

`window` : | a MetaWindow
Returns : | the matching tiled window or `NULL` if it doesn't exist. [transfer none][allow-none]

### meta_window_make_fullscreen ()

    void                meta_window_make_fullscreen         (MetaWindow *window);

### meta_window_unmake_fullscreen ()

    void                meta_window_unmake_fullscreen       (MetaWindow *window);

### meta_window_make_above ()

    void                meta_window_make_above              (MetaWindow *window);

### meta_window_unmake_above ()

    void                meta_window_unmake_above            (MetaWindow *window);

### meta_window_shade ()

    void                meta_window_shade                   (MetaWindow *window,
                                                             guint32 timestamp);

### meta_window_unshade ()

    void                meta_window_unshade                 (MetaWindow *window,
                                                             guint32 timestamp);

### meta_window_stick ()

    void                meta_window_stick                   (MetaWindow *window);

### meta_window_unstick ()

    void                meta_window_unstick                 (MetaWindow *window);

### meta_window_kill ()

    void                meta_window_kill                    (MetaWindow *window);

### meta_window_focus ()

    void                meta_window_focus                   (MetaWindow *window,
                                                             guint32 timestamp);

### meta_window_check_alive ()

    void                meta_window_check_alive             (MetaWindow *window,
                                                             guint32 timestamp);

### meta_window_get_work_area_current_monitor ()

    void                meta_window_get_work_area_current_monitor
                                                            (MetaWindow *window,
                                                             MetaRectangle *area);

Get the work area for the monitor `window` is currently on.

`window` : | a MetaWindow
`area` : | a location to store the work area. [out]

### meta_window_get_work_area_for_monitor ()

    void                meta_window_get_work_area_for_monitor
                                                            (MetaWindow *window,
                                                             int which_monitor,
                                                             MetaRectangle *area);

Get the work area for `window`, given the monitor index `which_monitor`.

`window` : | a MetaWindow
`which_monitor` : | a moniotr to get the work area for
`area` : | a location to store the work area. [out]

### meta_window_get_work_area_all_monitors ()

    void                meta_window_get_work_area_all_monitors
                                                            (MetaWindow *window,
                                                             MetaRectangle *area);

Get the work area for all monitors for `window`.

`window` : | a MetaWindow
`area` : | a location to store the work area. [out]

### meta_window_begin_grab_op ()

    void                meta_window_begin_grab_op           (MetaWindow *window,
                                                             MetaGrabOp op,
                                                             gboolean frame_action,
                                                             guint32 timestamp);

## Property Details

### The `"above"` property

      "above"                    gboolean              : Read

Whether the window is shown as always-on-top.

Default value: FALSE

### The `"appears-focused"` property

      "appears-focused"          gboolean              : Read

Whether the window is drawn as being focused.

Default value: FALSE

### The `"decorated"` property

      "decorated"                gboolean              : Read

Whether window is decorated.

Default value: TRUE

### The `"demands-attention"` property

      "demands-attention"        gboolean              : Read

Whether the window has _NET_WM_STATE_DEMANDS_ATTENTION set.

Default value: FALSE

### The `"fullscreen"` property

      "fullscreen"               gboolean              : Read

Whether window is fullscreened.

Default value: FALSE

### The `"gtk-app-menu-object-path"` property

      "gtk-app-menu-object-path" gchar*                : Read

Contents of the _GTK_APP_MENU_OBJECT_PATH property of this window.

Default value: NULL

### The `"gtk-application-id"` property

      "gtk-application-id"       gchar*                : Read

Contents of the _GTK_APPLICATION_ID property of this window.

Default value: NULL

### The `"gtk-application-object-path"` property

      "gtk-application-object-path" gchar*                : Read

Contents of the _GTK_APPLICATION_OBJECT_PATH property of this window.

Default value: NULL

### The `"gtk-menubar-object-path"` property

      "gtk-menubar-object-path"  gchar*                : Read

Contents of the _GTK_MENUBAR_OBJECT_PATH property of this window.

Default value: NULL

### The `"gtk-unique-bus-name"` property

      "gtk-unique-bus-name"      gchar*                : Read

Contents of the _GTK_UNIQUE_BUS_NAME property of this window.

Default value: NULL

### The `"gtk-window-object-path"` property

      "gtk-window-object-path"   gchar*                : Read

Contents of the _GTK_WINDOW_OBJECT_PATH property of this window.

Default value: NULL

### The `"icon"` property

      "icon"                     GdkPixbuf*            : Read

96 pixel sized icon.

### The `"maximized-horizontally"` property

      "maximized-horizontally"   gboolean              : Read

Whether window is maximized horizontally.

Default value: FALSE

### The `"maximized-vertically"` property

      "maximized-vertically"     gboolean              : Read

Whether window is maximized vertically.

Default value: FALSE

### The `"mini-icon"` property

      "mini-icon"                GdkPixbuf*            : Read

16 pixel sized icon.

### The `"minimized"` property

      "minimized"                gboolean              : Read

Whether window is minimized.

Default value: FALSE

### The `"mutter-hints"` property

      "mutter-hints"             gchar*                : Read

Contents of the _MUTTER_HINTS property of this window.

Default value: NULL

### The `"resizeable"` property

      "resizeable"               gboolean              : Read

Whether the window can be resized.

Default value: FALSE

### The `"skip-taskbar"` property

      "skip-taskbar"             gboolean              : Read

Whether the skip-taskbar flag of WM_HINTS is set.

Default value: FALSE

### The `"title"` property

      "title"                    gchar*                : Read

The title of the window.

Default value: NULL

### The `"urgent"` property

      "urgent"                   gboolean              : Read

Whether the urgent flag of WM_HINTS is set.

Default value: FALSE

### The `"user-time"` property

      "user-time"                guint                 : Read

Timestamp of last user interaction.

Default value: 0

### The `"window-type"` property

      "window-type"              MetaWindowType        : Read

The type of the window.

Default value: META_WINDOW_NORMAL

### The `"wm-class"` property

      "wm-class"                 gchar*                : Read

Contents of the WM_CLASS property of this window.

Default value: NULL

## Signal Details

### The `"focus"` signal

    void                user_function                      (MetaWindow *metawindow,
                                                            gpointer    user_data)       : Run Last

### The `"position-changed"` signal

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

This is emitted when the position of a window might have changed. Specifically, this is emitted when the position of the toplevel window has changed, or when the position of the client window has changed.

`window` : | a MetaWindow
`user_data` : | user data set when the signal handler was connected.

### The `"raised"` signal

    void                user_function                      (MetaWindow *metawindow,
                                                            gpointer    user_data)       : Run Last

### The `"size-changed"` signal

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

This is emitted when the position of a window might have changed. Specifically, this is emitted when the size of the toplevel window has changed, or when the size of the client window has changed.

`window` : | a MetaWindow
`user_data` : | user data set when the signal handler was connected.

### The `"unmanaged"` signal

    void                user_function                      (MetaWindow *metawindow,
                                                            gpointer    user_data)       : Run Last

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

    void                user_function                      (MetaWindow *metawindow,
                                                            gint        arg1,
                                                            gpointer    user_data)       : Run Last