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 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gsv.SourceCompletion; 26 27 private import glib.ErrorG; 28 private import glib.GException; 29 private import glib.ListG; 30 private import gobject.ObjectG; 31 private import gobject.Signals; 32 private import gsv.SourceCompletionContext; 33 private import gsv.SourceCompletionInfo; 34 private import gsv.SourceCompletionProviderIF; 35 private import gsv.SourceView; 36 private import gsvc.gsv; 37 public import gsvc.gsvtypes; 38 private import gtk.BuildableIF; 39 private import gtk.BuildableT; 40 private import gtk.TextIter; 41 private import std.algorithm; 42 43 44 /** */ 45 public class SourceCompletion : ObjectG, BuildableIF 46 { 47 /** the main Gtk struct */ 48 protected GtkSourceCompletion* gtkSourceCompletion; 49 50 /** Get the main Gtk struct */ 51 public GtkSourceCompletion* getSourceCompletionStruct(bool transferOwnership = false) 52 { 53 if (transferOwnership) 54 ownedRef = false; 55 return gtkSourceCompletion; 56 } 57 58 /** the main Gtk struct as a void* */ 59 protected override void* getStruct() 60 { 61 return cast(void*)gtkSourceCompletion; 62 } 63 64 protected override void setStruct(GObject* obj) 65 { 66 gtkSourceCompletion = cast(GtkSourceCompletion*)obj; 67 super.setStruct(obj); 68 } 69 70 /** 71 * Sets our main struct and passes it to the parent class. 72 */ 73 public this (GtkSourceCompletion* gtkSourceCompletion, bool ownedRef = false) 74 { 75 this.gtkSourceCompletion = gtkSourceCompletion; 76 super(cast(GObject*)gtkSourceCompletion, ownedRef); 77 } 78 79 // add the Buildable capabilities 80 mixin BuildableT!(GtkSourceCompletion); 81 82 83 /** */ 84 public static GType getType() 85 { 86 return gtk_source_completion_get_type(); 87 } 88 89 /** 90 * Add a new #GtkSourceCompletionProvider to the completion object. This will 91 * add a reference @provider, so make sure to unref your own copy when you 92 * no longer need it. 93 * 94 * Params: 95 * provider = a #GtkSourceCompletionProvider. 96 * 97 * Returns: %TRUE if @provider was successfully added, otherwise if @error 98 * is provided, it will be set with the error and %FALSE is returned. 99 * 100 * Throws: GException on failure. 101 */ 102 public bool addProvider(SourceCompletionProviderIF provider) 103 { 104 GError* err = null; 105 106 auto p = gtk_source_completion_add_provider(gtkSourceCompletion, (provider is null) ? null : provider.getSourceCompletionProviderStruct(), &err) != 0; 107 108 if (err !is null) 109 { 110 throw new GException( new ErrorG(err) ); 111 } 112 113 return p; 114 } 115 116 /** 117 * Block interactive completion. This can be used to disable interactive 118 * completion when inserting or deleting text from the buffer associated with 119 * the completion. Use gtk_source_completion_unblock_interactive() to enable 120 * interactive completion again. 121 * 122 * This function may be called multiple times. It will continue to block 123 * interactive completion until gtk_source_completion_unblock_interactive() 124 * has been called the same number of times. 125 */ 126 public void blockInteractive() 127 { 128 gtk_source_completion_block_interactive(gtkSourceCompletion); 129 } 130 131 /** 132 * Create a new #GtkSourceCompletionContext for @completion. The position where 133 * the completion occurs can be specified by @position. If @position is %NULL, 134 * the current cursor position will be used. 135 * 136 * Params: 137 * position = a #GtkTextIter, or %NULL. 138 * 139 * Returns: a new #GtkSourceCompletionContext. 140 * The reference being returned is a 'floating' reference, 141 * so if you invoke gtk_source_completion_show() with this context 142 * you don't need to unref it. 143 */ 144 public SourceCompletionContext createContext(TextIter position) 145 { 146 auto p = gtk_source_completion_create_context(gtkSourceCompletion, (position is null) ? null : position.getTextIterStruct()); 147 148 if(p is null) 149 { 150 return null; 151 } 152 153 return ObjectG.getDObject!(SourceCompletionContext)(cast(GtkSourceCompletionContext*) p); 154 } 155 156 /** 157 * The info widget is the window where the completion displays optional extra 158 * information of the proposal. 159 * 160 * Returns: The #GtkSourceCompletionInfo window 161 * associated with @completion. 162 */ 163 public SourceCompletionInfo getInfoWindow() 164 { 165 auto p = gtk_source_completion_get_info_window(gtkSourceCompletion); 166 167 if(p is null) 168 { 169 return null; 170 } 171 172 return ObjectG.getDObject!(SourceCompletionInfo)(cast(GtkSourceCompletionInfo*) p); 173 } 174 175 /** 176 * Get list of providers registered on @completion. The returned list is owned 177 * by the completion and should not be freed. 178 * 179 * Returns: list of #GtkSourceCompletionProvider. 180 */ 181 public ListG getProviders() 182 { 183 auto p = gtk_source_completion_get_providers(gtkSourceCompletion); 184 185 if(p is null) 186 { 187 return null; 188 } 189 190 return new ListG(cast(GList*) p); 191 } 192 193 /** 194 * The #GtkSourceView associated with @completion, or %NULL if the view has been 195 * destroyed. 196 * 197 * Returns: The #GtkSourceView associated with 198 * @completion, or %NULL. 199 */ 200 public SourceView getView() 201 { 202 auto p = gtk_source_completion_get_view(gtkSourceCompletion); 203 204 if(p is null) 205 { 206 return null; 207 } 208 209 return ObjectG.getDObject!(SourceView)(cast(GtkSourceView*) p); 210 } 211 212 /** 213 * Hides the completion if it is active (visible). 214 */ 215 public void hide() 216 { 217 gtk_source_completion_hide(gtkSourceCompletion); 218 } 219 220 /** 221 * Move the completion window to a specific iter. 222 * 223 * Deprecated: Use gtk_source_completion_provider_get_start_iter() instead. 224 * 225 * Params: 226 * iter = a #GtkTextIter. 227 */ 228 public void moveWindow(TextIter iter) 229 { 230 gtk_source_completion_move_window(gtkSourceCompletion, (iter is null) ? null : iter.getTextIterStruct()); 231 } 232 233 /** 234 * Remove @provider from the completion. 235 * 236 * Params: 237 * provider = a #GtkSourceCompletionProvider. 238 * 239 * Returns: %TRUE if @provider was successfully removed, otherwise if @error 240 * is provided, it will be set with the error and %FALSE is returned. 241 * 242 * Throws: GException on failure. 243 */ 244 public bool removeProvider(SourceCompletionProviderIF provider) 245 { 246 GError* err = null; 247 248 auto p = gtk_source_completion_remove_provider(gtkSourceCompletion, (provider is null) ? null : provider.getSourceCompletionProviderStruct(), &err) != 0; 249 250 if (err !is null) 251 { 252 throw new GException( new ErrorG(err) ); 253 } 254 255 return p; 256 } 257 258 /** 259 * Starts a new completion with the specified #GtkSourceCompletionContext and 260 * a list of potential candidate providers for completion. 261 * 262 * It can be convenient for showing a completion on-the-fly, without the need to 263 * add or remove providers to the #GtkSourceCompletion. 264 * 265 * Another solution is to add providers with 266 * gtk_source_completion_add_provider(), and implement 267 * gtk_source_completion_provider_match() for each provider. 268 * 269 * Params: 270 * providers = a list of #GtkSourceCompletionProvider, or %NULL. 271 * context = The #GtkSourceCompletionContext 272 * with which to start the completion. 273 * 274 * Returns: %TRUE if it was possible to the show completion window. 275 */ 276 public bool show(ListG providers, SourceCompletionContext context) 277 { 278 return gtk_source_completion_show(gtkSourceCompletion, (providers is null) ? null : providers.getListGStruct(), (context is null) ? null : context.getSourceCompletionContextStruct()) != 0; 279 } 280 281 /** 282 * Unblock interactive completion. This can be used after using 283 * gtk_source_completion_block_interactive() to enable interactive completion 284 * again. 285 */ 286 public void unblockInteractive() 287 { 288 gtk_source_completion_unblock_interactive(gtkSourceCompletion); 289 } 290 291 protected class OnActivateProposalDelegateWrapper 292 { 293 static OnActivateProposalDelegateWrapper[] listeners; 294 void delegate(SourceCompletion) dlg; 295 gulong handlerId; 296 297 this(void delegate(SourceCompletion) dlg) 298 { 299 this.dlg = dlg; 300 this.listeners ~= this; 301 } 302 303 void remove(OnActivateProposalDelegateWrapper source) 304 { 305 foreach(index, wrapper; listeners) 306 { 307 if (wrapper.handlerId == source.handlerId) 308 { 309 listeners[index] = null; 310 listeners = std.algorithm.remove(listeners, index); 311 break; 312 } 313 } 314 } 315 } 316 317 /** 318 * The #GtkSourceCompletion::activate-proposal signal is a 319 * keybinding signal which gets emitted when the user initiates 320 * a proposal activation. 321 * 322 * Applications should not connect to it, but may emit it with 323 * g_signal_emit_by_name() if they need to control the proposal 324 * activation programmatically. 325 */ 326 gulong addOnActivateProposal(void delegate(SourceCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 327 { 328 auto wrapper = new OnActivateProposalDelegateWrapper(dlg); 329 wrapper.handlerId = Signals.connectData( 330 this, 331 "activate-proposal", 332 cast(GCallback)&callBackActivateProposal, 333 cast(void*)wrapper, 334 cast(GClosureNotify)&callBackActivateProposalDestroy, 335 connectFlags); 336 return wrapper.handlerId; 337 } 338 339 extern(C) static void callBackActivateProposal(GtkSourceCompletion* sourcecompletionStruct, OnActivateProposalDelegateWrapper wrapper) 340 { 341 wrapper.dlg(wrapper.outer); 342 } 343 344 extern(C) static void callBackActivateProposalDestroy(OnActivateProposalDelegateWrapper wrapper, GClosure* closure) 345 { 346 wrapper.remove(wrapper); 347 } 348 349 protected class OnHideDelegateWrapper 350 { 351 static OnHideDelegateWrapper[] listeners; 352 void delegate(SourceCompletion) dlg; 353 gulong handlerId; 354 355 this(void delegate(SourceCompletion) dlg) 356 { 357 this.dlg = dlg; 358 this.listeners ~= this; 359 } 360 361 void remove(OnHideDelegateWrapper source) 362 { 363 foreach(index, wrapper; listeners) 364 { 365 if (wrapper.handlerId == source.handlerId) 366 { 367 listeners[index] = null; 368 listeners = std.algorithm.remove(listeners, index); 369 break; 370 } 371 } 372 } 373 } 374 375 /** 376 * Emitted when the completion window is hidden. The default handler 377 * will actually hide the window. 378 */ 379 gulong addOnHide(void delegate(SourceCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 380 { 381 auto wrapper = new OnHideDelegateWrapper(dlg); 382 wrapper.handlerId = Signals.connectData( 383 this, 384 "hide", 385 cast(GCallback)&callBackHide, 386 cast(void*)wrapper, 387 cast(GClosureNotify)&callBackHideDestroy, 388 connectFlags); 389 return wrapper.handlerId; 390 } 391 392 extern(C) static void callBackHide(GtkSourceCompletion* sourcecompletionStruct, OnHideDelegateWrapper wrapper) 393 { 394 wrapper.dlg(wrapper.outer); 395 } 396 397 extern(C) static void callBackHideDestroy(OnHideDelegateWrapper wrapper, GClosure* closure) 398 { 399 wrapper.remove(wrapper); 400 } 401 402 protected class OnMoveCursorDelegateWrapper 403 { 404 static OnMoveCursorDelegateWrapper[] listeners; 405 void delegate(GtkScrollStep, int, SourceCompletion) dlg; 406 gulong handlerId; 407 408 this(void delegate(GtkScrollStep, int, SourceCompletion) dlg) 409 { 410 this.dlg = dlg; 411 this.listeners ~= this; 412 } 413 414 void remove(OnMoveCursorDelegateWrapper source) 415 { 416 foreach(index, wrapper; listeners) 417 { 418 if (wrapper.handlerId == source.handlerId) 419 { 420 listeners[index] = null; 421 listeners = std.algorithm.remove(listeners, index); 422 break; 423 } 424 } 425 } 426 } 427 428 /** 429 * The #GtkSourceCompletion::move-cursor signal is a keybinding 430 * signal which gets emitted when the user initiates a cursor 431 * movement. 432 * 433 * The <keycap>Up</keycap>, <keycap>Down</keycap>, 434 * <keycap>PageUp</keycap>, <keycap>PageDown</keycap>, 435 * <keycap>Home</keycap> and <keycap>End</keycap> keys are bound to the 436 * normal behavior expected by those keys. 437 * 438 * When @step is equal to %GTK_SCROLL_PAGES, the page size is defined by 439 * the #GtkSourceCompletion:proposal-page-size property. It is used for 440 * the <keycap>PageDown</keycap> and <keycap>PageUp</keycap> keys. 441 * 442 * Applications should not connect to it, but may emit it with 443 * g_signal_emit_by_name() if they need to control the cursor 444 * programmatically. 445 * 446 * Params: 447 * step = The #GtkScrollStep by which to move the cursor 448 * num = The amount of steps to move the cursor 449 */ 450 gulong addOnMoveCursor(void delegate(GtkScrollStep, int, SourceCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 451 { 452 auto wrapper = new OnMoveCursorDelegateWrapper(dlg); 453 wrapper.handlerId = Signals.connectData( 454 this, 455 "move-cursor", 456 cast(GCallback)&callBackMoveCursor, 457 cast(void*)wrapper, 458 cast(GClosureNotify)&callBackMoveCursorDestroy, 459 connectFlags); 460 return wrapper.handlerId; 461 } 462 463 extern(C) static void callBackMoveCursor(GtkSourceCompletion* sourcecompletionStruct, GtkScrollStep step, int num, OnMoveCursorDelegateWrapper wrapper) 464 { 465 wrapper.dlg(step, num, wrapper.outer); 466 } 467 468 extern(C) static void callBackMoveCursorDestroy(OnMoveCursorDelegateWrapper wrapper, GClosure* closure) 469 { 470 wrapper.remove(wrapper); 471 } 472 473 protected class OnMovePageDelegateWrapper 474 { 475 static OnMovePageDelegateWrapper[] listeners; 476 void delegate(GtkScrollStep, int, SourceCompletion) dlg; 477 gulong handlerId; 478 479 this(void delegate(GtkScrollStep, int, SourceCompletion) dlg) 480 { 481 this.dlg = dlg; 482 this.listeners ~= this; 483 } 484 485 void remove(OnMovePageDelegateWrapper source) 486 { 487 foreach(index, wrapper; listeners) 488 { 489 if (wrapper.handlerId == source.handlerId) 490 { 491 listeners[index] = null; 492 listeners = std.algorithm.remove(listeners, index); 493 break; 494 } 495 } 496 } 497 } 498 499 /** 500 * The #GtkSourceCompletion::move-page signal is a keybinding 501 * signal which gets emitted when the user initiates a page 502 * movement (i.e. switches between provider pages). 503 * 504 * <keycombo><keycap>Control</keycap><keycap>Left</keycap></keycombo> 505 * is for going to the previous provider. 506 * <keycombo><keycap>Control</keycap><keycap>Right</keycap></keycombo> 507 * is for going to the next provider. 508 * <keycombo><keycap>Control</keycap><keycap>Home</keycap></keycombo> 509 * is for displaying all the providers. 510 * <keycombo><keycap>Control</keycap><keycap>End</keycap></keycombo> 511 * is for going to the last provider. 512 * 513 * When @step is equal to #GTK_SCROLL_PAGES, the page size is defined by 514 * the #GtkSourceCompletion:provider-page-size property. 515 * 516 * Applications should not connect to it, but may emit it with 517 * g_signal_emit_by_name() if they need to control the page selection 518 * programmatically. 519 * 520 * Params: 521 * step = The #GtkScrollStep by which to move the page 522 * num = The amount of steps to move the page 523 */ 524 gulong addOnMovePage(void delegate(GtkScrollStep, int, SourceCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 525 { 526 auto wrapper = new OnMovePageDelegateWrapper(dlg); 527 wrapper.handlerId = Signals.connectData( 528 this, 529 "move-page", 530 cast(GCallback)&callBackMovePage, 531 cast(void*)wrapper, 532 cast(GClosureNotify)&callBackMovePageDestroy, 533 connectFlags); 534 return wrapper.handlerId; 535 } 536 537 extern(C) static void callBackMovePage(GtkSourceCompletion* sourcecompletionStruct, GtkScrollStep step, int num, OnMovePageDelegateWrapper wrapper) 538 { 539 wrapper.dlg(step, num, wrapper.outer); 540 } 541 542 extern(C) static void callBackMovePageDestroy(OnMovePageDelegateWrapper wrapper, GClosure* closure) 543 { 544 wrapper.remove(wrapper); 545 } 546 547 protected class OnPopulateContextDelegateWrapper 548 { 549 static OnPopulateContextDelegateWrapper[] listeners; 550 void delegate(SourceCompletionContext, SourceCompletion) dlg; 551 gulong handlerId; 552 553 this(void delegate(SourceCompletionContext, SourceCompletion) dlg) 554 { 555 this.dlg = dlg; 556 this.listeners ~= this; 557 } 558 559 void remove(OnPopulateContextDelegateWrapper source) 560 { 561 foreach(index, wrapper; listeners) 562 { 563 if (wrapper.handlerId == source.handlerId) 564 { 565 listeners[index] = null; 566 listeners = std.algorithm.remove(listeners, index); 567 break; 568 } 569 } 570 } 571 } 572 573 /** 574 * Emitted just before starting to populate the completion with providers. 575 * You can use this signal to add additional attributes in the context. 576 * 577 * Params: 578 * context = The #GtkSourceCompletionContext for the current completion 579 */ 580 gulong addOnPopulateContext(void delegate(SourceCompletionContext, SourceCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 581 { 582 auto wrapper = new OnPopulateContextDelegateWrapper(dlg); 583 wrapper.handlerId = Signals.connectData( 584 this, 585 "populate-context", 586 cast(GCallback)&callBackPopulateContext, 587 cast(void*)wrapper, 588 cast(GClosureNotify)&callBackPopulateContextDestroy, 589 connectFlags); 590 return wrapper.handlerId; 591 } 592 593 extern(C) static void callBackPopulateContext(GtkSourceCompletion* sourcecompletionStruct, GtkSourceCompletionContext* context, OnPopulateContextDelegateWrapper wrapper) 594 { 595 wrapper.dlg(ObjectG.getDObject!(SourceCompletionContext)(context), wrapper.outer); 596 } 597 598 extern(C) static void callBackPopulateContextDestroy(OnPopulateContextDelegateWrapper wrapper, GClosure* closure) 599 { 600 wrapper.remove(wrapper); 601 } 602 603 protected class OnShowDelegateWrapper 604 { 605 static OnShowDelegateWrapper[] listeners; 606 void delegate(SourceCompletion) dlg; 607 gulong handlerId; 608 609 this(void delegate(SourceCompletion) dlg) 610 { 611 this.dlg = dlg; 612 this.listeners ~= this; 613 } 614 615 void remove(OnShowDelegateWrapper source) 616 { 617 foreach(index, wrapper; listeners) 618 { 619 if (wrapper.handlerId == source.handlerId) 620 { 621 listeners[index] = null; 622 listeners = std.algorithm.remove(listeners, index); 623 break; 624 } 625 } 626 } 627 } 628 629 /** 630 * Emitted when the completion window is shown. The default handler 631 * will actually show the window. 632 */ 633 gulong addOnShow(void delegate(SourceCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 634 { 635 auto wrapper = new OnShowDelegateWrapper(dlg); 636 wrapper.handlerId = Signals.connectData( 637 this, 638 "show", 639 cast(GCallback)&callBackShow, 640 cast(void*)wrapper, 641 cast(GClosureNotify)&callBackShowDestroy, 642 connectFlags); 643 return wrapper.handlerId; 644 } 645 646 extern(C) static void callBackShow(GtkSourceCompletion* sourcecompletionStruct, OnShowDelegateWrapper wrapper) 647 { 648 wrapper.dlg(wrapper.outer); 649 } 650 651 extern(C) static void callBackShowDestroy(OnShowDelegateWrapper wrapper, GClosure* closure) 652 { 653 wrapper.remove(wrapper); 654 } 655 }