gtk.gdk.Window
Prev | The gtk.gdk Class Reference | Next

## gtk.gdk.Window

gtk.gdk.Window — on-screen display areas in the target window system

## Synopsis

    class gtk.gdk.Window(gtk.gdk.Drawable):
        gtk.gdk.Window(parent, width, height, window_type, event_mask, wclass, title=None, x=-1, y=-1, visual=None, colormap=None, cursor=None, wmclass_name=None, wmclass_class=None, override_redirect=-1)
        def drag_begin(targets)
        def input_set_extension_events(mask, mode)
        def property_get(property, type=None, pdelete=False)
        def property_change(property, type, format, mode, data)
        def property_delete(property)
        def selection_convert(selection, target, time)
        def set_keep_above(setting)
        def set_keep_below(setting)
        def destroy()
        def get_window_type()
        def show()
        def hide()
        def withdraw()
        def move(x, y)
        def resize(width, height)
        def move_resize(x, y, width, height)
        def reparent(new_parent, x, y)
        def clear()
        def clear_area(x, y, width, height)
        def clear_area_e(x, y, width, height)
        def raise_()
        def lower()
        def focus(timestamp=0L)
        def set_user_data(user_data)
        def get_user_data()
        def set_override_redirect(override_redirect)
        def add_filter(function, data=None)
        def scroll(dx, dy)
        def shape_combine_mask(shape_mask, offset_x, offset_y)
        def set_child_shapes()
        def merge_child_shapes()
        def is_visible()
        def is_viewable()
        def get_state()
        def set_static_gravities(use_static)
        def get_type_hint()
        def set_type_hint(hint)
        def set_modal_hint(modal)
        def set_skip_taskbar_hint(skips_taskbar)
        def set_skip_pager_hint(skips_pager)
        def set_geometry_hints(min_width=-1, min_height=-1, max_width=-1, max_height=-1, base_width=-1, base_height=-1, width_inc=-1, height_inc=-1, min_aspect=-1.0, max_aspect=-1.0)
        def begin_paint_rect(rectangle)
        def begin_paint_region(region)
        def end_paint()
        def set_title(title)
        def set_role(role)
        def set_transient_for(leader)
        def set_background(color)
        def set_back_pixmap(pixmap, parent_relative)
        def set_cursor(cursor)
        def get_geometry()
        def get_position()
        def get_origin()
        def get_root_origin()
        def get_frame_extents()
        def get_pointer()
        def get_parent()
        def get_toplevel()
        def get_children()
        def get_events()
        def set_events(event_mask)
        def set_icon_list(pixbufs)
        def set_icon(icon_window, pixmap, mask)
        def set_icon_name(name)
        def set_group(leader)
        def get_group()
        def set_decorations(decorations)
        def get_decorations()
        def set_functions(functions)
        def iconify()
        def deiconify()
        def stick()
        def unstick()
        def maximize()
        def unmaximize()
        def fullscreen()
        def unfullscreen()
        def register_dnd()
        def begin_resize_drag(edge, button, root_x, root_y, timestamp)
        def begin_move_drag(button, root_x, root_y, timestamp)
        def invalidate_rect(rect, invalidate_children)
        def invalidate_region(region, invalidate_children)
        def get_update_area()
        def freeze_updates()
        def thaw_updates()
        def process_updates(update_children)
        def set_accept_focus(accept_focus)
        def enable_synchronized_configure()
        def configure_finished()
        def set_focus_on_map(focus_on_map)
        def set_urgency_hint(urgent)
        def move_region(region, dx, dy)
        def shape_combine_region(shape_region, offset_x, offset_y)
        def input_shape_combine_mask(mask, x, y)
        def input_shape_combine_region(shape_region, offset_x, offset_y)
        def beep()
        def set_composited(composited)
        def set_opacity(opacity)
        def set_startup_id(startup_id)
        def remove_redirection()

    Functions

        def gtk.gdk.window_foreign_new(anid)
        def gtk.gdk.window_foreign_new_for_display(display, anid)
        def gtk.gdk.get_default_root_window()
        def gtk.gdk.window_get_toplevels()
        def gtk.gdk.window_lookup(anid)
        def gtk.gdk.window_lookup_for_display(display, anid)
        def gtk.gdk.window_process_all_updates()
        def gtk.gdk.gdk_window_set_debug_updates(setting)
        def gtk.gdk.window_at_pointer()

## Ancestry

    +-- gobject.GObject
      +-- gtk.gdk.Drawable
        +-- gtk.gdk.Window

## Description

`gtk.gdk.Window` is a rectangular region on the screen. It's a low-level object, used to implement high-level objects such as `gtk.Widget` and `gtk.Window`. A `gtk.Window` is a toplevel window, the object a user might think of as a "window" with a titlebar and so on. A `gtk.Window` may contain several `gtk.gdk.Window` objects since most widgets use a `gtk.gdk.Window`.

A `gtk.gdk.Window` object interacts with the native window system for input and events. Some `gtk.Widget` objects do not have an associated `gtk.gdk.Window` and therefore cannot receive events. To receive events on behalf of these "windowless" widgets a `gtk.EventBox` must be used.

### A gtk.gdk.Window Composited Windows example

    import gtk
    import cairo

    '''
    The expose event handler for the event box.

    This function simply draws a transparency onto a widget on the area
    for which it receives expose events.  This is intended to give the
    event box a "transparent" background.

    In order for this to work properly, the widget must have an RGBA
    colourmap.  The widget should also be set as app-paintable since it
    doesn't make sense for GTK+ to draw a background if we are drawing it
    (and because GTK+ might actually replace our transparency with its
    default background colour).
    '''
    def transparent_expose(widget, event):
        cr = widget.window.cairo_create()
        cr.set_operator(cairo.OPERATOR_CLEAR)

        # Ugly but we don't have event.region
        region = gtk.gdk.region_rectangle(event.area)

        cr.region(region)
        cr.fill()

        return False

    '''
    The expose event handler for the window.

    This function performs the actual compositing of the event box onto
    the already-existing background of the window at 50% normal opacity.

    In this case we do not want app-paintable to be set on the widget
    since we want it to draw its own (red) background. Because of this,
    however, we must ensure that we use g_signal_register_after so that
    this handler is called after the red has been drawn. If it was
    called before then GTK would just blindly paint over our work.

    Note: if the child window has children, then you need a cairo 1.16
    feature to make this work correctly.
    '''
    def window_expose_event(widget, event):

        #get our child (in this case, the event box)
        child = widget.get_child()

        #create a cairo context to draw to the window
        cr = widget.window.cairo_create()

        #the source data is the (composited) event box
        cr.set_source_pixmap (child.window,
                              child.allocation.x,
                              child.allocation.y)

        #draw no more than our expose event intersects our child
        region = gtk.gdk.region_rectangle(child.allocation)
        r = gtk.gdk.region_rectangle(event.area)
        region.intersect(r)
        cr.region (region)
        cr.clip()

        #composite, with a 50% opacity
        cr.set_operator(cairo.OPERATOR_OVER)
        cr.paint_with_alpha(0.5)

        return False

    # Make the widgets
    w = gtk.Window()
    b = gtk.Button("A Button")
    e = gtk.EventBox()

    # Put a red background on the window
    red = gtk.gdk.color_parse("red")
    w.modify_bg(gtk.STATE_NORMAL, red)

    # Set the colourmap for the event box.
    # Must be done before the event box is realised.
    screen = e.get_screen()
    rgba = screen.get_rgba_colormap()
    e.set_colormap(rgba)

    # Set our event box to have a fully-transparent background
    # drawn on it. Currently there is no way to simply tell GTK+
    # that "transparency" is the background colour for a widget.
    e.set_app_paintable(True)
    e.connect("expose-event", transparent_expose)

    # Put them inside one another
    w.set_border_width(10)
    w.add(e)
    e.add(b)

    # Realise and show everything
    w.show_all()

    # Set the event box GdkWindow to be composited.
    # Obviously must be performed after event box is realised.
    e.window.set_composited(True)

    # Set up the compositing handler.
    # Note that we do _after_ so that the normal (red) background is drawn
    # by gtk before our compositing occurs.
    w.connect_after("expose-event", window_expose_event)

    gtk.main()

In this example a button is placed inside of an event box inside of a window. The event box is set as composited and therefore is no longer automatically drawn to the screen.

When the contents of the event box change, an expose event is generated on its parent window (which, in this case, belongs to the toplevel `gtk.Window`). The expose handler for this widget is responsible for merging the changes back on the screen in the way that it wishes.

In our case, we merge the contents with a 50% transparency. We also set the background colour of the window to red. The effect is that the background shows through the button.

## Constructor

        gtk.gdk.Window(parent, width, height, window_type, event_mask, wclass, title=None, x=-1, y=-1, visual=None, colormap=None, cursor=None, wmclass_name=None, wmclass_class=None, override_redirect=-1)

`parent` : | a `gtk.gdk.Window`
`width` : | the width of the window in pixels
`height` : | the height of the window in pixels
`window_type` : | the window type
`event_mask` : | the bitmask of events received by the window
`wclass` : | the class of window - either `gtk.gdk.INPUT_OUTPUT` or `gtk.gdk.INPUT_ONLY`
`title` : | the window title if a toplevel window
`x` : | the x coordinate of the window position relative to `parent`
`y` : | the y coordinate of the window position relative to `parent`
`visual` : | the `gtk.gdk.Visual` for the window
`colormap` : | the `gtk.gdk.Colormap` for the window
`cursor` : | the `gtk.gdk.Cursor` for the window
`wmclass_name` : | don't use this - see the `gtk.Window.set_wmclass`() method for more information.
`wmclass_class` : | don't use this - see the `gtk.Window.set_wmclass`() method for more information.
`override_redirect` : | if `True` bypass the window manager
Returns : | the new `gtk.gdk.Window`

Creates a new `gtk.gdk.Window` of the type and class specified by `window_type` and `wclass`. The window will be a child of the specified `parent` and will have the specified `width` and `height`. `event_mask` is a bitfield specifying the events that the window will receive - see the `set_events`() method for more information. The value of `window_type` must be one of the GDK Window Type Constants.

The value of `wclass` must be one of the GDK Window Class Constants.

If the optional parameters are not specified the corresponding attribute values will have default values:

`x` | 0
`y` | 0
`visual` | the default system visual - see the `gtk.gdk.visual_get_system`() function
`colormap` | either the system `gtk.gdk.Colormap` if using the system `gtk.gdk.Visual` (see the `gtk.gdk.colormap_get_system`() function) or a new `gtk.gdk.Colormap` using `visual`
`cursor` | use the parent window's cursor
`override_redirect` | False

## Methods

### gtk.gdk.Window.drag_begin

        def drag_begin(targets)

`targets` : | a list of offered targets
Returns : | a new `gtk.gdk.DragContext`

The `drag_begin`() method starts a drag operation and returns the new `gtk.gdk.DragContext` created for it. The list of targets (integer values) supported by the drag source are specified by `targets`.

### gtk.gdk.Window.input_set_extension_events

        def input_set_extension_events(mask, mode)

`mask` : | the event mask to be used
`mode` : | the set of extension events to receive

The `input_set_extension_events`() method enables or disables the extension events specified by `mode` for the window when using the event mask specified by `mask`. The value of `mode` must be one of the GDK Extension Mode Constants

### gtk.gdk.Window.property_get

        def property_get(property, type=0, pdelete=False)

`property` : | the property to get
`type` : | the type of property to get or not specified if any type of property data is acceptable.
`pdelete` : | if `True`, delete the property after retrieving the data.
Returns : | a tuple containing the actual property type, the data format and the data

The `property_get`() method returns a tuple containing the actual property type (as a `gtk.gdk.Atom`), the format and the data of the specified `property` with the specified `type`. The value of `type` may not be be specified in which case it will be 0 to match any type of property. the returned data will be a string if the data format is 8; a list of integers if the data format is 16; or, a list of `gtk.gdk.Atom` objects or integers if the data format is 32. If `property` cannot be found `None` is returned. `property` and `type` (if specified) must be a string or a `gtk.gdk.Atom`.

### gtk.gdk.Window.property_change

        def property_change(property, type, format, mode, data)

`property` : | the property to change
`type` : | the new type of the property. If `mode` is `gtk.gdk.PROP_MODE_PREPEND` or `gtk.gdk.PROP_MODE_APPEND`, then this must match the existing type or an error will occur.
`format` : | the new format for the property. If `mode` is `gtk.gdk.PROP_MODE_PREPEND` or `gtk.gdk.PROP_MODE_APPEND`, then this must match the existing format or an error will occur.
`mode` : | a value describing how the new data is to be combined with the current data.
`data` : | the data for the property

The `property_change`() method changes the contents of the specified `property` to the specified `data` with the specified `type` and `format`. The value of `mode` must be one of the GDK Property Mode Constants which describes how the new data is to be combined with the existing property data.The value of `format` must be 8, 16 or 32. `property` and `type` must be a string or a `gtk.gdk.Atom`.

### gtk.gdk.Window.property_delete

        def property_delete(property)

`property` : | the property to delete

The `property_delete`() method deletes the specified `property` from the window. `property` must be a string or a gtk.gdk.Atom.

### gtk.gdk.Window.selection_convert

        def selection_convert(selection, target, time)

`selection` : | the selection to retrieve
`target` : | the target form of `selection`
`time` : | the timestamp to use when retrieving `selection`. The selection owner may refuse the request if it did not own the selection at the time indicated by the timestamp.

The `selection_convert`() method converts the specified `selection` to the specified `form`.

### gtk.gdk.Window.set_keep_above

        def set_keep_above(setting)

`setting` : | xif `True` keep the window above other windows

### Note

This method is available in PyGTK 2.4 and above.

The `set_keep_above`() method sets the "keep-above" setting to the value of `setting`. If `setting` is `True` the window must be kept above other windows. If the window is already above, then this method does nothing.

On X11, asks the window manager to keep the window above, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "keep above", but most standard window managers do.

### gtk.gdk.Window.set_keep_below

        def set_keep_below(setting)

`setting` : | if `True`, keep the window below other windows

### Note

This method is available in PyGTK 2.4 and above.

The `set_keep_below`() method sets the "keep-below" setting to the value of `setting`. If `setting` is `True` the window must be kept below other windows. If the window was already below, then this method does nothing.

On X11, asks the window manager to keep the window below, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "keep below" but most standard window managers do.

### gtk.gdk.Window.destroy

        def destroy()

The `destroy`() method destroys the window (destroys the server-side resource associated with the window). All children of the window are also destroyed. There's normally no need to use this method since windows are automatically destroyed when their reference count reaches 0.

### gtk.gdk.Window.get_window_type

        def get_window_type()

Returns : | the type of window

The `get_window_type`() method returns the type of the window which is one of the GDK Window Type Constants.

### gtk.gdk.Window.show

        def show()

The `show`() method maps the window so it's visible on-screen and also raises it to the top of the window stack (moves the window to the front of the Z-order). This method is opposite to the `hide`() method. When implementing a `gtk.Widget`, you should call this method on the widget's `gtk.gdk.Window` as part of the "map" method.

### gtk.gdk.Window.hide

        def hide()

The `hide`() method withdraws toplevel windows, so they will no longer be known to the window manager and for all windows, unmaps them, so they won't be displayed. This is normally done automatically as part of the `gtk.Widget.hide`() method.

### gtk.gdk.Window.withdraw

        def withdraw()

The `withdraw`() method withdraws the window (unmaps it and asks the window manager to forget about it). This is normally done automatically by the `gtk.Widget.hide`() method called on a `gtk.Window`.

### gtk.gdk.Window.move

        def move(x, y)

`x` : | the X coordinate relative to the window's parent
`y` : | the Y coordinate relative to the window's parent

The `move`() method repositions the window to the location specified by `x` and `y` relative to its parent window. For toplevel windows, window managers may ignore or modify the move. You should probably use the `gtk.Window.move`() method on a `gtk.Window` widget anyway, instead of using this method. For child windows, the move will reliably succeed. If you're also planning to resize the window, use the `move_resize`() method to both move and resize simultaneously, for a nicer visual effect.

### gtk.gdk.Window.resize

        def resize(width, height)

`width` : | the new width of the window
`height` : | the new height of the window

The `resize`() method resizes the window to the specified `width` and `height`. For toplevel windows, this method asks the window manager to resize the window. However, the window manager may not allow the resize. You should use the `gtk.Window.resize`() method instead of this low-level method. Windows may not be resized smaller than 1x1. If you're also planning to move the window, use the `move_resize`() method to both move and resize simultaneously, for a nicer visual effect.

### gtk.gdk.Window.move_resize

        def move_resize(x, y, width, height)

`x` : | the new X position relative to the window's parent
`y` : | the new Y position relative to the window's parent
`width` : | the new width
`height` : | the new height

The `move_resize`() method repositions the window to the location specified by `x` and `y` with the size specified by `width` and `height`. This method is equivalent to calling the `move`() and `resize`() methods, except that both operations are performed at once, avoiding strange visual effects. (i.e. the user may be able to see the window first move, then resize, if you don't use the `move_resize`() method.)

### gtk.gdk.Window.reparent

        def reparent(new_parent, x, y)

`new_parent` : | the new parent `gtk.gdk.Window` to move the window into
`x` : | the X location inside the new parent
`y` : | the Y location inside the new parent

The `reparent`() method reparents the window into the `gtk.gdk.Window` specified `new_parent`. The window being reparented will be unmapped as a side effect.

### gtk.gdk.Window.clear

        def clear()

The `clear`() method clears an entire the window to the background color or background pixmap.

### gtk.gdk.Window.clear_area

        def clear_area(x, y, width, height)

`x` : | the X coordinate of the rectangle to clear
`y` : | the Y coordinate of the rectangle to clear
`width` : | the width of the rectangle to clear
`height` : | the height of the rectangle to clear

The `clear_area`() method clears the area (specified by `x`, `y`, `width` and `height`) of the window to the background color or background pixmap.

### gtk.gdk.Window.clear_area_e

        def clear_area_e(x, y, width, height)

`x` : | the X coordinate of the rectangle to clear
`y` : | the Y coordinate of the rectangle to clear
`width` : | the width of the rectangle to clear
`height` : | the height of the rectangle to clear

The `clear_area_e`() method is like the `clear_area`(), but also generates an expose event for the cleared area.

### gtk.gdk.Window.raise_

        def raise_()

The `raise_`() method raises the window to the top of the Z-order (stacking order), so that other windows with the same parent window appear below the window. If the window is a toplevel, the window manager may choose to deny the request to move the window in the Z-order. Therefore, the `raise_`() method only requests the restack, it does not guarantee it.

### Note

This method is called `raise`() in the C API, but was renamed `raise_`() since `raise` is a reserved Python keyword.

### gtk.gdk.Window.lower

        def lower()

The lower() method lowers the window to the bottom of the Z-order (stacking order), so that other windows with the same parent window appear above the window. If the window is a toplevel, the window manager may choose to deny the request to move the window in the Z-order. Therefore, the `lower`() only requests the restack, it does not guarantee it. Note that the `show`() method raises the window again, so don't call this method before calling the `show`() method to avoid duplication.

### gtk.gdk.Window.focus

        def focus(timestamp=0L)

`timestamp` : | the timestamp of the event triggering the window focus

The `focus`() method sets keyboard focus to the window. If the window is not on-screen this will not work. In most cases, the `gtk.Window.present`() method should be used on a `gtk.Window`, rather than calling this method.

### gtk.gdk.Window.set_user_data

        def set_user_data(user_data)

`user_data` : | a `gtk.Widget`

### Note

This method is available in PyGTK 2.4 and above.

The `set_user_data`() method stores the underlying GTK+ widget of the PyGTK widget that is specified by `user_data` as the user data of the window. In general GTK+ stores the widget that owns a `gtk.gdk.Window` as user data on a `gtk.Window`. So, custom widget implementations in `PyGTK` should use this method to provide that capability. If `GTK+` receives an event for a `gtk.gdk.Window`, and the user data for the window is set, `GTK+` will assume the user data is a `gtk.Widget`, and forward the event to that widget.

In PyGTK 2.4 and above this method will raise the TypeError exception if `user_data` is not a `gtk.Widget`.

### Note

This method is deprecated for any use other than the above. To set other user data on a `gtk.gdk.Window` use the `gobject.GObject.set_data`() method instead.

### gtk.gdk.Window.get_user_data

        def get_user_data()

Returns : | the user data set on the window

### Note

This method is available in PyGTK 2.4 and above.

The `get_user_data`() method returns the PyGTK widget that was set as the user data of the window using the `set_user_data`() method. This method raises the ValueError exception if the user data is not set or is not a PyGTK object.

### gtk.gdk.Window.set_override_redirect

        def set_override_redirect(override_redirect)

`override_redirect` : | if `True` the window should be override redirect

The `set_override_redirect`() method sets the "override redirect" attribute on the window to the value specified by `override_redirect`. If `override_redirect` is `True` the window is not under the control of the window manager. This means it won't have a titlebar, won't be minimizable, etc. - it will be entirely under the control of the application. The window manager can't see the override redirect window at all. Override redirect should only be used for short-lived temporary windows, such as popup menus. `gtk.Menu` uses an override redirect window in its implementation, for example. This method does not work on MS Windows.

### gtk.gdk.Window.add_filter

        def add_filter(function, data=None)

`function` : | a function
`data` : | data to pass to `function`

### Note

This method is available in PyGTK 2.2 and above.

The `add_filter`() method adds an event filter function specified by `function` to the window, allowing you to intercept events before they reach GDK. This is a low-level operation and makes it easy to break GDK and/or GTK+, so you have to know what you're doing. Once added there is no way to remove a filter function. The function signature is:

      def function(event, user_data)

where `event` is a `gtk.gdk.Event` and `user_data` is `data`. If `data` is not specified then `user_data` is not passed to `function`.

`function` should return one of the following values which is on of the GDK Filter Return Constants.

### gtk.gdk.Window.scroll

        def scroll(dx, dy)

`dx` : | the amount to scroll in the X direction
`dy` : | the amount to scroll in the Y direction

The `scroll`() method scrolls the contents of the window, both pixels and children, by the horizontal and vertical amounts specified by `dx` and `dy` respectively. The window itself does not move. Portions of the window that the scroll operation brings in from off-screen areas are invalidated. The invalidated region may be bigger than what would strictly be necessary. (For X11, a minimum area will be invalidated if the window has no subwindows, or if the edges of the window's parent do not extend beyond the edges of the window. In other cases, a multi-step process is used to scroll the window which may produce temporary visual artifacts and unnecessary invalidations.)

### gtk.gdk.Window.shape_combine_mask

        def shape_combine_mask(shape_mask, offset_x, offset_y)

`shape_mask` : | the shape bitmap mask
`offset_x` : | the X position of shape mask with respect to the window
`offset_y` : | the Y position of shape mask with respect to the window

The `shape_combine_mask`() method applies the bitmap mask specified by `shape_mask` to the window at the location specified by `x` and `y`. Pixels in the window corresponding to set bits in the `shape_mask` will be visible; pixels in the window corresponding to unset bits in the `shape_mask` will be transparent. This method provides a non-rectangular window. If `shape_mask` is `None`, the shape mask will be unset, and the `x`/`y` parameters are not used.

On the X11 platform, this uses an X server extension which is widely available on most common platforms, but not available on very old X servers, and occasionally the implementation will be buggy. On servers without the shape extension, this function will do nothing.

### gtk.gdk.Window.set_child_shapes

        def set_child_shapes()

The `set_child_shapes`() method sets the shape mask of the window to the union of shape masks for all children of the window, ignoring the shape mask of the window itself. Contrast this method with the `merge_child_shapes`() method that includes the shape mask of the window in the masks to be merged.

### gtk.gdk.Window.merge_child_shapes

        def merge_child_shapes()

The `merge_child_shapes`() method merges the shape masks for any child windows into the shape mask for the window. i.e. the union of all masks for the window and its children will become the new mask for the window. See the `shape_combine_mask`() method. This method is distinct from the `set_child_shapes`() method because it includes the window's shape mask in the set of shapes to be merged.

### gtk.gdk.Window.is_visible

        def is_visible()

Returns : | `True` if the window is mapped

The `is_visible`() method returns `True` if the window has been mapped (with the `show`() method.

### gtk.gdk.Window.is_viewable

        def is_viewable()

Returns : | `True` if the window is viewable

The `is_viewable`() method returns `True` if the window and all its ancestors are mapped. (This is not necessarily "viewable" in the X sense, since we only check as far as we have `gtk.gdk.Window` parents, not to the root window.)

### gtk.gdk.Window.get_state

        def get_state()

Returns : | the window state bitfield

The `get_state`() method returns the bitwise `OR` of the currently active GDK Window State Flag Constants.

### gtk.gdk.Window.set_static_gravities

        def set_static_gravities(use_static)

`use_static` : | if `True` turn on static gravity
Returns : | `True` if the server supports static gravity

The `set_static_gravities`() method sets the bit gravity of the given window to the value specified by `use_static`. If `use_static` is `True` the window uses static gravity and all children get static subwindow gravity as well. This method returns `True` if the window system server supports static gravity.

### gtk.gdk.Window.get_type_hint

        def get_type_hint()

Returns : | The type hint set for window.

The `get_type_hint`() method returns the type hint set for a window.

### gtk.gdk.Window.set_type_hint

        def set_type_hint(hint)

`hint` : | a hint of the function this window will have

The `set_type_hint`() method provides the specified `hint` to the window manager about the functionality of a window. The window manager can use this information when determining the decoration and behavior of the window. The hint must be set before the window is mapped. The value of hint must be one of the GDK Window Type Hint Constants.

### gtk.gdk.Window.set_modal_hint

        def set_modal_hint(modal)

`modal` : | if `True` the window is modal.

The `set_modal_hint`() method sets the window's modal hint to the value specified by `modal`. If `modal` is `True` the window is modal. The window manager can use this information to handle modal windows in a special way which usually means that the window gets all the input for the application effectively blocking input to other windows in the application. . You should only use this on windows for which you have previously called the `set_transient_for`() method

### gtk.gdk.Window.set_skip_taskbar_hint

        def set_skip_taskbar_hint(modal)

`skip_taskbar` : | if `True` skip the taskbar.

### Note

This method is available in PyGTK 2.2 and above.

The `set_skip_taskbar_hint`() method sets the "skip_taskbar" setting to the value specified by `skips_taskbar`. If `skips_taskbar` is `True` the window should not appear in a task list or window list. If the window's semantic type as specified with the `set_type_hint()` method already fully describes the window, this method should not be called in addition; instead you should allow the window to be treated according to standard policy for its semantic type.

### gtk.gdk.Window.set_skip_pager_hint

        def set_skip_pager_hint(skips_pager)

`skips_pager` : | if `True` skip the pager

### Note

This method is available in PyGTK 2.2 and above.

The `set_skip_pager_hint`() method sets the "skip_pager" setting to the value of skips_pager. If skips_pager is True the window should not appear in a pager (a workspace switcher, or other desktop utility program that displays a small thumbnail representation of the windows on the desktop). If the window's semantic type as specified with `set_type_hint()` already fully describes the window, this method should not be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type.

### gtk.gdk.Window.set_geometry_hints

        def set_geometry_hints(min_width=-1, min_height=-1, max_width=-1, max_height=-1, base_width=-1, base_height=-1, width_inc=-1, height_inc=-1, min_aspect=-1.0, max_aspect=-1.0)

`min_width` : | minimum width of window or -1 to use requisition
`min_height` : | minimum height of window or -1 to use requisition
`max_width` : | maximum width of window or -1 to use requisition
`max_height` : | maximum height of window or -1 to use requisition
`base_width` : | allowed window widths are base_width + width_inc * N (where N is any integer) or -1
`base_height` : | allowed window widths are base_height + height_inc * N (where N is any integer) or -1
`width_inc` : | width resize increment
`height_inc` : | height resize increment
`min_aspect` : | minimum width/height ratio
`max_aspect` : | maximum width/height ratio

### Note

This method is available in PyGTK 2.2 and above.

The `set_geometry_hints`() method sets the geometry hints for the window.

This method provides hints to the windowing system about acceptable sizes for a toplevel window. The purpose of this is to constrain user resizing, but the windowing system will typically (but is not required to) also constrain the current size of the window to the provided values and constrain programmatic resizing via gdk_window_resize() or gdk_window_move_resize().

Note that on X11, this effect has no effect on windows of type GDK_WINDOW_TEMP or windows where override_redirect has been turned on via the `set_override_redirect`() method since these windows are not resizable by the user.

### gtk.gdk.Window.begin_paint_rect

        def begin_paint_rect(rectangle)

`rectangle` : | the rectangle you intend to draw to

The `begin_paint_rect`() method indicates that you are beginning the process of redrawing the area specified by `rectangle`. A backing store (off-screen buffer) large enough to contain `rectangle` will be created. The backing store will be initialized with the background color or background pixmap for window. Then, all drawing operations performed on the window will be diverted to the backing store. When you call the `end_paint`() method, the backing store will be copied to the window, making it visible on-screen. Only the part of window contained in region will be modified; that is, drawing operations are clipped to `rectangle`. The net result of all this is to remove flicker, because the user sees the finished product appear all at once when you call the `end_paint`() method. If you draw to window directly without calling the `begin_paint_rect`() method, the user may see flicker as individual drawing operations are performed in sequence. The clipping and background initializing features of the `begin_paint_rect`() are conveniences for the programmer, so you can avoid doing that work yourself.

### gtk.gdk.Window.begin_paint_region

        def begin_paint_region(region)

`region` : | the region you intend to draw to

### Note

This method is available in PyGTK 2.10 and above.

The `begin_paint_region`() method indicates that you are beginning the process of redrawing the `gtk.gdk.Region` specified by `region`. A backing store (off-screen buffer) large enough to contain `region` will be created. The backing store will be initialized with the background color or background pixmap for the window. Then, all drawing operations performed on the window will be diverted to the backing store. When you call the `end_paint`() method, the backing store will be copied to the window, making it visible on-screen. Only the part of the window contained in `region` will be modified; that is, drawing operations are clipped to `region`.

The net result of all this is to remove flicker, because the user sees the finished product appear all at once when you call the `end_paint`() method. If you draw to the window directly without calling the `begin_paint_region`() method, the user may see flicker as individual drawing operations are performed in sequence. The clipping and background initializing features of the `begin_paint_region`() method are conveniences for the programmer, so you can avoid doing that work yourself.

The widget system automatically places calls to the `begin_paint_region`() and `end_paint`() methods around emissions of the "expose_event" signal. That is, if you're writing an expose event handler, you can assume that the exposed area in a gtk.gdk.EXPOSE type `gtk.gdk.Event` has already been cleared to the window background, is already set as the clip region, and already has a backing store. Therefore in most cases, application code need not call the `begin_paint_region`() method. (You can disable the automatic calls around expose events on a widget-by-widget basis by calling `gtk.Widget.set_double_buffered`().)

If you call this method multiple times before calling the matching the `end_paint`() method, the backing stores are pushed onto a stack. The `end_paint`() method copies the topmost backing store on-screen, subtracts the topmost region from all other regions in the stack, and pops the stack. All drawing operations affect only the topmost backing store in the stack. One matching call to the `end_paint`() method is required for each call to the `begin_paint_region`() method.

### gtk.gdk.Window.end_paint

        def end_paint()

The `end_paint`() method indicates that the backing store created by the most recent call to the `begin_paint_rect`() method should be copied on-screen and deleted, leaving the next-most-recent backing store or no backing store at all as the active paint region. It is an error to call this function without a matching call to the `begin_paint_rect`() method first.

### gtk.gdk.Window.set_title

        def set_title(title)

`title` : | the new title of the window

The `set_title`() method sets the title of a toplevel window, to the string specified by `title`. If you haven't explicitly set the icon name for the window (using the `set_icon_name`() method), the icon name will be set to `title` as well. `title` must be in UTF-8 encoding (as with all user-readable strings in `PyGTK`).

### gtk.gdk.Window.set_role

        def set_role(role)

`role` : | a string indicating its role

The `set_role`() method sets the string specified by `role` as the window's role. When using `PyGTK`, you should generally use the `gtk.Window.set_role`() method instead of this low-level function. The window manager and session manager use a window's role to distinguish it from other kinds of window in the same application. When an application is restarted after being saved in a previous session, all windows with the same title and role are treated as interchangeable. So if you have two windows with the same title that should be distinguished for session management purposes, you should set the role on those windows. It doesn't matter what string you use for the role, as long as you have a different role for each non-interchangeable kind of window.

### gtk.gdk.Window.set_transient_for

        def set_transient_for(leader)

`leader` : | another `gtk.gdk.Window`

The `set_transient_for`() method indicates to the window manager that the window is a transient dialog associated with the application window `leader`. This allows the window manager to do things like center the window on `leader` and keep the window above `leader`. See the `gtk.Window.set_transient_for`() method if you're using a `gtk.Window` or `gtk.Dialog`.

### gtk.gdk.Window.set_background

        def set_background(color)

`color` : | an allocated `gtk.gdk.Color`

The `set_background`() method sets the background `gtk.gdk.Color` of the window to the value specified by `color`. (However, when using `PyGTK`, set the background of a widget with the `gtk.Widget.modify_bg`() method from an application - or the `gtk.Style.set_background`() method from a custom widget implementation.) The `color` must be allocated Also see the `set_back_pixmap`() method.

### gtk.gdk.Window.set_back_pixmap

        def set_back_pixmap(pixmap, parent_relative)

`pixmap` : | a `gtk.gdk.Pixmap`, or `None`
`parent_relative` : | if `True` the tiling origin is at the origin of the window's parent

The `set_back_pixmap`() method sets the background pixmap of the window to the value specified by `pixmap` A background pixmap will be tiled, positioning the first tile at the origin of the window, or if `parent_relative` is `True`, the tiling will be done based on the origin of the parent window (useful to align tiles in a parent with tiles in a child). If `pixmap` is `None` the window will have no background which means it will never have its background filled by the windowing system. Instead the window will contain whatever pixels were already in the corresponding area of the display. The windowing system will normally fill a window with its background when the window is obscured then exposed, and when you call the `clear`() method.

### gtk.gdk.Window.set_cursor

        def set_cursor(cursor)

`cursor` : | a `gtk.gdk.Cursor` or `None`

The `set_cursor`() method sets the mouse pointer for a `gtk.gdk.Window`. Use either the gtk.gdk.Cursor() or gtk.gdk.Cursor() constructors to create the cursor. To make the cursor invisible, use the gtk.gdk.Cursor() constructor to create a cursor with no pixels in it. Passing `None` for the `cursor` argument to the `set_cursor`() method means that the window will use the cursor of its parent window. Most windows should use this default.

### gtk.gdk.Window.get_geometry

        def get_geometry()

Returns : | a 5-tuple containing the X and Y coordinate of the location of the window relative to its parent and the width and height of the window and the bit depth of the window.

The `get_geometry`() method returns a 5-tuple containing the window's location and size (x, y, width, height) and the bit depth of the window. The X and Y coordinates returned are relative to the parent window of the window, which for toplevels usually means relative to the window decorations (titlebar, etc.) rather than relative to the root window (screen-size background window).

On the X11 platform, the geometry is obtained from the X server, so reflects the latest position of the window; this may be out-of-sync with the position of the window delivered in the most-recently-processed `GdkEventConfigure`. the `get_position`() method in contrast gets the position from the most recent configure event.

### gtk.gdk.Window.get_position

        def get_position()

Returns : | a 2-tuple containing the X and Y coordinates of the window location.

The `get_position`() returns a 2-tuple containing the position of the window as reported in the most-recently-processed `GdkEventConfigure`. By comparison with the `get_geometry`() method that queries the X server for the current window position, regardless of what events have been received or processed. The position coordinates are relative to the window's parent window.

### gtk.gdk.Window.get_origin

        def get_origin()

Returns : | a 2-tuple containing the X and Y coordinates of the window

The `get_origin`() method returns a 2-tuple containing the x and y coordinates of the position of a window in root window coordinates. (Compare this method with the `get_position`() and `get_geometry`() methods that return the position of a window relative to its parent window.)

### gtk.gdk.Window.get_root_origin

        def get_root_origin()

Returns : | a 2-tuple containing the X and Y coordinates of the window frame position

The `get_root_origin`() method returns a 2-tuple containing the top-left corner of the window manager frame in root window coordinates.

### gtk.gdk.Window.get_frame_extents

        def get_frame_extents()

Returns : | a `gtk.gdk.Rectangle` specifying the bounding box of the window frame

The `get_frame_extents`() method returns a `gtk.gdk.Rectangle` specifying the bounding box of the window, including window manager titlebar/borders if any. The frame position is given in root window coordinates. To get the position of the window itself (rather than the frame) in root window coordinates, use the `get_origin`() method.

### gtk.gdk.Window.get_pointer

        def get_pointer()

Returns : | a 3-tuple containing the X and Y coordinates of the mouse pointer and the modifier mask

The `get_pointer`() method returns a 3-tuple containing the coordinates of the mouse pointer location relative to the window and the modifier state. The modifier state is a combination of the GDK Modifier Constants.

### gtk.gdk.Window.get_parent

        def get_parent()

Returns : | the parent `gtk.gdk.Window` of the window

The `get_parent`() method returns the parent of the window as set when the `gtk.gdk.Window` was created or when the `reparent`() method was called.

### gtk.gdk.Window.get_toplevel

        def get_toplevel()

Returns : | the toplevel `gtk.gdk.Window` containing the window

The `get_toplevel`() method returns the toplevel `gtk.gdk.Window` that's an ancestor of the window.

### gtk.gdk.Window.get_children

        def get_children()

Returns : | the list of child windows inside the window

The `get_children`() method returns the list of children `gtk.gdk.Window` objects of the window. This method only returns children created via `PyGTK`, so for example it's useless when used with the root window; it only returns windows an application created itself.

### gtk.gdk.Window.get_events

        def get_events()

Returns : | the event mask for the window

The `get_events`() method returns the event mask for the window. See the `set_events`() method for more detail.

### gtk.gdk.Window.set_events

        def set_events(event_mask)

`event_mask` : | the event mask for the window

The `set_events`() method sets the event mask to the value specified by event_mask for the window. The event mask determines which events will be reported for the window. For example, an event mask including `gtk.gdk.BUTTON_PRESS_MASK` means the window should report button press events. The event mask is the bitwise OR of the GDK Event Mask Flag Constants.

### gtk.gdk.Window.set_icon_list

        def set_icon_list(pixbufs)

`pixbufs` : | a list (or tuple) containing pixbufs, of different sizes.

### Note

This method is available in PyGTK 2.2 and above.

The `set_icon_list`() method sets the list of icons for the window. pixbufs is a list or tuple containing `gtk.gdk.Pixbuf` objects to be used as the icon images. One of these will be used to represent the window when it has been iconified. The icon is usually shown in an icon box or some sort of task bar. Which icon size is shown depends on the window manager. The window manager can scale the icon but setting several size icons can give better image quality since the window manager may only need to scale the icon by a small amount or not at all.

### gtk.gdk.Window.set_icon

        def set_icon(icon_window, pixmap, mask)

`icon_window` : | a `gtk.gdk.Window` to use for the icon
`pixmap` : | a `gtk.gdk.Pixmap` to use as the icon
`mask` : | a 1-bit pixmap (`GdkBitmap`) to use as mask for `pixmap`

The `set_icon`() method sets the icon of the window as a `gtk.gdk.Pixmap` (specified by `pixmap`) or `gtk.gdk.Window` specified by `icon_window`). Investigate the `gtk.window_set_default_icon_list()`() function first, and then the `gtk.Window.set_icon_list`() and `gtk.Window.set_icon`() methods. If those don't meet your needs, look at the `set_icon_list`() method. Only if all those are too high-level do you want to fall back to the `set_icon`().

### gtk.gdk.Window.set_icon_name

        def set_icon_name(name)

`name` : | the name of the window while iconified (minimized)

The `set_icon_name`() method sets the name of the window when it is iconified to the value of `name`. Windows may have a name used while minimized, distinct from the name they display in their titlebar. Most of the time this is a bad idea from a user interface standpoint. But you can set such a name with this method, if you like.

### gtk.gdk.Window.set_group

        def set_group(leader)

`leader` : | the group leader `gtk.gdk.Window`

The `set_group`() method sets the group leader for the window to the `gtk.gdk.Window` specified by `leader`. By default, the group leader for all toplevel windows is set to a global window implicitly created by `PyGTK`. With this method you can override this default. The group leader window allows the window manager to distinguish all windows that belong to a single application. It may for example allow users to minimize or unminimize all windows belonging to an application at once. You should only set a non-default group window if your application pretends to be multiple applications. The group leader window may not be changed after a window has been mapped (with the `show`() method for example).

### gtk.gdk.Window.get_group

        def get_group()

Returns : | the group leader `gtk.gdk.Window` for the window

### Note

This method is available in PyGTK 2.4 and above.

The `get_group`() method returns the group leader `gtk.gdk.Window` for the window. See the `set_group()` method for more information.

### gtk.gdk.Window.set_decorations

        def set_decorations(decorations)

`decorations` : | the decoration hint mask

The `set_decorations`() method sets the specified decorations for the window. "Decorations" are the features the window manager adds to a toplevel `gtk.gdk.Window`. This method sets the traditional Motif window manager hints that tell the window manager which decorations you would like your window to have. Usually you should use the `gtk.Window.set_decorated`() method on a `gtk.Window` instead of using this method directly. The value of `decorations` is the logical OR of the GDK WM Decoration Constants.

### gtk.gdk.Window.get_decorations

        def get_decorations()

Returns : | the window decorations

The `get_decorations`() method returns the decorations set on the window with the `set_decorations` method.

### gtk.gdk.Window.set_functions

        def set_functions(functions)

`functions` : | the bitmask of operations to allow on the window

The `set_functions`() method sets the traditional Motif window manager hint for which operations the window manager should allow on a toplevel window. However, few window managers do anything reliable or interesting with this hint. Many ignore it entirely. The `functions` argument is the logical OR of the GDK WM Function Constants.

### gtk.gdk.Window.iconify

        def iconify()

The `iconify`() method asks the window manager to iconify (minimize) the window. The window manager may choose to ignore the request, but normally will honor it. Using the `gtk.Window.iconify`() method is preferred, if you have a `gtk.Window` widget.

### gtk.gdk.Window.deiconify

        def deiconify()

The `deiconify`() method asks the window manager to deiconify (unminimize) the window. On X11 the window manager may choose to ignore the request to deiconify. Using the `gtk.Window.deiconify`() method is preferred. Or better yet, use the `gtk.Window.present`(), which raises the window, focuses it, unminimizes it, and puts it on the current desktop.

### gtk.gdk.Window.stick

        def stick()

The `stick`() method "pins" a window such that it's on all workspaces and does not scroll with viewports, for window managers that have scrollable viewports. (When using a `gtk.Window`, the `gtk.Window.stick`() method may be more useful.) On the X11 platform, this method depends on window manager support, so may have no effect with many window managers. However, `PyGTK` will do the best it can to convince the window manager to stick the window. For window managers that don't support this operation, there's nothing you can do to force it to happen.

### gtk.gdk.Window.unstick

        def unstick()

The `unstick`() method reverses the effect of the `stick`() method. See the `stick`() and `gtk.Window.unstick`() methods for more information.

### gtk.gdk.Window.maximize

        def maximize()

The `maximize`() method asks the window manager to maximize the window, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "maximized"; so you can't rely on the maximization actually happening. But it will happen with most standard window managers. If the window was already maximized, then this method does nothing.

### gtk.gdk.Window.unmaximize

        def unmaximize()

The `unmaximize`() method asks the window manager to unmaximize the window, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "maximized"; so you can't rely on the unmaximization actually happening. But it will happen with most standard window managers. If the window wasn't maximized, then this method does nothing.

### gtk.gdk.Window.fullscreen

        def fullscreen()

### Note

This method is available in PyGTK 2.2 and above.

The `fullscreen`() method moves the window into fullscreen mode. This means the window covers the entire screen and is above any panels or task bars.

If the window was already fullscreen, then this method does nothing.

On X11, asks the window manager to put the window in a fullscreen state, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "fullscreen" but most standard window managers do.

### gtk.gdk.Window.unfullscreen

        def unfullscreen()

### Note

This method is available in PyGTK 2.2 and above.

The `unfullscreen`() method moves the window out of fullscreen mode. If the window was not fullscreen, does nothing.

On X11, asks the window manager to move the window out of the fullscreen state, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "fullscreen" but most standard window managers do.

### gtk.gdk.Window.register_dnd

        def register_dnd()

The `register_dnd`() method registers the window as a potential drop destination.

### gtk.gdk.Window.begin_resize_drag

        def begin_resize_drag(edge, button, root_x, root_y, timestamp)

`edge` : | the edge or corner from which the drag is started
`button` : | the mouse button being used to drag
`root_x` : | the root window X coordinate of the mouse click that began the drag
`root_y` : | the root window Y coordinate of the mouse click that began the drag
`timestamp` : | the timestamp of the mouse click that began the drag (use the `gtk.gdk.Event.get_time`() method)

The `begin_resize_drag`() method begins a window resize operation (for a toplevel `gtk.gdk.Window`) from the specified `edge` using the specified `button` starting at the location specified by `root_x` and `root_y`. The value of edge must be one of the GDK Window Edge Constants.

You might use this method to implement a "window resize grip," for example; in fact the `gtk.Statusbar` uses it. The method works best with window managers that support the Extended Window Manager Hints spec (see http://www.freedesktop.org), but has a fallback implementation for other window managers.

### gtk.gdk.Window.begin_move_drag

        def begin_move_drag(button, root_x, root_y, timestamp)

`button` : | the button being used to drag
`root_x` : | the root window X coordinate of the mouse click that began the drag
`root_y` : | the root window Y coordinate of the mouse click that began the drag
`timestamp` : | the timestamp of the mouse click that began the drag

The `begin_move_drag`() method begins a window move operation (for a toplevel window) using the specified `button` starting at the location specified by `root_x` and `root_y`. You might use this method to implement a "window move grip," for example. The method works best with window managers that support the Extended Window Manager Hints spec (see http://www.freedesktop.org), but has a fallback implementation for other window managers.

### gtk.gdk.Window.invalidate_rect

        def invalidate_rect(rect, invalidate_children)

`rect` : | the rectangle to invalidate
`invalidate_children` : | if `True` invalidate child `gtk.gdk.Window` objects

The `invalidate_rect`() method invalidates the rectangular region specified by rect. If `invalidate_children` is `True` the child `gtk.gdk.Window` object of the window are also invalidated.

### gtk.gdk.Window.invalidate_region

        def invalidate_region(region, invalidate_children)

`region` : | a `gtk.gdk.Region`
`invalidate_children` : | If `True` also invalidate child windows

### Note

This method is available in PyGTK 2.10 and above.

The `invalidate_region`() method adds the `gtk.gdk.Region` specified by `region` to the update area for the window. The update area is the region that needs to be redrawn, or the "dirty region." The call to the `process_updates`() method sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of the window in response to those expose events.

PyGTK will call the `gtk.gdk.window_process_all_updates`() method on your behalf whenever your program returns to the main loop and becomes idle, so normally there's no need to do that manually, you just need to invalidate regions that you know should be redrawn.

The `invalidate_children` parameter controls whether the region of each child window that intersects `region` will also be invalidated. If `False`, then the update area for child windows will remain unaffected.

### gtk.gdk.Window.get_update_area

        def get_update_area()

Returns : | a `gtk.gdk.Region` conatining the update area for the window

### Note

This method is available in PyGTK 2.10 and above.

The `get_update_area`() method returns a `gtk.gdk.Region` containing the update area and transfers ownership of the update area from the window to the caller of the method. That is, after calling this method, the window will no longer have an invalid/dirty region; the update area is removed from the window and passed in the returned `gtk.gdk.Region`. If a window has no update area, the `get_update_area()` method returns `None`.

### gtk.gdk.Window.freeze_updates

        def freeze_updates()

The `freeze_updates`() method temporarily freezes the window such that it won't receive expose events. The window will begin receiving expose events again when the `thaw_updates`() method is called. If the `freeze_updates`() method has been called more than once, the `thaw_updates`() method must be called an equal number of times to begin processing exposes.

### gtk.gdk.Window.thaw_updates

        def thaw_updates()

The `thaw_updates`() method thaws a window frozen with the `freeze_updates`() method.

### gtk.gdk.Window.process_updates

        def process_updates(update_children)

`update_children` : | if `True` process updates for child windows

The `process_updates`() method sends one or more expose events to the window. The areas in each expose event will cover the entire update area for the window (see the `invalidate_rect`() method for details). Normally `PyGTK` calls the `gtk.gdk.window_process_all_updates`() function on your behalf, so there's no need to call this method unless you want to force expose events to be delivered immediately and synchronously (vs. the usual case, where `PyGTK` delivers them in an idle handler). Occasionally this is useful to produce nicer scrolling behavior, for example.

### gtk.gdk.Window.set_accept_focus

        def set_accept_focus(accept_focus)

`accept_focus` : | if `True`, the window should receive input focus

### Note

This method is available in PyGTK 2.4 and above.

The `set_accept_focus`() method sets the "accept_focus setting to the value of `accept_focus`. If `accept_focus` is `True` the window will accept focus; if `False` hints to the desktop environment that the window doesn't want to receive input focus.

On X, it is the responsibility of the window manager to interpret this hint. ICCCM-compliant window manager usually respect it.

### gtk.gdk.Window.enable_synchronized_configure

        def enable_synchronized_configure()

### Note

This method is available in PyGTK 2.6 and above.

The `enable_synchronized_configure`() method indicates that the application will cooperate with the window system in synchronizing the window repaint with the window manager during resizing operations. After an application calls this method, it must call the `configure_finished`() method every time it has finished all processing associated with a set of Configure events. Toplevel GTK+ windows automatically use this protocol.

On X, calling this function makes window participate in the _NET_WM_SYNC_REQUEST window manager protocol.

### gtk.gdk.Window.configure_finished

        def configure_finished()

### Note

This method is available in PyGTK 2.6 and above.

The `configure_finished`() method signals to the window system that the application has finished handling all the Configure events it has received. Window Managers can use this to better synchronize the frame repaint with the application. GTK+ applications will automatically call this function when appropriate.

This function can only be called if the `enable_synchronized_configure`() method was called previously.

### gtk.gdk.Window.set_focus_on_map

        def set_focus_on_map(focus_on_map)

`focus_on_map` : | if `True` the window should receive input focus when mapped.

### Note

This method is available in PyGTK 2.6 and above.

The `set_focus_on_map`() method sets the a hint for the desktop environment to the value specified by `focus_on_map`. If `focus_on_map` is `True` the window sets a hint for the desktop environment indicating that it would like to receive input focus when mapped.

On X, it is the responsibility of the window manager to interpret this hint. Window managers following the freedesktop.org window manager extension specification should respect it.

### gtk.gdk.Window.set_urgency_hint

        def set_urgency_hint(urgent)

`urgent` : | if `True` the window requires urgent user attention.

### Note

This method is available in PyGTK 2.10 and above.

The `set_urgency_hint`() method sets the a hint for the desktop environment to the value specified by `urgent`. If `urgent` is `True` the window sets a hint for the desktop environment indicating that it needs urgent user attention.

### gtk.gdk.Window.move_region

        def move_region(region, dx, dy)

`region` : | the `gtk.gdk.Region` to move
`dx` : | the distance to move horizontally
`dy` : | the distance to move vertically

### Note

This method is available in PyGTK 2.10 and above.

The `move_region`() method moves the part of window indicated by the `gtk.gdk.Region` specified by `region` by `dy` pixels in the Y direction and `dx` pixels in the X direction. The portions of `region` that are not covered by the new position of `region` are invalidated.

### gtk.gdk.Window.shape_combine_region

        def shape_combine_region(shape_region, offset_x, offset_y)

`shape_region` : | the region of the window to leave opaque
`offset_x` : | X position of `shape_region` in window coordinates
`offset_y` : | Y position of `shape_region` in window coordinates

### Note

This method is available in PyGTK 2.10 and above.

The `shape_combine_region`() method makes pixels in the window outside of the `gtk.gdk.Region` specified by `shape_region` transparent, so that the window may be nonrectangular. See the `shape_combine_mask`() method to use a bitmap as the mask.

If `shape_region` is `None`, the shape will be unset, so the whole window will be opaque again. `offset_x` and `offset_y` are ignored if `shape_region` is `None`.

This method works on both toplevel and child windows.

On the X11 platform, this uses an X server extension which is widely available on most common platforms, but not available on very old X servers, and occasionally the implementation will be buggy. On servers without the shape extension, this method will do nothing.

### gtk.gdk.Window.input_shape_combine_mask

        def input_shape_combine_mask(mask, x, y)

`mask` : | the shape bitmap mask
`x` : | the X position of shape mask with respect to the window
`y` : | the Y position of shape mask with respect to the window

### Note

This method is available in PyGTK 2.10 and above.

The `input_shape_combine_mask`() method is similar to the `shape_combine_mask`() method but the shape applies only to event handling. Mouse events which happen while the pointer position corresponds to an unset bit in the mask will be passed onto the window below this window.

An input shape is typically used with RGBA windows. The alpha channel of the window defines which pixels are invisible and allows for nicely antialiased borders, and the input shape controls where the window is "clickable".

On the X11 platform, this requires version 1.1 of the shape extension.

### gtk.gdk.Window.input_shape_combine_region

        def input_shape_combine_region(shape_region, offset_x, offset_y)

`shape_region` : | the region of the window to leave opaque
`offset_x` : | X position of `shape_region` in window coordinates
`offset_y` : | Y position of `shape_region` in window coordinates

### Note

This method is available in PyGTK 2.10 and above.

The `input_shape_combine_region`() method is similar to the `shape_combine_region`() method, but the shape applies only to event handling. Mouse events which happen while the pointer position corresponds to an unset bit in `shape_region` will be passed onto the window below this window.

An input shape is typically used with RGBA windows. The alpha channel of the window defines which pixels are invisible and allows for nicely antialiased borders, and the input shape controls where the window is "clickable".

On the X11 platform, this requires version 1.1 of the shape extension.

### gtk.gdk.Window.beep

        def beep()

### Note

This method is available in PyGTK 2.12 and above.

Emits a short beep associated to window in the appropriate display, if supported. Otherwise, emits a short beep on the display just as `gtk.gdk.Display.beep`().

### gtk.gdk.Window.set_composited

        def set_composited(composited)

`composited` : | `True` to set the window as composited

### Note

This method is available in PyGTK 2.12 and above.

Sets a GdkWindow as composited, or unsets it. Composited windows do not automatically have their contents drawn to the screen. Drawing is redirected to an offscreen buffer and an expose event is emitted on the parent of the composited window. It is the responsibility of the parent's expose handler to manually merge the off-screen content onto the screen in whatever way it sees fit.

It only makes sense for child windows to be composited; see `gtk.gdk.Window.set_opacity`() if you need translucent toplevel windows.

An additional effect of this call is that the area of this window is no longer clipped from regions marked for invalidation on its parent. Draws done on the parent window are also no longer clipped by the child.

This call is only supported on some systems (currently, only X11 with new enough Xcomposite and Xdamage extensions). You must call `gtk.gdk.Display.supports_composite`() to check if setting a window as composited is supported before attempting to do so.

### gtk.gdk.Window.set_opacity

        def set_opacity(opacity)

`opacity` : | The opacity value.

### Note

This method is available in PyGTK 2.12 and above.

Request the windowing system to make window partially transparent, with opacity 0 being fully transparent and 1 fully opaque. Values of the opacity parameter are clamped to the [0,1] range.)

On X11, this works only on X screens with a compositing manager running.

For setting up per-pixel alpha, see `gtk.gdk.Screen.get_rgba_colormap`(). For making non-toplevel windows translucent, see `gtk.gdk.Window.set_composited`().

### gtk.gdk.Window.set_startup_id

        def set_startup_id(startup_id)

`startup_id` : | A string with startup-notification identifier.

### Note

This method is available in PyGTK 2.12 and above.

When using GTK+, typically you should use `gtk.Window.set_startup_id`() instead of this low-level function.

### gtk.gdk.Window.remove_redirection

        def remove_redirection()

### Note

This method is available in PyGTK 2.14 and above.

When using GTK+, typically you should use `gtk.Window.set_startup_id`() instead of this low-level function.

## Functions

### gtk.gdk.window_foreign_new

        def gtk.gdk.window_foreign_new(anid)

`anid` : | a native window system ID
Returns : | the new `gtk.gdk.Window` wrapper for the native window or `None` if the window has been destroyed.

The `gtk.gdk.window_foreign_new`() function wraps a native window specified by `anid` for the default display in a `gtk.gdk.Window`. This may fail if the window has been destroyed. For example in the X Window System backend, a native window handle is an Xlib `XID`.

### gtk.gdk.window_foreign_new_for_display

        def gtk.gdk.window_foreign_new_for_display(display, anid)

`display` : | a `gtk.gdk.Display`
`anid` : | a native window system ID
Returns : | the new `gtk.gdk.Window` wrapper for the native window or `None` if the window has been destroyed.

### Note

This function is available in PyGTK 2.2 and above.

The `gtk.gdk.window_foreign_new_for_display`() function wraps a native window specified by `anid` for the `gtk.gdk.Display` specified by `display` in a `gtk.gdk.Window`. This may fail if the window has been destroyed. For example in the X Window System backend, a native window handle is an Xlib `XID`.

### gtk.gdk.get_default_root_window

        def gtk.gdk.get_default_root_window()

Returns : | the default root `gtk.gdk.Window`

The `gtk.gdk.get_default_root_window`() function returns the root `gtk.gdk.Window` (the parent window that all other windows are inside) for the default display and screen.

### gtk.gdk.window_get_toplevels

        def gtk.gdk.window_get_toplevels()

Returns : | a list containing the toplevel `gtk.gdk.Window` object

The `gtk.gdk.window_get_toplevels`() function returns a list of all toplevel windows known to `PyGTK` on the default screen. A toplevel window is a child of the root window (see the gtk.gdk.get_default_root_window() function).

### gtk.gdk.window_lookup

        def gtk.gdk.window_lookup(anid)

`anid` : | a native window system ID
Returns : | the `gtk.gdk.Window` wrapper for the native window or `None` if there is none.

The `gtk.gdk.window_lookup`() function looks up the `gtk.gdk.Window` that wraps the native window handle specified by `anid`. For example in the X Window System backend, a native window handle is an Xlib `XID`.

### gtk.gdk.window_lookup_for_display

        def gtk.gdk.window_lookup_for_display(display, anid)

`display` : | a `gtk.gdk.Display`
`anid` : | a native window system ID
Returns : | the `gtk.gdk.Window` wrapper for the native window or `None` if there is none.

### Note

This function is available in PyGTK 2.2 and above.

The `gtk.gdk.window_lookup_for_display`() function looks up the `gtk.gdk.Window` that wraps the native window handle specified by `anid` for the `gtk.gdk.Display` specified by `display`. For example in the X Window System backend, a native window handle is an Xlib `XID`.

### gtk.gdk.window_process_all_updates

        def gtk.gdk.window_process_all_updates()

The `gtk.gdk.process_all_updates`() function calls the `process_updates`() method for each `gtk.gdk.Window` in the application.

### gtk.gdk.gdk_window_set_debug_updates

        def gtk.gdk.gdk_window_set_debug_updates(setting)

`setting` : | if `True` enable update debugging

The `gtk.gdk.gdk_set_debug_updates`() function sets the update debugging flag to the value of `setting`. If `setting` is `True`, update debugging is enabled. With update debugging enabled, calls to the `invalidate_rect`() method clear the invalidated rectangle of the screen to a noticeable color, and `PyGTK` pauses for a short time before sending exposes to windows during the `process_updates`() method. The net effect is that you can see the invalid region for each window and watch redraws as they occur. This allows you to diagnose inefficiencies in your application.In essence, because the `GDK` rendering model prevents all flicker, if you are redrawing the same region 400 times you may never notice, aside from noticing a speed problem. Enabling update debugging causes `PyGTK` to flicker slowly and noticeably, so you can see exactly what's being redrawn when, in what order.

The `--gtk-debug=updates` command line option passed to `PyGTK` programs enables this debug option at application startup time. That's usually more useful than calling `gtk.gdk.gdk_set_debug_updates`() yourself, though you might want to use this function to enable updates sometime after application startup time.

### gtk.gdk.window_at_pointer

        def gtk.gdk.window_at_pointer()

Returns : | a 3 tuple containing the `gtk.gdk.Window` and the pointer location in the window or `None`.

### Note

This function is available in PyGTK 2.4 and above.

The `gtk.gdk.window_at_pointer`() function returns a 3-tuple containing the `gtk.gdk.Window` underneath the mouse pointer, and the location of the pointer in the window. This function returns `None` if the window under the mouse pointer is not known to GDK (if the window belongs to another application and a `gtk.gdk.Window` hasn't been created for it with the `gtk.gdk.window_foreign_new`() function)

### Note

For multi-head-aware widgets or applications use the `gtk.gdk.Display.get_window_at_pointer`() method instead.

Prev | Up | Next
gtk.gdk.Visual | Home | gtk.gdk Functions