gdk-Windows              package:RGtk2              R Documentation

_W_i_n_d_o_w_s

_D_e_s_c_r_i_p_t_i_o_n:

     Onscreen display areas in the target window system

_M_e_t_h_o_d_s _a_n_d _F_u_n_c_t_i_o_n_s:

     'gdkWindowNew(parent = NULL, attributes)'
      'gdkWindowDestroy(object)'
      'gdkWindowGetWindowType(object)'
      'gdkWindowAtPointer()'
      'gdkWindowShow(object)'
      'gdkWindowShowUnraised(object)'
      'gdkWindowHide(object)'
      'gdkWindowIsVisible(object)'
      'gdkWindowIsViewable(object)'
      'gdkWindowGetState(object)'
      'gdkWindowWithdraw(object)'
      'gdkWindowIconify(object)'
      'gdkWindowDeiconify(object)'
      'gdkWindowStick(object)'
      'gdkWindowUnstick(object)'
      'gdkWindowMaximize(object)'
      'gdkWindowUnmaximize(object)'
      'gdkWindowFullscreen(object)'
      'gdkWindowUnfullscreen(object)'
      'gdkWindowSetKeepAbove(object, setting)'
      'gdkWindowSetKeepBelow(object, setting)'
      'gdkWindowMove(object, x, y)'
      'gdkWindowResize(object, width, height)'
      'gdkWindowMoveResize(object, x, y, width, height)'
      'gdkWindowScroll(object, dx, dy)'
      'gdkWindowMoveRegion(object, region, x, y)'
      'gdkWindowReparent(object, new.parent, x, y)'
      'gdkWindowClear(object)'
      'gdkWindowClearArea(object, x, y, width, height)'
      'gdkWindowClearAreaE(object, x, y, width, height)'
      'gdkWindowRaise(object)'
      'gdkWindowLower(object)'
      'gdkWindowFocus(object, timestamp = "GDK_CURRENT_TIME")'
      'gdkWindowRegisterDnd(object)'
      'gdkWindowBeginResizeDrag(object, edge, button, root.x, root.y,
     timestamp)'
      'gdkWindowBeginMoveDrag(object, button, root.x, root.y,
     timestamp)'
      'gdkWindowConstrainSize(geometry, width, height)'
      'gdkWindowBeginPaintRect(object, rectangle)'
      'gdkWindowBeginPaintRegion(object, region)'
      'gdkWindowEndPaint(object)'
      'gdkWindowInvalidateRect(object, rect = NULL,
     invalidate.children)'
      'gdkWindowInvalidateRegion(object, region, invalidate.children)'
      'gdkWindowInvalidateMaybeRecurse(object, region, child.func,
     user.data)'
      'gdkWindowGetUpdateArea(object)'
      'gdkWindowFreezeUpdates(object)'
      'gdkWindowThawUpdates(object)'
      'gdkWindowProcessAllUpdates()'
      'gdkWindowProcessUpdates(object, update.children)'
      'gdkWindowSetDebugUpdates(setting)'
      'gdkWindowGetInternalPaintInfo(object)'
      'gdkWindowEnableSynchronizedConfigure(object)'
      'gdkWindowConfigureFinished(object)'
      'gdkWindowSetUserData(object, user.data)'
      'gdkWindowSetOverrideRedirect(object, override.redirect)'
      'gdkWindowSetAcceptFocus(object, accept.focus)'
      'gdkWindowSetFocusOnMap(object, focus.on.map)'
      'gdkWindowAddFilter(object, fun, data)'
      'gdkWindowRemoveFilter(object, fun, data)'
      'gdkWindowShapeCombineMask(object, shape.mask = NULL, offset.x,
     offset.y)'
      'gdkWindowShapeCombineRegion(object, shape.region = NULL,
     offset.x, offset.y)'
      'gdkWindowSetChildShapes(object)'
      'gdkWindowMergeChildShapes(object)'
      'gdkWindowSetStaticGravities(object, use.static)'
      'gdkWindowSetHints(object, x, y, min.width, min.height,
     max.width, max.height, flags)'
      'gdkWindowSetTitle(object, title)'
      'gdkWindowSetBackground(object, color)'
      'gdkWindowSetBackPixmap(object, pixmap = NULL, parent.relative)'
      'gdkWindowSetCursor(object, cursor = NULL)'
      'gdkWindowGetUserData(object)'
      'gdkWindowGetGeometry(object)'
      'gdkWindowSetGeometryHints(object, geometry)'
      'gdkWindowSetIconList(object, pixbufs)'
      'gdkWindowSetModalHint(object, modal)'
      'gdkWindowSetTypeHint(object, hint)'
      'gdkWindowSetSkipTaskbarHint(object, modal)'
      'gdkWindowSetSkipPagerHint(object, modal)'
      'gdkWindowSetUrgencyHint(object, urgent)'
      'gdkWindowGetPosition(object)'
      'gdkWindowGetRootOrigin(object)'
      'gdkWindowGetFrameExtents(object)'
      'gdkWindowGetOrigin(object)'
      'gdkWindowGetDeskrelativeOrigin(object)'
      'gdkWindowGetPointer(object)'
      'gdkWindowGetParent(object)'
      'gdkWindowGetToplevel(object)'
      'gdkWindowGetChildren(object)'
      'gdkWindowPeekChildren(object)'
      'gdkWindowGetEvents(object)'
      'gdkWindowSetEvents(object, event.mask)'
      'gdkWindowSetIcon(object, icon.window, pixmap, mask)'
      'gdkWindowSetIconName(object, name)'
      'gdkWindowSetTransientFor(object, leader)'
      'gdkWindowSetRole(object, role)'
      'gdkWindowSetGroup(object, leader)'
      'gdkWindowGetGroup(object)'
      'gdkWindowSetDecorations(object, decorations)'
      'gdkWindowGetDecorations(object)'
      'gdkWindowSetFunctions(object, functions)'
      'gdkWindowGetToplevels()'
      'gdkGetDefaultRootWindow()'
      'gdkSetPointerHooks(object, new.hooks)'
      'gdkWindow(parent = NULL, attributes)'

_H_i_e_r_a_r_c_h_y:

     GObject
        +----GdkDrawable
              +----GdkWindow 

_D_e_t_a_i_l_e_d _D_e_s_c_r_i_p_t_i_o_n:

     A 'GdkWindow' is a rectangular region on the screen. It's a
     low-level object, used to implement high-level objects such as
     'GtkWidget' and 'GtkWindow' on the GTK+ level. A 'GtkWindow' is a
     toplevel window, the thing a user might think of  as a "window"
     with a titlebar and so on; a 'GtkWindow' may contain many
     'GdkWindow'.  For example, each 'GtkButton' has a 'GdkWindow'
     associated with it.

_S_t_r_u_c_t_u_r_e_s:

     '_G_d_k_W_i_n_d_o_w' An opaque structure representing an onscreen drawable.
          Pointers to structures of type 'GdkPixmap', 'GdkBitmap', and
          'GdkWindow', can often be used interchangeably. The type
          'GdkDrawable' refers generically to any of these types.


     '_G_d_k_G_e_o_m_e_t_r_y' The 'GdkGeometry' struct gives the window manager
          information about  a window's geometry constraints. Normally
          you would set these on  the GTK+ level using
          'gtkWindowSetGeometryHints'. 'GtkWindow'  then sets the hints
          on the 'GdkWindow' it creates.

          'gdkWindowSetGeometryHints' expects the hints to be fully
          valid already and simply passes them to the window manager;
          in contrast, 'gtkWindowSetGeometryHints' performs some
          interpretation. For example, 'GtkWindow' will apply the hints
          to the geometry widget instead of the toplevel window, if you
          set a geometry widget. Also, the
          'min.width'/'min.height'/'max.width'/'max.height' fields may
          be set to -1, and 'GtkWindow' will substitute the size
          request of the window or geometry widget. If the minimum size
          hint is not provided, 'GtkWindow' will use its requisition as
          the minimum size.  If the minimum size is provided and a
          geometry widget is set, 'GtkWindow' will take the minimum
          size as the minimum size of the geometry widget rather than
          the entire window. The base size is treated similarly.

          The canonical use-case for 'gtkWindowSetGeometryHints' is to
          get a terminal widget to resize properly. Here, the terminal
          text area should be the geometry widget; 'GtkWindow' will
          then automatically set the base size to the size of other
          widgets in the terminal window, such as the menubar and
          scrollbar.  Then, the 'width.inc' and 'height.inc' fields
          should be set to the size of one character in the terminal.
          Finally, the base size should be set to the size of one
          character. The net effect is that the minimum size of the
          terminal  will have a 1x1 character terminal area, and only
          terminal sizes on  the "character grid" will be allowed.

          Here's an example of how the terminal example would be
          implemented, assuming  a terminal area widget called
          "terminal" and a toplevel window "toplevel":


          fields <- c("base.width", "base.height", "min.width",
          "min.height", "width.inc", "height.inc")
          hints[fields] <- char_width
          toplevel$setGeometryHints(terminal, hints)

          The other useful fields are the 'min.aspect' and 'max.aspect'
          fields; these contain a width/height ratio as a floating
          point number. If a geometry widget is set, the aspect applies
          to the geometry widget rather than the entire window. The
          most common use of these hints is probably to set
          'min.aspect' and 'max.aspect' to the same value, thus forcing
          the window to keep a constant aspect ratio. *'GdkGeometry' is
          a transparent-type.*

          '_m_i_n__w_i_d_t_h' [integer] minimum width of window (or -1 to use
               requisition, with 'GtkWindow' only) 'min.height' minimum
               height of window (or -1 to use requisition, with
               'GtkWindow' only)

          '_m_i_n__h_e_i_g_h_t' [integer] 

          '_m_a_x__w_i_d_t_h' [integer] maximum width of window (or -1 to use
               requisition, with 'GtkWindow' only)

          '_m_a_x__h_e_i_g_h_t' [integer] maximum height of window (or -1 to use
               requisition, with 'GtkWindow' only)

          '_b_a_s_e__w_i_d_t_h' [integer] allowed window widths are 'base.width'
               + 'width.inc' * N where N is any integer (-1 allowed
               with 'GtkWindow')

          '_b_a_s_e__h_e_i_g_h_t' [integer] allowed window widths are
               'base.height' + 'height.inc' * N where N is any integer
               (-1 allowed with 'GtkWindow')

          '_w_i_d_t_h__i_n_c' [integer] width resize increment

          '_h_e_i_g_h_t__i_n_c' [integer] height resize increment

          '_m_i_n__a_s_p_e_c_t' [numeric] minimum width/height ratio

          '_m_a_x__a_s_p_e_c_t' [numeric] maximum width/height ratio

          '_w_i_n__g_r_a_v_i_t_y' ['GdkGravity'] window gravity, see
               'gtkWindowSetGravity'


     '_G_d_k_W_i_n_d_o_w_A_t_t_r' Attributes to use for a newly-created window.
          *'GdkWindowAttr' is a transparent-type.*

          '_t_i_t_l_e' [character] title of the window (for toplevel
               windows)

          '_e_v_e_n_t__m_a_s_k' [integer] event mask (see 'gdkWindowSetEvents')

          '_x' [integer] X coordinate relative to parent window (see
               'gdkWindowMove')

          '_y' [integer] Y coordinate relative to parent window (see
               'gdkWindowMove')

          '_w_i_d_t_h' [integer] width of window

          '_h_e_i_g_h_t' [integer] height of window

          '_w_c_l_a_s_s' ['GdkWindowClass'] 'GDK_INPUT_OUTPUT' (normal
               window) or 'GDK_INPUT_ONLY' (invisible window that
               receives events)

          '_v_i_s_u_a_l' ['GdkVisual'] 'GdkVisual' for window

          '_c_o_l_o_r_m_a_p' ['GdkColormap'] 'GdkColormap' for window

          '_w_i_n_d_o_w__t_y_p_e' ['GdkWindowType'] type of window

          '_c_u_r_s_o_r' ['GdkCursor'] cursor for the window (see
               'gdkWindowSetCursor')

          '_w_m_c_l_a_s_s__n_a_m_e' [character] don't use (see
               'gtkWindowSetWmclass')

          '_w_m_c_l_a_s_s__c_l_a_s_s' [character] don't use (see
               'gtkWindowSetWmclass')

          '_o_v_e_r_r_i_d_e__r_e_d_i_r_e_c_t' [logical] 'TRUE' to bypass the window
               manager


     '_G_d_k_F_i_l_t_e_r_R_e_t_u_r_n' Specifies the result of applying a
          'GdkFilterFunc' to a native event.


_C_o_n_v_e_n_i_e_n_t _C_o_n_s_t_r_u_c_t_i_o_n:

     'gdkWindow' is the equivalent of 'gdkWindowNew'.

_E_n_u_m_s _a_n_d _F_l_a_g_s:

     '_G_d_k_W_i_n_d_o_w_T_y_p_e' Describes the kind of window.

          '_r_o_o_t' root window; this window has no parent, covers the
               entire screen, and is created by the window system

          '_t_o_p_l_e_v_e_l' toplevel window (used to implement 'GtkWindow')

          '_c_h_i_l_d' child window (used to implement e.g. 'GtkButton')

          '_d_i_a_l_o_g' useless/deprecated compatibility type

          '_t_e_m_p' override redirect temporary window (used to implement
               'GtkMenu')

          '_f_o_r_e_i_g_n' foreign window (see 'gdk\Window\Foreign\New()')


     '_G_d_k_W_i_n_d_o_w_C_l_a_s_s' 'GDK.INPUT.OUTPUT' windows are the standard kind
          of window you might expect.  'GDK.INPUT.ONLY' windows are
          invisible; they are used to trap events, but  you can't draw
          on them.

          '_o_u_t_p_u_t' window for graphics and events

          '_o_n_l_y' window for events only


     '_G_d_k_W_i_n_d_o_w_H_i_n_t_s' Used to indicate which fields of a 'GdkGeometry'
          struct should be paid attention to. Also, the
          presence/absence of 'GDK.HINT.POS', 'GDK.HINT.USER.POS', and
          'GDK.HINT.USER.SIZE' is significant, though they don't
          directly refer to 'GdkGeometry' fields.  'GDK.HINT.USER.POS'
          will be set automatically by 'GtkWindow' if you call
          'gtkWindowMove'. 'GDK.HINT.USER.POS' and 'GDK.HINT.USER.SIZE'
           should be set if the user specified a size/position using a
          -geometry  command-line argument;
          'gtk\Window\Parse\Geometry()' automatically sets these flags.

          '_p_o_s' indicates that the program has positioned the window

          '_m_i_n-_s_i_z_e' min size fields are set

          '_m_a_x-_s_i_z_e' max size fields are set

          '_b_a_s_e-_s_i_z_e' base size fields are set

          '_a_s_p_e_c_t' aspect ratio fields are set

          '_r_e_s_i_z_e-_i_n_c' resize increment fields are set

          '_w_i_n-_g_r_a_v_i_t_y' window gravity field is set

          '_u_s_e_r-_p_o_s' indicates that the window's position was
               explicitly set by the user

          '_u_s_e_r-_s_i_z_e' indicates that the window's size was explicitly
               set by the user


     '_G_d_k_G_r_a_v_i_t_y' Defines the reference point of a window and the
          meaning of coordinates passed to 'gtkWindowMove'. See
          'gtkWindowMove' and the "implementation  notes" section of
          the  Extended  Window Manager Hints (<URL:
          http://www.freedesktop.org/Standards/wm-spec>) specification
          for more details.

          '_n_o_r_t_h-_w_e_s_t' the reference point is at the top left corner.

          '_n_o_r_t_h' the reference point is in the middle of the top edge.

          '_n_o_r_t_h-_e_a_s_t' the reference point is at the top right corner.

          '_w_e_s_t' the reference point is at the middle of the left edge.

          '_c_e_n_t_e_r' the reference point is at the center of the window.

          '_e_a_s_t' the reference point is at the middle of the right
               edge.

          '_s_o_u_t_h-_w_e_s_t' the reference point is at the lower left corner.

          '_s_o_u_t_h' the reference point is at the middle of the lower
               edge.

          '_s_o_u_t_h-_e_a_s_t' the reference point is at the lower right
               corner.

          '_s_t_a_t_i_c' the reference point is at the top left corner of the
                window itself, ignoring window manager decorations.


     '_G_d_k_W_i_n_d_o_w_E_d_g_e' Determines a window edge or corner. 

          '_n_o_r_t_h-_w_e_s_t' the top left corner.

          '_n_o_r_t_h' the top edge.

          '_n_o_r_t_h-_e_a_s_t' the top right corner.

          '_w_e_s_t' the left edge.

          '_e_a_s_t' the right edge.

          '_s_o_u_t_h-_w_e_s_t' the lower left corner.

          '_s_o_u_t_h' the lower edge.

          '_s_o_u_t_h-_e_a_s_t' the lower right corner.


     '_G_d_k_W_i_n_d_o_w_T_y_p_e_H_i_n_t' These are hints for the window manager that
          indicate what type of function  the window has. The window
          manager can use this when determining decoration  and
          behaviour of the window. The hint must be set before mapping
          the window.

          See the Extended  Window Manager Hints (<URL:
          http://www.freedesktop.org/Standards/wm-spec>) specification
          for more details about  window types.

          '_n_o_r_m_a_l' Normal toplevel window.

          '_d_i_a_l_o_g' Dialog window.

          '_m_e_n_u' Window used to implement a menu.

          '_t_o_o_l_b_a_r' Window used to implement toolbars.

          '_s_p_l_a_s_h_s_c_r_e_e_n' Window used to display a splash  screen during
               application startup.

          '_u_t_i_l_i_t_y' Utility windows which are not detached  toolbars or
               dialogs.

          '_d_o_c_k' Used for creating dock or panel windows.

          '_d_e_s_k_t_o_p' Used for creating the desktop background  window.


     '_G_d_k_W_i_n_d_o_w_A_t_t_r_i_b_u_t_e_s_T_y_p_e' Used to indicate which fields in the
          'GdkWindowAttr' struct should be honored. For example, if you
          filled in the "cursor" and "x" fields of 'GdkWindowAttr',
          pass "'GDK.WA.X' | 'GDK.WA.CURSOR'" to 'gdkWindowNew'. 
          Fields in 'GdkWindowAttr' not covered by a bit in this enum
          are required; for example, the 'width'/'height', 'wclass',
          and 'window.type' fields are required, they have no
          corresponding flag in 'GdkWindowAttributesType'.

          '_t_i_t_l_e' Honor the title field

          '_x' Honor the X coordinate field

          '_y' Honor the Y coordinate field

          '_c_u_r_s_o_r' Honor the cursor field

          '_c_o_l_o_r_m_a_p' Honor the colormap field

          '_v_i_s_u_a_l' Honor the visual field

          '_w_m_c_l_a_s_s' Honor the wmclass_class and wmclass_name fields

          '_n_o_r_e_d_i_r' Honor the override_redirect field


     '_G_d_k_F_i_l_t_e_r_R_e_t_u_r_n' Specifies the result of applying a
          'GdkFilterFunc' to a native event.

          '_c_o_n_t_i_n_u_e' event not handled, continue processing.

          '_t_r_a_n_s_l_a_t_e' native event translated into a GDK event and
               stored in the 'event' structure that was passed in.

          '_r_e_m_o_v_e' event handled, terminate processing.


     '_G_d_k_M_o_d_i_f_i_e_r_T_y_p_e' A set of bit-flags to indicate the state of
          modifier keys and mouse buttons  in various event types.
          Typical modifier keys are Shift, Control, Meta, Super, Hyper,
          Alt, Compose, Apple, CapsLock or ShiftLock. 

          Like the X Window System, GDK supports 8 modifier keys and 5
          mouse buttons.

          '_s_h_i_f_t-_m_a_s_k' the Shift key.

          '_l_o_c_k-_m_a_s_k' a Lock key (depending on the modifier mapping of
               the  X server this may either be CapsLock or ShiftLock).

          '_c_o_n_t_r_o_l-_m_a_s_k' the Control key.

          '_m_o_d_1-_m_a_s_k' 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).

          '_m_o_d_2-_m_a_s_k' the fifth modifier key (it depends on the
               modifier  mapping of the X server which key is
               interpreted as this modifier).

          '_m_o_d_3-_m_a_s_k' the sixth modifier key (it depends on the
               modifier  mapping of the X server which key is
               interpreted as this modifier).

          '_m_o_d_4-_m_a_s_k' the seventh modifier key (it depends on the
               modifier  mapping of the X server which key is
               interpreted as this modifier).

          '_m_o_d_5-_m_a_s_k' the eighth modifier key (it depends on the
               modifier  mapping of the X server which key is
               interpreted as this modifier).

          '_b_u_t_t_o_n_1-_m_a_s_k' the first mouse button.

          '_b_u_t_t_o_n_2-_m_a_s_k' the second mouse button.

          '_b_u_t_t_o_n_3-_m_a_s_k' the third mouse button.

          '_b_u_t_t_o_n_4-_m_a_s_k' the fourth mouse button.

          '_b_u_t_t_o_n_5-_m_a_s_k' the fifth mouse button.

          '_r_e_l_e_a_s_e-_m_a_s_k' not used in GDK itself. GTK+ uses it to
               differentiate  between (keyval, modifiers) pairs from
               key press and release events.

          '_m_o_d_i_f_i_e_r-_m_a_s_k' a mask covering all modifier types.


     '_G_d_k_W_M_D_e_c_o_r_a_t_i_o_n' These are hints originally defined by the Motif
          toolkit. The window manager can use them when determining how
          to decorate the window. The hint must be set before mapping
          the window.

          '_a_l_l' all decorations should be applied.

          '_b_o_r_d_e_r' a frame should be drawn around the window.

          '_r_e_s_i_z_e_h' the frame should have resize handles.

          '_t_i_t_l_e' a titlebar should be placed above the window.

          '_m_e_n_u' a button for opening a menu should be included.

          '_m_i_n_i_m_i_z_e' a minimize button should be included.

          '_m_a_x_i_m_i_z_e' a maximize button should be included.


     '_G_d_k_W_M_F_u_n_c_t_i_o_n' These are hints originally defined by the Motif
          toolkit. The window manager can use them when determining the
          functions  to offer for the window.  The hint must be set
          before mapping the window.

          '_a_l_l' all functions should be offered.

          '_r_e_s_i_z_e' the window should be resizable.

          '_m_o_v_e' the window should be movable.

          '_m_i_n_i_m_i_z_e' the window should be minimizable.

          '_m_a_x_i_m_i_z_e' the window should be maximizable.

          '_c_l_o_s_e' the window should be closable.


_U_s_e_r _F_u_n_c_t_i_o_n_s:

     '_G_d_k_F_i_l_t_e_r_F_u_n_c(_x_e_v_e_n_t, _e_v_e_n_t, _d_a_t_a)' Specifies the type of
          function used to filter native events before they are
          converted to GDK events. 

          When a filter is called, 'event' is unpopulated, except for
          'event->window'. The filter may translate the native event to
          a GDK event and store the result in 'event', or handle it
          without translation. If the filter translates the event and
          processing should continue, it should return
          'GDK_FILTER_TRANSLATE'.

          '_x_e_v_e_n_t' [GdkXEvent] the native event to filter.

          '_e_v_e_n_t' ['GdkEvent'] the GDK event to which the X event will
               be translated.

          '_d_a_t_a' [R object] user data set when the filter was
               installed.

_A_u_t_h_o_r(_s):

     Derived by RGtkGen from GTK+ documentation

_R_e_f_e_r_e_n_c_e_s:

     <URL: http://developer.gnome.org/doc/API/2.0/gdk/gdk-Windows.html>

