From 91a5956707f72e6ca4f57c2af51fab378bf22949 Mon Sep 17 00:00:00 2001 From: Owen Taylor Date: Mon, 16 Aug 1999 18:51:52 +0000 Subject: Initial revision --- docs/reference/gtk/tmpl/gtk-unused.sgml | 24 + docs/reference/gtk/tmpl/gtkaccelgroup.sgml | 314 +++++ docs/reference/gtk/tmpl/gtkaccellabel.sgml | 69 + docs/reference/gtk/tmpl/gtkadjustment.sgml | 161 +++ docs/reference/gtk/tmpl/gtkalignment.sgml | 104 ++ docs/reference/gtk/tmpl/gtkarg.sgml | 147 ++ docs/reference/gtk/tmpl/gtkarrow.sgml | 92 ++ docs/reference/gtk/tmpl/gtkaspectframe.sgml | 71 + docs/reference/gtk/tmpl/gtkbbox.sgml | 159 +++ docs/reference/gtk/tmpl/gtkbin.sgml | 44 + docs/reference/gtk/tmpl/gtkbindings.sgml | 243 ++++ docs/reference/gtk/tmpl/gtkbox.sgml | 370 +++++ docs/reference/gtk/tmpl/gtkbutton.sgml | 163 +++ docs/reference/gtk/tmpl/gtkcalendar.sgml | 260 ++++ docs/reference/gtk/tmpl/gtkcheckbutton.sgml | 60 + docs/reference/gtk/tmpl/gtkcheckmenuitem.sgml | 111 ++ docs/reference/gtk/tmpl/gtkclist.sgml | 1268 +++++++++++++++++ docs/reference/gtk/tmpl/gtkcolorsel.sgml | 93 ++ docs/reference/gtk/tmpl/gtkcolorseldlg.sgml | 38 + docs/reference/gtk/tmpl/gtkcombo.sgml | 109 ++ docs/reference/gtk/tmpl/gtkcontainer.sgml | 410 ++++++ docs/reference/gtk/tmpl/gtkctree.sgml | 1266 +++++++++++++++++ docs/reference/gtk/tmpl/gtkcurve.sgml | 109 ++ docs/reference/gtk/tmpl/gtkdata.sgml | 30 + docs/reference/gtk/tmpl/gtkdebug.sgml | 42 + docs/reference/gtk/tmpl/gtkdialog.sgml | 122 ++ docs/reference/gtk/tmpl/gtkdnd.sgml | 344 +++++ docs/reference/gtk/tmpl/gtkdrawingarea.sgml | 111 ++ docs/reference/gtk/tmpl/gtkeditable.sgml | 448 ++++++ docs/reference/gtk/tmpl/gtkentry.sgml | 201 +++ docs/reference/gtk/tmpl/gtkenums.sgml | 361 +++++ docs/reference/gtk/tmpl/gtkeventbox.sgml | 34 + docs/reference/gtk/tmpl/gtkfeatures.sgml | 57 + docs/reference/gtk/tmpl/gtkfilesel.sgml | 188 +++ docs/reference/gtk/tmpl/gtkfixed.sgml | 104 ++ docs/reference/gtk/tmpl/gtkfontsel.sgml | 165 +++ docs/reference/gtk/tmpl/gtkfontseldlg.sgml | 229 +++ docs/reference/gtk/tmpl/gtkframe.sgml | 96 ++ docs/reference/gtk/tmpl/gtkgamma.sgml | 37 + docs/reference/gtk/tmpl/gtkgc.sgml | 36 + docs/reference/gtk/tmpl/gtkhandlebox.sgml | 170 +++ docs/reference/gtk/tmpl/gtkhbbox.sgml | 99 ++ docs/reference/gtk/tmpl/gtkhbox.sgml | 47 + docs/reference/gtk/tmpl/gtkhpaned.sgml | 33 + docs/reference/gtk/tmpl/gtkhruler.sgml | 38 + docs/reference/gtk/tmpl/gtkhscale.sgml | 45 + docs/reference/gtk/tmpl/gtkhscrollbar.sgml | 42 + docs/reference/gtk/tmpl/gtkhseparator.sgml | 31 + docs/reference/gtk/tmpl/gtkimage.sgml | 55 + docs/reference/gtk/tmpl/gtkinputdialog.sgml | 73 + docs/reference/gtk/tmpl/gtkinvisible.sgml | 31 + docs/reference/gtk/tmpl/gtkitem.sgml | 68 + docs/reference/gtk/tmpl/gtkitemfactory.sgml | 358 +++++ docs/reference/gtk/tmpl/gtklabel.sgml | 146 ++ docs/reference/gtk/tmpl/gtklayout.sgml | 130 ++ docs/reference/gtk/tmpl/gtklist.sgml | 283 ++++ docs/reference/gtk/tmpl/gtklistitem.sgml | 133 ++ docs/reference/gtk/tmpl/gtkmain.sgml | 414 ++++++ docs/reference/gtk/tmpl/gtkmarshal.sgml | 482 +++++++ docs/reference/gtk/tmpl/gtkmenu.sgml | 287 ++++ docs/reference/gtk/tmpl/gtkmenubar.sgml | 74 + docs/reference/gtk/tmpl/gtkmenufactory.sgml | 132 ++ docs/reference/gtk/tmpl/gtkmenuitem.sgml | 132 ++ docs/reference/gtk/tmpl/gtkmenushell.sgml | 191 +++ docs/reference/gtk/tmpl/gtkmisc.sgml | 109 ++ docs/reference/gtk/tmpl/gtknotebook.sgml | 446 ++++++ docs/reference/gtk/tmpl/gtkobject.sgml | 531 +++++++ docs/reference/gtk/tmpl/gtkoptionmenu.sgml | 76 + docs/reference/gtk/tmpl/gtkpacker.sgml | 227 +++ docs/reference/gtk/tmpl/gtkpaned.sgml | 198 +++ docs/reference/gtk/tmpl/gtkpixmap.sgml | 80 ++ docs/reference/gtk/tmpl/gtkplug.sgml | 60 + docs/reference/gtk/tmpl/gtkpreview.sgml | 265 ++++ docs/reference/gtk/tmpl/gtkprivate.sgml | 120 ++ docs/reference/gtk/tmpl/gtkprogress.sgml | 172 +++ docs/reference/gtk/tmpl/gtkprogressbar.sgml | 150 ++ docs/reference/gtk/tmpl/gtkradiobutton.sgml | 85 ++ docs/reference/gtk/tmpl/gtkradiomenuitem.sgml | 61 + docs/reference/gtk/tmpl/gtkrange.sgml | 202 +++ docs/reference/gtk/tmpl/gtkrc.sgml | 724 ++++++++++ docs/reference/gtk/tmpl/gtkruler.sgml | 81 ++ docs/reference/gtk/tmpl/gtkscale.sgml | 100 ++ docs/reference/gtk/tmpl/gtkscrollbar.sgml | 23 + docs/reference/gtk/tmpl/gtkscrolledwindow.sgml | 199 +++ docs/reference/gtk/tmpl/gtkselection.sgml | 270 ++++ docs/reference/gtk/tmpl/gtkseparator.sgml | 24 + docs/reference/gtk/tmpl/gtksignal.sgml | 473 +++++++ docs/reference/gtk/tmpl/gtksocket.sgml | 132 ++ docs/reference/gtk/tmpl/gtkspinbutton.sgml | 385 +++++ docs/reference/gtk/tmpl/gtkstatusbar.sgml | 136 ++ docs/reference/gtk/tmpl/gtkstyle.sgml | 887 ++++++++++++ docs/reference/gtk/tmpl/gtktable.sgml | 237 ++++ docs/reference/gtk/tmpl/gtktearoffmenuitem.sgml | 55 + docs/reference/gtk/tmpl/gtktext.sgml | 246 ++++ docs/reference/gtk/tmpl/gtkthemes.sgml | 73 + docs/reference/gtk/tmpl/gtktipsquery.sgml | 129 ++ docs/reference/gtk/tmpl/gtktogglebutton.sgml | 166 +++ docs/reference/gtk/tmpl/gtktoolbar.sgml | 332 +++++ docs/reference/gtk/tmpl/gtktooltips.sgml | 177 +++ docs/reference/gtk/tmpl/gtktree.sgml | 307 ++++ docs/reference/gtk/tmpl/gtktreeitem.sgml | 115 ++ docs/reference/gtk/tmpl/gtktypeutils.sgml | 869 ++++++++++++ docs/reference/gtk/tmpl/gtkvbbox.sgml | 63 + docs/reference/gtk/tmpl/gtkvbox.sgml | 47 + docs/reference/gtk/tmpl/gtkviewport.sgml | 98 ++ docs/reference/gtk/tmpl/gtkvpaned.sgml | 33 + docs/reference/gtk/tmpl/gtkvruler.sgml | 38 + docs/reference/gtk/tmpl/gtkvscale.sgml | 45 + docs/reference/gtk/tmpl/gtkvscrollbar.sgml | 42 + docs/reference/gtk/tmpl/gtkvseparator.sgml | 31 + docs/reference/gtk/tmpl/gtkwidget.sgml | 1721 +++++++++++++++++++++++ docs/reference/gtk/tmpl/gtkwindow.sgml | 247 ++++ 112 files changed, 23071 insertions(+) create mode 100644 docs/reference/gtk/tmpl/gtk-unused.sgml create mode 100644 docs/reference/gtk/tmpl/gtkaccelgroup.sgml create mode 100644 docs/reference/gtk/tmpl/gtkaccellabel.sgml create mode 100644 docs/reference/gtk/tmpl/gtkadjustment.sgml create mode 100644 docs/reference/gtk/tmpl/gtkalignment.sgml create mode 100644 docs/reference/gtk/tmpl/gtkarg.sgml create mode 100644 docs/reference/gtk/tmpl/gtkarrow.sgml create mode 100644 docs/reference/gtk/tmpl/gtkaspectframe.sgml create mode 100644 docs/reference/gtk/tmpl/gtkbbox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkbin.sgml create mode 100644 docs/reference/gtk/tmpl/gtkbindings.sgml create mode 100644 docs/reference/gtk/tmpl/gtkbox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkbutton.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcalendar.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcheckbutton.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcheckmenuitem.sgml create mode 100644 docs/reference/gtk/tmpl/gtkclist.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcolorsel.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcolorseldlg.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcombo.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcontainer.sgml create mode 100644 docs/reference/gtk/tmpl/gtkctree.sgml create mode 100644 docs/reference/gtk/tmpl/gtkcurve.sgml create mode 100644 docs/reference/gtk/tmpl/gtkdata.sgml create mode 100644 docs/reference/gtk/tmpl/gtkdebug.sgml create mode 100644 docs/reference/gtk/tmpl/gtkdialog.sgml create mode 100644 docs/reference/gtk/tmpl/gtkdnd.sgml create mode 100644 docs/reference/gtk/tmpl/gtkdrawingarea.sgml create mode 100644 docs/reference/gtk/tmpl/gtkeditable.sgml create mode 100644 docs/reference/gtk/tmpl/gtkentry.sgml create mode 100644 docs/reference/gtk/tmpl/gtkenums.sgml create mode 100644 docs/reference/gtk/tmpl/gtkeventbox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkfeatures.sgml create mode 100644 docs/reference/gtk/tmpl/gtkfilesel.sgml create mode 100644 docs/reference/gtk/tmpl/gtkfixed.sgml create mode 100644 docs/reference/gtk/tmpl/gtkfontsel.sgml create mode 100644 docs/reference/gtk/tmpl/gtkfontseldlg.sgml create mode 100644 docs/reference/gtk/tmpl/gtkframe.sgml create mode 100644 docs/reference/gtk/tmpl/gtkgamma.sgml create mode 100644 docs/reference/gtk/tmpl/gtkgc.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhandlebox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhbbox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhbox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhpaned.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhruler.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhscale.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhscrollbar.sgml create mode 100644 docs/reference/gtk/tmpl/gtkhseparator.sgml create mode 100644 docs/reference/gtk/tmpl/gtkimage.sgml create mode 100644 docs/reference/gtk/tmpl/gtkinputdialog.sgml create mode 100644 docs/reference/gtk/tmpl/gtkinvisible.sgml create mode 100644 docs/reference/gtk/tmpl/gtkitem.sgml create mode 100644 docs/reference/gtk/tmpl/gtkitemfactory.sgml create mode 100644 docs/reference/gtk/tmpl/gtklabel.sgml create mode 100644 docs/reference/gtk/tmpl/gtklayout.sgml create mode 100644 docs/reference/gtk/tmpl/gtklist.sgml create mode 100644 docs/reference/gtk/tmpl/gtklistitem.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmain.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmarshal.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmenu.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmenubar.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmenufactory.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmenuitem.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmenushell.sgml create mode 100644 docs/reference/gtk/tmpl/gtkmisc.sgml create mode 100644 docs/reference/gtk/tmpl/gtknotebook.sgml create mode 100644 docs/reference/gtk/tmpl/gtkobject.sgml create mode 100644 docs/reference/gtk/tmpl/gtkoptionmenu.sgml create mode 100644 docs/reference/gtk/tmpl/gtkpacker.sgml create mode 100644 docs/reference/gtk/tmpl/gtkpaned.sgml create mode 100644 docs/reference/gtk/tmpl/gtkpixmap.sgml create mode 100644 docs/reference/gtk/tmpl/gtkplug.sgml create mode 100644 docs/reference/gtk/tmpl/gtkpreview.sgml create mode 100644 docs/reference/gtk/tmpl/gtkprivate.sgml create mode 100644 docs/reference/gtk/tmpl/gtkprogress.sgml create mode 100644 docs/reference/gtk/tmpl/gtkprogressbar.sgml create mode 100644 docs/reference/gtk/tmpl/gtkradiobutton.sgml create mode 100644 docs/reference/gtk/tmpl/gtkradiomenuitem.sgml create mode 100644 docs/reference/gtk/tmpl/gtkrange.sgml create mode 100644 docs/reference/gtk/tmpl/gtkrc.sgml create mode 100644 docs/reference/gtk/tmpl/gtkruler.sgml create mode 100644 docs/reference/gtk/tmpl/gtkscale.sgml create mode 100644 docs/reference/gtk/tmpl/gtkscrollbar.sgml create mode 100644 docs/reference/gtk/tmpl/gtkscrolledwindow.sgml create mode 100644 docs/reference/gtk/tmpl/gtkselection.sgml create mode 100644 docs/reference/gtk/tmpl/gtkseparator.sgml create mode 100644 docs/reference/gtk/tmpl/gtksignal.sgml create mode 100644 docs/reference/gtk/tmpl/gtksocket.sgml create mode 100644 docs/reference/gtk/tmpl/gtkspinbutton.sgml create mode 100644 docs/reference/gtk/tmpl/gtkstatusbar.sgml create mode 100644 docs/reference/gtk/tmpl/gtkstyle.sgml create mode 100644 docs/reference/gtk/tmpl/gtktable.sgml create mode 100644 docs/reference/gtk/tmpl/gtktearoffmenuitem.sgml create mode 100644 docs/reference/gtk/tmpl/gtktext.sgml create mode 100644 docs/reference/gtk/tmpl/gtkthemes.sgml create mode 100644 docs/reference/gtk/tmpl/gtktipsquery.sgml create mode 100644 docs/reference/gtk/tmpl/gtktogglebutton.sgml create mode 100644 docs/reference/gtk/tmpl/gtktoolbar.sgml create mode 100644 docs/reference/gtk/tmpl/gtktooltips.sgml create mode 100644 docs/reference/gtk/tmpl/gtktree.sgml create mode 100644 docs/reference/gtk/tmpl/gtktreeitem.sgml create mode 100644 docs/reference/gtk/tmpl/gtktypeutils.sgml create mode 100644 docs/reference/gtk/tmpl/gtkvbbox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkvbox.sgml create mode 100644 docs/reference/gtk/tmpl/gtkviewport.sgml create mode 100644 docs/reference/gtk/tmpl/gtkvpaned.sgml create mode 100644 docs/reference/gtk/tmpl/gtkvruler.sgml create mode 100644 docs/reference/gtk/tmpl/gtkvscale.sgml create mode 100644 docs/reference/gtk/tmpl/gtkvscrollbar.sgml create mode 100644 docs/reference/gtk/tmpl/gtkvseparator.sgml create mode 100644 docs/reference/gtk/tmpl/gtkwidget.sgml create mode 100644 docs/reference/gtk/tmpl/gtkwindow.sgml (limited to 'docs/reference/gtk/tmpl') diff --git a/docs/reference/gtk/tmpl/gtk-unused.sgml b/docs/reference/gtk/tmpl/gtk-unused.sgml new file mode 100644 index 0000000000..3e32cdde96 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtk-unused.sgml @@ -0,0 +1,24 @@ + + +Determines the way that the the preview widget behaves +when the size it is allocated is larger than the requested +size. See gtk_preview_set_expand(). + + + + + +Determines the snap edge of a handlebox. The snap edge is +the edge of the detached child that must be aligned +with the corresponding edge of the "ghost" left +behind when the child was detached to reattach +the torn-off window. See gtk_handle_box_set_snap_edge(). + + + + + +Determines the side of the handlebox where the handle is drawn. + + + diff --git a/docs/reference/gtk/tmpl/gtkaccelgroup.sgml b/docs/reference/gtk/tmpl/gtkaccelgroup.sgml new file mode 100644 index 0000000000..ccf0ce427a --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkaccelgroup.sgml @@ -0,0 +1,314 @@ + +Keyboard Accelerators + + + + + + + + + + + + + + + + + + + +@ref_count: +@lock_count: +@modifier_mask: +@attach_objects: + + + + + + +@accel_group: +@accelerator_key: +@accelerator_mods: +@accel_flags: +@object: +@signal_id: + + + + + + +@Returns: + + + + + + + +@Returns: + + + + + + + +@accel_group: +@Returns: + + + + + + + +@accel_group: + + + + + + + +@accel_group: +@accel_key: +@accel_mods: +@Returns: + + + + + + + +@object: +@accel_key: +@accel_mods: +@Returns: + + + + + + + +@accel_group: +@object: + + + + + + + +@accel_group: +@object: + + + + + + + +@accel_group: + + + + + + + +@accel_group: + + + + + + + +@accel_group: +@accel_key: +@accel_mods: +@Returns: + + + + + + + +@accel_group: +@accel_key: +@accel_mods: + + + + + + + +@accel_group: +@accel_key: +@accel_mods: + + + + + + + +@accel_group: +@accel_key: +@accel_mods: +@accel_flags: +@object: +@accel_signal: + + + + + + + +@accel_group: +@accel_key: +@accel_mods: +@object: + + + + + + + +@object: +@accel_signal_id: +@accel_group: +@accel_key: +@accel_mods: +@accel_flags: + + + + + + + +@object: +@accel_group: +@accel_key: +@accel_mods: + + + + + + + +@class_type: +@signal_flags: +@handler_offset: +@Returns: + + + + + + + +@class_type: +@signal_flags: +@handler_offset: +@Returns: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@Returns: + + + + + + + +@object: +@Returns: + + + + + + + +@keyval: +@modifiers: +@Returns: + + + + + + + +@accelerator: +@accelerator_key: +@accelerator_mods: + + + + + + + +@accelerator_key: +@accelerator_mods: +@Returns: + + + + + + + +@default_mod_mask: + + + + + + + +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkaccellabel.sgml b/docs/reference/gtk/tmpl/gtkaccellabel.sgml new file mode 100644 index 0000000000..bd1c8c05a4 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkaccellabel.sgml @@ -0,0 +1,69 @@ + +GtkAccelLabel + + + + + + + + + + + + + + + + + + + +@label: +@queue_id: +@accel_padding: +@accel_widget: +@accel_string: +@accel_string_width: + + + + + + +@string: +@Returns: + + + + + + + +@accel_label: +@accel_widget: + + + + + + + +@accel_label: +@Returns: + + + + + + + +@accel_label: +@Returns: + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkadjustment.sgml b/docs/reference/gtk/tmpl/gtkadjustment.sgml new file mode 100644 index 0000000000..4d8540ad42 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkadjustment.sgml @@ -0,0 +1,161 @@ + +GtkAdjustment + + +a #GtkObject representing an adjustable bounded value. + + + +The #GtkAdjustment object represents a value which has an associated lower +and upper bound, together with step and page increments, and a page size. +It is used within several GTK+ widgets, including +#GtkSpinButton, #GtkViewport, and #GtkRange (which is a base class for +#GtkHScrollbar, #GtkVScrollbar, #GtkHScale, and #GtkVScale). + + +The #GtkAdjustment object does not update the value itself. Instead +it is left up to the owner of the #GtkAdjustment to control the value. + + +The owner of the #GtkAdjustment typically calls the +gtk_adjustment_value_changed() and gtk_adjustment_changed() functions +after changing the value and its bounds. This results in the emission of the +"value_changed" or "changed" signal respectively. + + + + + + + + + +The #GtkAdjustment-struct struct contains the following fields. + + + + + + +#gfloat lower; +the minimum value. + + + +#gfloat upper; +the maximum value. + + + +#gfloat value; +the current value. + + + +#gfloat step_increment; +the increment to use to make minor changes to the value. +In a #GtkScrollbar this increment is used when the mouse is clicked on the +arrows at the top and bottom of the scrollbar, to scroll by a small amount. + + + + +#gfloat page_increment; +the increment to use to make major changes to the value. +In a #GtkScrollbar this increment is used when the mouse is clicked in the +trough, to scroll by a large amount. + + + + +#gfloat page_size; +the page size. +In a #GtkScrollbar this is the size of the area which is currently visible. + + + + + + + +@data: +@lower: +@upper: +@value: +@step_increment: +@page_increment: +@page_size: + + + +Creates a new #GtkAdjustment. + + +@value: the initial value. +@lower: the minimum value. +@upper: the maximum value. +@step_increment: the step increment. +@page_increment: the page increment. +@page_size: the page size. +@Returns: a new #GtkAdjustment. + + + + +Sets the #GtkAdjustment value. + + +@adjustment: a #GtkAdjustment. +@value: the new value. + + + + +Updates the #GtkAdjustment @value to ensure that the range between @lower +and @upper is in the current page (i.e. between @value and @value + +@page_size). +If the range is larger than the page size, then only the start of it will +be in the current page. +A "changed" signal will be emitted if the value is changed. + + +@adjustment: a #GtkAdjustment. +@lower: the lower value. +@upper: the upper value. + + + + +Emits a "changed" signal from the #GtkAdjustment. +This is typically called by the owner of the #GtkAdjustment after it has +changed any of the #GtkAdjustment fields other than the value. + + +@adjustment: + + + + +Emits a "value_changed" signal from the #GtkAdjusmtent. +This is typically called by the owner of the #GtkAdjustment after it has +changed the #GtkAdjustment value field. + + +@adjustment: + + + + +Emitted when one or more of the #GtkAdjustment fields have been changed, +other than the value field. + + +@adjustment: the object which received the signal. + + + +Emitted when the #GtkAdjustment value field has been changed. + + +@adjustment: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkalignment.sgml b/docs/reference/gtk/tmpl/gtkalignment.sgml new file mode 100644 index 0000000000..5a2b5b51a8 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkalignment.sgml @@ -0,0 +1,104 @@ + +GtkAlignment + + +a widget which controls the alignment and size of its child. + + + +The #GtkAlignment widget controls the alignment and size of its child widget. +It has four settings: xscale, yscale, xalign, and yalign. + + +The scale settings are used to specify how much the child widget should +expand to fill the space allocated to the #GtkAlignment. +The values can range from 0 (meaning the child doesn't expand at all) to +1 (meaning the child expands to fill all of the available space). + + +The align settings are used to place the child widget within the available +area. The values range from 0 (top or left) to 1 (bottom or right). +Of course, if the scale settings are both set to 1, the alignment settings +have no effect. + + + + + + + + + +The #GtkAlignment-struct struct contains private data only, and should +be accessed using the functions below. + + +@bin: +@xalign: +@yalign: +@xscale: +@yscale: + + + +Creates a new #GtkAlignment. + + +@xalign: the horizontal alignment of the child widget, from 0 (left) to 1 +(right). +@yalign: the vertical alignment of the child widget, from 0 (top) to 1 +(bottom). +@xscale: the amount that the child widget expands horizontally to fill up +unused space, from 0 to 1. +A value of 0 indicates that the child widget should never expand. +A value of 1 indicates that the child widget will expand to fill all of the +space allocated for the #GtkAlignment. +@yscale: the amount that the child widget expands vertically to fill up +unused space, from 0 to 1. The values are similar to @xscale. +@Returns: the new #GtkAlignment. + + + + +Sets the #GtkAlignment values. + + +@alignment: a #GtkAlignment. +@xalign: the horizontal alignment of the child widget, from 0 (left) to 1 +(right). +@yalign: the vertical alignment of the child widget, from 0 (top) to 1 +(bottom). +@xscale: the amount that the child widget expands horizontally to fill up +unused space, from 0 to 1. +A value of 0 indicates that the child widget should never expand. +A value of 1 indicates that the child widget will expand to fill all of the +space allocated for the #GtkAlignment. +@yscale: the amount that the child widget expands vertically to fill up +unused space, from 0 to 1. The values are similar to @xscale. + + + + +the horizontal alignment of the child widget, from 0 (left) to 1 (right). + + + + +the vertical alignment of the child widget, from 0 (top) to 1 (bottom). + + + + +the amount that the child widget expands horizontally to fill up +unused space, from 0 to 1. +A value of 0 indicates that the child widget should never expand. +A value of 1 indicates that the child widget will expand to fill all of the +space allocated for the #GtkAlignment. + + + + +the amount that the child widget expands vertically to fill up +unused space, from 0 to 1. The values are similar to @xscale. + + diff --git a/docs/reference/gtk/tmpl/gtkarg.sgml b/docs/reference/gtk/tmpl/gtkarg.sgml new file mode 100644 index 0000000000..3b8bec4ebf --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkarg.sgml @@ -0,0 +1,147 @@ + +Object Properties + + + + + + + + + + + + + + + + + + + +@class_type: +@name: +@type: +@arg_flags: +@full_name: +@arg_id: +@seq_id: + + + + + + +@arg_type: +@Returns: + + + + + + + +@src_arg: +@dest_arg: +@Returns: + + + + + + + +@arg: +@free_contents: + + + + + + + +@object_type: +@arg_info_hash_table: +@arg_list_p: +@info_list_p: +@first_arg_name: +@var_args: +@Returns: + + + + + + + +@arg_list: +@info_list: + + + + + + + +@object_type: +@arg_info_hash_table: +@arg_name: +@info_p: +@Returns: + + + + + + + +@base_class_type: +@arg_name: +@class_n_args_offset: +@arg_info_hash_table: +@arg_type: +@arg_flags: +@arg_id: +@Returns: + + + + + + + +@class_type: +@arg_info_hash_table: +@arg_flags: +@n_args_p: +@Returns: + + + + + + + +@arg_name: +@Returns: + + + + + + + +@arg_info_1: +@arg_info_2: +@Returns: + + + + + + + +@arg_info: +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkarrow.sgml b/docs/reference/gtk/tmpl/gtkarrow.sgml new file mode 100644 index 0000000000..30538600cd --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkarrow.sgml @@ -0,0 +1,92 @@ + +GtkArrow + + +produces an arrow pointing in one of the four cardinal directions. + + + +GtkArrow should be used to draw simple arrows that need to point in +one of the four cardinal directions (up, down, left, or right). The +style of the arrow can be one of shadow in, shadow out, etched in, or +etched out. Note that these directions and style types may be +ammended in versions of Gtk to come. + + +GtkArrow will fill any space alloted to it, but since it is inherited +from #GtkMisc, it can be padded and/or aligned, to fill exactly the +space the programmer desires. + + +Arrows are created with a call to gtk_arrow_new(). The direction or +style of an arrow can be changed after creation by using gtk_arrow_set(). + + + + + + + +gtk_paint_arrow() +the function used internally to paint the arrow. + + + + + + + +The #GtkArrow-struct containes the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#gint16 arrow_type; +the direction of the arrow, one of #GtkArrowType. + + + +#gint16 shadow_type; +the style of the arrow, one of #GtkShadowType. + + + + +@misc: +@arrow_type: +@shadow_type: + + + +Creates a new arrow widget. + + +@arrow_type: a valid #GtkArrowType. +@shadow_type: a valid #GtkShadowType. +@Returns: the new #GtkArrow widget. + + + + +Sets the direction and style of the #GtkArrow, @arrow. + + +@arrow: a widget of type #GtkArrow. +@arrow_type: a valid #GtkArrowType. +@shadow_type: a valid #GtkShadowType. + + + + +the arrow direction, one of #GtkArrowType. + + + + +the arrow style, one of #GtkShadowType. + + diff --git a/docs/reference/gtk/tmpl/gtkaspectframe.sgml b/docs/reference/gtk/tmpl/gtkaspectframe.sgml new file mode 100644 index 0000000000..868a488684 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkaspectframe.sgml @@ -0,0 +1,71 @@ + +GtkAspectFrame + + +A frame that constrains its child to a particular aspect ratio. + + + +The #GtkAspectFrame is useful when you want +pack a widget so that it can resize but always retains +the same aspect ratio. For instance, one might be +drawing a small preview of a larger image. #GtkAspectFrame +derives from #GtkFrame, so it can draw a label and +a frame around the child. The frame will be +"shrink-wrapped" to the size of the child. + + + + + + + + + + + + +@frame: +@xalign: +@yalign: +@ratio: +@obey_child: +@center_allocation: + + + +Create a new #GtkAspectFrame. + + +@label: Label text. +@xalign: Horizontal lignment of the child within the allocation of +the #GtkAspectFrame. This ranges from 0.0 (left aligned) +to 1.0 (right aligned) +@yalign: Vertical lignment of the child within the allocation of +the #GtkAspectFrame. This ranges from 0.0 (left aligned) +to 1.0 (right aligned) +@ratio: The desired aspect ratio. +@obey_child: If %TRUE, @ratio is ignored, and the aspect + ratio is taken from the requistion of the child. +@Returns: the new #GtkAspectFrame. + +@ratio: The desired aspect ratio. + + + + +Set parameters for an existing #GtkAspectFrame. + + +@aspect_frame: a #GtkAspectFrame +@xalign: Horizontal lignment of the child within the allocation of +the #GtkAspectFrame. This ranges from 0.0 (left aligned) +to 1.0 (right aligned) +@yalign: Vertical lignment of the child within the allocation of +the #GtkAspectFrame. This ranges from 0.0 (left aligned) +to 1.0 (right aligned) +@ratio: The desired aspect ratio. +@obey_child: If %TRUE, @ratio is ignored, and the aspect + ratio is taken from the requistion of the child. + + diff --git a/docs/reference/gtk/tmpl/gtkbbox.sgml b/docs/reference/gtk/tmpl/gtkbbox.sgml new file mode 100644 index 0000000000..834df6912f --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkbbox.sgml @@ -0,0 +1,159 @@ + +GtkButtonBox + + + + + + + + + + + + + + + + + + + +@box: +@spacing: +@child_min_width: +@child_min_height: +@child_ipad_x: +@child_ipad_y: +@layout_style: + + + + + + + + + + + + + +@min_width: +@min_height: + + + + + + + +@ipad_x: +@ipad_y: + + + + + + + +@min_width: +@min_height: + + + + + + + +@ipad_x: +@ipad_y: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@min_width: +@min_height: + + + + + + + +@widget: +@ipad_x: +@ipad_y: + + + + + + + +@widget: +@spacing: + + + + + + + +@widget: +@layout_style: + + + + + + + +@widget: +@min_width: +@min_height: + + + + + + + +@widget: +@ipad_x: +@ipad_y: + + + + + + + +@widget: +@nvis_children: +@width: +@height: + + diff --git a/docs/reference/gtk/tmpl/gtkbin.sgml b/docs/reference/gtk/tmpl/gtkbin.sgml new file mode 100644 index 0000000000..1aa48ce5a2 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkbin.sgml @@ -0,0 +1,44 @@ + +GtkBin + + +a container with just one child. + + + +The #GtkBin widget is a container with just one child. +It is not very useful itself, but it is useful for deriving subclasses, +since it provides common code needed for handling a single child widget. + + +Many GTK+ widgets are subclasses of #GtkBin, including #GtkWindow, #GtkButton, +#GtkFrame, #GtkHandleBox, and #GtkScrolledWindow. + + + + + + + + + +The #GtkBin-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#GtkWidget *child; +the child widget. + + + + + + +@container: +@child: + diff --git a/docs/reference/gtk/tmpl/gtkbindings.sgml b/docs/reference/gtk/tmpl/gtkbindings.sgml new file mode 100644 index 0000000000..a5c84f097d --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkbindings.sgml @@ -0,0 +1,243 @@ + +Bindings + + + + + + + + + + + + + + + + + + + +@match_type: +@pattern_length: +@pattern: +@pattern_reversed: +@user_data: +@seq_id: + + + + + + +@pspec: +@pattern: + + + + + + + +@pspec: + + + + + + + +@pspec: +@string_length: +@string: +@string_reversed: +@Returns: + + + + + + + +@pspec: +@string: +@Returns: + + + + + + + +@pattern: +@string: +@Returns: + + + + + + + +@set_name: +@priority: +@widget_path_pspecs: +@widget_class_pspecs: +@class_branch_pspecs: +@entries: +@current: + + + + + + +@keyval: +@modifiers: +@binding_set: +@destroyed: +@in_emission: +@set_next: +@hash_next: +@signals: + + + + + + +@next: +@signal_name: +@n_args: +@args: + + + + + + +@arg_type: + + + + + + +@set_name: +@Returns: + + + + + + + +@object_class: +@Returns: + + + + + + + +@set_name: +@Returns: + + + + + + + +@object: +@keyval: +@modifiers: +@Returns: + + + + + + + +@binding_set: +@keyval: +@modifiers: +@object: +@Returns: + + + + + + + + + + + + + + +@binding_set: +@keyval: +@modifiers: + + + + + + + +@binding_set: +@keyval: +@modifiers: +@signal_name: +@n_args: +@Varargs: + + + + + + + +@binding_set: +@path_type: +@path_pattern: +@priority: + + + + + + + +@binding_set: +@keyval: +@modifiers: + + + + + + + +@binding_set: +@keyval: +@modifiers: +@signal_name: +@binding_args: + + + + + + + +@scanner: +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkbox.sgml b/docs/reference/gtk/tmpl/gtkbox.sgml new file mode 100644 index 0000000000..0ff6c7c8f9 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkbox.sgml @@ -0,0 +1,370 @@ + +GtkBox + + +a base class for box containers + + + +GtkBox is an abstract widget which encapsulates functionallity for a +particular kind of container, one that organizes a variable number of +widgets into a rectangular area. GtkBox currently has two derived +classes, #GtkHBox and #GtkVBox. + + +The rectangular area of a GtkBox is organized into either a single row +or a single column of child widgets depending upon whether the box is +of type #GtkHBox or #GtkVBox, respectively. Thus, all children of a +GtkBox are allocated one dimension in common, which is the height of a +row, or the width of a column. + + +GtkBox uses a notion of packing. Packing refers to +adding widgets with reference to a particular position in a +#GtkContainer. For a GtkBox, there are two reference positions: the +start and the end of the box. For a +#GtkVBox, the start is defined as the top of the box and the end is +defined as the bottom. For a #GtkHBox the start is defined as the +left side and the end is defined as the right side. + + +Use repeated calls to gtk_box_pack_start() to pack widgets into a +GtkBox from start to end. Use gtk_box_pack_end() to add widgets from +end to start. You may intersperse these calls and add widgets from +both ends of the same GtkBox. + + +Use gtk_box_pack_start_defaults() or gtk_box_pack_end_defaults() +to pack widgets into a GtkBox if you do not need to specify the +expand, fill, or +padding attributes of the child to be +added. + + +Because GtkBox is a #GtkContainer, you may also use +gtk_container_add() to insert widgets into the box, and they will be +packed as if with gtk_box_pack_start_defaults(). Use +gtk_container_remove() to remove widgets from the GtkBox. + + +Use gtk_box_set_homogeneous() to specify whether or not all children +of the GtkBox are forced to get the same amount of space. + + +Use gtk_box_set_spacing() to determine how much space will be +minimally placed between all children in the GtkBox. + + +Use gtk_box_reorder_child() to move a GtkBox child to a different +place in the box. + + +Use gtk_box_set_child_packing() to reset the +expand, fill, +and padding attributes of any GtkBox child. +Use gtk_box_query_child_packing() to query these fields. + + + + + + + +#GtkHBox +a derived class that organizes widgets into a row. + + + +#GtkVBox +a derived class that organizes widgets into a column. + + + +#GtkFrame +a #GtkWidget useful for drawing a border around a GtkBox. + + + +#GtkTable +a #GtkContainer for organizing widgets into a grid, +rather than independent rows or columns. + + + +#GtkLayout +a #GtkContainer for organizing widgets into arbitrary +layouts. + + + + + + + + +The #GtkBox-struct describes an instance of GtkBox and contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#GList * children; +a list of children belonging the GtkBox. The data is a list of +structures of type #GtkBoxChild-struct. + + + +#gint16 spacing; +the number of pixels to put between children of the GtkBox, zero +by default. Use gtk_box_set_spacing() to set this field. + + + +#guint homogeneous; +a flag that if %TRUE forces all children to get equal space in +the GtkBox; %FALSE by default. Use gtk_box_set_homogeneous() to set this +field. + + + + +@container: +@children: +@spacing: +@homogeneous: + + + +The #GtkBoxChild-struct holds a child widget of GtkBox and describes +how the child is to be packed into the GtkBox. Use +gtk_box_query_child_packing() and gtk_box_set_child_packing() to query +and reset the padding, +expand, fill, +and pack fields. + + +#GtkBoxChild-struct contains the following fields. (These fields +should be considered read-only. They should never be directly set by an +application.) + + + + + + +#GtkWidget * widget; +the child widget, packed into the GtkBox. + + + +#guint16 padding; +the number of extra pixels to put between this child and its +neighbors, set when packed, zero by default. + + + +#guint expand; +flag indicates whether extra space should be given to this +child. Any extra space given to the parent GtkBox is divided up among +all children with this attribute set to %TRUE; set when packed, %TRUE by +default. + + + +#guint fill; +flag indicates whether any extra space given to this child due to its +expand attribute being set is actually +allocated to the child, rather than being used as padding +around the widget; set when packed, %TRUE by default. + + + +#guint pack; one of +#GtkPackType indicating whether the child is packed with reference to +the start (top/left) or end (bottom/right) of the GtkBox. + + + + +@widget: +@padding: +@expand: +@fill: +@pack: + + + +Adds @child to @box, packed with reference to the start of @box. The +@child is packed after any other child packed with reference to the +start of @box. + + +@box: a #GtkBox. +@child: the #GtkWidget to be added to @box. +@expand: %TRUE if the new child is to be given extra space allocated to +@box. The extra space will be divided evenly between all children of +@box that use this option. +@fill: %TRUE if space given to @child by the @expand option is +actually allocated to @child, rather than just padding it. This +parameter has no effect if @expand is set to %FALSE. A child is +always allocated the full height of a #GtkHBox and the full width of a +#GtkVBox. This option affects the other dimension. +@padding: extra space in pixels to put between this child and its +neighbors, over and above the global amount specified by +spacing in #GtkBox-struct. If @child is a +widget at one of the reference ends of @box, then @padding pixels are also put +between @child and the reference edge of @box. + + + + +Adds @child to @box, packed with reference to the end of @box. The +@child is packed after (away from end of) any other child packed with reference to the +end of @box. + + +@box: a #GtkBox. +@child: the #GtkWidget to be added to @box. +@expand: %TRUE if the new child is to be given extra space allocated to +@box. The extra space will be divided evenly between all children of +@box that use this option. +@fill: %TRUE if space given to @child by the @expand option is +actually allocated to @child, rather than just padding it. This +parameter has no effect if @expand is set to %FALSE. A child is +always allocated the full height of a #GtkHBox and the full width of a +#GtkVBox. This option affects the other dimension. +@padding: extra space in pixels to put between this child and its +neighbors, over and above the global amount specified by +spacing in #GtkBox-struct. If @child is a +widget at one of the reference ends of @box, then @padding pixels are also put +between @child and the reference edge of @box. + + + + +Adds @widget to @box, packed with reference to the start of @box. The +child is packed after any other child packed with reference to the +start of @box. + + +Parameters for how to pack the child @widget, +expand, fill, +and padding in #GtkBoxChild-struct, are given their default +values, %TRUE, %TRUE, and 0, respectively. + + +@box: a #GtkBox. +@widget: the #GtkWidget to be added to @box. + + + + +Adds @widget to @box, packed with reference to the end of @box. The +child is packed after (away from end of) any other child packed with +reference to the end of @box. + + +Parameters for how to pack the child @widget, +expand, fill, +and padding in #GtkBoxChild-struct, are given their default +values, %TRUE, %TRUE, and 0, respectively. + + +@box: a #GtkBox. +@widget: the #GtkWidget to be added to @box. + + + + +Sets the homogeneous field of +#GtkBox-struct, controlling whether or not all children of @box are +given equal space in the box. + + +@box: a #GtkBox. +@homogeneous: a boolean value, %TRUE to create equal allotments, +%FALSE for variable allotments. + + + + +Sets the spacing field of #GtkBox-struct, +which is the number of pixels to place between children of @box. + + +@box: a #GtkBox. +@spacing: the number of pixels to put between children. + + + + +Moves @child to a new @position in the list of @box children. The +list is the children field of +#GtkBox-struct, and contains both widgets packed #GTK_PACK_START as +well as widgets packed #GTK_PACK_END, in the order that these widgets +were added to @box. + + +A widget's position in the @box children list determines where the +widget is packed into @box. A child widget at some position in the +list will be packed just after all other widgets of the same packing +type that appear earlier in the list. A negative value of @position is +interpreted as position 0. + + +@box: a #GtkBox. +@child: the #GtkWidget to move. +@position: the new position for @child in the +children list of #GtkBox-struct, starting +from 0. + + + + +Returns information about how @child is packed into @box. + + +@box: a #GtkBox. +@child: the #GtkWidget of the child to query. +@expand: the returned value of the expand +field in #GtkBoxChild-struct. +@fill: the returned value of the fill field +in #GtkBoxChild-struct. +@padding: the returned value of the padding +field in #GtkBoxChild-struct. +@pack_type: the returned value of the pack +field in #GtkBoxChild-struct. + + + + +Sets the way @child is packed into @box. + + +@box: a #GtkBox. +@child: the #GtkWidget of the child to set. +@expand: the new value of the expand field +in #GtkBoxChild-struct. +@fill: the new value of the fill field in +#GtkBoxChild-struct. +@padding: the new value of the padding +field in #GtkBoxChild-struct. +@pack_type: the new value of the pack field +in #GtkBoxChild-struct. + + + + +the minimum amount of space to put between children. Refers to the +spacing field of #GtkBox-struct. + + + + +how to allocate space for children, equally or variably. Refers to +the homogeneous field of #GtkBox-struct. + + diff --git a/docs/reference/gtk/tmpl/gtkbutton.sgml b/docs/reference/gtk/tmpl/gtkbutton.sgml new file mode 100644 index 0000000000..32a88b5c4a --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkbutton.sgml @@ -0,0 +1,163 @@ + +GtkButton + + +A widget that creates a signal when clicked on. + + + +The #GtkButton widget is generally used to attach a function to that +is called when the button is pressed. The various signals and how to use +them are outlined below. + + +The #GtkButton widget can hold any valid child widget. That is it can +hold most any other standard #GtkWidget. The most commonly used child is +the #GtkLabel. + + + + + + + + + +This should not be accessed directly. Use the accessor functions below. + + +@bin: +@child: +@in_button: +@button_down: +@relief: + + + +Creates a new #GtkButton widget. + + +@Returns: The newly created #GtkButton widget. + + + + +Creates a #GtkButton widget with a #GtkLabel child containing the given +text. + + +@label: The text you want the #GtkLabel to hold. +@Returns: The newly created #GtkButton widget. + + + + +Emits a #GtkButton::pressed signal to the given #GtkButton. + + +@button: The #GtkButton you want to send the signal to. + + + + +Emits a #GtkButton::released signal to the given #GtkButton. + + +@button: The #GtkButton you want to send the signal to. + + + + +Emits a #GtkButton::clicked signal to the given #GtkButton. + + +@button: The #GtkButton you want to send the signal to. + + + + +Emits a #GtkButton::enter signal to the given #GtkButton. + + +@button: The #GtkButton you want to send the signal to. + + + + +Emits a #GtkButton::leave signal to the given #GtkButton. + + +@button: The #GtkButton you want to send the signal to. + + + + +Sets the relief style of the edges of the given #GtkButton widget. +Three styles exist, GTK_RELIEF_NORMAL, GTK_RELIEF_HALF, GTK_RELIEF_NONE. +The default style is, as one can guess, GTK_RELIEF_NORMAL. + + + + +@button: The #GtkButton you want to set relief styles of. +@newstyle: The GtkReliefStyle as described above. + + + + +Returns the current relief style of the given #GtkButton. + + +@button: The #GtkButton you want the #GtkReliefStyle from. +@Returns: The current #GtkReliefStyle + + + + +Emitted when the button is initially pressed. + + +@button: the object which received the signal. + + + +Emitted when a button which is pressed is released, no matter where the +mouse cursor is. + + +@button: the object which received the signal. + + + +Emitted when a button clicked on by the mouse and the cursor stays on the +button. If the cursor is not on the button when the mouse button is released, +the signal is not emitted. + + +@button: the object which received the signal. + + + +Emitted when the mouse cursor enters the region of the button. + + +@button: the object which received the signal. + + + +Emitted when the mouse cursor leaves the region of the button. + + +@button: the object which received the signal. + + + +The text within the child #GtkLabel of the #GtkButton. Only useful if +there is actually a #GtkLabel inside of the #GtkButton. + + + + +The #GtkReliefStyle as outlined in gtk_button_set_relief(). + + diff --git a/docs/reference/gtk/tmpl/gtkcalendar.sgml b/docs/reference/gtk/tmpl/gtkcalendar.sgml new file mode 100644 index 0000000000..4ca84c2837 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcalendar.sgml @@ -0,0 +1,260 @@ + +GtkCalendar + + +display a calendar and/or allow the user to select a date. + + + +#GtkCalendar is a widget that displays a calendar, one month at a time. +It can be created with gtk_calendar_new(). + + +The month and year currently displayed can be altered with +gtk_calendar_select_month(). The exact day can be selected from the displayed +month using gtk_calendar_select_day(). + + +FIXME: (check)To place a visual marker on a particular day, use +gtk_calendar_mark_day() and to remove the marker, gtk_calendar_unmark_day(). +Alternative, all marks can be cleared with gtk_calendar_clear_marks(). + + +The way in which the calendar itself is displayed can be altered using +gtk_calendar_display_options(). + + +The selected date can be retrieved from a #GtkCalendar using +gtk_calendar_get_date(). + + +If performing many 'mark' operations, the calendar can be frozen to prevent +flicker, using gtk_calendar_freeze(), and 'thawed' again using +gtk_calendar_thaw(). + + + + + + + + + +num_marked_dates is an integer containing the +number of days that have a mark over them. + + +marked_date is an array containing the day numbers +that currently have a mark over them. + + +month, year, and +selected_day contain the currently visible month, +year, and selected day respectively. + + +All of these fields should be considered read only, and everything in this +struct should only be modified using the functions provided below. + + +@widget: +@header_style: +@label_style: +@month: +@year: +@selected_day: +@day_month: +@day: +@num_marked_dates: +@marked_date: +@display_flags: +@marked_date_color: +@gc: +@xor_gc: +@focus_row: +@focus_col: +@highlight_row: +@highlight_col: +@private_data: +@grow_space: + + + + + + + + +GTK_CALENDAR_SHOW_HEADING +Specifies that the month and year should be displayed. + + +GTK_CALENDAR_SHOW_DAY_NAMES +Specifies that three letter day descriptions should be present. + + +GTK_CALENDAR_NO_MONTH_CHANGE +Prevents the user from switching months with the calendar. + + +GTK_CALENDAR_SHOW_WEEK_NUMBERS +Displays each week numbers of the current year, down the left side of +the calendar. + + +GTK_CALENDAR_WEEK_START_MONDAY +Starts the calendar week on Monday, instead of the default Sunday. + + + + + +@GTK_CALENDAR_SHOW_HEADING: +@GTK_CALENDAR_SHOW_DAY_NAMES: +@GTK_CALENDAR_NO_MONTH_CHANGE: +@GTK_CALENDAR_SHOW_WEEK_NUMBERS: +@GTK_CALENDAR_WEEK_START_MONDAY: + + + +Creates a new calendar. FIXME:default date. + + +@Returns: a #GtkCalendar. + + + + +Shifts the calendar to a different month. + + +@calendar: a #GtkCalendar. +@month: a month number. +@year: the year the month is in. +@Returns: FIXME. + + + + +Selects a day from the current month. + + +@calendar: a #GtkCalendar. +@day: the day number to select. + + + + + + + +@calendar: +@day: +@Returns: + + + + + + + +@calendar: +@day: +@Returns: + + + + + + + +@calendar: + + + + + + + +@calendar: +@flags: + + + + + + + +@calendar: +@year: +@month: +@day: + + + + +Locks the display of the calendar until it is thawed with gtk_calendar_thaw(). + + +@calendar: a #GtkCalendar. + + + + +Defrosts a calendar; all the changes made since the last +gtk_calendar_freeze() are displayed. + + +@calendar: a #GtkCalendar. + + + + +Emitted when the user clicks a button to change the selected month on a +calendar. + + +@calendar: the object which received the signal. + + + +Emitted when the user selects a day. + + +@calendar: the object which received the signal. + + + + + + +@calendar: the object which received the signal. + + + + + + +@calendar: the object which received the signal. + + + + + + +@calendar: the object which received the signal. + + + + + + +@calendar: the object which received the signal. + + + + + + +@calendar: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkcheckbutton.sgml b/docs/reference/gtk/tmpl/gtkcheckbutton.sgml new file mode 100644 index 0000000000..bdbbbf7ab3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcheckbutton.sgml @@ -0,0 +1,60 @@ + +GtkCheckButton + + +create widgets with a discrete toggle button. + + + +A #GtkCheckButton places a discrete #GtkToggleButton next to a widget, (usually a #GtkLabel). See the section on #GtkToggleButton widgets for more information about toggle/check buttons. + + +The important signal ('toggled') is also inherited from #GtkToggleButton. + + + + + + +#GtkCheckMenuItem +add check buttons to your menus. + + +#GtkButton +a more general button. + + +#GtkToggleButton +#GtkCheckButton's parent. + + +#GtkRadioButton +group check buttons together. + + + + + + +toggle_button is a #GtkToggleButton representing the actual toggle button that composes the check button. + + +@toggle_button: + + + +Creates a new #GtkCheckButton. + + +@Returns: a #GtkWidget. + + + + +Creates a new #GtkCheckButton with a #GtkLabel to the right of it. + + +@label: the text for the check button. +@Returns: a #GtkWidget. + + diff --git a/docs/reference/gtk/tmpl/gtkcheckmenuitem.sgml b/docs/reference/gtk/tmpl/gtkcheckmenuitem.sgml new file mode 100644 index 0000000000..451e0cf7ac --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcheckmenuitem.sgml @@ -0,0 +1,111 @@ + +GtkCheckMenuItem + + +a menu item with a check box. + + + +A #GtkCheckMenuItem is a menu item that maintains the state of a boolean +value in addition to a #GtkMenuItem's usual role in activating application +code. + + + +A check box indicating the state of the boolean value is displayed +at the left side of the #GtkMenuItem. Activating the #GtkMenuItem +toggles the value. + + + + + + + + + +The #GtkCheckMenuItem-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#guint active; +TRUE if the check box is active. + + + + + +@menu_item: +@active: +@always_show_toggle: + + + +Creates a new #GtkCheckMenuItem. + + +@Returns: a new #GtkCheckMenuItem. + + + + +Creates a new #GtkCheckMenuItem with a label. + + +@label: the string to use for the label. +@Returns: a new #GtkCheckMenuItem. + + + + +This macro is provided to preserve compatibility with older code. +New code should use gtk_check_menu_item_set_active() function instead. + + + + + + +Sets the active state of the menu item's check box. + + +@check_menu_item: a #GtkCheckMenuItem. +@is_active: boolean value indicating whether the check box is active. + + + + +Controls whether the check box is shown at all times. +Normally the check box is shown only when it is active or while the +menu item is selected. + + +@menu_item: a #GtkCheckMenuItem. +@always: boolean value indicating whether to always show the check box. + + + + +Emits the GtkCheckMenuItem::toggled signal. + + +@check_menu_item: a #GtkCheckMenuItem. + + + + +This signal is emitted when the state of the check box is changed. + + + +A signal handler can examine the active +field of the #GtkCheckMenuItem-struct struct to discover the new state. + + +@checkmenuitem: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkclist.sgml b/docs/reference/gtk/tmpl/gtkclist.sgml new file mode 100644 index 0000000000..6c6d8a4a2e --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkclist.sgml @@ -0,0 +1,1268 @@ + +GtkCList + + + + + + + + + + + + + + + + + + + +@container: +@flags: +@row_mem_chunk: +@cell_mem_chunk: +@freeze_count: +@internal_allocation: +@rows: +@row_center_offset: +@row_height: +@row_list: +@row_list_end: +@columns: +@column_title_area: +@title_window: +@column: +@clist_window: +@clist_window_width: +@clist_window_height: +@hoffset: +@voffset: +@shadow_type: +@selection_mode: +@selection: +@selection_end: +@undo_selection: +@undo_unselection: +@undo_anchor: +@button_actions: +@drag_button: +@click_cell: +@hadjustment: +@vadjustment: +@xor_gc: +@fg_gc: +@bg_gc: +@cursor_drag: +@x_drag: +@focus_row: +@anchor: +@anchor_state: +@drag_pos: +@htimer: +@vtimer: +@sort_type: +@compare: +@sort_column: + + + + + + +@GTK_CELL_EMPTY: +@GTK_CELL_TEXT: +@GTK_CELL_PIXMAP: +@GTK_CELL_PIXTEXT: +@GTK_CELL_WIDGET: + + + + + + +@GTK_BUTTON_IGNORED: +@GTK_BUTTON_SELECTS: +@GTK_BUTTON_DRAGS: +@GTK_BUTTON_EXPANDS: + + + + + + +@clist: + + + + + + + +@clist: +@flag: + + + + + + + +@clist: +@flag: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@_glist_: + + + + + + + +@cell: + + + + + + + +@cell: + + + + + + + +@cell: + + + + + + + +@cell: + + + + + + + +@clist: +@ptr1: +@ptr2: +@Returns: + + + + + + + +@title: +@area: +@button: +@window: +@width: +@min_width: +@max_width: +@justification: +@visible: +@width_set: +@resizeable: +@auto_resize: +@button_passive: + + + + + + +@cell: +@state: +@foreground: +@background: +@style: +@data: +@destroy: +@fg_set: +@bg_set: +@selectable: + + + + + + +@type: +@vertical: +@horizontal: +@style: +@text: + + + + + + +@type: +@vertical: +@horizontal: +@style: +@pixmap: +@mask: + + + + + + +@type: +@vertical: +@horizontal: +@style: +@text: +@spacing: +@pixmap: +@mask: + + + + + + +@type: +@vertical: +@horizontal: +@style: +@widget: + + + + + + +@type: +@vertical: +@horizontal: +@style: +@widget: + + + + + + +@row: +@column: + + + + + + +@cell: +@insert_pos: + + + + + + +@GTK_CLIST_DRAG_NONE: +@GTK_CLIST_DRAG_BEFORE: +@GTK_CLIST_DRAG_INTO: +@GTK_CLIST_DRAG_AFTER: + + + + + + +@clist: +@columns: +@titles: + + + + + + + +@columns: +@Returns: + + + + + + + +@columns: +@titles: +@Returns: + + + + + + + +@clist: +@type: + + + + + + + +@clist: +@mode: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: +@column: + + + + + + + +@clist: +@column: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: +@column: +@title: + + + + + + + +@clist: +@column: +@widget: + + + + + + + +@clist: +@column: +@justification: + + + + + + + +@clist: +@column: +@visible: + + + + + + + +@clist: +@column: +@resizeable: + + + + + + + +@clist: +@column: +@auto_resize: + + + + + + + +@clist: +@column: +@Returns: + + + + + + + +@clist: +@column: +@width: + + + + + + + +@clist: +@column: +@min_width: + + + + + + + +@clist: +@column: +@max_width: + + + + + + + +@clist: +@height: + + + + + + + +@clist: +@row: +@column: +@row_align: +@col_align: + + + + + + + +@clist: +@row: +@Returns: + + + + + + + +@clist: +@row: +@column: +@Returns: + + + + + + + +@clist: +@row: +@column: +@text: + + + + + + + +@clist: +@row: +@column: +@text: +@Returns: + + + + + + + +@clist: +@row: +@column: +@pixmap: +@mask: + + + + + + + +@clist: +@row: +@column: +@pixmap: +@mask: +@Returns: + + + + + + + +@clist: +@row: +@column: +@text: +@spacing: +@pixmap: +@mask: + + + + + + + +@clist: +@row: +@column: +@text: +@spacing: +@pixmap: +@mask: +@Returns: + + + + + + + +@clist: +@row: +@color: + + + + + + + +@clist: +@row: +@color: + + + + + + + +@clist: +@row: +@column: +@style: + + + + + + + +@clist: +@row: +@column: +@Returns: + + + + + + + +@clist: +@row: +@style: + + + + + + + +@clist: +@row: +@Returns: + + + + + + + +@clist: +@row: +@column: +@vertical: +@horizontal: + + + + + + + +@clist: +@row: +@selectable: + + + + + + + +@clist: +@row: +@Returns: + + + + + + + +@clist: +@text: +@Returns: + + + + + + + +@clist: +@text: +@Returns: + + + + + + + +@clist: +@row: +@text: +@Returns: + + + + + + + +@clist: +@row: + + + + + + + +@clist: +@row: +@data: + + + + + + + +@clist: +@row: +@data: +@destroy: + + + + + + + +@clist: +@row: +@Returns: + + + + + + + +@clist: +@data: +@Returns: + + + + + + + +@clist: +@row: +@column: + + + + + + + +@clist: +@row: +@column: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: +@x: +@y: +@row: +@column: +@Returns: + + + + + + + +@clist: + + + + + + + +@clist: + + + + + + + +@clist: +@row1: +@row2: + + + + + + + +@clist: +@cmp_func: + + + + + + + +@clist: +@column: + + + + + + + +@clist: +@sort_type: + + + + + + + +@clist: + + + + + + + +@clist: +@auto_sort: + + + + + + + +@clist: +@Returns: + + + + + + + +@clist: +@column: +@Returns: + + + + + + + +@clist: +@column: +@Returns: + + + + + + + +@clist: +@Returns: + + + + + + + +@clist: +@Returns: + + + + + + + +@clist: +@source_row: +@dest_row: + + + + + + + +@clist: +@button: +@button_actions: + + + + + + + +@clist: +@adjustment: + + + + + + + +@clist: +@reorderable: + + + + + + + +@clist: +@use_icons: + + + + + + + +@clist: +@adjustment: + + + + + + + +@clist: the object which received the signal. +@row: +@column: +@event: + + + + + + +@clist: the object which received the signal. +@row: +@column: +@event: + + + + + + +@clist: the object which received the signal. +@arg1: +@arg2: + + + + + + +@clist: the object which received the signal. +@column: + + + + + + +@clist: the object which received the signal. +@column: +@width: + + + + + + +@clist: the object which received the signal. + + + + + + +@clist: the object which received the signal. + + + + + + +@clist: the object which received the signal. + + + + + + +@clist: the object which received the signal. + + + + + + +@clist: the object which received the signal. + + + + + + +@clist: the object which received the signal. + + + + + + +@clist: the object which received the signal. + + + + + + +@clist: the object which received the signal. +@scroll_type: +@position: +@auto_start_selection: + + + + + + +@clist: the object which received the signal. +@scroll_type: +@position: + + + + + + +@clist: the object which received the signal. +@scroll_type: +@position: + + + + + + +@clist: the object which received the signal. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkcolorsel.sgml b/docs/reference/gtk/tmpl/gtkcolorsel.sgml new file mode 100644 index 0000000000..819a072de3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcolorsel.sgml @@ -0,0 +1,93 @@ + +GtkColorSelection + + + + + + + + + + + + + + + + + + + +@vbox: +@wheel_area: +@value_area: +@sample_area: +@sample_area_eb: +@scales: +@entries: +@opacity_label: +@wheel_gc: +@value_gc: +@sample_gc: +@policy: +@use_opacity: +@timer_active: +@timer_tag: +@values: +@old_values: +@wheel_buf: +@value_buf: +@sample_buf: + + + + + + +@Returns: + + + + + + + +@colorsel: +@policy: + + + + + + + +@colorsel: +@use_opacity: + + + + + + + +@colorsel: +@color: + + + + + + + +@colorsel: +@color: + + + + + + + +@colorselection: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkcolorseldlg.sgml b/docs/reference/gtk/tmpl/gtkcolorseldlg.sgml new file mode 100644 index 0000000000..2dc847a654 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcolorseldlg.sgml @@ -0,0 +1,38 @@ + +GtkColorSelectionDialog + + + + + + + + + + + + + + + + + + + +@window: +@colorsel: +@main_vbox: +@ok_button: +@reset_button: +@cancel_button: +@help_button: + + + + + + +@title: +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkcombo.sgml b/docs/reference/gtk/tmpl/gtkcombo.sgml new file mode 100644 index 0000000000..ce8e542db2 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcombo.sgml @@ -0,0 +1,109 @@ + +GtkCombo + + + + + + + + + + + + + + + + + + + +@hbox: +@entry: +@button: +@popup: +@popwin: +@list: +@entry_change_id: +@list_change_id: +@value_in_list: +@ok_if_empty: +@case_sensitive: +@use_arrows: +@use_arrows_always: +@current_button: +@activate_id: + + + + + + +@Returns: + + + + + + + +@combo: +@val: +@ok_if_empty: + + + + + + + +@combo: +@val: + + + + + + + +@combo: +@val: + + + + + + + +@combo: +@val: + + + + + + + +@combo: +@item: +@item_value: + + + + + + + +@combo: +@strings: + + + + + + + +@combo: + + diff --git a/docs/reference/gtk/tmpl/gtkcontainer.sgml b/docs/reference/gtk/tmpl/gtkcontainer.sgml new file mode 100644 index 0000000000..3786dce30c --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcontainer.sgml @@ -0,0 +1,410 @@ + +GtkContainer + + + + + + + + + + + + + + + + + + + +@widget: +@focus_child: +@border_width: +@need_resize: +@resize_mode: +@resize_widgets: + + + + + + +@widget: + + + + + + + + + + + + + + +@container: +@widget: + + + + + + + +@container: +@widget: + + + + + + + +@container: +@resize_mode: + + + + + + + +@container: + + + + + + + +@container: +@callback: +@callback_data: + + + + + + + +@container: +@callback: +@marshal: +@callback_data: +@notify: + + + + + + + +@container: +@Returns: + + + + + + + +@container: +@direction: +@Returns: + + + + + + + +@container: +@child: + + + + + + + +@container: +@adjustment: + + + + + + + +@container: +@adjustment: + + + + + + + +@container: + + + + + + + +@container: + + + + + + + +@container: + + + + + + + +@container: +@Returns: + + + + + + + +@arg_name: +@arg_type: +@arg_flags: +@arg_id: + + + + + + + +@class_type: +@arg_flags: +@nargs: +@Returns: + + + + + + + +@container: +@child: +@n_args: +@args: + + + + + + + +@container: +@child: +@n_args: +@args: + + + + + + + +@container: +@widget: +@first_arg_name: +@Varargs: + + + + + + + +@container: +@widget: +@n_args: +@args: + + + + + + + +@container: +@child: +@first_arg_name: +@Varargs: + + + + + + + +@container: + + + + + + + +@container: + + + + + + + +@container: +@child: +@arg: +@info: + + + + + + + +@container: +@child: +@arg: +@info: + + + + + + + +@object_type: +@arg_list_p: +@info_list_p: +@first_arg_name: +@args: +@Returns: + + + + + + + +@object_type: +@arg_name: +@info_p: +@Returns: + + + + + + + +@container: +@callback: +@callback_data: + + + + + + + +@container: +@child: +@Returns: + + + + + + + +@Returns: + + + + + + + +@container: +@border_width: + + + + + + + +@container: the object which received the signal. +@widget: + + + + + + +@container: the object which received the signal. +@widget: + + + + + + +@container: the object which received the signal. + + + + + + +@container: the object which received the signal. +@direction: +@Returns: + + + + + + +@container: the object which received the signal. +@widget: + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkctree.sgml b/docs/reference/gtk/tmpl/gtkctree.sgml new file mode 100644 index 0000000000..08a610a295 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkctree.sgml @@ -0,0 +1,1266 @@ + +GtkCTree + + +a widget displaying a hierarchical tree. + + + +The #GtkCTree widget is used for showing a hierarchical tree +to the user, for example a directory tree. + + +The tree is internally represented as a set of #GtkCTreeNode structures. + + +The interface has much in common with the #GtkCList widget: rows (nodes) +can be selected by the user etc. + + +Positions in the tree are often indicated by two arguments, a +parent and a sibling, both #GtkCTreeNode pointers. If the parent +is %NULL, the position is at the root of the tree and if the sibling +is %NULL, it will be the last child of parent, otherwise it will be +inserted just before the sibling. + + + + + + + + + +The #GtkCTree-struct contains the following user-accessible fields. +These fields should be considered read-only; to set the values, +use the methods below. + + + + + + +#gint tree_indent; +The number of pixels each successive level of the tree is +indented in the display. + + + +#gint tree_spacing; +The space in pixels between the graphical tree and the text in the +node. + + + +#gint tree_column; +The index of the column for which the tree graphics is drawn. + + + +#GtkCTreeLineStyle line_style; +The style in which the lines in the tree graphics are drawn. + + + +#GtkCTreeExpanderStyle expander_style; +The style in which the expander buttons are drawn. + + + +#GtkCTreeExpanderStyle expander_style; +FIXME. + + + + + +@clist: +@lines_gc: +@tree_indent: +@tree_spacing: +@tree_column: +@line_style: +@expander_style: +@show_stub: +@drag_compare: + + + +Used to get the #GtkCTreeRow structure corresponding to the given #GtkCTreeNode. + + +@_node_: + + + + + + + +@_node_: + + + + +FIXME + + +@_nnode_: + + + + +FIXME + + +@_pnode_: + + + + + + + +@_func_: + + + + +A value specifying the position of a new node relative to an old one. + + + + + + +GTK_CTREE_POS_BEFORE +As a sibling, before the specified node. + + + +GTK_CTREE_POS_AS_CHILD +As a child of the specified node. + + + +GTK_CTREE_POS_AFTER +As a sibling, after the specified node. + + + + + + +@GTK_CTREE_POS_BEFORE: +@GTK_CTREE_POS_AS_CHILD: +@GTK_CTREE_POS_AFTER: + + + +The appearance of the lines in the tree graphics. + + + + + + +GTK_CTREE_LINES_NONE +No lines. + + + +GTK_CTREE_LINES_SOLID +Solid lines. + + + +GTK_CTREE_LINES_DOTTED +Dotted lines. + + + +GTK_CTREE_LINES_TABBED +FIXME. + + + + + + + +@GTK_CTREE_LINES_NONE: +@GTK_CTREE_LINES_SOLID: +@GTK_CTREE_LINES_DOTTED: +@GTK_CTREE_LINES_TABBED: + + + +The appearance of the expander buttons, i.e. the small buttons +which expand or contract parts of the tree when pressed. + + + + + + + +GTK_CTREE_EXPANDER_NONE +No expanders. + + + +GTK_CTREE_EXPANDER_SQUARE +Square expanders. + + + +GTK_CTREE_EXPANDER_TRIANGLE +Triangular expanders. + + + +GTK_CTREE_EXPANDER_CIRCULAR +Round expanders. + + + + + + + +@GTK_CTREE_EXPANDER_NONE: +@GTK_CTREE_EXPANDER_SQUARE: +@GTK_CTREE_EXPANDER_TRIANGLE: +@GTK_CTREE_EXPANDER_CIRCULAR: + + + +How to expand or collapse a part of a tree. + + + + + + +GTK_CTREE_EXPANSION_EXPAND +Expand this node. + + + +GTK_CTREE_EXPANSION_EXPAND_RECURSIVE +Expand this node and everything below it in the hierarchy. + + + +GTK_CTREE_EXPANSION_COLLAPSE +Collapse this node. + + + +GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE +Collapse this node and everything below it in the hierarchy. + + + +GTK_CTREE_EXPANSION_TOGGLE +Toggle this node (i.e. expand if collapsed and vice versa). + + + +GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE +Toggle this node and everything below it in the hierarchy. + + + + + + + + +@GTK_CTREE_EXPANSION_EXPAND: +@GTK_CTREE_EXPANSION_EXPAND_RECURSIVE: +@GTK_CTREE_EXPANSION_COLLAPSE: +@GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE: +@GTK_CTREE_EXPANSION_TOGGLE: +@GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE: + + + +A generic callback type to do something with a particular node. + + +@ctree: The #GtkCTree object. +@node: The #GtkCTreeNode in the tree. +@data: The user data associated with the node. + + + + +FIXME + + +@ctree: +@depth: +@gnode: +@cnode: +@data: +@Returns: + + + + +FIXME + + +@ctree: +@source_node: +@new_parent: +@new_sibling: +@Returns: + + + + +A structure representing a single row in the tree graph. +The values inside the structure should be considered read-only. +This structure is derived from the #GtkCListRow structure. + + + + + + +#GtkCTreeNode *parent; +The parent node of the node corresponding to this row. + + + + +#GtkCTreeNode *sibling; +The next sibling node of the node corresponding to this row. + + + + +#GtkCTreeNode *children; +The first child node corresponding to this row; to access +the other children, just use the siblings of that node. + + + + +#GdkPixmap *pixmap_closed; + The pixmap to be shown when the node is collapsed. + + + + +#GdkBitmap *mask_closed; + The mask for the above pixmap. + + + + +#GdkPixmap *pixmap_opened; + The pixmap to be shown when the node is expanded. + + + + +#GdkBitmap *mask_opened; + The mask for the above pixmap. + + + + +#guint16 level; +The level of this node in the tree. + + + + + +#guint is_leaf : 1; +Whether this row is a leaf. + + + + +#guint expanded : 1; +Whether the children of this row are visible. + + + + + + +@row: +@parent: +@sibling: +@children: +@pixmap_closed: +@mask_closed: +@pixmap_opened: +@mask_opened: +@level: +@is_leaf: +@expanded: + + + +This structure is opaque - you should use the +macros #GTK_CTREE_ROW, #GTK_CTREE_NODE_NEXT etc. as well +as the functions below to access it. + + +@list: + + + +This function is not usually used by users. + + +@ctree: +@columns: +@tree_column: +@titles: + + + + +Create a new #GtkCTree widget with the given titles for the columns. + + +@columns: Number of columns. +@tree_column: Which column has the tree graphic; 0 = leftmost. +@titles: The titles for the columns. +@Returns: The #GtkCTree widget. + + + + +Create a new #GtkCTree widget. + + +@columns: Number of columns. +@tree_column: Which columns has the tree graphic. +@Returns: The new #GtkCTree widget. + + + + +Insert a new node to the tree. The position is specified through +the parent-sibling notation, as explained in the introduction above. + + +@ctree: The #GtkCTree widget. +@parent: The parent node to be. +@sibling: The sibling node to be. +@text: The texts to be shown in each column. +@spacing: The extra space between the pixmap and the text. +@pixmap_closed: The pixmap to be used when the node is collapsed. Can be %NULL. +@mask_closed: The mask for the above pixmap. Can be %NULL. +@pixmap_opened: The pixmap to be used when the children are visible. Can be %NULL. +@mask_opened: The mask for the above pixmap. Can be %NULL. +@is_leaf: Whether this node is going to be a leaf. +@expanded: Whether this node should start out expanded or not. +@Returns: + + + + +Remove the node and all nodes underneath it from the tree. + + +@ctree: The widget. +@node: The node to be removed. + + + + +FIXME + + +@ctree: +@parent: +@sibling: +@gnode: +@func: +@data: +@Returns: + + + + +FIXME + + +@ctree: +@parent: +@sibling: +@node: +@func: +@data: +@Returns: + + + + +Recursively apply a function to all nodes of the tree at or below a certain +node. +The function is called for each node after it has been called +for that node's children. + + +@ctree: +@node: The node where to start. %NULL means to start at the root. +@func: The function to apply to each node. +@data: A closure argument given to each invocation of the function. + + + + +Recursively apply a function to nodes up to a certain depth. +The function is called for each node after it has been called +for that node's children. + + +@ctree: +@node: The node where to start. +@depth: The maximum absolute depth for applying the function. If depth is negative, this function just calls #gtk_ctree_post_recursive. +@func: The function to apply to each node. +@data: A closure argument given to each invocation of the function. + + + + +Recursively apply a function to all nodes of the tree at or below a certain +node. +The function is called for each node after it has been called +for its parent. + + +@ctree: +@node: The node where to start. %NULL means to start at the root. +@func: The function to apply to each node. +@data: A closure argument given to each invocation of the function. + + + + +Recursively apply a function to nodes up to a certain depth. +The function is called for each node after it has been called +for that node's children. + + +@ctree: +@node: The node where to start. +@depth: The maximum absolute depth for applying the function. If depth is negative, this function just calls #gtk_ctree_post_recursive. +@func: The function to apply to each node. +@data: A closure argument given to each invocation of the function. + + + + +This function checks whether the given node is viewable i.e. so that +all of its parent nodes are expanded. This is different from being +actually visible: the node can be viewable but outside the scrolling +area of the window. + + +@ctree: +@node: +@Returns: Whether the node is viewable. + + + + +Returns the last child of the last child of the last child... +of the given node. + + +@ctree: +@node: +@Returns: + + + + +Finds the node pointer given a #GtkCTreeRow structure. + + +@ctree: +@ctree_row: +@Returns: The node pointer. + + + + + + + +@ctree: +@node: The node to start searching from. May be %NULL. +@child: +@Returns: True if @child is on some level a child (grandchild...) of the @node. + + + + + + + +@ctree: +@node: +@child: +@Returns: True is @node is an ancestor of @child. + + + + +Finds a node in the tree under @node that has the given user data pointer. + + +@ctree: +@node: +@data: +@Returns: The node, or %NULL if not found. + + + + +Finds all nodes in the tree under @node that have the given user data pointer. + + +@ctree: +@node: +@data: +@Returns: A list of nodes that have the given data pointer. + + + + +Find the first node under @node whose row data pointer fulfills +a custom criterion. + + +@ctree: +@node: The node where to start searching. +@data: User data for the criterion function. +@func: The criterion function. +@Returns: The first node found. + + + + +Find all nodes under @node whose row data pointer fulfills +a custom criterion. + + + +@ctree: +@node: The node where to start searching. +@data: User data for the criterion function. +@func: The criterion function. +@Returns: A list of all nodes found. + + + + + + +@ctree: +@x: +@y: +@Returns: True if the given coordinates lie on an expander button. + + + + +Move a node in the tree to another location. + + +@ctree: +@node: The node to be moved. +@new_parent: The new parent-to-be of the node. +@new_sibling: The new sibling-to-be of the node. + + + + +Expand one node. + + +@ctree: +@node: + + + + +Expand one node and all nodes underneath. + + +@ctree: +@node: + + + + +Expand a node and its children up to the depth given. + + +@ctree: +@node: +@depth: The (absolute) depth up to which to expand nodes. + + + + +Collapse one node. + + +@ctree: +@node: + + + + +Collapse one node and all its subnodes. + + +@ctree: +@node: + + + + +Collapse a node and its children up to the depth given. + + +@ctree: +@node: +@depth: The (absolute) depth up to which to collapse nodes. + + + + +Toggle a node, i.e. if it is collapsed, expand it and vice versa. + + +@ctree: +@node: + + + + +Toggle the expansion of a node and all its children. + + +@ctree: +@node: + + + + +Cause the given node to be selected and emit the appropriate signal. + + +@ctree: +@node: + + + + +Cause the given node and its subnodes to be selected and emit the appropriate signal(s). + + +@ctree: +@node: + + + + +Unselect the given node and emit the appropriate signal. + + +@ctree: +@node: + + + + +Unselect the given node and its subnodes and emit the appropriate signal(s). + + +@ctree: +@node: + + + + +The function that implements both #gtk_ctree_select_recursive and +#gtk_ctree_unselect_recursive. + + +@ctree: +@node: +@state: True for selecting, false for unselecting. + + + + +Set the text in a node. + + +@ctree: +@node: +@column: The column whose text to change. +@text: The new text. + + + + +FIXME + + +@ctree: +@node: +@column: +@pixmap: +@mask: + + + + +FIXME + + +@ctree: +@node: +@column: +@text: +@spacing: +@pixmap: +@mask: + + + + +Change the information. Most parameters correspond +to the parameters of #gtk_ctree_insert_node. + + +@ctree: +@node: +@text: The text to be in the tree column. +@spacing: +@pixmap_closed: +@mask_closed: +@pixmap_opened: +@mask_opened: +@is_leaf: +@expanded: + + + + +Shift the given cell the given amounts in pixels. + + +@ctree: +@node: +@column: +@vertical: +@horizontal: + + + + + + + +@ctree: +@node: +@selectable: Whether this node can be selected by the user. + + + + + + + +@ctree: +@node: +@Returns: Whether this node can be selected by the user. + + + + + + + +@ctree: +@node: +@column: +@Returns: The type of the given cell. + + + + + + + +@ctree: +@node: +@column: +@text: If nonnull, the pointer to the text string is assigned to *@text. +@Returns: True if the given cell has text in it. + + + + + + + +@ctree: +@node: +@column: +@pixmap: If nonnull, the pointer to the pixmap is returned through this. +@mask: If nonnull, the pointer to the mask is returned through this. +@Returns: True if the given cell contains a pixmap. + + + + +Get the parameters of a cell containing both a pixmap and text. + + +@ctree: +@node: +@column: +@text: +@spacing: +@pixmap: +@mask: +@Returns: + + + + +Get information corresponding to a node. +Any of the return parameters can be null. + + +@ctree: +@node: +@text: +@spacing: +@pixmap_closed: +@mask_closed: +@pixmap_opened: +@mask_opened: +@is_leaf: +@expanded: +@Returns: + + + + +Set the style of a row. + + +@ctree: +@node: +@style: + + + + +Get the style of a row. + + +@ctree: +@node: +@Returns: + + + + +Set the style of an individual cell. + + +@ctree: +@node: +@column: +@style: + + + + +Get the style of an individual cell. + + +@ctree: +@node: +@column: +@Returns: + + + + + + + +@ctree: +@node: +@color: + + + + + + + +@ctree: +@node: +@color: + + + + +Set the custom data associated with a node. + + +@ctree: +@node: +@data: + + + + +This is the full interface to setting row data, so that a destructor +can be given for the data. + + +@ctree: +@node: +@data: +@destroy: The routine to be called when @data is no longer needed. + + + + + + + +@ctree: +@node: +@Returns: + + + + +This function makes the given column of the given node visible by +scrolling. + + +@ctree: +@node: The node to be made visible. +@column: The column to be made visible. +@row_align: Where in the window the row should appear. +@col_align: Where in the window the column should appear. + + + + + + + +@ctree: +@node: +@Returns: True if the node is currently inside the bounds of the window. +Note that this function can return true even if the node is not +viewable, if the node's ancestor is visible. + + + + + + + +@ctree: +@indent: The number of pixels to shift the levels of the tree. + + + + +The spacing between the tree graphic and the actual node content. + + +@ctree: +@spacing: + + + + + + + +@t: +@r: + + + + + + + +@ctree: +@line_style: + + + + + + + +@ctree: +@expander_style: + + + + +FIXME + + +@ctree: +@cmp_func: + + + + +Sort the children of a node. See #GtkCList for how to set the sorting +criteria etc. + + +@ctree: +@node: + + + + +Sort the descendants of a node. See #GtkCList for how to set the sorting +criteria etc. + + +@ctree: +@node: + + + + + + + +@ctree: +@row: +@Returns: The node corresponding to the @row th row. + + + + + + + +@ctree: +@show_stub: + + + + +Emitted when a row is selected. + + +@ctree: the object which received the signal. +@node: The node corresponding to the selected row. +@column: The column which was selected. + + + +Emitted when a node is unselected. + + +@ctree: the object which received the signal. +@node: The node corresponding to the selected row. +@column: + + + +Emitted when a node is expanded. + + +@ctree: the object which received the signal. +@node: + + + +Emitted when a node is collapsed. + + +@ctree: the object which received the signal. +@node: + + + +Emitted when a node is moved. + + +@ctree: the object which received the signal. +@node: The node that is moved. +@new_parent: The new parent of the node. +@new_sibling: The new sibling of the node. + + + +The row which has the focus is either collapsed or expanded +or toggled. + + +@ctree: the object which received the signal. +@expansion: What is being done. + + + +The number of columns in the tree. + + + + +The column in which the actual tree graphic appears. + + + + +The number of pixels to indent the tree levels. + + + + +The number of pixels between the tree and the columns. + + + + +FIXME + + + + +The style of the lines in the tree graphic. + + + + +The style of the expander buttons. + + diff --git a/docs/reference/gtk/tmpl/gtkcurve.sgml b/docs/reference/gtk/tmpl/gtkcurve.sgml new file mode 100644 index 0000000000..b8119415b4 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkcurve.sgml @@ -0,0 +1,109 @@ + +GtkCurve + + + + + + + + + + + + + + + + + + + +@graph: +@cursor_type: +@min_x: +@max_x: +@min_y: +@max_y: +@pixmap: +@curve_type: +@height: +@grab_point: +@last: +@num_points: +@point: +@num_ctlpoints: + + + + + + +@Returns: + + + + + + + +@curve: + + + + + + + +@curve: +@gamma: + + + + + + + +@curve: +@min_x: +@max_x: +@min_y: +@max_y: + + + + + + + +@curve: +@veclen: +@vector: + + + + + + + +@curve: +@veclen: +@vector: + + + + + + + +@curve: +@type: + + + + + + + +@curve: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkdata.sgml b/docs/reference/gtk/tmpl/gtkdata.sgml new file mode 100644 index 0000000000..2da64638d0 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkdata.sgml @@ -0,0 +1,30 @@ + +GtkData + + + + + + + + + + + + + + + + + + + +@object: + + + + + + +@data: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkdebug.sgml b/docs/reference/gtk/tmpl/gtkdebug.sgml new file mode 100644 index 0000000000..12195b2279 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkdebug.sgml @@ -0,0 +1,42 @@ + +Debugging + + + + + + + + + + + + + + + + + + + +@GTK_DEBUG_OBJECTS: +@GTK_DEBUG_MISC: +@GTK_DEBUG_SIGNALS: +@GTK_DEBUG_DND: +@GTK_DEBUG_PLUGSOCKET: + + + + + + + + + + + + +@type: +@action: + + diff --git a/docs/reference/gtk/tmpl/gtkdialog.sgml b/docs/reference/gtk/tmpl/gtkdialog.sgml new file mode 100644 index 0000000000..2ce5355409 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkdialog.sgml @@ -0,0 +1,122 @@ + +GtkDialog + + + +create popup windows. + + + +Dialog boxes are a convenient way to prompt the user for a small amount of +input, eg. to display +a message, ask a question, or anything else that does not require extensive +effort on the user's part. + + +Gtk+ treats a dialog as a window split horizontally. The top section is a +#GtkVBox, and is where widgets such as a #GtkLabel or a #GtkEntry should be +packed. The second area is known as the action_area. This is generally used +for packing buttons into the dialog which may perform functions such as cancel, ok, or apply. The two +areas are separated by a #GtkHSeparator. + + +#GtkDialog boxes are created with a call to gtk_dialog_new(). + + +If 'dialog' is a newly created dialog, the two primary areas of the window +can be accessed as GTK_DIALOG(dialog)->vbox and GTK_DIALOG(dialog)->action_area, +as can be seen from the example, below. + + +A 'modal' dialog (that is, one which freezes the rest of the application +from user input), can be created by calling gtk_window_set_modal() on the dialog. Use the +GTK_WINDOW() macro to cast the widget returned from gtk_dialog_new() into a +#GtkWindow. + + + +Using a #GtkDialog to keep the user informed. + + +/* Function to open a dialog box displaying the message provided. */ + +void quick_message(#gchar *message) { + + #GtkWidget *dialog, *label, *okay_button; + + /* Create the widgets */ + + dialog = gtk_dialog_new(); + label = gtk_label_new (message); + okay_button = gtk_button_new_with_label("Okay"); + + /* Ensure that the dialog box is destroyed when the user clicks ok. */ + + gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked", + GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog); + gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area), + okay_button); + + /* Add the label, and show everything we've added to the dialog. */ + + gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), + label); + gtk_widget_show_all (dialog); +} + + + + + + + + + + +#GtkVBox +Pack widgets vertically. + + +#GtkWindow +Alter the properties of your dialog box. + + +#GtkButton +Add them to the action_area to get a +response from the user. + + + + + + +window is a #GtkWindow, but should not be +modified directly, (use the functions provided, such as +gtk_window_set_title(). See the #GtkWindow section for more). + + +vbox is a #GtkVBox - the main part of the dialog box. + + +action_area is a #GtkHBox packed below the dividing #GtkHSeparator in the dialog. It is treated exactly the same as any other #GtkHBox. + + +@window: +@vbox: +@action_area: + + + +Deprecated. + + + + + +Creates a new dialog box. Widgets should not be packed into this #GtkWindow +directly, but into the vbox and action_area, as described above. + + +@Returns: a #GtkWidget - the newly created dialog box. + + diff --git a/docs/reference/gtk/tmpl/gtkdnd.sgml b/docs/reference/gtk/tmpl/gtkdnd.sgml new file mode 100644 index 0000000000..cf93b8f5f3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkdnd.sgml @@ -0,0 +1,344 @@ + +Drag and Drop + + +Functions for controlling drag and drop handling. + + + +GTK+ has a rich set of functions for doing inter-process +communication via the drag-and-drop metaphore. GTK+ +can do drag and drop (DND) via multiple protocols. +The currently supported protocols are the Xdnd and +Motif protocols. + +As well as the functions listed here, applications +may need to use some facilities provided for +Selections. +Also, the Drag and Drop API makes use of signals +in the #GtkWidget class. + + + + + + + + + +The #GtkDestfaults enumeration specifies the various +types of action that will be taken on behalf +of the user for a drag destination site. + + + + + + +GTK_DEST_DEFAULT_MOTION + + If set for a widget, GTK+, during a drag over this + widget will check if the drag matches this widget's + list of possible targets and actions. + GTK+ will then call gtk_drag_status() as appropriate. + + + + +GTK_DEST_DEFAULT_HIGHLIGHT + + If set for a widget, GTK+ will draw a highlight on + this widget as long as a drag is over this widget + and the wiget drag format and action is accetable. + + + +GTK_DEST_DEFAULT_DROP + + If set for a widget, when a drop occurs, GTK+ will + will check if the drag matches this widget's + list of possible targets and actions. If so, + GTK+ will call gtk_drag_data_get() on behalf + of the widget. Whether or not the drop is succesful, + GTK+ will call gtk_drag_finish(). If the action + was a move, then if the drag was succesful, then + %TRUE will be passed for the @delete parameter + to gtk_drag_finish(). + + + + +GTK_DEST_DEFAULT_ALL + + If set, specifies that all default actions should + be taken. + + + + + +@GTK_DEST_DEFAULT_MOTION: +@GTK_DEST_DEFAULT_HIGHLIGHT: +@GTK_DEST_DEFAULT_DROP: +@GTK_DEST_DEFAULT_ALL: + + + +The #GtkTargetFlags enumeration is used to specifies +constraints on an entry in a GtkTargetTable. + + %GTK_TARGET_SAME_APP + + + If this is set, the target will only be selected + for drags within a single application. + + + + %GTK_TARGET_SAME_WIDGET + + + If this is set, the target will only be selected + for drags within a single widget. + + + + + +@GTK_TARGET_SAME_APP: +@GTK_TARGET_SAME_WIDGET: + + + +Set a widget as a potential drop destination. + + +@widget: a widget +@flags: the flags that specify what actions GTK+ should take + on behalf of a widget for drops onto that widget. The @targets + and @actions fields only are used if %GTK_DEST_DEFAULT_MOTION + or %GTK_DEST_DEFAULT_DROP are given. +@targets: a pointer to an array of #GtkTargetEntry indicating + the drop types that this widget will accept. +@n_targets: the number of entries in @targets. +@actions: a bitmask of possible actions for a drop onto this + widget. + + + + +Set this widget as a proxy for drops to another window. + + +@widget: a #GtkWidget +@proxy_window: the window to which to forward drag events +@protocol: the drag protocol which the @proxy_window accepts + (You can use gdk_drag_get_protocol() to determine this) +@use_coordinates: If true, send the same coordinates to the + destination, because it is a embedded + subwindow. + + + + +Clear information about a drop destination set with +gtk_drag_dest_set(). The widget will no longer receive +notification of drags. + + +@widget: a #GtkWidget + + + + +Inform the drag source that the drop is finished, and +that the data of the drag will no longer be required. + + +@context: the drag context. +@success: a flag indicating whether the drop was succesful +@del: a flag indicating whether the source should delete the + original data. (This should be %TRUE for a move) +@time: the timestamp from the "drag_data_drop" signal. + + + + +Get the data associated with a drag. When the data +is received or the retrieval fails, GTK+ will emit a +"drag_data_received" signal. Failure of the retrieval +is indicated by the length field of the @selection_data +signal parameter being negative. However, when gtk_drag_get_data() +is called implicitely because the %GTK_DRAG_DEFAULT_DROP was set, +then the widget will not receive notification of failed +drops. + + +@widget: the widget that will receive the "drag_data_received" + signal. +@context: the drag context +@target: the target (form of the data) to retrieve. +@time: a timestamp for retrieving the data. This will + generally be the time received in a "drag_data_motion" + or "drag_data_drop" signal. + + + + +Determine the source widget for a drag. + + +@context: a (destination side) drag context. +@Returns: if the drag is occurring within a single application, + a pointer to the source widget. Otherwise, NULL. + + + + +Draw a highlight around a widget. This will attach +handlers to "expose_event" and "draw", so the highlight +will continue to be displayed until gtk_drag_unhighlight +is called. + + +@widget: a widget to highlight + + + + +Remove a highlight set by gtk_drag_highlight() from +a widget. +is called. + + +@widget: a widget to remove the highlight from. + + + + +Initiate a drag on the source side. The function +only needs to be used when the application is +starting drags itself, and is not needed when +gtk_drag_source_set() is used. + + +@widget: the source widget. +@targets: The targets (data formats) in which the + source can provide the data. +@actions: A bitmask of the allowed drag actions for this + drag. +@button: The button the user clicked to start the drag. +@event: The event that triggered the start of the + drag. Usually +@Returns: The context for this drag. + + + + +Change the icon for a widget to a given widget. GTK+ +will not destroy the icon, so if you don't want +it to persist, you should connect to the "drag_end" +signal and destroy it yourself. + + +@context: the context for a drag. (This must be called + with a context for the source side of a drag) +@widget: A toplevel window to use as an icon. +@hot_x: The X offset within @widget of the hotspot. +@hot_y: The Y offset within @widget of the hotspot. + + + + +Sets a given pixmap as the icon for a given drag. +GTK+ retains a reference count for the arguments, and +will release them when they are no longer needed. + + +@context: the context for a drag. (This must be called + with a context for the source side of a drag) +@colormap: the colormap of the icon +@pixmap: the image data for the icon +@mask: the transparency mask for an image. +@hot_x: The X offset within @widget of the hotspot. +@hot_y: The Y offset within @widget of the hotspot. + + + + +Set the icon for a particular drag to the default +icon. + + +@context: the context for a drag. (This must be called + with a context for the source side of a drag) + + + + +Change the default drag icon. GTK+ retains a reference count for the +arguments, and will release them when they are no longer needed. + + +@colormap: the colormap of the icon +@pixmap: the image data for the icon +@mask: the transparency mask for an image. +@hot_x: The X offset within @widget of the hotspot. +@hot_y: The Y offset within @widget of the hotspot. + + + + +Sets up a widget so that GTK+ will start a drag +operation when the user clicks and drags on the +widget. The widget must have a window. + + +@widget: a #GtkWidget +@start_button_mask: the bitmask of buttons that can start the drag +@targets: the table of targets that the drag will support +@n_targets: the number of items in @targets +@actions: the bitmask of possible actions for a drag from this + widget. + + + + +Sets the icon that will be used for drags from a +particular widget. GTK+ retains a reference count +for the arguments, and will release them when +they are no longer needed. + + +@widget: a #GtkWidget +@colormap: the colormap of the icon +@pixmap: the image data for the icon +@mask: the transparency mask for an image. + + + + +Undo the effects of gtk_drag_source_set(). + + +@widget: a #GtkWidget + + + + +Internal function. + + +@widget: +@event: + + + + +Internal function. + + +@toplevel: +@event: + + diff --git a/docs/reference/gtk/tmpl/gtkdrawingarea.sgml b/docs/reference/gtk/tmpl/gtkdrawingarea.sgml new file mode 100644 index 0000000000..b78eae267d --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkdrawingarea.sgml @@ -0,0 +1,111 @@ + +GtkDrawingArea + + +a widget for custom user interface elements. + + + +The #GtkDrawingArea widget is used for creating custom +user interface elements. After creating a drawing +area, the application may want to connect to: + + + + Mouse and button press signals to respond to input from + the user. + + + + + The "realize" signal to take any necessary actions + when the widget + + + + + The "size_allocate" signal to take any necessary actions + when the widget changes size. + + + + + The "expose_event" signal to handle redrawing the + contents of the widget. + + + +As a convenience, the #GtkDrawingArea widget synthesizes +a "configure_event" when the widget is realized +and any time the size of a widget changes when it +is realized. It often suffices to connect to this +signal instead of "realize" and "size_allocate". + + +The following code portion demonstrates using a drawing +area to implement a widget that draws a circle. +As this example demonstrates, an expose handler should +draw only the pixels within the requested area and +should draw or clear all these pixels. + + +gboolean +expose_event (GdkWidget *widget, GdkEventExpose *event, gpointer data) +{ + gdk_window_clear_area (widget->window, + event->area.x, event->area.y, + event->area.width, event->area.height); + gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state], + &event->area); + gdk_draw_arc (widget->window, + widget->style->fg_gc[widget->state], + TRUE, + 0, 0, widget->allocation->width, widget->allocation.height, + 0, 64 * 360); + gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state]); + + return TRUE; +} +[...] + GtkWidget *drawing_area = gdk_drawing_area_new (); + gdk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), + 100, 100); + gtk_signal_connect (GTK_OBJECT (drawing_area), + + + + + + + + + +The #GtkDrawingArea-struct struct contains private data only, and +should be accessed using the functions below. + + +@widget: +@draw_data: + + + +Create a new drawing area. + + +@Returns: + + + + +Set the size that the drawing area will request +in response to a "size_request" signal. The +drawing area may actually be allocated a size +larger than this depending on how it is packed +within the enclosing containers. + + +@darea: a #GtkDrawingArea. +@width: the width to request. +@height: the height to request. + + diff --git a/docs/reference/gtk/tmpl/gtkeditable.sgml b/docs/reference/gtk/tmpl/gtkeditable.sgml new file mode 100644 index 0000000000..f822b3bfe0 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkeditable.sgml @@ -0,0 +1,448 @@ + +GtkEditable + + +Base class for text-editing widgets. + + + +The #GtkEditable class is a base class for widgets +for editing text, such as #GtkEntry and #GtkText. It +cannot be instantiated by itself. The editable +class contains functions for generically manipulating +an editable widget, a large number of action signals +used for key bindings, and several signals that +an application can connect to to modify the behavior +of a widget. + + + +As an example of the latter usage, by connecting +the following handler to "insert_text", an application +can convert all entry into a widget into uppercase. + + + Forcing entry to uppercase + +#include <ctype.h> + +void +insert_text_handler (GtkEditable *editable, + const gchar *text, + gint length, + gint *position, + gpointer data) +{ + int i; + gchar *result = g_new (gchar, length); + + for (i=0; i<length; i++) + result[i] = islower(text[i]) ? toupper(text[i]) : text[i]; + + gtk_signal_handler_block_by_func (GTK_OBJECT (editable), + GTK_SIGNAL_FUNC (insert_text_handler), + data); + gtk_editable_insert_text (editable, result, length, position); + gtk_signal_handler_unblock_by_func (GTK_OBJECT (editable), + GTK_SIGNAL_FUNC (insert_text_handler), + data); + + gtk_signal_emit_stop_by_name (GTK_OBJECT (editable), "insert_text"); + + g_free (result); +} + + + + + + + + + + + +The #GtkEditable structure contains the following fields. +(These fields should be considered read-only. They should +never be set by an application.) + + + + + + +#guint selection_start; +the starting position of the selected characters + in the widget. + + + +#guint selection_end; +the end position of the selected characters + in the widget. + + + +#guint editable; +a flag indicating whether or not the widget is +editable by the user. + + + + + +@widget: +@current_pos: +@selection_start_pos: +@selection_end_pos: +@has_selection: +@editable: +@visible: +@ic: +@ic_attr: +@clipboard_text: + + + +Callback function for old method of setting key bindings. +No longer publically used. + + +@editable: +@time: + + + + +Selects a region of text. The characters that +are selected are those characters at positions from +@start_pos up to, but not including @end_pos. If +@end_pos is negative, then the the characters selected +will be those characters from @start_pos to the end +of the text. + + +@editable: a #GtkEditable widget. +@start: the starting position. +@end: the end position. + + + + +Insert text at a given position. + + +@editable: a #GtkEditable widget. +@new_text: the text to insert. +@new_text_length: the length of the text to insert, in bytes +@position: an inout parameter. The caller initializes it to + the position at which to insert the text. After the + call it points at the position after the newly + inserted text. + + + + +Delete a sequence of characters. The characters that +are deleted are those characters at positions from +@start_pos up to, but not including @end_pos. If +@end_pos is negative, then the the characters deleted +will be those characters from @start_pos to the end +of the text. + + +@editable: a #GtkEditable widget. +@start_pos: the starting position. +@end_pos: the end position. + + + + +Retrieves a sequence of characters. The characters that +are retrieved are those characters at positions from +@start_pos up to, but not including @end_pos. If +@end_pos is negative, then the the characters retrieved +will be those characters from @start_pos to the end +of the text. + + +@editable: a #GtkEditable widget. +@start_pos: the starting position. +@end_pos: the end position. +@Returns: the characters in the indicated region. + The result must be freed with g_free() when + the application is finished with it. + + + + +Causes the characters in the current selection to +be copied to the clipboard and then deleted from +the widget. + + +@editable: a #GtkEditable widget. + + + + +Causes the characters in the current selection to +be copied to the clipboard. + + +@editable: a #GtkEditable widget. + + + + +Causes the contents of the clipboard to be pasted into +the given widget at the current cursor position. + + +@editable: a #GtkEditable widget. + + + + +Claim or disclaim ownership of the PRIMARY X selection. + + +@editable: a #GtkEditable widget. +@claim: if %TRUE, claim the selection, otherwise, disclaim it. +@time: the timestamp for claiming the selection. + + + + +Deletes the current contents of the widgets selection and +disclaims the selection. + + +@editable: a #GtkEditable widget. + + + + +Causes the "changed" signal to be emitted. + + +@editable: a #GtkEditable widget. + + + + +Sets the cursor position. + + +@editable: a #GtkEditable widget. +@position: the position of the cursor. The cursor is displayed + before the character with the given (base 0) index + in the widget. The value must be less than or + equal to the number of characters in the widget. + A value of -1 indicates that the position should + be set after the last character in the entry. + Note that this position is in characters, not in + bytes. + + + + +Retrieves the current cursor position. + + +@editable: a #GtkEditable widget. +@Returns: the position of the cursor. The cursor is displayed + before the character with the given (base 0) index + in the widget. The value will be less than or + equal to the number of characters in the widget. + Note that this position is in characters, not in + bytes. + + + + +Determines if the user can edit the text in the editable +widget or not. + + +@editable: a #GtkEditable widget. +@is_editable: %TRUE if the user is allowed to edit the text + in the widget. + + + + +Indicates that the user has changed the contents +of the widget. + + +@editable: the object which received the signal. + + + +This signal is emitted when text is inserted into +the widget by the user. The default handler for +this signal will normally be responsible for inserting +the text, so by connecting to this signal and then +stopping the signal with gtk_signal_emit_stop(), it +is possible to modify the inserted text, or prevent +it from being inserted entirely. + + +@editable: the object which received the signal. +@new_text: the new text to insert. +@new_text_length: the length of the new text. +@position: the position at which to insert the new text. + this is an in-out paramter. After the signal + emission is finished, it should point after + the newly inserted text. + + + +This signal is emitted when text is deleted from +the widget by the user. The default handler for +this signal will normally be responsible for inserting +the text, so by connecting to this signal and then +stopping the signal with gtk_signal_emit_stop(), it +is possible to modify the inserted text, or prevent +it from being inserted entirely. The @start_pos +and @end_pos parameters are interpreted as for +gtk_editable_delete_text() + + +@editable: the object which received the signal. +@start_pos: the starting position. +@end_pos: the end position. + + + +Indicates that the user has activated the widget +in some fashion. Generally, this will be done +with a keystroke. (The default binding for this +action is Return for #GtkEntry and +Control-Return for #GtkText.) + + +@editable: the object which received the signal. + + + +Determines if the user can edit the text in the editable +widget or not. This is meant to be overriden by +child classes and should not generally useful to +applications. + + +@editable: the object which received the signal. +@is_editable: %TRUE if the user is allowed to edit the text + in the widget. + + + +An action signal. Move the cursor position. + + +@editable: the object which received the signal. +@x: horizontal distance to move the cursor. +@y: vertical distance to move the cursor. + + + +An action signal. Move the cursor by words. + + +@editable: the object which received the signal. +@num_words: The number of words to move the +cursor. (Can be negative). + + + +An action signal. Move the cursor by pages. + + +@editable: the object which received the signal. +@x: Number of pages to move the cursor horizontally. +@y: Number of pages to move the cursor vertically. + + + +An action signal. Move the cursor to the given row. + + +@editable: the object which received the signal. +@row: the row to move to. (A negative value indicates + the last row) + + + +An action signal. Move the cursor to the given column. + + +@editable: the object which received the signal. +@column: the column to move to. (A negative value indicates + the last column) + + + +An action signal. Delete a single character. + + +@editable: the object which received the signal. +@direction: the direction in which to delete. Positive + indicates forward deletion, negative, backwards deletion. + + + +An action signal. Delete a single word. + + +@editable: the object which received the signal. +@direction: the direction in which to delete. Positive + indicates forward deletion, negative, backwards deletion. + + + +An action signal. Delete a single line. + + +@editable: the object which received the signal. +@direction: the direction in which to delete. Positive + indicates forward deletion, negative, backwards deletion. + + + +An action signal. Causes the characters in the current +selection to be copied to the clipboard and then deleted from +the widget. + + +@editable: the object which received the signal. + + + +An action signal. Causes the characters in the current selection to +be copied to the clipboard. + + +@editable: the object which received the signal. + + + +An action signal. Causes the contents of the clipboard to +be pasted into the editable widget at the current cursor +position. + + +@editable: the object which received the signal. + + + +The position of the cursor. + + + + +A boolean indicating whether the widget is editable by +the user. + + diff --git a/docs/reference/gtk/tmpl/gtkentry.sgml b/docs/reference/gtk/tmpl/gtkentry.sgml new file mode 100644 index 0000000000..0552539a33 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkentry.sgml @@ -0,0 +1,201 @@ + +GtkEntry + + +a single line text entry field. + + + +The #GtkEntry widget is a single line text entry +widget. A fairly large set of key bindings are supported +by default. If the entered text is longer than the allocation +of the widget, the widget will scroll so that the cursor +position is visible. + + + + + + + +#GtkText +a widget for handling multi-line text entry. + + + + + + + +The #GtkEntry-struct struct contains only private data. + + +@editable: +@text_area: +@backing_pixmap: +@cursor: +@text: +@text_size: +@text_length: +@text_max_length: +@scroll_offset: +@visible: +@timer: +@button: +@char_offset: +@text_mb: +@text_mb_dirty: +@use_wchar: + + + +Creates a new #GtkEntry widget. + + +@Returns: a new #GtkEntry. + + + + +Creates a new #GtkEntry widget with the given maximum +length. + + +Note: the existance of this function is inconsistent +with the rest of the GTK+ API. The normal setup would +be to just require the user to make an extra call +to gtk_entry_set_max_length() instead. It is not +expected that this function will be removed, but +it would be better practice not to use it. + + +@max: the new maximum length. +@Returns: a new #GtkEntry. + + + + +Sets the text in the widget to the given +value, replacing the current contents. + + +@entry: a #GtkEntry. +@text: the new text. + + + + +Appends the given text to the contents of the widget. + + +@entry: a #GtkEntry. +@text: the text to append. + + + + +Prepends the given text to the contents of th ewidget. + + +@entry: a #GtkEntry. +@text: the text to prepend. + + + + +Sets the cursor position in an entry to the given +value. This function is obsolete. You should use +gtk_editable_set_position() instead. + + +@entry: a #GtkEntry. +@position: the position of the cursor. The cursor is displayed + before the character with the given (base 0) index + in the widget. The value must be less than or + equal to the number of characters in the widget. + A value of -1 indicates that the position should + be set after the last character in the entry. + Note that this position is in characters, not in + bytes. + + + + +Retrieve the contents of the entry widget. The returned +pointer points to internally allocated storage in the +widget and must not be freed, modified or stored. For +this reason, this function is deprecated. Use +gtk_editable_get_chars() instead. + + +@entry: a #GtkEntry. +@Returns: the pointer the the contents of the text widget as a + string. + + + + +Selects a region of text. The characters that +are selected are those characters at positions from +@start_pos up to, but not including @end_pos. If +@end_pos is negative, then the the characters selected +will be those characters from @start_pos to the end +of the text. This function is obsolete. You should +use gtk_editable_select_region() instead. + + +@entry: a #GtkEntry. +@start: the starting position. +@end: the end position. + + + + +Sets whether the contents of the entry are visible or +not. When visibility is set to %FALSE, characters +are displayed as asterisks (*'s), and will also appear +that way when the text in the entry widget is copied +elsewhere. + + +@entry: a #GtkEntry. +@visible: %TRUE if the contents of the entry are displayd + as plaintext. + + + + +Determines if the user can edit the text in the editable +widget or not. This function is obsolete. You should +use gtk_editable_set_editable() instead. + + +@entry: a #GtkEntry. +@editable: %TRUE if the user is allowed to edit the text + in the widget. + + + + +Sets the maximum allowed length of the contents +of the widget. If the current contents are longer +than the given length, then they will be truncated +to fit. + + +@entry: a #GtkEntry. +@max: the new maximum length. + + + + +Determines the maximum allowed length of the contents +of the widget. See gtk_entry_set_max_length(). + + + + +Determines whether the contents of the entry widget +are visible or not. See gtk_entry_set_visibility(). + + diff --git a/docs/reference/gtk/tmpl/gtkenums.sgml b/docs/reference/gtk/tmpl/gtkenums.sgml new file mode 100644 index 0000000000..5b8b1ede8f --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkenums.sgml @@ -0,0 +1,361 @@ + +Standard Enumerations + + + + + + + + + + + + + + + + + + + +@GTK_ACCEL_VISIBLE: +@GTK_ACCEL_SIGNAL_VISIBLE: +@GTK_ACCEL_LOCKED: +@GTK_ACCEL_MASK: + + + + + + +@GTK_ARROW_UP: +@GTK_ARROW_DOWN: +@GTK_ARROW_LEFT: +@GTK_ARROW_RIGHT: + + + + + + +@GTK_EXPAND: +@GTK_SHRINK: +@GTK_FILL: + + + + + + +@GTK_BUTTONBOX_DEFAULT_STYLE: +@GTK_BUTTONBOX_SPREAD: +@GTK_BUTTONBOX_EDGE: +@GTK_BUTTONBOX_START: +@GTK_BUTTONBOX_END: + + + + + + +@GTK_CORNER_TOP_LEFT: +@GTK_CORNER_BOTTOM_LEFT: +@GTK_CORNER_TOP_RIGHT: +@GTK_CORNER_BOTTOM_RIGHT: + + + + + + +@GTK_CURVE_TYPE_LINEAR: +@GTK_CURVE_TYPE_SPLINE: +@GTK_CURVE_TYPE_FREE: + + + + + + +@GTK_DIR_TAB_FORWARD: +@GTK_DIR_TAB_BACKWARD: +@GTK_DIR_UP: +@GTK_DIR_DOWN: +@GTK_DIR_LEFT: +@GTK_DIR_RIGHT: + + + + + + +@GTK_JUSTIFY_LEFT: +@GTK_JUSTIFY_RIGHT: +@GTK_JUSTIFY_CENTER: +@GTK_JUSTIFY_FILL: + + + + + + +@GTK_MATCH_ALL: +@GTK_MATCH_ALL_TAIL: +@GTK_MATCH_HEAD: +@GTK_MATCH_TAIL: +@GTK_MATCH_EXACT: +@GTK_MATCH_LAST: + + + + + + +@GTK_MENU_FACTORY_MENU: +@GTK_MENU_FACTORY_MENU_BAR: +@GTK_MENU_FACTORY_OPTION_MENU: + + + + + + +@GTK_PIXELS: +@GTK_INCHES: +@GTK_CENTIMETERS: + + + + + + +@GTK_ORIENTATION_HORIZONTAL: +@GTK_ORIENTATION_VERTICAL: + + + + + + +@GTK_PACK_START: +@GTK_PACK_END: + + + + + + +@GTK_PATH_PRIO_LOWEST: +@GTK_PATH_PRIO_GTK: +@GTK_PATH_PRIO_APPLICATION: +@GTK_PATH_PRIO_RC: +@GTK_PATH_PRIO_HIGHEST: +@GTK_PATH_PRIO_MASK: + + + + + + +@GTK_PATH_WIDGET: +@GTK_PATH_WIDGET_CLASS: +@GTK_PATH_CLASS: + + + + + + +@GTK_POLICY_ALWAYS: +@GTK_POLICY_AUTOMATIC: +@GTK_POLICY_NEVER: + + + + + + +@GTK_POS_LEFT: +@GTK_POS_RIGHT: +@GTK_POS_TOP: +@GTK_POS_BOTTOM: + + + +An enumeration which describes whether a preview +contains grayscale or red-green-blue data. + + + + + + +GTK_PREVIEW_COLOR +the preview contains red-green-blue data. + + + +GTK_PREVIEW_GRAYSCALE +The preview contains grayscale data. + + + + + +@GTK_PREVIEW_COLOR: +@GTK_PREVIEW_GRAYSCALE: + + + + + + +@GTK_RELIEF_NORMAL: +@GTK_RELIEF_HALF: +@GTK_RELIEF_NONE: + + + + + + +@GTK_RESIZE_PARENT: +@GTK_RESIZE_QUEUE: +@GTK_RESIZE_IMMEDIATE: + + + + + + +@GTK_RUN_FIRST: +@GTK_RUN_LAST: +@GTK_RUN_BOTH: +@GTK_RUN_NO_RECURSE: +@GTK_RUN_ACTION: +@GTK_RUN_NO_HOOKS: + + + + + + +@GTK_SCROLL_NONE: +@GTK_SCROLL_STEP_BACKWARD: +@GTK_SCROLL_STEP_FORWARD: +@GTK_SCROLL_PAGE_BACKWARD: +@GTK_SCROLL_PAGE_FORWARD: +@GTK_SCROLL_JUMP: + + + + + + +@GTK_SELECTION_SINGLE: +@GTK_SELECTION_BROWSE: +@GTK_SELECTION_MULTIPLE: +@GTK_SELECTION_EXTENDED: + + + + + + +@GTK_SHADOW_NONE: +@GTK_SHADOW_IN: +@GTK_SHADOW_OUT: +@GTK_SHADOW_ETCHED_IN: +@GTK_SHADOW_ETCHED_OUT: + + + + + + +@GTK_STATE_NORMAL: +@GTK_STATE_ACTIVE: +@GTK_STATE_PRELIGHT: +@GTK_STATE_SELECTED: +@GTK_STATE_INSENSITIVE: + + + + + + +@GTK_DIRECTION_LEFT: +@GTK_DIRECTION_RIGHT: + + + + + + +@GTK_TOP_BOTTOM: +@GTK_LEFT_RIGHT: + + + + + + +@GTK_TOOLBAR_ICONS: +@GTK_TOOLBAR_TEXT: +@GTK_TOOLBAR_BOTH: + + + + + + +@GTK_TROUGH_NONE: +@GTK_TROUGH_START: +@GTK_TROUGH_END: +@GTK_TROUGH_JUMP: + + + + + + +@GTK_UPDATE_CONTINUOUS: +@GTK_UPDATE_DISCONTINUOUS: +@GTK_UPDATE_DELAYED: + + + + + + +@GTK_VISIBILITY_NONE: +@GTK_VISIBILITY_PARTIAL: +@GTK_VISIBILITY_FULL: + + + + + + +@GTK_WIN_POS_NONE: +@GTK_WIN_POS_CENTER: +@GTK_WIN_POS_MOUSE: + + + + + + +@GTK_WINDOW_TOPLEVEL: +@GTK_WINDOW_DIALOG: +@GTK_WINDOW_POPUP: + + + + + + +@GTK_SORT_ASCENDING: +@GTK_SORT_DESCENDING: + diff --git a/docs/reference/gtk/tmpl/gtkeventbox.sgml b/docs/reference/gtk/tmpl/gtkeventbox.sgml new file mode 100644 index 0000000000..463a9f9963 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkeventbox.sgml @@ -0,0 +1,34 @@ + +GtkEventBox + + +a widget used to catch events for widgets which do not have their own window. + + + +The #GtkEventBox widget is a subclass of #GtkBin which also has its own window. +It is useful since it allows you to catch events for widgets which do not +have their own window. + + + + + + + + + +The #GtkEventBox-struct struct contains private data only, and +should be accessed using the functions below. + + +@bin: + + + +Creates a new #GtkEventBox. + + +@Returns: a new #GtkEventBox. + + diff --git a/docs/reference/gtk/tmpl/gtkfeatures.sgml b/docs/reference/gtk/tmpl/gtkfeatures.sgml new file mode 100644 index 0000000000..bf85207886 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkfeatures.sgml @@ -0,0 +1,57 @@ + +Feature Test Macros + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +@required_major: +@required_minor: +@required_micro: +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkfilesel.sgml b/docs/reference/gtk/tmpl/gtkfilesel.sgml new file mode 100644 index 0000000000..6a36d803b2 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkfilesel.sgml @@ -0,0 +1,188 @@ + +GtkFileSelection + + +prompt the user for a file or directory name. + + + +GtkFileSelection should be used to retrieve file or directory names from the user. It will create a new dialog window containing a directory list, and a file list corresponding to the current working directory. The filesystem can be navigated using the directory list or the drop-down history menu. Alternatively, the TAB key can be used to navigate using filename completion - common in text based editors such as emacs and jed. + + +File selection dialogs are created with a call to gtk_file_selection_new(). + + +The default filename can be set using gtk_file_selection_set_filename() and the selected filename retrieved using gtk_file_selection_get_filename(). + + +Use gtk_file_selection_complete() to display files that match a given pattern. This can be used for example, to show only *.txt files, or only files beginning with gtk*. + + +Simple file operations; create directory, delete file, and rename file, are available from buttons at the top of the dialog. These can be hidden using gtk_file_selection_hide_fileop_buttons() and shown again using gtk_file_selection_show_fileop_buttons(). + + + +Getting a filename from the user + + +/* The file selection widget and the string to store the chosen filename */ + +GtkWidget *file_selector; +gchar *selected_filename; + +void store_filename(GtkFileSelection *selector, gpointer user_data) { + selected_filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION(file_selector)); +} + +void create_file_selection(void) { + + /* Create the selector */ + + file_selector = gtk_file_selection_new("Please select a file for editing."); + + gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(file_selector)->ok_button)), + "clicked", GTK_SIGNAL_FUNC (store_filename), NULL); + + /* Ensure that the dialog box is destroyed when the user clicks a button. */ + + gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(file_selector)->ok_button)), + "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), + (gpointer) file_selector); + + gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(file_selector)->cancel_button)), + "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), + (gpointer) file_selector); + + /* Display that dialog */ + + gtk_widget_show (file_selector); +} + + + + + + + + + + +#GtkDialog +Add your own widgets into the #GtkFileSelection. + + + + + + +The #GtkFileSelection struct contains the following #GtkWidget fields: + + + + + + +*fileop_dialog; +the dialog box used to display the #GtkFileSelection. It can be customized by adding/removing widgets from it using the standard #GtkDialog functions. + + + +*dir_list, *file_list; +the two #GtkCList widgets corresponding to directories and files. + + + +*ok_button, *cancel_button; +the two main buttons that signals should be connected to in order to perform an action when the user hits either OK or Cancel. + + + +*history_pulldown; +the #GtkOptionMenu used to create the drop-down directory history. + + + +*fileop_c_dir, *fileop_del_file, *fileop_ren_file; +the buttons that appear at the top of the file selection dialog. These "operation buttons" can be hidden and redisplayed with gtk_file_selection_hide_fileop_buttons() and gtk_file_selection_show_fileop_buttons() respectively. + + + + + + +@window: +@dir_list: +@file_list: +@selection_entry: +@selection_text: +@main_vbox: +@ok_button: +@cancel_button: +@help_button: +@history_pulldown: +@history_menu: +@history_list: +@fileop_dialog: +@fileop_entry: +@fileop_file: +@cmpl_state: +@fileop_c_dir: +@fileop_del_file: +@fileop_ren_file: +@button_area: +@action_area: + + + +Creates a new file selection dialog box. By default it will contain a #GtkCList of the application's current working directory, and a file listing. Operation buttons that allow the user to create a directory, delete files and rename files, are also present. + + +@title: a message that will be placed in the file requestor's titlebar. +@Returns: the new file selection. + + + + +Sets a default path for the file requestor. If @filename includes a directory path, then the requestor will open with that path as its current working directory. + + + +@filesel: a #GtkFileSelection. +@filename: a string to set as the default file name. + + + + +Retrieves the currently selected filename from the file selection dialog. If no file is selected then the selected directory path is returned. + + +@filesel: a #GtkFileSelection +@Returns: a string containing the selected file's full path. + + + + +Will attempt to match @pattern to a valid filename in the current directory. If a match can be made, the matched filename will appear in the text entry field of the file selection dialog. +If a partial match can be made, the "Files" list will contain those file names which have been partially matched. + + +@filesel: a #GtkFileSelection. +@pattern: a string of characters which may or may not match any filenames in the current directory. + + + + +Shows the file operation buttons, if they have previously been hidden. The rest of the widgets in the dialog will be resized accordingly. + + +@filesel: a #GtkFileSelection. + + + + +Hides the file operation buttons that normally appear at the top of the dialog. Useful if you wish to create a custom file selector, based on #GtkFileSelection. + + +@filesel: a #GtkFileSelection. + + diff --git a/docs/reference/gtk/tmpl/gtkfixed.sgml b/docs/reference/gtk/tmpl/gtkfixed.sgml new file mode 100644 index 0000000000..20f6c085a9 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkfixed.sgml @@ -0,0 +1,104 @@ + +GtkFixed + + +a container which supports fixed sizes and positions of its children. + + + +The #GtkFixed widget is a container which can place child widgets at fixed +positions and with fixed sizes, given in pixels. + + + + + + + + + + +The #GtkFixed-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#GList *children; +a list of #GtkFixedChild elements, containing the child widgets and +their positions. + + + + + +@container: +@children: + + + +The #GtkFixedChild-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#GtkWidget *widget; +the child #GtkWidget. + + + +#gint16 x; +the horizontal position of the widget within the #GtkFixed +container. + + + +#gint16 y; +the vertical position of the widget within the #GtkFixed +container. + + + + + +@widget: +@x: +@y: + + + +Creates a new #GtkFixed. + + +@Returns: a new #GtkFixed. + + + + +Adds a widget to a #GtkFixed container at the given position. + + +@fixed: a #GtkFixed. +@widget: the widget to add. +@x: the horizontal position to place the widget at. +@y: the vertical position to place the widget at. + + + + +Moves a child of a #GtkFixed container to the given position. + + +@fixed: a #GtkFixed. +@widget: the child widget. +@x: the horizontal position to move the widget to. +@y: the vertical position to move the widget to. + + diff --git a/docs/reference/gtk/tmpl/gtkfontsel.sgml b/docs/reference/gtk/tmpl/gtkfontsel.sgml new file mode 100644 index 0000000000..caf3f88471 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkfontsel.sgml @@ -0,0 +1,165 @@ + +GtkFontSelection + + +a widget for selecting fonts. + + + +The #GtkFontSelection widget lists the available fonts, styles and sizes, +allowing the user to select a font. +It is used in the #GtkFontSelectionDialog widget to provide a dialog box for +selecting fonts. + + +To set the font which is initially selected, use +gtk_font_selection_set_font_name(). + + +To get the selected font use gtk_font_selection_get_font() +or gtk_font_selection_get_font_name(). + + +To change the text which is shown in the preview area, use +gtk_font_selection_set_preview_text(). + + +Filters can be used to limit the fonts shown. There are 2 filters in the +#GtkFontSelection - a base filter and a user filter. The base filter +can not be changed by the user, so this can be used when the user must choose +from the restricted set of fonts (e.g. for a terminal-type application you may +want to force the user to select a fixed-width font). The user filter can be +changed or reset by the user, by using the 'Reset Filter' button or changing +the options on the 'Filter' page of the widget. + + + + + + + +#GtkFontSelectionDialog +a dialog box which uses #GtkFontSelection. + + + + + + + +The #GtkFontSelection struct contains private data only, and should +only be accessed using the functions below. + + +@notebook: +@main_vbox: +@font_label: +@font_entry: +@font_clist: +@font_style_entry: +@font_style_clist: +@size_entry: +@size_clist: +@pixels_button: +@points_button: +@filter_button: +@preview_entry: +@message_label: +@info_vbox: +@info_clist: +@requested_font_name: +@actual_font_name: +@filter_vbox: +@type_bitmaps_button: +@type_scalable_button: +@type_scaled_bitmaps_button: +@filter_clists: +@font: +@font_index: +@style: +@metric: +@size: +@selected_size: +@property_values: +@filters: + + + +Creates a new #GtkFontSelection. + + +@Returns: a new #GtkFontSelection. + + + + +Gets the currently-selected font. + + +@fontsel: a #GtkFontSelection. +@Returns: the currently-selected font, or NULL if no font is selected. + + + + +Gets the currently-selected font name. + + +@fontsel: a #GtkFontSelection. +@Returns: + + + + +Sets the currently-selected font. + + +@fontsel: a #GtkFontSelection. +@fontname: a fontname. +@Returns: TRUE if the font was found. + + + + +Gets the text displayed in the preview area. + + +@fontsel: a #GtkFontSelection. +@Returns: the text displayed in the preview area. + + + + +Sets the text displayed in the preview area. + + +@fontsel: a #GtkFontSelection. +@text: the text to display in the preview area. + + + + +Sets one of the two font filters, to limit the fonts shown. + + +@fontsel: a #GtkFontSelection. +@filter_type: which of the two font filters to set, either +#GTK_FONT_FILTER_BASE or #GTK_FONT_FILTER_USER. The user filter +can be changed by the user, but the base filter is permanent. +@font_type: the types of font to be shown. This is a bitwise combination of +#GTK_FONT_BITMAP, #GTK_FONT_SCALABLE and #GTK_FONT_SCALABLE_BITMAP, +or #GTK_FONT_ALL to show all three font types. +@foundries: a NULL-terminated array of strings containing foundry names which +will be shown, or NULL to show all foundries. +@weights: a NULL-terminated array of strings containing weight names which +will be shown, or NULL to show all weights. +@slants: a NULL-terminated array of strings containing slant names which +will be shown, or NULL to show all slants. +@setwidths: a NULL-terminated array of strings containing setwidth names which +will be shown, or NULL to show all setwidths. +@spacings: a NULL-terminated array of strings containing spacings which +will be shown, or NULL to show all spacings. +@charsets: a NULL-terminated array of strings containing charset names which +will be shown, or NULL to show all charsets. + + diff --git a/docs/reference/gtk/tmpl/gtkfontseldlg.sgml b/docs/reference/gtk/tmpl/gtkfontseldlg.sgml new file mode 100644 index 0000000000..8c32d89a27 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkfontseldlg.sgml @@ -0,0 +1,229 @@ + +GtkFontSelectionDialog + + +a dialog box for selecting fonts. + + + +The #GtkFontSelectionDialog widget is a dialog box for selecting a font. + + +To set the font which is initially selected, use +gtk_font_selection_dialog_set_font_name(). + + +To get the selected font use gtk_font_selection_dialog_get_font() +or gtk_font_selection_dialog_get_font_name(). + + +To change the text which is shown in the preview area, use +gtk_font_selection_dialog_set_preview_text(). + + +Filters can be used to limit the fonts shown. There are 2 filters in the +#GtkFontSelectionDialog - a base filter and a user filter. The base filter +can not be changed by the user, so this can be used when the user must choose +from the restricted set of fonts (e.g. for a terminal-type application you may +want to force the user to select a fixed-width font). The user filter can be +changed or reset by the user, by using the 'Reset Filter' button or changing +the options on the 'Filter' page of the dialog. + + + +Setting a filter to show only fixed-width fonts. + + gchar *spacings[] = { "c", "m", NULL }; + gtk_font_selection_dialog_set_filter (GTK_FONT_SELECTION_DIALOG (fontsel), + GTK_FONT_FILTER_BASE, GTK_FONT_ALL, + NULL, NULL, NULL, NULL, spacings, NULL); + + + + +To allow only true scalable fonts to be selected use: + + + +Setting a filter to show only true scalable fonts. + + gtk_font_selection_dialog_set_filter (GTK_FONT_SELECTION_DIALOG (fontsel), + GTK_FONT_FILTER_BASE, GTK_FONT_SCALABLE, + NULL, NULL, NULL, NULL, NULL, NULL); + + + + + + + + +#GtkFontSelection +the underlying widget for selecting fonts. + + + + + + + +The #GtkFontSelectionDialog struct contains private data only, and should +only be accessed using the functions below. + + +@window: +@fontsel: +@main_vbox: +@action_area: +@ok_button: +@apply_button: +@cancel_button: +@dialog_width: +@auto_resize: + + + +Creates a new #GtkFontSelectionDialog. + + +@title: the title of the dialog box. +@Returns: a new #GtkFontSelectionDialog. + + + + +Gets the currently-selected font. + + +@fsd: a #GtkFontSelectionDialog. +@Returns: the currently-selected font, or NULL if no font is selected. + + + + +Gets the currently-selected font name. + + +@fsd: a #GtkFontSelectionDialog. +@Returns: the currently-selected font name, or NULL if no font is selected. + + + + +Sets the currently-selected font. + + +@fsd: a #GtkFontSelectionDialog. +@fontname: a fontname. +@Returns: TRUE if the font was found. + + + + +Gets the text displayed in the preview area. + + +@fsd: a #GtkFontSelectionDialog. +@Returns: the text displayed in the preview area. + + + + +Sets the text displayed in the preview area. + + +@fsd: a #GtkFontSelectionDialog. +@text: the text to display in the preview area. + + + + +Sets one of the two font filters, to limit the fonts shown. + + +@fsd: a #GtkFontSelectionDialog. +@filter_type: which of the two font filters to set, either +#GTK_FONT_FILTER_BASE or #GTK_FONT_FILTER_USER. The user filter +can be changed by the user, but the base filter is permanent. +@font_type: the types of font to be shown. This is a bitwise combination of +#GTK_FONT_BITMAP, #GTK_FONT_SCALABLE and #GTK_FONT_SCALABLE_BITMAP, +or #GTK_FONT_ALL to show all three font types. +@foundries: a NULL-terminated array of strings containing foundry names which +will be shown, or NULL to show all foundries. +@weights: a NULL-terminated array of strings containing weight names which +will be shown, or NULL to show all weights. +@slants: a NULL-terminated array of strings containing slant names which +will be shown, or NULL to show all slants. +@setwidths: a NULL-terminated array of strings containing setwidth names which +will be shown, or NULL to show all setwidths. +@spacings: a NULL-terminated array of strings containing spacings which +will be shown, or NULL to show all spacings. +@charsets: a NULL-terminated array of strings containing charset names which +will be shown, or NULL to show all charsets. + + + + +A set of bit flags used to specify the type of fonts shown +when calling gtk_font_selection_dialog_set_filter() or +gtk_font_selection_set_filter(). + + + + + + +GTK_FONT_BITMAP +bitmap fonts. + + + +GTK_FONT_SCALABLE +scalable fonts. + + + +GTK_FONT_SCALED_BITMAP +scaled bitmap fonts. + + + +GTK_FONT_ALL +a bitwise combination of all of the above. + + + + + +@GTK_FONT_BITMAP: +@GTK_FONT_SCALABLE: +@GTK_FONT_SCALABLE_BITMAP: +@GTK_FONT_ALL: + + + +A set of bit flags used to specify the filter being set +when calling gtk_font_selection_dialog_set_filter() or +gtk_font_selection_set_filter(). + + + + + + +GTK_FONT_FILTER_BASE +the base filter, which can't be changed by the user. + + + +GTK_FONT_FILTER_USER +the user filter, which can be changed from within the 'Filter' page +of the #GtkFontSelection widget. + + + + + +@GTK_FONT_FILTER_BASE: +@GTK_FONT_FILTER_USER: + diff --git a/docs/reference/gtk/tmpl/gtkframe.sgml b/docs/reference/gtk/tmpl/gtkframe.sgml new file mode 100644 index 0000000000..492ceefc31 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkframe.sgml @@ -0,0 +1,96 @@ + +GtkFrame + + +A bin with a decorative frame and optional label. + + + +The frame widget is a Bin that surrounds its child +with a decorative frame and an optional label. +If present, the label is drawn in a gap in the +top side of the frame. The position of the +label can be controlled with gtk_frame_set_label_align(). + + + + + + + + + + + + +@bin: +@label: +@shadow_type: +@label_width: +@label_height: +@label_xalign: +@label_yalign: + + + +Create a new Frame, with optional label @label. +If @label is %NULL, the label is omitted. + + +@label: +@Returns: + + + + + +Set the text of the label. If @label is %NULL, +the current label, if any, is removed. + + +@frame: +@label: + + + + +Set the alignment of the Frame widget's label. The +default value for a newly created Frame is 0.0. + + +@frame: The Frame widget. +@xalign: The position of the label along the top edge + of the widget. A value of 0.0 represents left alignment; + 1.0 represents right alignment. +@yalign: The y alignment of the label. Currently ignored. + + + + +Set the shadow type for the Frame widget. + + +@frame: The Frame widget. +@type: New shadow type. + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkgamma.sgml b/docs/reference/gtk/tmpl/gtkgamma.sgml new file mode 100644 index 0000000000..114c74548a --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkgamma.sgml @@ -0,0 +1,37 @@ + +GtkGammaCurve + + + + + + + + + + + + + + + + + + + +@vbox: +@table: +@curve: +@button: +@gamma: +@gamma_dialog: +@gamma_text: + + + + + + +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkgc.sgml b/docs/reference/gtk/tmpl/gtkgc.sgml new file mode 100644 index 0000000000..e1cd99b423 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkgc.sgml @@ -0,0 +1,36 @@ + +Graphics Contexts + + + + + + + + + + + + + + + + + + + +@depth: +@colormap: +@values: +@values_mask: +@Returns: + + + + + + + +@gc: + + diff --git a/docs/reference/gtk/tmpl/gtkhandlebox.sgml b/docs/reference/gtk/tmpl/gtkhandlebox.sgml new file mode 100644 index 0000000000..fdc52202fd --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhandlebox.sgml @@ -0,0 +1,170 @@ + +GtkHandleBox + + +a widget for detachable window portions. + + + +The #GtkHandleBox widget allows a portion of a window to be "torn +off". It is a bin widget which displays its child and a handle that +the user can drag to tear off a separate window (the float +window) containing the child widget. A thin +ghost is drawn in the original location of the +handlebox. By dragging the separate window back to its original +location, it can be reattached. + + +When reattaching, the ghost and float window, must be aligned +along one of the edges, the snap edge. +This either can be specified by the application programmer +explicitely, or GTK+ will pick a reasonable default based +on the handle position. + + +To make detaching and reattaching the handlebox as minimally confusing +as possible to the user, it is important to set the snap edge so that +the snap edge does not move when the handlebox is deattached. For +instance, if the handlebox is packed at the bottom of a VBox, then +when the handlebox is detached, the bottom edge of the handlebox's +allocation will remain fixed as the height of the handlebox shrinks, +so the snap edge should be set to %GTK_POS_BOTTOM. + + + + + + + + + +The #GtkHandleBox-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +GtkShadowType shadow_type; +The shadow type for the entry. (See gtk_handle_box_set_shadow_type()). + + + +GtkPositionType handle_position; +The position of the handlebox's handle with respect +to the child. (See gtk_handle_box_set_handle_position()) + + + +gint snap_edge; +A value of type #GtkPosition type indicating snap edge for the widget. +(See gtk_handle_box_set_snap_edge). The value of -1 indicates +that this value has not been set. + + +#gboolean child_detached; +A boolean value indicating whether the handlebox's +child is attached or detached. + + + + + + + + +@bin: +@bin_window: +@float_window: +@shadow_type: +@handle_position: +@float_window_mapped: +@child_detached: +@in_drag: +@shrink_on_detach: +@snap_edge: +@deskoff_x: +@deskoff_y: +@attach_allocation: +@float_allocation: + + + +Create a new handle box. + + +@Returns: a new #GtkHandleBox. + + + + +Sets the type of shadow to be drawn around the border +of the + + +@handle_box: a #GtkHandleBox +@type: the shadow type. + + + + +Sets the side of the handlebox where the handle is drawn. + + +@handle_box: a #GtkHandleBox +@position: the side of the handlebox where the handle should be drawn. + + + + +Sets the snap edge of a handlebox. The snap edge is +the edge of the detached child that must be aligned +with the corresponding edge of the "ghost" left +behind when the child was detached to reattach +the torn-off window. Usually, the snap edge should +be chosen so that it stays in the same place on +the screen when the handlebox is torn off. + + +If the snap edge is not set, then an appropriate value +will be guessed from the handle position. If the +handle position is %GTK_POS_RIGHT or %GTK_POS_LEFT, +then the snap edge will be %GTK_POS_TOP, otherwise +it will be %GTK_POS_LEFT. + + +@handle_box: a #GtkHandleBox +@edge: the snap edge, or -1 to unset the value; in which +case GTK+ will try to guess an appropriate value +in the future. + + + + +This signal is emitted when the contents of the +handlebox are reattached to the main window. + + +@handlebox: the object which received the signal. +@widget: the child widget of the handlebox. + (this argument provides no extra information + and is here only for backwards-compatibility) + + + +This signal is emitted when the contents of the +handlebox are detached from the main window. + + +@handlebox: the object which received the signal. +@widget: the child widget of the handlebox. + (this argument provides no extra information + and is here only for backwards-compatibility) + + + +Determines the shadow type for the handlebox. + + diff --git a/docs/reference/gtk/tmpl/gtkhbbox.sgml b/docs/reference/gtk/tmpl/gtkhbbox.sgml new file mode 100644 index 0000000000..0a67e4445d --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhbbox.sgml @@ -0,0 +1,99 @@ + +GtkHButtonBox + + +a container for arranging button horizontally. + + + +A button box should be used to provide a consistent layout of buttons +throughout your application. There is one default layout and a default +spacing value that are persistant across all #HButtonBox widgets. + + +The layout/spacing can then be altered by the programmer, or if desired, by +the user to alter the 'feel' of a program to a small degree. + + +A #HButtonBox is created with gtk_hbutton_box_new(). Buttons are packed into +a button box the same way as any other box, using gtk_box_pack_start() or +gtk_box_pack_end(). + + +The default spacing between buttons can be set with +gtk_hbutton_box_set_spacing_default() and queried with +gtk_hbutton_box_get_spacing_default(). + + +The arrangement and layout of the buttons can be changed using +gtk_hbutton_box_set_layout_default() and queried with +gtk_hbutton_box_get_layout_default(). + + + + + + +#GtkBox +Used to pack widgets into button boxes. + +#GtkButtonBox +Provides functions for controlling button boxes. + + +#GtkVButtonBox +Pack buttons vertically + + + + + + +button_box is the #GtkHButtonBox widget itself and +should not be modified directly. + + +@button_box: + + + +Creates a new horizontal button box. + + +@Returns: a new button box #GtkWidget. + + + + +Retrieves the current default spacing for horizontal button boxes. This is the number of pixels +to be placed between the buttons when they are arranged. + + +@Returns: the default number of pixels between buttons. + + + + +Retrieves the current layout used to arrange buttons in button box widgets. + + +@Returns: the current #GtkButtonBoxStyle. + + + + +Changes the default spacing that is placed between widgets in an +horizontal button box. + + +@spacing: an integer value. + + + + +Sets a new layout mode that will be used by all button boxes. + + +@layout: a new #GtkButtonBoxStyle. + + diff --git a/docs/reference/gtk/tmpl/gtkhbox.sgml b/docs/reference/gtk/tmpl/gtkhbox.sgml new file mode 100644 index 0000000000..0fd5acff22 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhbox.sgml @@ -0,0 +1,47 @@ + +GtkHBox + + +horizontal container box + + + +GtkHBox is a container that organizes child widgets into a single row. + + + +Use the #GtkBox packing interface to determine the arrangement, +spacing, width, and alignment of GtkHBox children. + + + +All children are allocated the same height. + + + + + + + +#GtkVBox +a sister class that organizes widgets into a column. + + + + + + + + +@box: + + + +Creates a new GtkHBox. + + +@homogeneous: %TRUE if all children are to be given equal space allotments. +@spacing: the number of pixels to place by default between children. +@Returns: a new GtkHBox. + + diff --git a/docs/reference/gtk/tmpl/gtkhpaned.sgml b/docs/reference/gtk/tmpl/gtkhpaned.sgml new file mode 100644 index 0000000000..369a0beaf3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhpaned.sgml @@ -0,0 +1,33 @@ + +GtkHPaned + + +A container with two panes arranged horizontally. + + + +The HPaned widget is a container widget with two +children arranged horizontally. The division between +the two panes is adjustable by the user by dragging +a handle. See #GtkPaned for details. + + + + + + + + + + + +@paned: + + + +Create a new #GtkHPaned + + +@Returns: the new #GtkHPaned + + diff --git a/docs/reference/gtk/tmpl/gtkhruler.sgml b/docs/reference/gtk/tmpl/gtkhruler.sgml new file mode 100644 index 0000000000..21658d405b --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhruler.sgml @@ -0,0 +1,38 @@ + +GtkHRuler + + +A horizontal ruler. + + + +The HRuler widget is a widget arranged horizontally creating a ruler that is +utilized around other widgets such as a text widget. The ruler is used to show +the location of the mouse on the window and to show the size of the window in +specified units. The available units of measurement are GTK_PIXELS, GTK_INCHES +and GTK_CENTIMETERS. GTK_PIXELS is the default. +rulers. + + + + + + + + + + +The #GtkHRuler struct contains private data and should be accessed +with the functions below. + + +@ruler: + + + +Creates a new horizontal ruler. + + +@Returns: the new GTKHRuler. + + diff --git a/docs/reference/gtk/tmpl/gtkhscale.sgml b/docs/reference/gtk/tmpl/gtkhscale.sgml new file mode 100644 index 0000000000..9c9803d84b --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhscale.sgml @@ -0,0 +1,45 @@ + +GtkHScale + + +a horizontal slider widget for selecting a value from a range. + + + +The #GtkHScale widget is used to allow the user to select a value using +a horizontal slider. +A #GtkAdjustment is used to set the initial value, the lower +and upper bounds, and the step and page increments. + + +The position to show the current value, and the number of decimal places +shown can be set using the parent #GtkScale class's functions. + + + + + + + + + +The #GtkHScale-struct struct contains private data only, and +should be accessed using the functions below. + + +@scale: + + + +Creates a new #GtkHScale. + + +@adjustment: the #GtkAdjustment which sets the range of the scale. +@Returns: a new #GtkHScale. + + + + +the #GtkAdjustment which sets the range of the scale. + + diff --git a/docs/reference/gtk/tmpl/gtkhscrollbar.sgml b/docs/reference/gtk/tmpl/gtkhscrollbar.sgml new file mode 100644 index 0000000000..fa0a60b6a9 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhscrollbar.sgml @@ -0,0 +1,42 @@ + +GtkHScrollbar + + +A horizontal scrollbar + + + +The HScrollbar widget is a widget arranged horizontally creating a scroll +bar. See #GtkScrollbar for details on scrollbars. #GtkAdjustment pointers may be +added to handle the adjustment of the scrollbars or it may be left NULL in which +case one will be created you. See #GtkAdjustment for details. + + + + + + + + + + +The #GtkHScrollbar struct contains private data and should be accessed +unsing the functions below. + + +@scrollbar: + + + +Creates a new horizontal scrollbar. + + +@adjustment: +@Returns: the new GTKHScrollbar + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkhseparator.sgml b/docs/reference/gtk/tmpl/gtkhseparator.sgml new file mode 100644 index 0000000000..4c3dc810d3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkhseparator.sgml @@ -0,0 +1,31 @@ + +GtkHSeparator + + + + + + + + + + + + + + + + + + + +@separator: + + + + + + +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkimage.sgml b/docs/reference/gtk/tmpl/gtkimage.sgml new file mode 100644 index 0000000000..476f4ae10e --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkimage.sgml @@ -0,0 +1,55 @@ + +GtkImage + + + + + + + + + + + + + + + + + + + +@misc: +@image: +@mask: + + + + + + +@val: +@mask: +@Returns: + + + + + + + +@image: +@val: +@mask: + + + + + + + +@image: +@val: +@mask: + + diff --git a/docs/reference/gtk/tmpl/gtkinputdialog.sgml b/docs/reference/gtk/tmpl/gtkinputdialog.sgml new file mode 100644 index 0000000000..065889214a --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkinputdialog.sgml @@ -0,0 +1,73 @@ + +GtkInputDialog + + +Configure devices for the XInput extension. + + + +#GtkInputDialog displays a dialog which allows the user +to configure XInput extension devices. For each +device, they can control the mode of the device +(disabled, screen-relative, or window-relative), +the mapping of axes to coordinates, and the +mapping of the devices macro keys to key press +events. + + +#GtkInputDialog contains two buttons to which +the application can connect; one for closing +the dialog, and one for saving the changes. +No actions are bound to these by default. +The changes that the user makes take effect +immediately. + + + + + + + + + + + +@dialog: +@axis_list: +@axis_listbox: +@mode_optionmenu: +@close_button: +@save_button: +@axis_items: +@current_device: +@keys_list: +@keys_listbox: + + + +Creates a new #GtkInputDialog. + + +@Returns: the new #GtkInputDialog. + + + + +This signal is emitted when the user changes the +mode of a device from #GDK_MODE_DISABLED to a +#GDK_MODE_SCREEN or #GDK_MODE_WINDOW. + + +@inputdialog: the object which received the signal. +@deviceid: The ID of the newly enabled device. + + + +This signal is emitted when the user changes the +mode of a device from a #GDK_MODE_SCREEN or #GDK_MODE_WINDOW +to #GDK_MODE_ENABLED. + + +@inputdialog: the object which received the signal. +@deviceid: The ID of the newly disabled device. + diff --git a/docs/reference/gtk/tmpl/gtkinvisible.sgml b/docs/reference/gtk/tmpl/gtkinvisible.sgml new file mode 100644 index 0000000000..692e4138c9 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkinvisible.sgml @@ -0,0 +1,31 @@ + +GtkInvisible + + + + + + + + + + + + + + + + + + + +@bin: + + + + + + +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkitem.sgml b/docs/reference/gtk/tmpl/gtkitem.sgml new file mode 100644 index 0000000000..42461654d4 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkitem.sgml @@ -0,0 +1,68 @@ + +GtkItem + + + + + + + + + + + + + + + + + + + +@bin: + + + + + + +@item: + + + + + + + +@item: + + + + + + + +@item: + + + + + + + +@item: the object which received the signal. + + + + + + +@item: the object which received the signal. + + + + + + +@item: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkitemfactory.sgml b/docs/reference/gtk/tmpl/gtkitemfactory.sgml new file mode 100644 index 0000000000..9eb4b7a368 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkitemfactory.sgml @@ -0,0 +1,358 @@ + +GtkItemFactory + + + + + + + + + + + + + + + + + + + +@object: +@path: +@accel_group: +@widget: +@items: +@translate_func: +@translate_data: +@translate_notify: + + + + + + +@func_data: +@str: + + + + + + + +@path: +@func_data: +@Returns: + + + + + + + + + + + + + + +@callback_data: +@callback_action: +@widget: + + + + + + + +@widget: +@callback_data: +@callback_action: + + + + + + + +@path: +@accelerator: +@callback: +@callback_action: +@item_type: + + + + + + +@path: +@accelerator_key: +@accelerator_mods: +@modified: +@in_propagation: +@dummy: +@widgets: + + + + + + +@container_type: +@path: +@accel_group: +@Returns: + + + + + + + +@ifactory: +@container_type: +@path: +@accel_group: + + + + + + + +@file_name: + + + + + + + +@rc_string: + + + + + + + +@scanner: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@Returns: + + + + + + + +@ifactory: +@path: +@Returns: + + + + + + + +@ifactory: +@action: +@Returns: + + + + + + + +@path_pspec: +@modified_only: +@print_func: +@func_data: + + + + + + + +@file_name: +@path_pspec: +@modified_only: + + + + + + + +@FILE_pointer: +@string: + + + + + + + +@ifactory: +@entry: +@callback_data: +@callback_type: + + + + + + + +@ifactory: +@n_entries: +@entries: +@callback_data: + + + + + + + +@ifactory: +@n_entries: +@entries: +@callback_data: +@callback_type: + + + + + + + +@ifactory: +@path: + + + + + + + +@ifactory: +@entry: + + + + + + + +@ifactory: +@n_entries: +@entries: + + + + + + + +@ifactory: +@x: +@y: +@mouse_button: +@time: + + + + + + + +@ifactory: +@popup_data: +@destroy: +@x: +@y: +@mouse_button: +@time: + + + + + + + +@ifactory: +@Returns: + + + + + + + +@widget: +@Returns: + + + + + + + +@path: +@Returns: + + + + + + + +@n_entries: +@entries: + + + + + + + +@ifactory_path: +@path: + + + + + + + +@ifactory: +@func: +@data: +@notify: + + diff --git a/docs/reference/gtk/tmpl/gtklabel.sgml b/docs/reference/gtk/tmpl/gtklabel.sgml new file mode 100644 index 0000000000..6d5c308352 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtklabel.sgml @@ -0,0 +1,146 @@ + +GtkLabel + + +A widget that displays a small to medium amount of text. + + + +The #GtkLabel widget is usually used directly by the programmer to display +word(s) describing an adjacent widget or its use. It is also used internally +by Gtk+ as #GtkButton labels, #GtkMenu items, and many other widgets which +use text. + + + + + + + + + +This should not be accessed directly. Use the accessor functions as +described below. + + +@misc: +@label: +@label_wc: +@pattern: +@words: +@max_width: +@jtype: +@wrap: + + + +Internal to #GtkLabel. + + + + + +Creates a new label with the given string of text inside it. You can +pass NULL to get an empty label widget. + + +@str: The string you want to display in the #GtkLabel +@Returns: The newly allocated #GtkLabel widget + + + + +Aliases gtk_label_set_text. Probably used for backward compatibility with +Gtk+ 1.0.x. + + + + + + +The pattern of underlines you want under the existing text within the +#GtkLabel widget. For example if the current text of the label says +"FooBarBaz" passing a pattern of "___ ___" will underline +"Foo" and "Baz" but not "Bar". + + +@label: The #GtkLabel you want to set the pattern to. +@pattern: The pattern as described above. + + + + +Set where the text within the #GtkLabel will align to. This can be one of +four values: GTK_JUSTIFY_LEFT, GTK_JUSTIFY_RIGHT, GTK_JUSTIFY_CENTER, +and GTK_JUSTIFY_FILL. GTK_JUSTIFY_CENTER is the default value when the +widget is first created with gtk_label_new(). + + +@label: The #GtkLabel widget you want to set justification for. +@jtype: The #GtkJustification type as described above. + + + + +Gets the current string of text within the #GtkLabel and writes it to +the given str argument. It does not make a copy of this string so you +must not write to it. + + +@label: The #GtkLabel widget you want to get the text from. +@str: The reference to the pointer you want to point to the text. + + + + +Parses the given string for underscores and converts the next +character to an underlined character. The last character that +was underlined will have its lower-cased accelerator keyval returned (i.e. +"_File" would return the keyval for "f". This is +probably only used within the Gtk+ library itself for menu items and such. + + +@label: The #GtkLabel you want to affect. +@string: The string you want to parse for underlines. +@Returns: The lowercase keyval of the last character underlined. + + + + +Toggles line wrapping within the #GtkLabel widget. TRUE makes it break +lines if text exceeds the widget's size. FALSE lets the text get cut off +by the edge of the widget if it exceeds the widget size. + + +@label: The #GtkLabel you want to set line wrapping for. +@wrap: TRUE turns it on; FALSE turns it off. + + + + +Sets the text within the #GtkLabel widget. It overwrites any text that +was there before. Note that underlines that were there before do not +get overwritten. If you want to erase underlines just send NULL to +gtk_label_set_pattern(). + + +@label: The #GtkLabel you want to set the text for. +@str: The text you want to add. + + + + +The actual label text. Do not write to this pointer, it is not copied. + + + + +The pattern of underlines under the existing text. Do not change the +pointer, it isn't copied. + + + + +The #GtkJustification setting. See gtk_label_set_justify() for more info. + + diff --git a/docs/reference/gtk/tmpl/gtklayout.sgml b/docs/reference/gtk/tmpl/gtklayout.sgml new file mode 100644 index 0000000000..dc058a3e6d --- /dev/null +++ b/docs/reference/gtk/tmpl/gtklayout.sgml @@ -0,0 +1,130 @@ + +GtkLayout + + + + + + + + + + + + + + + + + + + +@container: +@children: +@width: +@height: +@xoffset: +@yoffset: +@hadjustment: +@vadjustment: +@bin_window: +@visibility: +@configure_serial: +@scroll_x: +@scroll_y: +@freeze_count: + + + + + + +@hadjustment: +@vadjustment: +@Returns: + + + + + + + +@layout: +@widget: +@x: +@y: + + + + + + + +@layout: +@widget: +@x: +@y: + + + + + + + +@layout: +@width: +@height: + + + + + + + +@layout: + + + + + + + +@layout: + + + + + + + +@layout: +@Returns: + + + + + + + +@layout: +@Returns: + + + + + + + +@layout: +@adjustment: + + + + + + + +@layout: +@adjustment: + + diff --git a/docs/reference/gtk/tmpl/gtklist.sgml b/docs/reference/gtk/tmpl/gtklist.sgml new file mode 100644 index 0000000000..a640713ca3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtklist.sgml @@ -0,0 +1,283 @@ + +GtkList + + + + + + + + + + + + + + + + + + + +@container: +@children: +@selection: +@undo_selection: +@undo_unselection: +@last_focus_child: +@undo_focus_child: +@htimer: +@vtimer: +@anchor: +@drag_pos: +@anchor_state: +@selection_mode: +@drag_selection: +@add_mode: + + + + + + +@Returns: + + + + + + + +@list: +@items: +@position: + + + + + + + +@list: +@items: + + + + + + + +@list: +@items: + + + + + + + +@list: +@items: + + + + + + + +@list: +@items: + + + + + + + +@list: +@start: +@end: + + + + + + + +@list: +@item: + + + + + + + +@list: +@item: + + + + + + + +@list: +@child: + + + + + + + +@list: +@child: + + + + + + + +@list: +@child: +@Returns: + + + + + + + +@list: +@mode: + + + + + + + +@list: +@scroll_type: +@position: +@auto_start_selection: + + + + + + + +@list: + + + + + + + +@list: + + + + + + + +@list: + + + + + + + +@list: + + + + + + + +@list: +@scroll_type: +@position: + + + + + + + +@list: +@scroll_type: +@position: + + + + + + + +@list: + + + + + + + +@list: + + + + + + + +@list: +@item: + + + + + + + +@list: + + + + + + + +@list: + + + + + + + +@list: the object which received the signal. + + + + + + +@list: the object which received the signal. +@widget: + + + + + + +@list: the object which received the signal. +@widget: + diff --git a/docs/reference/gtk/tmpl/gtklistitem.sgml b/docs/reference/gtk/tmpl/gtklistitem.sgml new file mode 100644 index 0000000000..f4b7585568 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtklistitem.sgml @@ -0,0 +1,133 @@ + +GtkListItem + + + + + + + + + + + + + + + + + + + +@item: + + + + + + +@Returns: + + + + + + + +@label: +@Returns: + + + + + + + +@list_item: + + + + + + + +@list_item: + + + + + + + +@listitem: the object which received the signal. + + + + + + +@listitem: the object which received the signal. + + + + + + +@listitem: the object which received the signal. + + + + + + +@listitem: the object which received the signal. + + + + + + +@listitem: the object which received the signal. + + + + + + +@listitem: the object which received the signal. + + + + + + +@listitem: the object which received the signal. + + + + + + +@listitem: the object which received the signal. +@scroll_type: +@position: +@auto_start_selection: + + + + + + +@listitem: the object which received the signal. +@scroll_type: +@position: + + + + + + +@listitem: the object which received the signal. +@scroll_type: +@position: + diff --git a/docs/reference/gtk/tmpl/gtkmain.sgml b/docs/reference/gtk/tmpl/gtkmain.sgml new file mode 100644 index 0000000000..d75ab873c3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmain.sgml @@ -0,0 +1,414 @@ + +General + + + + + + + + + + + + + + + + + + + +@Returns: + + + + + + + +@argc: +@argv: + + + + + + + +@argc: +@argv: +@Returns: + + + + + + + +@error_code: + + + + + + + +@Returns: + + + + + + + + + + + + + + +@Returns: + + + + + + + + + + + + + + +@Returns: + + + + + + + +@blocking: +@Returns: + + + + + + + +@event: + + + + + + + +@argc: +@argv: + + + + + + + +@Returns: + + + + + + + +@Returns: + + + + + + + +@widget: + + + + + + + +@Returns: + + + + + + + +@widget: + + + + + + + +@function: +@data: + + + + + + + +@main_level: +@object: + + + + + + + +@main_level: +@function: +@data: +@Returns: + + + + + + + +@main_level: +@function: +@marshal: +@data: +@destroy: +@Returns: + + + + + + + +@quit_handler_id: + + + + + + + +@data: + + + + + + + +@interval: +@function: +@marshal: +@data: +@destroy: +@Returns: + + + + + + + +@interval: +@function: +@data: +@Returns: + + + + + + + +@timeout_handler_id: + + + + + + + +@function: +@data: +@Returns: + + + + + + + +@priority: +@function: +@data: +@Returns: + + + + + + + +@priority: +@function: +@marshal: +@data: +@destroy: +@Returns: + + + + + + + +@idle_handler_id: + + + + + + + +@data: + + + + + + + +@source: +@condition: +@function: +@marshal: +@data: +@destroy: +@Returns: + + + + + + + +@input_handler_id: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +@snooper: +@func_data: +@Returns: + + + + + + + +@grab_widget: +@event: +@func_data: +@Returns: + + + + + + + +@snooper_handler_id: + + + + + + + +@Returns: + + + + + + + +@event: +@Returns: + + + + + + + +@widget: +@event: + + diff --git a/docs/reference/gtk/tmpl/gtkmarshal.sgml b/docs/reference/gtk/tmpl/gtkmarshal.sgml new file mode 100644 index 0000000000..288a5cb459 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmarshal.sgml @@ -0,0 +1,482 @@ + +Signal Marshallers + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + + + + + + +@object: +@func: +@func_data: +@args: + + diff --git a/docs/reference/gtk/tmpl/gtkmenu.sgml b/docs/reference/gtk/tmpl/gtkmenu.sgml new file mode 100644 index 0000000000..7411912cbc --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmenu.sgml @@ -0,0 +1,287 @@ + +GtkMenu + + +a drop down menu widget. + + + +A #GtkMenu is a #GtkMenuShell that implements a drop down menu consisting of +a list of #GtkMenuItem objects which can be navigated and activated by the +user to perform application functions. + + + +A #GtkMenu is most commonly dropped down by activating a #GtkMenuItem in a +#GtkMenuBar or popped up by activating a #GtkMenuItem in another #GtkMenu. + + + +A #GtkMenu can also be popped up by activating a #GtkOptionMenu. +Other composite widgets such as the #GtkNotebook can pop up a #GtkMenu +as well. + + + +Applications can display a #GtkMenu as a popup menu by calling the +gtk_menu_popup() function. The example below shows how an application +can pop up a menu when the 3rd mouse button is pressed. + + + +Connecting the popup signal handler. + + /* connect our handler which will popup the menu */ + gtk_signal_connect_object(GTK_OBJECT(window), "button_press_event", + GTK_SIGNAL_FUNC (my_popup_handler), GTK_OBJECT(menu)); + + + + +Signal handler which displays a popup menu. + +static gint +my_popup_handler(GtkWidget *widget, GdkEvent *event) +{ + GtkMenu *menu; + GdkEventButton *event_button; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (GTK_IS_MENU (widget), FALSE); + g_return_val_if_fail (event != NULL, FALSE); + + /* The "widget" is the menu that was supplied when + * gtk_signal_connect_object was called. + */ + menu = GTK_MENU (widget); + + if (event->type == GDK_BUTTON_PRESS) + { + event_button = (GdkEventButton *) event; + if (event_button->button == 3) + { + gtk_menu_popup (menu, NULL, NULL, NULL, NULL, + event_button->button, event_button->time); + return TRUE; + } + } + + return FALSE; +} + + + + + + + + + + +The #GtkMenu-struct struct contains private data only, and +should be accessed using the functions below. + + +@menu_shell: +@parent_menu_item: +@old_active_menu_item: +@accel_group: +@position_func: +@position_func_data: +@toplevel: +@tearoff_window: +@torn_off: + + + +Creates a new #GtkMenu. + + +@Returns: a new #GtkMenu. + + + + +Adds a new #GtkMenuItem to the end of the menu's item list. + + +@menu: a #GtkMenu. +@child: The #GtkMenuItem to add. + + + + +Adds a new #GtkMenuItem to the beginning of the menu's item list. + + +@menu: a #GtkMenu. +@child: The #GtkMenuItem to add. + + + + +Adds a new #GtkMenuItem to the menu's item list at the position +indicated by @position. + + +@menu: a #GtkMenu. +@child: The #GtkMenuItem to add. +@position: The position in the item list where @child is added. +Positions are numbered from 0 to n-1. + + + + +Moves a #GtkMenuItem to a new position within the #GtkMenu. + + +@menu: a #GtkMenu. +@child: the #GtkMenuItem to move. +@position: the new position to place @child. Positions are numbered from +0 to n-1. + + + + +Displays a menu and makes it available for selection. Applications can use +this function to display context-sensitive menus, and will typically supply +NULL for the @parent_menu_shell, @parent_menu_item, @func and @data +parameters. The default menu positioning function will position the menu +at the current pointer position. + + +@menu: a #GtkMenu. +@parent_menu_shell: the menu shell containing the triggering menu item. +@parent_menu_item: the menu item whose activation triggered the popup. +@func: a user supplied function used to position the menu. +@data: user supplied data to be passed to @func. +@button: the button which was pressed to initiate the event. +@activate_time: the time at which the activation event occurred. + + + + +Set the #GtkAccelGroup which holds global accelerators for the menu. + + +@menu: a #GtkMenu. +@accel_group: the #GtkAccelGroup to be associated with the menu. + + + + +Sets the title string for the menu. The title is displayed when the menu +is shown as a tearoff menu. + + +@menu: a #GtkMenu. +@title: a string containing the title for the menu. + + + + +Removes the menu from the screen. + + +@menu: a #GtkMenu. + + + + +Repositions the menu according to its position function. + + +@menu: a #GtkMenu. + + + + +Returns the selected menu item from the menu. This is used by the +#GtkOptionMenu. + + +@menu: a #GtkMenu. +@Returns: the #GtkMenuItem that was last selected in the menu. If a +selection has not yet been made, the first menu item is selected. + + + + +Selects the specified menu item within the menu. This is used by the +#GtkOptionMenu. + + +@menu: a #GtkMenu. +@index: the index of the menu item to select. Index values are from +0 to n-1. + + + + +Changes the tearoff state of the menu. A menu is normally displayed +as drop down menu which persists as long as the menu is active. It can +also be displayed as a tearoff menu which persists until it is closed +or reattached. + + +@menu: a #GtkMenu. +@torn_off: If TRUE, menu is displayed as a tearoff menu. + + + + +Attaches the menu to the widget and provides a callback function that will +be invoked when the menu calls gtk_menu_detach() during its destruction. + + +@menu: a #GtkMenu. +@attach_widget: the #GtkWidget that the menu will be attached to. +@detacher: the user supplied callback function that will be called when +the menu calls gtk_menu_detach(). + + + + +Detaches the menu from the widget to which it had been attached. +This function will call the callback function, @detacher, provided +when the gtk_menu_attach_to_widget() function was called. + + +@menu: a #GtkMenu. + + + + +Returns the #GtkWidget that the menu is attached to. + + +@menu: a #GtkMenu. +@Returns: the #GtkWidget that the menu is attached to. + + + + +A user function supplied when calling gtk_menu_popup() which controls the +positioning of the menu when it is displayed. The function sets the @x +and @y parameters to the coordinates where the menu is to be drawn. + + +@menu: a #GtkMenu. +@x: address of the #gint representing the horizontal position where the +menu shall be drawn. This is an output parameter. +@y: address of the #gint representing the vertical position where the +menu shall be drawn. This is an output parameter. +@user_data: the data supplied by the user in the gtk_menu_popup() @data +parameter. + + + + +A user function supplied when calling gtk_menu_attach_to_widget() which +will be called when the menu is later detached from the widget. + + +@attach_widget: the #GtkWidget that the menu is being detached from. +@menu: the #GtkMenu being detached. + + diff --git a/docs/reference/gtk/tmpl/gtkmenubar.sgml b/docs/reference/gtk/tmpl/gtkmenubar.sgml new file mode 100644 index 0000000000..d26a5bd690 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmenubar.sgml @@ -0,0 +1,74 @@ + +GtkMenuBar + + + + + + + + + + + + + + + + + + + +@menu_shell: +@shadow_type: + + + + + + +@Returns: + + + + + + + +@menu_bar: +@child: + + + + + + + +@menu_bar: +@child: + + + + + + + +@menu_bar: +@child: +@position: + + + + + + + +@menu_bar: +@type: + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkmenufactory.sgml b/docs/reference/gtk/tmpl/gtkmenufactory.sgml new file mode 100644 index 0000000000..77a9754c46 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmenufactory.sgml @@ -0,0 +1,132 @@ + +Menu Factory + + + + + + + + + + + + + + + + + + + +@widget: +@user_data: + + + + + + + +@path: +@accelerator: +@callback: +@callback_data: +@widget: + + + + + + +@path: +@widget: + + + + + + +@path: +@type: +@accel_group: +@widget: +@subfactories: + + + + + + +@type: +@Returns: + + + + + + + +@factory: + + + + + + + +@factory: +@entries: +@nentries: + + + + + + + +@factory: +@subfactory: +@path: + + + + + + + +@factory: +@paths: +@npaths: + + + + + + + +@factory: +@entries: +@nentries: + + + + + + + +@factory: +@subfactory: +@path: + + + + + + + +@factory: +@path: +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkmenuitem.sgml b/docs/reference/gtk/tmpl/gtkmenuitem.sgml new file mode 100644 index 0000000000..2eed9a2436 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmenuitem.sgml @@ -0,0 +1,132 @@ + +GtkMenuItem + + + + + + + + + + + + + + + + + + + +@item: +@submenu: +@accelerator_signal: +@toggle_size: +@accelerator_width: +@show_toggle_indicator: +@show_submenu_indicator: +@submenu_placement: +@submenu_direction: +@right_justify: +@timer: + + + + + + +@Returns: + + + + + + + +@label: +@Returns: + + + + + + + +@menu_item: +@submenu: + + + + + + + +@menu_item: + + + + + + + +@menu_item: +@placement: + + + + + + + +@menu_item: +@show_toggle_indicator: +@show_submenu_indicator: + + + + + + + +@menu_item: + + + + + + + +@menu_item: + + + + + + + +@menu_item: + + + + + + + +@menu_item: + + + + + + + +@menuitem: the object which received the signal. + + + + + + +@menuitem: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkmenushell.sgml b/docs/reference/gtk/tmpl/gtkmenushell.sgml new file mode 100644 index 0000000000..cad3bdefe2 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmenushell.sgml @@ -0,0 +1,191 @@ + +GtkMenuShell + + +a base class for menu objects. + + + +A #GtkMenuShell is the abstract base class used to derive the +#GtkMenu and #GtkMenuBar subclasses. + + + +A #GtkMenuShell is a container of #GtkMenuItem objects arranged in a +list which can be navigated, selected, and activated by the user to perform +application functions. A #GtkMenuItem can have a submenu associated with it, +allowing for nested hierarchical menus. + + + + + + + + + +The #GtkMenuShell-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#GList *children; +The list of #GtkMenuItem objects contained by this #GtkMenuShell. + + + + + +@container: +@children: +@active_menu_item: +@parent_menu_shell: +@active: +@have_grab: +@have_xgrab: +@button: +@ignore_leave: +@menu_flag: +@ignore_enter: +@activate_time: + + + +Adds a new #GtkMenuItem to the end of the menu shell's item list. + + +@menu_shell: a #GtkMenuShell. +@child: The #GtkMenuItem to add. + + + + +Adds a new #GtkMenuItem to the beginning of the menu shell's item list. + + +@menu_shell: a #GtkMenuShell. +@child: The #GtkMenuItem to add. + + + + +Adds a new #GtkMenuItem to the menu shell's item list at the position +indicated by @position. + + +@menu_shell: a #GtkMenuShell. +@child: The #GtkMenuItem to add. +@position: The position in the item list where @child is added. +Positions are numbered from 0 to n-1. + + + + +Deactivates the menu shell. Typically this results in the menu shell +being erased from the screen. + + +@menu_shell: a #GtkMenuShell. + + + + +Selects the menu item from the menu shell. + + +@menu_shell: a #GtkMenuShell. +@menu_item: The #GtkMenuItem to select. + + + + +Activates the menu item within the menu shell. + + +@menu_shell: a #GtkMenuShell. +@menu_item: The #GtkMenuItem to activate. +@force_deactivate: If TRUE, force the deactivation of the menu shell +after the menu item is activated. + + + + +An enumeration representing directional movements within a menu. + + + + + + +GTK_MENU_DIR_PARENT +To the parent menu shell. + + + +GTK_MENU_DIR_CHILD +To the submenu, if any, associated with the item. + + + +GTK_MENU_DIR_NEXT +To the next menu item. + + + +GTK_MENU_DIR_PREV +To the previous menu item. + + + + + +@GTK_MENU_DIR_PARENT: +@GTK_MENU_DIR_CHILD: +@GTK_MENU_DIR_NEXT: +@GTK_MENU_DIR_PREV: + + + +This signal is emitted when a menu shell is deactivated. + + +@menushell: the object which received the signal. + + + +This signal is emitted when a selection has been completed within a menu +shell. + + +@menushell: the object which received the signal. + + + +An action signal which moves the current menu item in the direction +specified by @direction. + + +@menushell: the object which received the signal. +@direction: the direction to move. + + + +An action signal that activates the current menu item within the menu +shell. + + +@menushell: the object which received the signal. +@force_hide: if TRUE, hide the menu after activating the menu item. + + + +An action signal which cancels the selection within the menu shell. +Causes the GtkMenuShell::selection-done signal to be emitted. + + +@menushell: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtkmisc.sgml b/docs/reference/gtk/tmpl/gtkmisc.sgml new file mode 100644 index 0000000000..10f5662c6c --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkmisc.sgml @@ -0,0 +1,109 @@ + +GtkMisc + + +a base class for widgets with alignments and padding. + + + +The #GtkMisc widget is an abstract widget which is not useful itself, but +is used to derive subclasses which have alignment and padding attributes. + + +The horizontal and vertical padding attributes allows extra space to be +added around the widget. + + +The horizontal and vertical alignment attributes enable the widget to be +positioned within its allocated area. Note that if the widget is added to +a container in such a way that it expands automatically to fill its +allocated area, the alignment settings will not alter the widgets position. + + + + + + + + + +The #GtkMisc-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#gfloat xalign; +the horizontal alignment, from 0 (left) to 1 (right). + + + +#gfloat yalign; +the vertical alignment, from 0 (top) to 1 (bottom). + + + +#guint16 xpad; +the amount of space to add on the left and right of the widget, +in pixels. + + + +#guint16 ypad; +the amount of space to add on the top and bottom of the widget, +in pixels. + + + + +@widget: +@xalign: +@yalign: +@xpad: +@ypad: + + + +Sets the alignment of the widget. + + +@misc: a #GtkMisc. +@xalign: the horizontal alignment, from 0 (left) to 1 (right). +@yalign: the vertical alignment, from 0 (top) to 1 (bottom). + + + + +Sets the amount of space to add around the widget. + + +@misc: a #GtkMisc. +@xpad: the amount of space to add on the left and right of the widget, +in pixels. +@ypad: the amount of space to add on the top and bottom of the widget, +in pixels. + + + + +the horizontal alignment, from 0 (left) to 1 (right). + + + + +the vertical alignment, from 0 (top) to 1 (bottom). + + + + +the amount of space to add on the left and right of the widget, in pixels. + + + + +the amount of space to add on the top and bottom of the widget, in pixels. + + diff --git a/docs/reference/gtk/tmpl/gtknotebook.sgml b/docs/reference/gtk/tmpl/gtknotebook.sgml new file mode 100644 index 0000000000..dc6014b070 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtknotebook.sgml @@ -0,0 +1,446 @@ + +GtkNotebook + + + + + + + + + + + + + + + + + + + +@container: +@cur_page: +@children: +@first_tab: +@focus_tab: +@menu: +@panel: +@timer: +@tab_hborder: +@tab_vborder: +@show_tabs: +@homogeneous: +@show_border: +@tab_pos: +@scrollable: +@in_child: +@click_child: +@button: +@need_timer: +@child_has_focus: +@have_visible_child: + + + + + + +@_glist_: + + + + + + + +@child: +@tab_label: +@menu_label: +@default_menu: +@default_tab: +@expand: +@fill: +@pack: +@requisition: +@allocation: + + + + + + +@Returns: + + + + + + + +@notebook: +@child: +@tab_label: + + + + + + + +@notebook: +@child: +@tab_label: +@menu_label: + + + + + + + +@notebook: +@child: +@tab_label: + + + + + + + +@notebook: +@child: +@tab_label: +@menu_label: + + + + + + + +@notebook: +@child: +@tab_label: +@position: + + + + + + + +@notebook: +@child: +@tab_label: +@menu_label: +@position: + + + + + + + +@notebook: +@page_num: + + + + + + + + + + + + + + +@notebook: +@child: +@Returns: + + + + + + + +@notebook: +@page_num: + + + + + + + +@notebook: + + + + + + + +@notebook: + + + + + + + +@notebook: +@child: +@position: + + + + + + + +@notebook: +@pos: + + + + + + + +@notebook: +@show_tabs: + + + + + + + +@notebook: +@show_border: + + + + + + + +@notebook: +@scrollable: + + + + + + + +@notebook: +@border_width: + + + + + + + +@notebook: + + + + + + + +@notebook: + + + + + + + +@notebook: +@Returns: + + + + + + + +@notebook: +@child: +@Returns: + + + + + + + +@notebook: +@page_num: +@Returns: + + + + + + + +@notebook: +@child: +@Returns: + + + + + + + +@notebook: +@child: +@expand: +@fill: +@pack_type: + + + + + + + +@notebook: +@homogeneous: + + + + + + + +@notebook: +@child: +@menu_label: + + + + + + + +@notebook: +@child: +@menu_text: + + + + + + + +@notebook: +@tab_hborder: + + + + + + + +@notebook: +@child: +@tab_label: + + + + + + + +@notebook: +@child: +@expand: +@fill: +@pack_type: + + + + + + + +@notebook: +@child: +@tab_text: + + + + + + + +@notebook: +@tab_vborder: + + + + + + + +@notebook: the object which received the signal. +@page: +@page_num: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkobject.sgml b/docs/reference/gtk/tmpl/gtkobject.sgml new file mode 100644 index 0000000000..c4d5a576e1 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkobject.sgml @@ -0,0 +1,531 @@ + +GtkObject + + + + + + + + + + + + + + + + + + + +@klass: +@flags: +@ref_count: +@object_data: + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@GTK_DESTROYED: +@GTK_FLOATING: +@GTK_CONNECTED: +@GTK_CONSTRUCTED: + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: +@flag: + + + + + + + +@obj: +@flag: + + + + + + + +@GTK_ARG_READABLE: +@GTK_ARG_WRITABLE: +@GTK_ARG_CONSTRUCT: +@GTK_ARG_CONSTRUCT_ONLY: +@GTK_ARG_CHILD_ARG: +@GTK_ARG_MASK: +@GTK_ARG_READWRITE: + + + + + + +@klass: +@name: +@signal_flags: +@marshaller: +@return_val: +@nparams: +@Varargs: +@Returns: + + + + + + + +@klass: +@name: +@signal_flags: +@marshaller: +@return_val: +@nparams: +@params: +@Returns: + + + + + + + +@type: +@first_arg_name: +@Varargs: +@Returns: + + + + + + + +@object_type: +@n_args: +@args: +@Returns: + + + + + + + +@object: + + + + + + + +@object: + + + + + + + +@object: + + + + + + + +@object: + + + + + + + +@object: + + + + + + + +@object: +@notify: +@data: + + + + + + + +@object: +@notify: +@data: + + + + + + + +@object: + + + + + + + +@object: +@n_args: +@args: + + + + + + + +@object: +@first_arg_name: +@Varargs: + + + + + + + +@object: +@n_args: +@args: + + + + + + + +@class_type: +@arg_flags: +@n_args: +@Returns: + + + + + + + +@object: +@key: +@data: + + + + + + + +@object: +@key: +@data: +@destroy: + + + + + + + +@object: +@key: + + + + + + + +@object: +@key: +@Returns: + + + + + + + +@object: +@key: + + + + + + + +@object: +@data: + + + + + + + +@object: +@Returns: + + + + + + + +@klass: +@signals: +@nsignals: + + + + + + + +@arg_name: +@arg_type: +@arg_flags: +@arg_id: + + + + + + + +@object: +@data_id: +@data: + + + + + + + +@object: +@data_id: +@data: +@destroy: + + + + + + + +@object: +@data_id: +@Returns: + + + + + + + +@object: +@data_id: + + + + + + + +@object: +@key_id: + + + + + + + + + + + + + + + + + + + + + +@object: +@arg: +@info: + + + + + + + +@object: +@arg: +@info: + + + + + + + +@object_type: +@arg_list_p: +@info_list_p: +@first_arg_name: +@var_args: +@Returns: + + + + + + + +@object_type: +@arg_name: +@info_p: +@Returns: + + + + + + + +@object: +@func: +@dummy: +@line: +@do_ref: + + + + + + + +@object: the object which received the signal. + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkoptionmenu.sgml b/docs/reference/gtk/tmpl/gtkoptionmenu.sgml new file mode 100644 index 0000000000..429a319f48 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkoptionmenu.sgml @@ -0,0 +1,76 @@ + +GtkOptionMenu + + +a widget used to choose from a list of valid choices. + + + +A #GtkOptionMenu is a widget that allows the user to choose from a +list of valid choices. The #GtkOptionMenu displays the selected +choice. When activated the #GtkOptionMenu displays a popup #GtkMenu +which allows the user to make a new choice. + + + + + + + +The #GtkOptionMenu-struct struct contains private data only, and +should be accessed using the functions below. + + +@button: +@menu: +@menu_item: +@width: +@height: + + + +Creates a new #GtkOptionMenu. + + +@Returns: a new #GtkOptionMenu. + + + + +Returns the #GtkMenu associated with the #GtkOptionMenu. + + +@option_menu: a #GtkOptionMenu. +@Returns: the #GtkMenu associated with the #GtkOptionMenu. + + + + +Provides the #GtkMenu that is popped up to allow the user to choose +a new value. You should provide a simple menu avoiding the +use of tearoff menu items, submenus, and accelerators. + + +@option_menu: a #GtkOptionMenu. +@menu: the #GtkMenu to associate with the #GtkOptionMenu. + + + + +Removes the menu from the option menu. + + +@option_menu: a #GtkOptionMenu. + + + + +Selects the menu item specified by @index making it the newly +selected value for the option menu. + + +@option_menu: a #GtkOptionMenu. +@index: the index of the menu item to select. Index values are from +0 to n-1. + + diff --git a/docs/reference/gtk/tmpl/gtkpacker.sgml b/docs/reference/gtk/tmpl/gtkpacker.sgml new file mode 100644 index 0000000000..d9a0fdde06 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkpacker.sgml @@ -0,0 +1,227 @@ + +GtkPacker + + + + + + + + + + + + + + + + + + + +@parent: +@children: +@spacing: +@default_border_width: +@default_pad_x: +@default_pad_y: +@default_i_pad_x: +@default_i_pad_y: + + + + + + +@GTK_PACK_EXPAND: +@GTK_FILL_X: +@GTK_FILL_Y: + + + + + + +@GTK_SIDE_TOP: +@GTK_SIDE_BOTTOM: +@GTK_SIDE_LEFT: +@GTK_SIDE_RIGHT: + + + + + + +@GTK_ANCHOR_CENTER: +@GTK_ANCHOR_NORTH: +@GTK_ANCHOR_NORTH_WEST: +@GTK_ANCHOR_NORTH_EAST: +@GTK_ANCHOR_SOUTH: +@GTK_ANCHOR_SOUTH_WEST: +@GTK_ANCHOR_SOUTH_EAST: +@GTK_ANCHOR_WEST: +@GTK_ANCHOR_EAST: +@GTK_ANCHOR_N: +@GTK_ANCHOR_NW: +@GTK_ANCHOR_NE: +@GTK_ANCHOR_S: +@GTK_ANCHOR_SW: +@GTK_ANCHOR_SE: +@GTK_ANCHOR_W: +@GTK_ANCHOR_E: + + + + + + +@widget: +@anchor: +@side: +@options: +@use_default: +@border_width: +@pad_x: +@pad_y: +@i_pad_x: +@i_pad_y: + + + + + + +@Returns: + + + + + + + +@packer: +@child: +@side: +@anchor: +@options: + + + + + + + +@packer: +@child: +@side: +@anchor: +@options: +@border_width: +@pad_x: +@pad_y: +@i_pad_x: +@i_pad_y: + + + + + + + + + + + + + + +@packer: +@child: +@position: + + + + + + + +@packer: +@spacing: + + + + + + + +@packer: +@border: + + + + + + + +@packer: +@pad_x: +@pad_y: + + + + + + + +@packer: +@i_pad_x: +@i_pad_y: + + + + + + + +@packer: +@child: +@side: +@anchor: +@options: +@border_width: +@pad_x: +@pad_y: +@i_pad_x: +@i_pad_y: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkpaned.sgml b/docs/reference/gtk/tmpl/gtkpaned.sgml new file mode 100644 index 0000000000..63d2f3c549 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkpaned.sgml @@ -0,0 +1,198 @@ + +GtkPaned + + +Base class for widgets with two adjustable panes + + + +GtkPaned is the base class for widgets with two panes, +arranged either horizontally (#GtkHPaned) or +vertically (#GtkVPaned). Child widgets are +added to the panes of the widget with +gtk_paned_pack1() and gtk_paned_pack2(). The division +beween the two children is set by default from the +size requests of the children, but it can be adjusted +by the user. + + +A paned widget draws a separator between the two +child widgets and a small handle that the user +can drag to adjust the division. It does not +draw any relief around the children or around +the separator. (The space in which the separator +is called the gutter). Often, it is useful +to put each child inside a #GtkFrame with the +shadow type set to %GTK_SHADOW_IN so that the +gutter appears as a ridge. + +Each child has two options that can be set, +@resize and @shrink. If @resize is true, then when the +#GtkPaned is resized, that child will expand +or shrink along with the paned widget. If @shrink +is true, then when that child can be made smaller +than it's requisition by the user. Setting @shrink +to FALSE allows the application to set a minimum +size. If @resize is false for both children, then +this is treated as if @resize is true for both +children. + + +The application can set the position of the slider +as if it were set by the user, by calling +gtk_paned_set_position(). + + + + Creating a paned widget with minimum sizes + +GtkWidget *hpaned = gtk_hpaned_new(); +GtkWidget *frame1 = gtk_frame_new(NULL); +GtkWidget *frame2 = gtk_frame_new(NULL); +gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN); +gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN); + +gtk_widget_set_usize (hpaned, 200 + GTK_PANED (hpaned)->gutter_size, -1); + +gtk_paned_pack1 (GTK_PANED (hpaned), frame1, TRUE, FALSE); +gtk_widget_set_usize (frame1, 50, -1); + +gtk_paned_pack2 (GTK_PANED (hpaned), frame1, FALSE, FALSE); +gtk_widget_set_usize (frame1, 50, -1); + + + + + + + + + + + + +@container: +@child1: +@child2: +@handle: +@groove_rectangle: +@xor_gc: +@handle_size: +@gutter_size: +@child1_size: +@last_allocation: +@min_position: +@max_position: +@position_set: +@in_drag: +@child1_shrink: +@child1_resize: +@child2_shrink: +@child2_resize: +@handle_xpos: +@handle_ypos: + + + +Add a child to the top or left pane with +default parameters. This is equivalent +to + +gtk_paned_pack1(paned, FALSE, TRUE); + + + +@paned: a paned widget +@child: the child to add + + + + +Add a child to the bottom or right pane with default +parameters. This is equivalent to + +gtk_paned_pack1(paned, FALSE, FALSE); + + + +@paned: a paned widget +@child: the child to add + + + + +Old name for gtk_paned_set_handle_size() + + + + + + +Old name for gtk_paned_set_gutter_size() + + + + + + +Internal function used by #GtkHPaned and #GtkVPaned + + +@paned: +@allocation: +@child1_req: +@child2_req: + + + + +Add a child to the top or left pane. + + +@paned: a paned widget +@child: the child to add +@resize: should this child expand when the paned widget is resized. +@shrink: can this child be made smaller than its requsition. + + + + +Add a child to the bottom or right pane. + + +@paned: a paned widget +@child: the child to add +@resize: should this child expand when the paned widget is resized. +@shrink: can this child be made smaller than its requsition. + + + + +Set the width of the gutter. (The area between the two panes). + + +@paned: a paned widget +@size: the width of the widget in pixels + + + + +Set the the handle size to @size x @size pixels. + + +@paned: a paned widget +@size: the size in pixels + + + + +Set the position of the separator, as if set by the user. +If position is negative, the remembered position is +forgotten, and the division is recomputed from the +the requisitions of the children. + + +@paned: a paned widget +@position: the new position of the separator. + + diff --git a/docs/reference/gtk/tmpl/gtkpixmap.sgml b/docs/reference/gtk/tmpl/gtkpixmap.sgml new file mode 100644 index 0000000000..57444d8279 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkpixmap.sgml @@ -0,0 +1,80 @@ + +GtkPixmap + + +a widget displaying a graphical image or icon. + + + +The #GtkPixmap widget displays a graphical image or icon. +The icon is typically created using gdk_pixmap_colormap_create_from_xpm() +or gdk_pixmap_colormap_create_from_xpm_d(). + + +The pixels in a #GtkPixmap cannot be manipulated by the application after +creation, since under the X Window system the pixel data is stored on the +X server and so is not available to the client application. +If you want to create graphical images which can be manipulated by the +application, look at #GtkImage and #GdkRGB. + + + + + + + + + +The #GtkPixmap-struct struct contains private data only, and +should be accessed using the functions below. + + +@misc: +@pixmap: +@mask: +@pixmap_insensitive: +@build_insensitive: + + + +Creates a new #GtkPixmap, using the given GDK pixmap and mask. + + +@pixmap: a #GDKPixmap. +@mask: a #GDKBitmap which indicates which parts of the @pixmap should be +transparent. +@Returns: a new #GtkPixmap. + + + + +Sets the #GdkPixmap and #GdkBitmap mask. + + +@pixmap: a #GtkPixmap. +@val: a #GdkPixmap. +@mask: a #GdkBitmap, which indicates which parts of the @pixmap should be +transparent. This can be NULL, in which case none of the @pixmap is +transparent. + + + + +Gets the current #GdkPixmap and #GdkBitmap mask. + + +@pixmap: a #GtkPixmap. +@val: returns the current #GdkPixmap. +@mask: returns the current #GdkBitmap mask. + + + + + + + +@pixmap: a #GtkPixmap. +@build: set to TRUE if an extra pixmap should be automatically created to use +when the pixmap is insensitive. + + diff --git a/docs/reference/gtk/tmpl/gtkplug.sgml b/docs/reference/gtk/tmpl/gtkplug.sgml new file mode 100644 index 0000000000..1f71fb5dc9 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkplug.sgml @@ -0,0 +1,60 @@ + +GtkPlug + + +Toplevel for embedding into other processes. + + + +Together with #GtkSocket, #GtkPlug provides the ability +to embed widgets from one process into another process +in a fashion that is transparent to the user. One +process creates a #GtkSocket widget and, passes the +XID of that widgets window to the other process, +which then creates a #GtkPlug window with that XID. +Any widgets contained in the #GtkPlug then will appear +inside the first applications window. + + + + + + + +#GtkSocket +the widget that a #GtkPlug plugs into. + + + + + + + + + + +@window: +@socket_window: +@same_app: + + + +Finish the creation of a #GtkPlug widget. This function +will generally only be used by classes deriving +from #GtkPlug. + + +@plug: a #GtkPlug widget. +@socket_id: the XID of the socket's window. + + + + +Create a new plug widget inside the #GtkSocket identified +by @socket_id. + + +@socket_id: the XID of the socket's window. +@Returns: the new #GtkPlug widget. + + diff --git a/docs/reference/gtk/tmpl/gtkpreview.sgml b/docs/reference/gtk/tmpl/gtkpreview.sgml new file mode 100644 index 0000000000..d5448de0bd --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkpreview.sgml @@ -0,0 +1,265 @@ + +GtkPreview + + +a widget to display RGB or grayscale data. + + + +The #GtkPreview widget provides a simple interface +used to display images as RGB or grayscale data. + + + + + + + +#GdkRGB +the backend used by #GtkPreview. + + + + + + + +The #GtkPreview-struct struct contains private data only, and +should be accessed using the functions below. + + +@widget: +@buffer: +@buffer_width: +@buffer_height: +@bpp: +@rowstride: +@dither: +@type: +@expand: + + + +Contains information about global properties +of preview widgets. + +The #GtkPreviewInfo struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#GdkVisual *visual; +the visual used by all previews. + + + +#GdkColormap *cmap; +the colormap used by all previews. + + + +gdouble gamma; +the gamma correction value used by all previews (See gtk_preview_set_gamma()). + + + + + + + + +@visual: +@cmap: +@lookup: +@gamma: + + + +This union not used in GTK+. + + + + + +This function is deprecated and does nothing. + + + + + + +Create a new preview widget. + + +@type: the type data contained by the widget. +(Grayscale or RGB) +@Returns: + + + + +Set the size that the preview widget will request +in response to a "size_request" signal. The +drawing area may actually be allocated a size +larger than this depending on how it is packed +within the enclosing containers. The effect +of this is determined by whether the preview +is set to expand or not (see gtk_preview_expand()) + + +@preview: a #GtkPreview. +@width: the new width. +@height: the new height. + + + + +Takes a portion of the contents of a preview widget +and draws it onto the given drawable, @window. + + +@preview: a #GtkPreview. +@window: a window or pixmap. +@gc: The graphics context for the operation. Only the + clip mask for this GC matters. +@srcx: the x coordinate of the upper left corner in the source image. +@srcy: the y coordinate of the upper left corner in the source image. +@destx: the x coordinate of the upper left corner in the destination image. +@desty: the y coordinate of the upper left corner in the destination image. +@width: the width of the rectangular portion to draw. +@height: the height of the rectangular portion to draw. + + + + +Sets the data for a portion of a row. + + +@preview: a #GtkPreview. +@data: the new data for the portion. It should contain + @w bytes of data if the preview is of type + GTK_TYPE_GRAYSCALE, and 3*@w bytes of data + if the preview is of type GTK_TYPE_COLOR. +@x: the starting value on the row to set. +@y: the row to change. +@w: the number of pixels in the row to change. + + + + +Determines the way that the the preview widget behaves +when the size it is allocated is larger than the requested +size. If @expand is %FALSE, then the preview's window +and buffer will be no larger than the size set with +gtk_preview_size(), and the data set will be centered +in the allocation if it is larger. If @expand is %TRUE +then the window and buffer will expand with the allocation; +the application is responsible for catching +the "size_allocate" signal and providing the data +appropriate for this size. + + +@preview: a #GtkPreview. +@expand: whether the preview's window should expand or not. + + + + +Set the gamma-correction value for all preview widgets. +(This function will eventually be replaced with a +function that sets a per-preview-widget gamma value). +The resulting intensity is given by: +destination_value * pow (source_value/255, 1/gamma). +The gamma value is applied when the data is +set with gtk_preview_draw_row() so changing this +value will not affect existing data in preview +widgets. + + +@gamma: the new gamma value. + + + + +This function is deprecated and does nothing. GdkRGB +automatically picks an optimium color cube for the +display. + + +@nred_shades: ignored +@ngreen_shades: ignored +@nblue_shades: ignored +@ngray_shades: ignored + + + + +This function is deprecated +and does nothing. GdkRGB will automatically pick +a private colormap if it cannot allocate sufficient +colors. + + +@install_cmap: ignored. + + + + +This function is deprecated and does nothing. + + +@nreserved: ignored. + + + + +Set the dithering mode for the display. + + +@preview: a #GtkPreview. +@dither: the dithering mode. + + + + +Returns the visual used by preview widgets. This +function is deprecated, and you should use +gdk_rgb_get_visual() instead. + + +@Returns: the visual for previews. + + + + +Returns the colormap used by preview widgets. This +function is deprecated, and you should use +gdk_rgb_get_cmap() instead. + + +@Returns: the colormap for previews. + + + + +Return a #GtkPreviewInfo structure containing +global information about preview widgets. + + +@Returns: a #GtkPreviewInfo structure. The return + value belongs to GTK+ and must not be modified + or freed. + + + + +This function is deprecated and does nothing. It was +once used for changing the colormap and visual on the fly. + + + + diff --git a/docs/reference/gtk/tmpl/gtkprivate.sgml b/docs/reference/gtk/tmpl/gtkprivate.sgml new file mode 100644 index 0000000000..3be551b997 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkprivate.sgml @@ -0,0 +1,120 @@ + +Private Information + + + + + + + + + + + + + + + + + + + +@PRIVATE_GTK_USER_STYLE: +@PRIVATE_GTK_REDRAW_PENDING: +@PRIVATE_GTK_RESIZE_PENDING: +@PRIVATE_GTK_RESIZE_NEEDED: +@PRIVATE_GTK_LEAVE_PENDING: +@PRIVATE_GTK_HAS_SHAPE_MASK: +@PRIVATE_GTK_IN_REPARENT: +@PRIVATE_GTK_IS_OFFSCREEN: + + + + + + +@wid: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@obj: + + + + + + + +@wid: +@flag: + + + + + + + +@wid: +@flag: + + diff --git a/docs/reference/gtk/tmpl/gtkprogress.sgml b/docs/reference/gtk/tmpl/gtkprogress.sgml new file mode 100644 index 0000000000..f977ff9913 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkprogress.sgml @@ -0,0 +1,172 @@ + +GtkProgress + + + + + + + + + + + + + + + + + + + +@widget: +@adjustment: +@offscreen_pixmap: +@format: +@x_align: +@y_align: +@show_text: +@activity_mode: + + + + + + +@progress: +@show_text: + + + + + + + +@progress: +@x_align: +@y_align: + + + + + + + +@progress: +@format: + + + + + + + +@progress: +@adjustment: + + + + + + + +@progress: +@percentage: + + + + + + + +@progress: +@value: + + + + + + + +@progress: +@Returns: + + + + + + + +@progress: +@activity_mode: + + + + + + + +@progress: +@Returns: + + + + + + + +@progress: +@value: +@Returns: + + + + + + + +@progress: +@Returns: + + + + + + + +@progress: +@value: +@Returns: + + + + + + + +@progress: +@value: +@min: +@max: + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkprogressbar.sgml b/docs/reference/gtk/tmpl/gtkprogressbar.sgml new file mode 100644 index 0000000000..5838aba506 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkprogressbar.sgml @@ -0,0 +1,150 @@ + +GtkProgressBar + + + + + + + + + + + + + + + + + + + +@progress: +@bar_style: +@orientation: +@blocks: +@in_block: +@activity_pos: +@activity_step: +@activity_blocks: +@activity_dir: + + + + + + +@GTK_PROGRESS_CONTINUOUS: +@GTK_PROGRESS_DISCRETE: + + + + + + +@GTK_PROGRESS_LEFT_TO_RIGHT: +@GTK_PROGRESS_RIGHT_TO_LEFT: +@GTK_PROGRESS_BOTTOM_TO_TOP: +@GTK_PROGRESS_TOP_TO_BOTTOM: + + + + + + +@Returns: + + + + + + + +@adjustment: +@Returns: + + + + + + + +@pbar: +@style: + + + + + + + +@pbar: +@blocks: + + + + + + + +@pbar: +@step: + + + + + + + +@pbar: +@blocks: + + + + + + + +@pbar: +@orientation: + + + + + + + +@pbar: +@percentage: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkradiobutton.sgml b/docs/reference/gtk/tmpl/gtkradiobutton.sgml new file mode 100644 index 0000000000..681ceec23f --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkradiobutton.sgml @@ -0,0 +1,85 @@ + +GtkRadioButton + + + + + + + + + + + + + + + + + + + +@check_button: +@group: + + + + + + +@group: +@Returns: + + + + + + + +@group: +@Returns: + + + + + + + +@group: +@label: +@Returns: + + + + + + + +@group: +@label: +@Returns: + + + + + + + +@radio_button: +@Returns: + + + + + + + +@radio_button: +@group: + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkradiomenuitem.sgml b/docs/reference/gtk/tmpl/gtkradiomenuitem.sgml new file mode 100644 index 0000000000..58d7fa5afe --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkradiomenuitem.sgml @@ -0,0 +1,61 @@ + +GtkRadioMenuItem + + + + + + + + + + + + + + + + + + + +@check_menu_item: +@group: + + + + + + +@group: +@Returns: + + + + + + + +@group: +@label: +@Returns: + + + + + + + +@radio_menu_item: +@Returns: + + + + + + + +@radio_menu_item: +@group: + + diff --git a/docs/reference/gtk/tmpl/gtkrange.sgml b/docs/reference/gtk/tmpl/gtkrange.sgml new file mode 100644 index 0000000000..2908bce5a0 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkrange.sgml @@ -0,0 +1,202 @@ + +GtkRange + + + + + + + + + + + + + + + + + + + +@widget: +@trough: +@slider: +@step_forw: +@step_back: +@x_click_point: +@y_click_point: +@button: +@digits: +@policy: +@scroll_type: +@in_child: +@click_child: +@need_timer: +@timer: +@old_value: +@old_lower: +@old_upper: +@old_page_size: +@adjustment: + + + + + + +@range: +@Returns: + + + + + + + +@range: +@policy: + + + + + + + +@range: +@adjustment: + + + + + + + +@range: + + + + + + + +@range: + + + + + + + +@range: + + + + + + + +@range: + + + + + + + +@range: + + + + + + + +@range: + + + + + + + +@range: +@x: +@y: +@jump_perc: +@Returns: + + + + + + + +@range: + + + + + + + +@range: + + + + + + + +@range: +@x: +@y: +@jump_perc: +@Returns: + + + + + + + +@range: +@x: +@y: +@jump_perc: +@Returns: + + + + + + + +@range: +@xdelta: +@ydelta: + + + + + + + +@range: +@xdelta: +@ydelta: + + + + + + + +@range: + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkrc.sgml b/docs/reference/gtk/tmpl/gtkrc.sgml new file mode 100644 index 0000000000..850384c402 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkrc.sgml @@ -0,0 +1,724 @@ + +Resource Files + + +Routines for handling resource files + + + +GTK+ provides resource file mechanism for configuring +various aspects of the operation of a GTK+ program +at runtime. + + +Default files + +An application can cause GTK+ to parse a specific RC +file by calling gtk_rc_parse(). In addition to this, +certain files will be read at the end of gtk_init(). +Unless modified, the files looked for will be .gtkrc +in the users home directory, and +$localstatedir/gtk/gtkrc +($localstatedir defaults to +/usr/local/etc). + + + +The set of these default files +can be retrieved with gtk_rc_get_default_files() +and modified with gtk_rc_add_default_file() and +gtk_rc_set_default_files(). + + + +For each default file, in addition to the file itself, +GTK+ will look for a locale-specific file that will +be parsed in addition to the main file. For instance, +if LANG is set to ja_JP.ujis, +when loading the default file ~/.gtkrc +then GTK+ looks for ~/.gtkrc.ja_JP.ujis, +~/.gtkrc.ja_JP, and +~/.gtkrc.ja, and parses the +first one it finds. + + + +Toplevel declarations + +An RC file is a text file which is composed of a sequence +of declarations. '#' characters delimit comments and +the portion of a line after a '#' is ignored when parsing +an RC file. + + + +The possible toplevel declarations are: + + + + binding name + { ... } + + Declare a binding set + + + + class pattern + [ style | binding [ : priority ]] + name + + Specify a style or binding set for a particular + branch of the inheritance heirarchy. + + + + include filename + + Parse another file at this point + + + + module_path path> + + Sets a path (a list of directories separated + by colons) that will be searched for theme engines referenced in + RC files. + + + + pixmap_path path> + + Sets a path (a list of directories separated + by colons) that will be searched for pixmaps referenced in + RC files. + + + + style name [ = + parent ] { ... } + + Declare a style + + + + widget pattern + [ style | binding [ : priority ]] + name + + Specify a style or binding set for a particular + group of widgets by matching on the widget path. + + + + widget_class pattern + [ style | binding [ : priority ]] + name + + Specify a style or binding set for a particular + group of widgets by matching on the class path. + + + + + +Styles + +A RC style is specified by a style +declaration in a RC file, and then bound to widgets +with a widget, widget_class, +or class declaration. All styles +applying to a particular widget are composited together +with widget declarations overriding +widget_class declarations which, in +turn, override widget declarations. +Within each type of declaration, later declarations override +earlier ones. + + + +Within a style declaration, the possible +elements are: + + + + bg[state] = + color + + + Set color used for the background of most widgets. + + + + + fg[state] = + color + + + Set color used for the foreground of most widgets. + + + + + base[state] = + color + + + Set color used for the background of widgets displaying + editable text. This color is used for the background + of, among others, #GtkText, #GtkEntry, #GtkList, and #GtkClist. + + + + + text[state] = + color + + + Set color used for foreground of widgets using + base for the background color. + + + + + bg_text[state] = + color + + + Set a background pixmap to be used in place of + the bg color (or for #GtkText, + in place of the base color. + + + + + font = font + + + Set the font for a widget. + + + + + fontset = font + + + Set the fontset for a widget. Overrides any + font declarations. + + + + + + +The colors and background pixmaps are specified as a function of the +state of the widget. The states are: + + + + NORMAL + + + A color used for a widget in its normal state + + + + + ACTIVE + + + A variant of the NORMAL color used when the + widget is in the %GTK_STATE_ACTIVE state, and also for + the trough of a ScrollBar, tabs of a NoteBook + other than the current tab and similar areas. + Frequently, this should be a darker variant + of the NORMAL color. + + + + + PRELIGHT + + + A color used for widgets in the %GTK_STATE_PRELIGHT state. This + state is the used for Buttons and MenuItems + that have the mouse cursor over them, and for + their children. + + + + + SELECTED + + + A color used to highlight data selected by the user. + for instance, the selected ListItems in a List widget, and the + selection in an Editable widget. + + + + + INSENSITIVE + + + A color used for the background of widgets that have + been set insenstivie with gtk_widget_set_senstive() + + + + + + + +Colors can be specified as a string "#rrrrggggbbbb", +"#rrrgggbbb", "#rrggbb", +or "#rgb", where r +g, and b are +hex digits, or they can be specified as a triplet of floats +{ r, g, +b}. + + + +Key bindings + +Key bindings allow the user to specify actions to be +taken on particular key presses. The form of a binding +set declaration is: + + + +binding name { + bind key { + signalname (param, ...) + ... + } + ... +} + + + +key is a string consisting of a +series of modifiers followed by the name of a key. The +modifiers can be: + +<alt> +<control> +<mod1> +<mod2> +<mod3> +<mod4> +<mod5> +<release> +<shft> +<shift> + +<shft> is an alias for +<shift> and +<alt> is an alias for +<mod1>. + + + +The action that is bound to the key is a sequence +of signal names (strings) followed by parameters for +each signal. The signals must be action signals. +(See gtk_signal_new()). Each parameter can be +a float, integer, string, or unquoted string +representing an enumeration value. The types of +the parameters specified must match the types of the +parameters of the signal. + + + +Binding sets are connected to widgets in the +same manner as styles, with one addition. +A priority can be specified for each pattern, +and within each type of pattern, binding sets +override other binding sets first by priority, +and only then by order of specification. (Later +overrides earlier). The priorities that can +be specified are (highest to lowest): + +HIGHEST +RC +APPLICATION +GTK +LOWEST + +RC is the default for bindings +read from an RC file, APPLICATION +should be used for bindings an application sets +up, and GTK is used for bindings +that GTK+ creates internally. + + + + + + + + + + +The #GtkRcStyle structure is used to represent a set +of information about the appearance of a widget. +This can later be composited together with other +#GtkRcStyle structures to form a #GtkStyle. + + +@name: +@font_name: +@fontset_name: +@bg_pixmap_name: +@color_flags: +@fg: +@bg: +@text: +@base: +@engine: +@engine_data: +@ref_count: + + + +The #GtkRcFlags enumeration is used as a bitmask +to specify which fields of a #GtkRcStyle have been +set for each state. + + + %GTK_RC_FG + + + If present, the foreground color has been set for this state. + + + + %GTK_RC_BG + + + If present, the background color has been set for this state. + + + + %GTK_RC_TEXT + + + If present, the text color has been set for this state. + + + + %GTK_RC_BASE + + + If present, the base color has been set for this state. + + + + + +@GTK_RC_FG: +@GTK_RC_BG: +@GTK_RC_TEXT: +@GTK_RC_BASE: + + + +A GtkImageLoader is used to load a filename found in +a RC file. + + +@window: the window for creating image +@colormap: the colormap for this image +@mask: a pointer to the location to store the mask +@transparent_color: the transparent color for the image +@filename: filename to load +@Returns: a #GtkPixmap representing @filename + + + + +The #GtkRcTokenType enumeration represents the tokens +in the RC file. It is exposed so that theme engines +can reuse these tokens when parsing the theme-engine +specific portions of a RC file. + + +@GTK_RC_TOKEN_INVALID: +@GTK_RC_TOKEN_INCLUDE: +@GTK_RC_TOKEN_NORMAL: +@GTK_RC_TOKEN_ACTIVE: +@GTK_RC_TOKEN_PRELIGHT: +@GTK_RC_TOKEN_SELECTED: +@GTK_RC_TOKEN_INSENSITIVE: +@GTK_RC_TOKEN_FG: +@GTK_RC_TOKEN_BG: +@GTK_RC_TOKEN_BASE: +@GTK_RC_TOKEN_TEXT: +@GTK_RC_TOKEN_FONT: +@GTK_RC_TOKEN_FONTSET: +@GTK_RC_TOKEN_BG_PIXMAP: +@GTK_RC_TOKEN_PIXMAP_PATH: +@GTK_RC_TOKEN_STYLE: +@GTK_RC_TOKEN_BINDING: +@GTK_RC_TOKEN_BIND: +@GTK_RC_TOKEN_WIDGET: +@GTK_RC_TOKEN_WIDGET_CLASS: +@GTK_RC_TOKEN_CLASS: +@GTK_RC_TOKEN_LOWEST: +@GTK_RC_TOKEN_GTK: +@GTK_RC_TOKEN_APPLICATION: +@GTK_RC_TOKEN_RC: +@GTK_RC_TOKEN_HIGHEST: +@GTK_RC_TOKEN_ENGINE: +@GTK_RC_TOKEN_MODULE_PATH: +@GTK_RC_TOKEN_LAST: + + + +Finds all matching RC styles for a given widget, +composites them together, and then creates a +#GtkStyle representing the composite appearance. +(GTK+ actually keeps a cache of previously +created styles, so a new style may not be +created.) + + +@widget: a #GtkWidget +@Returns: the resulting style. The caller should +reference the result, since GTK+ will retain the +initial reference count itself for the cache +of created styles. + + + + +Add a RcStyle that will be looked up by a match against +the widget's pathname. This is equivalent to a: + +widget PATTERN style STYLE + +statement in a RC file. + + +@rc_style: the #GtkRcStyle to use for widgets matching @pattern +@pattern: the pattern + + + + +Add a RcStyle that will be looked up by a match against +the widget's class pathname. This is equivalent to a: + + +widget_class PATTERN style STYLE + +statement in a RC file. + + +@rc_style: the #GtkRcStyle to use for widgets matching @pattern +@pattern: the pattern + + + + +Add a RcStyle that will be looked up by a matching against +the class heirarchy of the widget. This is equivalent to a: + +class PATTERN style STYLE + +statement in a RC file. + + +@rc_style: the #GtkRcStyle to use for widgets deriving from @pattern +@pattern: the pattern + + + + +Parse a given resource file. + + +@filename: the filename of a file to parse. + + + + +Parse resource information directly from a string. + + +@rc_string: a string to parse. + + + + +If the modification time on any previously read file +has changed, discard all style information +and then reread all previously read RC files. + + +@Returns: %TRUE if the files were reread. + + + + +Adds a file to the list of files to be parsed at the +end of gtk_init(). + + +@filename: the pathname to the file. + + + + +Retrieves the current list of RC files that will be parsed +at the end of gtk_init() + + +@Returns: A NULL terminated array of filenames. This memory +is owned by GTK+ and must not be freed by the application. +If you want to store this information, you should make a +copy. + + + + +Sets the list of files that GTK+ will read at the +end of gtk_init() + + +@filenames: A %NULL terminated list of filenames. + + + + +Parses a color in the format expected in a RC file. + + +@scanner: a #GtkScanner +@color: a pointer to a #GtkColor structure in which to store the result +@Returns: %G_TOKEN_NONE if parsing suceeded, otherwise the token +that was expected but not found. + + + + +Parses a #GtkStateType variable from the format expected +in a RC file. + + +@scanner: a #GtkScanner (must be initialized for parsing an RC file) +@state: A pointer to a #GtkStateType variable in which to +store the result. +@Returns: %G_TOKEN_NONE if parsing suceeded, otherwise the token +that was expected but not found. + + + + +Parses a #GtkPathPriorityType variable from the format expected +in a RC file. + + +@scanner: a #GtkScanner (must be initialized for parsing an RC file) +@priority: A pointer to #GtkPathPriorityType variable in which +to store the result. +@Returns: %G_TOKEN_NONE if parsing suceeded, otherwise the token +that was expected but not found. + + + + +Looks up a file in the current module path. + + +@module_file: The name of the module to search for. +@Returns: The filename, if found. (Must be freed with g_free()), +otherwise %NULL. + + + + +Looks up a file in the current pixmap path. If the file is +not found, it outputs a warning message using g_warning() +and returns %NULL. + + +@scanner: a #GtkScanner. Used for printing out warning messages +if the file is not found. +@pixmap_file: The name of the file to search for. +@Returns: The filename, if found. (Must be freed with g_free()), +otherwise %NULL. + + + + +Returns the directory in which GTK+ will look for +theme engines. + + +@Returns: The directory. (Must be freed with g_free()) + + + + +Returns the standard directory in which themes should +be installed. (GTK+ does not actually use this directory +itself.) + + +@Returns: The directory. (Must be freed with g_free()) + + + + +Sets the function that GTK+ will use to load images + + +@loader: the #GtkImageLoader to use + + + + +Internal function. Loads an image using the current +image loader. + + +@colormap: the colormap to use for the image +@transparent_color: the transparent color for the image +@filename: the filename of the image file +@Returns: a #GtkPixmap representing @filename + + + + +Create a new #GtkRcStyle with no fields set and +a reference count of 1. + + +@Returns: the newly create #GtkRcStyle + + + + +Increment the reference count of a #GtkRcStyle. + + +@rc_style: a #GtkRcStyle + + + + +Decrement the reference count of a #GtkRcStyle and +free if the result is 0. + + +@rc_style: a #GtkRcStyle + + + + +Internal function. + + + + diff --git a/docs/reference/gtk/tmpl/gtkruler.sgml b/docs/reference/gtk/tmpl/gtkruler.sgml new file mode 100644 index 0000000000..2dcf0028ac --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkruler.sgml @@ -0,0 +1,81 @@ + +GtkRuler + + + + + + + + + + + + + + + + + + + +@widget: +@backing_store: +@non_gr_exp_gc: +@metric: +@xsrc: +@ysrc: +@slider_size: +@lower: +@upper: +@position: +@max_size: + + + + + + +@metric_name: +@abbrev: +@pixels_per_unit: +@ruler_scale: +@subdivide: + + + + + + +@ruler: +@metric: + + + + + + + +@ruler: +@lower: +@upper: +@position: +@max_size: + + + + + + + +@ruler: + + + + + + + +@ruler: + + diff --git a/docs/reference/gtk/tmpl/gtkscale.sgml b/docs/reference/gtk/tmpl/gtkscale.sgml new file mode 100644 index 0000000000..8eaf201008 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkscale.sgml @@ -0,0 +1,100 @@ + +GtkScale + + +a base class for #GtkHScale and #GtkVScale. + + + +The #GtkScale widget is an abstract class, used only for deriving the +subclasses #GtkHScale and #GtkVScale. + + + + + + + + + +The #GtkScale-struct struct contains the following fields. +(These fields should be considered read-only. They should never be set by +an application.) + + + + + + +#guint draw_value; +non-zero if the scale's current value is displayed next to the +slider. + + + +#guint value_pos; +the position in which the textual value is displayed, selected from +#GtkPositionType. + + + + + +@range: +@draw_value: +@value_pos: + + + +Sets the number of decimal places that are displayed in the value. + + +@scale: a #GtkScale. +@digits: the number of decimal places to display, e.g. use 1 to display 1.0, +2 to display 1.00 etc. + + + + +Specifies whether the current value is displayed as a string next to the +slider. + + +@scale: a #GtkScale. +@draw_value: + + + + +Sets the position in which the current value is displayed. + + +@scale: a #GtkScale. +@pos: the position in which the current value is displayed. + + + + +An internal function used to get the maximum width needed to display the value +string. + + +@scale: a #GtkScale. +@Returns: the maximum width needed to display the value string. + + + + +The number of decimal places that are displayed in the value. + + + + +If the current value is displayed as a string next to the slider. + + + + +The position in which the current value is displayed. + + diff --git a/docs/reference/gtk/tmpl/gtkscrollbar.sgml b/docs/reference/gtk/tmpl/gtkscrollbar.sgml new file mode 100644 index 0000000000..a459493b09 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkscrollbar.sgml @@ -0,0 +1,23 @@ + +GtkScrollbar + + + + + + + + + + + + + + + + + + + +@range: + diff --git a/docs/reference/gtk/tmpl/gtkscrolledwindow.sgml b/docs/reference/gtk/tmpl/gtkscrolledwindow.sgml new file mode 100644 index 0000000000..02163acd9c --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkscrolledwindow.sgml @@ -0,0 +1,199 @@ + +GtkScrolledWindow + + + +Adds scrollbars to its child widget. + + + +#GtkScrolledWindow is a #GtkBin subclass: it's a container +the accepts a single child widget. #GtkScrolledWindow adds scrollbars +to the child widget. + + + +The scrolled window can work in two ways. Some widgets have native +scrolling support; these widgets have "slots" for #GtkAdjustment +objects. The scrolled window installs #GtkAdjustment objects in the +child window's slots using the set_scroll_adjustments_signal, found in +#GtkWidgetClass. (Conceptually, these widgets implement a "Scrollable" +interface; because GTK+ 1.2 lacks multiple inheritance, this interface +is hackily implemented as a signal in #GtkWidgetClass.) + + + +The second way to use the scrolled window is useful with widgets that +lack the set_scroll_adjustments_signal. The #GtkViewport widget acts as +a proxy, implementing scrollability for child widgets that lack their +own scrolling capabilities. + + + +If a widget has native scrolling abilities, it can be added to the +#GtkScrolledWindow with gtk_container_add(). If a widget does not, you +must first add the widget to a #GtkViewport, then add the GtkViewport +to the scrolled window. The convenience function +gtk_scrolled_window_add_with_viewport() does exactly this, so you can +ignore the presence of the viewport. + + + + +#GtkViewport, #GtkAdjustment, #GtkWidgetClass + + + + +There are no public fields in the #GtkScrolledWindow struct; it should +only be accessed using the functions below. + + +@container: +@hscrollbar: +@vscrollbar: +@hscrollbar_policy: +@vscrollbar_policy: +@hscrollbar_visible: +@vscrollbar_visible: +@window_placement: + + + +Creates a new scrolled window. The two arguments are the scrolled +window's adjustments; these will be shared with the scrollbars and the +child widget to keep the bars in sync with the child. Usually you want +to pass NULL for the adjustments, which will cause the scrolled window +to create them for you. + + +@hadjustment: Horizontal adjustment. +@vadjustment: Vertical adjustment. +@Returns: New scrolled window. + + + + +Returns the horizontal scrollbar's adjustment, used to connect the +horizontal scrollbar to the child widget's horizontal scroll +functionality. + + +@scrolled_window: A #GtkScrolledWindow. +@Returns: The horizontal #GtkAdjustment. + + + + +Returns the vertical scrollbar's adjustment, used to connect the +vertical scrollbar to the child widget's vertical scroll +functionality. + + +@scrolled_window: A #GtkScrolledWindow. +@Returns: The vertical #GtkAdjustment. + + + + +Sets the scrollbar policy for the horizontal and vertical scrollbars. +The policy determines when the scrollbar should appear; it is a value +from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the +scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is +never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only +if needed (that is, if the slider part of the bar would be smaller +than the trough - the display is larger than the page size). + + +@scrolled_window: A #GtkScrolledWindow. +@hscrollbar_policy: Policy for horizontal bar. +@vscrollbar_policy: Policy for vertical bar. + + + + +Used to add children without native scrolling capabilities. This is +simply a convenience function; it is equivalent to adding the +unscrollable child to a viewport, then adding the viewport to the +scrolled window. If a child has native scrolling, use +gtk_container_add() instead of this function. + + + +The viewport scrolls the child by moving its #GdkWindow, and takes the +size of the child to be the size of its toplevel #GdkWindow. This will +be very wrong for most widgets that support native scrolling; for +example, if you add a #GtkCList with a viewport, the whole widget will +scroll, including the column headings. Thus #GtkCList supports +scrolling already, and should not be used with the #GtkViewport proxy. + + + +A widget supports scrolling natively if the +set_scroll_adjustments_signal field in #GtkWidgetClass is non-zero, +i.e. has been filled in with a valid signal identifier. + + +@scrolled_window: A #GtkScrolledWindow. +@child: Widget you want to scroll. + + + + +Sets the #GtkAdjustment for the horizontal scrollbar. + + +@scrolled_window: A #GtkScrolledWindow. +@hadjustment: Horizontal scroll adjustment. + + + + +Determines the location of the child widget with respect to the +scrollbars. The default is %GTK_CORNER_TOP_LEFT, meaning the child is +in the top left, with the scrollbars underneath and to the right. +Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT, +%GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT. + + +@scrolled_window: A #GtkScrolledWindow. +@window_placement: Position of the child window. + + + + +Sets the #GtkAdjustment for the vertical scrollbar. + + +@scrolled_window: A #GtkScrolledWindow. +@hadjustment: + +@vadjustment: Vertical scroll adjustment. + + + + +Horizontal adjustment. See gtk_scrolled_window_set_hadjustment(), gtk_scrolled_window_get_hadjustment(). + + + + +Vertical adjustment. See gtk_scrolled_window_set_vadjustment(), gtk_scrolled_window_get_vadjustment(). + + + + +Horizontal scrollbar policy (show scrollbar always, never, or "when appropriate"). + + + + +Vertical scrollbar policy (show scrollbar always, never, or "when appropriate"). + + + + +Position of child window with respect to scrollbars; top left, top +right, bottom left, bottom right. + + diff --git a/docs/reference/gtk/tmpl/gtkselection.sgml b/docs/reference/gtk/tmpl/gtkselection.sgml new file mode 100644 index 0000000000..6e873df058 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkselection.sgml @@ -0,0 +1,270 @@ + +Selections + + +Functions for handling inter-process communication via selections. + + + + +See the documentation for #GtkWidget for descriptions +of the "selection_get" and "selection_received" signals. + + + + + + + + + +A #GtkTargetEntry structure represents a single type of +data than can be supplied for by a widget for a selection +or for supplied or received during drag-and-drop. It +contains a string representing the drag type, a flags +field (used only for drag and drop - see #GtkTargetFlags), +and an application assigned integer ID. The integer +ID will later be passed as a signal parameter for signals +like "selection_get". It allows the application to identify +the target type without extensive string compares. + + +@target: +@flags: +@info: + + + +A #GtkTargetList structure is a reference counted list +of #GtkTargetPair. It is used to represent the same +information as a table of #GtkTargetEntry, but in +an efficient form. This structure should be treated as +opaque. + + +@list: +@ref_count: + + + +Internally used structure in the drag-and-drop and +selection handling code. + +@target: +@flags: +@info: + + + +Create a new #GtkTargetList from an array of #GtkTargetEntry. + + +@targets: Pointer to an array of #GtkTargetEntry +@ntargets: number of entries in @targets. +@Returns: the new #GtkTargetList. + + + + +Increase the reference count of a #GtkTargetList by one. + + +@list: a #GtkTargetList + + + + +Decrease the reference count of a #GtkTargetList by one. +If the resulting reference count is zero, free the list. + + +@list: a #GtkTargetList + + + + +Add another target to a #GtkTargetList + + +@list: a #GtkTargetList +@target: the interned atom representing the target +@flags: the flags for this target +@info: an ID that will be passed back to the application + + + + +Add a table of #GtkTargetEntry into a target list + + +@list: a #GtkTargetList +@targets: the table of #GtkTargetEntry +@ntargets: number of targets in the table + + + + +Remove a target from a target list + + +@list: a #GtkTargetList +@target: the interned atom representing the target + + + + +Look up a given target in a #GtkTargetList + + +@list: a #GtkTargetList +@target: an interned atom representing the target to search for +@info: a pointer to the location to store application info for target +@Returns: %TRUE if the target was found, otherwise %FALSE + + + + +Claim ownership of a given selection for a particular widget, +or, if @widget is %NULL, release ownership of the selection. + + +@widget: a #GtkWidget, or %NULL. +@selection: an interned atom representing the selection to claim +@time: the time stamp for claiming the selection +@Returns: %TRUE if the operation succeeded + + + + +Add specified target to the list of supported targets for a +given widget and selection. + + +@widget: a #GtkTarget +@selection: the selection +@target: target to add. +@info: A unsigned integer which will be passed back to the application. + + + + +Add a table of targets to the list of supported targets +for a given widget and selection. + + +@widget: a #GtkWidget +@selection: the selection +@targets: a table of targets to add +@ntargets: number of entries in @targets + + + + +Request the contents of a selection. When received, +a "selection_received" signal will be generated. + + +@widget: The widget which acts as requestor +@selection: Which selection to get +@target: Form of information desired (e.g., STRING) +@time: Time of request (usually of triggering event) + In emergency, you could use GDK_CURRENT_TIME +@Returns: TRUE if requested succeeded. FALSE if we could not process + request. (e.g., there was already a request in process for + this widget). + + + + +Store new data into a GtkSelectionData object. Should +_only_ by called from a selection handler callback. +Null terminates the stored data. + + +@selection_data: +@type: the type of selection data +@format: format (number of bits in a unit) +@data: pointer to the data (will be copied) +@length: length of the data + + + + +Removes all handlers and unsets ownership of all +selections for a widget. Called when widget is being +destroyed. This function will not generally be +called by applications. + + +@widget: a #GtkWidget + + + + +Make a copy of a #GtkSelection data structure and its +data. + + +@data: a pointer to a #GtkSelectionData structure. +@Returns: a pointer to a copy of @data. + + + + +Free a #GtkSelectionData structure returned from +gtk_selection_data_copy(). + + +@data: a pointer to a #GtkSelectionData structure. + + + + +Internal function. + + +@widget: +@event: +@Returns: + + + + +Internal function. + + +@window: +@event: +@Returns: + + + + +Internal function. + + +@widget: +@event: +@Returns: + + + + +Internal function. + + +@widget: +@event: +@Returns: + + + + +Internal function. + + +@widget: +@event: +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkseparator.sgml b/docs/reference/gtk/tmpl/gtkseparator.sgml new file mode 100644 index 0000000000..1f116c1d4e --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkseparator.sgml @@ -0,0 +1,24 @@ + +GtkSeparator + + +a base class for #GtkHSeparator and #GtkVseparator. + + + +The #GtkSeparator widget is an abstract class, used only for deriving the +subclasses #GtkHSeparator and #GtkVSeparator. + + + + + + + + + +The #GtkSeparator-struct struct contains private data only. + + +@widget: + diff --git a/docs/reference/gtk/tmpl/gtksignal.sgml b/docs/reference/gtk/tmpl/gtksignal.sgml new file mode 100644 index 0000000000..3a450f3246 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtksignal.sgml @@ -0,0 +1,473 @@ + +Signals + + + + + + + + + + + + + + + + + + + +@struct: +@field: + + + + + + + +@object: +@data: +@nparams: +@args: +@arg_types: +@return_type: + + + + + + + +@data: + + + + + + + +@object: +@signal_id: +@n_params: +@params: +@data: +@Returns: + + + + + + + +@object_type: +@signal_id: +@signal_name: +@is_user_signal: +@signal_flags: +@return_val: +@nparams: +@params: + + + + + + + + + + + + + +@name: +@signal_flags: +@object_type: +@function_offset: +@marshaller: +@return_val: +@nparams: +@Varargs: +@Returns: + + + + + + + +@name: +@signal_flags: +@object_type: +@function_offset: +@marshaller: +@return_val: +@nparams: +@params: +@Returns: + + + + + + + +@name: +@object_type: +@Returns: + + + + + + + +@signal_id: +@Returns: + + + + + + + +@object: +@signal_id: +@Varargs: + + + + + + + +@object: +@name: +@Varargs: + + + + + + + +@object: +@signal_id: +@params: + + + + + + + +@object: +@name: +@params: + + + + + + + +@object: +@signal_id: +@Returns: + + + + + + + +@object: +@name: +@Returns: + + + + + + + +@object: +@signal_id: + + + + + + + +@object: +@name: + + + + + + + +@object: +@name: +@func: +@func_data: +@Returns: + + + + + + + +@object: +@name: +@func: +@func_data: +@Returns: + + + + + + + +@object: +@name: +@func: +@slot_object: +@Returns: + + + + + + + +@object: +@name: +@func: +@slot_object: +@Returns: + + + + + + + +@object: +@name: +@func: +@marshal: +@data: +@destroy_func: +@object_signal: +@after: +@Returns: + + + + + + + +@object: +@signal: +@func: +@alive_object: + + + + + + + +@object: +@signal: +@func: +@func_data: +@alive_object: + + + + + + + +@object: +@handler_id: + + + + + + + +@object: +@func: +@data: + + + + + + + +@object: +@data: + + + + + + + +@object: +@handler_id: + + + + + + + +@object: +@func: +@data: + + + + + + + +@object: +@data: + + + + + + + +@object: +@handler_id: + + + + + + + +@object: +@func: +@data: + + + + + + + +@object: +@data: + + + + + + + +@object: +@signal_id: +@may_be_blocked: +@Returns: + + + + + + + +@object: +@signal_id: +@may_be_blocked: +@func: +@data: +@Returns: + + + + + + + +@object: +@handler_id: +@may_be_blocked: +@Returns: + + + + + + + +@object: + + + + + + + +@marshal_func: +@destroy_func: + + + + + + + +@signal_id: +@Returns: + + + + + + + +@signal_id: +@hook_func: +@data: +@Returns: + + + + + + + +@signal_id: +@hook_func: +@data: +@destroy: +@Returns: + + + + + + + +@signal_id: +@hook_id: + + diff --git a/docs/reference/gtk/tmpl/gtksocket.sgml b/docs/reference/gtk/tmpl/gtksocket.sgml new file mode 100644 index 0000000000..ae9ea670f2 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtksocket.sgml @@ -0,0 +1,132 @@ + +GtkSocket + + +Container for widgets from other processes. + + + +Together with #GtkPlug, #GtkSocket provides the ability +to embed widgets from one process into another process +in a fashion that is transparent to the user. One +process creates a #GtkSocket widget and, passes the +XID of that widget's window to the other process, +which then creates a #GtkPlug window with that XID. +Any widgets contained in the #GtkPlug then will appear +inside the first applications window. + + + +The XID of the socket's window is obtained by using +the GTK_WINDOW_XWINDOW() macro from the header +file <gdk/gdkx.h>. Before using this macro, +the socket must have been realized, and for hence, +have been added to its parent. + + + Obtaining the XID of a socket + +#include <gdk/gdkx.h> + +GtkWidget *socket = gtk_socket_new(); +gtk_widget_show (socket); +gtk_container_add (GTK_CONTAINER (parent), socket); + +/* The following call is only necessary if one of + * the ancestors of the socket is not yet visible. + */ +gtk_widget_realize (socket); +g_print ("The XID of the sockets window is %#x\n", + GDK_WINDOW_XWINDOW (socket->window)); + + + + + +Note that if you pass the XID of the socket to another +process that will create a plug in the socket, you +must make sure that the socket widget is not destroyed +until that plug is created. Violating this rule will +cause unpredictable consequences, the most likely +consequence being that the plug will appear as a +separate toplevel window. You can check if the plug +has been created by examining the +plug_window field of the +#GtkSocket structure. If this field is non-NULL, +then the plug has been succesfully created inside +of the socket. + + + +When GTK+ is notified that the embedded window has been +destroyed, then it will destroy the socket as well. You +should always, therefore, be prepared for your sockets +to be destroyed at any time when the main event loop +is running. + + + +A socket can also be used to swallow arbitrary +pre-existing top-level windows using gtk_socket_steal(), +though the integration when this is done will not be as close +as between a #GtkPlug and a #GtkSocket. + + + + + + +#GtkPlug +the widget that plugs into a #GtkSocket. + + + + + + + +The #GtkEditable structure contains the following field. +(This field should be considered read-only. It should +never be set by an application.) + + + + + + +#GdkWindow *plug_window; +the window embedded inside this #GtkSocket. + + + + + +@container: +@request_width: +@request_height: +@current_width: +@current_height: +@plug_window: +@same_app: +@focus_in: +@have_size: +@need_map: + + + +Create a new empty #GtkSocket. + + +@Returns: the new #GtkSocket. + + + + +Reparents a pre-existing toplevel window into a +#GtkSocket. + + +@socket: a #GtkSocket. +@wid: the XID of an existing toplevel window. + + diff --git a/docs/reference/gtk/tmpl/gtkspinbutton.sgml b/docs/reference/gtk/tmpl/gtkspinbutton.sgml new file mode 100644 index 0000000000..661ea26e1c --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkspinbutton.sgml @@ -0,0 +1,385 @@ + +GtkSpinButton + + +retrieve an integer or floating-point number from the user. + + + +A #GtkSpinButton is an ideal way to allow the user to set the value of some attribute. Rather than having to directly type a number into a #GtkEntry, #GtkSpinButton allows the user to click on one of two arrows to increment or decrement the displayed value. A value can still be typed in, with the bonus that it can be checked to ensure it is in a given range. + + +The main properties of a #GtkSpinButton are through a #GtkAdjustment. See the #GtkAdjustment section for more details about an adjustment's properties. + + +#GtkSpinButton widgets are created with a call to gtk_spin_button_new(). + + +The #GtkAdjustment of a spin button can be set or retrieved with a call to gtk_spin_button_set_adjustment() or gtk_spin_button_get_adjustment(), respectively. + + +The number of digits after the decimal point of a spin button can be altered with gtk_spin_button_set_digits(). + + +To retrieve values from a spin button, use gtk_spin_button_get_value_as_float() if you require a floating point number, or gtk_spin_button_get_value_as_int() if you require an integer. + + +To set the value of a #GtkSpinButton, use gtk_spin_button_set_value(). To change the update behaviour of a spin button, use gtk_spin_button_set_update_policy(). + + +When a spin button reaches it's upper or lower limit, it can either stop spinning, or wrap around and continue spinning from the opposite limit. For example, if five is the upper limit and the lower limit is zero, upon reaching the value five, the spin button can change it's value back to zero and continue spinning upwards. +This behaviour is set with gtk_spin_button_set_wrap(). + + +A border around a spin button's arrows can be created using gtk_spin_button_set_shadow_type(). + + +A number may be entered that is invalid, given a spin button's range. An erroneous number can be corrected as soon as the spin button is 'activated' using gtk_spin_button_snap_to_ticks(), which will alter the current value to the nearest step increment. (See #GtkAdjustment for step increments). + + +Because a spin contains a #GtkEntry, alphabetic characters may be entered. These can be ignored by using gtk_spin_button_set_numeric() with a value of TRUE. Then only numeric values, '-' and a decimal point will be accepted. + + +To manually increment or decrement the spin button, use gtk_spin_button_spin(), and to force an update (refresh), use gtk_spin_button_update(). + + + +Using a GtkSpinButton to get an integer. + + +/* Provides a function to retrieve an integer value from a GtkSpinButton + * and creates a spin button to model percentage values. + */ + +gint grab_int_value (GtkSpinButton *a_spinner, gpointer user_data) { + return gtk_spin_button_get_value_as_int (a_spinner); +} + +void create_integer_spin_button(void) { + + GtkWidget *window, *spinner; + GtkAdjustment *spinner_adj; + + spinner_adj = (GtkAdjustment *) gtk_adjustment_new(50.0, 0.0, 100.0, 1.0, 5.0, 5.0); + + window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_container_set_border_width (GTK_CONTAINER (window), 5); + + /* creates the spinner, with no decimal places */ + spinner = gtk_spin_button_new (spinner_adj, 1.0, 0); + gtk_container_add (GTK_CONTAINER(window), spinner); + + gtk_widget_show_all (window); + return; +} + + + + + + + +Using a GtkSpinButton to get a floating point value. + + +/* Provides a function to retrieve a floating point value from a + * GtkSpinButton, and creates a high precision spin button. + */ + +gfloat grab_int_value (GtkSpinButton *a_spinner, gpointer user_data) { + return gtk_spin_button_get_value_as_float (a_spinner); +} + +void create_floating_spin_button(void) { + + GtkWidget *window, *spinner; + GtkAdjustment *spinner_adj; + + spinner_adj = (GtkAdjustment *) gtk_adjustment_new(2.500, 0.0, 5.0, 0.001, 0.1, 0.1); + + window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_container_set_border_width (GTK_CONTAINER (window), 5); + + /* creates the spinner, with three decimal places */ + spinner = gtk_spin_button_new (spinner_adj, 0.001, 3); + gtk_container_add (GTK_CONTAINER(window), spinner); + + gtk_widget_show_all (window); + return; +} + + + + + + + + + +#GtkEntry +retrieve text rather than numbers. + + + + + + +entry is the #GtkEntry part of the #GtkSpinButton widget, and can be used accordingly. All other fields contain private data and should only be modified using the functions below. + + +@entry: +@adjustment: +@panel: +@shadow_type: +@timer: +@ev_time: +@climb_rate: +@timer_step: +@update_policy: +@in_child: +@click_child: +@button: +@need_timer: +@timer_calls: +@digits: +@numeric: +@wrap: +@snap_to_ticks: + + + + + + + + +GTK_UPDATE_ALWAYS +When refreshing your #GtkSpinButton, the value is always displayed. + + +GTK_UPDATE_IF_VALID +When refreshing your #GtkSpinButton, the value is only displayed if it is valid within the bounds of the spin button's #GtkAdjustment. + + + + +@GTK_UPDATE_ALWAYS: +@GTK_UPDATE_IF_VALID: + + + + + + + + +GTK_SPIN_STEP_FORWARD, +GTK_SPIN_STEP_BACKWARD, +GTK_SPIN_PAGE_FORWARD, +GTK_SPIN_PAGE_BACKWARD +These values spin a #GtkSpinButton by the relevant values of the spin button's #GtkAdjustment. + + +GTK_SPIN_HOME, +GTK_SPIN_END +These set the spin button's value to the minimum or maxmimum possible values, (set by it's #GtkAdjustment), respectively. + + +GTK_SPIN_USER_DEFINED +The programmer must specify the exact amount to spin the #GtkSpinButton. + + + + +@GTK_SPIN_STEP_FORWARD: +@GTK_SPIN_STEP_BACKWARD: +@GTK_SPIN_PAGE_FORWARD: +@GTK_SPIN_PAGE_BACKWARD: +@GTK_SPIN_HOME: +@GTK_SPIN_END: +@GTK_SPIN_USER_DEFINED: + + + +Changes the properties of an existing spin button. The adjustment, climb rate, and number of decimal places are all changed accordingly, after this function call. + + +@spin_button: a #GtkSpinButton. +@adjustment: a #GtkAdjustment. +@climb_rate: the new climb rate. +@digits: the number of decimal places to display in the spin button. + + + + +Creates a new #GtkSpinButton. + + +@adjustment: the #GtkAdjustment object that this spin button should use. +@climb_rate: specifies how much the spin button changes when an arrow is clicked on. +@digits: the number of decimal places to display. +@Returns: a #GtkWidget. + + + + +Changes which #GtkAdjustment is associated with a spin button. + + +@spin_button: a #GtkSpinButton. +@adjustment: a #GtkAdjustment. + + + + +Retrieves the #GtkAdjustment used by a given spin button. + + +@spin_button: a #GtkSpinButton. +@Returns: a #GtkAdjustment. + + + + +Alters the number of decimal places that are displayed in a spin button. + + +@spin_button: a #GtkSpinButton. +@digits: the number of decimal places. + + + + +Retrieves the current value of a #GtkSpinButton. If the number has no decimal places, it is converted to a float before the function returns. + + +@spin_button: a #GtkSpinButton. +@Returns: the value of @spin_button as a #gfloat. + + + + +Retrieves the current integer value of a #GtkSpinButton. + + +@spin_button: a #GtkSpinButton. +@Returns: the value of @spin_button as a #gint. + + + + +Sets the value of a spin button. + + +@spin_button: a #GtkSpinButton. +@value: the new floating point value. + + + + +Changes the way a spin button refreshes and updates itself. See %GtkSpinButtonUpdatePolicy for more information. + + +@spin_button: a #GtkSpinButton. +@policy: the new update policy. + + + + +Sets how the spin button's #GtkEntry reacts to alphabetic characters. A value of TRUE to @numeric means that all non-numeric characters (except '-' and a decimal point) are ignored. + + +@spin_button: a #GtkSpinButton. +@numeric: whether letters should be ignored. + + + + +Performs an explicit 'spin' on a spin button. + + +@spin_button: a #GtkSpinButton. +@direction: the type of spin to perform. +@increment: the amount to spin. + + + + +Sets a spin button's value to the lower limit when it's upper limit is reached, and vice versa. + + +@spin_button: a #GtkSpinButton. +@wrap: defaults to FALSE, set to TRUE to make the spin button wrap. + + + + +Creates a border around the arrows of a #GtkSpinButton. The type of border is determined by @shadow_type. + + +@spin_button: a #GtkSpinButton +@shadow_type: the new border type. + + + + +Sets whether a number typed into a spin button should be snapped to the nearest step increment. + + +@spin_button: a #GtkButton. +@snap_to_ticks: TRUE or FALSE. + + + + +Refreshes a spin button. The behaviour of the update is determined by gtk_spin_button_set_update_policy(). + + +@spin_button: a #GtkSpinButton. + + + + +the #GtkAdjustment that defines a spin button's main properties. + + + + +the amount a spin button changes when an arrow is clicked. + + + + +the number of decimal places to display. + + + + +whether erroneous values are automatically changed to a spin button's nearest step increment. + + + + +whether non-numeric characters should be ignored. + + + + +whether a spin button should wrap upon reaching its limits. + + + + +how a spin button should be updated. + + + + +the type of border that surrounds the arrows of a spin button. + + + + +reads the current value, or sets a new value. + + diff --git a/docs/reference/gtk/tmpl/gtkstatusbar.sgml b/docs/reference/gtk/tmpl/gtkstatusbar.sgml new file mode 100644 index 0000000000..13fa228c75 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkstatusbar.sgml @@ -0,0 +1,136 @@ + +GtkStatusbar + + +report messages of minor importance to the user. + + + +A #GtkStatusbar is usually placed along the bottom of an application's main +#GtkWindow. It may provide a regular commentary of the application's status +(as is usually the case in a web browser, for example), or may be used to +simply output a message when the status changes, (when an upload is complete +in an FTP client, for example). + + +Status bars in Gtk+ maintain a stack of messages. The message at +the top of the each bar's stack is the one that will currently be displayed. + + +Any messages added to a statusbar's stack must specify a context_id +that is used to uniquely identify the source of a message. This context_id can be +generated by gtk_statusbar_get_context_id(), given a message and the +statusbar that it will be added to. Note that messages are stored in a +stack, and when choosing which message to display, the stack structure is +adhered to, regardless of the context identifier of a message. + + +Status bars are created using gtk_statusbar_new(). + + +Messages are added to the bar's stack with gtk_statusbar_push(). + + +The message at the top of the stack can be removed using gtk_statusbar_pop(). A message can be removed from anywhere in the stack if it's message_id was recorded at the time it was added. This is done using gtk_statusbar_remove(). + + + + + + +#GtkDialog +another way of reporting information to the user. + + + + + + +Contains private data that should be modified with the functions described below. + + +@parent_widget: +@frame: +@label: +@messages: +@keys: +@seq_context_id: +@seq_message_id: + + + +Holds the data for a statusbar message. text holds the actual text string. context_id is the context that this message is associated with, and message_id is this particular message's identifier. However, these fields should not be modified directly. + + +@text: +@context_id: +@message_id: + + + +Creates a new #GtkStatusbar ready for messages. + + +@Returns: the new #GtkStatusbar. + + + + +Returns a new context identifier, given a description of the actual context. + + +@statusbar: a #GtkStatusbar. +@context_description: textual description of what context the new message is +being used in. +@Returns: an integer id. + + + + +Pushes a new message onto a statusbar's stack. + + +@statusbar: a #GtkStatusbar. +@context_id: the message's context id, as returned by +gkt_statusbar_get_context_id(). +@text: the message to add to the statusbar. +@Returns: the message's new message id for use with gtk_statusbar_remove(). + + + + +Removes the message at the top of a #GtkStatusBar's stack. + + +@statusbar: a #GtkStatusBar. +@context_id: a context identifier. + + + + +Forces the removal of a message from a statusbar's stack. The exact context_id and message_id must be specified. + + +@statusbar: a #GtkStatusBar. +@context_id: a context identifier. +@message_id: a message identifier, as returned by gtk_statusbar_push(). + + + + +Is emitted whenever a new message gets pushed onto a statusbar's stack. + + +@statusbar: the object which received the signal. +@context_id: the context id of the relevant message/statusbar. +@text: the message that was pushed. + + + +Is emitted whenever a new message is popped off a statusbar's stack. + + +@statusbar: the object which received the signal. +@context_id: the context id of the relevant message/statusbar. +@text: the message that was just popped. + diff --git a/docs/reference/gtk/tmpl/gtkstyle.sgml b/docs/reference/gtk/tmpl/gtkstyle.sgml new file mode 100644 index 0000000000..0fbac43c7b --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkstyle.sgml @@ -0,0 +1,887 @@ + +Styles + + + + + + + + + + + + + + + + + + + + + + + + + + +@style: + + + + + + + +@klass: +@fg: +@bg: +@light: +@dark: +@mid: +@text: +@base: +@black: +@white: +@font: +@fg_gc: +@bg_gc: +@light_gc: +@dark_gc: +@mid_gc: +@text_gc: +@base_gc: +@black_gc: +@white_gc: +@bg_pixmap: +@ref_count: +@attach_count: +@depth: +@colormap: +@engine: +@engine_data: +@rc_style: +@styles: + + + + + + +@xthickness: +@ythickness: +@draw_hline: +@draw_vline: +@draw_shadow: +@draw_polygon: +@draw_arrow: +@draw_diamond: +@draw_oval: +@draw_string: +@draw_box: +@draw_flat_box: +@draw_check: +@draw_option: +@draw_cross: +@draw_ramp: +@draw_tab: +@draw_shadow_gap: +@draw_box_gap: +@draw_extension: +@draw_focus: +@draw_slider: +@draw_handle: + + + + + + +@Returns: + + + + + + + +@style: +@Returns: + + + + + + + +@style: +@window: +@Returns: + + + + + + + +@style: + + + + + + + +@style: +@Returns: + + + + + + + +@style: + + + + + + + +@style: +@window: +@state_type: + + + + + + + +@style: +@window: +@set_bg: +@state_type: +@area: +@x: +@y: +@width: +@height: + + + + + + + +@s: +@gw: +@st: +@a: +@x: +@y: +@w: +@h: + + + + + + + +@style: +@window: +@state_type: +@x1: +@x2: +@y: + + + + + + + +@style: +@window: +@state_type: +@y1: +@y2: +@x: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@points: +@npoints: +@fill: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@arrow_type: +@fill: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@x: +@y: +@string: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: +@gap_side: +@gap_x: +@gap_width: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: +@gap_side: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: +@orientation: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@arrow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: +@gap_side: +@gap_x: +@gap_width: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: +@orientation: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@arrow_type: +@fill: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: +@gap_side: +@gap_x: +@gap_width: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: +@gap_side: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: +@orientation: + + + + + + + +@style: +@window: +@state_type: +@area: +@widget: +@detail: +@x1: +@x2: +@y: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@points: +@npoints: +@fill: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@arrow_type: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: +@gap_side: +@gap_x: +@gap_width: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: +@orientation: + + + + + + + +@style: +@window: +@state_type: +@area: +@widget: +@detail: +@x: +@y: +@string: + + + + + + + +@style: +@window: +@state_type: +@shadow_type: +@area: +@widget: +@detail: +@x: +@y: +@width: +@height: + + + + + + + +@style: +@window: +@state_type: +@area: +@widget: +@detail: +@y1: +@y2: +@x: + + diff --git a/docs/reference/gtk/tmpl/gtktable.sgml b/docs/reference/gtk/tmpl/gtktable.sgml new file mode 100644 index 0000000000..0ba1ce02e0 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktable.sgml @@ -0,0 +1,237 @@ + +GtkTable + + +Pack widgets in regular patterns. + + + +The GtkTable functions allow the programmer to arrange widgets in rows and +columns, making it easy to align many widgets next to each other, +horizontally and vertically. + + +Tables are created with a call to gtk_table_new(), the size of which can +later be changed with gtk_table_resize(). + + +Widgets can be added to a table using gtk_table_attach() or the more +convenient (but slightly less flexible) gtk_table_attach_defaults(). + + +To alter the space next to a specific row, use gtk_table_set_row_spacing(), +and for a column, gtk_table_set_col_spacing(). + +The gaps between all rows or columns can be changed by calling +gtk_table_set_row_spacings() or gtk_table_set_col_spacings() respectively. + + +gtk_table_set_homogeneous(), can be used to set whether all cells in the +table will resize themselves to the size of the largest widget in the table. + + + + + + +#GtkVBox +For packing widgets vertically only. + + +#GtkHBox +For packing widgets horizontally only. + + + + + + +The GtkTable structure holds the data for the actual table itself. + +children is a #GList of all the widgets the table contains. rows and columns are pointers to #GtkTableRowCol structures, which contain the default spacing and expansion details for the #GtkTable's rows and columns, respectively. + + +nrows and ncols are 16bit integers storing the number of rows and columns the table has. + + +@container: +@children: +@rows: +@cols: +@nrows: +@ncols: +@column_spacing: +@row_spacing: +@homogeneous: + + + +The widget field is a pointer to the widget that +this %GtkTableChild structure is keeping track of. +The left_attach, +right_attach, +top_attach, and +bottom_attach fields specify the row and column +numbers which make up the invisible rectangle that the child widget is packed into. + + +xpadding and ypadding +specify the space between this widget and the surrounding table cells. + + +@widget: +@left_attach: +@right_attach: +@top_attach: +@bottom_attach: +@xpadding: +@ypadding: +@xexpand: +@yexpand: +@xshrink: +@yshrink: +@xfill: +@yfill: + + + +These fields should be considered read-only and not be modified directly. + + +@requisition: +@allocation: +@spacing: +@need_expand: +@need_shrink: +@expand: +@shrink: +@empty: + + + +Used to create a new table widget. An initial size must be given by specifying how many rows and columns the table should have, although this can be changed later with gtk_table_resize(). + + +@rows: The number of rows the new table should have. +@columns: The number of columns the new table should have. +@homogeneous: If set to TRUE, all table cells are resized to the size of the cell +containing the largest widget. +@Returns: A pointer to the the newly created table widget. + + + + +If you need to change a table's size after it has been created, this function allows you to do so. + + +@table: The #GtkTable you wish to change the size of. +@rows: The new number of rows. +@columns: The new number of columns. + + + + +Adds a widget to a table. The number of 'cells' that a widget will occupy is +specified by @left_attach, @right_attach, @top_attach and @bottom_attach. +These each represent the leftmost, rightmost, uppermost and lowest column +and row numbers of the table. (Columns and rows are indexed from zero). + + +@table: The #GtkTable to add a new widget to. +@child: The widget to add. +@left_attach: the column number to attach the left side of a child widget to. +@right_attach: the column number to attach the right side of a child widget to. +@top_attach: the row number to attach the left side of a child widget to. +@bottom_attach: the column number to attach the right side of a child widget to. +@xoptions: Used to specify the properties of the child widget when the table is resized. +@yoptions: The same as xoptions, except this field determines behaviour of vertical resizing. +@xpadding: An integer value specifying the padding on the left and right of the widget being added to the table. +@ypadding: The amount of padding above and below the child widget. + + + + +As there are many options associated with gtk_table_attach(), this convenience function provides the programmer with a means to add children to a table with identical padding and expansion options. + + +@table: The table to add a new child widget to. +@widget: The child widget to add. +@left_attach: The column number to attach the left side of the child widget to. +@right_attach: The column number to attach the right side of the child widget to. +@top_attach: The row number to attach the top of the child widget to. +@bottom_attach: The row number to attach the bottom of the child widget to. + + + + +changes the space between a given table row and its surrounding rows. + + +@table: a #GtkTable containing the row whose properties you wish to change. +@row: row number whose spacing will be changed. +@spacing: number of pixels that the spacing should take up. + + + + +alters the amount of space between a given table column and the adjacent columns. + + +@table: a #GtkTable. +@column: the column whose spacing should be changed. +@spacing: number of pixels that the spacing should take up. + + + + +sets the space between every row in @table equal to @spacing. + + +@table: a #GtkTable. +@spacing: the number of pixels of space to place between every row in the table. + + + + +sets the space between every column in @table equal to @spacing. + + +@table: a #GtkTable. +@spacing: the number of pixels of space to place between every column in the table. + + + + +changes the homogenous property of table cells. Ie. whether all cells are an equal size or not. + + +@table: The GtkTable you wish to set the homogeneous properties of. +@homogeneous: Set to TRUE to ensure all table cells are the same size. Set +to FALSE if this is not your desired behaviour. + + + + +set or retrieve the number of rows in a table. + + + + +set or retrieve the number of columnsin a table. + + + + +set or retrieve the number of pixels of space between each row. + + + + +set or retrieve the number of pixels of space between each column. + + + + +whether each cell in the table should be the same size or not. + + diff --git a/docs/reference/gtk/tmpl/gtktearoffmenuitem.sgml b/docs/reference/gtk/tmpl/gtktearoffmenuitem.sgml new file mode 100644 index 0000000000..a065298e81 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktearoffmenuitem.sgml @@ -0,0 +1,55 @@ + +GtkTearoffMenuItem + + +a menu item used to tear off and reattach its menu. + + + +a #GtkTearoffMenuItem is a special #GtkMenuItem which is used to +tear off and reattach its menu. + + + +When its menu is shown normally, the #GtkTearoffMenuItem is drawn as a +dotted line indicating that the menu can be torn off. Activating it +causes its menu to be torn off and displayed in its own window +as a tearoff menu. + + + +When its menu is shown as a tearoff menu, the #GtkTearoffMenuItem is drawn +as a dotted line which has a left pointing arrow graphic indicating that +the tearoff menu can be reattached. Activating it will erase the tearoff +menu window. + + + + + + + +#GtkMenu +for further discussion of menus in GTK. + + + + + + + +The #GtkTearoffMenuItem-struct struct contains private data only, and +should be accessed using the functions below. + + +@menu_item: +@torn_off: + + + +Creates a new #GtkTearoffMenuItem. + + +@Returns: a new #GtkTearoffMenuItem. + + diff --git a/docs/reference/gtk/tmpl/gtktext.sgml b/docs/reference/gtk/tmpl/gtktext.sgml new file mode 100644 index 0000000000..73cd8f0039 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktext.sgml @@ -0,0 +1,246 @@ + +GtkText + + +text widget which allows display and manipulation of arbitrary text + + + +A #GtkText widget allows one to display any given text and manipulate it +by deleting from one point to another, selecting a region, and various +other functions as outlined below. It is inherited from #GtkEditable. + + + + + + + + + +Most of the #GtkText-struct struct members should not be accessed directly. +Listed below are a few exceptions and how to use them. + + + + + + +GtkAdjustment *hadj; +Allows you to see the state of an attached horizontal #GtkScrollbar. +See #GtkAdjustment for more info. This allows easy access to the adjustments +of the #GtkText struct without having to keep track of ones that you initialize +at widget creation. + + + +GtkAdjustment *vadj; +Same as hadj except it involves the vertical #GtkScrollbar. + + + + + + +@editable: +@text_area: +@hadj: +@vadj: +@gc: +@line_wrap_bitmap: +@line_arrow_bitmap: + + + +Internal #GtkText data type. + + + + + + +Internal #GtkText data type. Should not be access directly. + + + +@property: +@offset: +@index: + + + +Creates a new #GtkText widget, initialized with the given pointers to +#GtkAdjustments. These pointers can be used to track the viewing position +of the #GtkText widget. Passing NULL to either or both of them will make +the #GtkText create it's own. You can set these later with the function +gtk_text_set_adjustment() + + +@hadj: horizontal adjustment. +@vadj: vertical adjustment. +@Returns: the new #GtkText widget. + + + + +Set whether the #GtkText widget can be edited by the user or not. This +still allows you the programmer to make changes with the various #GtkText +functions. + + +@text: the #GtkText widget +@editable: %TRUE makes it editable, %FALSE makes it immutable by the user + + + + +Sets whether the #GtkText widget wraps words down to the next line if it +can't be completed on the current line. + + +@text: the #GtkText widget +@word_wrap: %TRUE makes it word wrap, %FALSE disables word wrapping + + + + +Controls how #GtkText handles long lines of continuous text. If line wrap +is on, the line is broken when it reaches the extent of the #GtkText widget +viewing area and the rest is displayed on the next line. If it is not set, +the line continues regardless size of current viewing area. Similar to word +wrap but it disregards word boundaries. + + +@text: the #GtkText widget +@line_wrap: %TRUE turns line wrap on, %FALSE turns it off + + + + +Allows you to set #GtkAdjustment pointers which in turn allows you to +keep track of the viewing position of the #GtkText widget. + + +@text: the #GtkText widget +@hadj: the horizontal adjustment +@vadj: the vertical adjustment + + + + +Sets the cursor at the given point. In this case a point constitutes +the number of characters from the extreme upper left corner of the #GtkText +widget. + + +@text: the #GtkText widget +@index: the number of characters from the upper left corner + + + + +Gets the current position of the cursor as the number of characters from +the upper left corner of the #GtkText widget. + + +@text: the #GtkText widget +@Returns: the number of characters from the upper left corner + + + + +Returns the length of the all the text contained within the #GtkText widget; +disregards current point position. + + +@text: the #GtkText widget +@Returns: the length of the text + + + + +Freezes the #GtkText widget which disallows redrawing of the widget until +it is thawed. This is useful if a large number of changes are going to +made to the text within the widget, reducing the amount of flicker seen +by the user. + + +@text: the #GtkText widget + + + + +Allows the #GtkText widget to be redrawn again by GTK. + + +@text: the #GtkText widget + + + + +Inserts given text into the #GtkText widget with the given properties as +outlined below. + + +@text: the #GtkText widget +@font: the #GdkFont to use +@fore: the foreground color to insert with +@back: the background color to insert with +@chars: the actual text to be inserted +@length: the length of the text to be inserted, passing -1 makes it insert +all the text. + + + + +Deletes from the current point position backward the given number of +characters. + + +@text: the #GtkText widget +@nchars: the number of characters to delete +@Returns: %TRUE if the operation was successful, otherwise returns %FALSE + + + + +Deletes from the current point position forward the given number of +characters. + + +@text: the #GtkText widget +@nchars: the number of characters to delete +@Returns: %TRUE if the operation was successful, otherwise returns %FALSE + + + + +Returns the character at the given index within the #GtkText widget. + + +@t: the #GtkText widget +@index: the number of characters from the upper left corner + + + + +Used by the #GtkText widget to keep track of the size of it's horizontal +text. + + + + +Used by the #GtkText widget to keep track of the size of it's vertical +text. + + + + +Boolean value indicating whether line wrap is enabled or not. + + + + +Boolean value indicated whether word wrap is enabled or not. + + diff --git a/docs/reference/gtk/tmpl/gtkthemes.sgml b/docs/reference/gtk/tmpl/gtkthemes.sgml new file mode 100644 index 0000000000..7dd4163a76 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkthemes.sgml @@ -0,0 +1,73 @@ + +Themes + + + + + + + + + + + + + + + + + + + +@parse_rc_style: +@merge_rc_style: +@rc_style_to_style: +@duplicate_style: +@realize_style: +@unrealize_style: +@destroy_rc_style: +@destroy_style: +@set_background: + + + + + + +@name: +@Returns: + + + + + + + +@engine: + + + + + + + +@engine: + + + + + + + +@argc: +@argv: + + + + + + + +@error_code: + + diff --git a/docs/reference/gtk/tmpl/gtktipsquery.sgml b/docs/reference/gtk/tmpl/gtktipsquery.sgml new file mode 100644 index 0000000000..0bc6abfaac --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktipsquery.sgml @@ -0,0 +1,129 @@ + +GtkTipsQuery + + + + + + + + + + + + + + + + + + + +@label: +@emit_always: +@in_query: +@label_inactive: +@label_no_tip: +@caller: +@last_crossed: +@query_cursor: + + + + + + +@Returns: + + + + + + + +@tips_query: + + + + + + + +@tips_query: + + + + + + + +@tips_query: +@caller: + + + + + + + +@tips_query: +@label_inactive: +@label_no_tip: + + + + + + + +@tipsquery: the object which received the signal. + + + + + + +@tipsquery: the object which received the signal. + + + + + + +@tipsquery: the object which received the signal. +@widget: +@tip_text: +@tip_private: + + + + + + +@tipsquery: the object which received the signal. +@widget: +@tip_text: +@tip_private: +@event: +@Returns: + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtktogglebutton.sgml b/docs/reference/gtk/tmpl/gtktogglebutton.sgml new file mode 100644 index 0000000000..3ba8121c48 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktogglebutton.sgml @@ -0,0 +1,166 @@ + +GtkToggleButton + + +create buttons which retain their state. + + + +A #GtkToggleButton is a #GtkButton which will remain 'pressed-in' when +clicked. Clicking again will cause the toggle button to return to it's +normal state. + + +A toggle button is created by calling either gtk_toggle_button_new() or +gtk_toggle_button_new_with_label(). If using the former, it is advisable to +pack a widget, (such as a #GtkLabel and/or a #GtkPixmap), into the toggle +button's container. (See #GtkButton for more information). + + +The state of a #GtkToggleButton can be set specifically using +gtk_toggle_button_set_active(), and retrieved using +gtk_toggle_button_get_active(). + + +To simply switch the state of a toggle button, use gtk_toggle_button_toggled. + + +Creating two #GtkToggleButton widgets. + + +void make_toggles(void) { + GtkWidget *dialog, *toggle1, *toggle2; + + dialog = gtk_dialog_new(); + toggle1 = gtk_toggle_button_new_with_label("Hi, i'm a toggle button."); + + /* Makes this toggle button invisible */ + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle1), TRUE); + + gtk_signal_connect (GTK_OBJECT (toggle1), "toggled", + GTK_SIGNAL_FUNC (output_state), NULL); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area), + toggle1, FALSE, FALSE, 2); + + toggle2 = gtk_toggle_button_new_with_label("Hi, i'm another toggle button."); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle2), FALSE); + gtk_signal_connect (GTK_OBJECT (toggle2), "toggled", + GTK_SIGNAL_FUNC (output_state), NULL); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area), + toggle2, FALSE, FALSE, 2); + + gtk_widget_show_all (dialog); +} + + + + + + + + +#GtkButton +a more general button. + + +#GtkCheckButton +another way of presenting a toggle option. + + +#GtkCheckMenuItem +a #GtkToggleButton as a menu item. + + + + + + +The #GtkToggleButton struct contains private data only, and should be manipulated using the functions below. + + +@button: +@active: +@draw_indicator: +@event_window: + + + +Creates a new toggle button. A widget should be packed into the button, as in gtk_button_new(). + + +@Returns: a new toggle button. + + + + +Creates a new toggle button with a text label. + + +@label: a string containing the message to be placed in the toggle button. +@Returns: a new toggle button. + + + + +Determines whether or not the toggle button is drawn on screen. The default mode is FALSE, which results in the button being displayed. To make the button invisible, set draw_indicator to TRUE. + + +@toggle_button: a #GtkToggleButton. +@draw_indicator: TRUE or FALSE. + + + + +This is a deprecated macro, and is only maintained for compatability reasons. + + + + + + +Changes the state of the toggle button. + + +@toggle_button: a #GtkToggleButton. + + + + +Queries a #GtkToggleButton and returns it's current state. Returns TRUE if +the toggle button is pressed in and FALSE if it is raised. + + +@toggle_button: a #GtkToggleButton. +@Returns: a #gboolean value. + + + + +Sets the status of the toggle button. Set to TRUE if you want the +GtkToggleButton to be 'pressed in', and FALSE to raise it. +This action causes the toggled signal to be emitted. + + +@toggle_button: a #GtkToggleButton. +@is_active: TRUE or FALSE. + + + + +Should be connected if you wish to perform an action whenever the +#GtkToggleButton's state is changed. + + +@togglebutton: the object which received the signal. + + + +Sets whether the toggle button should be pressed in or not. + + + + +A value of TRUE causes the toggle button to be invisible. FALSE displays it +again. + + diff --git a/docs/reference/gtk/tmpl/gtktoolbar.sgml b/docs/reference/gtk/tmpl/gtktoolbar.sgml new file mode 100644 index 0000000000..7debeba9f7 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktoolbar.sgml @@ -0,0 +1,332 @@ + +GtkToolbar + + +create bars of buttons and other widgets. + + + +A toolbar is created with a call to gtk_toolbar_new(). + + +Buttons with text and/or images are added with gtk_toolbar_append_item(), gtk_toolbar_prepend_item(), and gtk_toolbar_insert_item(). + + +Any of #GtkToggleButton, #GtkRadioButton, or an arbitrary widget can be added to the toolbar with gtk_toolbar_append_element(), gtk_toolbar_prepend_element(), and gtk_toolbar_insert_element(). + + +Widgets can be visibily grouped by adding gaps between widgets using gtk_toolbar_append_space(), gtk_toolbar_prepend_space, and gtk_toolbar_insert_space(). + + + + + + +#GtkToolTips +Change the properties of a #GtkToolbar's #GtkTooltips. + + +#GtkTipsQuery +Make use of the private tips of toolbar elements. + + + + + + +num_children is an integer specifying how many toolbar items the #GtkToolbar contains. children is a #GList of the child widgets of the toolbar. + + +orientation + + +@container: +@num_children: +@children: +@orientation: +@style: +@space_size: +@space_style: +@tooltips: +@button_maxw: +@button_maxh: +@relief: + + + +is used to set the type of new elements that are added to a #GtkToolbar. + + +SPACE is just a space in the style of the toolbar's GtkToolbarSpaceStyle. BUTTON denotes a #GtkButton. TOGGLEBUTTON denotes a #GtkToggleButton, RADIOBUTTON denotes a #GtkRadioButton, and WIDGET denotes a standard #GtkWidget. + + +@GTK_TOOLBAR_CHILD_SPACE: +@GTK_TOOLBAR_CHILD_BUTTON: +@GTK_TOOLBAR_CHILD_TOGGLEBUTTON: +@GTK_TOOLBAR_CHILD_RADIOBUTTON: +@GTK_TOOLBAR_CHILD_WIDGET: + + + + + + +@GTK_TOOLBAR_SPACE_EMPTY: +@GTK_TOOLBAR_SPACE_LINE: + + + + + + +@type: +@widget: +@icon: +@label: + + + +creates a new toolbar. + + +@orientation: a #GtkOrientation. It determines whether the toolbar appears horizontally or vertically. +@style: a #GtkToolbarStyle. It determines if the toolbar will contain buttons with just labels, just images, or both. +@Returns: the newly created toolbar. + + + + +adds a new button to the beginning (left or top edges) of the given toolbar. + + +@toolbar: a #GtkToolbar. +@text: give your toolbar button a label. +@tooltip_text: a string that appears when the user holds the mouse over this item. +@tooltip_private_text: use with #GtkTipsQuery. +@icon: a #GtkWidget that should be used as the button's icon. +@callback: the function to be executed when the button is pressed. +@user_data: a pointer to any data you wish to be passed to the callback. +@Returns: the new toolbar item as a #GtkWidget. + + + + +adds a new button to the beginning of the given toolbar. + + +@toolbar: a #GtkToolbar. +@text: give your toolbar button a label. +@tooltip_text: a string that appears when the user holds the mouse over this item. +@tooltip_private_text: use with #GtkTipsQuery. +@icon: a #GtkWidget that should be used as the button's icon. +@callback: the function to be executed when the button is pressed. +@user_data: a pointer to any data you wish to be passed to the callback. +@Returns: the new toolbar item as a #GtkWidget. + + + + +inserts a new item into the toolbar. You must specify the position in the toolbar where it will be inserted. + + +@toolbar: a #GtkToolbar. +@text: give your toolbar button a label. +@tooltip_text: a string that appears when the user holds the mouse over this item. +@tooltip_private_text: use with #GtkTipsQuery. +@icon: a #GtkWidget that should be used as the button's icon. +@callback: the function to be executed when the button is pressed. +@user_data: a pointer to any data you wish to be passed to the callback. +@position: the number of widgets to insert this item after. +@Returns: the new toolbar item as a #GtkWidget. + + + + +adds a new space to the end of the toolbar. + + +@toolbar: a #GtkToolbar. + + + + +adds a new space to the beginning of the toolbar. + + +@toolbar: a #GtkToolbar. + + + + +inserts a new space in the toolbar at the specified position. + + +@toolbar: a #GtkToolbar +@position: the number of widgets after which a space should be inserted. + + + + +adds a new element to the end of a toolbar. + + +@toolbar: a #GtkToolbar. +@type: a value of type #GtkToolbarChildType that determines what @widget will be. +@widget: a #GtkWidget to add to the toolbar. (FIXME: double check this). +@text: the element's label. +@tooltip_text: the element's tooltip. +@tooltip_private_text: used for context-sensitive help about this toolbar element. +@icon: a #GtkWidget that provides pictorial representation of the element's function. +@callback: the function to be executed when the button is pressed. +@user_data: any data you wish to pass to the callback. +@Returns: the new toolbar element as a #GtkWidget. + + + + +adds a new element to the beginning of a toolbar. + + +@toolbar: a #GtkToolbar. +@type: a value of type #GtkToolbarChildType that determines what @widget will be. +@widget: a #GtkWidget to add to the toolbar. (FIXME: double check this). +@text: the element's label. +@tooltip_text: the element's tooltip. +@tooltip_private_text: used for context-sensitive help about this toolbar element. +@icon: a #GtkWidget that provides pictorial representation of the element's function. +@callback: the function to be executed when the button is pressed. +@user_data: any data you wish to pass to the callback. +@Returns: the new toolbar element as a #GtkWidget. + + + + + + + +@toolbar: a #GtkToolbar. +@type: a value of type #GtkToolbarChildType that determines what @widget will be. +@widget: a #GtkWidget to add to the toolbar. (FIXME: double check this). +@text: the element's label. +@tooltip_text: the element's tooltip. +@tooltip_private_text: used for context-sensitive help about this toolbar element. +@icon: a #GtkWidget that provides pictorial representation of the element's function. +@callback: the function to be executed when the button is pressed. +@user_data: any data you wish to pass to the callback. +@position: the number of widgets to insert this element after. +@Returns: the new toolbar element as a #GtkWidget. + + + + + + + +@toolbar: +@widget: +@tooltip_text: +@tooltip_private_text: + + + + + + + +@toolbar: +@widget: +@tooltip_text: +@tooltip_private_text: + + + + + + + +@toolbar: +@widget: +@tooltip_text: +@tooltip_private_text: +@position: + + + + +sets whether a toolbar should appear horizontally or vertically. + + +@toolbar: a #GtkToolbar. +@orientation: a new #GtkOrientation. + + + + +alters the view of @toolbar to display either icons only, text only, or both. + + +@toolbar: a #GtkToolbar. +@style: the new style for @toolbar. + + + + +should be used to set the number of pixels each item of space takes up in a toolbar. + + +@toolbar: a #GtkToolbar. +@space_size: the new number of pixels that spaces should consume. + + + + +sets whether a 'space' in the toolbar appears as a line or just plain empty space. + + +@toolbar: a #GtkToolbar. +@space_style: the new style for the toolbar's spaces. + + + + +sets if the tooltips of a toolbar should be active or not. + + +@toolbar: a #GtkToolbar. +@enable: set to 0 to disable the tooltips, or 1 to enable them. + + + + + + + +@toolbar: +@relief: + + + + + + + +@toolbar: +@Returns: + + + + +should be used if you wish to perform an action when the orientation of a toolbar is changed. + + +@toolbar: the object which received the signal. +@orientation: the new #GtkOrientation of the toolbar. + + + +should be used if you wish to perform an action when ever the style of a toolbar is adjusted. For example, this would be a useful signal to connect to if you want to display more items on the toolbar when it is in icon-only mode; each item takes less space on the bar. + + +@toolbar: the object which received the signal. +@style: the new #GtkToolbarStyle of @toolbar. + diff --git a/docs/reference/gtk/tmpl/gtktooltips.sgml b/docs/reference/gtk/tmpl/gtktooltips.sgml new file mode 100644 index 0000000000..fba097eb9f --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktooltips.sgml @@ -0,0 +1,177 @@ + +GtkTooltips + + +Add tips to your widgets. + + + +Tooltips are the messages that appear next to a widget when the mouse pointer is held over it for a short amount of time. They are especially helpful for adding more verbose descriptions of things such as buttons in a toolbar. + + +An individual tooltip belongs to a group of tooltips. A group is created with a call to gtk_tooltips_new(). Every tooltip in the group can then be turned off with a call to gtk_tooltips_disable() and enabled with gtk_tooltips_enable(). + + +The length of time the user must keep the mouse over a widget before the tip is shown, can be altered with gtk_tooltips_set_delay(). This is set on a 'per group of tooltips' basis. + + +To assign a tip to a particular #GtkWidget, gtk_tooltips_set_tip() is used. + + +The default appearance of all tooltips in a program is determined by the current gtk theme that the user has selected. To change the tooltip appearance manually, use gtk_tooltips_set_colors(). Again, this is per group of tooltips. + + +Information about the tooltip (if any) associated with an arbitrary widget can be retrieved using gtk_tooltips_data_get(). + + + +Adding tooltips to buttons. + + GtkWidget *load_button, *save_button, *hbox; + GtkTooltips *button_bar_tips; + + button_bar_tips = gtk_tooltips_new(); + + /* Create the buttons and pack them into a #GtkHBox */ + hbox = gtk_hbox_new(TRUE, 2); + + load_button = gtk_button_new_with_label("Load a file"); + gtk_box_pack_start(GTK_BOX (hbox), load_button, TRUE, TRUE, 2); + gtk_widget_show(load_button); + + save_button = gtk_button_new_with_label("Save a file"); + gtk_box_pack_start(GTK_BOX (hbox), save_button, TRUE, TRUE, 2); + gtk_widget_show(save_button); + gtk_widget_show(hbox); + + /* Add the tips */ + gtk_tooltips_set_tip(GTK_TOOLTIPS (button_bar_tips), load_button, + "Load a new document into this window", + "Requests the filename of a document. + This will then be loaded into the current + window, replacing the contents of whatever + is already loaded."); + gtk_tooltips_set_tip(GTK_TOOLTIPS (button_bar_tips), save_button, + "Saves the current document to a file", + "If you have saved the document previously, + then the new version will be saved over the + old one. Otherwise, you will be prompted for + a filename."); + + + + + + + +#GtkToolbar +Create groups of widgets with their own tooltips. + + +#GtkTipsQuery +Query tooltips to create context-sensitive help. + + + + + +Holds information about a group of tooltips. Fields should be changed using the functions provided, rather than directly accessing the struct's members. + + +@data: +@tip_window: +@active_tips_data: +@tips_data_list: +@gc: +@foreground: +@background: +@delay: +@enabled: +@timer_tag: + + + +tooltips is the #GtkTooltips group that this tooltip belongs to. widget is the #GtkWidget that this tooltip data is associated with. tip_text is a string containing the tooltip message itself. + +tip_private is a string that is not shown as the default tooltip. Instead, this message may be more informative and go towards forming a context-sensitive help system for your application. (FIXME: how to actually "switch on" private tips?) + + +@tooltips: +@widget: +@tip_text: +@tip_private: +@font: +@width: +@row: + + + +Creates an empty group of tooltips. This function initialises a #GtkTooltips structure. Without at least one such structure, you can not add tips to your application. + + +@Returns: a new #GtkTooltips group for you to use. + + + + +Allows the user to see your tooltips as they navigate your application. + + +@tooltips: a #GtkTooltips. + + + + +Causes all tooltips in @tooltips to become inactive. Any widgets that have tips associated with that group will no longer display their tips until they are enabled again with gtk_tooltips_enable(). + + +@tooltips: a #GtkTooltips. + + + + +Sets the time between the user moving the mouse over a widget and the widget's tooltip appearing. + + +@tooltips: a #GtkTooltips. +@delay: an integer value representing seconds (FIXME: double-check this). + + + + +Adds a tooltip containing the message @tip_text to the specified #GtkWidget. + + +@tooltips: a #GtkTooltips. +@widget: the #GtkWidget you wish to associate the tip with. +@tip_text: a string containing the tip itself. +@tip_private: a string of any further information that may be useful if the user gets stuck. + + + + +Changes the foreground and background colors of a #GtkTooltips. + + +@tooltips: a #GtkTooltip +@background: a #GdkColor that your tooltip text will be shown in. +@foreground: a #GdkColor that your tooltip backgrounds will be shown in. + + + + +Retrieves any #GtkTooltipsData previously associated with the given widget. + + +@widget: a #GtkWidget. +@Returns: a #GtkTooltipsData struct, or NULL if the widget has no tooltip. + + + + +Soon as I play with this, I'll report what it does. + + +@tooltips: + + diff --git a/docs/reference/gtk/tmpl/gtktree.sgml b/docs/reference/gtk/tmpl/gtktree.sgml new file mode 100644 index 0000000000..84be04bd2a --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktree.sgml @@ -0,0 +1,307 @@ + +GtkTree + + +A treelist widget. + + + +The #GtkTree widget is a container that shows users a list of items, in a tree format complete with branches and leafnodes. Branches can be expanded to show their child items, or collapsed to hide them. + + + + +#GtkTreeList for the items to put into a #GtkTree. + + +#GtkScrolledWindow for details on how to scroll around a #GtkTree. + + + + + +struct _GtkTree +{ + GtkContainer container; + GList *children; + GtkTree* root_tree; /* owner of selection list */ + GtkWidget* tree_owner; + GList *selection; + guint level; + guint indent_value; + guint current_indent; + guint selection_mode : 2; + guint view_mode : 1; + guint view_line : 1; +}; + + + +@container: +@children: +@root_tree: +@tree_owner: +@selection: +@level: +@indent_value: +@current_indent: +@selection_mode: +@view_mode: +@view_line: + + + +A macro that returns a boolean value which indicates if @obj is a root tree or not. + + +@obj: A pointer to the #GtkTree. @obj will accept any pointer, but if the pointer does not point to a #GtkTree, the results are undefined. + + + + +A macro that returns the root tree of @obj. + + +If @obj is already a root tree, @obj is cast to #GtkTree and returned. + + +@obj: A pointer to the #GtkTree. @obj will accept any pointer, but if the pointer does not point to a #GtkTree, the results are undefined. + + + + +A macro that returns a GList that contains the selection of the root tree of @obj. + + +@obj: A pointer to the #GtkTree. @obj will accept any pointer, but it the pointer does not point to a #GtkTree, the results are undefined. + + + + + + + +@GTK_TREE_VIEW_LINE: +@GTK_TREE_VIEW_ITEM: + + + +Creates a new #GtkTree. + + +@Returns: A pointer to the newly allocated widget. + + + + +Adds the #GtkTreeItem in @tree_item to the end of the items in @tree. + + +@tree: A pointer to a #GtkTree. +@tree_item: A pointer to the #GtkWidget that is to be appended to the tree. + + + + +Adds the #GtkTreeItem in @tree_item to the start of the items in @tree. + + +@tree: A pointer to a #GtkTree. +@tree_item: A pointer to the #GtkWidget that is to be prepended to the tree. + + + + +Adds the #GtkTreeItem in @tree_item to the list of items in @tree at the position indicated by @position. + + +@tree: A pointer to a #GtkTree. +@tree_item: A pointer to the #GtkWidget that is to be added to the tree. +@position: A #gint that indicates the position in the tree, that the tree_item is to be added at. + + + + +Removes a list of items from the #GtkTree in @tree. + + +If only one item is to be removed from the #GtkTree, gtk_container_remove() can be used instead. + + +Removing an item from a #GtkTree dereferences the item, and thus usually destroys the item and any subtrees it may contain. If the item is not to be destroyed, use gtk_object_ref() before removing it. + + +@tree: A pointer to a #GtkTree. +@items: A pointer to a #GList that contains the items to be removed. + + + + +Removes the items at positions between @start and @end from the #GtkTree @tree. + + +Removing an item from a #GtkTree dereferences the item, and thus usually destroys the item and any subtrees it may contain. If the item is not to be destroyed, use gtk_object_ref() before removing it. + + +@tree: A pointer to a #GtkTree. +@start: A gint. +@end: A gint. + + + + +Emits the #select_item signal for the child at position @item, and thus selects it (unless it is unselected in a signal handler). + + +@tree: A pointer to a #GtkTree. +@item: A gint. + + + + +Emits the #unselect_item for the child at position @item, and thus unselects it. + + +@tree: A pointer to a #GtkTree. +@item: A gint. + + + + +Emits the #select_item signal for the child @tree_item, and thus selects it (unless it is unselected in a signal handler). + + +@tree: A pointer to a #GtkTree. +@tree_item: A pointer to the #GtkWidget that is to be selected. + + + + +Emits the #unselect_item signal for the child @tree_item, and thus unselects it. + + +@tree: A pointer to a #GtkTree. +@tree_item: A pointer to the #GtkWidget that is to be selected. + + + + +Returns the position of @child in the #GtkTree @tree. + + +If @child is not a child of @tree, then -1 is returned. + + +@tree: A pointer to a #GtkTree. +@child: A pointer to a #GtkWidget. +@Returns: A gint. + + + + +Sets the selection mode for the #GtkTree @tree. + + +@mode can be one of + + + + +%GTK_SELECTION_SINGLE for when only one item can be selected at a time. + + + + +%GTK_SELECTION_BROWSE for when one item must be selected. + + + + +%GTK_SELECTION_MULTIPLE for when many items can be selected at once. + + + + +%GTK_SELECTION_EXTENDED Reserved for later use. + + + + +The selection mode is only defined for a root tree, as the root tree "owns" the selection. + + +The default mode is %GTK_SELECTION_SINGLE. + + +@tree: A pointer to a #GtkTree. +@mode: A #GtkSelectionMode. + + + + +Sets the 'viewmode' for the #GtkTree in @tree. The 'viewmode' defines how the tree looks when an item is selected. + + +@mode can be one of: + + + + +%GTK_TREE_VIEW_LINE : When an item is selected the entire #GtkTreeItem is highlighted. + + + + +%GTK_TREE_VIEW_ITEM : When an item is selected only the selected item's child widget is highlighted. + + + + +The default mode is %GTK_TREE_VIEW_LINE. + + +@tree: A pointer to a #GtkTree. +@mode: A #GtkTreeViewMode. + + + + +Sets whether or not the connecting lines between branches and children are drawn. + + +@tree: A pointer to a #GtkTree. +@flag: A guint, indicating %TRUE, or %FALSE. + + + + +Removes the item @child from the #GtkTree @tree. + + +@tree: A pointer to a #GtkTree. +@child: A pointer to the #GtkWidget that is to be removed from the tree. + + + + +This signal is emitted by the root tree whenever the selection changes. + + +@tree: the object which received the signal. + + + +This signal is emitted by @tree whenever @widget is about to be selected. + + +@tree: the object which received the signal. +@widget: The child that is about to be selected. + + + +This signal is emitted by @tree whenever @widget is about to be unselected. + + +@tree: the object which received the signal. +@widget: The child that is about to be unselected. + diff --git a/docs/reference/gtk/tmpl/gtktreeitem.sgml b/docs/reference/gtk/tmpl/gtktreeitem.sgml new file mode 100644 index 0000000000..fd745a7293 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktreeitem.sgml @@ -0,0 +1,115 @@ + +GtkTreeItem + + + + + + + + + + + + + + + + + + + +@item: +@subtree: +@pixmaps_box: +@pixmaps: +@expanded: + + + + + + +@obj: + + + + + + + +@Returns: + + + + + + + +@label: +@Returns: + + + + + + + +@tree_item: +@subtree: + + + + + + + +@tree_item: + + + + + + + +@tree_item: + + + + + + + +@tree_item: + + + + + + + +@tree_item: + + + + + + + +@tree_item: + + + + + + + +@treeitem: the object which received the signal. + + + + + + +@treeitem: the object which received the signal. + diff --git a/docs/reference/gtk/tmpl/gtktypeutils.sgml b/docs/reference/gtk/tmpl/gtktypeutils.sgml new file mode 100644 index 0000000000..6580d98173 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtktypeutils.sgml @@ -0,0 +1,869 @@ + +Types + + +Handle run-time type creation. + + + +Gtk's type system is extensible. Because of that, types have to be +managed at runtime. + + + + + + + + + +@GtkType is unique integer identifying the type. The guts of the +information about the type is held in a private struct named +GtkTypeNode. + + + + + +@GtkFundamentalType is an enumerated type which lists all the possible +fundamental types (e.g. char, uchar, int, long, float, etc). + + +@GTK_TYPE_INVALID: +@GTK_TYPE_NONE: +@GTK_TYPE_CHAR: +@GTK_TYPE_UCHAR: +@GTK_TYPE_BOOL: +@GTK_TYPE_INT: +@GTK_TYPE_UINT: +@GTK_TYPE_LONG: +@GTK_TYPE_ULONG: +@GTK_TYPE_FLOAT: +@GTK_TYPE_DOUBLE: +@GTK_TYPE_STRING: +@GTK_TYPE_ENUM: +@GTK_TYPE_FLAGS: +@GTK_TYPE_BOXED: +@GTK_TYPE_POINTER: +@GTK_TYPE_SIGNAL: +@GTK_TYPE_ARGS: +@GTK_TYPE_CALLBACK: +@GTK_TYPE_C_CALLBACK: +@GTK_TYPE_FOREIGN: +@GTK_TYPE_OBJECT: + + + +No idea. + + + + + + +The first "flat" (no struct) enumerated type value. + + + + + + +The last "flat" (no struct) enumerated type value. + + + + + + +The first structured enumerated type value. + + + + + + +The last structured enumerated type value. + + + + + + +The highest-numbered structured or flat enumerated type value. + + + + + + +The highest maximum fundamental enumerated type value. + + + + + + +Use in place of offsetof(), which is used if it exists. + + +@struct: The type of the structure. +@field: The field within the structure. + + + + +Cast the object in @tobj into @cast. If GTK_NO_CHECK_CASTS is +defined, just cast it. Otherwise, check to see if we can cast @tobj +into a @cast. + + +@tobj: a pointer to a GtkObject. +@cast_type: a Gtk type. +@cast: a C type + + + + +Cast the object in @tobj into @cast. If GTK_NO_CHECK_CASTS is +defined, just cast it. Otherwise, check to see if we can cast @tobj +into a @cast. + + +@tclass: a pointer to a GtkClassInitFunc +@cast_type: a Gtk type. +@cast: a C type + + + + +Determines whether @type_object is a type of @otype. + + +@type_object: A GtkTypeObject object. +@otype: + + + + +Determines whether @type_class is a type of @otype. + + +@type_class: A GtkTypeClass class. +@otype: + + + + +Hide the name of gtk_identifier_get_type + + + + + + +Get the type of GtkIdentifier. + + +@Returns: GtkType -- the enumerated type of something. + + + + +Combine a fundemantal type and a sequence number to create a gtk type. + + +@parent_t: +@seqno: + + + + +Convert a gtk type into a fundamental type + + +@type: + + + + +Convert a gtk type into its sequence number + + +@type: + + + + +Just a macroized cast into a GtkSignalFunc + + +@f: + + + + +Define a function pointer. + + +@klass: a gpointer + + + + +Define a function pointer. + + +@object: a gpointer +@klass: a gpointer + + + + +Define a function pointer. + + + + + + +Define a function pointer. + + +@data: gpointer +@Returns: gint + + + + +Define a function pointer. + + +@data: gpointer + + + + +Define a function pointer. + + +@object: GtkObject* +@data: gpointer +@n_args: guint +@args: GtkArg* + + + + +Define a function pointer. + + +@object: GtkObject* +@func: GtkSignalFunc +@func_data: gpointer +@args: GtkArg* + + + + +Define a function pointer. Deprecated. + + +@object: +@arg: +@arg_id: + + + + +Define a function pointer. Deprecated. + + +@object: +@arg: +@arg_id: + + + + +A GtkTypeObject defines the minimum structure requirements +for type instances. Type instances returned from gtk_type_new () +and initialized through a GtkObjectInitFunc need to directly inherit +from this structure or at least copy its fields one by one. + + +@klass: + + + +This is a structure that we use to pass in typed values (and names). + + +@type: +@name: + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_CHAR + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_UCHAR + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_BOOL + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_INT + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_UINT + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_LONG + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_ULONG + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_FLOAT + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_DOUBLE + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_STRING + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_ENUM + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_FLAGS + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_BOXED + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_POINTER + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_OBJECT + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_SIGNAL + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_ARGS + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_CALLBACK + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_C_CALLBACK + + +@a: + + + + +Use to get the value of a GtkArg whose GtkType is GTK_TYPE_C_FOREIGN + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_CHAR + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_UCHAR + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_BOOL + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_INT + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_UINT + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_LONG + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_ULONG + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_FLOAT + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_DOUBLE + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_STRING + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_ENUM + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_FLAGS + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_BOXED + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_POINTER + + +@a: + + + + +If the GtkArg contains a pointer to the value, this macro will be a pointer to a GTK_TYPE_OBJECT + + +@a: + + + + +Holds information about the type. @gtk_type_name returns the name. +@object_size is somehow set to the number of bytes that an instance of +the object will occupy. @class_init_func holds the type's +initialization function. @object_init_func holds the initialization +function for an instance of the object. @reserved_1 is used for +GtkEnumValue to hold the enumerated values. + + +@type_name: +@object_size: +@class_size: +@class_init_func: +@object_init_func: +@reserved_1: +@reserved_2: +@base_class_init_func: + + + +A structure used to return values from @gtk_type_query. + + +@type: +@type_name: +@object_size: +@class_size: + + + +The base structure for a Gtk Type. Every type inherits this as a base structure. + + + + + +A structure which contains a single enum value, and its name, and it's +nickname. + + +@value: +@value_name: +@value_nick: + + + +Initialize the data structures associated with gtk types. + + + + + + +Create a new, unique type. + + +@parent_type: if zero, a fundamental type is created. +@type_info: must not be null, and @type_info->type_name must also not be null. +@Returns: the new GtkType. + + + + +Set the mem_chunk size so it will hold @n_chunks of the objects of that @type. + + +@type: There must be an unlocked TypeNode associated with this type otherwise nothing happens. +@n_chunks: + + + + + + +@type: a GtkType +@Returns: a pointer to the name of a type, or NULL if it has none. + + + + +Get the internal representation of a type given its name. + + +@name: the name of a gtk type +@Returns: a GtkType + + + + + + + +@type: a GtkType +@Returns: the GtkType of the parent + + + + +Return a gpointer pointing to the class of @type or NULL if there was +any trouble identifying @type. Initialize the class if necessary. + + +@type: a GtkType +@Returns: gpointer to the klass. + + + + +Return the class of the parent. Initialize the class if necessary. +Return NULL if anything goes wrong. + + +@type: GtkType +@Returns: gpointer to the klass. + + + + +Return the pointer to the type's children's types. + + +@type: GtkType +@Returns: pointer to a GList + + + + +Create a new object of a given type, and return a gpointer to it. +Returns NULL if you give it an invalid type. It allocates the object +out of the type's memory chunk if there is a memory chunk. The object +has all the proper initializers called. + + +@type: GtkType +@Returns: gpointer to a GtkTypeObject + + + + +Given the type of an object and a pointer to it, the object is freed. + + +@type: GtkType +@mem: gpointer to the object + + + + +Print the types @type inherits from. + + +@type: GtkType + + + + +Given a @type, describe all of its children, and their children. Only +show the size if @show_size is true. + + +@type: GtkType +@show_size: gboolean + + + + +Look in the type hierarchy to see if @type has @is_a_type among its +ancestors. Do so with a simple lookup, not a loop. + + +@type: GtkType +@is_a_type: GtkType +@Returns: + + + + +Given a pointer to a GtkTypeObject @type_object, and a GtkType @cast_type, +make sure that it's okay to cast @type_object into a @cast_type. + + +@type_object: GtkTypeObject* +@cast_type: GtkType +@Returns: the same GtkTypeObject* as @type_object + + + + +Given a GtkTypeClass pointer @klass, and a GtkType @cast_type, make +sure that it's okay to cast something of that @klass into a @cast_type. + + +@klass: GtkTypeClass* +@cast_type: GtkType +@Returns: Always return @klass. + + + + +Register a new set of enum @values and give them the name in +@type_name. + + +@type_name: must not be null. +@values: GtkEnumValue* +@Returns: + + + + +Register a new set of flags @values and give them the name in +@type_name. +ara> + +@type_name: must not be null. +@values: GtkFlagValue* +@Returns: + + + + +If @enum_type has values, then return a pointer to all of them. + + +@enum_type: GtkType +@Returns: GtkEnumValue* + + + + +If @flags_type has values, then return a pointer to all of them. + + +@flags_type: +@Returns: GtkFlagValue* + + + + +Return a pointer to one of @enum_type's GtkEnumValues's whose name (or nickname) matches @value_name. + + +@enum_type: GtkType +@value_name: +@Returns: GtkEnumValue* + + + + +Return a pointer to one of @flag_type's GtkFlagValue's whose name (or nickname) matches @value_name. + + +@flag_type: GtkType +@value_name: +@Returns: GtkFlagValue* + + + + +Set the varargs type for a fundamental type @foreign_type. + + +@foreign_type: Must be a GtkType with a sequence number of zero. Must not be a +fundamental type. +@varargs_type: Must be a GtkType which is either structured or flag, or NONE. + + + + +Get the varargs type associated with @foreign_type + + +@foreign_type: GtkType +@Returns: GtkType + + + + +Given a type, return various interesting parameters of the type. + + +@type: GtkType +@Returns: GtkTypeQuery* + + diff --git a/docs/reference/gtk/tmpl/gtkvbbox.sgml b/docs/reference/gtk/tmpl/gtkvbbox.sgml new file mode 100644 index 0000000000..d0fe4c8652 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkvbbox.sgml @@ -0,0 +1,63 @@ + +GtkVButtonBox + + + + + + + + + + + + + + + + + + + +@button_box: + + + + + + +@Returns: + + + + + + + +@Returns: + + + + + + + +@spacing: + + + + + + + +@Returns: + + + + + + + +@layout: + + diff --git a/docs/reference/gtk/tmpl/gtkvbox.sgml b/docs/reference/gtk/tmpl/gtkvbox.sgml new file mode 100644 index 0000000000..306f685abe --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkvbox.sgml @@ -0,0 +1,47 @@ + +GtkVBox + + +vertical container box + + + +GtkVBox is a container that organizes child widgets into a single column. + + + +Use the #GtkBox packing interface to determine the arrangement, +spacing, height, and alignment of GtkVBox children. + + + +All children are allocated the same width. + + + + + + + +#GtkHBox +a sister class that organizes widgets into a row. + + + + + + + + +@box: + + + +Creates a new GtkVBox. + + +@homogeneous: %TRUE if all children are to be given equal space allotments. +@spacing: the number of pixels to place by default between children. +@Returns: a new GtkVBox. + + diff --git a/docs/reference/gtk/tmpl/gtkviewport.sgml b/docs/reference/gtk/tmpl/gtkviewport.sgml new file mode 100644 index 0000000000..a43582f0c7 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkviewport.sgml @@ -0,0 +1,98 @@ + +GtkViewport + + + + + + + + + + + + + + + + + + + +@bin: +@shadow_type: +@view_window: +@bin_window: +@hadjustment: +@vadjustment: + + + + + + +@hadjustment: +@vadjustment: +@Returns: + + + + + + + +@viewport: +@Returns: + + + + + + + +@viewport: +@Returns: + + + + + + + +@viewport: +@adjustment: + + + + + + + +@viewport: +@adjustment: + + + + + + + +@viewport: +@type: + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkvpaned.sgml b/docs/reference/gtk/tmpl/gtkvpaned.sgml new file mode 100644 index 0000000000..f6d41bc5a6 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkvpaned.sgml @@ -0,0 +1,33 @@ + +GtkVPaned + + +A container with two panes arranged vertically. + + + +The VPaned widget is a container widget with two +children arranged vertically. The division between +the two panes is adjustable by the user by dragging +a handle. See #GtkPaned for details. + + + + + + + + + + + +@paned: + + + +Create a new #GtkVPaned + + +@Returns: the new #GtkVPaned + + diff --git a/docs/reference/gtk/tmpl/gtkvruler.sgml b/docs/reference/gtk/tmpl/gtkvruler.sgml new file mode 100644 index 0000000000..789cd16ce8 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkvruler.sgml @@ -0,0 +1,38 @@ + +GtkVRuler + + +A vertical ruler. + + + +The VRuler widget is a widget arranged vertically creating a ruler that is +utilized around other widgets such as a text widget. The ruler is used to show +the location of the mouse on the window and to show the size of the window in +specified units. The available units of measurement are GTK_PIXELS, GTK_INCHES +and GTK_CENTIMETERS. GTK_PIXELS is the default. +rulers. + + + + + + + + + + +The #GtkVRuler struct contains private data and should be accessed +using the functions below. + + +@ruler: + + + +Creates a new vertical ruler + + +@Returns: the new GTKVRuler. + + diff --git a/docs/reference/gtk/tmpl/gtkvscale.sgml b/docs/reference/gtk/tmpl/gtkvscale.sgml new file mode 100644 index 0000000000..0b0e0171d1 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkvscale.sgml @@ -0,0 +1,45 @@ + +GtkVScale + + +a vertical slider widget for selecting a value from a range. + + + +The #GtkVScale widget is used to allow the user to select a value using +a vertical slider. +A #GtkAdjustment is used to set the initial value, the lower +and upper bounds, and the step and page increments. + + +The position to show the current value, and the number of decimal places +shown can be set using the parent #GtkScale class's functions. + + + + + + + + + +The #GtkVScale-struct struct contains private data only, and +should be accessed using the functions below. + + +@scale: + + + +Creates a new #GtkVScale. + + +@adjustment: the #GtkAdjustment which sets the range of the scale. +@Returns: a new #GtkVScale. + + + + +the #GtkAdjustment which sets the range of the scale. + + diff --git a/docs/reference/gtk/tmpl/gtkvscrollbar.sgml b/docs/reference/gtk/tmpl/gtkvscrollbar.sgml new file mode 100644 index 0000000000..ecff50a5b0 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkvscrollbar.sgml @@ -0,0 +1,42 @@ + +GtkVScrollbar + + +A vertical scrollbar + + + +The VScrollbar widget is a widget arranged vertically creating a scroll bar. See +#GtkScrollbar for details on scrollbars. #GtkAdjustment pointers may be added to +handle the adjustment of the scrollbars or it may be left NULL in which case one +will be created you. See #GtkAdjustment for details. + + + + + + + + + + +The #GtkVScrollbar struct contains private data and should be accessed +using the functions below. + + +@scrollbar: + + + +Creates a new vertical scrollbar. + + +@adjustment: +@Returns: the new GTKVScrollbar + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkvseparator.sgml b/docs/reference/gtk/tmpl/gtkvseparator.sgml new file mode 100644 index 0000000000..6e4b7047c3 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkvseparator.sgml @@ -0,0 +1,31 @@ + +GtkVSeparator + + + + + + + + + + + + + + + + + + + +@separator: + + + + + + +@Returns: + + diff --git a/docs/reference/gtk/tmpl/gtkwidget.sgml b/docs/reference/gtk/tmpl/gtkwidget.sgml new file mode 100644 index 0000000000..3ecc84727b --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkwidget.sgml @@ -0,0 +1,1721 @@ + +GtkWidget + + + + + + + + + + + + + + + + + + + +@object: +@private_flags: +@state: +@saved_state: +@name: +@style: +@requisition: +@allocation: +@window: +@parent: + + + + + + +@GTK_TOPLEVEL: +@GTK_NO_WINDOW: +@GTK_REALIZED: +@GTK_MAPPED: +@GTK_VISIBLE: +@GTK_SENSITIVE: +@GTK_PARENT_SENSITIVE: +@GTK_CAN_FOCUS: +@GTK_HAS_FOCUS: +@GTK_CAN_DEFAULT: +@GTK_HAS_DEFAULT: +@GTK_HAS_GRAB: +@GTK_RC_STYLE: +@GTK_COMPOSITE_CHILD: +@GTK_NO_REPARENT: +@GTK_APP_PAINTABLE: +@GTK_RECEIVES_DEFAULT: + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: + + + + + + + +@wid: +@flag: + + + + + + + +@wid: +@flag: + + + + + + + +@widget: +@data: + + + + + + + +@width: +@height: + + + + + + +@x: +@y: +@width: +@height: + + + + + + +@selection: +@target: +@type: +@format: +@data: +@length: + + + + + + +@x: +@y: +@width: +@height: + + + + + + +@offset_x: +@offset_y: +@shape_mask: + + + + + + +@type: +@first_arg_name: +@Varargs: +@Returns: + + + + + + + +@type: +@nargs: +@args: +@Returns: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: +@widget_pointer: + + + + + + + +@widget: +@arg: + + + + + + + +@widget: +@nargs: +@args: + + + + + + + +@widget: +@first_arg_name: +@Varargs: + + + + + + + +@widget: +@nargs: +@args: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: +@area: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: +@requisition: + + + + + + + +@widget: +@requisition: + + + + + + + +@widget: +@allocation: + + + + + + + +@widget: +@accel_signal: +@accel_group: +@accel_key: +@accel_mods: +@accel_flags: + + + + + + + +@widget: +@accel_group: +@accel_key: +@accel_mods: + + + + + + + +@widget: +@accel_signal: +@visible_only: + + + + + + + +@widget: +@accel_group: +@accel_key: +@accel_mods: +@Returns: + + + + + + + +@widget: +@event: +@Returns: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@new_parent: + + + + + + + +@widget: +@x: +@y: + + + + + + + +@widget: +@area: +@intersection: +@Returns: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: +@name: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@state: + + + + + + + +@widget: +@sensitive: + + + + + + + +@widget: +@parent: + + + + + + + +@widget: +@parent_window: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@x: +@y: + + + + + + + +@widget: +@width: +@height: + + + + + + + +@widget: +@events: + + + + + + + +@widget: +@events: + + + + + + + +@widget: +@mode: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@widget_type: +@Returns: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@colormap: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@visual: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@x: +@y: + + + + + + + +@widget: +@ancestor: +@Returns: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: +@style: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: + + + + + + + +@widget: + + + + + + + +@style: + + + + + + + +@cmap: + + + + + + + +@visual: + + + + + + + + + + + + + + + + + + + + + + + + + + + + +@style: + + + + + + + +@colormap: + + + + + + + +@visual: + + + + + + + +@Returns: + + + + + + + +@Returns: + + + + + + + +@Returns: + + + + + + + +@widget: +@shape_mask: +@offset_x: +@offset_y: + + + + + + + +@widget: +@path_length: +@path: +@path_reversed: + + + + + + + +@widget: +@path_length: +@path: +@path_reversed: + + + + + + + +@widget: +@Returns: + + + + + + + +@widget: + + + + + + + +@widget: +@style: + + + + + + + + + + + + + + + + + + + + + +@widget: + + + + + + + +@widget: +@x: +@y: +@width: +@height: + + + + + + + +@widget: +@x: +@y: +@width: +@height: + + + + + + + +@widget: + + + + + + + +@widget: +@app_paintable: + + + + + + + +@widget: +@name: + + + + + + + +@widget: +@hadjustment: +@vadjustment: +@Returns: + + + + + + + +@widget: + + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. +@area: + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. +@requisition: + + + + + + +@widget: the object which received the signal. +@allocation: + + + + + + +@widget: the object which received the signal. +@state: + + + + + + +@widget: the object which received the signal. +@old_parent: + + + + + + +@widget: the object which received the signal. +@previous_style: + + + + + + +@widget: the object which received the signal. +@accel_signal_id: +@accel_group: +@accel_key: +@accel_mods: +@accel_flags: + + + + + + +@widget: the object which received the signal. +@accel_group: +@accel_key: +@accel_mods: + + + + + + +@widget: the object which received the signal. + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@data: +@info: +@time: + + + + + + +@widget: the object which received the signal. +@data: +@time: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@drag_context: + + + + + + +@widget: the object which received the signal. +@drag_context: + + + + + + +@widget: the object which received the signal. +@drag_context: + + + + + + +@widget: the object which received the signal. +@drag_context: +@time: + + + + + + +@widget: the object which received the signal. +@drag_context: +@x: +@y: +@time: +@Returns: + + + + + + +@widget: the object which received the signal. +@drag_context: +@x: +@y: +@time: +@Returns: + + + + + + +@widget: the object which received the signal. +@drag_context: +@data: +@info: +@time: + + + + + + +@widget: the object which received the signal. +@drag_context: +@x: +@y: +@data: +@info: +@time: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@event: +@Returns: + + + + + + +@widget: the object which received the signal. +@message: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/gtk/tmpl/gtkwindow.sgml b/docs/reference/gtk/tmpl/gtkwindow.sgml new file mode 100644 index 0000000000..abb94a3fa6 --- /dev/null +++ b/docs/reference/gtk/tmpl/gtkwindow.sgml @@ -0,0 +1,247 @@ + +GtkWindow + + + + + + + + + + + + + + + + + + + +@bin: +@title: +@wmclass_name: +@wmclass_class: +@type: +@focus_widget: +@default_widget: +@transient_parent: +@resize_count: +@allow_shrink: +@allow_grow: +@auto_shrink: +@handling_resize: +@position: +@use_uposition: +@modal: + + + + + + +@type: +@Returns: + + + + + + + +@window: +@title: + + + + + + + +@window: +@wmclass_name: +@wmclass_class: + + + + + + + +@window: +@focus: + + + + + + + +@window: +@defaultw: + + + + + + + +@window: +@allow_shrink: +@allow_grow: +@auto_shrink: + + + + + + + +@window: +@accel_group: + + + + + + + +@window: +@accel_group: + + + + + + + + + + + + + + +@window: +@Returns: + + + + + + + +@window: +@Returns: + + + + + + + +@window: +@modal: + + + + + + + +@window: +@xid: + + + + + + + +@window: +@xid: + + + + + + + +@window: +@width: +@height: + + + + + + + +@window: +@geometry_widget: +@geometry: +@geom_mask: + + + + + + + +@window: +@position: + + + + + + + +@window: +@parent: + + + + + + + +@window: the object which received the signal. +@widget: + + + +The type of the window. + + + + +The title of the window. + + + + +If the window shrinks automatically when widgets within it shrink. + + + + +If the window can be resized to a smaller size by the user. + + + + +If the window can be resized to a larger size by the user. + + + + +If the window is modal, i.e. it grabs all GTK+ events. + + + + +The position of the window. + + -- cgit v1.2.1