gtk2/cally.d

   1 // *** DO NOT EDIT ***
   2 // Automatically generated from "/usr/share/gir-1.0/Cally-1.0.gir"
   3
   4 module Cally;
   5 public import gtk2.atk;
   6 alias gtk2.atk Atk;
   7 public import gtk2.clutter;
   8 alias gtk2.clutter Clutter;
   9 public import gtk2.cogl;
  10 alias gtk2.cogl Cogl;
  11 public import gtk2.coglpango;
  12 alias gtk2.coglpango CoglPango;
  13 public import gtk2.gl;
  14 alias gtk2.gl GL;
  15 public import gtk2.glib2;
  16 alias gtk2.glib2 GLib2;
  17 public import gtk2.gobject2;
  18 alias gtk2.gobject2 GObject2;
  19 public import gtk2.gio2;
  20 alias gtk2.gio2 Gio2;
  21 public import gtk2.json;
  22 alias gtk2.json Json;
  23 public import gtk2.pango;
  24 alias gtk2.pango Pango;
  25 public import gtk2.pangocairo;
  26 alias gtk2.pangocairo PangoCairo;
  27 public import gtk2.pangoft2;
  28 alias gtk2.pangoft2 PangoFT2;
  29 public import gtk2.cairo;
  30 alias gtk2.cairo cairo;
  31 public import gtk2.fontconfig2;
  32 alias gtk2.fontconfig2 fontconfig2;
  33 public import gtk2.freetype2;
  34 alias gtk2.freetype2 freetype2;
  35
  36 // package: "cally-1.0";
  37 // C header: "cally/cally.h";
  38
  39 // c:symbol-prefixes: ["cally"]
  40 // c:identifier-prefixes: ["Cally"]
  41
  42 // module Cally;
  43
  44
  45 // Action function, to be used on #AtkAction implementations as
  46 // an individual action. Unlike #CallyActionFunc, this function
  47 // uses the @user_data argument passed to cally_actor_add_action_full().
  48 // <cally_actor>: a #CallyActor
  49 // <user_data>: user data passed to the function
  50 extern (C) alias void function (Actor* cally_actor, void* user_data) ActionCallback;
  51
  52
  53 // Action function, to be used on #AtkAction implementations as a individual
  54 // action
  55 // <cally_actor>: a #CallyActor
  56 extern (C) alias void function (Actor* cally_actor) ActionFunc;
  57
  58
  59 // The <structname>CallyActor</structname> structure contains only private
  60 // data and should be accessed using the provided API
  61 struct Actor /* : Atk.GObjectAccessible */ /* Version 1.4 */ {
  62    alias parent this;
  63    alias parent super_;
  64    alias parent gobjectaccessible;
  65    Atk.GObjectAccessible parent;
  66    private ActorPrivate* priv;
  67
  68
  69    // Creates a new #CallyActor for the given @actor
  70    // RETURNS: the newly created #AtkObject
  71    // <actor>: a #ClutterActor
  72    static Actor* /*new*/ new_(Clutter.Actor* actor) {
  73       return cally_actor_new(actor);
  74    }
  75
  76    // Unintrospectable method: add_action() / cally_actor_add_action()
  77    // Adds a new action to be accessed with the #AtkAction interface.
  78    // RETURNS: added action id, or -1 if failure
  79    // <action_name>: the action name
  80    // <action_description>: the action description
  81    // <action_keybinding>: the action keybinding
  82    // <action_func>: the callback of the action, to be executed with do_action
  83    uint add_action(char* action_name, char* action_description, char* action_keybinding, ActionFunc action_func) {
  84       return cally_actor_add_action(&this, action_name, action_description, action_keybinding, action_func);
  85    }
  86
  87    // Adds a new action to be accessed with the #AtkAction interface.
  88    // RETURNS: added action id, or -1 if failure
  89    // <action_name>: the action name
  90    // <action_description>: the action description
  91    // <action_keybinding>: the action keybinding
  92    // <callback>: the callback of the action
  93    // <user_data>: data to be passed to @callback
  94    // <notify>: function to be called when removing the action
  95    uint add_action_full(char* action_name, char* action_description, char* action_keybinding, ActionCallback callback, void* user_data, GLib2.DestroyNotify notify) {
  96       return cally_actor_add_action_full(&this, action_name, action_description, action_keybinding, callback, user_data, notify);
  97    }
  98
  99    // Removes a action, using the @action_id returned by cally_actor_add_action()
 100    // RETURNS: %TRUE if the operation was succesful, %FALSE otherwise
 101    // <action_id>: the action id
 102    int remove_action(int action_id) {
 103       return cally_actor_remove_action(&this, action_id);
 104    }
 105
 106    // Removes an action, using the @action_name used when the action was added
 107    // with cally_actor_add_action()
 108    // RETURNS: %TRUE if the operation was succesful, %FALSE otherwise
 109    // <action_name>: the name of the action to remove
 110    int remove_action_by_name(char* action_name) {
 111       return cally_actor_remove_action_by_name(&this, action_name);
 112    }
 113 }
 114
 115
 116 // The <structname>CallyActorClass</structname> structure contains only
 117 // private data
 118 struct ActorClass /* Version 1.4 */ {
 119    private Atk.GObjectAccessibleClass parent_class;
 120    extern (C) void function (GObject2.Object* object, GObject2.ParamSpec* pspec) notify_clutter;
 121    extern (C) int function (Clutter.Actor* actor, void* data) focus_clutter;
 122    extern (C) int function (Clutter.Actor* container, Clutter.Actor* actor, void* data) add_actor;
 123    extern (C) int function (Clutter.Actor* container, Clutter.Actor* actor, void* data) remove_actor;
 124    private void*[32] _padding_dummy;
 125 }
 126
 127 struct ActorPrivate {
 128 }
 129
 130
 131 // The <structname>CallyClone</structname> structure contains only private
 132 // data and should be accessed using the provided API
 133 struct Clone /* : Actor */ /* Version 1.4 */ {
 134    alias parent this;
 135    alias parent super_;
 136    alias parent actor;
 137    Actor parent;
 138    private ClonePrivate* priv;
 139
 140
 141    // Creates a new #CallyClone for the given @actor. @actor must be a
 142    // #ClutterClone.
 143    // RETURNS: the newly created #AtkObject
 144    // <actor>: a #ClutterActor
 145    static Clone* /*new*/ new_(Clutter.Actor* actor) {
 146       return cally_clone_new(actor);
 147    }
 148 }
 149
 150
 151 // The <structname>CallyCloneClass</structname> structure contains only
 152 // private data
 153 struct CloneClass /* Version 1.4 */ {
 154    private ActorClass parent_class;
 155    private void*[8] _padding_dummy;
 156 }
 157
 158 struct ClonePrivate {
 159 }
 160
 161
 162 // The <structname>CallyGroup</structname> structure contains only
 163 // private data and should be accessed using the provided API
 164 struct Group /* : Actor */ /* Version 1.4 */ {
 165    alias parent this;
 166    alias parent super_;
 167    alias parent actor;
 168    Actor parent;
 169    private GroupPrivate* priv;
 170
 171
 172    // Creates a #CallyGroup for @actor
 173    // RETURNS: the newly created #CallyGroup
 174    // <actor>: a #ClutterGroup
 175    static Group* /*new*/ new_(Clutter.Actor* actor) {
 176       return cally_group_new(actor);
 177    }
 178 }
 179
 180
 181 // The <structname>CallyGroupClass</structname> structure contains only
 182 // private data
 183 struct GroupClass /* Version 1.4 */ {
 184    private ActorClass parent_class;
 185    private void*[8] _padding_dummy;
 186 }
 187
 188 struct GroupPrivate {
 189 }
 190
 191
 192 // The <structname>CallyRectangle</structname> structure contains only private
 193 // data and should be accessed using the provided API
 194 struct Rectangle /* : Actor */ /* Version 1.4 */ {
 195    alias parent this;
 196    alias parent super_;
 197    alias parent actor;
 198    Actor parent;
 199    private RectanglePrivate* priv;
 200
 201
 202    // Creates a new #CallyRectangle for the given @actor. @actor must be
 203    // a #ClutterRectangle.
 204    // RETURNS: the newly created #AtkObject
 205    // <actor>: a #ClutterActor
 206    static Rectangle* /*new*/ new_(Clutter.Actor* actor) {
 207       return cally_rectangle_new(actor);
 208    }
 209 }
 210
 211
 212 // The <structname>CallyRectangleClass</structname> structure contains
 213 // only private data
 214 struct RectangleClass /* Version 1.4 */ {
 215    private ActorClass parent_class;
 216    private void*[8] _padding_dummy;
 217 }
 218
 219 struct RectanglePrivate {
 220 }
 221
 222
 223 // The <structname>CallyRoot</structname> structure contains only private
 224 // data and should be accessed using the provided API
 225 struct Root /* : Atk.GObjectAccessible */ /* Version 1.4 */ {
 226    alias parent this;
 227    alias parent super_;
 228    alias parent gobjectaccessible;
 229    Atk.GObjectAccessible parent;
 230    private RootPrivate* priv;
 231
 232
 233    // Creates a new #CallyRoot object.
 234    // RETURNS: the newly created #AtkObject
 235    static Root* /*new*/ new_() {
 236       return cally_root_new();
 237    }
 238 }
 239
 240
 241 // The <structname>CallyRootClass</structname> structure contains only
 242 // private data
 243 struct RootClass /* Version 1.4 */ {
 244    private Atk.GObjectAccessibleClass parent_class;
 245    private void*[16] _padding_dummy;
 246 }
 247
 248 struct RootPrivate {
 249 }
 250
 251
 252 // The <structname>CallyStage</structname> structure contains only
 253 // private data and should be accessed using the provided API
 254 struct Stage /* : Group */ /* Version 1.4 */ {
 255    alias parent this;
 256    alias parent super_;
 257    alias parent group;
 258    Group parent;
 259    private StagePrivate* priv;
 260
 261
 262    // Creates a new #CallyStage for the given @actor. @actor should be a
 263    // #ClutterStage.
 264    // RETURNS: the newly created #AtkObject
 265    // <actor>: a #ClutterActor
 266    static Stage* /*new*/ new_(Clutter.Actor* actor) {
 267       return cally_stage_new(actor);
 268    }
 269 }
 270
 271
 272 // The <structname>CallyStageClass</structname> structure contains only
 273 // private data
 274 struct StageClass /* Version 1.4 */ {
 275    private GroupClass parent_class;
 276    private void*[16] _padding_dummy;
 277 }
 278
 279 struct StagePrivate {
 280 }
 281
 282
 283 // The <structname>CallyText</structname> structure contains only private
 284 // data and should be accessed using the provided API
 285 struct Text /* : Actor */ /* Version 1.4 */ {
 286    alias parent this;
 287    alias parent super_;
 288    alias parent actor;
 289    Actor parent;
 290    private TextPrivate* priv;
 291
 292
 293    // Creates a new #CallyText for the given @actor. @actor must be a
 294    // #ClutterText.
 295    // RETURNS: the newly created #AtkObject
 296    // <actor>: a #ClutterActor
 297    static Text* /*new*/ new_(Clutter.Actor* actor) {
 298       return cally_text_new(actor);
 299    }
 300 }
 301
 302
 303 // The <structname>CallyTextClass</structname> structure contains only
 304 // private data
 305 struct TextClass /* Version 1.4 */ {
 306    private ActorClass parent_class;
 307    private void*[8] _padding_dummy;
 308 }
 309
 310 struct TextPrivate {
 311 }
 312
 313
 314 // The <structname>CallyTexture</structname> structure contains only
 315 // private data and should be accessed using the provided API
 316 struct Texture /* : Actor */ /* Version 1.4 */ {
 317    alias parent this;
 318    alias parent super_;
 319    alias parent actor;
 320    Actor parent;
 321    private TexturePrivate* priv;
 322
 323
 324    // Creates a new #CallyTexture for the given @actor. @actor must be
 325    // a #ClutterTexture.
 326    // RETURNS: the newly created #AtkObject
 327    // <actor>: a #ClutterActor
 328    static Texture* /*new*/ new_(Clutter.Actor* actor) {
 329       return cally_texture_new(actor);
 330    }
 331 }
 332
 333
 334 // The <structname>CallyTextureClass</structname> structure contains
 335 // only private data
 336 struct TextureClass /* Version 1.4 */ {
 337    private ActorClass parent_class;
 338    private void*[8] _padding_dummy;
 339 }
 340
 341 struct TexturePrivate {
 342 }
 343
 344
 345 // The <structname>CallyUtil</structname> structure contains only
 346 // private data and should be accessed using the provided API
 347 struct Util /* : Atk.Util */ /* Version 1.4 */ {
 348    alias parent this;
 349    alias parent super_;
 350    alias parent util;
 351    Atk.Util parent;
 352    private UtilPrivate* priv;
 353 }
 354
 355
 356 // The <structname>CallyUtilClass</structname> structure contains only
 357 // private data
 358 struct UtilClass /* Version 1.4 */ {
 359    private Atk.UtilClass parent_class;
 360    private void*[8] _padding_dummy;
 361 }
 362
 363 struct UtilPrivate {
 364 }
 365
 366
 367 // Initializes the accessibility support.
 368 //
 369 // initialized.
 370 // RETURNS: %TRUE if accessibility support has been correctly
 371 static int accessibility_init() {
 372    return cally_accessibility_init();
 373 }
 374
 375
 376 // Returns if the accessibility support using cally is enabled.
 377 //
 378 // initialized.
 379 // RETURNS: %TRUE if accessibility support has been correctly
 380 static int get_cally_initialized() {
 381    return cally_get_cally_initialized();
 382 }
 383
 384
 385 // C prototypes:
 386
 387 extern (C) {
 388 Actor* /*new*/ cally_actor_new(Clutter.Actor* actor);
 389 uint cally_actor_add_action(Actor* this_, char* action_name, char* action_description, char* action_keybinding, ActionFunc action_func);
 390 uint cally_actor_add_action_full(Actor* this_, char* action_name, char* action_description, char* action_keybinding, ActionCallback callback, void* user_data, GLib2.DestroyNotify notify);
 391 int cally_actor_remove_action(Actor* this_, int action_id);
 392 int cally_actor_remove_action_by_name(Actor* this_, char* action_name);
 393 Clone* /*new*/ cally_clone_new(Clutter.Actor* actor);
 394 Group* /*new*/ cally_group_new(Clutter.Actor* actor);
 395 Rectangle* /*new*/ cally_rectangle_new(Clutter.Actor* actor);
 396 Root* /*new*/ cally_root_new();
 397 Stage* /*new*/ cally_stage_new(Clutter.Actor* actor);
 398 Text* /*new*/ cally_text_new(Clutter.Actor* actor);
 399 Texture* /*new*/ cally_texture_new(Clutter.Actor* actor);
 400 int cally_accessibility_init();
 401 int cally_get_cally_initialized();
 402 }