gtkD/src/gtk/ToolButton.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = GtkToolButton.html
  26  * outPack = gtk
  27  * outFile = ToolButton
  28  * strct   = GtkToolButton
  29  * realStrct=
  30  * ctorStrct=GtkToolItem
  31  * clss    = ToolButton
  32  * interf  =
  33  * class Code: Yes
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_tool_button_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - glib.Str
  46  *      - gtk.ToolItem
  47  *      - gtk.Widget
  48  * structWrap:
  49  *      - GtkWidget* -> Widget
  50  * module aliases:
  51  * local aliases:
  52  */
  53
  54 module gtk.ToolButton;
  55
  56 version(noAssert)
  57 {
  58         version(Tango)
  59         {
  60                 import tango.io.Stdout; // use the tango loging?
  61         }
  62 }
  63
  64 private import gtkc.gtktypes;
  65
  66 private import gtkc.gtk;
  67
  68
  69 private import glib.Str;
  70 private import gtk.ToolItem;
  71 private import gtk.Widget;
  72
  73
  74
  75
  76 /**
  77  * Description
  78  * GtkToolButtons are GtkToolItems containing buttons.
  79  * Use gtk_tool_button_new() to create a new GtkToolButton. Use
  80  * gtk_tool_button_new_with_stock() to create a GtkToolButton
  81  * containing a stock item.
  82  * The label of a GtkToolButton is determined by the properties
  83  * "label_widget", "label", and "stock_id". If "label_widget" is
  84  * non-NULL, then that widget is used as the label. Otherwise, if
  85  * "label" is non-NULL, that string is used as the label. Otherwise, if
  86  * "stock_id" is non-NULL, the label is determined by the stock
  87  * item. Otherwise, the button does not have a label.
  88  * The icon of a GtkToolButton is determined by the properties
  89  * "icon_widget" and "stock_id". If "icon_widget" is non-NULL, then
  90  * that widget is used as the icon. Otherwise, if "stock_id" is
  91  * non-NULL, the icon is determined by the stock item. Otherwise,
  92  * the button does not have a label.
  93  */
  94 private import gtk.ToolItem;
  95 public class ToolButton : ToolItem
  96 {
  97
  98         /** the main Gtk struct */
  99         protected GtkToolButton* gtkToolButton;
 100
 101
 102         public GtkToolButton* getToolButtonStruct()
 103         {
 104                 return gtkToolButton;
 105         }
 106
 107
 108         /** the main Gtk struct as a void* */
 109         protected void* getStruct()
 110         {
 111                 return cast(void*)gtkToolButton;
 112         }
 113
 114         /**
 115          * Sets our main struct and passes it to the parent class
 116          */
 117         public this (GtkToolButton* gtkToolButton)
 118         {
 119                 version(noAssert)
 120                 {
 121                         if ( gtkToolButton is null )
 122                         {
 123                                 int zero = 0;
 124                                 version(Tango)
 125                                 {
 126                                         Stdout("struct gtkToolButton is null on constructor").newline;
 127                                 }
 128                                 else
 129                                 {
 130                                         printf("struct gtkToolButton is null on constructor");
 131                                 }
 132                                 zero = zero / zero;
 133                         }
 134                 }
 135                 else
 136                 {
 137                         assert(gtkToolButton !is null, "struct gtkToolButton is null on constructor");
 138                 }
 139                 super(cast(GtkToolItem*)gtkToolButton);
 140                 this.gtkToolButton = gtkToolButton;
 141         }
 142
 143         /** An arbitrary string to be used by the application */
 144         private char[] action;
 145
 146         public void setActionName(char[] action)
 147         {
 148                 this.action = action.dup;
 149         }
 150
 151         public char[] getActionName()
 152         {
 153                 return action;
 154         }
 155
 156         public this (StockID stockID)
 157         {
 158                 this(StockDesc[stockID]);
 159         }
 160
 161
 162         /**
 163          */
 164
 165         // imports for the signal processing
 166         private import gobject.Signals;
 167         private import gtkc.gdktypes;
 168         int[char[]] connectedSignals;
 169
 170         void delegate(ToolButton)[] onClickedListeners;
 171         void addOnClicked(void delegate(ToolButton) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 172         {
 173                 if ( !("clicked" in connectedSignals) )
 174                 {
 175                         Signals.connectData(
 176                         getStruct(),
 177                         "clicked",
 178                         cast(GCallback)&callBackClicked,
 179                         cast(void*)this,
 180                         null,
 181                         connectFlags);
 182                         connectedSignals["clicked"] = 1;
 183                 }
 184                 onClickedListeners ~= dlg;
 185         }
 186         extern(C) static void callBackClicked(GtkToolButton* toolbuttonStruct, ToolButton toolButton)
 187         {
 188                 bool consumed = false;
 189
 190                 foreach ( void delegate(ToolButton) dlg ; toolButton.onClickedListeners )
 191                 {
 192                         dlg(toolButton);
 193                 }
 194
 195                 return consumed;
 196         }
 197
 198
 199
 200         /**
 201          * Creates a new GtkToolButton using icon_widget as icon and label as
 202          * label.
 203          * icon_widget:
 204          *  a widget that will be used as icon widget, or NULL
 205          * label:
 206          *  a string that will be used as label, or NULL
 207          * Returns:
 208          *  A new GtkToolButton
 209          * Since 2.4
 210          */
 211         public this (Widget iconWidget, char[] label)
 212         {
 213                 // GtkToolItem* gtk_tool_button_new (GtkWidget *icon_widget,  const gchar *label);
 214                 this(cast(GtkToolButton*)gtk_tool_button_new((iconWidget is null) ? null : iconWidget.getWidgetStruct(), Str.toStringz(label)) );
 215         }
 216
 217         /**
 218          * Creates a new GtkToolButton containing the image and text from a
 219          * stock item. Some stock ids have preprocessor macros like GTK_STOCK_OK
 220          * and GTK_STOCK_APPLY.
 221          * It is an error if stock_id is not a name of a stock item.
 222          * stock_id:
 223          *  the name of the stock item
 224          * Returns:
 225          *  A new GtkToolButton
 226          * Since 2.4
 227          */
 228         public this (char[] stockId)
 229         {
 230                 // GtkToolItem* gtk_tool_button_new_from_stock (const gchar *stock_id);
 231                 this(cast(GtkToolButton*)gtk_tool_button_new_from_stock(Str.toStringz(stockId)) );
 232         }
 233
 234         /**
 235          * Sets label as the label used for the tool button. The "label" property
 236          * only has an effect if not overridden by a non-NULL "label_widget" property.
 237          * If both the "label_widget" and "label" properties are NULL, the label
 238          * is determined by the "stock_id" property. If the "stock_id" property is also
 239          * NULL, button will not have a label.
 240          * button:
 241          *  a GtkToolButton
 242          * label:
 243          *  a string that will be used as label, or NULL.
 244          * Since 2.4
 245          */
 246         public void setLabel(char[] label)
 247         {
 248                 // void gtk_tool_button_set_label (GtkToolButton *button,  const gchar *label);
 249                 gtk_tool_button_set_label(gtkToolButton, Str.toStringz(label));
 250         }
 251
 252         /**
 253          * Returns the label used by the tool button, or NULL if the tool button
 254          * doesn't have a label. or uses a the label from a stock item. The returned
 255          * string is owned by GTK+, and must not be modified or freed.
 256          * button:
 257          *  a GtkToolButton
 258          * Returns:
 259          *  The label, or NULL
 260          * Since 2.4
 261          */
 262         public char[] getLabel()
 263         {
 264                 // const gchar* gtk_tool_button_get_label (GtkToolButton *button);
 265                 return Str.toString(gtk_tool_button_get_label(gtkToolButton) );
 266         }
 267
 268         /**
 269          * If set, an underline in the label property indicates that the next character
 270          * should be used for the mnemonic accelerator key in the overflow menu. For
 271          * example, if the label property is "_Open" and use_underline is TRUE,
 272          * the label on the tool button will be "Open" and the item on the overflow
 273          * menu will have an underlined 'O'.
 274          * Labels shown on tool buttons never have mnemonics on them; this property
 275          * only affects the menu item on the overflow menu.
 276          * button:
 277          *  a GtkToolButton
 278          * use_underline:
 279          *  whether the button label has the form "_Open"
 280          * Since 2.4
 281          */
 282         public void setUseUnderline(int useUnderline)
 283         {
 284                 // void gtk_tool_button_set_use_underline (GtkToolButton *button,  gboolean use_underline);
 285                 gtk_tool_button_set_use_underline(gtkToolButton, useUnderline);
 286         }
 287
 288         /**
 289          * Returns whether underscores in the label property are used as mnemonics
 290          * on menu items on the overflow menu. See gtk_tool_button_set_use_underline().
 291          * button:
 292          *  a GtkToolButton
 293          * Returns:
 294          *  TRUE if underscores in the label property are used as
 295          * mnemonics on menu items on the overflow menu.
 296          * Since 2.4
 297          */
 298         public int getUseUnderline()
 299         {
 300                 // gboolean gtk_tool_button_get_use_underline (GtkToolButton *button);
 301                 return gtk_tool_button_get_use_underline(gtkToolButton);
 302         }
 303
 304         /**
 305          * Sets the name of the stock item. See gtk_tool_button_new_from_stock().
 306          * The stock_id property only has an effect if not
 307          * overridden by non-NULL "label" and "icon_widget" properties.
 308          * button:
 309          *  a GtkToolButton
 310          * stock_id:
 311          *  a name of a stock item, or NULL
 312          * Since 2.4
 313          */
 314         public void setStockId(char[] stockId)
 315         {
 316                 // void gtk_tool_button_set_stock_id (GtkToolButton *button,  const gchar *stock_id);
 317                 gtk_tool_button_set_stock_id(gtkToolButton, Str.toStringz(stockId));
 318         }
 319
 320         /**
 321          * Returns the name of the stock item. See gtk_tool_button_set_stock_id().
 322          * The returned string is owned by GTK+ and must not be freed or modifed.
 323          * button:
 324          *  a GtkToolButton
 325          * Returns:
 326          *  the name of the stock item for button.
 327          * Since 2.4
 328          */
 329         public char[] getStockId()
 330         {
 331                 // const gchar* gtk_tool_button_get_stock_id (GtkToolButton *button);
 332                 return Str.toString(gtk_tool_button_get_stock_id(gtkToolButton) );
 333         }
 334
 335         /**
 336          * Sets the icon for the tool button from a named themed icon.
 337          * See the docs for GtkIconTheme for more details.
 338          * The "icon_name" property only has an effect if not
 339          * overridden by non-NULL "label", "icon_widget" and "stock_id"
 340          * properties.
 341          * button:
 342          *  a GtkToolButton
 343          * icon_name:
 344          *  the name of the themed icon
 345          * Since 2.8
 346          */
 347         public void setIconName(char[] iconName)
 348         {
 349                 // void gtk_tool_button_set_icon_name (GtkToolButton *button,  const gchar *icon_name);
 350                 gtk_tool_button_set_icon_name(gtkToolButton, Str.toStringz(iconName));
 351         }
 352
 353         /**
 354          * Returns the name of the themed icon for the tool button,
 355          * see gtk_tool_button_set_icon_name().
 356          * button:
 357          *  a GtkToolButton
 358          * Returns:
 359          *  the icon name or NULL if the tool button has
 360          * no themed icon
 361          * Since 2.8
 362          */
 363         public char[] getIconName()
 364         {
 365                 // const gchar* gtk_tool_button_get_icon_name (GtkToolButton *button);
 366                 return Str.toString(gtk_tool_button_get_icon_name(gtkToolButton) );
 367         }
 368
 369         /**
 370          * Sets icon as the widget used as icon on button. If icon_widget is
 371          * NULL the icon is determined by the "stock_id" property. If the
 372          * "stock_id" property is also NULL, button will not have an icon.
 373          * button:
 374          *  a GtkToolButton
 375          * icon_widget:
 376          *  the widget used as icon, or NULL
 377          * Since 2.4
 378          */
 379         public void setIconWidget(Widget iconWidget)
 380         {
 381                 // void gtk_tool_button_set_icon_widget (GtkToolButton *button,  GtkWidget *icon_widget);
 382                 gtk_tool_button_set_icon_widget(gtkToolButton, (iconWidget is null) ? null : iconWidget.getWidgetStruct());
 383         }
 384
 385         /**
 386          * Return the widget used as icon widget on button. See
 387          * gtk_tool_button_set_icon_widget().
 388          * button:
 389          *  a GtkToolButton
 390          * Returns:
 391          *  The widget used as icon on button, or NULL.
 392          * Since 2.4
 393          */
 394         public Widget getIconWidget()
 395         {
 396                 // GtkWidget* gtk_tool_button_get_icon_widget (GtkToolButton *button);
 397                 return new Widget( gtk_tool_button_get_icon_widget(gtkToolButton) );
 398         }
 399
 400         /**
 401          * Sets label_widget as the widget that will be used as the label
 402          * for button. If label_widget is NULL the "label" property is used
 403          * as label. If "label" is also NULL, the label in the stock item
 404          * determined by the "stock_id" property is used as label. If
 405          * "stock_id" is also NULL, button does not have a label.
 406          * button:
 407          *  a GtkToolButton
 408          * label_widget:
 409          *  the widget used as label, or NULL
 410          * Since 2.4
 411          */
 412         public void setLabelWidget(Widget labelWidget)
 413         {
 414                 // void gtk_tool_button_set_label_widget (GtkToolButton *button,  GtkWidget *label_widget);
 415                 gtk_tool_button_set_label_widget(gtkToolButton, (labelWidget is null) ? null : labelWidget.getWidgetStruct());
 416         }
 417
 418         /**
 419          * Returns the widget used as label on button. See
 420          * gtk_tool_button_set_label_widget().
 421          * button:
 422          *  a GtkToolButton
 423          * Returns:
 424          *  The widget used as label on button, or NULL.
 425          * Since 2.4
 426          * Property Details
 427          * The "icon-name" property
 428          *  "icon-name" gchararray : Read / Write
 429          * The name of the themed icon displayed on the item.
 430          * This property only has an effect if not overridden by "label",
 431          * "icon_widget" or "stock_id" properties.
 432          * Default value: NULL
 433          * Since 2.8
 434          */
 435         public Widget getLabelWidget()
 436         {
 437                 // GtkWidget* gtk_tool_button_get_label_widget (GtkToolButton *button);
 438                 return new Widget( gtk_tool_button_get_label_widget(gtkToolButton) );
 439         }
 440
 441
 442
 443
 444
 445 }