Pileus Git - ~andy/gtk/blob - docs/reference/gtk/glossary.xml

   1 <?xml version="1.0"?>
   2 <!DOCTYPE glossary PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
   3                "http://www.oasis-open.org/docbook/xml/4.3/docbookx.dtd" [
   4 ]>
   5 <glossary id="glossary">
   6   <title>Glossary</title>
   7
   8   <glossentry id="allocation">
   9     <glossterm>allocation</glossterm>
  10     <glossdef>
  11       <para>
  12         The final size of a <glossterm
  13         linkend="widget">widget</glossterm> within its <glossterm
  14         linkend="parent">parent</glossterm>.  For example, a widget
  15         may request a minimum size of 20&times;20 pixels, but its
  16         parent may decide to allocate 50&times;20 pixels for it
  17         instead.
  18       </para>
  19       <glossseealso>
  20         <glossterm linkend="requisition">requisition</glossterm>
  21       </glossseealso>
  22     </glossdef>
  23   </glossentry>
  24
  25   <glossentry id="bin">
  26     <glossterm>bin</glossterm>
  27     <glossdef>
  28       <para>
  29         A <glossterm linkend="container">container</glossterm> that
  30         can hold at most one child widget.  The base class for bins is
  31         #GtkBin.
  32       </para>
  33       <glossseealso>
  34         <glossterm linkend="container">container</glossterm>
  35       </glossseealso>
  36     </glossdef>
  37   </glossentry>
  38
  39   <glossentry id="child">
  40     <glossterm>child</glossterm>
  41     <glossdef>
  42       <para>
  43         A <glossterm linkend="container">container's</glossterm> child
  44         is a <glossterm linkend="widget">widget</glossterm> contained
  45         inside it.
  46       </para>
  47     </glossdef>
  48   </glossentry>
  49
  50   <glossentry id="column">
  51     <glossterm>column</glossterm>
  52     <glossdef>
  53       <para>
  54         GTK+ contains several widgets which display data in columns,
  55         e.g. the #GtkTreeView.
  56         These <glossterm linkend="view-column">view columns</glossterm> in
  57         the tree view are represented by #GtkTreeViewColumn
  58         objects inside GTK+. They should not be confused with
  59         <glossterm linkend="model-column">model columns</glossterm> which
  60         are used to organize the data in tree models.
  61       </para>
  62       <glossseealso>model-view widget</glossseealso>
  63     </glossdef>
  64   </glossentry>
  65
  66   <glossentry id="container">
  67     <glossterm>container</glossterm>
  68     <glossdef>
  69       <para>
  70         A <glossterm linkend="widget">widget</glossterm> that contains
  71         other widgets; in that case, the container is the
  72         <emphasis>parent</emphasis> of the <emphasis>child</emphasis>
  73         widgets.  Some containers don't draw anything on their own,
  74         but rather just organize their children's <glossterm
  75         linkend="geometry">geometry</glossterm>; for example, #GtkVBox lays out
  76         its children vertically without painting anything on its own.  Other
  77         containers include decorative elements; for example, #GtkFrame contains
  78         the frame's child and a label in addition to the shaded frame it draws.
  79         The base class for containers is #GtkContainer.
  80       </para>
  81       <glossseealso>
  82         <glossterm linkend="container">widget</glossterm>
  83         <glossterm linkend="container">geometry</glossterm>
  84       </glossseealso>
  85     </glossdef>
  86   </glossentry>
  87
  88   <glossentry id="display">
  89     <glossterm>display</glossterm>
  90     <glossdef>
  91       <para>
  92         GDK inherited the concept of display from the X window system,
  93         which considers a display to be the combination
  94         of a keyboard, a pointing device and one or more
  95         <glossterm linkend="screen">screens</glossterm>.
  96         Applications open a display to show windows and interact with the user.
  97         In GDK, a display is represented by a #GdkDisplay.
  98       </para>
  99     </glossdef>
 100   </glossentry>
 101
 102   <glossentry id="ellipsization">
 103     <glossdef>
 104       <para>
 105         Ellipsization is the process of replacing some part
 106         of a text by an ellipsis (usually "...") to make the
 107         text fit in a smaller space. Pango can ellipsize text
 108         at the beginning, at the end or in the middle.
 109       </para>
 110     </glossdef>
 111   </glossentry>
 112
 113   <glossentry id="event">
 114     <glossterm>event</glossterm>
 115     <glossdef>
 116       <para>
 117         Events are the way in which GDK informs GTK+ about external events
 118         like pointer motion, button clicks, key presses, etc.
 119       </para>
 120     </glossdef>
 121   </glossentry>
 122
 123   <glossentry id="geometry">
 124     <glossterm>geometry</glossterm>
 125     <glossdef>
 126       <para>
 127         A <glossterm linkend="widget">widget's</glossterm> position
 128         and size.  Within its parent, this is called the widget's
 129         <glossterm linkend="allocation">allocation</glossterm>.
 130       </para>
 131     </glossdef>
 132   </glossentry>
 133
 134   <glossentry id="mapping">
 135     <glossterm>mapping</glossterm>
 136     <glossdef>
 137       <para>
 138         This is the step in a <glossterm
 139         linkend="widget">widget's</glossterm> life cycle where it
 140         actually shows the GdkWindows it created when it was
 141         <glossterm linkend="realization">realized</glossterm>.  When a
 142         widget is mapped, it must turn on its
 143         %GTK_MAPPED <link linkend="GtkWidgetFlags">flag</link>.
 144       </para>
 145
 146       <para>
 147         Note that due to the asynchronous nature of the X window
 148         system, a widget's window may not appear on the screen
 149         immediatly after one calls gdk_window_show():
 150         you must wait for the corresponding map <glossterm
 151         linkend="event">event</glossterm> to be received.  You can do
 152         this with the <link
 153         linkend="GtkWidget-map-event"><methodname>GtkWidget::map-event</methodname>
 154         signal</link>.
 155       </para>
 156     </glossdef>
 157   </glossentry>
 158
 159   <glossentry id="model-column">
 160     <glossterm>model column</glossterm>
 161     <glossdef>
 162       <para>
 163         A column in a tree model, holding data of a certain type.
 164         The types which can be stored in the columns of a model
 165         have to be specified when the model is constructed, see
 166         e.g. gtk_list_store_new().
 167       </para>
 168       <glossseealso>
 169         <glossterm linkend="view-column">view column</glossterm>
 170       </glossseealso>
 171     </glossdef>
 172   </glossentry>
 173
 174   <glossentry id="model-view">
 175     <glossterm>model-view widget</glossterm>
 176     <glossdef>
 177       <para>
 178         These widgets follow the well-known model-view pattern, which separates
 179         the data (the model) to be displayed from the component which does the
 180         actual visualization (the view). Examples of this pattern in GTK+ are
 181         the #GtkTreeView/#GtkTreeModel and #GtkTextView/#GtkTextBuffer
 182       </para>
 183       <para>
 184         One important advantage of this pattern is that it is possible to
 185         display the same model in multiple views; another one that the
 186         separation of the model allows a great deal of flexibility, as
 187         demonstrated by e.g. #GtkTreeModelSort or #GtkTreeModelFilter.
 188       </para>
 189     </glossdef>
 190   </glossentry>
 191
 192   <glossentry id="no-window">
 193     <glossterm>no-window widget</glossterm>
 194     <glossdef>
 195       <para>
 196         A widget that does not have a GdkWindow of its own on which to
 197         draw its contents, but rather shares its <glossterm
 198         linkend="parent">parent's</glossterm>.  This can be tested with
 199         the gtk_widget_get_has_window() function.  See
 200         <xref linkend="window-no-window-widgets"/> for a detailed
 201         description of this flag.
 202       </para>
 203     </glossdef>
 204   </glossentry>
 205
 206   <glossentry id="parent">
 207     <glossterm>parent</glossterm>
 208     <glossdef>
 209       <para>
 210         A <glossterm linkend="widget">widget's</glossterm> parent is
 211         the <glossterm linkend="container">container</glossterm>
 212         inside which it resides.
 213       </para>
 214     </glossdef>
 215   </glossentry>
 216
 217   <glossentry id="realization">
 218     <glossterm>realization</glossterm>
 219     <glossdef>
 220       <para>
 221         This is the step in a <glossterm
 222         linkend="widget">widget's</glossterm> life cycle where it
 223         creates its own GdkWindow, or otherwise associates itself with
 224         its <glossterm linkend="parent">parent's</glossterm>
 225         GdkWindow.  If the widget has its own window, then it must
 226         also attach a <glossterm linkend="style">style</glossterm> to
 227         it.  A widget becomes unrealized by destroying its associated
 228         GdkWindow.  When a widget is realized, it must turn on its
 229         %GTK_REALIZED <link linkend="GtkWidgetFlags">flag</link>.
 230       </para>
 231
 232       <para>
 233         Widgets that don't own the GdkWindow on which they draw are
 234         called <glossterm linkend="no-window">no-window widgets</glossterm>.
 235         This can be tested with the GTK_WIDGET_NO_WINDOW() macro.  Normally,
 236         these widgets draw on their parent's GdkWindow.
 237       </para>
 238
 239       <para>
 240         Note that when a widget creates a window in its <link
 241         linkend="gtkwidget-realize"><methodname>::realize()</methodname></link>
 242         handler, it does not actually show the window.  That is, the
 243         window's structure is just created in memory.  The widget
 244         actually shows the window when it gets <glossterm
 245         linkend="mapping">mapped</glossterm>.
 246       </para>
 247     </glossdef>
 248   </glossentry>
 249
 250   <glossentry id="requisition">
 251     <glossterm>requisition</glossterm>
 252     <glossdef>
 253       <para>
 254         The size requisition of a <glossterm
 255         linkend="widget">widget</glossterm> is the minimum amount of
 256         space it requests from its <glossterm
 257         linkend="parent">parent</glossterm>.  Once the parent computes
 258         the widget's final size, it gives it its <glossterm
 259         linkend="allocation">size allocation</glossterm>.
 260       </para>
 261       <glossseealso>
 262         <glossterm linkend="allocation">allocation</glossterm>
 263       </glossseealso>
 264     </glossdef>
 265   </glossentry>
 266
 267   <glossentry id="screen">
 268     <glossterm>screen</glossterm>
 269     <glossdef>
 270       <para>
 271         GDK inherited the concept of screen from the X window system,
 272         which considers a screen to be a rectangular area, on which
 273         applications may place their windows. Screens under X may have
 274         quite dissimilar <glossterm linkend="visual">visuals</glossterm>.
 275         Each screen can stretch across multiple physical monitors.
 276       </para>
 277       <para>
 278         In GDK, screens are represented by #GdkScreen objects.
 279       </para>
 280     </glossdef>
 281   </glossentry>
 282
 283   <glossentry id="style">
 284     <glossterm>style</glossterm>
 285     <glossdef>
 286       <para>
 287         A style encapsulates what GTK+ needs to know in order to draw
 288         a widget. Styles can be modified with
 289         <link linkend="gtk-Resource-Files">resource files</link>.
 290       </para>
 291     </glossdef>
 292   </glossentry>
 293
 294   <glossentry id="toplevel">
 295     <glossterm>toplevel</glossterm>
 296     <glossdef>
 297       <para>
 298         A <glossterm linkend="widget">widget</glossterm> that does not
 299         require a <glossterm linkend="parent">parent</glossterm> container.
 300         The only toplevel widgets in GTK+ are #GtkWindow and widgets derived from it.
 301       </para>
 302       <glossseealso>
 303         <glossterm linkend="container">container</glossterm>
 304       </glossseealso>
 305     </glossdef>
 306   </glossentry>
 307
 308   <glossentry id="unmap">
 309     <glossterm>unmap</glossterm>
 310     <glosssee><glossterm linkend="mapping">mapping</glossterm></glosssee>
 311   </glossentry>
 312
 313   <glossentry id="unrealize">
 314     <glossterm>unrealize</glossterm>
 315     <glosssee><glossterm linkend="realization">realization</glossterm></glosssee>
 316   </glossentry>
 317
 318   <glossentry id="view-column">
 319     <glossterm>view column</glossterm>
 320     <glossdef>
 321       <para>
 322         A displayed column in a tree view, represented by a
 323         #GtkTreeViewColumn object.
 324       </para>
 325       <glossseealso>
 326         <glossterm linkend="model-column">model column</glossterm>
 327       </glossseealso>
 328     </glossdef>
 329   </glossentry>
 330
 331   <glossentry id="visual">
 332     <glossterm>visual</glossterm>
 333     <glossdef>
 334       <para>
 335         A visual describes how color information is stored in pixels.
 336         A <glossterm linkend="screen">screen</glossterm> may support
 337         multiple visuals. On modern hardware, the most common visuals
 338         are truecolor visuals, which store a fixed number of bits
 339         (typically 8) for the red, green and blue components of a color.
 340       </para>
 341       <para>
 342         On ancient hardware, one may still meet indexed visuals, which
 343         store color information as an index into a color map, or even
 344         monochrome visuals.
 345       </para>
 346     </glossdef>
 347   </glossentry>
 348
 349   <glossentry id="widget">
 350     <glossterm>widget</glossterm>
 351     <glossdef>
 352       <para>
 353         A control in a graphical user interface.  Widgets can draw
 354         themselves and process events from the mouse and keyboard.
 355         Widget types include buttons, menus, text entry lines, and
 356         lists.  Widgets can be arranged into <glossterm
 357         linkend="container">containers</glossterm>, and these take
 358         care of assigning the <glossterm
 359         linkend="geometry">geometry</glossterm> of the widgets:  every
 360         widget thus has a parent except those widgets which are
 361         <glossterm linkend="toplevel">toplevels</glossterm>.  The base
 362         class for widgets is #GtkWidget.
 363       </para>
 364       <glossseealso>
 365         <glossterm linkend="container">container</glossterm>
 366       </glossseealso>
 367     </glossdef>
 368   </glossentry>
 369 </glossary>
 370
 371 <!--
 372 Local variables:
 373 mode: sgml
 374 sgml-parent-document: ("gtk-docs.sgml" "book" "glossary")
 375 End:
 376 -->