path: root/docs/reference/pygtk-gdkwindow.xml

<?xml version="1.0" standalone="no"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
    "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd">

<refentry id="class-gdkwindow">
  <refnamediv>
    <refname>gtk.gdk.Window</refname>
    <refpurpose>onscreen display areas in the target window
system</refpurpose>
  </refnamediv>

  <refsect1>
    <title>Synopsis</title>

    <classsynopsis language="python">
      <ooclass><classname>gtk.gdk.Window</classname></ooclass>
      <ooclass><classname><link
linkend="class-gdkdrawable">gtk.gdk.Drawable</link></classname></ooclass>

      <constructorsynopsis language="python">
	<methodname><link
linkend="constructor-gdkwindow">gtk.gdk.Window</link></methodname>
	<methodparam><parameter
		       role="keyword">parent</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">width</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">height</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">window_type</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">event_mask</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">wclass</parameter></methodparam>
	<methodparam><parameter role="keyword">title</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">x</parameter>
	  <initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">y</parameter>
	  <initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">visual</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">colormap</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">cursor</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">wmclass_name</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">wmclass_class</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">override_redirect</parameter>
	  <initializer>-1</initializer></methodparam>
      </constructorsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--drag-begin">drag_begin</link></methodname>
	<methodparam><parameter
		       role="keyword">targets</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--input-set-extension-events">input_set_extension_events</link></methodname>
	<methodparam><parameter
		       role="keyword">mask</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">mode</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--property-get">property_get</link></methodname>
	<methodparam><parameter
		       role="keyword">property</parameter></methodparam>
	<methodparam><parameter role="keyword">type</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">pdelete</parameter>
	  <initializer>FALSE</initializer></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--property-change">property_change</link></methodname>
	<methodparam><parameter
		       role="keyword">property</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">type</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">format</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">mode</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">data</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--property-delete">property_delete</link></methodname>
	<methodparam><parameter
		       role="keyword">property</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--selection-convert">selection_convert</link></methodname>
	<methodparam><parameter
		       role="keyword">selection</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">target</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">time</parameter></methodparam>
      </methodsynopsis>

<!-- NOT IMPLEMENTED
<methodsynopsis language="python">
    <methodname><link linkend="method-gdkwindow- -selection-property-get">selection_property_get</link></methodname>
    <methodparam><parameter role="keyword">data</parameter></methodparam>
    <methodparam><parameter role="keyword">prop_type</parameter></methodparam>
    <methodparam><parameter role="keyword">prop_format</parameter></methodparam>
  </methodsynopsis>
END NOT IMPLEMENTED -->

      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--set-keep-above">set_keep_above</link></methodname>
	<methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--set-keep-below">set_keep_below</link></methodname>
	<methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--destroy">destroy</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-window-type">get_window_type</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--show">show</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--hide">hide</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--withdraw">withdraw</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--move">move</link></methodname>
	<methodparam><parameter role="keyword">x</parameter></methodparam>
	<methodparam><parameter role="keyword">y</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--resize">resize</link></methodname>
	<methodparam><parameter
		       role="keyword">width</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">height</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--move-resize">move_resize</link></methodname>
	<methodparam><parameter role="keyword">x</parameter></methodparam>
	<methodparam><parameter role="keyword">y</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">width</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">height</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--reparent">reparent</link></methodname>
	<methodparam><parameter
		       role="keyword">new_parent</parameter></methodparam>
	<methodparam><parameter role="keyword">x</parameter></methodparam>
	<methodparam><parameter role="keyword">y</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--clear">clear</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--clear-area">clear_area</link></methodname>
	<methodparam><parameter role="keyword">x</parameter></methodparam>
	<methodparam><parameter role="keyword">y</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">width</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">height</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--clear-area-e">clear_area_e</link></methodname>
	<methodparam><parameter role="keyword">x</parameter></methodparam>
	<methodparam><parameter role="keyword">y</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">width</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">height</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--raise_">raise_</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--lower">lower</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--focus">focus</link></methodname>
	<methodparam><parameter role="keyword">timestamp</parameter>
	  <initializer>0L</initializer></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gdkwindow--set-user-data">set_user_data</link></methodname>
        <methodparam><parameter role="keyword">user_data</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gdkwindow--get-user-data">get_user_data</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-override-redirect">set_override_redirect</link></methodname>
	<methodparam><parameter
		       role="keyword">override_redirect</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gdkwindow--add-filter">add_filter</link></methodname>
        <methodparam><parameter role="keyword">function</parameter></methodparam>
        <methodparam><parameter role="keyword">data</parameter><initializer>None</initializer></methodparam>
      </methodsynopsis>

<!-- NOT IMPLEMENTED
      <methodsynopsis language="python">
        <methodname><link linkend="method-gdkwindow- -remove-filter">remove_filter</link></methodname>
        <methodparam><parameter role="keyword">function</parameter></methodparam>
        <methodparam><parameter role="keyword">data</parameter></methodparam>
      </methodsynopsis>
END NOT IMPLEMENTED -->

      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--scroll">scroll</link></methodname>
	<methodparam><parameter role="keyword">dx</parameter></methodparam>
	<methodparam><parameter role="keyword">dy</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--shape-combine-mask">shape_combine_mask</link></methodname>
	<methodparam><parameter
		       role="keyword">shape_mask</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">offset_x</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">offset_y</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-child-shapes">set_child_shapes</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--merge-child-shapes">merge_child_shapes</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--is-visible">is_visible</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--is-viewable">is_viewable</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-state">get_state</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-static-gravities">set_static_gravities</link></methodname>
	<methodparam><parameter
		       role="keyword">use_static</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-type-hint">set_type_hint</link></methodname>
	<methodparam><parameter
		       role="keyword">hint</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-modal-hint">set_modal_hint</link></methodname>
	<methodparam><parameter
		       role="keyword">modal</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--set-skip-taskbar-hint">set_skip_taskbar_hint</link></methodname>
	<methodparam><parameter
		       role="keyword">skips_taskbar</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--set-skip-pager-hint">set_skip_pager_hint</link></methodname>
	<methodparam><parameter
		       role="keyword">skips_pager</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--set-geometry-hints">set_geometry_hints</link></methodname>
	<methodparam><parameter role="keyword">min_width</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">min_height</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">max_width</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">max_height</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">base_width</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">base_height</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">width_inc</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">height_inc</parameter><initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">min_aspect</parameter><initializer>-1.0</initializer></methodparam>
	<methodparam><parameter role="keyword">max_aspect</parameter><initializer>-1.0</initializer></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--begin-paint-rect">begin_paint_rect</link></methodname>
	<methodparam><parameter
		       role="keyword">rectangle</parameter></methodparam>
      </methodsynopsis>

<!-- NOT IMPLEMENTED
<methodsynopsis language="python">
    <methodname><link linkend="method-gdkwindow- -begin-paint-region">begin_paint_region</link></methodname>
    <methodparam><parameter role="keyword">region</parameter></methodparam>
  </methodsynopsis>
END NOT IMPLEMENTED -->

      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--end-paint">end_paint</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-title">set_title</link></methodname>
	<methodparam><parameter
		       role="keyword">title</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-role">set_role</link></methodname>
	<methodparam><parameter
		       role="keyword">role</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-transient-for">set_transient_for</link></methodname>
	<methodparam><parameter
		       role="keyword">leader</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-background">set_background</link></methodname>
	<methodparam><parameter
		       role="keyword">color</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-back-pixmap">set_back_pixmap</link></methodname>
	<methodparam><parameter
		       role="keyword">pixmap</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">parent_relative</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-cursor">set_cursor</link></methodname>
	<methodparam><parameter
		       role="keyword">cursor</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-geometry">get_geometry</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-position">get_position</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-origin">get_origin</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-root-origin">get_root_origin</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-frame-extents">get_frame_extents</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-pointer">get_pointer</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-parent">get_parent</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-toplevel">get_toplevel</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-children">get_children</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-events">get_events</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-events">set_events</link></methodname>
	<methodparam><parameter
		       role="keyword">event_mask</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--set-icon-list">set_icon_list</link></methodname>
	<methodparam><parameter role="keyword">pixbufs</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-icon">set_icon</link></methodname>
	<methodparam><parameter
		       role="keyword">icon_window</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">pixmap</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">mask</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-icon-name">set_icon_name</link></methodname>
	<methodparam><parameter
		       role="keyword">name</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-group">set_group</link></methodname>
	<methodparam><parameter
		       role="keyword">leader</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-group">get_group</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-decorations">set_decorations</link></methodname>
	<methodparam><parameter
		       role="keyword">decorations</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--get-decorations">get_decorations</link></methodname>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--set-functions">set_functions</link></methodname>
	<methodparam><parameter
		       role="keyword">functions</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--iconify">iconify</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--deiconify">deiconify</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--stick">stick</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--unstick">unstick</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--maximize">maximize</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--unmaximize">unmaximize</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--fullscreen">fullscreen</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--unfullscreen">unfullscreen</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--register-dnd">register_dnd</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--begin-resize-drag">begin_resize_drag</link></methodname>
	<methodparam><parameter
		       role="keyword">edge</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">button</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">root_x</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">root_y</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">timestamp</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--begin-move-drag">begin_move_drag</link></methodname>
	<methodparam><parameter
		       role="keyword">button</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">root_x</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">root_y</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">timestamp</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--invalidate-rect">invalidate_rect</link></methodname>
	<methodparam><parameter
		       role="keyword">rect</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">invalidate_children</parameter></methodparam>
      </methodsynopsis>

<!-- NOT IMPLEMENTED
<methodsynopsis language="python">
    <methodname><link linkend="method-gdkwindow- -invalidate-region">invalidate_region</link></methodname>
    <methodparam><parameter role="keyword">region</parameter></methodparam>
    <methodparam><parameter role="keyword">invalidate_children</parameter></methodparam>
  </methodsynopsis>
<methodsynopsis language="python">
    <methodname><link linkend="method-gdkwindow- -invalidate-maybe-recurse">invalidate_maybe_recurse</link></methodname>
    <methodparam><parameter role="keyword">region</parameter></methodparam>
    <methodparam><parameter role="keyword">(*child_func</parameter></methodparam>
  </methodsynopsis>
<methodsynopsis language="python">
    <methodname><link linkend="method-gdkwindow- -get-update-area">get_update_area</link></methodname>
    <methodparam></methodparam>
      </methodsynopsis>
END NOT IMPLEMENTED -->

      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--freeze-updates">freeze_updates</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--thaw-updates">thaw_updates</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
	<methodname><link
linkend="method-gdkwindow--process-updates">process_updates</link></methodname>
	<methodparam><parameter
		       role="keyword">update_children</parameter></methodparam>
      </methodsynopsis>

<!-- NOT IMPLEMENTED
<methodsynopsis language="python">
    <methodname><link linkend="method-gdkwindow- -get-internal-paint-info">get_internal_paint_info</link></methodname>
    <methodparam><parameter role="keyword">real_drawable</parameter></methodparam>
    <methodparam><parameter role="keyword">x_offset</parameter></methodparam>
    <methodparam><parameter role="keyword">y_offset</parameter></methodparam>
  </methodsynopsis>
END NOT IMPLEMENTED -->

      <methodsynopsis language="python">
	<methodname><link linkend="method-gdkwindow--set-accept-focus">set_accept_focus</link></methodname>
	<methodparam><parameter role="keyword">accept_focus</parameter></methodparam>
      </methodsynopsis>
    </classsynopsis>

    <programlisting>
<emphasis role="bold">Functions</emphasis>

<methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--window-foreign-new">gtk.gdk.window_foreign_new</link></methodname>
	<methodparam><parameter
		       role="keyword">anid</parameter></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--window-foreign-new-for-display">gtk.gdk.window_foreign_new_for_display</link></methodname>
	<methodparam><parameter
		       role="keyword">display</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">anid</parameter></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--get-default-root-window">gtk.gdk.get_default_root_window</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--window-get-toplevels">gtk.gdk.window_get_toplevels</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--window-lookup">gtk.gdk.window_lookup</link></methodname>
	<methodparam><parameter
		       role="keyword">anid</parameter></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--window-lookup-for-display">gtk.gdk.window_lookup_for_display</link></methodname>
	<methodparam><parameter
		       role="keyword">display</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">anid</parameter></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--window-process-all-updates">gtk.gdk.window_process_all_updates</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--gdk-window-set-debug-updates">gtk.gdk.gdk_window_set_debug_updates</link></methodname>
	<methodparam><parameter
		       role="keyword">setting</parameter></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gdk--window-at-pointer">gtk.gdk.window_at_pointer</link></methodname>
      </methodsynopsis></programlisting>

  </refsect1>

  <refsect1>
    <title>Ancestry</title>

<synopsis>+-- <link linkend="class-gobject">gobject.GObject</link>
  +-- <link linkend="class-gdkdrawable">gtk.gdk.Drawable</link>
    +-- <link linkend="class-gdkwindow">gtk.gdk.Window</link>
</synopsis>

  </refsect1>

  <refsect1>
    <title>Description</title>

    <para> <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> is a
rectangular region on the screen. It's a low-level object, used to implement
high-level objects such as <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> and <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>. A <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> is a
toplevel window, the object a user might think of as a "window" with a
titlebar and so on. A <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> may
contain several <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
objects since most widgets use a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>.</para>

    <para>A <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
object interacts with the native window system for input and events. Some
<link linkend="class-gtkwidget"><classname>gtk.Widget</classname></link>
objects do not have an associated <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> and
therefore cannot receive events. To receive events on behalf of these
"windowless" widgets a <link
linkend="class-gtkeventbox"><classname>gtk.EventBox</classname></link> must
be used.</para>

  </refsect1>

  <refsect1 id="constructor-gdkwindow">
    <title>Constructor</title>

    <programlisting><constructorsynopsis language="python">
	<methodname>gtk.gdk.Window</methodname>
	<methodparam><parameter
		       role="keyword">parent</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">width</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">height</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">window_type</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">event_mask</parameter></methodparam>
	<methodparam><parameter
		       role="keyword">wclass</parameter></methodparam>
	<methodparam><parameter role="keyword">title</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">x</parameter>
	  <initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">y</parameter>
	  <initializer>-1</initializer></methodparam>
	<methodparam><parameter role="keyword">visual</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">colormap</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">cursor</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">wmclass_name</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">wmclass_class</parameter>
	  <initializer>None</initializer></methodparam>
	<methodparam><parameter role="keyword">override_redirect</parameter>
	  <initializer>-1</initializer></methodparam>
      </constructorsynopsis></programlisting>
    <variablelist>
      <varlistentry>
	<term><parameter role="keyword">parent</parameter>&nbsp;:</term>
	<listitem><simpara>a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link></simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">width</parameter>&nbsp;:</term>
	<listitem><simpara>the width of the window in
pixels</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">height</parameter>&nbsp;:</term>
	<listitem><simpara>the height of the window in
pixels</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter
role="keyword">window_type</parameter>&nbsp;:</term>
	<listitem><simpara>the window type</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">event_mask</parameter>&nbsp;:</term>
	<listitem><simpara>the bitmask of events received by the
window</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">wclass</parameter>&nbsp;:</term>
	<listitem><simpara>the class of window - either
<literal>gtk.gdk.INPUT_OUTPUT</literal> or
<literal>gtk.gdk.INPUT_ONLY</literal></simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">title</parameter>&nbsp;:</term>
	<listitem><simpara>the window title if a toplevel
window</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">x</parameter>&nbsp;:</term>
	<listitem><simpara>the x coordinate of the window position relative
to <parameter>parent</parameter></simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">y</parameter>&nbsp;:</term>
	<listitem><simpara>the y coordinate of the window position relative
to <parameter>parent</parameter></simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">visual</parameter>&nbsp;:</term>
	<listitem><simpara>the <link
linkend="class-gdkvisual"><classname>gtk.gdk.Visual</classname></link> for
the window</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">colormap</parameter>&nbsp;:</term>
	<listitem><simpara>the <link
linkend="class-gdkcolormap"><classname>gtk.gdk.Colormap</classname></link>
for the window</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter role="keyword">cursor</parameter>&nbsp;:</term>
	<listitem><simpara>the <link
linkend="class-gdkcursor"><classname>gtk.gdk.Cursor</classname></link> for
the window</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter
role="keyword">wmclass_name</parameter>&nbsp;:</term>
	<listitem><simpara>don't use this - see the <link
linkend="method-gtkwindow--set-wmclass"><methodname>gtk.Window.set_wmclass</methodname>()</link> 
method for more information.</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter
role="keyword">wmclass_class</parameter>&nbsp;:</term>
	<listitem><simpara>don't use this - see the <link
linkend="method-gtkwindow--set-wmclass"><methodname>gtk.Window.set_wmclass</methodname>()</link> 
method for more information.</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter
role="keyword">override_redirect</parameter>&nbsp;:</term>
	<listitem><simpara>if <literal>TRUE</literal> bypass the window
manager</simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><emphasis>Returns</emphasis>&nbsp;:</term>
	<listitem><simpara>the new <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link></simpara></listitem>
      </varlistentry>
    </variablelist>

    <para>Creates a new <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> of
the type and class specified by <parameter>window_type</parameter> and
<parameter>wclass</parameter>. The window will be a child of the specified
<parameter>parent</parameter> and will have the specified
<parameter>width</parameter> and <parameter>height</parameter>.
<parameter>event_mask</parameter> is a bitfield specifying the events that
the window will receive - see the <link
linkend="method-gdkwindow--set-events"><methodname>set_events</methodname>()</link> 
method for more information. The value of <parameter>window_type</parameter>
must be one of:</para>

    <variablelist>
      <varlistentry>
	<term><literal>gtk.gdk.WINDOW_ROOT</literal></term>
	<listitem>
	  <simpara>The root window; this window has no parent, covers the
entire screen, and is created by the window system.</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>gtk.gdk.WINDOW_TOPLEVEL</literal></term>
	<listitem>
	  <simpara>A toplevel window (used to implement <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>).</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>gtk.gdk.WINDOW_CHILD</literal></term>
	<listitem>
	  <simpara>A child window (used to implement widgets e.g. <link
linkend="class-gtkentry"><classname>gtk.Entry</classname></link>).</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>gtk.gdk.WINDOW_DIALOG</literal></term>
	<listitem>
	  <simpara>A useless/deprecated compatibility type.</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>gtk.gdk.WINDOW_TEMP</literal></term>
	<listitem>
	  <simpara>An override redirect temporary window (used to implement
<link
linkend="class-gtkmenu"><classname>gtk.Menu</classname></link>).</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>gtk.gdk.WINDOW_FOREIGN</literal></term>
	<listitem>
	  <simpara>A foreign window (see the <link
linkend="function-gdk--window-foreign-new"><function>gtk.gdk.window_foreign_new</function>()</link> 
function).</simpara>
	</listitem>
      </varlistentry>
    </variablelist>

    <para>The value of <parameter>wclass</parameter> must be one of:</para>

    <variablelist>
      <varlistentry>
	<term><literal>gtk.gdk.INPUT_OUTPUT</literal></term>
	<listitem>
	  <simpara>A window for graphics and events.</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><literal>gtk.gdk.INPUT_ONLY</literal></term>
	<listitem>
	  <simpara>A window for events only.</simpara>
	</listitem>
      </varlistentry>
    </variablelist>

    <para>If the optional parameters are not specified the corresponding
attribute values will have default values:</para>

    <variablelist>
      <varlistentry>
	<term><parameter>x</parameter></term>
	<listitem>
	  <simpara>0</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter>y</parameter></term>
	<listitem>
	  <simpara>0</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter>visual</parameter></term>
	<listitem>
	  <simpara>the default system visual - see the <link
linkend="function-gdk--visual-get-system"><function>gtk.gdk.visual_get_system</function>()</link> 
function</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter>colormap</parameter></term>
	<listitem>
	  <simpara>either the system <link
linkend="class-gdkcolormap"><classname>gtk.gdk.Colormap</classname></link>
if using the system <link
linkend="class-gdkvisual"><classname>gtk.gdk.Visual</classname></link> (see
the <link
linkend="function-gdk--colormap-get-system"><function>gtk.gdk.colormap_get_system</function>()</link> 
function) or a new <link
linkend="class-gdkcolormap"><classname>gtk.gdk.Colormap</classname></link>
using <parameter>visual</parameter></simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter>cursor</parameter></term>
	<listitem>
	  <simpara>use the parent window's cursor</simpara>
	</listitem>
      </varlistentry>
      <varlistentry>
	<term><parameter>override_redirect</parameter></term>
	<listitem>
	  <simpara>gtk.FALSE</simpara>
	</listitem>
      </varlistentry>
    </variablelist>

    <para></para>

  </refsect1>

  <refsect1>
    <title>Methods</title>

    <refsect2 id="method-gdkwindow--drag-begin">
      <title>gtk.gdk.Window.drag_begin</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>drag_begin</methodname>
	  <methodparam><parameter
			 role="keyword">targets</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">targets</parameter>&nbsp;:</term>
	  <listitem><simpara>a list of offered targets</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a new <link
linkend="class-gdkdragcontext"><classname>gtk.gdk.DragContext</classname></link></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>drag_begin</methodname>() method starts a drag
operation and returns the new <link
linkend="class-gdkdragcontext"><classname>gtk.gdk.DragContext</classname></link> 
created for it. The list of targets (integer values) supported by the drag
source are specified by <parameter>targets</parameter>.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--input-set-extension-events">
      <title>gtk.gdk.Window.input_set_extension_events</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>input_set_extension_events</methodname>
	  <methodparam><parameter
			 role="keyword">mask</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">mode</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">mask</parameter>&nbsp;:</term>
	  <listitem><simpara>the event mask to be used</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">mode</parameter>&nbsp;:</term>
	  <listitem><simpara>the set of extension events to
receive</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>input_set_extension_events</methodname>() method
enables or disables the extension events specified by
<parameter>mode</parameter> for the window when using the event mask
specified by <parameter>mask</parameter>. The value of
<parameter>mode</parameter> must be one of:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.EXTENSION_EVENTS_NONE</literal></term>
	  <listitem>
	    <simpara>no extension events are desired.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.EXTENSION_EVENTS_ALL</literal></term>
	  <listitem>
	    <simpara>all extension events are desired.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.EXTENSION_EVENTS_CURSOR</literal></term>
	  <listitem>
	    <simpara>extension events are desired only if a cursor will be
displayed for the device.</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para></para>

    </refsect2>

    <refsect2 id="method-gdkwindow--property-get">
      <title>gtk.gdk.Window.property_get</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>property_get</methodname>
	  <methodparam><parameter
			 role="keyword">property</parameter></methodparam>
	  <methodparam><parameter role="keyword">type</parameter>
	    <initializer>0</initializer></methodparam>
	  <methodparam><parameter role="keyword">pdelete</parameter>
	    <initializer>FALSE</initializer></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">property</parameter>&nbsp;:</term>
	  <listitem><simpara>the property to get</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">type</parameter>&nbsp;:</term>
	  <listitem><simpara>the type of property to get or not specified if
any type of property data is acceptable.</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">pdelete</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal>, delete the property
after retrieving the data.</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a tuple containing the actual property type,
the data format and the data</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>property_get</methodname>() method returns a
tuple containing the actual property type (as a gtk.gdk.Atom), the format
and the data of the specified <parameter>property</parameter> with the
specified <parameter>type</parameter>. The value of
<parameter>type</parameter> 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
<parameter>property</parameter> cannot be found <literal>None</literal> is
returned. <parameter>property</parameter> and <parameter>type</parameter>
(if specified) must be a string or a gtk.gdk.Atom.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--property-change">
      <title>gtk.gdk.Window.property_change</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>property_change</methodname>
	  <methodparam><parameter
			 role="keyword">property</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">type</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">format</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">mode</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">data</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">property</parameter>&nbsp;:</term>
	  <listitem><simpara>the property to change</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">type</parameter>&nbsp;:</term>
	  <listitem><simpara>the new type of the property. If
<parameter>mode</parameter> is <literal>gtk.gdk.PROP_MODE_PREPEND</literal>
or <literal>gtk.gdk.PROP_MODE_APPEND</literal>, then this must match the
existing type or an error will occur.</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">format</parameter>&nbsp;:</term>
	  <listitem><simpara>the new format for the property. If
<parameter>mode</parameter> is <literal>gtk.gdk.PROP_MODE_PREPEND</literal>
or <literal>gtk.gdk.PROP_MODE_APPEND</literal>, then this must match the
existing format or an error will occur.</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">mode</parameter>&nbsp;:</term>
	  <listitem><simpara>a value describing how the new data is to be
combined with the current data.</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">data</parameter>&nbsp;:</term>
	  <listitem><simpara>the data for the property</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>property_change</methodname>() method changes
the contents of the specified <parameter>property</parameter> to the
specified <parameter>data</parameter> with the specified
<parameter>type</parameter> and <parameter>format</parameter>. The value of
<parameter>mode</parameter> must be one of:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.PROP_MODE_REPLACE</literal></term>
	  <listitem>
	    <simpara>The new data replaces the existing data.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.PROP_MODE_PREPEND</literal></term>
	  <listitem>
	    <simpara>The new data is prepended to the existing data.
</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.PROP_MODE_APPEND</literal></term>
	  <listitem>
	    <simpara>The new data is appended to the existing
data.</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para>which describes how the new data is to be combined with the
existing property data.The value of <parameter>format</parameter> must be 8,
16 or 32. <parameter>property</parameter> and <parameter>type</parameter>
must be a string or a gtk.gdk.Atom.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--property-delete">
      <title>gtk.gdk.Window.property_delete</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>property_delete</methodname>
	  <methodparam><parameter
			 role="keyword">property</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">property</parameter>&nbsp;:</term>
	  <listitem><simpara>the property to delete</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>property_delete</methodname>() method deletes
the specified <parameter>property</parameter> from the window.
<parameter>property</parameter> must be a string or a gtk.gdk.Atom.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--selection-convert">
      <title>gtk.gdk.Window.selection_convert</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>selection_convert</methodname>
	  <methodparam><parameter
			 role="keyword">selection</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">target</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">time</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">selection</parameter>&nbsp;:</term>
	  <listitem><simpara>the selection to retrieve</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">target</parameter>&nbsp;:</term>
	  <listitem><simpara>the target form of
<parameter>selection</parameter></simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">time</parameter>&nbsp;:</term>
	  <listitem><simpara>the timestamp to use when retrieving
<parameter>selection</parameter>. The selection owner may refuse the request
if it did not own the selection at the time indicated by the
timestamp.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>selection_convert</methodname>() method converts
the specified <parameter>selection</parameter> to the specified
<parameter>form</parameter>.</para>

    </refsect2>

<!-- NOT IMPLEMENTED
  <refsect2 id="method-gdkwindow- -selection-property-get">
    <title>gtk.gdk.Window.selection_property_get</title>

<programlisting><methodsynopsis language="python">
    <methodname>selection_property_get</methodname>
    <methodparam><parameter role="keyword">data</parameter></methodparam>
    <methodparam><parameter role="keyword">prop_type</parameter></methodparam>
    <methodparam><parameter role="keyword">prop_format</parameter></methodparam>
  </methodsynopsis></programlisting>
  <variablelist>
    <varlistentry>
      <term><parameter role="keyword">data</parameter>&nbsp;:</term>
      <listitem><simpara>a guchar**</simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><parameter role="keyword">prop_type</parameter>&nbsp;:</term>
      <listitem><simpara>a GdkAtom*</simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><parameter role="keyword">prop_format</parameter>&nbsp;:</term>
      <listitem><simpara>a gint*</simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><emphasis>Returns</emphasis>&nbsp;:</term>
      <listitem><simpara>a gboolean</simpara></listitem>
    </varlistentry>
  </variablelist>
  </refsect2>
END NOT IMPLEMENTED -->

    <refsect2 id="method-gdkwindow--set-keep-above">
      <title>gtk.gdk.Window.set_keep_above</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_keep_above</methodname>
	  <methodparam><parameter role="keyword">setting</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
	  <listitem><simpara>xif <literal>TRUE</literal> keep the window
	  above other windows</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.4 and above.</para>
      </note>

      <para>The <methodname>set_keep_above</methodname>() method sets the
"keep-above" setting to the value of <parameter>setting</parameter>. If
<parameter>setting</parameter> is <literal>TRUE</literal> the window must be
kept above other windows. If the window is already above, then this method
does nothing.</para>

      <para>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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-keep-below">
      <title>gtk.gdk.Window.set_keep_below</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_keep_below</methodname>
	  <methodparam><parameter role="keyword">setting</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal>, keep the window
	  below other windows</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.4 and above.</para>
      </note>

      <para>The <methodname>set_keep_below</methodname>() method sets the
"keep-below" setting to the value of <parameter>setting</parameter>. If
<parameter>setting</parameter> is <literal>TRUE</literal> the window must be
kept below other windows. If the window was already below, then this
method does nothing.</para>

      <para>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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--destroy">
      <title>gtk.gdk.Window.destroy</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>destroy</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>destroy</methodname>() 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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-window-type">
      <title>gtk.gdk.Window.get_window_type</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_window_type</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the type of window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_window_type</methodname>() method returns
the type of the window:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_ROOT</literal></term>
	  <listitem>
	    <simpara>the root window; this window has no parent, covers the
entire screen, and is created by the window system</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_TOPLEVEL</literal></term>
	  <listitem>
	    <simpara>a toplevel window (used to implement <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>)</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_CHILD</literal></term>
	  <listitem>
	    <simpara>a child window (used to implement e.g. <link
linkend="class-gtkbutton"><classname>gtk.Button</classname></link>)</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_DIALOG</literal></term>
	  <listitem>
	    <simpara>a useless and deprecated compatibility type</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_TEMP</literal></term>
	  <listitem>
	    <simpara>an override redirect temporary window (used to
implement <link
linkend="class-gtkmenu"><classname>gtk.Menu</classname></link>)</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_FOREIGN</literal></term>
	  <listitem>
	    <simpara>a foreign window (see the <link
linkend="function-gdk--window-foreign-new"><function>gtk.gdk.window_foreign_new</function>()</link> 
function)</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para></para>

    </refsect2>

    <refsect2 id="method-gdkwindow--show">
      <title>gtk.gdk.Window.show</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>show</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>show</methodname>() method maps the window so
it's visible onscreen 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 <link
linkend="method-gdkwindow--hide"><methodname>hide</methodname>()</link>
method. When implementing a <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link>, you
should call this method on the widget's <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> as
part of the "map" method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--hide">
      <title>gtk.gdk.Window.hide</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>hide</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>hide</methodname>() 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 <link
linkend="method-gtkwidget--hide"><methodname>gtk.Widget.hide</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--withdraw">
      <title>gtk.gdk.Window.withdraw</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>withdraw</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>withdraw</methodname>() method withdraws the
window (unmaps it and asks the window manager to forget about it). This is
normally done automatically by the <link
linkend="method-gtkwidget--hide"><methodname>gtk.Widget.hide</methodname>()</link> 
method called on a <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--move">
      <title>gtk.gdk.Window.move</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>move</methodname>
	  <methodparam><parameter role="keyword">x</parameter></methodparam>
	  <methodparam><parameter role="keyword">y</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">x</parameter>&nbsp;:</term>
	  <listitem><simpara>the X coordinate relative to the window's
parent</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y coordinate relative to the window's
parent</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>move</methodname>() method repositions the
window to the location specified by <parameter>x</parameter> and
<parameter>y</parameter> relative to its parent window. For toplevel
windows, window managers may ignore or modify the move. You should probably
use the <link
linkend="method-gtkwindow--move"><methodname>gtk.Window.move</methodname>()</link> 
method on a <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> 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
<link
linkend="method-gdkwindow--move-resize"><methodname>move_resize</methodname>()</link> 
method to both move and resize simultaneously, for a nicer visual
effect.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--resize">
      <title>gtk.gdk.Window.resize</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>resize</methodname>
	  <methodparam><parameter
			 role="keyword">width</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">height</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">width</parameter>&nbsp;:</term>
	  <listitem><simpara>the new width of the
window</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">height</parameter>&nbsp;:</term>
	  <listitem><simpara>the new height of the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>resize</methodname>() method resizes the window
to the specified <parameter>width</parameter> and
<parameter>height</parameter>. 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 <link
linkend="method-gtkwindow--resize"><methodname>gtk.Window.resize</methodname>()</link> 
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 <link
linkend="method-gdkwindow--move-resize"><methodname>move_resize</methodname>()</link> 
method to both move and resize simultaneously, for a nicer visual
effect.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--move-resize">
      <title>gtk.gdk.Window.move_resize</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>move_resize</methodname>
	  <methodparam><parameter role="keyword">x</parameter></methodparam>
	  <methodparam><parameter role="keyword">y</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">width</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">height</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">x</parameter>&nbsp;:</term>
	  <listitem><simpara>the new X position relative to the window's
parent</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">y</parameter>&nbsp;:</term>
	  <listitem><simpara>the new Y position relative to the window's
parent</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">width</parameter>&nbsp;:</term>
	  <listitem><simpara>the new width</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">height</parameter>&nbsp;:</term>
	  <listitem><simpara>the new height</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>move_resize</methodname>() method repositions
the window to the location specified by <parameter>x</parameter> and
<parameter>y</parameter> with the size specified by
<parameter>width</parameter> and <parameter>height</parameter>. This method
is equivalent to calling the <link
linkend="method-gdkwindow--move"><methodname>move</methodname>()</link> and
<link
linkend="method-gdkwindow--resize"><methodname>resize</methodname>()</link>
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 <methodname>move_resize</methodname>()
method.)</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--reparent">
      <title>gtk.gdk.Window.reparent</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>reparent</methodname>
	  <methodparam><parameter
			 role="keyword">new_parent</parameter></methodparam>
	  <methodparam><parameter role="keyword">x</parameter></methodparam>
	  <methodparam><parameter role="keyword">y</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">new_parent</parameter>&nbsp;:</term>
	  <listitem><simpara>the new parent <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> to
move the window into</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">x</parameter>&nbsp;:</term>
	  <listitem><simpara>the X location inside the new
parent</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y location inside the new
parent</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>reparent</methodname>() method reparents the
window into the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
specified <parameter>new_parent</parameter>. The window being reparented
will be unmapped as a side effect.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--clear">
      <title>gtk.gdk.Window.clear</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>clear</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>clear</methodname>() method clears an entire the
window to the background color or background pixmap.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--clear-area">
      <title>gtk.gdk.Window.clear_area</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>clear_area</methodname>
	  <methodparam><parameter role="keyword">x</parameter></methodparam>
	  <methodparam><parameter role="keyword">y</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">width</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">height</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">x</parameter>&nbsp;:</term>
	  <listitem><simpara>the X coordinate of the rectangle to
clear</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y coordinate of the rectangle to
clear</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">width</parameter>&nbsp;:</term>
	  <listitem><simpara>the width of the rectangle to
clear</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">height</parameter>&nbsp;:</term>
	  <listitem><simpara>the height of the rectangle to
clear</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>clear_area</methodname>() method clears the area
(specified by <parameter>x</parameter>, <parameter>y</parameter>,
<parameter>width</parameter> and <parameter>height</parameter>) of the
window to the background color or background pixmap.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--clear-area-e">
      <title>gtk.gdk.Window.clear_area_e</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>clear_area_e</methodname>
	  <methodparam><parameter role="keyword">x</parameter></methodparam>
	  <methodparam><parameter role="keyword">y</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">width</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">height</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">x</parameter>&nbsp;:</term>
	  <listitem><simpara>the X coordinate of the rectangle to
clear</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y coordinate of the rectangle to
clear</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">width</parameter>&nbsp;:</term>
	  <listitem><simpara>the width of the rectangle to
clear</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">height</parameter>&nbsp;:</term>
	  <listitem><simpara>the height of the rectangle to
clear</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>clear_area_e</methodname>() method is like the
<link
linkend="method-gdkwindow--clear-area"><methodname>clear_area</methodname>()</link>, 
but also generates an expose event for the cleared area.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--raise_">
      <title>gtk.gdk.Window.raise_</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>raise_</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>raise_</methodname>() 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 <link
linkend="method-gdkwindow--raise_"><methodname>raise_</methodname>()</link>
method only requests the restack, it does not guarantee it.</para>

	<note><para>
		This method is called <methodname>raise</methodname>() in
		the C API, but was renamed <methodname>raise_</methodname>()
		since <literal>raise</literal> is a reserved Python keyword.
	</para></note>
    </refsect2>

    <refsect2 id="method-gdkwindow--lower">
      <title>gtk.gdk.Window.lower</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>lower</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>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
<link
linkend="method-gdkwindow--lower"><methodname>lower</methodname>()</link>
only requests the restack, it does not guarantee it. Note that the <link
linkend="method-gdkwindow--show"><methodname>show</methodname>()</link>
method raises the window again, so don't call this method before calling the
<link
linkend="method-gdkwindow--show"><methodname>show</methodname>()</link>
method to avoid duplication.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--focus">
      <title>gtk.gdk.Window.focus</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>focus</methodname>
	  <methodparam><parameter role="keyword">timestamp</parameter>
	    <initializer>0L</initializer></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">timestamp</parameter>&nbsp;:</term>
	  <listitem><simpara>the timestamp of the event triggering the
window focus</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>focus</methodname>() method sets keyboard focus
to the window. If the window is not onscreen this will not work. In most
cases, the <link
linkend="method-gtkwindow--present"><methodname>gtk.Window.present</methodname>()</link> 
method should be used on a <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>, rather
than calling this method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-user-data">
      <title>gtk.gdk.Window.set_user_data</title>

      <programlisting><methodsynopsis language="python">
          <methodname>set_user_data</methodname>
          <methodparam><parameter role="keyword">user_data</parameter></methodparam>
        </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><parameter
          role="keyword">user_data</parameter>&nbsp;:</term>
          <listitem><simpara>a <link
          linkend="class-gtkwidget"><classname>gtk.Widget</classname></link></simpara></listitem>
        </varlistentry>
      </variablelist>

      <note>
        <para>This method is available in PyGTK 2.4 and above.</para>
      </note>

      <para>The <methodname>set_user_data</methodname>() method stores the
underlying GTK+ widget of the PyGTK widget that is specified by
<parameter>user_data</parameter> as the user data of the window. In general
GTK+ stores the widget that owns a GdkWindow as user data on a
GtkWindow. So, custom widget implementations in PyGTK should use this method
to provide that capability. If GTK+ receives an event for a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>, and
the user data for the window is set, GTK+ will assume the user data is a
<link linkend="class-gtkwidget"><classname>gtk.Widget</classname></link>,
and forward the event to that widget.</para>

      <para>In PyGTK 2.4 and above this method will raise the TypeError
exception if <parameter>user_data</parameter> is not a <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link>.</para>

      <note>
        <para>This method is deprecated for any use other than the above. To
set other user data on a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> use
the <link
linkend="method-gobject--set-data"><methodname>gobject.GObject.set_data</methodname>()</link>
method instead.</para>
      </note>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-user-data">
      <title>gtk.gdk.Window.get_user_data</title>

      <programlisting><methodsynopsis language="python">
          <methodname>get_user_data</methodname>
          <methodparam></methodparam>
        </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara>the user data set on the
          window</simpara></listitem>
        </varlistentry>
      </variablelist>

      <note>
        <para>This method is available in PyGTK 2.4 and above.</para>
      </note>

      <para>The <methodname>get_user_data</methodname>() method returns the
PyGTK widget that was set as the user data of the window using the <link
linkend="method-gdkwindow--set-user-data"><methodname>set_user_data</methodname>()</link>
method. This method raises the ValueError exception if the user data is not
set or is not a PyGTK object.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-override-redirect">
      <title>gtk.gdk.Window.set_override_redirect</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_override_redirect</methodname>
	  <methodparam><parameter
			 role="keyword">override_redirect</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">override_redirect</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> the window should be
override redirect</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_override_redirect</methodname>() method sets
the "override redirect" attribute on the window to the value specified by
<parameter>override_redirect</parameter>. If
<parameter>override_redirect</parameter> is <literal>TRUE</literal> 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. <link
linkend="class-gtkmenu"><classname>gtk.Menu</classname></link> uses an
override redirect window in its implementation, for example. This method
does not work on MS Windows.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--add-filter">
      <title>gtk.gdk.Window.add_filter</title>

      <programlisting><methodsynopsis language="python">
          <methodname>add_filter</methodname>
          <methodparam><parameter role="keyword">function</parameter></methodparam>
          <methodparam><parameter role="keyword">data</parameter><initializer>None</initializer></methodparam>
        </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">function</parameter>&nbsp;:</term>
          <listitem><simpara>a function</simpara></listitem>
        </varlistentry>
        <varlistentry>
          <term><parameter role="keyword">data</parameter>&nbsp;:</term>
          <listitem><simpara>data to pass to
          <parameter>function</parameter></simpara></listitem>
        </varlistentry>
      </variablelist>

      <note>
        <para>This method is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The <methodname>add_filter</methodname>() method adds an event
filter function specified by <parameter>function</parameter> 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:</para>

      <programlisting>
  def function(<parameter>event</parameter>, <parameter>user_data</parameter>)
</programlisting>

      <para>where <parameter>event</parameter> is a <link
linkend="class-gdkevent"><classname>gtk.gdk.Event</classname></link> and
<parameter>user_data</parameter> is <parameter>data</parameter>. If
<parameter>data</parameter> is not specified then
<parameter>user_data</parameter> is not passed to
<parameter>function</parameter>.</para>

      <para><parameter>function</parameter> should return one of the
following values:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.FILTER_CONTINUE</literal></term>
	  <listitem>
	    <simpara>the event was not handled, continue processing.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.FILTER_TRANSLATE</literal></term>
	  <listitem>
	    <simpara>the native event was translated into a GDK event and
stored in the event that was passed in.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.FILTER_REMOVE</literal></term>
	  <listitem>
	    <simpara>the event was handled, terminate processing.</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para></para>

    </refsect2>

<!-- NOT IMPLEMENTED
  <refsect2 id="method-gdkwindow- -remove-filter">
    <title>gtk.gdk.Window.remove_filter</title>

<programlisting><methodsynopsis language="python">
    <methodname>remove_filter</methodname>
    <methodparam><parameter role="keyword">function</parameter></methodparam>
    <methodparam><parameter role="keyword">data</parameter></methodparam>
  </methodsynopsis></programlisting>
  <variablelist>
    <varlistentry>
      <term><parameter role="keyword">function</parameter>&nbsp;:</term>
      <listitem><simpara>previously-added filter function</simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><parameter role="keyword">data</parameter>&nbsp;:</term>
      <listitem><simpara>user data for previously-added filter function</simpara></listitem>
    </varlistentry>
  </variablelist>
<para>
Remove a filter previously added with <link linkend="method-gdkwindow- -add-filter"><function>gtk.gdk.Window.add_filter()</function></link>.
</para>  </refsect2>
END NOT IMPLEMENTED -->

    <refsect2 id="method-gdkwindow--scroll">
      <title>gtk.gdk.Window.scroll</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>scroll</methodname>
	  <methodparam><parameter
			 role="keyword">dx</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">dy</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">dx</parameter>&nbsp;:</term>
	  <listitem><simpara>the amount to scroll in the X
direction</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">dy</parameter>&nbsp;:</term>
	  <listitem><simpara>the amount to scroll in the Y
direction</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>scroll</methodname>() method scrolls the
contents of the window, both pixels and children, by the horizontal and
vertical amounts specified by <parameter>dx</parameter> and
<parameter>dy</parameter> respectively. The window itself does not move.
Portions of the window that the scroll operation brings in from offscreen
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.)</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--shape-combine-mask">
      <title>gtk.gdk.Window.shape_combine_mask</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>shape_combine_mask</methodname>
	  <methodparam><parameter
			 role="keyword">shape_mask</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">offset_x</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">offset_y</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">shape_mask</parameter>&nbsp;:</term>
	  <listitem><simpara>the shape bitmap mask</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">offset_x</parameter>&nbsp;:</term>
	  <listitem><simpara>the X position of shape mask with respect to
the window</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">offset_y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y position of shape mask with respect to
the window</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-child-shapes">
      <title>gtk.gdk.Window.set_child_shapes</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_child_shapes</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>set_child_shapes</methodname>() 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 <link
linkend="method-gdkwindow--merge-child-shapes"><methodname>merge_child_shapes</methodname>()</link> 
method that includes the shape mask of the window in the masks to be
merged.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--merge-child-shapes">
      <title>gtk.gdk.Window.merge_child_shapes</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>merge_child_shapes</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>merge_child_shapes</methodname>() 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 <link
linkend="method-gdkwindow--shape-combine-mask"><methodname>shape_combine_mask</methodname>()</link> 
method. This method is distinct from the <link
linkend="method-gdkwindow--set-child-shapes"><methodname>set_child_shapes</methodname>()</link> 
method because it includes the window's shape mask in the set of shapes to
be merged.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--is-visible">
      <title>gtk.gdk.Window.is_visible</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>is_visible</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>TRUE</literal> if the window is
mapped</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>is_visible</methodname>() method returns
<literal>TRUE</literal> if the window has been mapped (with the <link
linkend="method-gdkwindow--show"><methodname>show</methodname>()</link>
method.</para>

    </refsect2>

  <refsect2 id="method-gdkwindow--is-viewable">
      <title>gtk.gdk.Window.is_viewable</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>is_viewable</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>TRUE</literal> if the window is
viewable</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>is_viewable</methodname>() method returns
<literal>TRUE</literal>  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 <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
parents, not to the root window.)</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-state">
      <title>gtk.gdk.Window.get_state</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_state</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the window state bitfield</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_state</methodname>() method returns the
bitwise <literal>OR</literal> of the currently active window state
flags:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_STATE_WITHDRAWN</literal></term>
	  <listitem>
	    <simpara>The window is not shown.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_STATE_ICONIFIED</literal></term>
	  <listitem>
	    <simpara>The window is minimized.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_STATE_MAXIMIZED</literal></term>
	  <listitem>
	    <simpara>The window is maximized.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_STATE_STICKY</literal></term>
	  <listitem>
	    <simpara>The window is sticky.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>GDK_WINDOW_STATE_FULLSCREEN</literal></term>
	  <listitem>
	    <simpara>the window is maximized without decorations. Available
in PyGTK 2.2 and above.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>GDK_WINDOW_STATE_ABOVE</literal></term>
	  <listitem>
	    <simpara>the window is kept above other windows. Available
in PyGTK 2.4 and above.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>GDK_WINDOW_STATE_BELOW</literal></term>
	  <listitem>
	    <simpara>the window is kept below other windows. Available
in PyGTK 2.4 and above.</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para></para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-static-gravities">
      <title>gtk.gdk.Window.set_static_gravities</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_static_gravities</methodname>
	  <methodparam><parameter
			 role="keyword">use_static</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">use_static</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> turn on static
gravity</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>TRUE</literal> if the server supports
static gravity</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_static_gravities</methodname>() method sets
the bit gravity of the given window to the value specified by
<parameter>use_static</parameter>. If <parameter>use_static</parameter> is
<literal>TRUE</literal> the window uses static gravity and all children get
static subwindow gravity as well. This method returns
<literal>TRUE</literal> if the window system server supports static
gravity.</para>
    </refsect2>

    <refsect2 id="method-gdkwindow--set-type-hint">
      <title>gtk.gdk.Window.set_type_hint</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_type_hint</methodname>
	  <methodparam><parameter
			 role="keyword">hint</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">hint</parameter>&nbsp;:</term>
	  <listitem><simpara>a hint of the function this window will
have</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_type_hint</methodname>() method provides the
specified <parameter>hint</parameter> 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:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_TYPE_HINT_NORMAL</literal></term>
	  <listitem>
	    <simpara>A normal toplevel window.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_TYPE_HINT_DIALOG</literal></term>
	  <listitem>
	    <simpara>A dialog window.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_TYPE_HINT_MENU</literal></term>
	  <listitem>
	    <simpara>A window used to implement a menu.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_TYPE_HINT_TOOLBAR</literal></term>
	  <listitem>
	    <simpara>A window used to implement a toolbar. </simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para></para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-modal-hint">
      <title>gtk.gdk.Window.set_modal_hint</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_modal_hint</methodname>
	  <methodparam><parameter
			 role="keyword">modal</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">modal</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> the window is
modal.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_modal_hint</methodname>() method sets the
window's modal hint to the value specified by <parameter>modal</parameter>.
If <parameter>modal</parameter> is <literal>TRUE</literal> 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 <link
linkend="method-gdkwindow--set-transient-for"><methodname>set_transient_for</methodname>()</link> 
method</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-skip-taskbar-hint">
      <title>gtk.gdk.Window.set_skip_taskbar_hint</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_skip_taskbar_hint</methodname>
	  <methodparam><parameter role="keyword">modal</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">skip_taskbar</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> skip the
	  taskbar.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The <methodname>set_skip_taskbar_hint</methodname>() method sets
the "skip_taskbar" setting to the value specified by
<parameter>skips_taskbar</parameter>. If
<parameter>skips_taskbar</parameter> is <literal>TRUE</literal> the window
should <emphasis role="bold">not</emphasis> appear in a task list or window
list. If the window's semantic type as specified with the <link
linkend="method-gdkwindow--set-type-hint"><methodname>set_type_hint()</methodname></link>
method already fully describes the window, this method should <emphasis
role="bold">not</emphasis> be called in addition; instead you should allow
the window to be treated according to standard policy for its semantic
type.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-skip-pager-hint">
      <title>gtk.gdk.Window.set_skip_pager_hint</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_skip_pager_hint</methodname>
	  <methodparam><parameter role="keyword">skips_pager</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">skips_pager</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> skip the pager</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The <methodname>set_skip_pager_hint</methodname>() method sets
the "skip_pager" setting to the value of skips_pager. If skips_pager is TRUE
the window should <emphasis role="bold">not</emphasis> 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 <link
linkend="method-gdkwindow--set-type-hint"><methodname>set_type_hint()</methodname></link>
already fully describes the window, this method should <emphasis
role="bold">not</emphasis> be called in addition, instead you should allow
the window to be treated according to standard policy for its semantic
type.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-geometry-hints">
      <title>gtk.gdk.Window.set_geometry_hints</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_geometry_hints</methodname>
	  <methodparam><parameter role="keyword">min_width</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">min_height</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">max_width</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">max_height</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">base_width</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">base_height</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">width_inc</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">height_inc</parameter><initializer>-1</initializer></methodparam>
	  <methodparam><parameter role="keyword">min_aspect</parameter><initializer>-1.0</initializer></methodparam>
	  <methodparam><parameter role="keyword">max_aspect</parameter><initializer>-1.0</initializer></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">min_width</parameter>&nbsp;:</term>
	  <listitem><simpara>minimum width of window or -1 to use 
requisition</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">min_height</parameter>&nbsp;:</term>
	  <listitem><simpara>minimum height of window or -1 to use
requisition</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">max_width</parameter>&nbsp;:</term>
	  <listitem><simpara>maximum width of window or -1 to use
requisition</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">max_height</parameter>&nbsp;:</term>
	  <listitem><simpara>maximum height of window or -1 to use
requisition</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">base_width</parameter>&nbsp;:</term>
	  <listitem><simpara>allowed window widths are
base_width + width_inc * N (where N is any integer) or
-1</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">base_height</parameter>&nbsp;:</term>
	  <listitem><simpara>allowed window widths are
base_height + height_inc * N (where N is any integer) or
-1</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">width_inc</parameter>&nbsp;:</term>
	  <listitem><simpara>width resize increment</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">height_inc</parameter>&nbsp;:</term>
	  <listitem><simpara>height resize increment</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">min_aspect</parameter>&nbsp;:</term>
	  <listitem><simpara>minimum width/height ratio</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">max_aspect</parameter>&nbsp;:</term>
	  <listitem><simpara>maximum width/height ratio</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The <methodname>set_geometry_hints</methodname>() method sets
the geometry hints for the window.</para>

      <para>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().</para>

      <para>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 <link
linkend="method-gdkwindow--set-override-redirect"><methodname>set_override_redirect</methodname>()</link>
method since these windows are not resizable by the user.</para>

<!--      <para>Since you can't count on the windowing system doing the
constraints for programmatic resizes, you should generally call the <link
linkend="function-gdk- -window-constrain-size"><function>gtk.gdk.window_constrain_size</function>()</link>
function yourself to determine appropriate sizes.</para>-->

    </refsect2>

    <refsect2 id="method-gdkwindow--begin-paint-rect">
      <title>gtk.gdk.Window.begin_paint_rect</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>begin_paint_rect</methodname>
	  <methodparam><parameter
			 role="keyword">rectangle</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">rectangle</parameter>&nbsp;:</term>
	  <listitem><simpara>the rectangle you intend to draw
to</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>begin_paint_rect</methodname>() method indicates
that you are beginning the process of redrawing the area specified by
<parameter>rectangle</parameter>. A backing store (offscreen buffer) large
enough to contain <parameter>rectangle</parameter> 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 <link
linkend="method-gdkwindow--end-paint"><methodname>end_paint</methodname>()</link> 
method, the backing store will be copied to the window, making it visible
onscreen. Only the part of window contained in region will be modified; that
is, drawing operations are clipped to <parameter>rectangle</parameter>. 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 <link
linkend="method-gdkwindow--end-paint"><methodname>end_paint</methodname>()</link> 
method. If you draw to window directly without calling the
<methodname>begin_paint_rect</methodname>() method, the user may see flicker
as individual drawing operations are performed in sequence. The clipping and
background initializing features of the
<methodname>begin_paint_rect</methodname>() are conveniences for the
programmer, so you can avoid doing that work yourself.</para>

    </refsect2>

<!-- NOT IMPLEMENTED
  <refsect2 id="method-gdkwindow- -begin-paint-region">
    <title>gtk.gdk.Window.begin_paint_region</title>

<programlisting><methodsynopsis language="python">
    <methodname>begin_paint_region</methodname>
    <methodparam><parameter role="keyword">region</parameter></methodparam>
  </methodsynopsis></programlisting>
  <variablelist>
    <varlistentry>
      <term><parameter role="keyword">region</parameter>&nbsp;:</term>
      <listitem><simpara>region you intend to draw to</simpara></listitem>
    </varlistentry>
  </variablelist>
<para>
Indicates that you are beginning the process of redrawing <parameter>region</parameter>.
A backing store (offscreen buffer) large enough to contain <parameter>region</parameter>
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 <link linkend="method-gdkwindow- -end-paint"><function>gtk.gdk.Window.end_paint()</function></link>, the backing
store will be copied to the window, making it visible onscreen. Only
the part of the window contained in <parameter>region</parameter> will be modified; that is,
drawing operations are clipped to <parameter>region</parameter>.
</para>
<para>
The net result of all this is to remove flicker, because the user
sees the finished product appear all at once when you call
<link linkend="method-gdkwindow- -end-paint"><function>gtk.gdk.Window.end_paint()</function></link>. If you draw to the window directly without
calling <link linkend="method-gdkwindow- -begin-paint-region"><function>gtk.gdk.Window.begin_paint_region()</function></link>, the user may see flicker
as individual drawing operations are performed in sequence.  The
clipping and background-initializing features of
<link linkend="method-gdkwindow- -begin-paint-region"><function>gtk.gdk.Window.begin_paint_region()</function></link> are conveniences for the
programmer, so you can avoid doing that work yourself.
</para>
<para>
When using GTK+, the widget system automatically places calls to
<link linkend="method-gdkwindow- -begin-paint-region"><function>gtk.gdk.Window.begin_paint_region()</function></link> and <link linkend="method-gdkwindow- -end-paint"><function>gtk.gdk.Window.end_paint()</function></link> 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
<literal>GdkEventExpose</literal> 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
<link linkend="method-gdkwindow- -begin-paint-region"><function>gtk.gdk.Window.begin_paint_region()</function></link>. (You can disable the automatic
calls around expose events on a widget-by-widget basis by calling
<link linkend="method-gtkwidget- -set-double-buffered"><function>gtk.Widget.set_double_buffered()</function></link>.)
</para>
<para>
If you call this function multiple times before calling the
matching <link linkend="method-gdkwindow- -end-paint"><function>gtk.gdk.Window.end_paint()</function></link>, the backing stores are pushed onto
a stack. <link linkend="method-gdkwindow- -end-paint"><function>gtk.gdk.Window.end_paint()</function></link> copies the topmost backing store
onscreen, 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
<link linkend="method-gdkwindow- -end-paint"><function>gtk.gdk.Window.end_paint()</function></link> is required for each call to
<link linkend="method-gdkwindow- -begin-paint-region"><function>gtk.gdk.Window.begin_paint_region()</function></link>.
</para>  </refsect2>
END NOT IMPLEMENTED -->

    <refsect2 id="method-gdkwindow--end-paint">
      <title>gtk.gdk.Window.end_paint</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>end_paint</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>end_paint</methodname>() method indicates that
the backing store created by the most recent call to the <link
linkend="method-gdkwindow--begin-paint-rect"><methodname>begin_paint_rect</methodname>()</link> 
method should be copied onscreen 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 <link
linkend="method-gdkwindow--begin-paint-rect"><methodname>begin_paint_rect</methodname>()</link> 
method first.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-title">
      <title>gtk.gdk.Window.set_title</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_title</methodname>
	  <methodparam><parameter
			 role="keyword">title</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">title</parameter>&nbsp;:</term>
	  <listitem><simpara>the new title of the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_title</methodname>() method sets the title
of a toplevel window, to the string specified by
<parameter>title</parameter>. If you haven't explicitly set the icon name
for the window (using the <link
linkend="method-gdkwindow--set-icon-name"><methodname>set_icon_name</methodname>()</link> 
method), the icon name will be set to <parameter>title</parameter> as well.
<parameter>title</parameter> must be in UTF-8 encoding (as with all
user-readable strings in <literal>PyGTK</literal>).</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-role">
      <title>gtk.gdk.Window.set_role</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_role</methodname>
	  <methodparam><parameter
			 role="keyword">role</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">role</parameter>&nbsp;:</term>
	  <listitem><simpara>a string indicating its
role</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_role</methodname>() method sets the string
specified by <parameter>role</parameter> as the window's role. When using
<literal>PyGTK</literal>, you should generally use the <link
linkend="method-gtkwindow--set-role"><methodname>gtk.Window.set_role</methodname>()</link> 
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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-transient-for">
      <title>gtk.gdk.Window.set_transient_for</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_transient_for</methodname>
	  <methodparam><parameter
			 role="keyword">leader</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">leader</parameter>&nbsp;:</term>
	  <listitem><simpara>another <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_transient_for</methodname>() method
indicates to the window manager that the window is a transient dialog
associated with the application window <parameter>leader</parameter>. This
allows the window manager to do things like center the window on
<parameter>leader</parameter> and keep the window above
<parameter>leader</parameter>. See the <link
linkend="method-gtkwindow--set-transient-for"><methodname>gtk.Window.set_transient_for</methodname>()</link> 
method if you're using a <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> or <link
linkend="class-gtkdialog"><classname>gtk.Dialog</classname></link>.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-background">
      <title>gtk.gdk.Window.set_background</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_background</methodname>
	  <methodparam><parameter
			 role="keyword">color</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">color</parameter>&nbsp;:</term>
	  <listitem><simpara>an allocated <link
linkend="class-gdkcolor"><classname>gtk.gdk.Color</classname></link></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_background</methodname>() method sets the
background <link
linkend="class-gdkcolor"><classname>gtk.gdk.Color</classname></link> of the
window to the value specified by <parameter>color</parameter>. (However,
when using <literal>PyGTK</literal>, set the background of a widget with the
<link
linkend="method-gtkwidget--modify-bg"><methodname>gtk.Widget.modify_bg</methodname>()</link> 
method from an application - or the <link
linkend="method-gtkstyle--set-background"><methodname>gtk.Style.set_background</methodname>()</link> 
method from a custom widget implementation.) The
<parameter>color</parameter> must be allocated Also see the <link
linkend="method-gdkwindow--set-back-pixmap"><methodname>set_back_pixmap</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-back-pixmap">
      <title>gtk.gdk.Window.set_back_pixmap</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_back_pixmap</methodname>
	  <methodparam><parameter
			 role="keyword">pixmap</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">parent_relative</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">pixmap</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
linkend="class-gdkpixmap"><classname>gtk.gdk.Pixmap</classname></link>, or
<literal>None</literal></simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">parent_relative</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> the tiling origin is
at the origin of the window's parent</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_back_pixmap</methodname>() method sets the
background pixmap of the window to the value specified by
<parameter>pixmap</parameter> A background pixmap will be tiled, positioning
the first tile at the origin of the window, or if
<parameter>parent_relative</parameter> is <literal>TRUE</literal>, 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
<parameter>pixmap</parameter> is <literal>None</literal> 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 <link
linkend="method-gdkwindow--clear"><methodname>clear</methodname>()</link>
method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-cursor">
      <title>gtk.gdk.Window.set_cursor</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_cursor</methodname>
	  <methodparam><parameter
			 role="keyword">cursor</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">cursor</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
linkend="class-gdkcursor"><classname>gtk.gdk.Cursor</classname></link> or
<literal>None</literal></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_cursor</methodname>() method sets the mouse
pointer for a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>. Use
either the <link linkend="constructor-gdkcursor1">gtk.gdk.Cursor()</link> or
<link linkend="constructor-gdkcursor2">gtk.gdk.Cursor</link>() constructors
to create the cursor. To make the cursor invisible, use the <link
linkend="constructor-gdkcursor2">gtk.gdk.Cursor</link>() constructor to
create a cursor with no pixels in it. Passing <literal>None</literal> for
the <parameter>cursor</parameter> argument to the
<methodname>set_cursor</methodname>() method means that the window will use
the cursor of its parent window. Most windows should use this
default.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-geometry">
      <title>gtk.gdk.Window.get_geometry</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_geometry</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>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.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_geometry</methodname>() 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).
</para>
      <para>
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
<literal>GdkEventConfigure</literal>. the <link
linkend="method-gdkwindow--get-position"><methodname>get_position</methodname>()</link> 
method in contrast gets the position from the most recent configure
event.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-position">
      <title>gtk.gdk.Window.get_position</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_position</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a 2-tuple containing the X and Y coordinates of
the window location.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_position</methodname>() returns a 2-tuple
containing the position of the window as reported in the
most-recently-processed <literal>GdkEventConfigure</literal>. By comparison
with the <link
linkend="method-gdkwindow--get-geometry"><methodname>get_geometry</methodname>()</link> 
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.</para>

    </refsect2>

  <refsect2 id="method-gdkwindow--get-origin">
      <title>gtk.gdk.Window.get_origin</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_origin</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a 2-tuple containing the X and Y coordinates of
the window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_origin</methodname>() 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 <link
linkend="method-gdkwindow--get-position"><methodname>get_position</methodname>()</link> 
and <link
linkend="method-gdkwindow--get-geometry"><methodname>get_geometry</methodname>()</link> 
methods that return the position of a window relative to its parent
window.)</para>

    </refsect2>

  <refsect2 id="method-gdkwindow--get-root-origin">
      <title>gtk.gdk.Window.get_root_origin</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_root_origin</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a 2-tuple containing the X and Y coordinates of
the window frame position</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_root_origin</methodname>() method returns a
2-tuple containing the top-left corner of the window manager frame in root
window coordinates.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-frame-extents">
      <title>gtk.gdk.Window.get_frame_extents</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_frame_extents</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a <link
linkend="class-gdkrectangle"><classname>gtk.gdk.Rectangle</classname></link>
specifying the bounding box of the window frame</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_frame_extents</methodname>() method returns
a <link
linkend="class-gdkrectangle"><classname>gtk.gdk.Rectangle</classname></link>
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 <link
linkend="method-gdkwindow--get-origin"><methodname>get_origin</methodname>()</link>
method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-pointer">
      <title>gtk.gdk.Window.get_pointer</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_pointer</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a 3-tuple containing the X and Y coordinates of
the mouse pointer and the modifier mask</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_pointer</methodname>() 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
following:</para>

      <variablelist>
	<varlistentry>
          <term><literal>gtk.gdk.SHIFT_MASK</literal></term>
	  <listitem>
            <simpara>The Shift key.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.LOCK_MASK</literal></term>
	  <listitem>
            <simpara>A Lock key (depending on the modifier mapping of the X
server this may either be CapsLock or ShiftLock).</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.CONTROL_MASK</literal></term>
	  <listitem>
            <simpara>The Control key. </simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.MOD1_MASK</literal></term>
	  <listitem>
            <simpara>The fourth modifier key (it depends on the modifier
mapping of the X server which key is interpreted as this modifier, but
normally it is the Alt key).</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.MOD2_MASK</literal></term>
	  <listitem>
            <simpara>The fifth modifier key (it depends on the modifier
mapping of the X server which key is interpreted as this
modifier).</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.MOD3_MASK</literal></term>
	  <listitem>
            <simpara>The sixth modifier key (it depends on the modifier
mapping of the X server which key is interpreted as this
modifier).</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.MOD4_MASK</literal></term>
	  <listitem>
            <simpara>The seventh modifier key (it depends on the modifier
mapping of the X server which key is interpreted as this
modifier).</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.MOD5_MASK</literal></term>
	  <listitem>
            <simpara>The eighth modifier key (it depends on the modifier
mapping of the X server which key is interpreted as this
modifier).</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.BUTTON1_MASK</literal></term>
	  <listitem>
            <simpara>The first mouse button.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.BUTTON2_MASK</literal></term>
	  <listitem>
            <simpara>The second mouse button.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.BUTTON3_MASK</literal></term>
	  <listitem>
            <simpara>The third mouse button.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.BUTTON4_MASK</literal></term>
	  <listitem>
            <simpara>The fourth mouse button.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.BUTTON5_MASK</literal></term>
	  <listitem>
            <simpara>The fifth mouse button.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.RELEASE_MASK</literal></term>
	  <listitem>
            <simpara>Differentiates between (keyval, modifiers) pairs from
key press and release events.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
          <term><literal>gtk.gdk.MODIFIER_MASK</literal></term>
	  <listitem>
            <simpara>all of the above</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para></para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-parent">
      <title>gtk.gdk.Window.get_parent</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_parent</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the parent <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> of
the window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_parent</methodname>() method returns the
parent of the window as set when the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> was
created or when the <link
linkend="method-gdkwindow--reparent"><methodname>reparent</methodname>()</link> 
method was called.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-toplevel">
      <title>gtk.gdk.Window.get_toplevel</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_toplevel</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the toplevel <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
containing the window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_toplevel</methodname>() method returns the
toplevel <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
that's an ancestor of the window.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-children">
      <title>gtk.gdk.Window.get_children</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_children</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the list of child windows inside the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_children</methodname>() method returns the
list of children <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
objects of the window. This method only returns children created via
<literal>PyGTK</literal>, so for example it's useless when used with the
root window; it only returns windows an application created itself.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-events">
      <title>gtk.gdk.Window.get_events</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_events</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the event mask for the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_events</methodname>() method returns the
event mask for the window. See the <link
linkend="method-gdkwindow--set-events"><methodname>set_events</methodname>()</link> 
method for more detail.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-events">
      <title>gtk.gdk.Window.set_events</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_events</methodname>
	  <methodparam><parameter
			 role="keyword">event_mask</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">event_mask</parameter>&nbsp;:</term>
	  <listitem><simpara>the event mask for the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_events</methodname>() 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 <literal>gtk.gdk.BUTTON_PRESS_MASK</literal> means the
window should report button press events. The event mask is the bitwise OR
of the following:</para>

      <itemizedlist>
        <listitem>
          <simpara><literal>gtk.gdk.EXPOSURE_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.POINTER_MOTION_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.POINTER_MOTION_HINT_MASK</literal></simpara> 
	</listitem>
        <listitem>
          <simpara><literal>gtk.gdk.BUTTON_MOTION_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.BUTTON1_MOTION_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.BUTTON2_MOTION_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.BUTTON3_MOTION_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.BUTTON_PRESS_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.BUTTON_RELEASE_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.KEY_PRESS_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.KEY_RELEASE_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.ENTER_NOTIFY_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.LEAVE_NOTIFY_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.FOCUS_CHANGE_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.STRUCTURE_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.PROPERTY_CHANGE_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.VISIBILITY_NOTIFY_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.PROXIMITY_IN_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.PROXIMITY_OUT_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.SUBSTRUCTURE_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.SCROLL_MASK</literal></simpara>
        </listitem>
        <listitem>
          <simpara><literal>gtk.gdk.ALL_EVENTS_MASK</literal></simpara>
        </listitem>
      </itemizedlist>

      <para><literal>gtk.gdk.ALL_EVENTS_MASK</literal> is a combination of
all the event masks.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-icon-list">
      <title>gtk.gdk.Window.set_icon_list</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_icon_list</methodname>
	  <methodparam><parameter role="keyword">pixbufs</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">pixbufs</parameter>&nbsp;:</term>
	  <listitem><simpara>a list (or tuple) containing pixbufs, of
	  different sizes.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The <methodname>set_icon_list</methodname>() method sets the
list of icons for the window. pixbufs is a list or tuple containing <link
linkend="class-gdkpixbuf"><classname>gtk.gdk.Pixbuf</classname></link>
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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-icon">
      <title>gtk.gdk.Window.set_icon</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_icon</methodname>
	  <methodparam><parameter
			 role="keyword">icon_window</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">pixmap</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">mask</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">icon_window</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> to
use for the icon</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">pixmap</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
linkend="class-gdkpixmap"><classname>gtk.gdk.Pixmap</classname></link> to
use as the icon</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">mask</parameter>&nbsp;:</term>
	  <listitem><simpara>a 1-bit pixmap (<literal>GdkBitmap</literal>)
to use as mask for <parameter>pixmap</parameter></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_icon</methodname>() method sets the icon of
the window as a <link
linkend="class-gdkpixmap"><classname>gtk.gdk.Pixmap</classname></link>
(specified by <parameter>pixmap</parameter>) or <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
specified by <parameter>icon_window</parameter>). Investigate the <link
linkend="function-gtk--window-set-default-icon-list"><methodname>gtk.window_set_default_icon_list()</methodname>()</link> 
function first, and then the <link
linkend="method-gtkwindow--set-icon-list"><methodname>gtk.Window.set_icon_list</methodname>()</link> 
and <link
linkend="method-gtkwindow--set-icon"><methodname>gtk.Window.set_icon</methodname>()</link> 
methods. If those don't meet your needs, look at the <link
linkend="method-gdkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method. Only if all those are too high-level do you want to fall back to the
<link
linkend="method-gdkwindow--set-icon"><methodname>set_icon</methodname>()</link>.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-icon-name">
      <title>gtk.gdk.Window.set_icon_name</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_icon_name</methodname>
	  <methodparam><parameter
			 role="keyword">name</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">name</parameter>&nbsp;:</term>
	  <listitem><simpara>the name of the window while iconified
(minimized)</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_icon_name</methodname>() method sets the
name of the window when it is iconified to the value of
<parameter>name</parameter>. 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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-group">
      <title>gtk.gdk.Window.set_group</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_group</methodname>
	  <methodparam><parameter
			 role="keyword">leader</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">leader</parameter>&nbsp;:</term>
	  <listitem><simpara>the group leader <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_group</methodname>() method sets the group
leader for the window to the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
specified by <parameter>leader</parameter>. By default, the group leader
for all toplevel windows is set to a global window implicitly created by
<literal>PyGTK</literal>. 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 <link
linkend="method-gdkwindow--show"><methodname>show</methodname>()</link>
method for example).</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-group">
      <title>gtk.gdk.Window.get_group</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_group</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the group leader <link
	  linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
	  for the window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.4 and above.</para>
      </note>

      <para>The <methodname>get_group</methodname>() method returns the
group leader <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> for
the window. See the <link
linkend="method-gdkwindow--set-group"><methodname>set_group()</methodname></link>
method for more information.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-decorations">
      <title>gtk.gdk.Window.set_decorations</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_decorations</methodname>
	  <methodparam><parameter
			 role="keyword">decorations</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">decorations</parameter>&nbsp;:</term>
	  <listitem><simpara>the decoration hint mask</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_decorations</methodname>() method sets the
specified decorations for the window. "Decorations" are the features the
window manager adds to a toplevel <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>. 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 <link
linkend="method-gtkwindow--set-decorated"><methodname>gtk.Window.set_decorated</methodname>()</link> 
method on a <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> instead
of using this method directly. The value of
<parameter>decorations</parameter> is the logical OR of the
following:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.DECOR_ALL</literal></term>
	  <listitem>
	    <simpara>All decorations should be applied.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.DECOR_BORDER</literal></term>
	  <listitem>
	    <simpara>A frame should be drawn around the window.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.DECOR_RESIZEH</literal></term>
	  <listitem>
	    <simpara>The frame should have resize handles.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.DECOR_TITLE</literal></term>
	  <listitem>
	    <simpara>A titlebar should be placed above the window.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.DECOR_MENU</literal></term>
	  <listitem>
	    <simpara>A button for opening a menu should be
included.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.DECOR_MINIMIZE</literal></term>
	  <listitem>
	    <simpara>A minimize button should be included.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.DECOR_MAXIMIZE</literal></term>
	  <listitem>
	    <simpara>A maximize button should be included.</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para>If <literal>gtk.gdk.DECOR_ALL</literal> is included in the mask,
the other bits indicate which decorations should be turned off. If
<literal>gtk.gdk.DECOR_ALL</literal> is not included, then the other bits
indicate which decorations should be turned on. Most window managers honor a
decorations hint of 0 to disable all decorations, but very few honor all
possible combinations of bits.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--get-decorations">
      <title>gtk.gdk.Window.get_decorations</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_decorations</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the window decorations</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_decorations</methodname>() method returns
the decorations set on the window with the <link
linkend="method-gdkwindow--set-decorations"><methodname>set_decorations</methodname></link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--set-functions">
      <title>gtk.gdk.Window.set_functions</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_functions</methodname>
	  <methodparam><parameter
			 role="keyword">functions</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">functions</parameter>&nbsp;:</term>
	  <listitem><simpara>the bitmask of operations to allow on the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>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
<parameter>functions</parameter> argument is the logical OR of the
following:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.FUNC_ALL</literal></term>
	  <listitem>
	    <simpara>All functions should be offered.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.FUNC_RESIZE</literal></term>
	  <listitem>
	    <simpara>The window should be resizable.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.FUNC_MOVE</literal></term>
	  <listitem>
	    <simpara>The window should be movable.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.FUNC_MINIMIZE</literal></term>
	  <listitem>
	    <simpara>The window should be minimizable.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.FUNC_MAXIMIZE</literal></term>
	  <listitem>
	    <simpara>The window should be maximizable.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.FUNC_CLOSE</literal></term>
	  <listitem>
	    <simpara>The window should be closeable.</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

      <para>If the bitmask includes <literal>gtk.gdk.FUNC_ALL</literal>,
then the other bits indicate which functions to disable; if it doesn't
include <literal>gtk.gdk.FUNC_ALL</literal>, it indicates which functions to
enable.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--iconify">
      <title>gtk.gdk.Window.iconify</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>iconify</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>iconify</methodname>() 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 <link
linkend="method-gtkwindow--iconify"><methodname>gtk.Window.iconify</methodname>()</link> 
method is preferred, if you have a <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>
widget.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--deiconify">
      <title>gtk.gdk.Window.deiconify</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>deiconify</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>deiconify</methodname>() 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 <link
linkend="method-gtkwindow--deiconify"><methodname>gtk.Window.deiconify</methodname>()</link> 
method is preferred. Or better yet, use the <link
linkend="method-gtkwindow--present"><methodname>gtk.Window.present</methodname>()</link>, 
which raises the window, focuses it, unminimizes it, and puts it on the
current desktop.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--stick">
      <title>gtk.gdk.Window.stick</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>stick</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>stick</methodname>() 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 <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>, the
<link
linkend="method-gtkwindow--stick"><methodname>gtk.Window.stick</methodname>()</link> 
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, <literal>PyGTK</literal> 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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--unstick">
      <title>gtk.gdk.Window.unstick</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>unstick</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>unstick</methodname>() method reverses the
effect of the <link
linkend="method-gdkwindow--stick"><methodname>stick</methodname>()</link>
method. See the <link
linkend="method-gdkwindow--stick"><methodname>stick</methodname>()</link>
and <link
linkend="method-gtkwindow--unstick"><methodname>gtk.Window.unstick</methodname>()</link> 
methods for more information.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--maximize">
      <title>gtk.gdk.Window.maximize</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>maximize</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>maximize</methodname>() 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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--unmaximize">
      <title>gtk.gdk.Window.unmaximize</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>unmaximize</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>unmaximize</methodname>() 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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--fullscreen">
      <title>gtk.gdk.Window.fullscreen</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>fullscreen</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
 
      <note>
	<para>This method is available in PyGTK 2.2 and above.</para>
      </note>

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

      <para>If the window was already fullscreen, then this method does
nothing.</para>

      <para>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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--unfullscreen">
      <title>gtk.gdk.Window.unfullscreen</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>unfullscreen</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>

      <note>
	<para>This method is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The <methodname>unfullscreen</methodname>() method moves the
window out of fullscreen mode. If the window was not fullscreen, does
nothing.</para>

      <para>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.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--register-dnd">
      <title>gtk.gdk.Window.register_dnd</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>register_dnd</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>register_dnd</methodname>() method registers the
window as a potential drop destination.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--begin-resize-drag">
      <title>gtk.gdk.Window.begin_resize_drag</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>begin_resize_drag</methodname>
	  <methodparam><parameter
			 role="keyword">edge</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">button</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">root_x</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">root_y</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">timestamp</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">edge</parameter>&nbsp;:</term>
	  <listitem><simpara>the edge or corner from which the drag is
started</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">button</parameter>&nbsp;:</term>
	  <listitem><simpara>the mouse button being used to
drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_x</parameter>&nbsp;:</term>
	  <listitem><simpara>the root window X coordinate of the mouse click
that began the drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_y</parameter>&nbsp;:</term>
	  <listitem><simpara>the root window Y coordinate of the mouse click
that began the drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">timestamp</parameter>&nbsp;:</term>
	  <listitem><simpara>the timestamp of the mouse click that began the
drag (use the <link
linkend="method-gdkevent--get-time"><methodname>gtk.gdk.Event.get_time</methodname>()</link> 
method)</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>begin_resize_drag</methodname>() method begins a
window resize operation (for a toplevel <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>) from
the specified <parameter>edge</parameter> using the specified
<parameter>button</parameter> starting at the location specified by
<parameter>root_x</parameter> and <parameter>root_y</parameter>. The value
of edge must be one of:</para>

      <variablelist>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_NORTH_WEST</literal></term>
	  <listitem>
	    <simpara>The top left corner.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_NORTH</literal></term>
	  <listitem>
	    <simpara>The top edge.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_NORTH_EAST</literal></term>
	  <listitem>
	    <simpara>The top right corner.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_WEST</literal></term>
	  <listitem>
	    <simpara>The left edge.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_EAST</literal></term>
	  <listitem>
	    <simpara>The right edge.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_SOUTH_WEST</literal></term>
	  <listitem>
	    <simpara>The lower left corner.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_SOUTH</literal></term>
	  <listitem>
	    <simpara>The lower edge.</simpara>
	  </listitem>
	</varlistentry>
	<varlistentry>
	  <term><literal>gtk.gdk.WINDOW_EDGE_SOUTH_EAST</literal></term>
	  <listitem>
	    <simpara>The lower right corner.</simpara>
	  </listitem>
	</varlistentry>
      </variablelist>

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

    </refsect2>

    <refsect2 id="method-gdkwindow--begin-move-drag">
      <title>gtk.gdk.Window.begin_move_drag</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>begin_move_drag</methodname>
	  <methodparam><parameter
			 role="keyword">button</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">root_x</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">root_y</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">timestamp</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">button</parameter>&nbsp;:</term>
	  <listitem><simpara>the button being used to
drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_x</parameter>&nbsp;:</term>
	  <listitem><simpara>the root window X coordinate of the mouse click
that began the drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_y</parameter>&nbsp;:</term>
	  <listitem><simpara>the root window Y coordinate of the mouse click
that began the drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">timestamp</parameter>&nbsp;:</term>
	  <listitem><simpara>the timestamp of the mouse click that began the
drag</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>begin_move_drag</methodname>() method begins a
window move operation (for a toplevel window) using the specified
<parameter>button</parameter> starting at the location specified by
<parameter>root_x</parameter> and <parameter>root_y</parameter>. 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 <ulink
linkend="http://www.freedesktop.org">http://www.freedesktop.org</ulink>),
but has a fallback implementation for other window managers.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--invalidate-rect">
      <title>gtk.gdk.Window.invalidate_rect</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>invalidate_rect</methodname>
	  <methodparam><parameter
			 role="keyword">rect</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">invalidate_children</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">rect</parameter>&nbsp;:</term>
	  <listitem><simpara>the rectangle to
invalidate</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">invalidate_children</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> invalidate child
<link linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
objects</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>invalidate_rect</methodname>() method
invalidates the rectangular region specified by rect. If
<parameter>invalidate_children</parameter> is <literal>TRUE</literal> the
child <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
object of the window are also invalidated.</para>

    </refsect2>

<!-- NOT IMPLEMENTED
  <refsect2 id="method-gdkwindow- -invalidate-region">
    <title>gtk.gdk.Window.invalidate_region</title>

<programlisting><methodsynopsis language="python">
    <methodname>invalidate_region</methodname>
    <methodparam><parameter role="keyword">region</parameter></methodparam>
    <methodparam><parameter role="keyword">invalidate_children</parameter></methodparam>
  </methodsynopsis></programlisting>
  <variablelist>
    <varlistentry>
      <term><parameter role="keyword">region</parameter>&nbsp;:</term>
      <listitem><simpara>a <literal>GdkRegion</literal></simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><parameter role="keyword">invalidate_children</parameter>&nbsp;:</term>
      <listitem><simpara><literal>TRUE</literal> to also invalidate child windows</simpara></listitem>
    </varlistentry>
  </variablelist>
<para>
Adds <parameter>region</parameter> to the update area for the window. The update area is the
region that needs to be redrawn, or "dirty region." The call
<link linkend="method-gdkwindow- -process-updates"><function>gtk.gdk.Window.process_updates()</function></link> 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.
</para>
<para>
GDK will call <function>window_process_all_updates()</function> 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.
</para>
<para>
The <parameter>invalidate_children</parameter> parameter controls whether the region of
each child window that intersects <parameter>region</parameter> will also be invalidated.
If <literal>FALSE</literal>, then the update area for child windows will remain
unaffected. See gdk_window_invalidate_maybe_recurse if you need
fine grained control over which children are invalidated.
</para>  </refsect2>


  <refsect2 id="method-gdkwindow- -invalidate-maybe-recurse">
    <title>gtk.gdk.Window.invalidate_maybe_recurse</title>

<programlisting><methodsynopsis language="python">
    <methodname>invalidate_maybe_recurse</methodname>
    <methodparam><parameter role="keyword">region</parameter></methodparam>
    <methodparam><parameter role="keyword">(*child_func</parameter></methodparam>
  </methodsynopsis></programlisting>
  <variablelist>
    <varlistentry>
      <term><parameter role="keyword">region</parameter>&nbsp;:</term>
      <listitem><simpara>a <literal>GdkRegion</literal></simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><parameter role="keyword">(*child_func</parameter>&nbsp;:</term>
      <listitem><simpara></simpara></listitem>
    </varlistentry>
  </variablelist>
<para>
Adds <parameter>region</parameter> to the update area for the window. The update area is the
region that needs to be redrawn, or "dirty region." The call
<link linkend="method-gdkwindow- -process-updates"><function>gtk.gdk.Window.process_updates()</function></link> 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.
</para>
<para>
GDK will call <function>window_process_all_updates()</function> 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.
</para>
<para>
The <parameter>child_func</parameter> parameter controls whether the region of
each child window that intersects <parameter>region</parameter> will also be invalidated.
Only children for which <parameter>child_func</parameter> returns TRUE will have the area
invalidated.
</para>  </refsect2>


  <refsect2 id="method-gdkwindow- -get-update-area">
    <title>gtk.gdk.Window.get_update_area</title>

<programlisting><methodsynopsis language="python">
    <methodname>get_update_area</methodname>
    <methodparam></methodparam>
      </methodsynopsis></programlisting>
  <variablelist>
    <varlistentry>
      <term><emphasis>Returns</emphasis>&nbsp;:</term>
      <listitem><simpara>the update area for the window</simpara></listitem>
    </varlistentry>
  </variablelist>
<para>
Transfers ownership of the update area from the window to the caller
of the function. That is, after calling this function, the window will
no longer have an invalid/dirty region; the update area is removed
from the window and handed to you. If a window has no update area,
<link linkend="method-gdkwindow- -get-update-area"><function>gtk.gdk.Window.get_update_area()</function></link> returns <literal>NULL</literal>. You are responsible for
calling <function>gdk_region_destroy()</function> on the returned region if it's non-<literal>NULL</literal>.
</para>  </refsect2>
END NOT IMPLEMENTED -->

    <refsect2 id="method-gdkwindow--freeze-updates">
      <title>gtk.gdk.Window.freeze_updates</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>freeze_updates</methodname>
	  <methodparam></methodparam>
      </methodsynopsis></programlisting>

      <para>The <methodname>freeze_updates</methodname>() method temporarily
freezes the window such that it won't receive expose events. The window will
begin receiving expose events again when the <link
linkend="method-gdkwindow--thaw-updates"><methodname>thaw_updates</methodname>()</link> 
method is called. If the <methodname>freeze_updates</methodname>() method
has been called more than once, the <link
linkend="method-gdkwindow--thaw-updates"><methodname>thaw_updates</methodname>()</link> 
method must be called an equal number of times to begin processing
exposes.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--thaw-updates">
      <title>gtk.gdk.Window.thaw_updates</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>thaw_updates</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>

      <para>The <methodname>thaw_updates</methodname>() method thaws a
window frozen with the <link
linkend="method-gdkwindow--freeze-updates"><methodname>freeze_updates</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gdkwindow--process-updates">
      <title>gtk.gdk.Window.process_updates</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>process_updates</methodname>
	  <methodparam><parameter
			 role="keyword">update_children</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">update_children</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> process updates for
child windows</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>process_updates</methodname>() 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 <link
linkend="method-gdkwindow--invalidate-rect"><methodname>invalidate_rect</methodname>()</link> 
method for details). Normally <literal>PyGTK</literal> calls the <link
linkend="function-gdk--window-process-all-updates"><methodname>gtk.gdk.window_process_all_updates</methodname>()</link> 
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 <literal>PyGTK</literal> delivers them in an idle
handler). Occasionally this is useful to produce nicer scrolling behavior,
for example.</para>

    </refsect2>

<!-- NOT IMPLEMENTED
  <refsect2 id="method-gdkwindow- -get-internal-paint-info">
    <title>gtk.gdk.Window.get_internal_paint_info</title>

<programlisting><methodsynopsis language="python">
    <methodname>get_internal_paint_info</methodname>
    <methodparam><parameter role="keyword">real_drawable</parameter></methodparam>
    <methodparam><parameter role="keyword">x_offset</parameter></methodparam>
    <methodparam><parameter role="keyword">y_offset</parameter></methodparam>
  </methodsynopsis></programlisting>
  <variablelist>
    <varlistentry>
      <term><parameter role="keyword">real_drawable</parameter>&nbsp;:</term>
      <listitem><simpara>location to store the drawable to which drawing should be 
done.</simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><parameter role="keyword">x_offset</parameter>&nbsp;:</term>
      <listitem><simpara>location to store the X offset between coordinates in the window,
and the underlying window system primitive coordinates for 
*<parameter>real_drawable</parameter>.</simpara></listitem>
    </varlistentry>
    <varlistentry>
      <term><parameter role="keyword">y_offset</parameter>&nbsp;:</term>
      <listitem><simpara>location to store the Y offset between coordinates in the window,
and the underlying window system primitive coordinates for
*<parameter>real_drawable</parameter>.</simpara></listitem>
    </varlistentry>
  </variablelist>
<para>
If you bypass the GDK layer and use windowing system primitives to
draw directly onto a <link linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>, then you need to deal with two
details: there may be an offset between GDK coordinates and windowing
system coordinates, and GDK may have redirected drawing to a offscreen
pixmap as the result of a <link linkend="method-gdkwindow- -begin-paint-region"><function>gtk.gdk.Window.begin_paint_region()</function></link> calls.
This function allows retrieving the information you need to compensate
for these effects.
</para>
<para>
This function exposes details of the GDK implementation, and is thus
likely to change in future releases of GDK.
</para>  </refsect2>
END NOT IMPLEMENTED -->

    <refsect2 id="method-gdkwindow--set-accept-focus">
      <title>gtk.gdk.Window.set_accept_focus</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_accept_focus</methodname>
	  <methodparam><parameter role="keyword">accept_focus</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
	  role="keyword">accept_focus</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal>, the window should
	  receive input focus</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This method is available in PyGTK 2.4 and above.</para>
      </note>

      <para>The <methodname>set_accept_focus</methodname>() method sets the
"accept_focus setting to the value of
<parameter>accept_focus</parameter>. If <parameter>accept_focus</parameter>
is <literal>TRUE</literal> the window will accept focus; if
<literal>FALSE</literal> hints to the desktop environment that the window
doesn't want to receive input focus.</para>

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

    </refsect2>

  </refsect1>

  <refsect1>
    <title>Functions</title>

    <refsect2 id="function-gdk--window-foreign-new">
      <title>gtk.gdk.window_foreign_new</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.window_foreign_new</methodname>
	  <methodparam><parameter
			 role="keyword">anid</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">anid</parameter>&nbsp;:</term>
	  <listitem><simpara>a native window system ID</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the new <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
wrapper for the native window or <literal>None</literal> if the window has
been destroyed.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <function>gtk.gdk.window_foreign_new</function>() function
wraps a native window specified by <parameter>anid</parameter> for the default display in a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>. This
may fail if the window has been destroyed. For example in the X Window
System backend, a native window handle is an Xlib
<literal>XID</literal>.</para>

    </refsect2>

    <refsect2 id="function-gdk--window-foreign-new-for-display">
      <title>gtk.gdk.window_foreign_new_for_display</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.window_foreign_new_for_display</methodname>
	  <methodparam><parameter
			 role="keyword">display</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">anid</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">display</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
	  linkend="class-gdkdisplay"><classname>gtk.gdk.Display</classname></link></simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">anid</parameter>&nbsp;:</term>
	  <listitem><simpara>a native window system ID</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the new <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
wrapper for the native window or <literal>None</literal> if the window has
been destroyed.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This function is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The
<function>gtk.gdk.window_foreign_new_for_display</function>() function wraps
a native window specified by <parameter>anid</parameter> for the <link
linkend="class-gdkdisplay"><classname>gtk.gdk.Display</classname></link>
specified by <parameter>display</parameter> in a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>. This
may fail if the window has been destroyed. For example in the X Window
System backend, a native window handle is an Xlib
<literal>XID</literal>.</para>

    </refsect2>

    <refsect2 id="function-gdk--get-default-root-window">
      <title>gtk.gdk.get_default_root_window</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.get_default_root_window</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara> the default root <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <function>gtk.gdk.get_default_root_window</function>()
function returns the root <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> (the
parent window that all other windows are inside) for the default display and
screen.</para>

    </refsect2>

    <refsect2 id="function-gdk--window-get-toplevels">
      <title>gtk.gdk.window_get_toplevels</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.window_get_toplevels</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a list containing the toplevel <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
object</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <function>gtk.gdk.window_get_toplevels</function>() function
returns a list of all toplevel windows known to <literal>PyGTK</literal> on
the default screen. A toplevel window is a child of the root window (see the
<link
linkend="function-gdk--get-default-root-window">gtk.gdk.get_default_root_window</link>() 
function).</para>

    </refsect2>

    <refsect2 id="function-gdk--window-lookup">
      <title>gtk.gdk.window_lookup</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.window_lookup</methodname>
	  <methodparam><parameter
			 role="keyword">anid</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">anid</parameter>&nbsp;:</term>
	  <listitem><simpara>a native window system ID</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
wrapper for the native window or <literal>None</literal> if there is
none.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <function>gtk.gdk.window_lookup</function>() function looks
up the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> that
wraps the native window handle specified by <parameter>anid</parameter>. For
example in the X Window System backend, a native window handle is an Xlib
<literal>XID</literal>.</para>

    </refsect2>

    <refsect2 id="function-gdk--window-lookup-for-display">
      <title>gtk.gdk.window_lookup_for_display</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.window_lookup_for_display</methodname>
	  <methodparam><parameter
			 role="keyword">display</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">anid</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">display</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
	  linkend="class-gdkdisplay"><classname>gtk.gdk.Display</classname></link></simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">anid</parameter>&nbsp;:</term>
	  <listitem><simpara>a native window system ID</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
wrapper for the native window or <literal>None</literal> if there is
none.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This function is available in PyGTK 2.2 and above.</para>
      </note>

      <para>The <function>gtk.gdk.window_lookup_for_display</function>()
function looks up the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> that
wraps the native window handle specified by <parameter>anid</parameter> for
the <link
linkend="class-gdkdisplay"><classname>gtk.gdk.Display</classname></link>
specified by <parameter>display</parameter>. For example in the X Window
System backend, a native window handle is an Xlib
<literal>XID</literal>.</para>

    </refsect2>

    <refsect2 id="function-gdk--window-process-all-updates">
      <title>gtk.gdk.window_process_all_updates</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.window_process_all_updates</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>

      <para>The <function>gtk.gdk.process_all_updates</function>() function
calls the <link
linkend="method-gdkwindow--process-updates"><methodname>process_updates</methodname>()</link> 
method fo each <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> in
the application.</para>

    </refsect2>

    <refsect2 id="function-gdk--gdk-window-set-debug-updates">
      <title>gtk.gdk.gdk_window_set_debug_updates</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.gdk_window_set_debug_updates</methodname>
	  <methodparam><parameter
			 role="keyword">setting</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>TRUE</literal> enable update
debugging</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <function>gtk.gdk.gdk_set_debug_updates</function>() function
sets the update debugging flag to the value of
<parameter>setting</parameter>. If <parameter>setting</parameter> is
<literal>TRUE</literal>, update debugging is enabled. With update debugging
enabled, calls to the <link
linkend="method-gdkwindow--invalidate-rect"><methodname>invalidate_rect</methodname>()</link> 
method clear the invalidated rectangle of the screen to a noticeable color,
and <literal>PyGTK</literal> pauses for a short time before sending exposes
to windows during the <link
linkend="method-gdkwindow--process-updates"><methodname>process_updates</methodname>()</link> 
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
<literal>GDK</literal> 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
<literal>PyGTK</literal> to flicker slowly and noticeably, so you can see
exactly what's being redrawn when, in what order.</para>

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

    </refsect2>

    <refsect2 id="function-gdk--window-at-pointer">
      <title>gtk.gdk.window_at_pointer</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.gdk.window_at_pointer</methodname>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a 3 tuple containing the <link
	  linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
	  and the pointer location in the window or
	  <literal>None</literal>.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <note>
	<para>This function is available in PyGTK 2.4 and above.</para>
      </note>

      <para>The <function>gtk.gdk.window_at_pointer</function>() function
returns a 3-tuple containing the <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
underneath the mouse pointer, and the location of the pointer in the
window. This function returns <literal>None</literal> if the window under
the mouse pointer is not known to GDK (if the window belongs to another
application and a <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>
hasn't been created for it with the <link
linkend="function-gdk--window-foreign-new"><function>gtk.gdk.window_foreign_new</function>()</link>
function)</para>

      <note>
	  <para>For multi-head-aware widgets or applications use the <link
linkend="method-gdkdisplay--get-window-at-pointer"><methodname>gtk.gdk.Display.get_window_at_pointer</methodname>()</link>
method instead.</para>
      </note>

    </refsect2>

  </refsect1>

</refentry>