<?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-gtkwindow">
  <refnamediv>
    <refname>gtk.Window</refname>
    <refpurpose>a top-level window that holds one child widget.</refpurpose>
  </refnamediv>

  <refsect1>
    <title>Synopsis</title>

    <classsynopsis language="python">
      <ooclass><classname>gtk.Window</classname></ooclass>
      <ooclass><classname><link linkend="class-gtkbin">gtk.Bin</link></classname></ooclass>
      <constructorsynopsis language="python">
        <methodname><link linkend="constructor-gtkwindow">gtk.Window</link></methodname>
        <methodparam><parameter role="keyword">type</parameter>
        <initializer>gtk.WINDOW_TOPLEVEL</initializer></methodparam>
      </constructorsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-title">set_title</link></methodname>
        <methodparam><parameter role="keyword">title</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-title">get_title</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-wmclass">set_wmclass</link></methodname>
        <methodparam><parameter role="keyword">wmclass_name</parameter></methodparam>
        <methodparam><parameter role="keyword">wmclass_class</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-role">set_role</link></methodname>
        <methodparam><parameter role="keyword">role</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-role">get_role</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--add-accel-group">add_accel_group</link></methodname>
        <methodparam><parameter role="keyword">accel_group</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--remove-accel-group">remove_accel_group</link></methodname>
        <methodparam><parameter role="keyword">accel_group</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-position">set_position</link></methodname>
        <methodparam><parameter role="keyword">position</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--activate-focus">activate_focus</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-focus">set_focus</link></methodname>
        <methodparam><parameter role="keyword">focus</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-focus">get_focus</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-default">set_default</link></methodname>
        <methodparam><parameter role="keyword">default_widget</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--activate-default">activate_default</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-transient-for">set_transient_for</link></methodname>
        <methodparam><parameter role="keyword">parent</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-transient-for">get_transient_for</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-type-hint">set_type_hint</link></methodname>
        <methodparam><parameter role="keyword">hint</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-type-hint">get_type_hint</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-destroy-with-parent">set_destroy_with_parent</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-destroy-with-parent">get_destroy_with_parent</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-resizable">set_resizable</link></methodname>
        <methodparam><parameter role="keyword">resizable</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-resizable">get_resizable</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-gravity">set_gravity</link></methodname>
        <methodparam><parameter role="keyword">gravity</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-gravity">get_gravity</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-geometry-hints">set_geometry_hints</link></methodname>
        <methodparam><parameter role="keyword">geometry_widget</parameter></methodparam>
        <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-gtkwindow--set-screen">set_screen</link></methodname>
        <methodparam><parameter role="keyword">screen</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-screen">get_screen</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--is-active">is_active</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--has-toplevel-focus">has_toplevel_focus</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-has-frame">set_has_frame</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-has-frame">get_has_frame</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-frame-dimensions">set_frame_dimensions</link></methodname>
        <methodparam><parameter role="keyword">left</parameter></methodparam>
        <methodparam><parameter role="keyword">top</parameter></methodparam>
        <methodparam><parameter role="keyword">right</parameter></methodparam>
        <methodparam><parameter role="keyword">bottom</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-frame-dimensions">get_frame_dimensions</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-decorated">set_decorated</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-decorated">get_decorated</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-icon-list">set_icon_list</link></methodname>
        <methodparam><parameter>...</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-icon-list">get_icon_list</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-icon">set_icon</link></methodname>
        <methodparam><parameter role="keyword">icon</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-icon-from-file">set_icon_from_file</link></methodname>
        <methodparam><parameter role="keyword">filename</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-icon">get_icon</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-modal">set_modal</link></methodname>
        <methodparam><parameter role="keyword">modal</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-modal">get_modal</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--add-mnemonic">add_mnemonic</link></methodname>
        <methodparam><parameter role="keyword">keyval</parameter></methodparam>
        <methodparam><parameter role="keyword">target</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--remove-mnemonic">remove_mnemonic</link></methodname>
        <methodparam><parameter role="keyword">keyval</parameter></methodparam>
        <methodparam><parameter role="keyword">target</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--mnemonic-activate">mnemonic_activate</link></methodname>
        <methodparam><parameter role="keyword">keyval</parameter></methodparam>
        <methodparam><parameter role="keyword">modifier</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-mnemonic-modifier">set_mnemonic_modifier</link></methodname>
        <methodparam><parameter role="keyword">modifier</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-mnemonic-modifier">get_mnemonic_modifier</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-mnemonics-visible">set_mnemonics_visible</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-mnemonics-visible">get_mnemonics_visible</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--activate-key">activate_key</link></methodname>
        <methodparam><parameter role="keyword">event</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--propagate-key-event">propagate_key_event</link></methodname>
        <methodparam><parameter role="keyword">event</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--present">present</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--iconify">iconify</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--deiconify">deiconify</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--stick">stick</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--unstick">unstick</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--maximize">maximize</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--unmaximize">unmaximize</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--fullscreen">fullscreen</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--unfullscreen">unfullscreen</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-keep-above">set_keep_above</link></methodname>
        <methodparam><parameter>setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-keep-below">set_keep_below</link></methodname>
        <methodparam><parameter>setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--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-gtkwindow--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-gtkwindow--set-default-size">set_default_size</link></methodname>
        <methodparam><parameter role="keyword">width</parameter></methodparam>
        <methodparam><parameter role="keyword">height</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-default-size">get_default_size</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--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-gtkwindow--get-size">get_size</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--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-gtkwindow--get-position">get_position</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--parse-geometry">parse_geometry</link></methodname>
        <methodparam><parameter role="keyword">geometry</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--reshow-with-initial-size">reshow_with_initial_size</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--tooltips-get-info-from-tip-window">tooltips_get_info_from_tip_window</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-focus-on-map">set_focus_on_map</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-focus-on-map">get_focus_on_map</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-icon-name">set_icon_name</link></methodname>
        <methodparam><parameter role="keyword">name</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-icon-name">get_icon_name</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-urgency-hint">set_urgency_hint</link></methodname>
        <methodparam><parameter role="keyword">urgency_hint</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-urgency-hint">get_urgency_hint</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--present-with-time">present_with_time</link></methodname>
        <methodparam><parameter role="keyword">timestamp</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-deletable">set_deletable</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-deletable">get_deletable</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-group">get_group</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--has-group">has_group</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-window-type">get_window_type</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-opacity">set_opacity</link></methodname>
        <methodparam><parameter role="keyword">opacity</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-opacity">get_opacity</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-startup-id">set_startup_id</link></methodname>
        <methodparam><parameter role="keyword">startup_id</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-default-widget">get_default_widget</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-skip-taskbar-hint">set_skip_taskbar_hint</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-skip-taskbar-hint">get_skip_taskbar_hint</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-skip-pager-hint">set_skip_pager_hint</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-skip-pager-hint">get_skip_pager_hint</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--set-accept-focus">set_accept_focus</link></methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis>
      <methodsynopsis language="python">
        <methodname><link linkend="method-gtkwindow--get-accept-focus">get_accept_focus</link></methodname>
        <methodparam></methodparam>
      </methodsynopsis>
     </classsynopsis>

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

<methodsynopsis language="python">
	<methodname><link
linkend="function-gtk--window-set-default-icon">gtk.window_set_default_icon</link></methodname>
	<methodparam><parameter role="keyword">icon</parameter></methodparam> </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gtk--window-set-default-icon-from-file">gtk.window_set_default_icon_from_file</link></methodname>
	<methodparam><parameter role="keyword">filename</parameter></methodparam> </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gtk--window-set-default-icon-list">gtk.window_set_default_icon_list</link></methodname>
	<methodparam><parameter>...</parameter></methodparam> </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gtk--window-get-default-icon-list">gtk.window_get_default_icon_list</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link linkend="function-gtk--window-set-auto-startup-notification">gtk.window_set_auto_startup_notification</link></methodname>
	<methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link linkend="function-gtk--window-list-toplevels">gtk.window_list_toplevels</link></methodname>
	<methodparam></methodparam>
      </methodsynopsis><methodsynopsis language="python">
	<methodname><link
linkend="function-gtk--window-set-default-icon-name">gtk.window_set_default_icon_name</link></methodname>
	<methodparam><parameter
		       role="keyword">name</parameter></methodparam>
      </methodsynopsis></programlisting>

  </refsect1>

  <refsect1>
    <title>Ancestry</title>

<synopsis>+-- <link linkend="class-gobject">gobject.GObject</link>
  +-- <link linkend="class-gtkobject">gtk.Object</link>
    +-- <link linkend="class-gtkwidget">gtk.Widget</link>
      +-- <link linkend="class-gtkcontainer">gtk.Container</link>
        +-- <link linkend="class-gtkbin">gtk.Bin</link>
          +-- <link linkend="class-gtkwindow">gtk.Window</link>
</synopsis>

  </refsect1>
  
  <refsect1>
		<title>Implemented Interfaces</title>
		<para>
			<link linkend="class-gtkwindow"><classname>gtk.Window</classname></link>
			implements 
			<link linkend="class-gtkbuildable"><classname>gtk.Buildable</classname></link>
		</para>
	</refsect1>


  <refsect1 id="properties-gtkwindow">
    <title>gtk.Window Properties</title>

    <para><link linkend="properties-gtkobject">gtk.Object Properties</link></para>
    <para><link linkend="properties-gtkwidget">gtk.Widget Properties</link></para>
    <para><link linkend="properties-gtkcontainer">gtk.Container Properties</link></para>

    <blockquote role="properties">
      <informaltable pgwide="1" frame="none">
	<tgroup cols="3">
	  <colspec column="1" colwidth="1in"/>
	  <colspec column="2" colwidth="1in"/>
	  <colspec column="3" colwidth="4in"/>
	  <tbody>

	    <row valign="top">
	      <entry>"accept-focus"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window should receive
the input focus. Default value: <literal>True</literal>. Available in GTK+
2.4 and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"allow-grow"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the user can expand the
window beyond its minimum size. Default value: <literal>True</literal>.</entry>
	    </row>

	    <row valign="top">
	      <entry>"allow-shrink"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window has no minimum
size. Setting this to <literal>True</literal> is a bad
idea 99% of the time. Default value: <literal>False</literal>.</entry>
	    </row>

	    <row valign="top">
	      <entry>"decorated"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window should be
decorated by the window manager. Default value: <literal>True</literal>.
Available in GTK+ 2.4 and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"default-height"</entry>
	      <entry>Read-Write</entry>
	      <entry>The default height of the window, used when initially
showing the window. Allowed values: >= -1. Default value: -1</entry>
	    </row>

	    <row valign="top">
	      <entry>"default-width"</entry>
	      <entry>Read-Write</entry>
	      <entry>The default width of the window, used when initially
showing the window. Allowed values: >= -1. Default value: -1</entry>
	    </row>

            <row valign="top">
              <entry>"deletable"</entry>
              <entry>Read-Write</entry>
              <entry>If <literal>True</literal> the window frame should have
              a close button.  This property is available in GTK+ 2.10 and
              above.</entry>
            </row>

	    <row valign="top">
	      <entry>"destroy-with-parent"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window should be
destroyed when its parent is destroyed. Default value:
<literal>False</literal>.</entry>
	    </row>

	    <row valign="top">
	      <entry>"focus-on-map"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window should
receive the input focus when mapped. Default value:
<literal>True</literal>. Available in GTK+ 2.6 and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"gravity"</entry>
	      <entry>Read-Write</entry>

	      <entry>The window gravity of the window. See the <link
linkend="method-gtkwindow--move"><methodname>move</methodname>()</link>
method and the <xref linkend="gdk-gravity-constants"
endterm="gdk-gravity-constants-title"></xref> for more details about window
gravity. Default value:
<literal>gtk.gdk.GRAVITY_NORTH_WEST</literal>. Available in GTK+ 2.4 and
above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"has-toplevel-focus"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal>, the input focus is within
the window. Default value: <literal>False</literal>. Available in GTK+ 2.2
and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"icon"</entry>
	      <entry>Read-Write</entry>
	      <entry>The icon for this window</entry>
	    </row>

	    <row valign="top">
	      <entry>"icon-name"</entry>
	      <entry>Read-Write</entry>
	      <entry>The name of the themed icon to use as the window icon.
See <link
linkend="class-gtkicontheme"><classname>gtk.IconTheme</classname></link>
for more details. Default value: <literal>None</literal>. Available in
GTK+ 2.6 and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"is-active"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal>, the toplevel is the current
active window. Default value: <literal>False</literal>. Available in GTK+ 2.2
and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"mnemonics-visible"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, mnemonics are currently visible in
        the window. Default value: <literal>True</literal>.</entry>
	    </row>

	    <row valign="top">
	      <entry>"modal"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window is modal (other
windows are not usable while this one is up). Default value:
<literal>False</literal>.</entry>
	    </row>
        
        <row valign="top">
	      <entry>"opacity"</entry>
	      <entry>Read-Write</entry>
	      <entry>The requested opacity of the window. See
          <methodname><link linkend="method-gtkwindow--set-opacity">gtk.Window.set_opacity</link></methodname>()
          for more details about window opacity.
          Allowed values: [0,1] Default value: 1.
          Available in GTK+ 2.12.</entry>
	    </row>

	    <row valign="top">
	      <entry>"resizable"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the user can resize the
window. Default value: <literal>True</literal>.</entry>
	    </row>

	    <row valign="top">
	      <entry>"role"</entry>
	      <entry>Read-Write</entry>
	      <entry>Unique identifier for the window to be used when
restoring a session. Default value: <literal>None</literal>. Available in
GTK+ 2.4</entry>
	    </row>

	    <row valign="top">
	      <entry>"screen"</entry>
	      <entry>Read-Write</entry>
	      <entry>The screen where this window will be displayed.
Available in GTK+ 2.2</entry>
	    </row>

	    <row valign="top">
	      <entry>"skip-pager-hint"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window should not be
in the pager. Default value: <literal>False</literal>. Available in GTK+ 2.2
and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"skip-taskbar-hint"</entry>
	      <entry>Read-Write</entry>
	      <entry>If <literal>True</literal>, the window should not be
in the task bar. Default value: <literal>False</literal>. Available in GTK+
2.2 and above.</entry>
	    </row>
        
        <row valign="top">
	      <entry>"startup-id"</entry>
	      <entry>Write</entry>
	      <entry>The :startup-id is a write-only property for setting window's
          startup notification identifier. See
          <methodname><link linkend="method-gtkwindow--set-startup-id">gtk.Window.set_startup_id</link></methodname>()
          for more details. Default value: NULL.
          Available in GTK+ 2.12 and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"title"</entry>
	      <entry>Read-Write</entry>
	      <entry>The title of the window. Default value: <literal>None</literal>.</entry>
	    </row>

        <row valign="top">
          <entry>"transient-for"</entry>
          <entry>Read-Write-Construct</entry>
          <entry>The transient parent of the window. See <link
          linkend="method-gtkwindow--set-transient-for"><methodname>gtk.Window.set_transient_for()</methodname></link>
          for more details about transient windows.  This property is
          available in GTK+ 2.10 and above.</entry>
        </row>

	    <row valign="top">
	      <entry>"type"</entry>
	      <entry>Read-Write</entry>
	      <entry>The type of the window. Default value:
<literal>gtk.WINDOW_TOPLEVEL</literal></entry>
	    </row>

	    <row valign="top">
	      <entry>"type-hint"</entry>
	      <entry>Read-Write</entry>
	      <entry>Hint to help the desktop environment understand what
kind of window this is and how to treat it. Default value:
<literal>gtk.gdk.WINDOW_TYPE_HINT_NORMAL</literal>. Available in GTK+ 2.2
and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"urgency-hint"</entry>
	      <entry>Read-Write</entry>
	      <entry>If True the window should be brought to the users
attention. Default value: <literal>False</literal>. Available in GTK+ 2.8
and above.</entry>
	    </row>

	    <row valign="top">
	      <entry>"window-position"</entry>
	      <entry>Read-Write</entry>
	      <entry>The initial position of the window. Default value:
<literal>gtk.WIN_POS_NONE</literal></entry>
	    </row>

	  </tbody>
	</tgroup>
      </informaltable>
    </blockquote>

  </refsect1>

  <refsect1 id="style-properties-gtkwindow">
    <title>gtk.Window Style Properties</title>

    <para><link linkend="style-properties-gtkwidget">gtk.Widget Style Properties</link></para>

  </refsect1>

  <refsect1>
    <title>Attributes</title>

    <blockquote role="properties">
      <informaltable pgwide="1" frame="none">
	<tgroup cols="3">
	<?dbhtml cellpadding="5"?>
	  <colspec column="1" colwidth="1in"/>
	  <colspec column="2" colwidth="1in"/>
	  <colspec column="3" colwidth="4in"/>
	  <tbody>

	    <row valign="top">
	      <entry>"allow_grow"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal>, users can expand the window
beyond its minimum size.</entry>
	    </row>

	    <row valign="top">
	      <entry>"allow_shrink"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal>, the window has no minimum
size.</entry>
	    </row>

	    <row valign="top">
	      <entry>"configure_notify_received"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> a window resize
configuration event has been received.</entry>
	    </row>

	    <row valign="top">
	      <entry>"configure_request_count"</entry>
	      <entry>Read</entry>
	      <entry>The number of outstanding configuration
requests.</entry>
	    </row>

	    <row valign="top">
	      <entry>"decorated"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window will have
decorations like a titlebar, resize controls, etc. See the <link
linkend="method-gtkwindow--set-decorated"><methodname>set_decorated</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"default_widget"</entry>
	      <entry>Read</entry>
	      <entry>The child widget that will be activated by default. See
the <link
linkend="method-gtkwindow--set-default"><methodname>set_default</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"destroy_with_parent"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window is destroyed when
its transient parent is destroyed.</entry>
	    </row>

	    <row valign="top">
	      <entry>"focus_widget"</entry>
	      <entry>Read</entry>
	      <entry>The child widget that has the focus.</entry>
	    </row>

	    <row valign="top">
	      <entry>"frame"</entry>
	      <entry>Read</entry>
	      <entry>The frame <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link> (if
any). See the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
and <link
linkend="method-gtkwindow--set-frame-dimensions"><methodname>set_frame_dimensions</methodname>()</link> 
methods.</entry>
	    </row>

	    <row valign="top">
	      <entry>"frame_bottom"</entry>
	      <entry>Read</entry>
	      <entry>The height of the bottom frame border. See the <link
linkend="method-gtkwindow--set-frame-dimensions"><methodname>set_frame_dimensions</methodname>()</link> 
and <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
methods.</entry>
	    </row>

	    <row valign="top">
	      <entry>"frame_left"</entry>
	      <entry>Read</entry>
	      <entry>The width of the left frame border. See the <link
linkend="method-gtkwindow--set-frame-dimensions"><methodname>set_frame_dimensions</methodname>()</link> 
and <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
methods.</entry>
	    </row>

	    <row valign="top">
	      <entry>"frame_right"</entry>
	      <entry>Read</entry>
	      <entry>The width of the right frame border. See the <link
linkend="method-gtkwindow--set-frame-dimensions"><methodname>set_frame_dimensions</methodname>()</link> 
and <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
methods.</entry>
	    </row>

	    <row valign="top">
	      <entry>"frame_top"</entry>
	      <entry>Read</entry>
	      <entry>The height of the top frame border. See the <link
linkend="method-gtkwindow--set-frame-dimensions"><methodname>set_frame_dimensions</methodname>()</link> 
and <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
methods.</entry>
	    </row>

	    <row valign="top">
	      <entry>"gravity"</entry>
	      <entry>Read</entry>
	      <entry>The window's gravity. See the <link
linkend="method-gtkwindow--move"><methodname>move</methodname>()</link> and
<link
linkend="method-gtkwindow--set-gravity"><methodname>set_gravity</methodname>()</link> 
methods.</entry>
	    </row>

	    <row valign="top">
	      <entry>"group"</entry>
	      <entry>Read</entry>
	      <entry>The <link
linkend="class-gtkwindowgroup"><classname>gtk.WindowGroup</classname></link>
(if any) the window belongs to.</entry>
	    </row>

	    <row valign="top">
	      <entry>"has_focus"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window has the
focus.</entry>
	    </row>

	    <row valign="top">
	      <entry>"has_frame"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window has a frame
window. See the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"has_user_ref_count"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window has not been
destroyed.</entry>
	    </row>

	    <row valign="top">
	      <entry>"iconify_initially"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window has been
iconified by a call to the <link
linkend="method-gtkwindow--iconify"><methodname>iconify</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"keys_changed_handler"</entry>
	      <entry>Read</entry>
	      <entry>The idle handler ID for handling accelerator group
changes.</entry>
	    </row>

	    <row valign="top">
	      <entry>"maximize_initially"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window has been
maximized by a call to the <link
linkend="method-gtkwindow--maximize"><methodname>maximize</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"mnemonic_modifier"</entry>
	      <entry>Read</entry>
	      <entry>The mnemonic modifier used with a key to activate an
accelerator. See the <link
linkend="method-gtkwindow--set-mnemonic-modifier"><methodname>set_mnemonic_modifier</methodname>()</link> 
method </entry>
	    </row>

	    <row valign="top">
	      <entry>"modal"</entry>
	      <entry>Read</entry>
	      <entry>If True the window is modal. See the <link
linkend="method-gtkwindow--set-modal"><methodname>set_modal</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"need_default_position"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window needs an initial
position calculated.</entry>
	    </row>

	    <row valign="top">
	      <entry>"need_default_size"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window needs an initial
size calculated.</entry>
	    </row>

	    <row valign="top">
	      <entry>"position"</entry>
	      <entry>Read</entry>
	      <entry>The initial position of the window. See the <link
linkend="method-gtkwindow--set-position"><methodname>set_position</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"stick_initially"</entry>
	      <entry>Read</entry>
	      <entry>If <literal>True</literal> the window has been made
sticky by a call to the <link
linkend="method-gtkwindow--stick"><methodname>stick</methodname>()</link>
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"title"</entry>
	      <entry>Read</entry>
	      <entry>The title of the window.</entry>
	    </row>

	    <row valign="top">
	      <entry>"transient_parent"</entry>
	      <entry>Read</entry>
	      <entry>The transient parent window. See the <link
linkend="method-gtkwindow--set-transient-for"><methodname>set_transient_for</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"type"</entry>
	      <entry>Read</entry>
	      <entry>The type of the window: gtk.WINDOW_TOPLEVEL or gtk.WINDOW_POPUP.</entry>
	    </row>

	    <row valign="top">
	      <entry>"type_hint"</entry>
	      <entry>Read</entry>
	      <entry>The window's type hint. See the <link
linkend="method-gtkwindow--set-type-hint"><methodname>set_type_hint</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"wmclass_class"</entry>
	      <entry>Read</entry>
	      <entry>The window system class hint. See the <link
linkend="method-gtkwindow--set-wmclass"><methodname>set_wmclass</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"wmclass_name"</entry>
	      <entry>Read</entry>
	      <entry>The window system name hint. See the <link
linkend="method-gtkwindow--set-wmclass"><methodname>set_wmclass</methodname>()</link> 
method.</entry>
	    </row>

	    <row valign="top">
	      <entry>"wm_role"</entry>
	      <entry>Read</entry>
	      <entry>The unique identifier for the window. See the <link
linkend="method-gtkwindow--set-role"><methodname>set_role</methodname>()</link> 
method.</entry>
	    </row>

	</tbody>
      </tgroup>
      </informaltable>
    </blockquote>

  </refsect1>

  <refsect1 id="signal-prototypes-gtkwindow">
    <title>gtk.Window Signal Prototypes</title>

    <para><link linkend="signal-prototypes-gobject">gobject.GObject Signal Prototypes</link></para>
    <para><link linkend="signal-prototypes-gtkobject">gtk.Object Signal Prototypes</link></para>
    <para><link linkend="signal-prototypes-gtkwidget">gtk.Widget Signal Prototypes</link></para>
    <para><link linkend="signal-prototypes-gtkcontainer">gtk.Container Signal Prototypes</link></para>

    <variablelist>
      <varlistentry>
        <term>"<link
linkend="signal-gtkwindow--activate-default">activate-default</link>"</term>
        <listitem>
          <methodsynopsis
	    language="python"><methodname>callback</methodname>
            <methodparam><parameter>window</parameter></methodparam>
            <methodparam><parameter>user_param1</parameter></methodparam>
            <methodparam><parameter>...</parameter></methodparam>
          </methodsynopsis>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term>"<link
linkend="signal-gtkwindow--activate-focus">activate-focus</link>"</term>
        <listitem>
          <methodsynopsis
	    language="python"><methodname>callback</methodname>
            <methodparam><parameter>window</parameter></methodparam>
            <methodparam><parameter>user_param1</parameter></methodparam>
            <methodparam><parameter>...</parameter></methodparam>
          </methodsynopsis>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term>"<link
linkend="signal-gtkwindow--frame-event">frame-event</link>"</term>
        <listitem>
          <methodsynopsis
	    language="python"><methodname>callback</methodname>
            <methodparam><parameter>window</parameter></methodparam>
            <methodparam><parameter>event</parameter></methodparam>
            <methodparam><parameter>user_param1</parameter></methodparam>
            <methodparam><parameter>...</parameter></methodparam>
          </methodsynopsis>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term>"<link
linkend="signal-gtkwindow--keys-changed">keys-changed</link>"</term>
        <listitem>
          <methodsynopsis
	    language="python"><methodname>callback</methodname>
            <methodparam><parameter>window</parameter></methodparam>
            <methodparam><parameter>user_param1</parameter></methodparam>
            <methodparam><parameter>...</parameter></methodparam>
          </methodsynopsis>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term>"<link
linkend="signal-gtkwindow--move-focus">move-focus</link>"</term>
        <listitem>
          <methodsynopsis
	    language="python"><methodname>callback</methodname>
            <methodparam><parameter>window</parameter></methodparam>
            <methodparam><parameter>direction</parameter></methodparam>
            <methodparam><parameter>user_param1</parameter></methodparam>
            <methodparam><parameter>...</parameter></methodparam>
          </methodsynopsis>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term>"<link
linkend="signal-gtkwindow--set-focus">set-focus</link>"</term>
        <listitem>
          <methodsynopsis
	    language="python"><methodname>callback</methodname>
            <methodparam><parameter>window</parameter></methodparam>
            <methodparam><parameter>widget</parameter></methodparam>
            <methodparam><parameter>user_param1</parameter></methodparam>
            <methodparam><parameter>...</parameter></methodparam>
          </methodsynopsis>
        </listitem>
      </varlistentry>
    </variablelist>

  </refsect1>

  <refsect1>
    <title>Description</title>

    <para>A <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> provides
a widget that users commonly think of as a window. That is, an area of the
display that is managed by the window manager and usually decorated with a
title bar, and items to allow the user to close, resize and move the
window. <literal>PyGTK</literal> provides two types of windows (see the
<xref linkend="gtk-window-type-constants"
endterm="gtk-window-type-constants-title"></xref> section for more
information):</para>

    <variablelist>
      <varlistentry>
        <term><literal>gtk.WINDOW_TOPLEVEL</literal></term>
        <listitem>
	  <simpara>A window that has no parent and usually has a frame and
decorations supplied by a window manager. Toplevels windows are the main
application window and dialogs.</simpara>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term><literal>gtk.WINDOW_POPUP</literal></term>
        <listitem>
	  <simpara>A window that is ignored by the window manager and has no
frame or decorations. A popup window is used for menus and
tooltips.</simpara>
        </listitem>
      </varlistentry>
    </variablelist>

    <para>Typically, applications only directly create and use toplevel
windows.</para>

    <para>A <link linkend="class-gtkwindow"><classname>gtk.Window</classname></link> is a container (subclass of <link linkend="class-gtkbin"><classname>gtk.Bin</classname></link>) holding one child widget.</para>

  </refsect1>

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

    <programlisting><constructorsynopsis language="python">
	<methodname>gtk.Window</methodname>
	<methodparam><parameter role="keyword">type</parameter>
	  <initializer>gtk.WINDOW_TOPLEVEL</initializer></methodparam>
      </constructorsynopsis></programlisting>
    <variablelist>
      <varlistentry>
	<term><parameter role="keyword">type</parameter>&nbsp;:</term>
	<listitem><simpara>the type of window:
<literal>gtk.WINDOW_TOPLEVEL</literal> or
<literal>gtk.WINDOW_POPUP</literal></simpara></listitem>
      </varlistentry>
      <varlistentry>
	<term><emphasis>Returns</emphasis>&nbsp;:</term>
	<listitem><simpara>a new <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>.</simpara></listitem>
      </varlistentry>
    </variablelist>

    <para>Creates a new <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>, which is
a toplevel window that can contain other widgets. Nearly always, the type of
the window should be <literal>gtk.WINDOW_TOPLEVEL</literal> (see the <xref
linkend="gtk-window-type-constants"
endterm="gtk-window-type-constants-title"></xref> for more details).
<literal>gtk.WINDOW_POPUP</literal> is used to create a pop-up menu or
pop-up tooltip. On X11, popup windows are not controlled by the window
manager. If you simply want an undecorated window (no window borders), use
the <link
linkend="method-gtkwindow--set-decorated"><methodname>set_decorated</methodname>()</link>
method with a toplevel window, don't use a popup window.</para>


  </refsect1>

  <refsect1>
    <title>Methods</title>

    <refsect2 id="method-gtkwindow--set-title">
      <title>gtk.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 title of the window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_title</methodname>() method sets the "title" property
of the <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> to the
value specified by <parameter>title</parameter>. The title of a window will
be displayed in its title bar. On the X Window System, the title bar is
rendered by the window manager, so exactly how the title appears to users
may vary according to a user's exact configuration. The title should help a
user distinguish this window from other windows they may have open. A good
title might include the application name and current document
filename.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-title">
      <title>gtk.Window.get_title</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_title</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the title of the window, or
<literal>None</literal>.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_title</methodname>() method returns the
value of the "title" property of the window. See the <link
linkend="method-gtkwindow--set-title"><methodname>set_title</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-wmclass">
      <title>gtk.Window.set_wmclass</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_wmclass</methodname>
	  <methodparam><parameter
			 role="keyword">wmclass_name</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">wmclass_class</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">wmclass_name</parameter>&nbsp;:</term>
	  <listitem><simpara>the window name hint</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">wmclass_class</parameter>&nbsp;:</term>
	  <listitem><simpara>the window class hint</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_wmclass</methodname>() method sets the X
Window System "class" and "name" hints for a window. Applications should not
call this method. According to the ICCCM, you should always set these to the
same value for all windows in an application, and <literal>PyGTK</literal>
sets them to that value by default, so calling this method is sort of
pointless. However, you may want to call the <link
linkend="method-gtkwindow--set-role"><methodname>set_role</methodname>()</link> 
method on each window in your application, for the benefit of the session
manager. Setting the role allows the window manager to restore window
positions when loading a saved session.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-role">
      <title>gtk.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 unique identifier for the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_role</methodname>() method sets a unique
identifier (specified by <parameter>role</parameter>) for the window to be
used when restoring a session. This method is only useful on X11. In
combination with the window title, the window role allows a window manager
to identify "the same" window when an application is restarted. So for
example you might set the "toolbox" role on your app's toolbox window, so
that when the user restarts their session, the window manager can put the
toolbox back in the same place. If a window already has a unique title, you
don't need to set the role, since the WM can use the title to identify the
window when restoring the session.d</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-role">
      <title>gtk.Window.get_role</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_role</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the role of the window if set, or
<literal>None</literal>.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_role</methodname>() method returns the role
of the window. See the <link
linkend="method-gtkwindow--set-role"><methodname>set_role</methodname>()</link> 
method for further explanation.</para>

    </refsect2>

  <refsect2 id="method-gtkwindow--add-accel-group">
      <title>gtk.Window.add_accel_group</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>add_accel_group</methodname>
	  <methodparam><parameter
			 role="keyword">accel_group</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">accel_group</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
linkend="class-gtkaccelgroup"><classname>gtk.AccelGroup</classname></link></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>add_accel_group</methodname>() method associates
the accelerator group specified by <parameter>accel_group</parameter> with
the window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--remove-accel-group">
      <title>gtk.Window.remove_accel_group</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>remove_accel_group</methodname>
	  <methodparam><parameter
			 role="keyword">accel_group</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">accel_group</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
linkend="class-gtkaccelgroup"><classname>gtk.AccelGroup</classname></link></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>remove_accel_group</methodname>() method
dissociates the accelerator group specified by
<parameter>accel_group</parameter> from the widget. This method reverses the
effects of the <link
linkend="method-gtkwindow--add-accel-group"><methodname>add_accel_group</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-position">
      <title>gtk.Window.set_position</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_position</methodname>
	  <methodparam><parameter
			 role="keyword">position</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">position</parameter>&nbsp;:</term>
	  <listitem><simpara>a position constraint.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_position</methodname>() method sets the
"window-position" property to the value of <parameter>position</parameter>.
The value of <parameter>position</parameter> must be one of the <xref
linkend="gtk-window-position-constants"
endterm="gtk-window-position-constants-title"></xref>.</para>

      <para>If the old or new window position constraint is
<literal>gtk.WIN_POS_CENTER_ALWAYS</literal>, this will also cause the
window to be repositioned to satisfy the new constraint.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--activate-focus">
      <title>gtk.Window.activate_focus</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>activate_focus</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window has a
focus widget</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>activate_focus</methodname>() method activates
the child widget with the focus. This method returns <literal>True</literal>
if the window has a widget with the focus.</para>

  </refsect2>

    <refsect2 id="method-gtkwindow--set-focus">
      <title>gtk.Window.set_focus</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_focus</methodname>
	  <methodparam><parameter
			 role="keyword">focus</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">focus</parameter>&nbsp;:</term>
	  <listitem><simpara>the widget to be the new focus
widget or <literal>None</literal> to unset a focus widget</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_focus</methodname>() method sets the widget
specified by <parameter>focus</parameter> to be the focus widget for the
window. If <parameter>focus</parameter> is <literal>None</literal> the
window's focus widget is unset. To set the focus to a particular widget in
the toplevel, it is usually more convenient to use the <link
linkend="method-gtkwidget--grab-focus"><methodname>gtk.Widget.grab_focus</methodname>()</link> 
method instead of this method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-focus">
      <title>gtk.Window.get_focus</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_focus</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the currently focused
widget.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_focus</methodname>() method returns the
current focused widget within the window. The focus widget is the widget
that would have the focus if the toplevel window is focused.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-default">
      <title>gtk.Window.set_default</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_default</methodname>
	  <methodparam><parameter
			 role="keyword">default_widget</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">default_widget</parameter>&nbsp;:</term>
	  <listitem><simpara>the widget to be the default, or
<literal>None</literal> to unset the default widget.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_default</methodname>() method sets the
window's default widget to the value specified by
<parameter>default_widget</parameter>. If
<parameter>default_widget</parameter> is <literal>None</literal> the
window's default widget is unset. The default widget is the widget that's
activated when the user presses <keycap>Enter</keycap> in a window. When
setting (rather than unsetting) the default widget it's generally easier to
call the <link
linkend="method-gtkwidget--grab-default"><methodname>gtk.Widget.grab_default</methodname>()</link> 
method on the widget. Before making a widget the default widget, you must
set the <literal>gtk.CAN_DEFAULT</literal> flag on the widget you'd like to
make the default using the <link
linkend="method-gtkobject--set-flags"><methodname>gtk.Object.set_flags</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--activate-default">
      <title>gtk.Window.activate_default</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>activate_default</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window has a
default widget or a focus widget.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>activate_default</methodname>() method activates
the default widget. If there is no default widget or the default widget
cannot be activated, the window's focus widget (if any) is activated. This
method returns <literal>False</literal> if no default widget could be
activated or there is no focus widget.</para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
	  <methodname>set_transient_for</methodname>
	  <methodparam><parameter
			 role="keyword">parent</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">parent</parameter>&nbsp;:</term>
	  <listitem><simpara>the parent window or <literal>None</literal> to
remove the transient parent</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_transient_for</methodname>() method sets the
window as a transient window for the window specified by
<parameter>parent</parameter>. Dialog windows should be set transient for
the main application window they were spawned from. This allows window
managers to keep the dialog on top of the main window, or center the dialog
over the main window. The <link
linkend="constructor-gtkdialog">gtk.Dialog</link>() constructor and other
convenience functions in <literal>PyGTK</literal> will sometimes call the
<methodname>set_transient_for</methodname>() method on your behalf.
</para>
      <para>
On Windows, this method will and put the child window on top of the parent,
much as the window manager would have done on X.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-transient-for">
      <title>gtk.Window.get_transient_for</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_transient_for</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the transient parent for this window, or
<literal>None</literal> if no transient parent has been
set.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_transient_for</methodname>() method returns
the transient parent for this window or <literal>None</literal> if no
transient window is set. See the <link
linkend="method-gtkwindow--set-transient-for"><methodname>set_transient_for</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-type-hint">
      <title>gtk.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>the window type</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_type_hint</methodname>() method sets the
window type hint for the window to the value specified by
<parameter>hint</parameter>. The value of <parameter>hint</parameter> must
be one of the <xref linkend="gdk-window-type-hint-constants"
endterm="gdk-window-type-hint-constants-title"></xref>.</para>

      <para>By setting the type hint for the window, you allow the window
manager to decorate and handle the window in a way which is suitable to the
method of the window in your application. This method should be called
before the window becomes visible. The <link
linkend="constructor-gtkdialog">gtk.Dialog</link>() constructor and other
convenience functions in <literal>PyGTK</literal> will sometimes call this
method on your behalf.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-type-hint">
      <title>gtk.Window.get_type_hint</title>

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

      <para>The <methodname>get_type_hint</methodname>() method returns the
type hint for this window. See the <link
linkend="method-gtkwindow--set-type-hint">s<methodname>et_type_hint</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-destroy-with-parent">
      <title>gtk.Window.set_destroy_with_parent</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_destroy_with_parent</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> destroy the window
with its transient parent</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_destroy_with_parent</methodname>() method
sets the "destroy-with-parent" property to the value specified by
<parameter>setting</parameter>. If <parameter>setting</parameter> is
<literal>True</literal>, destroying the transient parent of the window will
also destroy the window itself. This is useful for dialogs that shouldn't
persist beyond the lifetime of the main window they're associated
with.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-destroy-with-parent">
      <title>gtk.Window.get_destroy_with_parent</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_destroy_with_parent</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window will be
destroyed with its transient parent.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_destroy_with_parent</methodname>() method
returns the value of the "destroy-with-parent" property that determines if
the window will be destroyed with its transient parent. See the <link
linkend="method-gtkwindow--set-destroy-with-parent"><methodname>set_destroy_with_parent</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-resizable">
      <title>gtk.Window.set_resizable</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_resizable</methodname>
	  <methodparam><parameter
			 role="keyword">resizable</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
role="keyword">resizable</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>True</literal> the user can resize
this window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_resizable</methodname>() method sets the
"resizable" property to  the value of <parameter>resizable</parameter>. If
<parameter>resizable</parameter> is <literal>True</literal> the user can
resize the window. Windows are user resizable by default.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-resizable">
      <title>gtk.Window.get_resizable</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_resizable</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the user can resize
the window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_resizable</methodname>() method returns the
value of the "resizable" property. See the <link
linkend="method-gtkwindow--set-resizable"><methodname>set_resizable</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-gravity">
      <title>gtk.Window.set_gravity</title>

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


      <para>The <methodname>set_gravity</methodname>() method sets the
gravity of the window to the value specified by
<parameter>gravity</parameter>. The window gravity defines the meaning of
coordinates passed to the <link
linkend="method-gtkwindow--move"><methodname>move</methodname>()</link>
method. The value of gravity must be one of the <xref
linkend="gdk-gravity-constants"
endterm="gdk-gravity-constants-title"></xref>.</para>

      <para>The default window gravity is
<literal>gtk.gdk.GRAVITY_NORTH_WEST</literal> which will typically "do what
you want."</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-gravity">
      <title>gtk.Window.get_gravity</title>

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

      <para>The <methodname>get_gravity</methodname>() method returns window
gravity. See the <link
linkend="method-gtkwindow--set-gravity"><methodname>set_gravity</methodname>()</link> 
method.</para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
	  <methodname>set_geometry_hints</methodname>
	  <methodparam><parameter
			 role="keyword">geometry_widget</parameter></methodparam>
	  <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">geometry_widget</parameter>&nbsp;:</term>
	  <listitem><simpara>the widget the geometry hints will be applied
to</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">min_width</parameter>&nbsp;:</term>
	  <listitem><simpara>the minimum width of window (or -1 to use
requisition)</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">min_height</parameter>&nbsp;:</term>
	  <listitem><simpara>the minimum height of window (or -1 to use
requisition)</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">max_width</parameter>&nbsp;:</term>
	  <listitem><simpara>the maximum width of window (or -1 to use
requisition)</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">max_height</parameter>&nbsp;:</term>
	  <listitem><simpara>the 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</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">base_height</parameter>&nbsp;:</term>
	  <listitem><simpara>allowed window heights are base_height +
width_inc * N where N is any integer</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">width_inc</parameter>&nbsp;:</term>
	  <listitem><simpara>the width resize increment</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">height_inc</parameter>&nbsp;:</term>
	  <listitem><simpara>the height resize
increment</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">min_aspect</parameter>&nbsp;:</term>
	  <listitem><simpara>the minimum width to height
ratio</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">max_aspect</parameter>&nbsp;:</term>
	  <listitem><simpara>the maximum width to height
ratio</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_geometry_hints</methodname>() method sets up
hints about how a window can be resized by the user. You can set the minimum
and maximum widths and heights, the base width and height for resizing, the
allowed width and height resize increments (e.g. for xterm, you can only
resize by the size of a character), and the minimum and maximum aspect
ratios. If <parameter>geometry_widget</parameter> is not
<literal>None</literal> it specifies the widget to figure the geometry
on.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-screen">
      <title>gtk.Window.set_screen</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_screen</methodname>
	  <methodparam><parameter role="keyword">screen</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">screen</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
	  linkend="class-gdkscreen"><classname>gtk.gdk.Screen</classname></link>.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>set_screen</methodname>() method sets the
"screen" property to the <link
linkend="class-gdkscreen"><classname>gtk.gdk.Screen</classname></link>
specified by <parameter>screen</parameter>. The "screen" property contains
the screen that the window is displayed on. If the window is already mapped,
it will be unmapped, and then remapped on the new screen.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-screen">
      <title>gtk.Window.get_screen</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_screen</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a <link
	  linkend="class-gdkscreen"><classname>gtk.gdk.Screen</classname></link>.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>get_screen</methodname>() method returns the
<link linkend="class-gdkscreen"><classname>gtk.gdk.Screen</classname></link>
that the window is displayed on.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--is-active">
      <title>gtk.Window.is_active</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>is_active</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window is part
	  of the current active window.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>is_active</methodname>() method returns
<literal>True</literal> if the window is part of the current active
toplevel, i.e., the toplevel window receiving keystrokes.  The return value
is <literal>True</literal> if the window is active the toplevel itself, or
if it is, for example, a <link
linkend="class-gtkplug"><classname>gtk.Plug</classname></link> embedded in
the active toplevel. You might use this method if you wanted to draw a
widget differently in an active window from a widget in an inactive window.
See the <link
linkend="method-gtkwindow--has-toplevel-focus"><methodname>has_toplevel_focus()</methodname></link>
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--has-toplevel-focus">
      <title>gtk.Window.has_toplevel_focus</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>has_toplevel_focus</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the the input focus
	  is within the window</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>has_toplevel_focus</methodname>() method returns
<literal>True</literal> if the input focus is within the window.  For real
toplevel windows, this is identical to <link
linkend="method-gtkwindow--is-active"><methodname>is_active()</methodname></link>,
but for embedded windows, like a <link
linkend="class-gtkplug"><classname>gtk.Plug</classname></link>, the results
will differ.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-has-frame">
      <title>gtk.Window.set_has_frame</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_has_frame</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> PyGTK draws the
window border</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_has_frame</methodname>() method sets the
flag that causes <literal>PyGTK</literal> to draw its own window border for
the window.</para>

      <note>
	<para>This is a special-purpose method for the framebuffer port. For
most applications, you want the <link
linkend="method-gtkwindow--set-decorated"><methodname>set_decorated</methodname>()</link> 
method instead,that tells the window manager whether to draw the window
border.</para>
      </note>

      <para>If this method is called on a window with setting of
<literal>True</literal>, before it is realized or showed, it will have a
"frame" window around the window's <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>,
accessible in the window's frame. Using the signal "frame-event" you can
receive all events targeted at the frame. This method is used by the
linux-fb port to implement managed windows, but it could conceivably be used
by X-programs that want to do their own window decorations.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-has-frame">
      <title>gtk.Window.get_has_frame</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_has_frame</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if a frame has been
added to the window via the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
method.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_has_frame</methodname>() method returns the
value of the window's "has_frame" flag that determines if the window has a
frame window exterior to its <link
linkend="class-gdkwindow"><classname>gtk.gdk.Window</classname></link>. See
the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
method for more information.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-frame-dimensions">
      <title>gtk.Window.set_frame_dimensions</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_frame_dimensions</methodname>
	  <methodparam><parameter
			 role="keyword">left</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">top</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">right</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">bottom</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">left</parameter>&nbsp;:</term>
	  <listitem><simpara>the width of the left
border</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">top</parameter>&nbsp;:</term>
	  <listitem><simpara>the height of the top
border</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">right</parameter>&nbsp;:</term>
	  <listitem><simpara>the width of the right
border</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">bottom</parameter>&nbsp;:</term>
	  <listitem><simpara>the height of the bottom
border</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_frame_dimensions</methodname>() method sets
the size of the frame around the window to the values specified by
<parameter>left</parameter>, <parameter>top</parameter>,
<parameter>bottom</parameter> and <parameter>right</parameter>.</para>

      <note>
	<para>This is a special-purpose method intended for the framebuffer
port. See the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
method. It will have no effect on the window border drawn by the window
manager, which is the normal case when using the X Window system.</para>
      </note>

      <para>For windows with frames (see the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
method) this method can be used to change the size of the frame
border.</para>

    </refsect2>

  <refsect2 id="method-gtkwindow--get-frame-dimensions">
      <title>gtk.Window.get_frame_dimensions</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_frame_dimensions</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a tuple containing the frame dimensions: the
width of the frame at the left; the height of the frame at the top; the
width of the frame at the right; and, the height of the frame at the
bottom.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_frame_dimensions</methodname>() method
returns a tuple containing the frame dimensions:  the width of the frame at
the left; the height of the frame at the top; the width of the frame at the
right; and, the height of the frame at the bottom.</para>

      <note>
	<para>This is a special-purpose method intended for the framebuffer
port See the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
method. It will not return the size of the window border drawn by the window
manager, which is the normal case when using a windowing system.  See the
<link
linkend="method-gdkwindow--get-frame-extents"><methodname>get_frame_extents</methodname>()</link> 
to get the standard window border extents.</para>
      </note>

      <para>See the <link
linkend="method-gtkwindow--set-has-frame"><methodname>set_has_frame</methodname>()</link> 
and <link
linkend="method-gtkwindow--set-frame-dimensions"><methodname>set_frame_dimensions</methodname>()</link> 
methods for more information.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-decorated">
      <title>gtk.Window.set_decorated</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_decorated</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> decorate the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_decorated</methodname>() method sets the
decorated flag to the value specified by <parameter>setting</parameter>. If
<parameter>setting</parameter> is <literal>True</literal> the window will be
decorated. By default, windows are decorated with a title bar, resize
controls, etc. Some window managers allow PyGTK to disable these
decorations, creating a borderless window. If you set the decorated property
to <literal>False</literal> using this method, <literal>PyGTK</literal> will
do its best to convince the window manager not to decorate the window. On
Windows, this method always works, since there's no window manager policy
involved.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-decorated">
      <title>gtk.Window.get_decorated</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_decorated</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window has been
set to have decorations</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_decorated</methodname>() method returns the
value of the decorated flag that determines if the window has been set to
have decorations such as a title bar. See the <link
linkend="method-gtkwindow--set-decorated"><methodname>set_decorated</methodname>()</link> 
method.</para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
	  <methodname>set_icon_list</methodname>
	  <methodparam><parameter>...</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter>...</parameter>&nbsp;:</term>
	  <listitem><simpara>zero or more <link
linkend="class-gdkpixbuf"><classname>gtk.gdk.Pixbuf</classname></link>
objects</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_icon_list</methodname>() method sets up the
icon representing the window using the set of <link
linkend="class-gdkpixbuf"><classname>gtk.gdk.Pixbuf</classname></link>
objects passed as arguments. If no <link
linkend="class-gdkpixbuf"><classname>gtk.gdk.Pixbuf</classname></link>
objects are passed in the icon is unset and reverts to the default icon. The
icon is used when the window is minimized (also known as iconified). Some
window managers or desktop environments may also place it in the window
frame, or display it in other contexts. This method allows you to pass in
the same icon in several hand-drawn sizes. The <link
linkend="class-gdkpixbuf"><classname>gtk.gdk.Pixbuf</classname></link>
objects should contain the natural sizes your icon is available in; i.e.,
don't scale the image before passing it to <literal>PyGTK</literal>. Scaling
is postponed until the last minute, when the desired final size is known, to
allow best quality. By passing several sizes, you may improve the final
image quality of the icon, by reducing or eliminating automatic image
scaling. The recommended sizes to provide are: 16x16, 32x32, 48x48 at
minimum, and larger images (64x64, 128x128) if you have them.</para>

      <para>See the <link
linkend="function-gtk--window-set-default-icon-list"><methodname>gtk.window_set_default_icon_list</methodname>()</link> 
function to set the icon for all windows in your application in one go. Note
that transient windows (those who have been set transient for another window
using the <link
linkend="method-gtkwindow--set-transient-for"><methodname>set_transient_for</methodname>()</link> 
method) will inherit their icon from their transient parent. So there's no
need to explicitly set the icon on transient windows.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-icon-list">
      <title>gtk.Window.get_icon_list</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_icon_list</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a copy of the window's icon
list</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_icon_list</methodname>() method returns the
list of icons set by the <link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method.</para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
	  <methodname>set_icon</methodname>
	  <methodparam><parameter
			 role="keyword">icon</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">icon</parameter>&nbsp;:</term>
	  <listitem><simpara>an icon image, or
<literal>None</literal></simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_icon</methodname>() method sets the "icon"
property to the value specified by <parameter>icon</parameter>. This icon is
used when the window is minimized (also known as iconified). Some window
managers or desktop environments may also place it in the window frame, or
display it in other contexts. The icon should be provided in whatever size
it was naturally drawn; that is, don't scale the image before passing it to
<literal>PyGTK</literal>. Scaling is postponed until the last minute, when
the desired final size is known, to allow best quality. If you have your
icon hand-drawn in multiple sizes, use the <link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method. Then the best size will be used.</para>

      <para>This method is equivalent to calling the <link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method with a 1-element list. See the <link
linkend="function-gtk--window-set-default-icon-list"><methodname>gtk.window_set_default_icon_list</methodname>()</link> 
function to set the icon for all windows in your application in one
go.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-icon-from-file">
      <title>gtk.Window.set_icon_from_file</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_icon_from_file</methodname>
	  <methodparam><parameter
			 role="keyword">filename</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">filename</parameter>&nbsp;:</term>
	  <listitem><simpara>the name of a file containing an icon
	  image</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the icon was
	  loaded.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_icon_from_file</methodname>() method sets
the "icon" property to the icon loaded from the file specified by
<parameter>filename</parameter>. The icon is used when the window is
minimized (also known as iconified). See the <link
linkend="method-gtkwindow--set-icon"><methodname>set_icon</methodname>()</link>)
method for more information. This method is equivalent to calling the <link
linkend="method-gtkwindow--set-icon"><methodname>set_icon</methodname>()</link>
method with a pixbuf created by loading the image from
<parameter>filename</parameter>.</para>

      <para>The GError exception is raised if an error occurs while loading
the pixbuf from <parameter>filename</parameter>.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-icon">
      <title>gtk.Window.get_icon</title>

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

      <para>The <methodname>get_icon</methodname>() method returns the value
of the "icon" property set by the <link
linkend="method-gtkwindow--set-icon"><methodname>set_icon</methodname>()</link> 
(or if you've called the <link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method, returns the first icon in the icon list).</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-modal">
      <title>gtk.Window.set_modal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_modal</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</methodname>() method sets the "modal"
property to the value of <parameter>modal</parameter>. If
<parameter>modal</parameter> is <literal>True</literal> the window becomes
modal. Modal windows prevent interaction with other windows in the same
application. Typically modal windows are used for <link
linkend="class-gtkdialog"><classname>gtk.Dialog</classname></link> windows
that require a user response before the application can continue. To keep
modal dialogs on top of the main application windows, use the <link
linkend="method-gtkwindow--set-transient-for"><methodname>set_transient_for</methodname>()</link> 
method to make the dialog transient for the parent - most window managers
will then disallow lowering the dialog below the parent.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-modal">
      <title>gtk.Window.get_modal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_modal</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window is set to
be modal and establishes a grab when shown</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_modal</methodname>() method returns the
value of the "modal" property. If "modal" is <literal>True</literal> the
window is modal. See the <link
linkend="method-gtkwindow--set-modal"><methodname>set_modal</methodname>()</link> 
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--add-mnemonic">
      <title>gtk.Window.add_mnemonic</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>add_mnemonic</methodname>
	  <methodparam><parameter
			 role="keyword">keyval</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">target</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">keyval</parameter>&nbsp;:</term>
	  <listitem><simpara>the mnemonic key</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">target</parameter>&nbsp;:</term>
	  <listitem><simpara>the widget that gets activated by the
mnemonic</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>add_mnemonic</methodname>() method adds a
mnemonic key specified by <parameter>keyval</parameter> to this window. When
the mnemonic key is pressed the widget specified by
<parameter>target</parameter> will be activated.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--remove-mnemonic">
      <title>gtk.Window.remove_mnemonic</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>remove_mnemonic</methodname>
	  <methodparam><parameter
			 role="keyword">keyval</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">target</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">keyval</parameter>&nbsp;:</term>
	  <listitem><simpara>the mnemonic key</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">target</parameter>&nbsp;:</term>
	  <listitem><simpara>the widget that gets activated by the
mnemonic</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>remove_mnemonic</methodname>() method removes
the mnemonic specified by <parameter>keyval</parameter> for the widget
specified by <parameter>target</parameter> from this window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--mnemonic-activate">
      <title>gtk.Window.mnemonic_activate</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>mnemonic_activate</methodname>
	  <methodparam><parameter
			 role="keyword">keyval</parameter></methodparam>
	  <methodparam><parameter
			 role="keyword">modifier</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">keyval</parameter>&nbsp;:</term>
	  <listitem><simpara>the mnemonic key</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">modifier</parameter>&nbsp;:</term>
	  <listitem><simpara>the modifiers</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>True if the activation was
done</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The<methodname> mnemonic_activate</methodname>() method
activates the targets associated with the mnemonic specified by
<parameter>keyval</parameter>. The window's mnemonic modifier must match
<parameter>modifier</parameter> to allow the activation to proceed. See the
<link
linkend="method-gtkwindow--set-mnemonic-modifier"><methodname>set_mnemonic_modifier</methodname>()</link> 
method for more information.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-mnemonic-modifier">
      <title>gtk.Window.set_mnemonic_modifier</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_mnemonic_modifier</methodname>
	  <methodparam><parameter
			 role="keyword">modifier</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">modifier</parameter>&nbsp;:</term>
	  <listitem><simpara>the modifier mask used to activate mnemonics on
this window.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_mnemonic_modifier</methodname>() method sets
the mnemonic modifier for this window to the value specified by
<parameter>modifier</parameter>. The value of
<parameter>modifier</parameter> is one of:</para>

      <variablelist>
	<varlistentry>
          <term><literal>gtk.gdk.SHIFT_MASK</literal></term>
	  <listitem>
            <simpara>The Shift key.</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>
      </variablelist>

      <para></para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-mnemonic-modifier">
      <title>gtk.Window.get_mnemonic_modifier</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_mnemonic_modifier</methodname>
	  <methodparam></methodparam>  </methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>the modifier mask used to activate mnemonics on
this window.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_mnemonic_modifier</methodname>() method
returns the mnemonic modifier for this window. See the <link
linkend="method-gtkwindow--set-mnemonic-modifier"><methodname>set_mnemonic_modifier</methodname>()</link> 
method for more detail.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-mnemonics-visible">
      <title>gtk.Window.set_mnemonics_visible</title>

      <programlisting><methodsynopsis language="python">
        <methodname>set_mnemonics_visible</methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> if mnemomics should be visible in the window, <literal>False</literal> otherwise.</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>The <methodname>set_mnemonics_visible</methodname>() method sets whether mnemonics are currently visible in the window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-mnemonics-visible">
      <title>gtk.Window.get_mnemonics_visible</title>

      <programlisting><methodsynopsis language="python">
        <methodname>get_mnemonics_visible</methodname>
        <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> if mnemomics are currently visible in the window, <literal>False</literal> otherwise.</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>The <methodname>get_mnemonics_visible</methodname>() method returns whether mnemonics are currently visible in the window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--activate-key">
      <title>gtk.Window.activate_key</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>activate_key</methodname>
	  <methodparam><parameter role="keyword">event</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">event</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
	  linkend="class-gdkevent"><classname>gtk.gdk.Event</classname></link></simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if a mnemonic or
	  accelerator was found and activated.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>activate_key</methodname>() method activates
mnemonics and accelerators for the window. This is normally called by the
default <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--key-press-event">key-press-event</link>" signal
handler for toplevel windows, however in some cases it may be useful to call
this directly when overriding the standard key handling for a toplevel
window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--propagate-key-event">
      <title>gtk.Window.propagate_key_event</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>propagate_key_event</methodname>
	  <methodparam><parameter role="keyword">event</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">event</parameter>&nbsp;:</term>
	  <listitem><simpara>a <link
	  linkend="class-gdkevent"><classname>gtk.gdk.Event</classname></link></simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if a widget in the
	  focus chain handled the event.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>propagate_key_event</methodname>() method
propagates a key press or release event to the focus widget and up the focus
container chain until a widget handles the key event specified by
<parameter>event</parameter>. This is normally called by the default <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--key-press-event">key-press-event</link>" and
"<link
linkend="signal-gtkwidget--key-release-event">key-release-event</link>"
signal handlers for toplevel windows, however in some cases it may be useful
to call this directly when overriding the standard key handling for a
toplevel window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--present">
      <title>gtk.Window.present</title>

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


      <para>The <methodname>present</methodname>() method presents a window
to the user. This may mean raising the window in the stacking order,
deiconifying it, moving it to the current desktop, and/or giving it the
keyboard focus, possibly dependent on the user's platform, window manager,
and preferences. If the window is hidden, this method calls the the <link
linkend="method-gtkwidget--show"><methodname>gtk.Widget.show</methodname>()</link> 
method as well. This method should be used when the user tries to open a
window that's already open. Say for example the preferences dialog is
currently open, and the user chooses <guimenuitem>Preferences</guimenuitem>
from the menu a second time; use the <methodname>present</methodname>()
method to move the already-open dialog where the user can see it.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--iconify">
      <title>gtk.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 (i.e. minimize) the specified the window. Note that you
shouldn't assume the window is definitely iconified afterward, because other
entities (e.g. the user or window manager) could deiconify it again, or
there may not be a window manager in which case iconification isn't
possible, etc. But normally the window will end up iconified. Just don't
write code that crashes if not. This method can be called before showing a
window, in which case the window will be iconified before it ever appears
on-screen. You can track iconification via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window-state-event</link>"
signal.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--deiconify">
      <title>gtk.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 (i.e. unminimize) the specified the window. Note that
you shouldn't assume the window is definitely deiconified afterward, because
other entities (e.g. the user or window manager) could iconify it again
before your code which assumes deiconification gets to run. You can track
iconification via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window-state-event</link>"
signal.</para>

    </refsect2>

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

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

      <para>The <methodname>stick</methodname>() method asks the window
manager to stick the window, which means that it will appear on all user
desktops. Note that you shouldn't assume the window is definitely stuck
afterward, because other entities (e.g. the user or window manager) could
unstick it again, and some window managers do not support sticking windows.
But normally the window will end up stuck. Just don't write code that
crashes if not. This method can be called before showing a window. You can
track stickiness via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window-state-event</link>"
signal.</para>

    </refsect2>

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

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

      <para>The unstick() method asks the window manager to unstick the
window, which means that it will appear on only one of the user's desktops.
Note that you shouldn't assume the window is definitely unstuck afterward,
because other entities (e.g. the user or window manager) could stick it
again. But normally the window will end up stuck. Just don't write code that
crashes if not. You can track stickiness via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window-state-event</link>"
signal.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--maximize">
      <title>gtk.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, so that it becomes full-screen. Note that
you shouldn't assume the window is definitely maximized afterward, because
other entities (e.g. the user or window manager) could unmaximize it again,
and not all window managers support maximization. But normally the window
will end up maximized. This method can be called before showing a window, in
which case the window will be maximized when it appears on-screen initially.
You can track maximization via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window-state-event</link>"
signal.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--unmaximize">
      <title>gtk.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. Note that you shouldn't assume the window
is definitely unmaximized afterward, because other entities (e.g. the user
or window manager) could maximize it again, and not all window managers
honor requests to unmaximize. But normally the window will end up
unmaximized. You can track maximization via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window-state-event</link>"
signal.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--fullscreen">
      <title>gtk.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 requests the
window manager to place the window in the fullscreen state. Note you
shouldn't assume the window is definitely full screen afterward, because
other entities (e.g. the user or window manager) could unfullscreen it
again, and not all window managers honor requests to fullscreen windows. But
normally the window will end up fullscreen. Just don't write code that
crashes if not.</para>

      <para>You can track the fullscreen state via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window-state-event</link>"
signal.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--unfullscreen">
      <title>gtk.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 requests the
window manager to toggle off the fullscreen state for the window. Note that
you shouldn't assume the window is definitely not full screen afterward,
because other entities (e.g. the user or window manager) could fullscreen it
again, and not all window managers honor requests to unfullscreen
windows. But normally the window will end up restored to its normal
state. Just don't write code that crashes if not.</para>

      <para>You can track the fullscreen state via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window_state_event</link>"
signal.</para> </refsect2>

    <refsect2 id="method-gtkwindow--set-keep-above">
      <title>gtk.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>if <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 requests
the window manager to keep the window on top if
<parameter>setting</parameter> is <literal>True</literal>. Note that you
shouldn't assume the window is definitely above afterward, because other
entities (e.g. the user or window manager) could not keep it above, and not
all window managers support keeping windows above. But normally the window
will end kept above. Just don't write code that crashes if not.</para>

      <para>It's permitted to call this method before showing a window, so
the window will be kept above when it appears on-screen initially.</para>

      <para>You can track the above state via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window_state_event</link>"
signal.</para>

      <para>Note that, according to the <ulink
url="http://standards.freedesktop.org/wm-spec/wm-spec-latest.html">Extended
Window Manager Hints</ulink> specification, the above state is mainly meant
for user preferences and should not be used by applications e.g. for drawing
attention to their dialogs.</para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
	  <methodname>set_keep_below</methodname>
	  <methodparam><parameter>setting</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter>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 requests
the window manager to keep the window on the bottom (i.e. below all other
windows). Note that you shouldn't assume the window is definitely below
afterward, because other entities (e.g. the user or window manager) could
not keep it below, and not all window managers support putting windows
below. But normally the window will be kept below. Just don't write code
that crashes if not.</para>

      <para>It's permitted to call this function before showing a window, in
which case the window will be kept below when it appears on-screen
initially.</para>

      <para>You can track the below state via the <link
linkend="class-gtkwidget"><classname>gtk.Widget</classname></link> "<link
linkend="signal-gtkwidget--window-state-event">window_state_event</link>"
signal.</para>

      <para>Note that, according to the <ulink
url="http://standards.freedesktop.org/wm-spec/wm-spec-latest.html">Extended
Window Manager Hints</ulink> specification, the above state is mainly meant
for user preferences and should not be used by applications e.g. for drawing
attention to their dialogs.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--begin-resize-drag">
      <title>gtk.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 position of the resize
control</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">button</parameter>&nbsp;:</term>
	  <listitem><simpara>the mouse button that initiated the
drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_x</parameter>&nbsp;:</term>
	  <listitem><simpara>the X position where the user clicked to
initiate the drag, in root window coordinates</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y position where the user clicked to
initiate the drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">timestamp</parameter>&nbsp;:</term>
	  <listitem><simpara>the timestamp from the click event that
initiated the drag</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>begin_resize_drag</methodname>() method starts
resizing a window from the edge specified by <parameter>edge</parameter>.
The mouse button that started the resize is specified by
<parameter>button</parameter>; the location, by
<parameter>root_x</parameter> and <parameter>root_y</parameter>; and the
time of the event, by <parameter>timestamp</parameter>. The value of
<parameter>edge</parameter> must be one of the <xref
linkend="gdk-window-edge-constants"
endterm="gdk-window-edge-constants-title"></xref>.</para>

      <para>This method is used if an application has window resizing
controls. When <literal>PyGTK</literal> can support it, the resize will be
done using the standard mechanism for the window manager or windowing
system. Otherwise, <literal>PyGTK</literal> will try to emulate window
resizing, potentially not all that well, depending on the windowing
system.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--begin-move-drag">
      <title>gtk.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 mouse button that initiated the
drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_x</parameter>&nbsp;:</term>
	  <listitem><simpara>the X position where the user clicked to
initiate the drag, in root window coordinates</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">root_y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y position where the user clicked to
initiate the drag</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter
role="keyword">timestamp</parameter>&nbsp;:</term>
	  <listitem><simpara>the timestamp from the click event that
initiated the drag</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>begin_move_drag</methodname>() method starts
moving a window when the user presses the mouse button specified by
<parameter>button</parameter> at the location specified by
<parameter>root_x</parameter> and <parameter>root_y</parameter> at the time
specified by <parameter>timestamp</parameter>. This method is used if an
application has window movement grips. When <literal>PyGTK</literal> can
support it, the window movement will be done using the standard mechanism
for the window manager or windowing system. Otherwise,
<literal>PyGTK</literal> will try to emulate window movement, potentially
not all that well, depending on the windowing system.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-default-size">
      <title>gtk.Window.set_default_size</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_default_size</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 width in pixels, or -1 to unset the default
width</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">height</parameter>&nbsp;:</term>
	  <listitem><simpara>the height in pixels, or -1 to unset the
default height</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>set_default_size</methodname>() method sets the
default size of the window to the specified <parameter>width</parameter> and
<parameter>height</parameter>. If the window's "natural" size (its size
request) is larger than the default, the default will be ignored. More
generally, if the default size does not obey the geometry hints for the
window (the <link
linkend="method-gtkwindow--set-geometry-hints"><methodname>set_geometry_hints</methodname>()</link> 
method can be used to set these explicitly), the default size will be
clamped to the nearest permitted size.</para>

      <para>Unlike the <link
linkend="method-gtkwidget--set-size-request"><methodname>gtk.Widget.set_size_request</methodname>()</link> 
method, which sets a size request for a widget and thus would keep users
from shrinking the window, this method only sets the initial size, just as
if the user had resized the window themselves. Users can still shrink the
window again as they normally would. Setting a default size of -1 means to
use the "natural" default size (the size request of the window). For more
control over a window's initial size and how resizing works, investigate the
<link
linkend="method-gtkwindow--set-geometry-hints"><methodname>set_geometry_hints</methodname>()</link> 
method.</para>

      <para>For some uses, the <link
linkend="method-gtkwindow--resize"><methodname>resize</methodname>()</link>
method is more appropriate as it changes the current size of the window,
rather than the size to be used on initial display. The <link
linkend="method-gtkwindow--resize"><methodname>resize</methodname>()</link>
method always affects the window itself, not the geometry widget. The
default size of a window only affects the first time a window is shown; if a
window is hidden and re-shown, it will remember the size it had prior to
hiding, rather than using the default size. Windows can't actually be 0x0 in
size, they must be at least 1x1, but passing 0 for
<parameter>width</parameter> and <parameter>height</parameter> is OK,
resulting in a 1x1 default size.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-default-size">
      <title>gtk.Window.get_default_size</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_default_size</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a tuple containing the default width and height
of the window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_default_size</methodname>() method returns a
tuple containing the default width and height of the window. A value of -1
for the returned width or height indicates that a default size has not been
explicitly set for that dimension, so the "natural" size of the window will
be used. See the <link linkend="method-gtkwindow--set-default-size"><methodname>set_default_size</methodname>()</link>
method for more information</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--resize">
      <title>gtk.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 width in pixels to resize the window
to</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">height</parameter>&nbsp;:</term>
	  <listitem><simpara>the height in pixels to resize the window
to</simpara></listitem>
	</varlistentry>
      </variablelist>


      <para>The <methodname>resize</methodname>() method resizes the window
to the specified <parameter>width</parameter> and
<parameter>height</parameter> as if the user had done so, obeying geometry
constraints. The default geometry constraint is that windows may not be
smaller than their size request; to override this constraint, call the <link
linkend="method-gtkwidget--set-size-request"><methodname>gtk.Widget.set_size_request</methodname>()</link> 
method to set the window's request to a smaller value. If the
<methodname>resize</methodname>() method is called before showing a window
for the first time, it overrides any default size set with the <link
linkend="method-gtkwindow--set-default-size"><methodname>set_default_size</methodname>()</link> 
method. Windows may not be resized smaller than 1 by 1 pixels.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-size">
      <title>gtk.Window.get_size</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_size</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a tuple containing the width and height of the
window</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_size</methodname>() method returns a tuple
containing the current width and height of the window. If the window is not
on-screen, it returns the size <literal>PyGTK</literal> will suggest to the
window manager for the initial window size (but this is not reliably the
same as the size the window manager will actually select). The size obtained
by the <methodname>get_size</methodname>() method is the last size received
in a configure event, that is, <literal>PyGTK</literal> uses its
locally-stored size, rather than querying the X server for the size. As a
result, if you call the <link
linkend="method-gtkwindow--resize"><methodname>resize</methodname>()</link>
method then immediately call the <methodname>get_size</methodname>() method,
the size won't have taken effect yet. After the window manager processes the
resize request, PyGTK receives notification that the size has changed via a
configure event, and the size of the window gets updated.</para>

      <note>
	<para>Nearly any use of this method creates a race condition,
because the size of the window may change between the time that you get the
size and the time that you perform some action assuming that size is the
current size. To avoid race conditions, connect to "configure_event" on the
window and adjust your size-dependent state to match the size delivered in
the configure event.</para>

	<para>The returned size does <emphasis>not</emphasis> include the
size of the window manager decorations (aka the window frame or border).
Those are not drawn by <literal>PyGTK</literal> which has no reliable method
of determining their size.</para>

	<para>If you are getting a window size in order to position the
window on-screen, there may be a better way. The preferred way is to simply
set the window's semantic type with the <link
linkend="method-gtkwindow--set-type-hint"><methodname>set_type_hint</methodname>()</link> 
method, that allows the window manager to center dialogs, etc. Also, if you
set the transient parent of dialogs with the <link
linkend="method-gtkwindow--set-transient-for"><methodname>set_transient_for</methodname>()</link> 
method, window managers will often center the dialog over its parent window.
It's much preferred to let the window manager handle these things rather
than doing it yourself, because all apps will behave consistently and
according to user prefs if the window manager handles it. Also, the window
manager can take the size of the window decorations/border into account,
while your application cannot.</para>

	<para>In any case, if you insist on application-specified window
positioning, there's <emphasis>still</emphasis> a better way than doing it
yourself - the <link
linkend="method-gtkwindow--set-position"><methodname>set_position</methodname>()</link> 
method will frequently handle the details for you.</para>
      </note>

    </refsect2>

    <refsect2 id="method-gtkwindow--move">
      <title>gtk.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 to move window
to</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter role="keyword">y</parameter>&nbsp;:</term>
	  <listitem><simpara>the Y coordinate to move window
to</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>move</methodname>() method asks the window
manager to move the window to the position specified by
<parameter>x</parameter> and <parameter>y</parameter>.  Window managers are
free to ignore this. In fact, most window managers ignore requests for
initial window positions (instead using a user-defined placement algorithm)
and honor requests after the window has already been shown.</para>

	<para>The position is the position of the gravity-determined
reference point for the window. The gravity determines two things: first,
the location of the reference point in root window coordinates; and second,
which point on the window is positioned at the reference point. By default
the gravity is <literal>gtk.gdk.GRAVITY_NORTH_WEST</literal>, so the
reference point is simply the <parameter>x</parameter>,
<parameter>y</parameter> supplied to the <methodname>move</methodname>()
method. The top-left corner of the window decorations (aka window frame or
border) will be placed at <parameter>x</parameter>,
<parameter>y</parameter>. Therefore, to position a window at the top left of
the screen, you want to use the default gravity (which is
<literal>gtk.gdk.GRAVITY_NORTH_WEST</literal>) and move the window to
0,0.</para>

	<para>To position a window at the bottom right corner of the screen,
you would set <literal>gtk.gdk.GRAVITY_SOUTH_EAST</literal>, which means
that the reference point is at <parameter>x</parameter> + the window width
and <parameter>y</parameter> + the window height, and the bottom-right
corner of the window border will be placed at that reference point. So, to
place a window in the bottom right corner you would first set gravity to
south east, then move the window:</para>

	<programlisting>
  window.set_gravity(gtk.gdk.GRAVITY_SOUTH_EAST)
  width, height = window.get_size()
  window.move(gtk.gdk.screen_width() - width, gtk.gdk.screen_height() - height)
</programlisting>

	<para>The <ulink
url="http://standards.freedesktop.org/wm-spec/wm-spec-latest.html">Extended
Window Manager Hints</ulink> specification has a nice table of gravities in
the "implementation notes" section. The <link
linkend="method-gtkwindow--get-position"><methodname>get_position</methodname>()</link>
method documentation may also be relevant.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-position">
      <title>gtk.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 tuple containing the X and Y coordinates of
the gravity-determined reference point</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>get_position</methodname>() method returns a
tuple containing the x and y coordinates of the window that you would need
to pass to the <link
linkend="method-gtkwindow--move"><methodname>move</methodname>()</link>
method to keep the window in its current position. This means that the
meaning of the returned value varies with window gravity. See the <link
linkend="method-gtkwindow--move"><methodname>move</methodname>()</link>
method for more details. If you haven't changed the window gravity, its
gravity will be <literal>gtk.gdk.GRAVITY_NORTH_WEST</literal>. This means
that the <methodname>get_position</methodname>() method gets the position of
the top-left corner of the window manager frame for the window. The <link
linkend="method-gtkwindow--move"><methodname>move</methodname>()</link>
method sets the position of this same top-left corner.</para>

      <para>The <methodname>get_position</methodname>() method is not 100%
reliable because the X Window System does not specify a way to obtain the
geometry of the decorations placed on a window by the window manager. Thus
<literal>PyGTK</literal> is using a "best guess" that works with most window
managers. Moreover, nearly all window managers are historically broken with
respect to their handling of window gravity. So moving a window to its
current position as returned by the <methodname>get_position</methodname>()
method tends to result in moving the window slightly. Window managers are
slowly getting better over time.</para>

      <para>If a window has gravity
<literal>gtk.gdk.GRAVITY_STATIC</literal> the window manager frame is not
relevant, and thus the <methodname>get_position</methodname>() method will
always produce accurate results. However you can't use static gravity to do
things like place a window in a corner of the screen, because static gravity
ignores the window manager decorations. If you are saving and restoring your
application's window positions, you should know that it's impossible for
applications to do this without getting it somewhat wrong because
applications do not have sufficient knowledge of window manager state. The
correct mechanism is to support the session management protocol (see the
"GnomeClient" object in the GNOME libraries for example) and allow the
window manager to save your window sizes and positions.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--parse-geometry">
      <title>gtk.Window.parse_geometry</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>parse_geometry</methodname>
	  <methodparam><parameter
			 role="keyword">geometry</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">geometry</parameter>&nbsp;:</term>
	  <listitem><simpara>the geometry string</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if string was parsed
successfully</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <methodname>parse_geometry</methodname>() method parses the
standard X Window System geometry string specified by
<parameter>geometry</parameter>. The geometry string has the format
"WIDTHxHEIGHT+XOFFSET+YOFFSET" where WIDTH, HEIGHT, XOFFSET and YOFFSET are
specified in pixels (see the X documentation for more details). This method
works work on all <literal>PyGTK</literal> ports including Win32 but is
primarily intended for an X environment. If either a size or a position can
be extracted from the geometry string, the
<methodname>parse_geometry</methodname>() method returns
<literal>True</literal> and calls the <link
linkend="method-gtkwindow--set-default-size"><methodname>set_default_size</methodname>()</link> 
and <link
linkend="method-gtkwindow--move"><methodname>move</methodname>()</link>
methods to resize and move the window.</para>

      <para>If the <methodname>parse_geometry</methodname>() method returns
<literal>True</literal>, it will also set the
<literal>gtk.gdk.HINT_USER_POS</literal> and
<literal>gtk.gdk.HINT_USER_SIZE</literal> hints indicating to the window
manager that the size and position of the window was user-specified. This
causes most window managers to honor the geometry.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--reshow-with-initial-size">
      <title>gtk.Window.reshow_with_initial_size</title>

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

      <para>The <methodname>reshow_with_initial_size</methodname>() method
hides the window, then reshows it, resetting the default size and position
of the window. Used by GUI builders only.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--tooltips-get-info-from-tip-window">
      <title>gtk.Window.tooltips_get_info_from_tip_window</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>tooltips_get_info_from_tip_window</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	<term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a 2-tuple containing the <link
	  linkend="class-gtktooltips"><classname>gtk.Tooltips</classname></link>
	  and <link
	  linkend="class-gtkwidget"><classname>gtk.Widget</classname></link>
	  displayed in the window or <literal>None</literal>.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>tooltips_get_info_from_tip_window</methodname>()
method returns a 2-tuple containing the <link
linkend="class-gtktooltips"><classname>gtk.Tooltips</classname></link> and
<link linkend="class-gtkwidget"><classname>gtk.Widget</classname></link>
displayed in the window. If the window is not displaying tooltips this
method returns None. This method is mostly intended for use by accessibility
technologies - applications should have little use for it.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-focus-on-map">
      <title>gtk.Window.set_focus_on_map</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_focus_on_map</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> this window would
like to receive focus when mapped.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>set_focus_on_map</methodname>() method sets the
"focus-on-map" property to the value of <parameter>setting</parameter>. If
<parameter>setting</parameter> is <literal>True</literal> a hint is set
asking the desktop environment to give focus to the window when it is
mapped.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-focus-on-map">
      <title>gtk.Window.get_focus_on_map</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_focus_on_map</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window would
like to receive focus when mapped.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>get_focus_on_map</methodname>() method returns
the value of the "focus-on-map" property. See the <link
linkend="method-gtkwindow--set-focus-on-map"><methodname>set_focus_on_map</methodname>()</link>
method for more information.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-icon-name">
      <title>gtk.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 themed icon or
<literal>None</literal></simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>set_icon_name</methodname>() method sets the
"icon-name" property to the value of <parameter>name</parameter>. If
<parameter>name</parameter> is <literal>None</literal>, then the default
themed icon will be used. The "icon-name" property contains the name of the
icon used for the window. See the <link
linkend="class-gtkicontheme"><classname>gtk.IconTheme</classname></link>
reference for more information.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-icon-name">
      <title>gtk.Window.get_icon_name</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_icon_name</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>The name of the themed icon used for the
window icon or <literal>None</literal> if no icon is set.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>get_icon_name</methodname>() method returns the
name of the themed icon for the window, see the <link
linkend="method-gtkwindow--set-icon-name"><methodname>set_icon_name</methodname>()</link>
method for more information.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-urgency-hint">
      <title>gtk.Window.set_urgency_hint</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>set_urgency_hint</methodname>
	  <methodparam><parameter
			 role="keyword">urgency_hint</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">urgency_hint</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>True</literal> mark this window
as needing urgent attention.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>set_urgency_hint</methodname>() method sets the
"urgency-hint" property to the value of
<parameter>urgency_hint</parameter>. If the "urgency-hint" property is True
the window sets a hint to the desktop environment to draw the users
attention to the window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-urgency-hint">
      <title>gtk.Window.get_urgency_hint</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>get_urgency_hint</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> if the window is marked
as needing urgent user attention.</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>get_urgency_hint</methodname>() method returns
the value of the "urgency-hint" property. See the <link
linkend="method-gtkwindow--set-urgency-hint"><methodname>set_urgency_hint</methodname>()</link>
method for more information.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--present-with-time">
      <title>gtk.Window.present_with_time</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>present_with_time</methodname>
	  <methodparam><parameter role="keyword">timestamp</parameter></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter
	  role="keyword">timestamp</parameter>&nbsp;:</term>
	  <listitem><simpara>the timestamp of the user interaction (typically
a button or key press event) which triggered this call</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <methodname>present_with_time</methodname>() method presents
a window to the user in response to a user interaction. If you need to
present a window without a timestamp, use the <link
linkend="method-gtkwindow--present"><methodname>present</methodname>()</link>
method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-deletable">
      <title>gtk.Window.set_deletable</title>

      <programlisting><methodsynopsis language="python">
        <methodname>set_deletable</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> decorate the window
          as deletable</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>By default, windows have a close button in the window
      frame. Some window managers allow GTK+ to disable this button. If you
      set the deletable property to <literal>False</literal> using this
      method, GTK+ will do its best to convince the window manager not to
      show a close button. Depending on the system, this method may not have
      any effect when called on a window that is already visible, so you
      should call it before calling
      <methodname>gtk_window_show</methodname>().</para>
      
      <para>On Windows, this method always works, since there's no window
      manager policy involved.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-deletable">
      <title>gtk.Window.get_deletable</title>

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

      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> if the window has been
          set to have a close button</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>Returns whether the window has been set to have a close button
      via the <link
      linkend="method-gtkwindow--set-deletable"><methodname>gtk.Window.set_deletable()</methodname></link>
      method.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-group">
      <title>gtk.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 <link
          linkend="class-gtkwindowgroup"><classname>gtk.WindowGroup</classname></link>
          for a window or the default group</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>Returns the <link
      linkend="class-gtkwindowgroup"><classname>gtk.WindowGroup</classname></link>
      or the default group, if the window does not have an explicit window
      group.</para>

    </refsect2>
    
    <refsect2 id="method-gtkwindow--has-group">
      <title>gtk.Window.has_group</title>

      <programlisting><methodsynopsis language="python">
        <methodname>has_group</methodname>
        <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> if the window has an explicit window group, <literal>False</literal> otherwise.</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>The <methodname>has_group</methodname>() method returns whether window has an explicit window group.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-window-type">
      <title>gtk.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 the window.</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>The <methodname>get_window_type</methodname>() method gets the type of the window.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--set-opacity">
      <title>gtk.Window.set_opacity</title>

      <programlisting><methodsynopsis language="python">
        <methodname>set_opacity</methodname>
        <methodparam><parameter role="keyword">opacity</parameter></methodparam>
      </methodsynopsis></programlisting>

      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">opacity</parameter>&nbsp;:</term>
          <listitem><simpara>desired opacity, between 0 and 1.</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>
        Request the windowing system to make window partially transparent, with
        opacity 0 being fully transparent and 1 fully opaque. (Values of the
        opacity parameter are clamped to the [0,1] range.) On X11 this has any
        effect only on X screens with a compositing manager running.
        See <methodname><link linkend="method-gtkwidget--is-composited">gtk.Widget.is_composited</link></methodname>().
        On Windows it should work always.
      </para>
      <para>        
        Note that setting a window's opacity after the window has been shown causes it to flicker once on Windows.
      </para>
    </refsect2>

    <refsect2 id="method-gtkwindow--get-opacity">
      <title>gtk.Window.get_opacity</title>

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

      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara>the requested opacity for this window.</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>Fetches the requested opacity for this window. See
      <methodname><link linkend="method-gtkwindow--set-opacity">gtk.Window.set_opacity</link></methodname>().</para>

    </refsect2>
    
    <refsect2 id="method-gtkwindow--set-startup-id">
      <title>gtk.Window.set_startup_id</title>

      <programlisting><methodsynopsis language="python">
        <methodname>set_startup_id</methodname>
        <methodparam><parameter role="keyword">startup_id</parameter></methodparam>
      </methodsynopsis></programlisting>

      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">startup_id</parameter>&nbsp;:</term>
          <listitem><simpara>a string with startup-notification identifier</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>
        Startup notification identifiers are used by desktop environment to track
        application startup, to provide user feedback and other features. This
        function changes the corresponding property on the underlying GdkWindow.
        Normally, startup identifier is managed automatically and you should only
        use this function in special cases like transferring focus from other processes.
        You should use this function before calling
        <methodname><link linkend="method-gtkwindow--present">gtk.Window.present</link></methodname>()
        or any equivalent function generating a window map event.
      </para>
      <para>        
        This function is only useful on X11, not with other GTK+ targets.
      </para>
    </refsect2>

    <refsect2 id="method-gtkwindow--get-default-widget">
      <title>gtk.Window.get_default_widget</title>

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

      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara>The default widget, or <literal>None</literal>
	  if there is none.</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>
	Returns the default widget for window. See
	<methodname><link linkend="method-gtkwindow--set-default">gtk.Window.set_default</link></methodname>()()
	for more details.
      </para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
        <methodname>set_skip_taskbar_hint</methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> to keep this window from appearing in the task bar, <literal>False</literal> otherwise.</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <methodname>set_skip_taskbar_hint</methodname>() method set a hint
      asking the desktop environment not to display the window in the task bar.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-skip-taskbar-hint">
      <title>gtk.Window.get_skip_taskbar_hint</title>

      <programlisting><methodsynopsis language="python">
        <methodname>get_skip_taskbar_hint</methodname>
        <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> if this window is kept from appearing in the task bar, <literal>False</literal> otherwise.</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <methodname>get_skip_taskbar_hint</methodname>() method returns whether a hint
      is set asking the desktop environment not to display the window in the task bar.</para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
        <methodname>set_skip_pager_hint</methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> to keep this window from appearing in the pager, <literal>False</literal> otherwise.</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <methodname>set_skip_pager_hint</methodname>() method sets a hint asking the
      desktop environment not to display the window in the pager. A "pager" is any desktop
      navigation tool such as a workspace switcher that displays a thumbnail representation of
      the windows on the screen.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-skip-pager-hint">
      <title>gtk.Window.get_skip_pager_hint</title>

      <programlisting><methodsynopsis language="python">
        <methodname>get_skip_pager_hint</methodname>
        <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> if this window is kept from appearing in the pager, <literal>False</literal> otherwise.</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <methodname>get_skip_pager_hint</methodname>() method returns whether a hint
      is set asking the desktop environment not to display the window in the pager.</para>

    </refsect2>

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

      <programlisting><methodsynopsis language="python">
        <methodname>set_accept_focus</methodname>
        <methodparam><parameter role="keyword">setting</parameter></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> to let this window receive input focus.</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <methodname>set_accept_focus</methodname>() method sets a hint asking
      the desktop environment to receive the input focus or not.</para>

    </refsect2>

    <refsect2 id="method-gtkwindow--get-accept-focus">
      <title>gtk.Window.get_accept_focus</title>

      <programlisting><methodsynopsis language="python">
        <methodname>get_accept_focus</methodname>
        <methodparam></methodparam>
      </methodsynopsis></programlisting>
      <variablelist>
        <varlistentry>
          <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara><literal>True</literal> if the window should receive the input focus.</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <methodname>get_accept_focus</methodname>() method returns whether a hint
      is set asking the desktop environment to receive the input focus.</para>

    </refsect2>

  </refsect1>

  <refsect1>
    <title>Functions</title>

    <refsect2 id="function-gtk--window-set-default-icon-list">
      <title>gtk.window_set_default_icon_list</title>

      <programlisting><methodsynopsis language="python">
          <methodname>gtk.window_set_default_icon_list</methodname>
          <methodparam><parameter>...</parameter>
          </methodparam>
        </methodsynopsis></programlisting>

      <variablelist>
        <varlistentry>
          <term><parameter>...</parameter>&nbsp;:</term>
          <listitem><simpara>zero or more <link
linkend="class-gdkpixbuf"><classname>gtk.gdk.Pixbuf</classname></link>
objects</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <function>gtk.window_set_default_icon_list</function>()
function sets an icon list to be used as fallback for windows that haven't
had the <link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method called on them to set up a window-specific icon list. This function
allows you to set up the icon for all windows in your app at once. See the
<link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method documentation for more details.</para>

    </refsect2>

    <refsect2 id="function-gtk--window-set-default-icon">
      <title>gtk.window_set_default_icon</title>

      <programlisting><methodsynopsis language="python">
          <methodname>gtk.window_set_default_icon</methodname>
          <methodparam><parameter role="keyword">icon</parameter>
          </methodparam>
        </methodsynopsis></programlisting>

      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">icon</parameter>&nbsp;:</term>
          <listitem><simpara>a <link
          linkend="class-gdkpixbuf"><classname>gtk.gdk.Pixbuf</classname></link></simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>The <function>gtk.window_set_default_icon</function>() function
sets an icon specified by <parameter>icon</parameter> to be used as the
fallback for windows that haven't had the <link
linkend="method-gtkwindow--set-icon"><methodname>set_icon</methodname>()</link>
method called on them to set up a window-specific icon. This function allows
you to set up the icon for all windows in your app at once.</para>

    </refsect2>

    <refsect2 id="function-gtk--window-set-default-icon-from-file">
      <title>gtk.window_set_default_icon_from_file</title>

      <programlisting><methodsynopsis language="python">
          <methodname>gtk.window_set_default_icon_from_file</methodname>
          <methodparam><parameter role="keyword">filename</parameter>
          </methodparam>
        </methodsynopsis></programlisting>

      <variablelist>
        <varlistentry>
          <term><parameter role="keyword">filename</parameter>&nbsp;:</term>
          <listitem><simpara>an icon file name</simpara></listitem>
        </varlistentry>
      </variablelist>

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

      <para>The <function>gtk.window_set_default_icon_from_file</function>()
function sets an icon contained in the file specified by
<parameter>filename</parameter> to be used as the fallback for windows that
haven't had the <link
linkend="method-gtkwindow--set-icon"><methodname>set_icon</methodname>()</link>
method called on them to set up a window-specific icon. This function allows
you to set up the icon for all windows in your app at once.</para>

      <para>The GError exception is raised if an error occurs while loading
the icon pixbuf from <parameter>filename</parameter>.</para>

    </refsect2>

    <refsect2 id="function-gtk--window-get-default-icon-list">
      <title>gtk.window_get_default_icon_list</title>

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

      <variablelist>
        <varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
          <listitem><simpara>a copy of the applications default icon
list</simpara></listitem>
        </varlistentry>
      </variablelist>

      <para>The <function>gtk.window_get_default_icon_list</function>()
function returns the application's default icon list as set by the <link
linkend="function-gtk--window-set-default-icon-list"><methodname>gtk.window_set_default_icon_list</methodname>()</link> 
function. See the <link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link> 
method documentation for more details.</para>

    </refsect2>

    <refsect2 id="function-gtk--window-set-auto-startup-notification">
      <title>gtk.window_set_auto_startup_notification</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.window_set_auto_startup_notification</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>True</literal>, automatically do
	  startup notification</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The
<function>gtk.window_set_auto_startup_notification</function>() function
sets the auto startup notification setting to the value of <parameter>setting</parameter>. If <parameter>setting</parameter> is <literal>True</literal> startup notification will be done automatically.</para>

      <para>By default, after showing the first <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> for each
<link
linkend="class-gdkscreen"><classname>gtk.gdk.Screen</classname></link>, GTK+
calls the <function>gdk_notify_startup_complete</function>() function. Call
this function to disable the automatic startup notification. You might do
this if your first window is a splash screen, and you want to delay
notification until after your real main window has been shown. In that
example, you would disable startup notification temporarily, show your
splash screen, then re-enable it so that showing the main window would
automatically result in notification.</para>

    </refsect2>

    <refsect2 id="function-gtk--window-list-toplevels">
      <title>gtk.window_list_toplevels</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.window_list_toplevels</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara>a list of all the toplevel <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link>
widgets</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The <function>gtk.window_list_toplevels</function>() function
returns a list of all the toplevel <link
linkend="class-gtkwindow"><classname>gtk.Window</classname></link> widgets
in the application.</para>

    </refsect2>

    <refsect2 id="function-gtk--window-set-default-icon-name">
      <title>gtk.window_set_default_icon_name</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>gtk.window_set_default_icon_name</methodname>
	  <methodparam></methodparam>
	</methodsynopsis></programlisting>
      <variablelist>
	<varlistentry>
	  <term><parameter role="keyword">setting</parameter>&nbsp;:</term>
	  <listitem><simpara>if <literal>True</literal>, automatically do
	  startup notification</simpara></listitem>
	</varlistentry>
      </variablelist>

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

      <para>The <function>gtk.window_set_default_icon_name</function>()
function sets an icon to be used as fallback for windows that haven't had
the <link
linkend="method-gtkwindow--set-icon-list"><methodname>set_icon_list</methodname>()</link>
method called on them from a named themed icon, see the <link
linkend="method-gtkwindow--set-icon-name"><methodname>set_icon_name</methodname>()</link>
method.</para>

    </refsect2>

  </refsect1>

  <refsect1>
    <title>Signals</title>

    <refsect2 id="signal-gtkwindow--activate-default">
      <title>The "activate-default" gtk.Window Signal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>callback</methodname>
	  <methodparam><parameter>window</parameter></methodparam>
	  <methodparam><parameter>user_param1</parameter></methodparam>
	  <methodparam><parameter>...</parameter></methodparam>
	</methodsynopsis></programlisting>

      <variablelist>
	<varlistentry>
	  <term><parameter>window</parameter>&nbsp;:</term>
	  <listitem><simpara>the window that received the
signal</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>user_param1</parameter>&nbsp;:</term>
          <listitem><simpara>the first user parameter (if any) specified
with the <link
linkend="method-gobject--connect"><methodname>connect</methodname>()</link>
method</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>...</parameter>&nbsp;:</term>
	  <listitem><simpara>additional user parameters (if
any)</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The "activate-default" signal is emitted when the default child
widget of <parameter>window</parameter> is activated usually by the user
pressing the <keycap>Return</keycap> or <keycap>Enter</keycap> key.</para>

    </refsect2>

    <refsect2 id="signal-gtkwindow--activate-focus">
      <title>The "activate-focus" gtk.Window Signal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>callback</methodname>
	  <methodparam><parameter>window</parameter></methodparam>
	  <methodparam><parameter>user_param1</parameter></methodparam>
	  <methodparam><parameter>...</parameter></methodparam>
	</methodsynopsis></programlisting>

      <variablelist>
	<varlistentry>
	  <term><parameter>window</parameter>&nbsp;:</term>
	  <listitem><simpara>the window that received the
signal</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>user_param1</parameter>&nbsp;:</term>
          <listitem><simpara>the first user parameter (if any) specified
with the <link
linkend="method-gobject--connect"><methodname>connect</methodname>()</link>
method</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>...</parameter>&nbsp;:</term>
	  <listitem><simpara>additional user parameters (if
any)</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The "activate-focus" signal is emitted when the child widget
with the focus is activated usually by the user pressing the
<keycap>Space</keycap> key.</para>

    </refsect2>

    <refsect2 id="signal-gtkwindow--frame-event">
      <title>The "frame-event" gtk.Window Signal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>callback</methodname>
	  <methodparam><parameter>window</parameter></methodparam>
	  <methodparam><parameter>event</parameter></methodparam>
	  <methodparam><parameter>user_param1</parameter></methodparam>
	  <methodparam><parameter>...</parameter></methodparam>
	</methodsynopsis></programlisting>

      <variablelist>
	<varlistentry>
	  <term><parameter>window</parameter>&nbsp;:</term>
	  <listitem><simpara>the window that received the
signal</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>event</parameter>&nbsp;:</term>
	  <listitem><simpara>the event that triggered the
signal</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>user_param1</parameter>&nbsp;:</term>
          <listitem><simpara>the first user parameter (if any) specified
with the <link
linkend="method-gobject--connect"><methodname>connect</methodname>()</link>
method</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>...</parameter>&nbsp;:</term>
	  <listitem><simpara>additional user parameters (if
any)</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><emphasis>Returns</emphasis>&nbsp;:</term>
	  <listitem><simpara><literal>True</literal> to stop other handlers
	  from being invoked for the event. <literal>False</literal> to
	  propagate the event further.</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The "frame-event" signal is emitted when an event other than key
press or release or focus change is received on the window's frame.</para>

    </refsect2>

    <refsect2 id="signal-gtkwindow--keys-changed">
      <title>The "keys-changed" gtk.Window Signal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>callback</methodname>
	  <methodparam><parameter>window</parameter></methodparam>
	  <methodparam><parameter>user_param1</parameter></methodparam>
	  <methodparam><parameter>...</parameter></methodparam>
	</methodsynopsis></programlisting>

      <variablelist>
	<varlistentry>
	  <term><parameter>window</parameter>&nbsp;:</term>
	  <listitem><simpara>the window that received the
signal</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>user_param1</parameter>&nbsp;:</term>
          <listitem><simpara>the first user parameter (if any) specified
with the <link
linkend="method-gobject--connect"><methodname>connect</methodname>()</link>
method</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>...</parameter>&nbsp;:</term>
	  <listitem><simpara>additional user parameters (if
any)</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The "keys-changed" signal is emitted when a mnemonic accelerator
is added, removed or changed or the mnemonic modifier is set.</para>

    </refsect2>

    <refsect2 id="signal-gtkwindow--move-focus">
      <title>The "move-focus" gtk.Window Signal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>callback</methodname>
	  <methodparam><parameter>window</parameter></methodparam>
	  <methodparam><parameter>direction</parameter></methodparam>
	  <methodparam><parameter>user_param1</parameter></methodparam>
	  <methodparam><parameter>...</parameter></methodparam>
	</methodsynopsis></programlisting>

      <variablelist>
	<varlistentry>
	  <term><parameter>window</parameter>&nbsp;:</term>
	  <listitem><simpara>the window that received the
signal</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>direction</parameter>&nbsp;:</term>
	  <listitem><simpara>the move direction:
<literal>gtk.DIR_TAB_FORWARD</literal>,
<literal>gtk.DIR_TAB_BACKWARD</literal>, <literal>gtk.DIR_UP</literal>,
<literal>gtk.DIR_DOWN</literal>, <literal>gtk.DIR_LEFT</literal> or
<literal>gtk.DIR_RIGHT</literal></simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>user_param1</parameter>&nbsp;:</term>
          <listitem><simpara>the first user parameter (if any) specified
with the <link
linkend="method-gobject--connect"><methodname>connect</methodname>()</link>
method</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>...</parameter>&nbsp;:</term>
	  <listitem><simpara>additional user parameters (if
any)</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The "move-focus" signal is emitted when the focus is changed
within the window's child widgets. Usually this happens when the user
presses the <keycap>Tab</keycap>, the <keycombo
action="simul"><keycap>Shift</keycap><keycap>Tab</keycap> </keycombo> or the
<keycap>Up</keycap>, <keycap>Down</keycap>, <keycap>Left</keycap> or
<keycap>Right</keycap> arrow keys.</para>

    </refsect2>

    <refsect2 id="signal-gtkwindow--set-focus">
      <title>The "set-focus" gtk.Window Signal</title>

      <programlisting><methodsynopsis language="python">
	  <methodname>callback</methodname>
	  <methodparam><parameter>window</parameter></methodparam>
	  <methodparam><parameter>widget</parameter></methodparam>
	  <methodparam><parameter>user_param1</parameter></methodparam>
	  <methodparam><parameter>...</parameter></methodparam>
	</methodsynopsis></programlisting>

      <variablelist>
	<varlistentry>
	  <term><parameter>window</parameter>&nbsp;:</term>
	  <listitem><simpara>the window that received the
signal</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>widget</parameter>&nbsp;:</term>
	  <listitem><simpara>the widget that receives the
focus</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>user_param1</parameter>&nbsp;:</term>
          <listitem><simpara>the first user parameter (if any) specified
with the <link
linkend="method-gobject--connect"><methodname>connect</methodname>()</link>
method</simpara></listitem>
	</varlistentry>
	<varlistentry>
	  <term><parameter>...</parameter>&nbsp;:</term>
	  <listitem><simpara>additional user parameters (if
any)</simpara></listitem>
	</varlistentry>
      </variablelist>

      <para>The "set-focus" signal is emitted when the focus changes to <parameter>widget</parameter> in <parameter>window</parameter>.</para>

    </refsect2>

  </refsect1>

</refentry>
