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