gdk-Points-Rectangles-and-Regions   package:RGtk2   R Documentation

_P_o_i_n_t_s, _R_e_c_t_a_n_g_l_e_s _a_n_d _R_e_g_i_o_n_s

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

     Simple graphical data types

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

     'gdkRectangleIntersect(src1, src2)'
      'gdkRectangleUnion(src1, src2)'
      'gdkRegionNew()'
      'gdkRegionPolygon(points, fill.rule)'
      'gdkRegionCopy(object)'
      'gdkRegionRectangle(rectangle)'
      'gdkRegionGetClipbox(object)'
      'gdkRegionGetRectangles(object)'
      'gdkRegionEmpty(object)'
      'gdkRegionEqual(object, region2)'
      'gdkRegionPointIn(object, x, y)'
      'gdkRegionRectIn(object, rect)'
      'gdkRegionOffset(object, dx, dy)'
      'gdkRegionShrink(object, dx, dy)'
      'gdkRegionUnionWithRect(object, rect)'
      'gdkRegionIntersect(object, source2)'
      'gdkRegionUnion(object, source2)'
      'gdkRegionSubtract(object, source2)'
      'gdkRegionXor(object, source2)'
      'gdkRegionSpansIntersectForeach(object, spans, sorted, fun,
     data)'

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

     GDK provides the 'GdkPoint', 'GdkRectangle', 'GdkRegion' and
     'GdkSpan' data types for representing pixels and sets of pixels on
     the screen. 'GdkPoint' is a simple structure containing an x and y
     coordinate of a point. 'GdkRectangle' is a structure holding the
     position and size of a rectangle. The intersection of two
     rectangles can be computed with 'gdkRectangleIntersect'. To find
     the union of two rectangles use 'gdkRectangleUnion'. 'GdkRegion'
     is an opaque data type holding a set of arbitrary pixels, and is
     usually used for clipping graphical operations (see
     'gdkGCSetClipRegion'). 'GdkSpan' is a structure holding a
     spanline. A spanline is a horizontal line that is one pixel wide.
     It is mainly used when rasterizing other graphics primitives. It
     can be intersected to regions by using
     'gdkRegionSpansIntersectForeach'.

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


     '_G_d_k_P_o_i_n_t' Defines the x and y coordinates of a point. *'GdkPoint'
          is a transparent-type.*

          '_x' [integer] the x coordinate of the point.

          '_y' [integer] the y coordinate of the point.


     '_G_d_k_R_e_c_t_a_n_g_l_e' Defines the position and size of a rectangle.
          *'GdkRectangle' is a transparent-type.*

          '_x' [integer] the x coordinate of the left edge of the
               rectangle.

          '_y' [integer] the y coordinate of the top of the rectangle.

          '_w_i_d_t_h' [integer] the width of the rectangle.

          '_h_e_i_g_h_t' [integer] the height of the rectangle.


     '_G_d_k_R_e_g_i_o_n' A GdkRegion represents a set of pixels on the screen.


     '_G_d_k_S_p_a_n' A GdkSpan represents a horizontal line of pixels
          starting at the pixel with coordinates 'x', 'y' and ending
          before 'x' + 'width', 'y'. *'GdkSpan' is a transparent-type.*

          '_x' [integer] x coordinate of the first pixel.

          '_y' [integer] y coordinate of the first pixel.

          '_w_i_d_t_h' [integer] number of pixels in the span.


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


     '_G_d_k_F_i_l_l_R_u_l_e' The method for determining which pixels are included
          in a region, when creating a 'GdkRegion' from a polygon. The
          fill rule is only relevant for polygons which overlap
          themselves.

          '_e_v_e_n-_o_d_d-_r_u_l_e' areas which are overlapped an odd number of
               times are included in the region, while areas overlapped
               an even number of times are not.

          '_w_i_n_d_i_n_g-_r_u_l_e' overlapping areas are always included.


     '_G_d_k_O_v_e_r_l_a_p_T_y_p_e' Specifies the possible values returned by
          'gdkRegionRectIn'.

          '_i_n' if the rectangle is inside the 'GdkRegion'.

          '_o_u_t' if the rectangle is outside the 'GdkRegion'.

          '_p_a_r_t' if the rectangle is partly inside the 'GdkRegion'.


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


     '_G_d_k_S_p_a_n_F_u_n_c(_s_p_a_n, _d_a_t_a)' This defines the type of the function
          passed to  'gdkRegionSpansIntersectForeach'. 

          '_s_p_a_n' ['GdkSpan'] a 'GdkSpan'.

          '_d_a_t_a' [R object] the user data passed to
               'gdkRegionSpansIntersectForeach'.


_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-Points-Rectangles-and-Regions.html>

