gtkD/src/gtk/MenuBar.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  = GtkMenuBar.html
  26  * outPack = gtk
  27  * outFile = MenuBar
  28  * strct   = GtkMenuBar
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = MenuBar
  32  * interf  =
  33  * class Code: Yes
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_menu_bar_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - gtk.Widget
  46  *      - gtk.Menu;
  47  *      - gtk.MenuItem;
  48  * structWrap:
  49  *      - GtkMenu* -> Menu
  50  *      - GtkMenuItem* -> MenuItem
  51  *      - GtkWidget* -> Widget
  52  * module aliases:
  53  * local aliases:
  54  */
  55
  56 module gtk.MenuBar;
  57
  58 version(noAssert)
  59 {
  60         version(Tango)
  61         {
  62                 import tango.io.Stdout; // use the tango loging?
  63         }
  64 }
  65
  66 private import gtkc.gtktypes;
  67
  68 private import gtkc.gtk;
  69
  70
  71 private import gtk.Widget;
  72 private import gtk.Menu;;
  73 private import gtk.MenuItem;;
  74
  75
  76
  77
  78 /**
  79  * Description
  80  * The GtkMenuBar is a subclass of GtkMenuShell which contains one to many GtkMenuItem. The result is a standard menu bar which can hold many menu items. GtkMenuBar allows for a shadow type to be set for aesthetic purposes. The shadow types are defined in the gtk_menu_bar_set_shadow_type function.
  81  */
  82 private import gtk.MenuShell;
  83 public class MenuBar : MenuShell
  84 {
  85
  86         /** the main Gtk struct */
  87         protected GtkMenuBar* gtkMenuBar;
  88
  89
  90         public GtkMenuBar* getMenuBarStruct()
  91         {
  92                 return gtkMenuBar;
  93         }
  94
  95
  96         /** the main Gtk struct as a void* */
  97         protected void* getStruct()
  98         {
  99                 return cast(void*)gtkMenuBar;
 100         }
 101
 102         /**
 103          * Sets our main struct and passes it to the parent class
 104          */
 105         public this (GtkMenuBar* gtkMenuBar)
 106         {
 107                 version(noAssert)
 108                 {
 109                         if ( gtkMenuBar is null )
 110                         {
 111                                 int zero = 0;
 112                                 version(Tango)
 113                                 {
 114                                         Stdout("struct gtkMenuBar is null on constructor").newline;
 115                                 }
 116                                 else
 117                                 {
 118                                         printf("struct gtkMenuBar is null on constructor");
 119                                 }
 120                                 zero = zero / zero;
 121                         }
 122                 }
 123                 else
 124                 {
 125                         assert(gtkMenuBar !is null, "struct gtkMenuBar is null on constructor");
 126                 }
 127                 super(cast(GtkMenuShell*)gtkMenuBar);
 128                 this.gtkMenuBar = gtkMenuBar;
 129         }
 130
 131         Menu append(char[] label, bool rightJustify=false)
 132         {
 133                 MenuItem item = new MenuItem(label);
 134                 super.append(item);
 135                 item.setRightJustified(rightJustify);
 136                 Menu menu= new Menu();
 137                 item.setSubmenu(menu);
 138                 return menu;
 139         }
 140
 141         public void append(Widget widget)
 142         {
 143                 super.append(widget);
 144         }
 145
 146         /**
 147          */
 148
 149
 150         /**
 151          * Creates the new GtkMenuBar
 152          * Returns:
 153          * the GtkMenuBar
 154          */
 155         public this ()
 156         {
 157                 // GtkWidget* gtk_menu_bar_new (void);
 158                 this(cast(GtkMenuBar*)gtk_menu_bar_new() );
 159         }
 160
 161
 162
 163
 164
 165         /**
 166          * Sets how items should be packed inside a menubar.
 167          * menubar:
 168          *  a GtkMenuBar.
 169          * pack_dir:
 170          *  a new GtkPackDirection.
 171          * Since 2.8
 172          */
 173         public void setPackDirection(GtkPackDirection packDir)
 174         {
 175                 // void gtk_menu_bar_set_pack_direction (GtkMenuBar *menubar,  GtkPackDirection pack_dir);
 176                 gtk_menu_bar_set_pack_direction(gtkMenuBar, packDir);
 177         }
 178
 179         /**
 180          * Retrieves the current pack direction of the menubar. See
 181          * gtk_menu_bar_set_pack_direction().
 182          * menubar:
 183          *  a GtkMenuBar
 184          * Returns:
 185          *  the pack direction
 186          * Since 2.8
 187          */
 188         public GtkPackDirection getPackDirection()
 189         {
 190                 // GtkPackDirection gtk_menu_bar_get_pack_direction (GtkMenuBar *menubar);
 191                 return gtk_menu_bar_get_pack_direction(gtkMenuBar);
 192         }
 193
 194         /**
 195          * Sets how widgets should be packed inside the children of a menubar.
 196          * menubar:
 197          *  a GtkMenuBar.
 198          * child_pack_dir:
 199          *  a new GtkPackDirection.
 200          * Since 2.8
 201          */
 202         public void setChildPackDirection(GtkPackDirection childPackDir)
 203         {
 204                 // void gtk_menu_bar_set_child_pack_direction  (GtkMenuBar *menubar,  GtkPackDirection child_pack_dir);
 205                 gtk_menu_bar_set_child_pack_direction(gtkMenuBar, childPackDir);
 206         }
 207
 208         /**
 209          * Retrieves the current child pack direction of the menubar. See
 210          * gtk_menu_bar_set_child_pack_direction().
 211          * menubar:
 212          *  a GtkMenuBar
 213          * Returns:
 214          *  the child pack direction
 215          * Since 2.8
 216          * Property Details
 217          * The "child-pack-direction" property
 218          *  "child-pack-direction" GtkPackDirection : Read / Write
 219          * The pack direction of the menubar. It determines how
 220          * the widgets contained in child menuitems are arranged.
 221          * Default value: GTK_PACK_DIRECTION_LTR
 222          * Since 2.8
 223          */
 224         public GtkPackDirection getChildPackDirection()
 225         {
 226                 // GtkPackDirection gtk_menu_bar_get_child_pack_direction  (GtkMenuBar *menubar);
 227                 return gtk_menu_bar_get_child_pack_direction(gtkMenuBar);
 228         }
 229
 230
 231 }