Pileus Git - ~andy/gtk/blob - docs/reference/gtk/tmpl/gtkrc.sgml

   1 <!-- ##### SECTION Title ##### -->
   2 Resource Files
   3
   4 <!-- ##### SECTION Short_Description ##### -->
   5 Routines for handling resource files
   6
   7 <!-- ##### SECTION Long_Description ##### -->
   8 <para>
   9 GTK+ provides resource file mechanism for configuring
  10 various aspects of the operation of a GTK+ program
  11 at runtime.
  12 </para>
  13
  14 <refsect2><title>Default files</title>
  15 <para>
  16 An application can cause GTK+ to parse a specific RC
  17 file by calling gtk_rc_parse(). In addition to this,
  18 certain files will be read at the end of gtk_init().
  19 Unless modified, the files looked for will be <filename>.gtkrc</filename>
  20 in the users home directory, and
  21 <filename>$localstatedir/gtk/gtkrc</filename>
  22 (<literal>$localstatedir</literal> defaults to
  23 <filename>/usr/local/etc</filename>).
  24 </para>
  25 <para>
  26 The set of these <firstterm>default</firstterm> files
  27 can be retrieved with gtk_rc_get_default_files()
  28 and modified with gtk_rc_add_default_file() and
  29 gtk_rc_set_default_files().
  30 </para>
  31 <para>
  32 For each default file, in addition to the file itself,
  33 GTK+ will look for a locale-specific file that will
  34 be parsed in addition to the main file. For instance,
  35 if <literal>LANG</literal> is set to <literal>ja_JP.ujis</literal>,
  36 when loading the default file <filename>~/.gtkrc</filename>
  37 then GTK+ looks for <filename>~/.gtkrc.ja_JP.ujis</filename>,
  38 <filename>~/.gtkrc.ja_JP</filename>, and
  39 <filename>~/.gtkrc.ja</filename>, and parses the
  40 first one it finds.
  41 </para>
  42 </refsect2>
  43
  44 <refsect2><title>Pathnames and patterns</title>
  45 <para>
  46 A resource file defines a number of styles and key bindings and
  47 attaches them to particular widgets. The attachment is done
  48 by the <literal>widget</literal>, <literal>widget_class</literal>,
  49 and <literal>class</literal> declarations. As an example
  50 of such a statement:
  51 <programlisting>
  52 widget "mywindow.*.GtkEntry" style "my-entry-class"
  53 </programlisting>
  54 attaches the style <literal>"my-entry-class"</literal>
  55 to all widgets whose <firstterm>widget class</firstterm>
  56 matches the <firstterm>pattern</firstterm>
  57 <literal>"mywindow.*.GtkEntry"</literal>.
  58 </para>
  59 <para>
  60 The patterns here are given in the standard shell glob
  61 syntax. The <literal>"?"</literal> wildcard matches
  62 any character, while <literal>"*"</literal> matches
  63 zero or more of any character. The three types of
  64 matching are against the widget path, the
  65 <firstterm>class path</firstterm> and the class
  66 heirarchy. Both the widget and the class paths consists of a
  67 <literal>"."</literal> separated list of all the
  68 parents of the widget and the widget itself from
  69 outermost to innermost. The difference is that in
  70 the widget path, the name assigned by
  71 <function>gtk_widget_set_name()</function> is used
  72 if present, otherwise the class name of the widget, while
  73 for the widget path, the class name is always used.
  74 </para>
  75 <para>
  76 So, if you have a <classname>GtkEntry</classname> named
  77 <literal>"myentry"</literal>, inside of a of a window
  78 named <literal>"mywindow"</literal>, then the
  79 widget path is:
  80 <programlisting>
  81 "mwindow.GtkHBox.myentry"
  82 </programlisting>
  83 while the class path is:
  84 <programlisting>
  85 "GtkWindow.GtkHBox.GtkEntry"
  86 </programlisting>
  87 </para>
  88 <para>
  89 Matching against class is a little different. The pattern
  90 match is done against all class names in the widgets
  91 class heirarchy (not the layout heirarchy) in sequence, so the
  92 pattern:
  93 <programlisting>
  94 class "GtkButton" style "my-style"
  95 </programlisting>
  96 will match not just <classname>GtkButton</classname> widgets,
  97 but also <classname>GtkToggleButton</classname> and
  98 <classname>GtkCheckButton</classname> widgets, since
  99 those classes derive from <classname>GtkButton</classname>.
 100 </para>
 101 </refsect2>
 102
 103 <refsect2><title>Toplevel declarations</title>
 104 <para>
 105 An RC file is a text file which is composed of a sequence
 106 of declarations. '#' characters delimit comments and
 107 the portion of a line after a '#' is ignored when parsing
 108 an RC file.
 109 </para>
 110
 111 <para>
 112 The possible toplevel declarations are:
 113
 114 <variablelist>
 115   <varlistentry>
 116     <term><literal>binding <replaceable>name</replaceable>
 117      { ... }</literal></term>
 118     <listitem>
 119       <para>Declare a binding set</para>
 120     </listitem>
 121   </varlistentry>
 122   <varlistentry>
 123     <term><literal>class <replaceable>pattern</replaceable>
 124           [ style | binding [ : <replaceable>priority</replaceable> ]]
 125           <replaceable>name</replaceable></literal></term>
 126     <listitem>
 127      <para>Specify a style or binding set for a particular
 128      branch of the inheritance heirarchy.</para>
 129     </listitem>
 130   </varlistentry>
 131   <varlistentry>
 132     <term><literal>include <replaceable>filename</replaceable></literal></term>
 133     <listitem>
 134       <para>Parse another file at this point</para>
 135     </listitem>
 136   </varlistentry>
 137   <varlistentry>
 138     <term><literal>module_path <replaceable>path></replaceable></literal></term>
 139     <listitem>
 140       <para>Sets a path (a list of directories separated
 141       by colons) that will be searched for theme engines referenced in
 142       RC files.</para>
 143     </listitem>
 144   </varlistentry>
 145   <varlistentry>
 146     <term><literal>pixmap_path <replaceable>path></replaceable></literal></term>
 147     <listitem>
 148       <para>Sets a path (a list of directories separated
 149       by colons) that will be searched for pixmaps referenced in
 150       RC files.</para>
 151     </listitem>
 152   </varlistentry>
 153   <varlistentry>
 154     <term><literal>style <replaceable>name</replaceable> [ =
 155     <replaceable>parent</replaceable> ] { ... }</literal></term>
 156     <listitem>
 157       <para>Declare a style</para>
 158     </listitem>
 159   </varlistentry>
 160   <varlistentry>
 161     <term><literal>widget <replaceable>pattern</replaceable>
 162           [ style | binding [ : <replaceable>priority</replaceable> ]]
 163           <replaceable>name</replaceable></literal></term>
 164     <listitem>
 165      <para>Specify a style or binding set for a particular
 166      group of widgets by matching on the widget pathname.</para>
 167     </listitem>
 168   </varlistentry>
 169   <varlistentry>
 170     <term><literal>widget_class <replaceable>pattern</replaceable>
 171           [ style | binding [ : <replaceable>priority</replaceable> ]]
 172           <replaceable>name</replaceable></literal></term>
 173     <listitem>
 174      <para>Specify a style or binding set for a particular
 175      group of widgets by matching on the class pathname.</para>
 176     </listitem>
 177   </varlistentry>
 178 </variablelist>
 179 </para>
 180 </refsect2>
 181
 182 <refsect2><title>Styles</title>
 183 <para>
 184 A RC style is specified by a <literal>style</literal>
 185 declaration in a RC file, and then bound to widgets
 186 with a <literal>widget</literal>, <literal>widget_class</literal>,
 187 or <literal>class</literal> declaration. All styles
 188 applying to a particular widget are composited together
 189 with <literal>widget</literal> declarations overriding
 190 <literal>widget_class</literal> declarations which, in
 191 turn, override <literal>widget</literal> declarations.
 192 Within each type of declaration, later declarations override
 193 earlier ones.
 194 </para>
 195
 196 <para>
 197 Within a <literal>style</literal> declaration, the possible
 198 elements are:
 199
 200 <variablelist>
 201   <varlistentry>
 202     <term><literal>bg[<replaceable>state</replaceable>] =
 203       <replaceable>color</replaceable></literal></term>
 204      <listitem>
 205        <para>
 206          Set color used for the background of most widgets.
 207        </para>
 208      </listitem>
 209   </varlistentry>
 210   <varlistentry>
 211     <term><literal>fg[<replaceable>state</replaceable>] =
 212       <replaceable>color</replaceable></literal></term>
 213      <listitem>
 214        <para>
 215          Set color used for the foreground of most widgets.
 216        </para>
 217      </listitem>
 218   </varlistentry>
 219   <varlistentry>
 220     <term><literal>base[<replaceable>state</replaceable>] =
 221       <replaceable>color</replaceable></literal></term>
 222      <listitem>
 223        <para>
 224          Set color used for the background of widgets displaying
 225          editable text. This color is used for the background
 226          of, among others, #GtkText, #GtkEntry, #GtkList, and #GtkClist.
 227        </para>
 228      </listitem>
 229   </varlistentry>
 230   <varlistentry>
 231     <term><literal>text[<replaceable>state</replaceable>] =
 232       <replaceable>color</replaceable></literal></term>
 233      <listitem>
 234        <para>
 235          Set color used for foreground of widgets using
 236          <literal>base</literal> for the background color.
 237        </para>
 238      </listitem>
 239   </varlistentry>
 240   <varlistentry>
 241     <term><literal>bg_text[<replaceable>state</replaceable>] =
 242       <replaceable>color</replaceable></literal></term>
 243      <listitem>
 244        <para>
 245          Set a background pixmap to be used in place of
 246          the <literal>bg</literal> color (or for #GtkText,
 247          in place of the <literal>base</literal> color.
 248        </para>
 249      </listitem>
 250   </varlistentry>
 251   <varlistentry>
 252     <term><literal>font = <replaceable>font</replaceable></literal></term>
 253      <listitem>
 254        <para>
 255          Set the font for a widget.
 256        </para>
 257      </listitem>
 258   </varlistentry>
 259   <varlistentry>
 260     <term><literal>fontset = <replaceable>font</replaceable></literal></term>
 261      <listitem>
 262        <para>
 263          Set the fontset for a widget. Overrides any
 264          <literal>font</literal> declarations.
 265        </para>
 266      </listitem>
 267   </varlistentry>
 268   <varlistentry>
 269     <term><literal>stock[<replaceable>"stock-id"</replaceable>] = { <replaceable>icon source specifications</replaceable> }</literal></term>
 270      <listitem>
 271        <para>
 272         Defines the icon for a stock item.
 273        </para>
 274      </listitem>
 275   </varlistentry>
 276 </variablelist>
 277 </para>
 278 <para>
 279 The colors and background pixmaps are specified as a function of the
 280 state of the widget. The states are:
 281
 282 <variablelist>
 283   <varlistentry>
 284     <term><literal>NORMAL</literal></term>
 285     <listitem>
 286       <para>
 287         A color used for a widget in its normal state
 288       </para>
 289     </listitem>
 290   </varlistentry>
 291   <varlistentry>
 292     <term><literal>ACTIVE</literal></term>
 293     <listitem>
 294       <para>
 295         A variant of the <literal>NORMAL</literal> color used when the
 296         widget is in the %GTK_STATE_ACTIVE state, and also for
 297         the trough of a ScrollBar, tabs of a NoteBook
 298         other than the current tab and similar areas.
 299         Frequently, this should be a darker variant
 300         of the <literal>NORMAL</literal> color.
 301       </para>
 302     </listitem>
 303   </varlistentry>
 304   <varlistentry>
 305     <term><literal>PRELIGHT</literal></term>
 306     <listitem>
 307       <para>
 308         A color used for widgets in the %GTK_STATE_PRELIGHT state. This
 309         state is the used for Buttons and MenuItems
 310         that have the mouse cursor over them, and for
 311         their children.
 312       </para>
 313     </listitem>
 314   </varlistentry>
 315   <varlistentry>
 316     <term><literal>SELECTED</literal></term>
 317     <listitem>
 318       <para>
 319         A color used to highlight data selected by the user.
 320         for instance, the selected ListItems in a List widget, and the
 321         selection in an Editable widget.
 322       </para>
 323     </listitem>
 324   </varlistentry>
 325   <varlistentry>
 326     <term><literal>INSENSITIVE</literal></term>
 327     <listitem>
 328       <para>
 329         A color used for the background of widgets that have
 330         been set insensitive with gtk_widget_set_sensitive()
 331       </para>
 332     </listitem>
 333   </varlistentry>
 334 </variablelist>
 335 </para>
 336
 337 <para>
 338 Colors can be specified as a string <literal>"&hash;rrrrggggbbbb"</literal>,
 339 <literal>"&hash;rrrgggbbb"</literal>, <literal>"&hash;rrggbb"</literal>,
 340 or <literal>"&hash;rgb"</literal>, where <literal>r</literal>
 341 <literal>g</literal>, and <literal>b</literal> are
 342 hex digits, or they can be specified as a triplet of floats
 343 <literal>{ <replaceable>r</replaceable>, <replaceable>g</replaceable>,
 344 <replaceable>b</replaceable>}</literal>.
 345 </para>
 346
 347 <para>
 348 In a <literal>stock</literal> definition, icon sources are specified as a
 349 4-tuple of image filename, text direction, widget state, and size, in that
 350 order.  Each icon source specifies an image filename to use with a given
 351 direction, state, and size. The <literal>*</literal> character can be used as a
 352 wildcard, and if direction/state/size are omitted they default to
 353 <literal>*</literal>. So for example, the following specifies different icons to
 354 use for left-to-right and right-to-left languages:
 355 <programlisting>
 356 stock["my-stock-item"] =
 357 {
 358   { "itemltr.png", LTR, *, * },
 359   { "itemrtl.png", RTL, *, * }
 360 }
 361 </programlisting>
 362 This could be abbreviated as follows:
 363 <programlisting>
 364 stock["my-stock-item"] =
 365 {
 366   { "itemltr.png", LTR },
 367   { "itemrtl.png", RTL }
 368 }
 369 </programlisting>
 370 </para>
 371
 372 <para>
 373 You can specify custom icons for specific sizes, as follows:
 374 <programlisting>
 375 stock["my-stock-item"] =
 376 {
 377   { "itemmenusize.png", *, *, "gtk-menu" },
 378   { "itemtoolbarsize.png", *, *, "gtk-large-toolbar" }
 379   { "itemgeneric.png" } /* implicit *, *, * as a fallback */
 380 }
 381 </programlisting>
 382 The sizes that come with GTK+ itself are <literal>"gtk-menu"</literal>,
 383 <literal>"gtk-small-toolbar"</literal>, <literal>"gtk-large-toolbar"</literal>,
 384 <literal>"gtk-button"</literal>, <literal>"gtk-dialog"</literal>. Applications
 385 can define other sizes.
 386 </para>
 387
 388 <para>
 389 It's also possible to use custom icons for a given state, for example:
 390 You can specify custom icons for specific sizes, as follows:
 391 <programlisting>
 392 stock["my-stock-item"] =
 393 {
 394   { "itemprelight.png", *, PRELIGHT },
 395   { "iteminsensitive.png", *, INSENSITIVE },
 396   { "itemgeneric.png" } /* implicit *, *, * as a fallback */
 397 }
 398 </programlisting>
 399 </para>
 400
 401 <para>
 402 When selecting an icon source to use, GTK+ will consider text direction most
 403 important, state second, and size third. It will select the best match based on
 404 those criteria. If an attribute matches exactly (e.g. you specified
 405 <literal>PRELIGHT</literal> or specified the size), GTK+ won't modify the image;
 406 if the attribute matches with a wildcard, GTK+ will scale or modify the image to
 407 match the state and size the user requested.
 408 </para>
 409
 410 </refsect2>
 411
 412 <refsect2><title>Key bindings</title>
 413 <para>
 414 Key bindings allow the user to specify actions to be
 415 taken on particular key presses. The form of a binding
 416 set declaration is:
 417 </para>
 418
 419 <programlisting>
 420 binding <replaceable>name</replaceable> {
 421   bind <replaceable>key</replaceable> {
 422     <replaceable>signalname</replaceable> (<replaceable>param</replaceable>, ...)
 423     ...
 424   }
 425   ...
 426 }
 427 </programlisting>
 428
 429 <para>
 430 <replaceable>key</replaceable> is a string consisting of a
 431 series of modifiers followed by the name of a key. The
 432 modifiers can be:
 433 <simplelist>
 434 <member><literal>&lt;alt&gt;</literal></member>
 435 <member><literal>&lt;control&gt;</literal></member>
 436 <member><literal>&lt;mod1&gt;</literal></member>
 437 <member><literal>&lt;mod2&gt;</literal></member>
 438 <member><literal>&lt;mod3&gt;</literal></member>
 439 <member><literal>&lt;mod4&gt;</literal></member>
 440 <member><literal>&lt;mod5&gt;</literal></member>
 441 <member><literal>&lt;release&gt;</literal></member>
 442 <member><literal>&lt;shft&gt;</literal></member>
 443 <member><literal>&lt;shift&gt;</literal></member>
 444 </simplelist>
 445 <literal>&lt;shft&gt;</literal> is an alias for
 446 <literal>&lt;shift&gt;</literal> and
 447 <literal>&lt;alt&gt;</literal> is an alias for
 448 <literal>&lt;mod1&gt;</literal>.
 449 </para>
 450
 451 <para>
 452 The action that is bound to the key is a sequence
 453 of signal names (strings) followed by parameters for
 454 each signal. The signals must be action signals.
 455 (See gtk_signal_new()). Each parameter can be
 456 a float, integer, string, or unquoted string
 457 representing an enumeration value. The types of
 458 the parameters specified must match the types of the
 459 parameters of the signal.
 460 </para>
 461
 462 <para>
 463 Binding sets are connected to widgets in the
 464 same manner as styles, with one addition.
 465 A priority can be specified for each pattern,
 466 and within each type of pattern, binding sets
 467 override other binding sets first by priority,
 468 and only then by order of specification. (Later
 469 overrides earlier). The priorities that can
 470 be specified are (highest to lowest):
 471 <simplelist>
 472 <member><literal>HIGHEST</literal></member>
 473 <member><literal>RC</literal></member>
 474 <member><literal>APPLICATION</literal></member>
 475 <member><literal>GTK</literal></member>
 476 <member><literal>LOWEST</literal></member>
 477 </simplelist>
 478 <literal>RC</literal> is the default for bindings
 479 read from an RC file, <literal>APPLICATION</literal>
 480 should be used for bindings an application sets
 481 up, and <literal>GTK</literal> is used for bindings
 482 that GTK+ creates internally.
 483 </para>
 484 </refsect2>
 485
 486 <!-- ##### SECTION See_Also ##### -->
 487 <para>
 488
 489 </para>
 490
 491 <!-- ##### STRUCT GtkRcStyle ##### -->
 492 <para>
 493 The #GtkRcStyle structure is used to represent a set
 494 of information about the appearance of a widget.
 495 This can later be composited together with other
 496 #GtkRcStyle structures to form a #GtkStyle.
 497 </para>
 498
 499 @parent_instance:
 500 @name:
 501 @bg_pixmap_name:
 502 @font_desc:
 503 @color_flags:
 504 @fg:
 505 @bg:
 506 @text:
 507 @base:
 508 @xthickness:
 509 @ythickness:
 510
 511 <!-- ##### STRUCT GtkRcStyleClass ##### -->
 512 <para>
 513
 514 </para>
 515
 516
 517 <!-- ##### ENUM GtkRcFlags ##### -->
 518 <para>
 519 The #GtkRcFlags enumeration is used as a bitmask
 520 to specify which fields of a #GtkRcStyle have been
 521 set for each state.
 522 </para>
 523 <variablelist>
 524  <varlistentry><term> %GTK_RC_FG </term>
 525  <listitem>
 526    <para>
 527    If present, the foreground color has been set for this state.
 528    </para>
 529  </listitem>
 530  </varlistentry>
 531  <varlistentry><term> %GTK_RC_BG </term>
 532  <listitem>
 533    <para>
 534    If present, the background color has been set for this state.
 535    </para>
 536  </listitem>
 537  </varlistentry>
 538  <varlistentry><term> %GTK_RC_TEXT </term>
 539  <listitem>
 540    <para>
 541    If present, the text color has been set for this state.
 542    </para>
 543  </listitem>
 544  </varlistentry>
 545  <varlistentry><term> %GTK_RC_BASE </term>
 546  <listitem>
 547    <para>
 548    If present, the base color has been set for this state.
 549    </para>
 550  </listitem>
 551  </varlistentry>
 552 </variablelist>
 553
 554 @GTK_RC_FG:
 555 @GTK_RC_BG:
 556 @GTK_RC_TEXT:
 557 @GTK_RC_BASE:
 558
 559 <!-- ##### USER_FUNCTION GtkImageLoader ##### -->
 560 <para>
 561 A GtkImageLoader is used to load a filename found in
 562 a RC file.
 563 </para>
 564
 565 @window: the window for creating image
 566 @colormap: the colormap for this image
 567 @mask: a pointer to the location to store the mask
 568 @transparent_color: the transparent color for the image
 569 @filename: filename to load
 570 @Returns: a #GtkPixmap representing @filename
 571
 572
 573 <!-- ##### ENUM GtkRcTokenType ##### -->
 574 <para>
 575 The #GtkRcTokenType enumeration represents the tokens
 576 in the RC file. It is exposed so that theme engines
 577 can reuse these tokens when parsing the theme-engine
 578 specific portions of a RC file.
 579 </para>
 580
 581 @GTK_RC_TOKEN_INVALID:
 582 @GTK_RC_TOKEN_INCLUDE:
 583 @GTK_RC_TOKEN_NORMAL:
 584 @GTK_RC_TOKEN_ACTIVE:
 585 @GTK_RC_TOKEN_PRELIGHT:
 586 @GTK_RC_TOKEN_SELECTED:
 587 @GTK_RC_TOKEN_INSENSITIVE:
 588 @GTK_RC_TOKEN_FG:
 589 @GTK_RC_TOKEN_BG:
 590 @GTK_RC_TOKEN_TEXT:
 591 @GTK_RC_TOKEN_BASE:
 592 @GTK_RC_TOKEN_XTHICKNESS:
 593 @GTK_RC_TOKEN_YTHICKNESS:
 594 @GTK_RC_TOKEN_FONT:
 595 @GTK_RC_TOKEN_FONTSET:
 596 @GTK_RC_TOKEN_FONT_NAME:
 597 @GTK_RC_TOKEN_BG_PIXMAP:
 598 @GTK_RC_TOKEN_PIXMAP_PATH:
 599 @GTK_RC_TOKEN_STYLE:
 600 @GTK_RC_TOKEN_BINDING:
 601 @GTK_RC_TOKEN_BIND:
 602 @GTK_RC_TOKEN_WIDGET:
 603 @GTK_RC_TOKEN_WIDGET_CLASS:
 604 @GTK_RC_TOKEN_CLASS:
 605 @GTK_RC_TOKEN_LOWEST:
 606 @GTK_RC_TOKEN_GTK:
 607 @GTK_RC_TOKEN_APPLICATION:
 608 @GTK_RC_TOKEN_RC:
 609 @GTK_RC_TOKEN_HIGHEST:
 610 @GTK_RC_TOKEN_ENGINE:
 611 @GTK_RC_TOKEN_MODULE_PATH:
 612 @GTK_RC_TOKEN_IM_MODULE_PATH:
 613 @GTK_RC_TOKEN_IM_MODULE_FILE:
 614 @GTK_RC_TOKEN_STOCK:
 615 @GTK_RC_TOKEN_LTR:
 616 @GTK_RC_TOKEN_RTL:
 617 @GTK_RC_TOKEN_LAST:
 618
 619 <!-- ##### FUNCTION gtk_rc_scanner_new ##### -->
 620 <para>
 621
 622 </para>
 623
 624 @Returns:
 625
 626
 627 <!-- ##### FUNCTION gtk_rc_get_style ##### -->
 628 <para>
 629 Finds all matching RC styles for a given widget,
 630 composites them together, and then creates a
 631 #GtkStyle representing the composite appearance.
 632 (GTK+ actually keeps a cache of previously
 633 created styles, so a new style may not be
 634 created.)
 635 </para>
 636
 637 @widget: a #GtkWidget
 638 @Returns: the resulting style. The caller should
 639 reference the result, since GTK+ will retain the
 640 initial reference count itself for the cache
 641 of created styles.
 642
 643
 644 <!-- ##### FUNCTION gtk_rc_add_widget_name_style ##### -->
 645 <para>
 646 Add a RcStyle that will be looked up by a match against
 647 the widget's pathname. This is equivalent to a:
 648 <programlisting>
 649 widget PATTERN style STYLE
 650 </programlisting>
 651 statement in a RC file.
 652 </para>
 653
 654 @rc_style: the #GtkRcStyle to use for widgets matching @pattern
 655 @pattern: the pattern
 656
 657
 658 <!-- ##### FUNCTION gtk_rc_add_widget_class_style ##### -->
 659 <para>
 660 Add a RcStyle that will be looked up by a match against
 661 the widget's class pathname. This is equivalent to a:
 662
 663 <programlisting>
 664 widget_class PATTERN style STYLE
 665 </programlisting>
 666 statement in a RC file.
 667 </para>
 668
 669 @rc_style: the #GtkRcStyle to use for widgets matching @pattern
 670 @pattern: the pattern
 671
 672
 673 <!-- ##### FUNCTION gtk_rc_add_class_style ##### -->
 674 <para>
 675 Add a RcStyle that will be looked up by a matching against
 676 the class heirarchy of the widget. This is equivalent to a:
 677 <programlisting>
 678 class PATTERN style STYLE
 679 </programlisting>
 680 statement in a RC file.
 681 </para>
 682
 683 @rc_style: the #GtkRcStyle to use for widgets deriving from @pattern
 684 @pattern: the pattern
 685
 686
 687 <!-- ##### FUNCTION gtk_rc_parse ##### -->
 688 <para>
 689 Parse a given resource file.
 690 </para>
 691
 692 @filename: the filename of a file to parse.
 693
 694
 695 <!-- ##### FUNCTION gtk_rc_parse_string ##### -->
 696 <para>
 697 Parse resource information directly from a string.
 698 </para>
 699
 700 @rc_string: a string to parse.
 701
 702
 703 <!-- ##### FUNCTION gtk_rc_reparse_all ##### -->
 704 <para>
 705 If the modification time on any previously read file
 706 has changed, discard all style information
 707 and then reread all previously read RC files.
 708 </para>
 709
 710 @Returns: %TRUE if the files were reread.
 711
 712
 713 <!-- ##### FUNCTION gtk_rc_add_default_file ##### -->
 714 <para>
 715 Adds a file to the list of files to be parsed at the
 716 end of gtk_init().
 717 </para>
 718
 719 @filename: the pathname to the file.
 720
 721
 722 <!-- ##### FUNCTION gtk_rc_get_default_files ##### -->
 723 <para>
 724 Retrieves the current list of RC files that will be parsed
 725 at the end of gtk_init()
 726 </para>
 727
 728 @Returns: A NULL terminated array of filenames. This memory
 729 is owned by GTK+ and must not be freed by the application.
 730 If you want to store this information, you should make a
 731 copy.
 732
 733
 734 <!-- ##### FUNCTION gtk_rc_set_default_files ##### -->
 735 <para>
 736 Sets the list of files that GTK+ will read at the
 737 end of gtk_init()
 738 </para>
 739
 740 @filenames: A %NULL terminated list of filenames.
 741
 742
 743 <!-- ##### FUNCTION gtk_rc_parse_color ##### -->
 744 <para>
 745 Parses a color in the format expected in a RC file.
 746 </para>
 747
 748 @scanner: a #GtkScanner
 749 @color: a pointer to a #GtkColor structure in which to store the result
 750 @Returns: %G_TOKEN_NONE if parsing suceeded, otherwise the token
 751 that was expected but not found.
 752
 753
 754 <!-- ##### FUNCTION gtk_rc_parse_state ##### -->
 755 <para>
 756 Parses a #GtkStateType variable from the format expected
 757 in a RC file.
 758 </para>
 759
 760 @scanner: a #GtkScanner (must be initialized for parsing an RC file)
 761 @state: A pointer to a #GtkStateType variable in which to
 762 store the result.
 763 @Returns: %G_TOKEN_NONE if parsing suceeded, otherwise the token
 764 that was expected but not found.
 765
 766
 767 <!-- ##### FUNCTION gtk_rc_parse_priority ##### -->
 768 <para>
 769 Parses a #GtkPathPriorityType variable from the format expected
 770 in a RC file.
 771 </para>
 772
 773 @scanner: a #GtkScanner (must be initialized for parsing an RC file)
 774 @priority: A pointer to #GtkPathPriorityType variable in which
 775 to store the result.
 776 @Returns: %G_TOKEN_NONE if parsing suceeded, otherwise the token
 777 that was expected but not found.
 778
 779
 780 <!-- ##### FUNCTION gtk_rc_find_module_in_path ##### -->
 781 <para>
 782 Looks up a file in the current module path.
 783 </para>
 784
 785 @module_file: The name of the module to search for.
 786 @Returns: The filename, if found. (Must be freed with g_free()),
 787 otherwise %NULL.
 788
 789
 790 <!-- ##### FUNCTION gtk_rc_find_pixmap_in_path ##### -->
 791 <para>
 792 Looks up a file in the current pixmap path. If the file is
 793 not found, it outputs a warning message using g_warning()
 794 and returns %NULL.
 795 </para>
 796
 797 @scanner: a #GtkScanner. Used for printing out warning messages
 798 if the file is not found.
 799 @pixmap_file: The name of the file to search for.
 800 @Returns: The filename, if found. (Must be freed with g_free()),
 801 otherwise %NULL.
 802
 803
 804 <!-- ##### FUNCTION gtk_rc_get_module_dir ##### -->
 805 <para>
 806 Returns the directory in which GTK+ will look for
 807 theme engines.
 808 </para>
 809
 810 @Returns: The directory. (Must be freed with g_free())
 811
 812
 813 <!-- ##### FUNCTION gtk_rc_get_im_module_path ##### -->
 814 <para>
 815
 816 </para>
 817
 818 @Returns:
 819
 820
 821 <!-- ##### FUNCTION gtk_rc_get_im_module_file ##### -->
 822 <para>
 823
 824 </para>
 825
 826 @Returns:
 827
 828
 829 <!-- ##### FUNCTION gtk_rc_get_theme_dir ##### -->
 830 <para>
 831 Returns the standard directory in which themes should
 832 be installed. (GTK+ does not actually use this directory
 833 itself.)
 834 </para>
 835
 836 @Returns: The directory. (Must be freed with g_free())
 837
 838
 839 <!-- ##### FUNCTION gtk_rc_set_image_loader ##### -->
 840 <para>
 841 Sets the function that GTK+ will use to load images
 842 </para>
 843
 844 @loader: the #GtkImageLoader to use
 845
 846
 847 <!-- ##### FUNCTION gtk_rc_load_image ##### -->
 848 <para>
 849 Internal function. Loads an image using the current
 850 image loader.
 851 </para>
 852
 853 @colormap: the colormap to use for the image
 854 @transparent_color: the transparent color for the image
 855 @filename: the filename of the image file
 856 @Returns: a #GtkPixmap representing @filename
 857
 858
 859 <!-- ##### FUNCTION gtk_rc_style_new ##### -->
 860 <para>
 861 Create a new #GtkRcStyle with no fields set and
 862 a reference count of 1.
 863 </para>
 864
 865 @Returns: the newly create #GtkRcStyle
 866
 867
 868 <!-- ##### FUNCTION gtk_rc_style_copy ##### -->
 869 <para>
 870
 871 </para>
 872
 873 @orig:
 874 @Returns:
 875
 876
 877 <!-- ##### FUNCTION gtk_rc_style_ref ##### -->
 878 <para>
 879 Increment the reference count of a #GtkRcStyle.
 880 </para>
 881
 882 @rc_style: a #GtkRcStyle
 883
 884
 885 <!-- ##### FUNCTION gtk_rc_style_unref ##### -->
 886 <para>
 887 Decrement the reference count of a #GtkRcStyle and
 888 free if the result is 0.
 889 </para>
 890
 891 @rc_style: a #GtkRcStyle
 892
 893