src/gtk/AccelMap.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  = gtk-Accelerator-Maps.html
  26  * outPack = gtk
  27  * outFile = AccelMap
  28  * strct   = GtkAccelMap
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = AccelMap
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_accel_map_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  *      - glib.Str
  46  *      - gtk.AccelMap
  47  * structWrap:
  48  *      - GtkAccelMap* -> AccelMap
  49  * local aliases:
  50  */
  51
  52 module gtk.AccelMap;
  53
  54 private import gtk.gtktypes;
  55
  56 private import lib.gtk;
  57
  58 private import glib.Str;
  59 private import gtk.AccelMap;
  60
  61 /**
  62  * Description
  63  */
  64 private import gobject.ObjectG;
  65 public class AccelMap : ObjectG
  66 {
  67
  68         /** the main Gtk struct */
  69         protected GtkAccelMap* gtkAccelMap;
  70
  71
  72         public GtkAccelMap* getAccelMapStruct()
  73         {
  74                 return gtkAccelMap;
  75         }
  76
  77
  78         /** the main Gtk struct as a void* */
  79         protected void* getStruct()
  80         {
  81                 return cast(void*)gtkAccelMap;
  82         }
  83
  84         /**
  85          * Sets our main struct and passes it to the parent class
  86          */
  87         public this (GtkAccelMap* gtkAccelMap)
  88         {
  89                 super(cast(GObject*)gtkAccelMap);
  90                 this.gtkAccelMap = gtkAccelMap;
  91         }
  92
  93         /**
  94          */
  95
  96         // imports for the signal processing
  97         private import gobject.Signals;
  98         private import gdk.gdktypes;
  99         int[char[]] connectedSignals;
 100
 101         void delegate(char[], guint, GdkModifierType, AccelMap)[] onChangedListeners;
 102         void addOnChanged(void delegate(char[], guint, GdkModifierType, AccelMap) dlg)
 103         {
 104                 if ( !("changed" in connectedSignals) )
 105                 {
 106                         Signals.connectData(
 107                         getStruct(),
 108                         "changed",
 109                         cast(GCallback)&callBackChanged,
 110                         this,
 111                         null,
 112                         cast(ConnectFlags)0);
 113                         connectedSignals["changed"] = 1;
 114                 }
 115                 onChangedListeners ~= dlg;
 116         }
 117         extern(C) static void callBackChanged(GtkAccelMap* objectStruct, gchar* accelPath, guint accelKey, GdkModifierType accelMods, AccelMap accelMap)
 118         {
 119                 bit consumed = false;
 120
 121                 foreach ( void delegate(char[], guint, GdkModifierType, AccelMap) dlg ; accelMap.onChangedListeners )
 122                 {
 123                         dlg(Str.toString(accelPath), accelKey, accelMods, accelMap);
 124                 }
 125
 126                 return consumed;
 127         }
 128
 129
 130
 131
 132         /**
 133          * Registers a new accelerator with the global accelerator map.
 134          * This function should only be called once per accel_path
 135          * with the canonical accel_key and accel_mods for this path.
 136          * To change the accelerator during runtime programatically, use
 137          * gtk_accel_map_change_entry().
 138          * The accelerator path must consist of "<WINDOWTYPE>/Category1/Category2/.../Action",
 139          * where <WINDOWTYPE> should be a unique application-specific identifier, that
 140          * corresponds to the kind of window the accelerator is being used in, e.g. "Gimp-Image",
 141          * "Abiword-Document" or "Gnumeric-Settings".
 142          * The Category1/.../Action portion is most appropriately chosen by the action the
 143          * accelerator triggers, i.e. for accelerators on menu items, choose the item's menu path,
 144          * e.g. "File/Save As", "Image/View/Zoom" or "Edit/Select All".
 145          * So a full valid accelerator path may look like:
 146          * "<Gimp-Toolbox>/File/Dialogs/Tool Options...".
 147          * accel_path:
 148          *  valid accelerator path
 149          * accel_key:
 150          *  the accelerator key
 151          * accel_mods:
 152          *  the accelerator modifiers
 153          */
 154         public static void addEntry(char[] accelPath, uint accelKey, GdkModifierType accelMods)
 155         {
 156                 // void gtk_accel_map_add_entry (const gchar *accel_path,  guint accel_key,  GdkModifierType accel_mods);
 157                 gtk_accel_map_add_entry(Str.toStringz(accelPath), accelKey, accelMods);
 158         }
 159
 160         /**
 161          * Looks up the accelerator entry for accel_path and fills in key.
 162          * accel_path:
 163          *  a valid accelerator path
 164          * key:
 165          *  the accelerator key to be filled in (optional)
 166          * Returns:
 167          *  TRUE if accel_path is known, FALSE otherwise
 168          */
 169         public static int lookupEntry(char[] accelPath, GtkAccelKey* key)
 170         {
 171                 // gboolean gtk_accel_map_lookup_entry (const gchar *accel_path,  GtkAccelKey *key);
 172                 return gtk_accel_map_lookup_entry(Str.toStringz(accelPath), key);
 173         }
 174
 175         /**
 176          * Changes the accel_key and accel_mods currently associated with accel_path.
 177          * Due to conflicts with other accelerators, a change may not always be possible,
 178          * replace indicates whether other accelerators may be deleted to resolve such
 179          * conflicts. A change will only occur if all conflicts could be resolved (which
 180          * might not be the case if conflicting accelerators are locked). Successful
 181          * changes are indicated by a TRUE return value.
 182          * accel_path:
 183          *  a valid accelerator path
 184          * accel_key:
 185          *  the new accelerator key
 186          * accel_mods:
 187          *  the new accelerator modifiers
 188          * replace:
 189          *  TRUE if other accelerators may be deleted upon conflicts
 190          * Returns:
 191          *  TRUE if the accelerator could be changed, FALSE otherwise
 192          */
 193         public static int changeEntry(char[] accelPath, uint accelKey, GdkModifierType accelMods, int replace)
 194         {
 195                 // gboolean gtk_accel_map_change_entry (const gchar *accel_path,  guint accel_key,  GdkModifierType accel_mods,  gboolean replace);
 196                 return gtk_accel_map_change_entry(Str.toStringz(accelPath), accelKey, accelMods, replace);
 197         }
 198
 199         /**
 200          * Parses a file previously saved with gtk_accel_map_save() for
 201          * accelerator specifications, and propagates them accordingly.
 202          * file_name:
 203          *  a file containing accelerator specifications,
 204          *  in the GLib file name encoding
 205          */
 206         public static void load(char[] fileName)
 207         {
 208                 // void gtk_accel_map_load (const gchar *file_name);
 209                 gtk_accel_map_load(Str.toStringz(fileName));
 210         }
 211
 212         /**
 213          * Saves current accelerator specifications (accelerator path, key
 214          * and modifiers) to file_name.
 215          * The file is written in a format suitable to be read back in by
 216          * gtk_accel_map_load().
 217          * file_name:
 218          *  the name of the file to contain accelerator specifications,
 219          *  in the GLib file name encoding
 220          */
 221         public static void save(char[] fileName)
 222         {
 223                 // void gtk_accel_map_save (const gchar *file_name);
 224                 gtk_accel_map_save(Str.toStringz(fileName));
 225         }
 226
 227         /**
 228          * Loops over the entries in the accelerator map whose accel path
 229          * doesn't match any of the filters added with gtk_accel_map_add_filter(),
 230          * and execute foreach_func on each. The signature of foreach_func is
 231          * that of GtkAccelMapForeach, the changed parameter indicates whether
 232          * this accelerator was changed during runtime (thus, would need
 233          * saving during an accelerator map dump).
 234          * data:
 235          *  data to be passed into foreach_func
 236          * foreach_func:
 237          *  function to be executed for each accel map entry which
 238          *  is not filtered out
 239          */
 240         public static void foreac(void* data, GtkAccelMapForeach foreachFunc)
 241         {
 242                 // void gtk_accel_map_foreach (gpointer data,  GtkAccelMapForeach foreach_func);
 243                 gtk_accel_map_foreach(data, foreachFunc);
 244         }
 245
 246         /**
 247          * Filedescriptor variant of gtk_accel_map_load().
 248          * Note that the file descriptor will not be closed by this function.
 249          * fd:
 250          *  a valid readable file descriptor
 251          */
 252         public static void loadFd(int fd)
 253         {
 254                 // void gtk_accel_map_load_fd (gint fd);
 255                 gtk_accel_map_load_fd(fd);
 256         }
 257
 258         /**
 259          * Filedescriptor variant of gtk_accel_map_save().
 260          * Note that the file descriptor will not be closed by this function.
 261          * fd:
 262          *  a valid writable file descriptor
 263          */
 264         public static void saveFd(int fd)
 265         {
 266                 // void gtk_accel_map_save_fd (gint fd);
 267                 gtk_accel_map_save_fd(fd);
 268         }
 269
 270         /**
 271          * GScanner variant of gtk_accel_map_load().
 272          * scanner:
 273          *  a GScanner which has already been provided with an input file
 274          */
 275         public static void loadScanner(GScanner* scanner)
 276         {
 277                 // void gtk_accel_map_load_scanner (GScanner *scanner);
 278                 gtk_accel_map_load_scanner(scanner);
 279         }
 280
 281         /**
 282          * Adds a filter to the global list of accel path filters.
 283          * Accel map entries whose accel path matches one of the filters
 284          * are skipped by gtk_accel_map_foreach().
 285          * This function is intended for GTK+ modules that create their own
 286          * menus, but don't want them to be saved into the applications accelerator
 287          * map dump.
 288          * filter_pattern:
 289          *  a pattern (see GPatternSpec)
 290          */
 291         public static void addFilter(char[] filterPattern)
 292         {
 293                 // void gtk_accel_map_add_filter (const gchar *filter_pattern);
 294                 gtk_accel_map_add_filter(Str.toStringz(filterPattern));
 295         }
 296
 297         /**
 298          * Loops over all entries in the accelerator map, and execute
 299          * foreach_func on each. The signature of foreach_func is that of
 300          * GtkAccelMapForeach, the changed parameter indicates whether
 301          * this accelerator was changed during runtime (thus, would need
 302          * saving during an accelerator map dump).
 303          * data:
 304          *  data to be passed into foreach_func
 305          * foreach_func:
 306          *  function to be executed for each accel map entry
 307          */
 308         public static void foreachUnfiltered(void* data, GtkAccelMapForeach foreachFunc)
 309         {
 310                 // void gtk_accel_map_foreach_unfiltered  (gpointer data,  GtkAccelMapForeach foreach_func);
 311                 gtk_accel_map_foreach_unfiltered(data, foreachFunc);
 312         }
 313
 314         /**
 315          * Gets the singleton global GtkAccelMap object. This object
 316          * is useful only for notification of changes to the accelerator
 317          * map via the ::changed signal; it isn't a parameter to the
 318          * other accelerator map functions.
 319          * Returns:
 320          *  the global GtkAccelMap object
 321          * Since 2.4
 322          */
 323         public static AccelMap get()
 324         {
 325                 // GtkAccelMap* gtk_accel_map_get (void);
 326                 return new AccelMap( gtk_accel_map_get() );
 327         }
 328
 329         /**
 330          * Locks the given accelerator path. If the accelerator map doesn't yet contain
 331          * an entry for accel_path, a new one is created.
 332          * Locking an accelerator path prevents its accelerator from being changed
 333          * during runtime. A locked accelerator path can be unlocked by
 334          * gtk_accel_map_unlock_path(). Refer to gtk_accel_map_change_entry()
 335          * for information about runtime accelerator changes.
 336          * If called more than once, accel_path remains locked until
 337          * gtk_accel_map_unlock_path() has been called an equivalent number
 338          * of times.
 339          * Note that locking of individual accelerator paths is independent from
 340          * locking the GtkAccelGroup containing them. For runtime accelerator
 341          * changes to be possible both the accelerator path and its GtkAccelGroup
 342          * have to be unlocked.
 343          * accel_path:
 344          *  a valid accelerator path
 345          * Since 2.4
 346          */
 347         public static void lockPath(char[] accelPath)
 348         {
 349                 // void gtk_accel_map_lock_path (const gchar *accel_path);
 350                 gtk_accel_map_lock_path(Str.toStringz(accelPath));
 351         }
 352
 353         /**
 354          * Undoes the last call to gtk_accel_map_lock_path() on this accel_path.
 355          * Refer to gtk_accel_map_lock_path() for information about accelerator path locking.
 356          * accel_path:
 357          *  a valid accelerator path
 358          * Since 2.4
 359          * Signal Details
 360          * The "changed" signal
 361          * void user_function (GtkAccelMap *object,
 362          *  gchar *accel_path,
 363          *  guint accel_key,
 364          *  GdkModifierType accel_mods,
 365          *  gpointer user_data) : Run last / Has details
 366          * Notifies of a change in the global accelerator map.
 367          * The path is also used as the detail for the signal,
 368          * so it is possible to connect to
 369          * changed::accel_path.
 370          * object:
 371          *  the global accel map object
 372          * accel_path:
 373          *  the path of the accelerator that changed
 374          * accel_key:
 375          *  the key value for the new accelerator
 376          * accel_mods:
 377          *  the modifier mask for the new accelerator
 378          * user_data:
 379          * user data set when the signal handler was connected.
 380          * Since 2.4
 381          */
 382         public static void unlockPath(char[] accelPath)
 383         {
 384                 // void gtk_accel_map_unlock_path (const gchar *accel_path);
 385                 gtk_accel_map_unlock_path(Str.toStringz(accelPath));
 386         }
 387 }