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 // VERSION: 1.6
  46 // Action function, to be used on #AtkAction implementations as
  47 // an individual action. Unlike #CallyActionFunc, this function
  48 // uses the @user_data argument passed to cally_actor_add_action_full().
  49 // <cally_actor>: a #CallyActor
  50 // <user_data>: user data passed to the function
  51 extern (C) alias void function (Actor* cally_actor, void* user_data) nothrow ActionCallback;
  52
  53
  54 // VERSION: 1.4
  55 // Action function, to be used on #AtkAction implementations as a individual
  56 // action
  57 // <cally_actor>: a #CallyActor
  58 extern (C) alias void function (Actor* cally_actor) nothrow ActionFunc;
  59
  60
  61 // The <structname>CallyActor</structname> structure contains only private
  62 // data and should be accessed using the provided API
  63 struct Actor /* : Atk.GObjectAccessible */ /* Version 1.4 */ {
  64    mixin Atk.Action.__interface__;
  65    mixin Atk.Component.__interface__;
  66    alias parent this;
  67    alias parent super_;
  68    alias parent gobjectaccessible;
  69    Atk.GObjectAccessible parent;
  70    private ActorPrivate* priv;
  71
  72
  73    // VERSION: 1.4
  74    // Creates a new #CallyActor for the given @actor
  75    // RETURNS: the newly created #AtkObject
  76    // <actor>: a #ClutterActor
  77    static Actor* /*new*/ new_(AT0)(AT0 /*Clutter.Actor*/ actor) nothrow {
  78       return cally_actor_new(UpCast!(Clutter.Actor*)(actor));
  79    }
  80    static auto opCall(AT0)(AT0 /*Clutter.Actor*/ actor) {
  81       return cally_actor_new(UpCast!(Clutter.Actor*)(actor));
  82    }
  83
  84    // Unintrospectable method: add_action() / cally_actor_add_action()
  85    // VERSION: 1.4
  86    // Adds a new action to be accessed with the #AtkAction interface.
  87    // RETURNS: added action id, or -1 if failure
  88    // <action_name>: the action name
  89    // <action_description>: the action description
  90    // <action_keybinding>: the action keybinding
  91    // <action_func>: the callback of the action, to be executed with do_action
  92    uint add_action(AT0, AT1, AT2)(AT0 /*char*/ action_name, AT1 /*char*/ action_description, AT2 /*char*/ action_keybinding, ActionFunc action_func) nothrow {
  93       return cally_actor_add_action(&this, toCString!(char*)(action_name), toCString!(char*)(action_description), toCString!(char*)(action_keybinding), action_func);
  94    }
  95
  96    // VERSION: 1.6
  97    // Adds a new action to be accessed with the #AtkAction interface.
  98    // RETURNS: added action id, or -1 if failure
  99    // <action_name>: the action name
 100    // <action_description>: the action description
 101    // <action_keybinding>: the action keybinding
 102    // <callback>: the callback of the action
 103    // <user_data>: data to be passed to @callback
 104    // <notify>: function to be called when removing the action
 105    uint add_action_full(AT0, AT1, AT2, AT3)(AT0 /*char*/ action_name, AT1 /*char*/ action_description, AT2 /*char*/ action_keybinding, ActionCallback callback, AT3 /*void*/ user_data, GLib2.DestroyNotify notify) nothrow {
 106       return cally_actor_add_action_full(&this, toCString!(char*)(action_name), toCString!(char*)(action_description), toCString!(char*)(action_keybinding), callback, UpCast!(void*)(user_data), notify);
 107    }
 108
 109    // VERSION: 1.4
 110    // Removes a action, using the @action_id returned by cally_actor_add_action()
 111    // RETURNS: %TRUE if the operation was succesful, %FALSE otherwise
 112    // <action_id>: the action id
 113    int remove_action()(int action_id) nothrow {
 114       return cally_actor_remove_action(&this, action_id);
 115    }
 116
 117    // VERSION: 1.4
 118    // Removes an action, using the @action_name used when the action was added
 119    // with cally_actor_add_action()
 120    // RETURNS: %TRUE if the operation was succesful, %FALSE otherwise
 121    // <action_name>: the name of the action to remove
 122    int remove_action_by_name(AT0)(AT0 /*char*/ action_name) nothrow {
 123       return cally_actor_remove_action_by_name(&this, toCString!(char*)(action_name));
 124    }
 125 }
 126
 127
 128 // The <structname>CallyActorClass</structname> structure contains only
 129 // private data
 130 struct ActorClass /* Version 1.4 */ {
 131    private Atk.GObjectAccessibleClass parent_class;
 132    extern (C) void function (GObject2.Object* object, GObject2.ParamSpec* pspec) nothrow notify_clutter;
 133    extern (C) int function (Clutter.Actor* actor, void* data) nothrow focus_clutter;
 134    extern (C) int function (Clutter.Actor* container, Clutter.Actor* actor, void* data) nothrow add_actor;
 135    extern (C) int function (Clutter.Actor* container, Clutter.Actor* actor, void* data) nothrow remove_actor;
 136    private void*[32] _padding_dummy;
 137 }
 138
 139 struct ActorPrivate {
 140 }
 141
 142
 143 // The <structname>CallyClone</structname> structure contains only private
 144 // data and should be accessed using the provided API
 145 struct Clone /* : Actor */ /* Version 1.4 */ {
 146    mixin Atk.Action.__interface__;
 147    mixin Atk.Component.__interface__;
 148    alias parent this;
 149    alias parent super_;
 150    alias parent actor;
 151    Actor parent;
 152    private ClonePrivate* priv;
 153
 154
 155    // VERSION: 1.4
 156    // Creates a new #CallyClone for the given @actor. @actor must be a
 157    // #ClutterClone.
 158    // RETURNS: the newly created #AtkObject
 159    // <actor>: a #ClutterActor
 160    static Clone* /*new*/ new_(AT0)(AT0 /*Clutter.Actor*/ actor) nothrow {
 161       return cally_clone_new(UpCast!(Clutter.Actor*)(actor));
 162    }
 163    static auto opCall(AT0)(AT0 /*Clutter.Actor*/ actor) {
 164       return cally_clone_new(UpCast!(Clutter.Actor*)(actor));
 165    }
 166 }
 167
 168
 169 // The <structname>CallyCloneClass</structname> structure contains only
 170 // private data
 171 struct CloneClass /* Version 1.4 */ {
 172    private ActorClass parent_class;
 173    private void*[8] _padding_dummy;
 174 }
 175
 176 struct ClonePrivate {
 177 }
 178
 179
 180 // The <structname>CallyGroup</structname> structure contains only
 181 // private data and should be accessed using the provided API
 182 struct Group /* : Actor */ /* Version 1.4 */ {
 183    mixin Atk.Action.__interface__;
 184    mixin Atk.Component.__interface__;
 185    alias parent this;
 186    alias parent super_;
 187    alias parent actor;
 188    Actor parent;
 189    private GroupPrivate* priv;
 190
 191
 192    // VERSION: 1.4
 193    // Creates a #CallyGroup for @actor
 194    // RETURNS: the newly created #CallyGroup
 195    // <actor>: a #ClutterGroup
 196    static Group* /*new*/ new_(AT0)(AT0 /*Clutter.Actor*/ actor) nothrow {
 197       return cally_group_new(UpCast!(Clutter.Actor*)(actor));
 198    }
 199    static auto opCall(AT0)(AT0 /*Clutter.Actor*/ actor) {
 200       return cally_group_new(UpCast!(Clutter.Actor*)(actor));
 201    }
 202 }
 203
 204
 205 // The <structname>CallyGroupClass</structname> structure contains only
 206 // private data
 207 struct GroupClass /* Version 1.4 */ {
 208    private ActorClass parent_class;
 209    private void*[8] _padding_dummy;
 210 }
 211
 212 struct GroupPrivate {
 213 }
 214
 215
 216 // The <structname>CallyRectangle</structname> structure contains only private
 217 // data and should be accessed using the provided API
 218 struct Rectangle /* : Actor */ /* Version 1.4 */ {
 219    mixin Atk.Action.__interface__;
 220    mixin Atk.Component.__interface__;
 221    alias parent this;
 222    alias parent super_;
 223    alias parent actor;
 224    Actor parent;
 225    private RectanglePrivate* priv;
 226
 227
 228    // VERSION: 1.4
 229    // Creates a new #CallyRectangle for the given @actor. @actor must be
 230    // a #ClutterRectangle.
 231    // RETURNS: the newly created #AtkObject
 232    // <actor>: a #ClutterActor
 233    static Rectangle* /*new*/ new_(AT0)(AT0 /*Clutter.Actor*/ actor) nothrow {
 234       return cally_rectangle_new(UpCast!(Clutter.Actor*)(actor));
 235    }
 236    static auto opCall(AT0)(AT0 /*Clutter.Actor*/ actor) {
 237       return cally_rectangle_new(UpCast!(Clutter.Actor*)(actor));
 238    }
 239 }
 240
 241
 242 // The <structname>CallyRectangleClass</structname> structure contains
 243 // only private data
 244 struct RectangleClass /* Version 1.4 */ {
 245    private ActorClass parent_class;
 246    private void*[8] _padding_dummy;
 247 }
 248
 249 struct RectanglePrivate {
 250 }
 251
 252
 253 // The <structname>CallyRoot</structname> structure contains only private
 254 // data and should be accessed using the provided API
 255 struct Root /* : Atk.GObjectAccessible */ /* Version 1.4 */ {
 256    alias parent this;
 257    alias parent super_;
 258    alias parent gobjectaccessible;
 259    Atk.GObjectAccessible parent;
 260    private RootPrivate* priv;
 261
 262
 263    // VERSION: 1.4
 264    // Creates a new #CallyRoot object.
 265    // RETURNS: the newly created #AtkObject
 266    static Root* /*new*/ new_()() nothrow {
 267       return cally_root_new();
 268    }
 269    static auto opCall()() {
 270       return cally_root_new();
 271    }
 272 }
 273
 274
 275 // The <structname>CallyRootClass</structname> structure contains only
 276 // private data
 277 struct RootClass /* Version 1.4 */ {
 278    private Atk.GObjectAccessibleClass parent_class;
 279    private void*[16] _padding_dummy;
 280 }
 281
 282 struct RootPrivate {
 283 }
 284
 285
 286 // The <structname>CallyStage</structname> structure contains only
 287 // private data and should be accessed using the provided API
 288 struct Stage /* : Group */ /* Version 1.4 */ {
 289    mixin Atk.Action.__interface__;
 290    mixin Atk.Component.__interface__;
 291    mixin Atk.Window.__interface__;
 292    alias parent this;
 293    alias parent super_;
 294    alias parent group;
 295    Group parent;
 296    private StagePrivate* priv;
 297
 298
 299    // VERSION: 1.4
 300    // Creates a new #CallyStage for the given @actor. @actor should be a
 301    // #ClutterStage.
 302    // RETURNS: the newly created #AtkObject
 303    // <actor>: a #ClutterActor
 304    static Stage* /*new*/ new_(AT0)(AT0 /*Clutter.Actor*/ actor) nothrow {
 305       return cally_stage_new(UpCast!(Clutter.Actor*)(actor));
 306    }
 307    static auto opCall(AT0)(AT0 /*Clutter.Actor*/ actor) {
 308       return cally_stage_new(UpCast!(Clutter.Actor*)(actor));
 309    }
 310 }
 311
 312
 313 // The <structname>CallyStageClass</structname> structure contains only
 314 // private data
 315 struct StageClass /* Version 1.4 */ {
 316    private GroupClass parent_class;
 317    private void*[16] _padding_dummy;
 318 }
 319
 320 struct StagePrivate {
 321 }
 322
 323
 324 // The <structname>CallyText</structname> structure contains only private
 325 // data and should be accessed using the provided API
 326 struct Text /* : Actor */ /* Version 1.4 */ {
 327    mixin Atk.Action.__interface__;
 328    mixin Atk.Component.__interface__;
 329    mixin Atk.EditableText.__interface__;
 330    mixin Atk.Text.__interface__;
 331    alias parent this;
 332    alias parent super_;
 333    alias parent actor;
 334    Actor parent;
 335    private TextPrivate* priv;
 336
 337
 338    // VERSION: 1.4
 339    // Creates a new #CallyText for the given @actor. @actor must be a
 340    // #ClutterText.
 341    // RETURNS: the newly created #AtkObject
 342    // <actor>: a #ClutterActor
 343    static Text* /*new*/ new_(AT0)(AT0 /*Clutter.Actor*/ actor) nothrow {
 344       return cally_text_new(UpCast!(Clutter.Actor*)(actor));
 345    }
 346    static auto opCall(AT0)(AT0 /*Clutter.Actor*/ actor) {
 347       return cally_text_new(UpCast!(Clutter.Actor*)(actor));
 348    }
 349 }
 350
 351
 352 // The <structname>CallyTextClass</structname> structure contains only
 353 // private data
 354 struct TextClass /* Version 1.4 */ {
 355    private ActorClass parent_class;
 356    private void*[8] _padding_dummy;
 357 }
 358
 359 struct TextPrivate {
 360 }
 361
 362
 363 // The <structname>CallyTexture</structname> structure contains only
 364 // private data and should be accessed using the provided API
 365 struct Texture /* : Actor */ /* Version 1.4 */ {
 366    mixin Atk.Action.__interface__;
 367    mixin Atk.Component.__interface__;
 368    alias parent this;
 369    alias parent super_;
 370    alias parent actor;
 371    Actor parent;
 372    private TexturePrivate* priv;
 373
 374
 375    // VERSION: 1.4
 376    // Creates a new #CallyTexture for the given @actor. @actor must be
 377    // a #ClutterTexture.
 378    // RETURNS: the newly created #AtkObject
 379    // <actor>: a #ClutterActor
 380    static Texture* /*new*/ new_(AT0)(AT0 /*Clutter.Actor*/ actor) nothrow {
 381       return cally_texture_new(UpCast!(Clutter.Actor*)(actor));
 382    }
 383    static auto opCall(AT0)(AT0 /*Clutter.Actor*/ actor) {
 384       return cally_texture_new(UpCast!(Clutter.Actor*)(actor));
 385    }
 386 }
 387
 388
 389 // The <structname>CallyTextureClass</structname> structure contains
 390 // only private data
 391 struct TextureClass /* Version 1.4 */ {
 392    private ActorClass parent_class;
 393    private void*[8] _padding_dummy;
 394 }
 395
 396 struct TexturePrivate {
 397 }
 398
 399
 400 // The <structname>CallyUtil</structname> structure contains only
 401 // private data and should be accessed using the provided API
 402 struct Util /* : Atk.Util */ /* Version 1.4 */ {
 403    alias parent this;
 404    alias parent super_;
 405    alias parent util;
 406    Atk.Util parent;
 407    private UtilPrivate* priv;
 408 }
 409
 410
 411 // The <structname>CallyUtilClass</structname> structure contains only
 412 // private data
 413 struct UtilClass /* Version 1.4 */ {
 414    private Atk.UtilClass parent_class;
 415    private void*[8] _padding_dummy;
 416 }
 417
 418 struct UtilPrivate {
 419 }
 420
 421
 422 // VERSION: 1.4
 423 // Initializes the accessibility support.
 424 //
 425 // initialized.
 426 // RETURNS: %TRUE if accessibility support has been correctly
 427 static int accessibility_init()() nothrow {
 428    return cally_accessibility_init();
 429 }
 430
 431
 432 // VERSION: 1.4
 433 // Returns if the accessibility support using cally is enabled.
 434 //
 435 // initialized.
 436 // RETURNS: %TRUE if accessibility support has been correctly
 437 static int get_cally_initialized()() nothrow {
 438    return cally_get_cally_initialized();
 439 }
 440
 441
 442 // C prototypes:
 443
 444 extern (C) {
 445 Actor* /*new*/ cally_actor_new(Clutter.Actor* actor) nothrow;
 446 uint cally_actor_add_action(Actor* this_, char* action_name, char* action_description, char* action_keybinding, ActionFunc action_func) nothrow;
 447 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) nothrow;
 448 int cally_actor_remove_action(Actor* this_, int action_id) nothrow;
 449 int cally_actor_remove_action_by_name(Actor* this_, char* action_name) nothrow;
 450 Clone* /*new*/ cally_clone_new(Clutter.Actor* actor) nothrow;
 451 Group* /*new*/ cally_group_new(Clutter.Actor* actor) nothrow;
 452 Rectangle* /*new*/ cally_rectangle_new(Clutter.Actor* actor) nothrow;
 453 Root* /*new*/ cally_root_new() nothrow;
 454 Stage* /*new*/ cally_stage_new(Clutter.Actor* actor) nothrow;
 455 Text* /*new*/ cally_text_new(Clutter.Actor* actor) nothrow;
 456 Texture* /*new*/ cally_texture_new(Clutter.Actor* actor) nothrow;
 457 int cally_accessibility_init() nothrow;
 458 int cally_get_cally_initialized() nothrow;
 459 }