Handles monitor config, modesetting, cursor sprites, ... MetaBackend is the abstraction that deals with several things like: - Modesetting (depending on the backend, this can be done either by X or KMS) - Initializing the [struct@Meta.Settings] - Setting up Monitor configuration - Input device configuration (using the #ClutterDeviceManager) - Creating the #MetaRenderer - Setting up the stage of the scene graph (using [class@Meta.Stage]) - Creating the object that deals with the cursor (using [class@Meta.CursorTracker]) and its possible pointer constraint (using #MetaPointerConstraint) - Setting the cursor sprite (using #MetaCursorRenderer) - Interacting with logind (using the appropriate D-Bus interface) - Querying logind (over D-Bus) to know when the lid is closed - Setup Remote Desktop / Screencasting (#MetaRemoteDesktop) - Setup the #MetaEgl object Note that the #MetaBackend is not a subclass of [class@Clutter.Backend]. It is responsible for creating the correct one, based on the backend that is used (#MetaBackendNative or #MetaBackendX11). The #MetaContext the #MetaBackend the #MetaIdleMonitor that tracks server-global idle time for all devices. Returns the [class@Meta.LogicalMonitor] that currently has the mouse pointer. The current [class@Meta.LogicalMonitor]. A #MetaBackend The cursor tracker corresponding to @backend a #MetaBackend Gets the global #MetaDnd that's managed by this backend. the #MetaDnd A #MetaDnd A #MetaMonitorManager A #MetaOrientationManager The #MetaRemoteAccessController A #MetaBackend Gets the global #ClutterStage that's managed by this backend. the #ClutterStage A #MetaBackend %TRUE if the rendering is hardware accelerated, otherwise %FALSE. A #MetaBackend the #MetaGpu This class handles tracking and painting the root window background. By integrating with [class@Meta.WindowGroup] we can avoid painting parts of the background that are obscured by other windows. Set the background to @file a #MetaBackground a #GFile representing the background file the background style to apply This class handles tracking and painting the root window background. By integrating with [class@Meta.WindowGroup] we can avoid painting parts of the background that are obscured by other windows. Creates a new actor to draw the background for the given monitor. the newly created background actor Index of the monitor for which to draw the background This class handles tracking and painting the root window background. By integrating with [class@Meta.WindowGroup] we can avoid painting parts of the background that are obscured by other windows. The overall model drawing model of this content is that we have one texture, or two interpolated textures, possibly with alpha or margins that let the underlying background show through, blended over a solid color or a gradient. The result of that combination can then be affected by a "vignette" that darkens the background away from a central point (or as a no-GLSL fallback, simply darkens the background) and by overall opacity. As of GNOME 3.14, GNOME is only using a fraction of this when the user sets the background through the control center - what can be set is: A single image without a border An animation of images without a border that blend together, with the blend changing every 4-5 minutes A solid color with a repeated noise texture blended over it This all is pretty easy to do in a fragment shader, except when: A) We don't have GLSL - in this case, the operation of interpolating the two textures and blending the result over the background can't be expressed with Cogl's fixed-function layer combining (which is confined to what GL's texture environment combining can do) So we can only handle the above directly if there are no margins or alpha. B) The image textures are sliced. Texture size limits on older hardware (pre-965 intel hardware, r300, etc.) is often 2048, and it would be common to use a texture larger than this for a background and expect it to be scaled down. Cogl can compensate for this by breaking the texture up into multiple textures, but can't multitexture with sliced textures. So we can only handle the above if there's a single texture. However, even when we *can* represent everything in a single pass, it's not necessarily efficient. If we want to draw a 1024x768 background, it's pretty inefficient to bilinearly texture from two 2560x1440 images and mix that. So the drawing model we take here is that MetaBackground generates a single texture (which might be a 1x1 texture for a solid color, or a 1x2 texture for a gradient, or a repeated texture for wallpaper, or a pre-rendered texture the size of the screen), and we draw with that, possibly adding the vignette and opacity. Creates a new actor to draw the background for the given monitor. the newly created background actor a #MetaDisplay Index of the monitor for which to draw the background Sets the bounding clip rectangle of the #MetaBackgroundContent that's used when a rounded clip set via meta_background_content_set_rounded_clip_radius() is in effect, set it to %NULL to use no bounding clip, rounding the edges of the full texture. The #MetaBackgroundContent The new bounding clip rectangle, or %NULL Container for background actors This class is a subclass of ClutterActor with special handling for MetaBackgroundActor/MetaBackgroundGroup when painting children. It makes sure to only draw the parts of the backgrounds not occluded by opaque windows. See #MetaWindowGroup for more information behind the motivation, and details on implementation. Represents a loaded or loading background image. This function is a convenience function for checking for success, without having to call meta_background_image_get_texture() and handle the return of a Cogl type. %TRUE if loading completed successfully, otherwise %FALSE a #MetaBackgroundImage a #CoglTexture if loading succeeded; if loading failed or has not yet finished, %NULL. a #MetaBackgroundImage %TRUE if loading has already completed, %FALSE otherwise a #MetaBackgroundImage Caches loading of textures for backgrounds. There's actually nothing background specific about it, other than it is tuned to work well for large images as typically are used for backgrounds. the global singleton background cache Loads an image to use as a background, or returns a reference to an image that is already in the process of loading or loaded. In either case, what is returned is a [class@Meta.BackgroundImage] which can be dereferenced to get a [class@Cogl.Texture]. If [method@Meta.BackgroundImage.is_loaded] returns %TRUE, the background is loaded, otherwise the [signal@Meta.BackgroundImage::loaded] signal will be emitted exactly once. The 'loaded' state means that the loading process finished, whether it succeeded or failed. a #MetaBackgroundImage to dereference to get the loaded texture a #MetaBackgroundImageCache #GFile to load Remove an entry from the cache; this would be used if monitoring showed that the file changed. a #MetaBackgroundImageCache file to remove from the cache Returns the brightness target of the backlight. The target is a value between the minimum and maximum brightness of the backlight. The brightness target of the backlight. A #MetaBacklight object Returns the minimum and maximum supported brightness of the monitor. A #MetaBacklight object minimum brightness maximum brightness Sets the brightness target of the backlight. The target is a value between the minimum and maximum brightness of the backlight. A #MetaBacklight object The brightness target Pointer barriers In XI2.3, pointer barriers provide a feature where they can be temporarily released so that the pointer goes through them. Pass a #MetaBarrierEvent to release the barrier for this event sequence. The barrier to release The event to release the pointer for When a pointer barrier is hit, this will trigger. This requires an XI2-enabled server. A #MetaBarrierEvent that has the details of how the barrier was hit. When a pointer barrier hitbox was left, this will trigger. This requires an XI2-enabled server. A #MetaBarrierEvent that has the details of how the barrier was left. Positive direction in the X axis Positive direction in the Y axis Negative direction in the X axis Negative direction in the Y axis A unique integer ID identifying a consecutive series of motions at or along the barrier Server time, in milliseconds, since the last event sent for this barrier Server time, in milliseconds The cursor X position in screen coordinates The cursor Y position in screen coordinates. If the cursor hadn't been constrained, the delta of X movement past the barrier, in screen coordinates If the cursor hadn't been constrained, the delta of X movement past the barrier, in screen coordinates A boolean flag, %TRUE if this event generated by the pointer leaving the barrier as a result of a client calling meta_barrier_release() (will be set only for MetaBarrier::leave signals) A boolean flag, %TRUE if the pointer was grabbed at the time this event was sent Function a window button can have. Note, you can't add stuff here without extending the theme format to draw a new function and breaking all existing themes. Menu Minimize Maximize Close Marks the end of the #MetaButtonFunction enumeration Call whenever @dialog should receive keyboard focus, usually when the window would. a #MetaCloseDialog Hides the close dialog. a #MetaCloseDialog Shows the close dialog. a #MetaCloseDialog Call whenever @dialog should receive keyboard focus, usually when the window would. a #MetaCloseDialog Hides the close dialog. a #MetaCloseDialog Returns whether @dialog is currently visible. #TRUE if @dialog is visible. a #MetaCloseDialog Responds and closes the dialog. To be called by #MetaCloseDialog implementations. a #MetaCloseDialog a #MetaCloseDialogResponse Shows the close dialog. a #MetaCloseDialog a #MetaCloseDialog a #MetaCloseDialog a #MetaCloseDialog Indicates the appropriate effect to show the user for meta_compositor_show_window() and meta_compositor_hide_window() The window is newly created (also used for a window that was previously on a different workspace and is changed to become visible on the active workspace.) The window should be shown as unminimizing from its icon geometry. The window is being destroyed The window should be shown as minimizing to its icon geometry. No effect, the window should be shown or hidden immediately. Compositor API At a high-level, a window is not-visible or visible. When a window is added (with meta_compositor_add_window()) it is not visible. meta_compositor_show_window() indicates a transition from not-visible to visible. Some of the reasons for this: - Window newly created - Window is unminimized - Window is moved to the current desktop - Window was made sticky meta_compositor_hide_window() indicates that the window has transitioned from visible to not-visible. Some reasons include: - Window was destroyed - Window is minimized - Window is moved to a different desktop - Window no longer sticky. Note that combinations are possible - a window might have first been minimized and then moved to a different desktop. The 'effect' parameter to meta_compositor_show_window() and meta_compositor_hide_window() is a hint as to the appropriate effect to show the user and should not be considered to be indicative of a state change. When the active workspace is changed, meta_compositor_switch_workspace() is called first, then meta_compositor_show_window() and meta_compositor_hide_window() are called individually for each window affected, with an effect of META_COMP_EFFECT_NONE. If hiding windows will affect the switch workspace animation, the compositor needs to delay hiding the windows until the switch workspace animation completes. # Containers # There's two containers in the stage that are used to place window actors, here are listed in the order in which they are painted: - window group, accessible with [method@Meta.Compositor.get_window_group] - top window group, accessible with [method@Meta.Compositor.get_top_window_group] Mutter will place actors representing windows in the window group, except for override-redirect windows (ie. popups and menus) which will be placed in the top window group. Disables unredirection, can be useful in situations where having unredirected windows is undesirable like when recording a video. a #MetaCompositor Enables unredirection which reduces the overhead for apps like games. a #MetaCompositor The backend corresponding to @compositor a #MetaCompositor The feedback group corresponding to @display a #MetaCompositor a #MetaLaters a #MetaCompositor The stage corresponding to @compositor a #MetaCompositor The top window group corresponding to @compositor a #MetaCompositor The set of #MetaWindowActor on @compositor a #MetaCompositor The window group corresponding to @compositor a #MetaCompositor See g_option_context_add_main_entries() for more details. a #MetaContext a %NULL-terminated array of #GOptionEntrys a translation domain to use, or %NULL See g_option_context_add_group() for more details. a #MetaContext the group to add %TRUE if the commandline arguments (if any) were valid and if the configuration has been successful, %FALSE otherwise a #MetaContext Address of the `argc` parameter of your main() function (or 0 if @argv is %NULL). Address of the`argv` parameter of main(), or %NULL. the #MetaBackend The #MetaContext the #MetaDebugControl The #MetaContext the #MetaDisplay The #MetaContext Get the #MetaWaylandCompositor associated with the MetaContext. The might be none currently associated if the context hasn't been started or if the requested compositor type is not %META_COMPOSITOR_TYPE_WAYLAND. the #MetaWaylandCompositor The #MetaContext Raises the RLIMIT_NOFILE limit value to the hard limit. a #MetaContext Restores the RLIMIT_NOFILE limits from when the #MetaContext was created. a #MetaContext No cursor No cursor Default cursor Context menu cursor Help cursor Pointer cursor Progress cursor Wait cursor Cell cursor Crosshair cursor Text cursor Vertical text cursor DnD alias cursor DnD copy cursor DnD move cursor DnD no drop cursor DnD not allowed cursor DnD grab cursor DnD grabbing cursor Resize eastern edge cursor Resize northern edge cursor Resize north-eastern corner cursor Resize north-western corner cursor Resize southern edge cursor Resize south-eastern corner cursor Resize south-western corner cursor Resize western edge cursor Resize eastern and western edges cursor Resize northern and eastern edges cursor Resize north-east and south-west corners cursor Resize north-west and south-east corners cursor Resize column cursor Resize row cursor Scroll all directions cursor Zoom in cursor Zoom out cursor DnD ask cursor Resize all directions Mutter cursor tracking helper. Originally only tracking the cursor image, now more of a "core pointer abstraction" Get the hotspot of the current cursor sprite. a #MetaCursorTracker the x coordinate of the cursor hotspot the y coordinate of the cursor hotspot Get the current pointer position and state. a #MetaCursorTracker object the coordinates of the pointer the current #ClutterModifierType of the pointer Get the scale factor of the cursor sprite The scale factor of the cursor sprite a #MetaCursorTracker Get the #CoglTexture of the cursor sprite the #CoglTexture of the cursor sprite a #MetaCursorTracker default paint opaque regions make cursor updates await compositing frames always composite frames verbose logging focus workarea stack session management events window state window operations geometry window placement display keybindings sync startup preferences edge resistance Wayland kernel mode setting screencasting remote desktop backend native backend rendering color management input events eis state KMS deadline timers session management X11 window management Left Right Top Bottom Up Down Horizontal Vertical Mutter display representation The display is represented as a #MetaDisplay struct. Add a keybinding at runtime. The key @name in @schema needs to be of type %G_VARIANT_TYPE_STRING_ARRAY, with each string describing a keybinding in the form of "&lt;Control&gt;a" or "&lt;Shift&gt;&lt;Alt&gt;F1". The parser is fairly liberal and allows lower or upper case, and also abbreviations such as "&lt;Ctl&gt;" and "&lt;Ctrl&gt;". If the key is set to the empty list or a list with a single element of either "" or "disabled", the keybinding is disabled. Use meta_display_remove_keybinding() to remove the binding. the corresponding keybinding action if the keybinding was added successfully, otherwise %META_KEYBINDING_ACTION_NONE a #MetaDisplay the binding's name the #GSettings object where @name is stored flags to specify binding details function to run when the keybinding is invoked the data to pass to @handler function to free @user_data Sets the mouse-mode flag to %FALSE, which means that motion events are no longer ignored in mouse or sloppy focus. This is an internal function. It should be used only for reimplementing keybindings, and only in a manner compatible with core code. a #MetaDisplay the #MetaCompositor a #MetaDisplay the #MetaContext a #MetaDisplay Gets the index of the monitor that currently has the mouse pointer. a monitor index a #MetaDisplay Get our best guess as to the "currently" focused window (that is, the window that we expect will be focused at the point when the X server processes our next request). The current focus window a #MetaDisplay Get the keybinding action bound to @keycode. Builtin keybindings have a fixed associated #MetaKeyBindingAction, for bindings added dynamically the function will return the keybinding action meta_display_add_keybinding() returns on registration. The action that should be taken for the given key, or %META_KEYBINDING_ACTION_NONE. A #MetaDisplay Raw keycode Event mask Timestamp of the last user interaction event with a window a #MetaDisplay Stores the location and size of the indicated @monitor in @geometry. a #MetaDisplay the monitor number location to store the monitor geometry Determines whether there is a fullscreen window obscuring the specified monitor. If there is a fullscreen window, the desktop environment will typically hide any controls that might obscure the fullscreen window. You can get notification when this changes by connecting to MetaDisplay::in-fullscreen-changed. %TRUE if there is a fullscreen window covering the specified monitor. a #MetaDisplay the monitor number Gets the monitor scaling value for the given @monitor. the monitor scaling value a #MetaDisplay the monitor number Gets the number of monitors that are joined together to form @display. the number of monitors a #MetaDisplay Gets the index of the primary monitor on this @display. a monitor index a #MetaDisplay The selection manager of the display a #MetaDisplay Retrieve the size of the display. A #MetaDisplay The width of the screen The height of the screen The sound player of the display a #MetaDisplay Determine the active window that should be displayed for Alt-TAB. Current window a #MetaDisplay type of tab list origin workspace Determine the list of windows that should be displayed for Alt-TAB functionality. The windows are returned in most recently used order. If @workspace is not %NULL, the list only contains windows that are on @workspace or have the demands-attention hint set; otherwise it contains all windows. List of windows a #MetaDisplay type of tab list origin workspace Determine the next window that should be displayed for Alt-TAB functionality. Next window a #MetaDisplay type of tab list origin workspace starting window If %TRUE, look for the previous window. The workspace manager of the display a #MetaDisplay a #MetaDisplay Returns %TRUE if there is an ongoing grab operation. Whether there is an active display grab operation. The #MetaDisplay that the window is on Tells whether the event sequence is the used for pointer emulation and single-touch interaction. #TRUE if the sequence emulates pointer behavior the display a #ClutterEventSequence List all windows, including override-redirect ones. The windows are in no particular order. List of windows a #MetaDisplay Remove keybinding @name; the function will fail if @name is not a known keybinding or has not been added with meta_display_add_keybinding(). %TRUE if the binding has been removed successfully, otherwise %FALSE the #MetaDisplay name of the keybinding to remove Sorts a set of windows according to their current stacking order. If windows from multiple screens are present in the set of input windows, then all the windows on screen 0 are sorted below all the windows on screen 1, and so forth. Since the stacking order of override-redirect windows isn't controlled by Metacity, if override-redirect windows are in the input, the result may not correspond to the actual stacking order in the X server. An example of using this would be to sort the list of transient dialogs for a window into their current stacking order. Input windows sorted by stacking order, from lowest to highest a #MetaDisplay Set of windows Xserver time can wraparound, thus comparing two timestamps needs to take this into account. If no wraparound has occurred, this is equivalent to time1 < time2 Otherwise, we need to account for the fact that wraparound can occur and the fact that a timestamp of 0 must be special-cased since it means "older than anything else". Note that this is NOT an equivalent for time1 <= time2; if that's what you need then you'll need to swap the order of the arguments and negate the result. a #MetaDisplay An event timestamp An event timestamp The ::modifiers-accelerator-activated signal will be emitted when a special modifiers-only keybinding is activated. %TRUE means that the keyboard device should remain frozen and %FALSE for the default behavior of unfreezing the keyboard. The signal is emitted to indicate that compositor should reexec the process. This is emitted when [func@Meta.restart] is called, either by Mutter internally or by the embedding compositor. See also [signal@Meta.Display::show-restart-message]. %FALSE to indicate that the compositor could not be restarted. When the compositor is restarted, the signal should not return. Requests the pad button mapping OSD to be shown. The OSD actor the pad device the pad device settings path to the layout image Whether the OSD should be shown in edition mode Monitor to show the OSD on The signal will be emitted to indicate that the compositor should show a message during restart. This is emitted when [func@Meta.restart] is called, either by Mutter internally or by the embedding compositor. The message should be immediately added to the Clutter stage in its final form - [signal@Meta.Display::restart] will be emitted to exit the application and leave the stage contents frozen as soon as the the stage is painted again. On case of failure to restart, this signal will be emitted again with %NULL for @message. %TRUE means the message was added to the stage; %FALSE indicates that the compositor did not show the message. The message to display, or %NULL to clear a previous restart message. top-left corner top-right corner bottom-left corner bottom-right corner up down left right #MtkRectangle with the bounds of the edge Side To what belongs the edge Whether the edge belongs to a window Whether the edge belongs to a monitor Whether the edge belongs to a screen Success Error left border right border top border bottom border inner visible portion of frame border outer invisible portion of frame border sum of the two borders above Normal frame Dialog frame Modal dialog frame Utility frame Menu frame Border frame Attached frame Marks the end of the #MetaFrameType enumeration Converts a frame type enum value to the name string that would appear in the theme definition file. the string value a #MetaFrameType None Moving with pointer Resizing NW with pointer Resizing N with pointer Resizing NE with pointer Resizing E with pointer Resizing SW with pointer Resizing S with pointer Resizing SE with pointer Resizing W with pointer Moving with keyboard Resizing with keyboard Resizing NS with keyboard Resizing N with keyboard Resizing NE with keyboard Resizing E with keyboard Resizing SW with keyboard Resizing S with keyboard Resizing SE with keyboard Resizing W with keyboard Mutter window groups List of windows A #MetaGroup Mutter idle counter (similar to X's IDLETIME) a watch id Adds a watch for a specific idle time. The callback will be called when the user has accumulated @interval_msec milliseconds of idle time. This function will return an ID that can either be passed to meta_idle_monitor_remove_watch(), or can be used to tell idle time watches apart if you have more than one. Also note that this function will only care about positive transitions (user's idle time exceeding a certain time). If you want to know about when the user has become active, use meta_idle_monitor_add_user_active_watch(). A #MetaIdleMonitor The idletime interval, in milliseconds The callback to call when the user has accumulated @interval_msec milliseconds of idle time. The user data to pass to the callback A #GDestroyNotify a watch id Add a one-time watch to know when the user is active again. Note that this watch is one-time and will de-activate after the function is called, for efficiency purposes. It's most convenient to call this when an idle watch, as added by meta_idle_monitor_add_idle_watch(), has triggered. A #MetaIdleMonitor The callback to call when the user is active again. The user data to pass to the callback A #GDestroyNotify The current idle time, in milliseconds, or -1 for not supported A #MetaIdleMonitor Removes an idle time watcher, previously added by meta_idle_monitor_add_idle_watch() or meta_idle_monitor_add_user_active_watch(). A #MetaIdleMonitor A watch ID Hides the inhibit shortcuts dialog. a #MetaInhibitShortcutsDialog Shows the inhibit shortcuts dialog. a #MetaInhibitShortcutsDialog Hides the inhibit shortcuts dialog. a #MetaInhibitShortcutsDialog Responds and closes the dialog. To be called by #MetaInhibitShortcutsDialog implementations. a #MetaInhibitShortcutsDialog a #MetaInhibitShortcutsDialogResponse Shows the inhibit shortcuts dialog. a #MetaInhibitShortcutsDialog a #MetaInhibitShortcutsDialog a #MetaInhibitShortcutsDialog FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME FILLME none per-window built-in is reversed always active ignore autorepeat not grabbed automatically uses a custom keybinding action notifies on release in addition to press a #MetaDisplay a #MetaWindow a #ClutterEvent a #MetaKeyBinding data passed to the function Keyboard accessibility features. call in a resize processing phase that is done before GTK+ repainting (including window borders) is done. used by Mutter to compute which windows should be mapped used by Mutter to see if there's a fullscreen window used by Mutter to send it's idea of the stacking order to the server call before the stage is redrawn call at a very low priority (can be blocked by running animations or redrawing applications) Sets up a callback to be called at some later time. @when determines the particular later occasion at which it is called. This is much like g_idle_add(), except that the functions interact properly with clutter event handling. If a "later" function is added from a clutter event handler, and is supposed to be run before the stage is redrawn, it will be run before that redraw of the stage, not the next one. an integer ID (guaranteed to be non-zero) that can be used to cancel the callback and prevent it from being run. a #MetaLaters enumeration value determining the phase at which to run the callback callback to run later data to pass to the callback function to call to destroy @data when it is no longer in use, or %NULL Removes a callback added with meta_later_add() a #MetaLaters the integer ID returned from meta_later_add() An abstraction for a monitor(set) and its configuration. A logical monitor is a group of one or more physical monitors that must behave and be treated as single one. This happens, for example, when 2 monitors are mirrored. Each physical monitor is represented by a [class@Meta.Monitor]. #MetaLogicalMonitor has a single viewport, with its owns transformations (such as scaling), that are applied to all the [class@Meta.Monitor]s that are grouped by it. #MetaLogicalMonitor provides an abstraction that makes it easy to handle the specifics of setting up different [class@Meta.Monitor]s. It then can be used more easily by #MetaRendererView. Returns the list of [class@Meta.Monitor]s. The list of [class@Meta.Monitor]s. A #MetaLogicalMonitor Returns the [class@Meta.Monitor]s number which is compatible with the monitor API on [class@Meta.Display] until the next monitors-changed. The [class@Meta.Monitor]s number A #MetaLogicalMonitor Horizontal Vertical Both Returns the [class@Meta.Backlight] of the monitor, or NULL if it has no controllable backlight. The [class@Meta.Backlight]. A #MetaMonitor object Get the connector name of the monitor. The connector name of the monitor. A #MetaMonitor object Get the displayable name of the monitor. The displayable name of the monitor. A #MetaMonitor object Get the product name of the monitor. The product name of the monitor. A #MetaMonitor object Get the serial id of the monitor. The serial id of the monitor. A #MetaMonitor object Get the vendor name of the monitor. The vendor name of the monitor. A #MetaMonitor object Returns whether the monitor is active. %TRUE if the monitor is active, %FALSE otherwise. A #MetaMonitor object Returns whether the monitor is a builtin monitor. %TRUE if no monitors is a builtin monitor, %FALSE otherwise. A #MetaMonitor object Returns whether the monitor is the primary monitor. %TRUE if no monitors is the primary monitor, %FALSE otherwise. A #MetaMonitor object Returns whether the monitor is virtual. %TRUE if no monitors is virtual, %FALSE otherwise. A #MetaMonitor object A manager for multiple monitors #MetaMonitorManager is an abstract class which contains methods to handle multiple monitors (both #MetaMonitor and #MetaLogicalMonitor) and GPU's (#MetaGpu). Its functions include reading and/or changing the current configuration and available capabiliies. The #MetaMonitorManager also provides the "org.gnome.Mutter.DisplayConfig" DBus service, so apps like GNOME Settings can use this functionality. Returns whether the built-in display (i.e. a laptop panel) is turned on. A #MetaMonitorManager object Returns the list of [class@Meta.LogicalMonitor]s. See also meta_monitor_manager_get_num_logical_monitors() if you only need the size of the list. The list of [class@Meta.LogicalMonitor]s. A #MetaMonitorManager object The monitor index or -1 if @id isn't valid or the connector isn't associated with a logical monitor. A #MetaMonitorManager A valid connector name Returns the list of [class@Meta.Monitor]s. See also meta_monitor_manager_get_logical_monitors() for a list of `MetaLogicalMonitor`s. The list of [class@Meta.Monitor]s. A #MetaMonitorManager object The #MetaLogicalMonitor where the privacy screen state changed %TRUE if the privacy screen was enabled, otherwise %FALSE Upwards motion Downwards motion Motion to the left Motion to the right Motion up and to the left Motion up and to the right Motion down and to the left Motion down and to the right A texture that can have multiple planes. #MetaMultiTexture allows one to deal with non-trivial formats that have multiple planes, requires subsampling and/or aren't in RGB. A common example of this are decoded video frames, which often use something in the YUV colorspace, combined with subsampling. The basic idea of a #MetaMultiTexture is the following: - Each plane is represented by a separate #CoglTexture. That means that you should add each of these planes as a layer to your CoglPipeline. - When dealing with a color space that is not RGB, you can ask the #MetaMultiTexture to create a shader for you that does the conversion in the GPU. - In case you need to deal with memory access in a format with subsampling, you can use meta_multi_texture_get_width() and its analogous version for the height to get the correct size of the texture. Creates a #MetaMultiTexture with the given @format. Each of the `CoglTexture`s represents a plane. A new #MetaMultiTexture. Use g_object_unref() when you're done with it. The format of the #MetaMultiTexture The actual planes of the texture The number of planes Creates a #MetaMultiTexture for a "simple" texture, i.e. with only one plane, in a format that can be represented using #CoglPixelFormat. A new #MetaMultiTexture. Use g_object_unref() when you're done with it. The single plane of the texture Returns the #MetaMultiTextureFormat that is used by this texture. The texture format that is used by this #MetaMultiTexture. a #MetaMultiTexture Returns the height of the #MetaMultiTexture. Prefer this over calling cogl_texture_get_height() on one of the textures, as that might give a different size when dealing with subsampling. The height of the texture. a #MetaMultiTexture Returns the number of planes for this texture. Note that this is entirely dependent on the #CoglPixelFormat that is used. For example, simple RGB textures will have a single plane, while some more convoluted formats like NV12 and YUV 4:4:4 can have 2 and 3 planes respectively. The number of planes in this #MetaMultiTexture. a #MetaMultiTexture Returns the n'th plane of the #MetaMultiTexture. Note that it's a programming error to use with an index larger than meta_multi_texture_get_n_planes(). The plane at the given @index. a #MetaMultiTexture the index of the plane Returns the width of the #MetaMultiTexture. Prefer this over calling cogl_texture_get_width() on one of the textures, as that might give a different size when dealing with subsampling. The width of the texture. a #MetaMultiTexture A small function that checks whether the given multi texture uses a "simple" format, i.e. one that can be represented by a #CoglPixelFormat. Whether the texture format is #META_MULTI_TEXTURE_FORMAT_SIMPLE a #MetaMultiTexture Returns a string representation of @multi_texture, useful for debugging purposes. A string representation of @multi_texture. Use g_free() when done with it. a #MetaMultiTexture A representation for complex pixel formats Some pixel formats that are used in the wild are a bit more complex than just ARGB and all its variants. For example: a component might be put in a different plane (i.e. at a different place in memory). Another example are formats that use Y, U, and V components rather than RGB; if we composite them onto an RGBA framebuffer, we have to make sure for example that these get converted to the right color format first (using e.g. a shader). Invalid value Any format supported by Cogl (see #CoglPixelFormat) YUYV, 32 bits, 16 bpc (Y), 8 bpc (U & V) 2 planes: 1 Y-plane, 1 UV-plane (2x2 subsampled) 3 planes: 1 Y-plane, 1 U-plane (2x2 subsampled), 1 V-plane (2x2 subsampled) A screen orientation manager #MetaOrientationManager is a final class which contains methods to read the current screen orientation, as well as a signal that is triggered whenever a screen changes its orientation. Entry point for plugins Virtual function called to create a "force quit" dialog on non-responsive clients. a #MetaCloseDialog a #MetaPlugin a #MetaWindow Virtual function called to create a "inhibit shortcuts" dialog when a client requests compositor shortcuts to be inhibited. a #MetaInhibitShortcutsDialog a #MetaPlugin a #MetaWindow Virtual function called when the window represented by @actor is destroyed. a #MetaWindowActor Virtual function called when handling each keybinding. %TRUE if the plugin handled the keybinding. a #MetaKeyBinding Virtual function called when the workspace-switching effect needs to be killed prematurely. Virtual function called when the effects on @actor need to be killed prematurely; the plugin must call the completed() callback as if the effect terminated naturally. a #MetaWindowActor Virtual function called when the user triggered the "locate-pointer" mechanism. The common way to implement this function is to show some animation on screen to draw user attention on the pointer location. Virtual function called when the window represented by @actor is mapped. a #MetaWindowActor Virtual function called when the window represented by @actor is minimized. a #MetaWindowActor virtual function called when a window changes size to/from constraints Virtual function called when the compositor starts managing a screen Virtual function called when the window represented by @actor is destroyed. origin workspace destination workspace a #MetaMotionDirection Virtual function called when the window represented by @actor is unminimized. a #MetaWindowActor Virtual function called when handling each event. %TRUE if the plugin handled the event type (i.e., if the return value is %FALSE, there will be no subsequent call to the manager completed() callback, and the compositor must ensure that any appropriate post-effect cleanup is carried out. a xlib.XEvent Gets the #MetaDisplay corresponding to a plugin. the #MetaDisplay for the plugin a #MetaPlugin virtual function called when the compositor starts managing a screen virtual function called when a window is minimized a #MetaWindowActor a #MetaWindowActor virtual function called when a window changes size to/from constraints virtual function called when a window is mapped a #MetaWindowActor virtual function called when a window is destroyed a #MetaWindowActor virtual function called when the user switches to another workspace origin workspace destination workspace a #MetaMotionDirection virtual function called when the effects on a window need to be killed prematurely; the plugin must call the completed() callback as if the effect terminated naturally a #MetaWindowActor virtual function called when the workspace-switching effect needs to be killed prematurely virtual function called when handling each event %TRUE if the plugin handled the event type (i.e., if the return value is %FALSE, there will be no subsequent call to the manager completed() callback, and the compositor must ensure that any appropriate post-effect cleanup is carried out. a xlib.XEvent virtual function called when handling each keybinding %TRUE if the plugin handled the keybinding. a #MetaKeyBinding a #MetaCloseDialog a #MetaPlugin a #MetaWindow a #MetaInhibitShortcutsDialog a #MetaPlugin a #MetaWindow mouse button modifiers focus mode focus new windows attach modal dialogs raise on click action double click titlebar action middle click titlebar action right click titlebar auto-raise auto-raise delay focus change on pointer rest number of workspaces dynamic workspaces keybindings disable workarounds button layout workspace names visual bell audible bell visual bell type GNOME accessibility GNOME animations cursor theme cursor size resize with right button edge tiling force fullscreen workspaces only on primary draggable border width auto-maximize center new windows drag threshold show pointer location Inhibits remote access sessions from being created and running. Any active remote access session will be terminated. a #MetaRemoteAccessController Uninhibits remote access sessions from being created and running. If this was the last inhibition that was inhibited, new remote access sessions can now be created. a #MetaRemoteAccessController Stop the associated remote access session. A #MetaRemoteAccessHandle Stop the associated remote access session. A #MetaRemoteAccessHandle A #MetaRemoteAccessHandle Returns the list of supported mimetypes for the given selection type. The supported mimetypes The selection manager Selection to query Sets @owner as the owner of the selection given by @selection_type, unsets any previous owner there was. The selection manager Selection type New selection owner Requests a transfer of @mimetype on the selection given by @selection_type. The selection manager Selection type Mimetype to transfer Maximum size to transfer, -1 for unlimited Output stream to write contents to Cancellable User callback User data Finishes the transfer of a queried mimetype. #TRUE if the transfer was successful. The selection manager The async result Unsets @owner as the owner the selection given by @selection_type. If @owner does not own the selection, nothing is done. The selection manager Selection type Owner to unset Returns the list of supported mimetypes. The supported mimetypes The selection source Finishes a read from the selection source. The resulting #GInputStream The selection source The async result Returns the list of supported mimetypes. The supported mimetypes The selection source Returns #TRUE if the source is active on a selection. #TRUE if the source owns a selection. the selection source Finishes a read from the selection source. The resulting #GInputStream The selection source The async result The supported mimetypes The selection source The resulting #GInputStream The selection source The async result A ClutterContent which draws a shaped texture A MetaShapedTexture draws a #CoglTexture (often provided from a client surface) in such a way that it matches any required transformations that give its final shape, such as a #MtkMonitorTransform, y-invertedness, or a crop-and-scale operation. Flattens the two layers of the shaped texture into one ARGB32 image by alpha blending the two images, and returns the flattened image. a new cairo surface to be freed with cairo_surface_destroy(). A #MetaShapedTexture A clipping rectangle, to help prevent extra processing. In the case that the clipping rectangle is partially or fully outside the bounds of the texture, the rectangle will be clipped. the unshaped texture The #MetaShapedTexture Left side Right side Top side Bottom side Plays a sound from a file. a #MetaSoundPlayer file to play description of the played sound cancellable for the request Plays a sound from the sound theme. a #MetaSoundPlayer sound theme name of the event description of the event cancellable for the request Layers a window can be in. These MUST be in the order of stacking. Desktop layer Bottom layer Normal layer Top layer Dock layer Override-redirect layer Marks the end of the #MetaStackLayer enumeration Creates an app launch context. a launch context. a #MetaStartupNotification Get the list of startup sequences arrived in the startup notification object. a #GSList of #MetaStartupSequence in the #MetaStartupNotification. a #MetaStartupNotification Get the application id of the startup sequence. the application id or %NULL. a #MetaStartupSequence Get the icon name of the startup sequence. the icon name or %NULL. a #MetaStartupSequence Get the wmclass of the startup sequence. the wmclass or %NULL. a #MetaStartupSequence #MtkRectangle the #MetaStrut is on #MetaSide the #MetaStrut is on Normal windows Dock windows Groups All windows All windows in pure MRU order Show icon (Alt-Tab mode) Show instantly (Alt-Esc mode) A class that allows to launch a trusted client and detect if an specific Wayland window belongs to it. Creates a new #MetaWaylandClient. The #GSubprocesslauncher and array of arguments are used to launch a new process with the binary specified in the first element of argv, and with the rest of elements as parameters. It also sets up a new Wayland socket and sets the environment variable WAYLAND_SOCKET to make the new process to use it. A #MetaWaylandClient or %NULL if %error is set. Free with g_object_unref(). a #MetaContext a GSubprocessLauncher to use to launch the subprocess Command line arguments Get the #GSubprocess which was created by meta_wayland_client_new_subprocess. The #GSubprocess a #MetaWaylandClient Checks whether @window belongs to the process launched from @client or not. This only works under Wayland. If the window is an X11 window, an exception will be triggered. TRUE if the window was created by this process; FALSE if not. a #MetaWaylandClient a MetaWindow the Wayland display object The #MetaWaylandCompositor Get the #MetaWindow associated with this wayland surface. a #MetaWindow a #MetaWaylandSurface A display-agnostic abstraction for a window. #MetaWindow is the core abstraction in Mutter of a window. It has the properties you'd expect, such as a title, whether it's fullscreen, has decorations, etc. Since a lot of different kinds of windows exist, each window also a [enum@Meta.WindowType] which denotes which kind of window we're exactly dealing with. For example, one expects slightly different behaviour from a dialog than a "normal" window. The type of a window can be queried with [method@Meta.Window.get_window_type]. Common API for windows include: - Minimizing: [method@Meta.Window.minimize] / [method@Meta.Window.unminimize] - Maximizing: [method@Meta.Window.maximize] / [method@Meta.Window.unmaximize] - Fullscreen: [method@Meta.Window.make_fullscreen] / [method@Meta.Window.unmake_fullscreen] / [method@Meta.Window.is_fullscreen] Each #MetaWindow is part of either one or all [class@Meta.Workspace]s of the desktop. You can activate a window on a certain workspace using [method@Meta.Window.activate_with_workspace], and query on which workspace it is located using [method@Meta.Window.located_on_workspace]. The workspace it is part of can be obtained using [method@Meta.Window.get_workspace]. Each display protocol should make a subclass to be compatible with that protocols' specifics, for example #MetaWindowX11 and #MetaWindowWayland. This is independent of the protocol that the client uses, which is modeled using the [enum@Meta.WindowClientType] enum. To integrate within the Clutter scene graph, which deals with the actual rendering, each #MetaWindow will be part of a [class@Meta.WindowActor]. 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. %TRUE if the window should be drawn with a focused frame a #MetaWindow Converts a desired bounds of the client window into the corresponding bounds of the window frame (excluding invisible borders and client side shadows.) a #MetaWindow client rectangle in root coordinates location to store the computed corresponding frame bounds. Follow the chain of parents of @window, skipping transient windows, and return the "root" window which has no non-transient parent. The root ancestor window a #MetaWindow 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. a #MetaWindow Called for each window which is a transient parent of @window 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. a #MetaWindow Called for each window which is a transient of @window (transitively) User data Converts a desired frame bounds for a window into the bounds of the client window. a #MetaWindow desired frame bounds for the window location to store the computed corresponding client rectangle. Gets the rectangle that the pixmap or buffer of @window occupies. For X11 windows, this is the server-side geometry of the toplevel window. For Wayland windows, this is the bounding rectangle of the attached buffer. a #MetaWindow pointer to an allocated #MtkRectangle Gets the client rectangle that ATSPI window coordinates are relative to. A #MetaWindow pointer to an allocated #MtkRectangle Returns the #MetaWindowClientType of the window. The root ancestor window a #MetaWindow Gets the compositor's wrapper object for @window. the wrapper object. a #MetaWindow The display for @window A #MetaWindow 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. a #MetaWindow pointer to an allocated #MtkRectangle Gets the type of window decorations that should be used for this window. the frame type a #MetaWindow the object path a #MetaWindow the application ID a #MetaWindow the object path a #MetaWindow the object path a #MetaWindow the theme variant or %NULL a #MetaWindow the unique name a #MetaWindow the object path a #MetaWindow 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. %TRUE if the icon geometry was successfully retrieved. a #MetaWindow rectangle into which to store the returned geometry. Returns the window id associated with window. The window id a #MetaWindow Gets the current maximization state of the window, as combination of the %META_MAXIMIZE_HORIZONTAL and %META_MAXIMIZE_VERTICAL flags; current maximization state a #MetaWindow Gets index of the monitor that this window is on. The index of the monitor in the screens monitor list, or -1 if the window has been recently unmanaged and does not have a monitor. a #MetaWindow 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. the _MUTTER_HINTS string, or %NULL if no hints are set. a #MetaWindow Returns the pid of the process that created this window, if available to the windowing system. Note that the value returned by this is vulnerable to spoofing attacks by the client. the pid, or 0 if not known. a #MetaWindow Gets an unique id for a sandboxed app (currently flatpaks and snaps are supported). the sandboxed application ID or %NULL a #MetaWindow 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. Internal sequence number for this window A #MetaWindow Gets the startup id of the given #MetaWindow the startup id a #MetaWindow Get a tag associated to the window. Under wayland the tag can be set using the toplevel tag protocol, and under x11 it falls back to using `NET_WM_WINDOW_TAG` atom. An associated toplevel tag A #MetaWindow 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. the matching tiled window or %NULL if it doesn't exist. a #MetaWindow the current title of the window. a #MetaWindow Returns the #MetaWindow for the window that is pointed to by the WM_TRANSIENT_FOR hint on this window (see XGetTransientForHint() or XSetTransientForHint()). Mutter keeps transient windows above their parents. A typical usage of this hint is for a dialog that wants to stay above its associated window. 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 Mutter knows about. a #MetaWindow 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. The last time the user interacted with this window. a #MetaWindow Return the current value of the name part of `WM_CLASS` X property. the current value of the name part of `WM_CLASS` X property a #MetaWindow Return the current value of the instance part of `WM_CLASS` X property. the current value of the instance part of `WM_CLASS` X property. a #MetaWindow Get the work area for all monitors for @window. a #MetaWindow a location to store the work area Get the work area for the monitor @window is currently on. a #MetaWindow a location to store the work area Get the work area for @window, given the monitor index @which_monitor. a #MetaWindow a moniotr to get the work area for a location to store the work area Gets the [class@Meta.Workspace] that the window is currently displayed on. If the window is on all workspaces, returns the currently active workspace. the #MetaWorkspace for the window a #MetaWindow Tests if @window has any transients attached to it. If the `attach_modal_dialogs` option is not enabled, this will always return %FALSE. whether @window has attached transients a #MetaWindow Hides this window from any window list, like taskbars, pagers... A #MetaWindow 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. %TRUE if window is an ancestor of transient. a #MetaWindow a #MetaWindow Tests if @window should be attached to its parent window. If the `attach_modal_dialogs` option is not enabled, this will always return %FALSE. whether @window should be attached to its parent a #MetaWindow %TRUE if the window is currently fullscreen a #MetaWindow %TRUE if the window is maximized vertically and horizontally. a #MetaWindow %TRUE if the window is occupies an entire monitor or the whole screen. a #MetaWindow %TRUE if the window is on the primary monitor a #MetaWindow %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". A #MetaWindow %TRUE if this window originates from a host different from the one running mutter. a #MetaWindow %TRUE if the window is occupies the the whole screen (all monitors). A #MetaWindow Gets whether this window should be ignored by task lists. %TRUE if the skip bar hint is set. A #MetaWindow whether @window is displayed on @workspace, or whether it will be displayed on all workspaces. a #MetaWindow a #MetaWorkspace 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(). a #MetaWindow bool to indicate whether or not this is a user operation desired x pos desired y pos Resizes the window so that its outer bounds (including frame) fit within the given rect a #MetaWindow bool to indicate whether or not this is a user operation new x new y desired width desired height Moves the window to the monitor with index @monitor, keeping the relative position of the window's top left corner. a #MetaWindow desired monitor index Transform the coordinates from protocol coordinates to coordinates expected by the stage and internal window management logic. A #MetaWindow rectangle in protocol coordinate space rect in stage coordinate space Raises a window and marks it as the most recently used window on the workspace @target_workspace. If the window exists on all workspaces, it will become the most recently used sticky window on all other workspaces. This ensures proper tracking among windows on all workspaces while not overriding MRU for other windows. a #MetaWindow the #MetaWorkspace to raise and make it most recent on 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. a #MetaWindow rectangle with the desired geometry or %NULL. Set the window type A #MetaWindow The #MetaWindowType Shows again this window in window lists, like taskbars, pagers... A #MetaWindow %TRUE if window would be visible, if its workspace was current A #MetaWindow Transform the coordinates from stage coordinates to protocol coordinates A #MetaWindow x #MtkRectangle in stage coordinate space x #MtkRectangle in protocol coordinate space the #MetaGroup of the window a #MetaWindow a #MetaWindowConfig This is emitted when the monitor with the highest scale intersecting the window changes. 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. This is emitted after a window has been shown. This is emitted when the size 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. An actor representing a top-level window in the scene graph #MetaWindowActor is a #ClutterActor that adds a notion of a window to the Clutter scene graph. It contains a #MetaWindow which provides the windowing API, and the #MetaCompositor that handles it. For the actual content of the window, it contains a #MetaSurfaceActor. #MetaWindowActor takes care of the rendering features you need for your window. For example, it will take the windows' requested opacity and use that for clutter_actor_set_opacity(). Furthermore, it will also draw a shadow around the window (using #MetaShadow) and deal with synchronization between events of the window and the actual render loop. See MetaWindowActor::first-frame for an example of the latter. Freezes the #MetaWindowActor, which inhibits updates and geometry changes of the window. This property is refcounted, so make sure to call meta_window_actor_thaw() the exact same amount of times as this function to allow updates again. The #MetaWindowActor Flattens the layers of @self into one ARGB32 image by alpha blending the images, and returns the flattened image. a new cairo surface to be freed with cairo_surface_destroy(). A #MetaWindowActor A clipping rectangle, to help prevent extra processing. In the case that the clipping rectangle is partially or fully outside the bounds of the actor, the rectangle will be clipped. Gets the #MetaWindow object that the the #MetaWindowActor is displaying the displayed #MetaWindow a #MetaWindowActor Gets the ClutterActor that is used to display the contents of the window, or NULL if no texture is shown yet, because the window is not mapped. the #ClutterActor for the contents a #MetaWindowActor Gets whether the X window that the actor was displaying has been destroyed %TRUE when the window is destroyed, otherwise %FALSE a #MetaWindowActor a new #ClutterContent A #MetaWindowActor A clipping rectangle, in actor coordinates, to help prevent extra processing. In the case that the clipping rectangle is partially or fully outside the bounds of the actor, the rectangle will be clipped. Thaws/unfreezes the #MetaWindowActor to allow updates and geometry changes after a window was frozen using meta_window_actor_freeze(). The #MetaWindowActor Notify that one or more of the surfaces of the window have been damaged. The ::effects-completed signal will be emitted once all pending compositor effects are completed. The ::first-frame signal will be emitted the first time a frame of window contents has been drawn by the application and Mutter has had the chance to drawn that frame to the screen. If the window starts off initially hidden, obscured, or on on a different workspace, the ::first-frame signal will be emitted even though the user doesn't see the contents. MetaDisplay::window-created is a good place to connect to this signal - at that point, the MetaWindowActor for the window exists, but the window has reliably not yet been drawn. Connecting to an existing window that has already been drawn to the screen is not useful. A Wayland based window An X11 based window An object representing the configuration of a top-level window Menu the compositor should display for a given window the window manager menu the (fallback) app menu Normal Desktop Dock Dialog Modal dialog Toolbar Menu Utility Splashcreen Dropdown menu Popup menu Tooltip Notification Combobox Drag and drop Other override-redirect window type Workspaces A workspace is a set of windows which all live on the same screen. (You may also see the name "desktop" around the place, which is the EWMH's name for the same thing.) Only one workspace of a screen may be active at once; all windows on all other workspaces are unmapped. Switches to @workspace and possibly activates the window @focus_this. The window @focus_this is activated by calling meta_window_activate() which will unminimize it and transient parents, raise it and give it the focus. If a window is currently being moved by the user, it will be moved to @workspace. The advantage of calling this function instead of meta_workspace_activate() followed by meta_window_activate() is that it happens as a unit, so no other window gets focused first before @focus_this. a #MetaWorkspace the #MetaWindow to be focused, or %NULL timestamp for @focus_this Gets the #MetaDisplay that the workspace is part of. the #MetaDisplay for the workspace a #MetaWorkspace Calculate and retrieve the workspace that is next to @workspace, according to @direction and the current workspace layout, as set by meta_screen_override_workspace_layout(). the workspace next to @workspace, or @workspace itself if the neighbor would be outside the layout a #MetaWorkspace a #MetaMotionDirection, relative to @workspace Stores the work area in @area. a #MetaWorkspace location to store the work area Stores the work area for @which_monitor on @workspace in @area. a #MetaWorkspace a monitor index location to store the work area Gets windows contained on the workspace, including workspace->windows and also sticky windows. Override-redirect windows are not included. the list of windows. a #MetaWorkspace Sets a list of struts that will be used in addition to the struts of the windows in the workspace when computing the work area of the workspace. a #MetaWorkspace list of #MetaStrut Append a new workspace to the workspace manager and (optionally) switch to that display. the newly appended workspace. a #MetaWorkspaceManager %TRUE if the workspace should be switched to after creation if switching to a new workspace, timestamp to be used when focusing a window on the new workspace. (Doesn't hurt to pass a valid timestamp when available even if not switching workspaces.) The current workspace A #MetaWorkspaceManager Gets the workspace object for one of a workspace manager's workspaces given the workspace index. It's valid to call this function with an out-of-range index and it will robustly return %NULL. the workspace object with specified index, or %NULL if the index is out of range. a #MetaWorkspaceManager index of one of the display's workspaces The workspaces for @display a #MetaWorkspaceManager Explicitly set the layout of workspaces. Once this has been called, the contents of the _NET_DESKTOP_LAYOUT property on the root window are completely ignored. a #MetaWorkspaceManager the corner at which the first workspace is found if %TRUE the workspaces are laid out in columns rather than rows number of rows of workspaces, or -1 to determine the number of rows from @n_columns and the total number of workspaces number of columns of workspaces, or -1 to determine the number of columns from @n_rows and the total number of workspaces Reorder a workspace to a new index. If the workspace is currently active the "active-workspace-changed" signal will be emitted. If the workspace's index is the same as @new_index or the workspace will not be found in the list, this function will return. Calling this function will also emit the "workspaces-reordered" signal. a #MetaWorkspaceManager a #MetaWorkspace to reorder the new index of the passed workspace Mutter X display handler The X11 display is represented as a #MetaX11Display struct. a #MetaX11Display A #MetaX11Display Convert an accelerator keyval and modifier mask into a string parsable by `meta_parse_accelerator`. The accelerator name. Accelerator modifier mask. Accelerator keyval. Ensure log messages for the given topic @topic will be printed. Topic for which logging will be started Create a context. A new context instance. Human readable name of display server or window manager Converts a frame type enum value to the name string that would appear in the theme definition file. the string value a #MetaFrameType Returns %TRUE if this instance of Mutter comes from Mutter restarting itself (for example to enable/disable stereo.) See [func@Meta.restart]. If this is the case, any startup visuals or animations should be suppressed. Allows users to register a custom handler for a builtin key binding. %TRUE if the binding known as @name was found, %FALSE otherwise. The name of the keybinding to set The new handler function User data to pass to the callback Will be called when this handler is overridden. a #MetaPrefsChangedFunc data passed to the function a #MetaPrefsChangedFunc data passed to the function Stop printing log messages for the given topic @topic. Note that this method does not stack with [func@Meta.add_verbose_topic]; i.e. if two calls to [func@Meta.add_verbose_topic] for the same topic are made, one call to [func@Meta.remove_verbose_topic] will remove it. Topic for which logging will be stopped Starts the process of restarting the compositor. Note that Mutter's involvement here is to make the restart visually smooth for the user - it cannot itself safely reexec a program that embeds libmuttter. So in order for this to work, the compositor must handle two signals - [signal@Meta.Display::show-restart-message], to display the message passed here on the Clutter stage - [signal@Meta.Display::restart] to actually reexec the compositor. message to display to the user, or %NULL a #MetaContext