gtkD/src/gtk/TextChildAnchor.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD 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  * gtkD 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 gtkD; 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  =
  26  * outPack = gtk
  27  * outFile = TextChildAnchor
  28  * strct   = GtkTextChildAnchor
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = TextChildAnchor
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_text_child_anchor_
  40  * omit structs:
  41  * omit prefixes:
  42  * omit code:
  43  * imports:
  44  *      - glib.Str
  45  * structWrap:
  46  * module aliases:
  47  * local aliases:
  48  */
  49
  50 module gtk.TextChildAnchor;
  51
  52 version(noAssert)
  53 {
  54         version(Tango)
  55         {
  56                 import tango.io.Stdout; // use the tango loging?
  57         }
  58 }
  59
  60 private import gtkc.gtktypes;
  61
  62 private import gtkc.gtk;
  63
  64
  65 private import glib.Str;
  66
  67
  68
  69
  70 /**
  71  * Description
  72  * You may wish to begin by reading the text widget
  73  * conceptual overview which gives an overview of all the objects and data
  74  * types related to the text widget and how they work together.
  75  */
  76 public class TextChildAnchor
  77 {
  78
  79         /** the main Gtk struct */
  80         protected GtkTextChildAnchor* gtkTextChildAnchor;
  81
  82
  83         public GtkTextChildAnchor* getTextChildAnchorStruct()
  84         {
  85                 return gtkTextChildAnchor;
  86         }
  87
  88
  89         /** the main Gtk struct as a void* */
  90         protected void* getStruct()
  91         {
  92                 return cast(void*)gtkTextChildAnchor;
  93         }
  94
  95         /**
  96          * Sets our main struct and passes it to the parent class
  97          */
  98         public this (GtkTextChildAnchor* gtkTextChildAnchor)
  99         {
 100                 version(noAssert)
 101                 {
 102                         if ( gtkTextChildAnchor is null )
 103                         {
 104                                 int zero = 0;
 105                                 version(Tango)
 106                                 {
 107                                         Stdout("struct gtkTextChildAnchor is null on constructor").newline;
 108                                 }
 109                                 else
 110                                 {
 111                                         printf("struct gtkTextChildAnchor is null on constructor");
 112                                 }
 113                                 zero = zero / zero;
 114                         }
 115                 }
 116                 else
 117                 {
 118                         assert(gtkTextChildAnchor !is null, "struct gtkTextChildAnchor is null on constructor");
 119                 }
 120                 this.gtkTextChildAnchor = gtkTextChildAnchor;
 121         }
 122
 123         /**
 124          */
 125
 126         // imports for the signal processing
 127         private import gobject.Signals;
 128         private import gtkc.gdktypes;
 129         int[char[]] connectedSignals;
 130
 131         void delegate(TextChildAnchor)[] onBackspaceListeners;
 132         void addOnBackspace(void delegate(TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 133         {
 134                 if ( !("backspace" in connectedSignals) )
 135                 {
 136                         Signals.connectData(
 137                         getStruct(),
 138                         "backspace",
 139                         cast(GCallback)&callBackBackspace,
 140                         cast(void*)this,
 141                         null,
 142                         connectFlags);
 143                         connectedSignals["backspace"] = 1;
 144                 }
 145                 onBackspaceListeners ~= dlg;
 146         }
 147         extern(C) static void callBackBackspace(GtkTextView* textviewStruct, TextChildAnchor textChildAnchor)
 148         {
 149                 bool consumed = false;
 150
 151                 foreach ( void delegate(TextChildAnchor) dlg ; textChildAnchor.onBackspaceListeners )
 152                 {
 153                         dlg(textChildAnchor);
 154                 }
 155
 156                 return consumed;
 157         }
 158
 159         void delegate(TextChildAnchor)[] onCopyClipboardListeners;
 160         void addOnCopyClipboard(void delegate(TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 161         {
 162                 if ( !("copy-clipboard" in connectedSignals) )
 163                 {
 164                         Signals.connectData(
 165                         getStruct(),
 166                         "copy-clipboard",
 167                         cast(GCallback)&callBackCopyClipboard,
 168                         cast(void*)this,
 169                         null,
 170                         connectFlags);
 171                         connectedSignals["copy-clipboard"] = 1;
 172                 }
 173                 onCopyClipboardListeners ~= dlg;
 174         }
 175         extern(C) static void callBackCopyClipboard(GtkTextView* textviewStruct, TextChildAnchor textChildAnchor)
 176         {
 177                 bool consumed = false;
 178
 179                 foreach ( void delegate(TextChildAnchor) dlg ; textChildAnchor.onCopyClipboardListeners )
 180                 {
 181                         dlg(textChildAnchor);
 182                 }
 183
 184                 return consumed;
 185         }
 186
 187         void delegate(TextChildAnchor)[] onCutClipboardListeners;
 188         void addOnCutClipboard(void delegate(TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 189         {
 190                 if ( !("cut-clipboard" in connectedSignals) )
 191                 {
 192                         Signals.connectData(
 193                         getStruct(),
 194                         "cut-clipboard",
 195                         cast(GCallback)&callBackCutClipboard,
 196                         cast(void*)this,
 197                         null,
 198                         connectFlags);
 199                         connectedSignals["cut-clipboard"] = 1;
 200                 }
 201                 onCutClipboardListeners ~= dlg;
 202         }
 203         extern(C) static void callBackCutClipboard(GtkTextView* textviewStruct, TextChildAnchor textChildAnchor)
 204         {
 205                 bool consumed = false;
 206
 207                 foreach ( void delegate(TextChildAnchor) dlg ; textChildAnchor.onCutClipboardListeners )
 208                 {
 209                         dlg(textChildAnchor);
 210                 }
 211
 212                 return consumed;
 213         }
 214
 215         void delegate(GtkDeleteType, gint, TextChildAnchor)[] onDeleteFromCursorListeners;
 216         void addOnDeleteFromCursor(void delegate(GtkDeleteType, gint, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 217         {
 218                 if ( !("delete-from-cursor" in connectedSignals) )
 219                 {
 220                         Signals.connectData(
 221                         getStruct(),
 222                         "delete-from-cursor",
 223                         cast(GCallback)&callBackDeleteFromCursor,
 224                         cast(void*)this,
 225                         null,
 226                         connectFlags);
 227                         connectedSignals["delete-from-cursor"] = 1;
 228                 }
 229                 onDeleteFromCursorListeners ~= dlg;
 230         }
 231         extern(C) static void callBackDeleteFromCursor(GtkTextView* textviewStruct, GtkDeleteType arg1, gint arg2, TextChildAnchor textChildAnchor)
 232         {
 233                 bool consumed = false;
 234
 235                 foreach ( void delegate(GtkDeleteType, gint, TextChildAnchor) dlg ; textChildAnchor.onDeleteFromCursorListeners )
 236                 {
 237                         dlg(arg1, arg2, textChildAnchor);
 238                 }
 239
 240                 return consumed;
 241         }
 242
 243         void delegate(char[], TextChildAnchor)[] onInsertAtCursorListeners;
 244         void addOnInsertAtCursor(void delegate(char[], TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 245         {
 246                 if ( !("insert-at-cursor" in connectedSignals) )
 247                 {
 248                         Signals.connectData(
 249                         getStruct(),
 250                         "insert-at-cursor",
 251                         cast(GCallback)&callBackInsertAtCursor,
 252                         cast(void*)this,
 253                         null,
 254                         connectFlags);
 255                         connectedSignals["insert-at-cursor"] = 1;
 256                 }
 257                 onInsertAtCursorListeners ~= dlg;
 258         }
 259         extern(C) static void callBackInsertAtCursor(GtkTextView* textviewStruct, gchar* arg1, TextChildAnchor textChildAnchor)
 260         {
 261                 bool consumed = false;
 262
 263                 foreach ( void delegate(char[], TextChildAnchor) dlg ; textChildAnchor.onInsertAtCursorListeners )
 264                 {
 265                         dlg(Str.toString(arg1), textChildAnchor);
 266                 }
 267
 268                 return consumed;
 269         }
 270
 271         void delegate(GtkMovementStep, gint, gboolean, TextChildAnchor)[] onMoveCursorListeners;
 272         void addOnMoveCursor(void delegate(GtkMovementStep, gint, gboolean, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 273         {
 274                 if ( !("move-cursor" in connectedSignals) )
 275                 {
 276                         Signals.connectData(
 277                         getStruct(),
 278                         "move-cursor",
 279                         cast(GCallback)&callBackMoveCursor,
 280                         cast(void*)this,
 281                         null,
 282                         connectFlags);
 283                         connectedSignals["move-cursor"] = 1;
 284                 }
 285                 onMoveCursorListeners ~= dlg;
 286         }
 287         extern(C) static void callBackMoveCursor(GtkTextView* widgetStruct, GtkMovementStep step, gint count, gboolean extendSelection, TextChildAnchor textChildAnchor)
 288         {
 289                 bool consumed = false;
 290
 291                 foreach ( void delegate(GtkMovementStep, gint, gboolean, TextChildAnchor) dlg ; textChildAnchor.onMoveCursorListeners )
 292                 {
 293                         dlg(step, count, extendSelection, textChildAnchor);
 294                 }
 295
 296                 return consumed;
 297         }
 298
 299         void delegate(GtkDirectionType, TextChildAnchor)[] onMoveFocusListeners;
 300         void addOnMoveFocus(void delegate(GtkDirectionType, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 301         {
 302                 if ( !("move-focus" in connectedSignals) )
 303                 {
 304                         Signals.connectData(
 305                         getStruct(),
 306                         "move-focus",
 307                         cast(GCallback)&callBackMoveFocus,
 308                         cast(void*)this,
 309                         null,
 310                         connectFlags);
 311                         connectedSignals["move-focus"] = 1;
 312                 }
 313                 onMoveFocusListeners ~= dlg;
 314         }
 315         extern(C) static void callBackMoveFocus(GtkTextView* textviewStruct, GtkDirectionType arg1, TextChildAnchor textChildAnchor)
 316         {
 317                 bool consumed = false;
 318
 319                 foreach ( void delegate(GtkDirectionType, TextChildAnchor) dlg ; textChildAnchor.onMoveFocusListeners )
 320                 {
 321                         dlg(arg1, textChildAnchor);
 322                 }
 323
 324                 return consumed;
 325         }
 326
 327         void delegate(GtkScrollStep, gint, TextChildAnchor)[] onMoveViewportListeners;
 328         void addOnMoveViewport(void delegate(GtkScrollStep, gint, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 329         {
 330                 if ( !("move-viewport" in connectedSignals) )
 331                 {
 332                         Signals.connectData(
 333                         getStruct(),
 334                         "move-viewport",
 335                         cast(GCallback)&callBackMoveViewport,
 336                         cast(void*)this,
 337                         null,
 338                         connectFlags);
 339                         connectedSignals["move-viewport"] = 1;
 340                 }
 341                 onMoveViewportListeners ~= dlg;
 342         }
 343         extern(C) static void callBackMoveViewport(GtkTextView* textviewStruct, GtkScrollStep arg1, gint arg2, TextChildAnchor textChildAnchor)
 344         {
 345                 bool consumed = false;
 346
 347                 foreach ( void delegate(GtkScrollStep, gint, TextChildAnchor) dlg ; textChildAnchor.onMoveViewportListeners )
 348                 {
 349                         dlg(arg1, arg2, textChildAnchor);
 350                 }
 351
 352                 return consumed;
 353         }
 354
 355         void delegate(gint, gboolean, TextChildAnchor)[] onPageHorizontallyListeners;
 356         void addOnPageHorizontally(void delegate(gint, gboolean, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 357         {
 358                 if ( !("page-horizontally" in connectedSignals) )
 359                 {
 360                         Signals.connectData(
 361                         getStruct(),
 362                         "page-horizontally",
 363                         cast(GCallback)&callBackPageHorizontally,
 364                         cast(void*)this,
 365                         null,
 366                         connectFlags);
 367                         connectedSignals["page-horizontally"] = 1;
 368                 }
 369                 onPageHorizontallyListeners ~= dlg;
 370         }
 371         extern(C) static void callBackPageHorizontally(GtkTextView* textviewStruct, gint arg1, gboolean arg2, TextChildAnchor textChildAnchor)
 372         {
 373                 bool consumed = false;
 374
 375                 foreach ( void delegate(gint, gboolean, TextChildAnchor) dlg ; textChildAnchor.onPageHorizontallyListeners )
 376                 {
 377                         dlg(arg1, arg2, textChildAnchor);
 378                 }
 379
 380                 return consumed;
 381         }
 382
 383         void delegate(TextChildAnchor)[] onPasteClipboardListeners;
 384         void addOnPasteClipboard(void delegate(TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 385         {
 386                 if ( !("paste-clipboard" in connectedSignals) )
 387                 {
 388                         Signals.connectData(
 389                         getStruct(),
 390                         "paste-clipboard",
 391                         cast(GCallback)&callBackPasteClipboard,
 392                         cast(void*)this,
 393                         null,
 394                         connectFlags);
 395                         connectedSignals["paste-clipboard"] = 1;
 396                 }
 397                 onPasteClipboardListeners ~= dlg;
 398         }
 399         extern(C) static void callBackPasteClipboard(GtkTextView* textviewStruct, TextChildAnchor textChildAnchor)
 400         {
 401                 bool consumed = false;
 402
 403                 foreach ( void delegate(TextChildAnchor) dlg ; textChildAnchor.onPasteClipboardListeners )
 404                 {
 405                         dlg(textChildAnchor);
 406                 }
 407
 408                 return consumed;
 409         }
 410
 411         void delegate(GtkMenu*, TextChildAnchor)[] onPopulatePopupListeners;
 412         void addOnPopulatePopup(void delegate(GtkMenu*, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 413         {
 414                 if ( !("populate-popup" in connectedSignals) )
 415                 {
 416                         Signals.connectData(
 417                         getStruct(),
 418                         "populate-popup",
 419                         cast(GCallback)&callBackPopulatePopup,
 420                         cast(void*)this,
 421                         null,
 422                         connectFlags);
 423                         connectedSignals["populate-popup"] = 1;
 424                 }
 425                 onPopulatePopupListeners ~= dlg;
 426         }
 427         extern(C) static void callBackPopulatePopup(GtkTextView* textviewStruct, GtkMenu* arg1, TextChildAnchor textChildAnchor)
 428         {
 429                 bool consumed = false;
 430
 431                 foreach ( void delegate(GtkMenu*, TextChildAnchor) dlg ; textChildAnchor.onPopulatePopupListeners )
 432                 {
 433                         dlg(arg1, textChildAnchor);
 434                 }
 435
 436                 return consumed;
 437         }
 438
 439         void delegate(gboolean, TextChildAnchor)[] onSelectAllListeners;
 440         void addOnSelectAll(void delegate(gboolean, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 441         {
 442                 if ( !("select-all" in connectedSignals) )
 443                 {
 444                         Signals.connectData(
 445                         getStruct(),
 446                         "select-all",
 447                         cast(GCallback)&callBackSelectAll,
 448                         cast(void*)this,
 449                         null,
 450                         connectFlags);
 451                         connectedSignals["select-all"] = 1;
 452                 }
 453                 onSelectAllListeners ~= dlg;
 454         }
 455         extern(C) static void callBackSelectAll(GtkTextView* textviewStruct, gboolean arg1, TextChildAnchor textChildAnchor)
 456         {
 457                 bool consumed = false;
 458
 459                 foreach ( void delegate(gboolean, TextChildAnchor) dlg ; textChildAnchor.onSelectAllListeners )
 460                 {
 461                         dlg(arg1, textChildAnchor);
 462                 }
 463
 464                 return consumed;
 465         }
 466
 467         void delegate(TextChildAnchor)[] onSetAnchorListeners;
 468         void addOnSetAnchor(void delegate(TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 469         {
 470                 if ( !("set-anchor" in connectedSignals) )
 471                 {
 472                         Signals.connectData(
 473                         getStruct(),
 474                         "set-anchor",
 475                         cast(GCallback)&callBackSetAnchor,
 476                         cast(void*)this,
 477                         null,
 478                         connectFlags);
 479                         connectedSignals["set-anchor"] = 1;
 480                 }
 481                 onSetAnchorListeners ~= dlg;
 482         }
 483         extern(C) static void callBackSetAnchor(GtkTextView* textviewStruct, TextChildAnchor textChildAnchor)
 484         {
 485                 bool consumed = false;
 486
 487                 foreach ( void delegate(TextChildAnchor) dlg ; textChildAnchor.onSetAnchorListeners )
 488                 {
 489                         dlg(textChildAnchor);
 490                 }
 491
 492                 return consumed;
 493         }
 494
 495         void delegate(GtkAdjustment*, GtkAdjustment*, TextChildAnchor)[] onSetScrollAdjustmentsListeners;
 496         void addOnSetScrollAdjustments(void delegate(GtkAdjustment*, GtkAdjustment*, TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 497         {
 498                 if ( !("set-scroll-adjustments" in connectedSignals) )
 499                 {
 500                         Signals.connectData(
 501                         getStruct(),
 502                         "set-scroll-adjustments",
 503                         cast(GCallback)&callBackSetScrollAdjustments,
 504                         cast(void*)this,
 505                         null,
 506                         connectFlags);
 507                         connectedSignals["set-scroll-adjustments"] = 1;
 508                 }
 509                 onSetScrollAdjustmentsListeners ~= dlg;
 510         }
 511         extern(C) static void callBackSetScrollAdjustments(GtkTextView* textviewStruct, GtkAdjustment* arg1, GtkAdjustment* arg2, TextChildAnchor textChildAnchor)
 512         {
 513                 bool consumed = false;
 514
 515                 foreach ( void delegate(GtkAdjustment*, GtkAdjustment*, TextChildAnchor) dlg ; textChildAnchor.onSetScrollAdjustmentsListeners )
 516                 {
 517                         dlg(arg1, arg2, textChildAnchor);
 518                 }
 519
 520                 return consumed;
 521         }
 522
 523         void delegate(TextChildAnchor)[] onToggleOverwriteListeners;
 524         void addOnToggleOverwrite(void delegate(TextChildAnchor) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 525         {
 526                 if ( !("toggle-overwrite" in connectedSignals) )
 527                 {
 528                         Signals.connectData(
 529                         getStruct(),
 530                         "toggle-overwrite",
 531                         cast(GCallback)&callBackToggleOverwrite,
 532                         cast(void*)this,
 533                         null,
 534                         connectFlags);
 535                         connectedSignals["toggle-overwrite"] = 1;
 536                 }
 537                 onToggleOverwriteListeners ~= dlg;
 538         }
 539         extern(C) static void callBackToggleOverwrite(GtkTextView* textviewStruct, TextChildAnchor textChildAnchor)
 540         {
 541                 bool consumed = false;
 542
 543                 foreach ( void delegate(TextChildAnchor) dlg ; textChildAnchor.onToggleOverwriteListeners )
 544                 {
 545                         dlg(textChildAnchor);
 546                 }
 547
 548                 return consumed;
 549         }
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583         /**
 584          * Creates a new GtkTextChildAnchor. Usually you would then insert
 585          * it into a GtkTextBuffer with gtk_text_buffer_insert_child_anchor().
 586          * To perform the creation and insertion in one step, use the
 587          * convenience function gtk_text_buffer_create_child_anchor().
 588          * Returns:
 589          *  a new GtkTextChildAnchor
 590          */
 591         public this ()
 592         {
 593                 // GtkTextChildAnchor* gtk_text_child_anchor_new (void);
 594                 this(cast(GtkTextChildAnchor*)gtk_text_child_anchor_new() );
 595         }
 596
 597         /**
 598          * Gets a list of all widgets anchored at this child anchor.
 599          * The returned list should be freed with g_list_free().
 600          * anchor:
 601          *  a GtkTextChildAnchor
 602          * Returns:
 603          *  list of widgets anchored at anchor
 604          */
 605         public GList* getWidgets()
 606         {
 607                 // GList* gtk_text_child_anchor_get_widgets (GtkTextChildAnchor *anchor);
 608                 return gtk_text_child_anchor_get_widgets(gtkTextChildAnchor);
 609         }
 610
 611         /**
 612          * Determines whether a child anchor has been deleted from
 613          * the buffer. Keep in mind that the child anchor will be
 614          * unreferenced when removed from the buffer, so you need to
 615          * hold your own reference (with g_object_ref()) if you plan
 616          * to use this function  otherwise all deleted child anchors
 617          * will also be finalized.
 618          * anchor:
 619          *  a GtkTextChildAnchor
 620          * Returns:
 621          *  TRUE if the child anchor has been deleted from its buffer
 622          */
 623         public int getDeleted()
 624         {
 625                 // gboolean gtk_text_child_anchor_get_deleted (GtkTextChildAnchor *anchor);
 626                 return gtk_text_child_anchor_get_deleted(gtkTextChildAnchor);
 627         }
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685 }