src/gtk/MenuBar.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit 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  * duit 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 duit; 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  * local aliases:
  53  */
  54
  55 module gtk.MenuBar;
  56
  57 private import gtk.gtktypes;
  58
  59 private import lib.gtk;
  60
  61 private import gtk.Widget;
  62 private import gtk.Menu;;
  63 private import gtk.MenuItem;;
  64
  65 /**
  66  * Description
  67  * 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.
  68  */
  69 private import gtk.MenuShell;
  70 public class MenuBar : MenuShell
  71 {
  72
  73         /** the main Gtk struct */
  74         protected GtkMenuBar* gtkMenuBar;
  75
  76
  77         public GtkMenuBar* getMenuBarStruct()
  78         {
  79                 return gtkMenuBar;
  80         }
  81
  82
  83         /** the main Gtk struct as a void* */
  84         protected void* getStruct()
  85         {
  86                 return cast(void*)gtkMenuBar;
  87         }
  88
  89         /**
  90          * Sets our main struct and passes it to the parent class
  91          */
  92         public this (GtkMenuBar* gtkMenuBar)
  93         {
  94                 super(cast(GtkMenuShell*)gtkMenuBar);
  95                 this.gtkMenuBar = gtkMenuBar;
  96         }
  97
  98         Menu append(char[] label, bool rightJustify=false)
  99         {
 100                 MenuItem item = new MenuItem(label);
 101                 super.append(item);
 102                 item.setRightJustified(rightJustify);
 103                 Menu menu= new Menu();
 104                 item.setSubmenu(menu);
 105                 return menu;
 106         }
 107
 108         public void append(Widget widget)
 109         {
 110                 super.append(widget);
 111         }
 112
 113         /**
 114          */
 115
 116
 117         /**
 118          * Creates the new GtkMenuBar
 119          * Returns:
 120          * the GtkMenuBar
 121          */
 122         public this ()
 123         {
 124                 // GtkWidget* gtk_menu_bar_new (void);
 125                 this(cast(GtkMenuBar*)gtk_menu_bar_new() );
 126         }
 127
 128
 129
 130
 131
 132         /**
 133          * Sets how items should be packed inside a menubar.
 134          * menubar:
 135          *  a GtkMenuBar.
 136          * pack_dir:
 137          *  a new GtkPackDirection.
 138          * Since 2.8
 139          */
 140         public void setPackDirection(GtkPackDirection packDir)
 141         {
 142                 // void gtk_menu_bar_set_pack_direction (GtkMenuBar *menubar,  GtkPackDirection pack_dir);
 143                 gtk_menu_bar_set_pack_direction(gtkMenuBar, packDir);
 144         }
 145
 146         /**
 147          * Retrieves the current pack direction of the menubar. See
 148          * gtk_menu_bar_set_pack_direction().
 149          * menubar:
 150          *  a GtkMenuBar
 151          * Returns:
 152          *  the pack direction
 153          * Since 2.8
 154          */
 155         public GtkPackDirection getPackDirection()
 156         {
 157                 // GtkPackDirection gtk_menu_bar_get_pack_direction  (GtkMenuBar *menubar);
 158                 return gtk_menu_bar_get_pack_direction(gtkMenuBar);
 159         }
 160
 161         /**
 162          * Sets how widgets should be packed inside the children of a menubar.
 163          * menubar:
 164          *  a GtkMenuBar.
 165          * child_pack_dir:
 166          *  a new GtkPackDirection.
 167          * Since 2.8
 168          */
 169         public void setChildPackDirection(GtkPackDirection childPackDir)
 170         {
 171                 // void gtk_menu_bar_set_child_pack_direction  (GtkMenuBar *menubar,  GtkPackDirection child_pack_dir);
 172                 gtk_menu_bar_set_child_pack_direction(gtkMenuBar, childPackDir);
 173         }
 174
 175         /**
 176          * Retrieves the current child pack direction of the menubar. See
 177          * gtk_menu_bar_set_child_pack_direction().
 178          * menubar:
 179          *  a GtkMenuBar
 180          * Returns:
 181          *  the child pack direction
 182          * Since 2.8
 183          * Property Details
 184          * The "child-pack-direction" property
 185          *  "child-pack-direction" GtkPackDirection : Read / Write
 186          * The pack direction of the menubar. It determines how
 187          * the widgets contained in child menuitems are arranged.
 188          * Default value: GTK_PACK_DIRECTION_LTR
 189          * Since 2.8
 190          */
 191         public GtkPackDirection getChildPackDirection()
 192         {
 193                 // GtkPackDirection gtk_menu_bar_get_child_pack_direction  (GtkMenuBar *menubar);
 194                 return gtk_menu_bar_get_child_pack_direction(gtkMenuBar);
 195         }
 196
 197
 198 }