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 gtk.IconView; 26 27 private import cairo.Surface; 28 private import glib.ConstructionException; 29 private import glib.ListG; 30 private import gobject.ObjectG; 31 private import gobject.Signals; 32 private import gtk.CellArea; 33 private import gtk.CellLayoutIF; 34 private import gtk.CellLayoutT; 35 private import gtk.CellRenderer; 36 private import gtk.Container; 37 private import gtk.ScrollableIF; 38 private import gtk.ScrollableT; 39 private import gtk.TargetEntry; 40 private import gtk.Tooltip; 41 private import gtk.TreeIter; 42 private import gtk.TreeModel; 43 private import gtk.TreeModelIF; 44 private import gtk.TreePath; 45 private import gtk.Widget; 46 public import gtkc.gdktypes; 47 private import gtkc.gtk; 48 public import gtkc.gtktypes; 49 50 51 /** 52 * #GtkIconView provides an alternative view on a #GtkTreeModel. 53 * It displays the model as a grid of icons with labels. Like 54 * #GtkTreeView, it allows to select one or multiple items 55 * (depending on the selection mode, see gtk_icon_view_set_selection_mode()). 56 * In addition to selection with the arrow keys, #GtkIconView supports 57 * rubberband selection, which is controlled by dragging the pointer. 58 * 59 * Note that if the tree model is backed by an actual tree store (as 60 * opposed to a flat list where the mapping to icons is obvious), 61 * #GtkIconView will only display the first level of the tree and 62 * ignore the tree’s branches. 63 */ 64 public class IconView : Container, CellLayoutIF, ScrollableIF 65 { 66 /** the main Gtk struct */ 67 protected GtkIconView* gtkIconView; 68 69 /** Get the main Gtk struct */ 70 public GtkIconView* getIconViewStruct() 71 { 72 return gtkIconView; 73 } 74 75 /** the main Gtk struct as a void* */ 76 protected override void* getStruct() 77 { 78 return cast(void*)gtkIconView; 79 } 80 81 protected override void setStruct(GObject* obj) 82 { 83 gtkIconView = cast(GtkIconView*)obj; 84 super.setStruct(obj); 85 } 86 87 /** 88 * Sets our main struct and passes it to the parent class. 89 */ 90 public this (GtkIconView* gtkIconView, bool ownedRef = false) 91 { 92 this.gtkIconView = gtkIconView; 93 super(cast(GtkContainer*)gtkIconView, ownedRef); 94 } 95 96 // add the CellLayout capabilities 97 mixin CellLayoutT!(GtkIconView); 98 99 // add the Scrollable capabilities 100 mixin ScrollableT!(GtkIconView); 101 102 103 /** */ 104 public static GType getType() 105 { 106 return gtk_icon_view_get_type(); 107 } 108 109 /** 110 * Creates a new #GtkIconView widget 111 * 112 * Return: A newly created #GtkIconView widget 113 * 114 * Since: 2.6 115 * 116 * Throws: ConstructionException GTK+ fails to create the object. 117 */ 118 public this() 119 { 120 auto p = gtk_icon_view_new(); 121 122 if(p is null) 123 { 124 throw new ConstructionException("null returned by new"); 125 } 126 127 this(cast(GtkIconView*) p); 128 } 129 130 /** 131 * Creates a new #GtkIconView widget using the 132 * specified @area to layout cells inside the icons. 133 * 134 * Params: 135 * area = the #GtkCellArea to use to layout cells 136 * 137 * Return: A newly created #GtkIconView widget 138 * 139 * Since: 3.0 140 * 141 * Throws: ConstructionException GTK+ fails to create the object. 142 */ 143 public this(CellArea area) 144 { 145 auto p = gtk_icon_view_new_with_area((area is null) ? null : area.getCellAreaStruct()); 146 147 if(p is null) 148 { 149 throw new ConstructionException("null returned by new_with_area"); 150 } 151 152 this(cast(GtkIconView*) p); 153 } 154 155 /** 156 * Creates a new #GtkIconView widget with the model @model. 157 * 158 * Params: 159 * model = The model. 160 * 161 * Return: A newly created #GtkIconView widget. 162 * 163 * Since: 2.6 164 * 165 * Throws: ConstructionException GTK+ fails to create the object. 166 */ 167 public this(TreeModelIF model) 168 { 169 auto p = gtk_icon_view_new_with_model((model is null) ? null : model.getTreeModelStruct()); 170 171 if(p is null) 172 { 173 throw new ConstructionException("null returned by new_with_model"); 174 } 175 176 this(cast(GtkIconView*) p); 177 } 178 179 /** 180 * Converts widget coordinates to coordinates for the bin_window, 181 * as expected by e.g. gtk_icon_view_get_path_at_pos(). 182 * 183 * Params: 184 * wx = X coordinate relative to the widget 185 * wy = Y coordinate relative to the widget 186 * bx = return location for bin_window X coordinate 187 * by = return location for bin_window Y coordinate 188 * 189 * Since: 2.12 190 */ 191 public void convertWidgetToBinWindowCoords(int wx, int wy, out int bx, out int by) 192 { 193 gtk_icon_view_convert_widget_to_bin_window_coords(gtkIconView, wx, wy, &bx, &by); 194 } 195 196 /** 197 * Creates a #cairo_surface_t representation of the item at @path. 198 * This image is used for a drag icon. 199 * 200 * Params: 201 * path = a #GtkTreePath in @icon_view 202 * 203 * Return: a newly-allocated surface of the drag icon. 204 * 205 * Since: 2.8 206 */ 207 public Surface createDragIcon(TreePath path) 208 { 209 auto p = gtk_icon_view_create_drag_icon(gtkIconView, (path is null) ? null : path.getTreePathStruct()); 210 211 if(p is null) 212 { 213 return null; 214 } 215 216 return new Surface(cast(cairo_surface_t*) p); 217 } 218 219 /** 220 * Turns @icon_view into a drop destination for automatic DND. Calling this 221 * method sets #GtkIconView:reorderable to %FALSE. 222 * 223 * Params: 224 * targets = the table of targets that the drag will 225 * support 226 * nTargets = the number of items in @targets 227 * actions = the bitmask of possible actions for a drag to this 228 * widget 229 * 230 * Since: 2.8 231 */ 232 public void enableModelDragDest(TargetEntry[] targets, GdkDragAction actions) 233 { 234 GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length]; 235 for ( int i = 0; i < targets.length; i++ ) 236 { 237 targetsArray[i] = *(targets[i].getTargetEntryStruct()); 238 } 239 240 gtk_icon_view_enable_model_drag_dest(gtkIconView, targetsArray.ptr, cast(int)targets.length, actions); 241 } 242 243 /** 244 * Turns @icon_view into a drag source for automatic DND. Calling this 245 * method sets #GtkIconView:reorderable to %FALSE. 246 * 247 * Params: 248 * startButtonMask = Mask of allowed buttons to start drag 249 * targets = the table of targets that the drag will 250 * support 251 * nTargets = the number of items in @targets 252 * actions = the bitmask of possible actions for a drag from this 253 * widget 254 * 255 * Since: 2.8 256 */ 257 public void enableModelDragSource(GdkModifierType startButtonMask, TargetEntry[] targets, GdkDragAction actions) 258 { 259 GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length]; 260 for ( int i = 0; i < targets.length; i++ ) 261 { 262 targetsArray[i] = *(targets[i].getTargetEntryStruct()); 263 } 264 265 gtk_icon_view_enable_model_drag_source(gtkIconView, startButtonMask, targetsArray.ptr, cast(int)targets.length, actions); 266 } 267 268 /** 269 * Gets the setting set by gtk_icon_view_set_activate_on_single_click(). 270 * 271 * Return: %TRUE if item-activated will be emitted on a single click 272 * 273 * Since: 3.8 274 */ 275 public bool getActivateOnSingleClick() 276 { 277 return gtk_icon_view_get_activate_on_single_click(gtkIconView) != 0; 278 } 279 280 /** 281 * Fills the bounding rectangle in widget coordinates for the cell specified by 282 * @path and @cell. If @cell is %NULL the main cell area is used. 283 * 284 * This function is only valid if @icon_view is realized. 285 * 286 * Params: 287 * path = a #GtkTreePath 288 * cell = a #GtkCellRenderer or %NULL 289 * rect = rectangle to fill with cell rect 290 * 291 * Return: %FALSE if there is no such item, %TRUE otherwise 292 * 293 * Since: 3.6 294 */ 295 public bool getCellRect(TreePath path, CellRenderer cell, out GdkRectangle rect) 296 { 297 return gtk_icon_view_get_cell_rect(gtkIconView, (path is null) ? null : path.getTreePathStruct(), (cell is null) ? null : cell.getCellRendererStruct(), &rect) != 0; 298 } 299 300 /** 301 * Returns the value of the ::column-spacing property. 302 * 303 * Return: the space between columns 304 * 305 * Since: 2.6 306 */ 307 public int getColumnSpacing() 308 { 309 return gtk_icon_view_get_column_spacing(gtkIconView); 310 } 311 312 /** 313 * Returns the value of the ::columns property. 314 * 315 * Return: the number of columns, or -1 316 * 317 * Since: 2.6 318 */ 319 public int getColumns() 320 { 321 return gtk_icon_view_get_columns(gtkIconView); 322 } 323 324 /** 325 * Fills in @path and @cell with the current cursor path and cell. 326 * If the cursor isn’t currently set, then *@path will be %NULL. 327 * If no cell currently has focus, then *@cell will be %NULL. 328 * 329 * The returned #GtkTreePath must be freed with gtk_tree_path_free(). 330 * 331 * Params: 332 * path = Return location for the current 333 * cursor path, or %NULL 334 * cell = Return location the current 335 * focus cell, or %NULL 336 * 337 * Return: %TRUE if the cursor is set. 338 * 339 * Since: 2.8 340 */ 341 public bool getCursor(out TreePath path, out CellRenderer cell) 342 { 343 GtkTreePath* outpath = null; 344 GtkCellRenderer* outcell = null; 345 346 auto p = gtk_icon_view_get_cursor(gtkIconView, &outpath, &outcell) != 0; 347 348 path = ObjectG.getDObject!(TreePath)(outpath); 349 cell = ObjectG.getDObject!(CellRenderer)(outcell); 350 351 return p; 352 } 353 354 /** 355 * Determines the destination item for a given position. 356 * 357 * Params: 358 * dragX = the position to determine the destination item for 359 * dragY = the position to determine the destination item for 360 * path = Return location for the path of the item, 361 * or %NULL. 362 * pos = Return location for the drop position, or %NULL 363 * 364 * Return: whether there is an item at the given position. 365 * 366 * Since: 2.8 367 */ 368 public bool getDestItemAtPos(int dragX, int dragY, out TreePath path, out GtkIconViewDropPosition pos) 369 { 370 GtkTreePath* outpath = null; 371 372 auto p = gtk_icon_view_get_dest_item_at_pos(gtkIconView, dragX, dragY, &outpath, &pos) != 0; 373 374 path = ObjectG.getDObject!(TreePath)(outpath); 375 376 return p; 377 } 378 379 /** 380 * Gets information about the item that is highlighted for feedback. 381 * 382 * Params: 383 * path = Return location for the path of 384 * the highlighted item, or %NULL. 385 * pos = Return location for the drop position, or %NULL 386 * 387 * Since: 2.8 388 */ 389 public void getDragDestItem(out TreePath path, out GtkIconViewDropPosition pos) 390 { 391 GtkTreePath* outpath = null; 392 393 gtk_icon_view_get_drag_dest_item(gtkIconView, &outpath, &pos); 394 395 path = ObjectG.getDObject!(TreePath)(outpath); 396 } 397 398 /** 399 * Finds the path at the point (@x, @y), relative to bin_window coordinates. 400 * In contrast to gtk_icon_view_get_path_at_pos(), this function also 401 * obtains the cell at the specified position. The returned path should 402 * be freed with gtk_tree_path_free(). 403 * See gtk_icon_view_convert_widget_to_bin_window_coords() for converting 404 * widget coordinates to bin_window coordinates. 405 * 406 * Params: 407 * x = The x position to be identified 408 * y = The y position to be identified 409 * path = Return location for the path, or %NULL 410 * cell = Return location for the renderer 411 * responsible for the cell at (@x, @y), or %NULL 412 * 413 * Return: %TRUE if an item exists at the specified position 414 * 415 * Since: 2.8 416 */ 417 public bool getItemAtPos(int x, int y, out TreePath path, out CellRenderer cell) 418 { 419 GtkTreePath* outpath = null; 420 GtkCellRenderer* outcell = null; 421 422 auto p = gtk_icon_view_get_item_at_pos(gtkIconView, x, y, &outpath, &outcell) != 0; 423 424 path = ObjectG.getDObject!(TreePath)(outpath); 425 cell = ObjectG.getDObject!(CellRenderer)(outcell); 426 427 return p; 428 } 429 430 /** 431 * Gets the column in which the item @path is currently 432 * displayed. Column numbers start at 0. 433 * 434 * Params: 435 * path = the #GtkTreePath of the item 436 * 437 * Return: The column in which the item is displayed 438 * 439 * Since: 2.22 440 */ 441 public int getItemColumn(TreePath path) 442 { 443 return gtk_icon_view_get_item_column(gtkIconView, (path is null) ? null : path.getTreePathStruct()); 444 } 445 446 /** 447 * Returns the value of the ::item-orientation property which determines 448 * whether the labels are drawn beside the icons instead of below. 449 * 450 * Return: the relative position of texts and icons 451 * 452 * Since: 2.6 453 */ 454 public GtkOrientation getItemOrientation() 455 { 456 return gtk_icon_view_get_item_orientation(gtkIconView); 457 } 458 459 /** 460 * Returns the value of the ::item-padding property. 461 * 462 * Return: the padding around items 463 * 464 * Since: 2.18 465 */ 466 public int getItemPadding() 467 { 468 return gtk_icon_view_get_item_padding(gtkIconView); 469 } 470 471 /** 472 * Gets the row in which the item @path is currently 473 * displayed. Row numbers start at 0. 474 * 475 * Params: 476 * path = the #GtkTreePath of the item 477 * 478 * Return: The row in which the item is displayed 479 * 480 * Since: 2.22 481 */ 482 public int getItemRow(TreePath path) 483 { 484 return gtk_icon_view_get_item_row(gtkIconView, (path is null) ? null : path.getTreePathStruct()); 485 } 486 487 /** 488 * Returns the value of the ::item-width property. 489 * 490 * Return: the width of a single item, or -1 491 * 492 * Since: 2.6 493 */ 494 public int getItemWidth() 495 { 496 return gtk_icon_view_get_item_width(gtkIconView); 497 } 498 499 /** 500 * Returns the value of the ::margin property. 501 * 502 * Return: the space at the borders 503 * 504 * Since: 2.6 505 */ 506 public int getMargin() 507 { 508 return gtk_icon_view_get_margin(gtkIconView); 509 } 510 511 /** 512 * Returns the column with markup text for @icon_view. 513 * 514 * Return: the markup column, or -1 if it’s unset. 515 * 516 * Since: 2.6 517 */ 518 public int getMarkupColumn() 519 { 520 return gtk_icon_view_get_markup_column(gtkIconView); 521 } 522 523 /** 524 * Returns the model the #GtkIconView is based on. Returns %NULL if the 525 * model is unset. 526 * 527 * Return: A #GtkTreeModel, or %NULL if none is 528 * currently being used. 529 * 530 * Since: 2.6 531 */ 532 public TreeModelIF getModel() 533 { 534 auto p = gtk_icon_view_get_model(gtkIconView); 535 536 if(p is null) 537 { 538 return null; 539 } 540 541 return ObjectG.getDObject!(TreeModel, TreeModelIF)(cast(GtkTreeModel*) p); 542 } 543 544 /** 545 * Finds the path at the point (@x, @y), relative to bin_window coordinates. 546 * See gtk_icon_view_get_item_at_pos(), if you are also interested in 547 * the cell at the specified position. 548 * See gtk_icon_view_convert_widget_to_bin_window_coords() for converting 549 * widget coordinates to bin_window coordinates. 550 * 551 * Params: 552 * x = The x position to be identified 553 * y = The y position to be identified 554 * 555 * Return: The #GtkTreePath corresponding to the icon or %NULL 556 * if no icon exists at that position. 557 * 558 * Since: 2.6 559 */ 560 public TreePath getPathAtPos(int x, int y) 561 { 562 auto p = gtk_icon_view_get_path_at_pos(gtkIconView, x, y); 563 564 if(p is null) 565 { 566 return null; 567 } 568 569 return ObjectG.getDObject!(TreePath)(cast(GtkTreePath*) p); 570 } 571 572 /** 573 * Returns the column with pixbufs for @icon_view. 574 * 575 * Return: the pixbuf column, or -1 if it’s unset. 576 * 577 * Since: 2.6 578 */ 579 public int getPixbufColumn() 580 { 581 return gtk_icon_view_get_pixbuf_column(gtkIconView); 582 } 583 584 /** 585 * Retrieves whether the user can reorder the list via drag-and-drop. 586 * See gtk_icon_view_set_reorderable(). 587 * 588 * Return: %TRUE if the list can be reordered. 589 * 590 * Since: 2.8 591 */ 592 public bool getReorderable() 593 { 594 return gtk_icon_view_get_reorderable(gtkIconView) != 0; 595 } 596 597 /** 598 * Returns the value of the ::row-spacing property. 599 * 600 * Return: the space between rows 601 * 602 * Since: 2.6 603 */ 604 public int getRowSpacing() 605 { 606 return gtk_icon_view_get_row_spacing(gtkIconView); 607 } 608 609 /** 610 * Creates a list of paths of all selected items. Additionally, if you are 611 * planning on modifying the model after calling this function, you may 612 * want to convert the returned list into a list of #GtkTreeRowReferences. 613 * To do this, you can use gtk_tree_row_reference_new(). 614 * 615 * To free the return value, use: 616 * |[<!-- language="C" --> 617 * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free); 618 * ]| 619 * 620 * Return: A #GList containing a #GtkTreePath for each selected row. 621 * 622 * Since: 2.6 623 */ 624 public ListG getSelectedItems() 625 { 626 auto p = gtk_icon_view_get_selected_items(gtkIconView); 627 628 if(p is null) 629 { 630 return null; 631 } 632 633 return new ListG(cast(GList*) p); 634 } 635 636 /** 637 * Gets the selection mode of the @icon_view. 638 * 639 * Return: the current selection mode 640 * 641 * Since: 2.6 642 */ 643 public GtkSelectionMode getSelectionMode() 644 { 645 return gtk_icon_view_get_selection_mode(gtkIconView); 646 } 647 648 /** 649 * Returns the value of the ::spacing property. 650 * 651 * Return: the space between cells 652 * 653 * Since: 2.6 654 */ 655 public int getSpacing() 656 { 657 return gtk_icon_view_get_spacing(gtkIconView); 658 } 659 660 /** 661 * Returns the column with text for @icon_view. 662 * 663 * Return: the text column, or -1 if it’s unset. 664 * 665 * Since: 2.6 666 */ 667 public int getTextColumn() 668 { 669 return gtk_icon_view_get_text_column(gtkIconView); 670 } 671 672 /** 673 * Returns the column of @icon_view’s model which is being used for 674 * displaying tooltips on @icon_view’s rows. 675 * 676 * Return: the index of the tooltip column that is currently being 677 * used, or -1 if this is disabled. 678 * 679 * Since: 2.12 680 */ 681 public int getTooltipColumn() 682 { 683 return gtk_icon_view_get_tooltip_column(gtkIconView); 684 } 685 686 /** 687 * This function is supposed to be used in a #GtkWidget::query-tooltip 688 * signal handler for #GtkIconView. The @x, @y and @keyboard_tip values 689 * which are received in the signal handler, should be passed to this 690 * function without modification. 691 * 692 * The return value indicates whether there is an icon view item at the given 693 * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard 694 * tooltips the item returned will be the cursor item. When %TRUE, then any of 695 * @model, @path and @iter which have been provided will be set to point to 696 * that row and the corresponding model. @x and @y will always be converted 697 * to be relative to @icon_view’s bin_window if @keyboard_tooltip is %FALSE. 698 * 699 * Params: 700 * x = the x coordinate (relative to widget coordinates) 701 * y = the y coordinate (relative to widget coordinates) 702 * keyboardTip = whether this is a keyboard tooltip or not 703 * model = a pointer to receive a 704 * #GtkTreeModel or %NULL 705 * path = a pointer to receive a #GtkTreePath or %NULL 706 * iter = a pointer to receive a #GtkTreeIter or %NULL 707 * 708 * Return: whether or not the given tooltip context points to a item 709 * 710 * Since: 2.12 711 */ 712 public bool getTooltipContext(ref int x, ref int y, bool keyboardTip, out TreeModelIF model, out TreePath path, out TreeIter iter) 713 { 714 GtkTreeModel* outmodel = null; 715 GtkTreePath* outpath = null; 716 GtkTreeIter* outiter = gMalloc!GtkTreeIter(); 717 718 auto p = gtk_icon_view_get_tooltip_context(gtkIconView, &x, &y, keyboardTip, &outmodel, &outpath, outiter) != 0; 719 720 model = ObjectG.getDObject!(TreeModel, TreeModelIF)(outmodel); 721 path = ObjectG.getDObject!(TreePath)(outpath); 722 iter = ObjectG.getDObject!(TreeIter)(outiter); 723 724 return p; 725 } 726 727 /** 728 * Sets @start_path and @end_path to be the first and last visible path. 729 * Note that there may be invisible paths in between. 730 * 731 * Both paths should be freed with gtk_tree_path_free() after use. 732 * 733 * Params: 734 * startPath = Return location for start of region, 735 * or %NULL 736 * endPath = Return location for end of region, or %NULL 737 * 738 * Return: %TRUE, if valid paths were placed in @start_path and @end_path 739 * 740 * Since: 2.8 741 */ 742 public bool getVisibleRange(out TreePath startPath, out TreePath endPath) 743 { 744 GtkTreePath* outstartPath = null; 745 GtkTreePath* outendPath = null; 746 747 auto p = gtk_icon_view_get_visible_range(gtkIconView, &outstartPath, &outendPath) != 0; 748 749 startPath = ObjectG.getDObject!(TreePath)(outstartPath); 750 endPath = ObjectG.getDObject!(TreePath)(outendPath); 751 752 return p; 753 } 754 755 /** 756 * Activates the item determined by @path. 757 * 758 * Params: 759 * path = The #GtkTreePath to be activated 760 * 761 * Since: 2.6 762 */ 763 public void itemActivated(TreePath path) 764 { 765 gtk_icon_view_item_activated(gtkIconView, (path is null) ? null : path.getTreePathStruct()); 766 } 767 768 /** 769 * Returns %TRUE if the icon pointed to by @path is currently 770 * selected. If @path does not point to a valid location, %FALSE is returned. 771 * 772 * Params: 773 * path = A #GtkTreePath to check selection on. 774 * 775 * Return: %TRUE if @path is selected. 776 * 777 * Since: 2.6 778 */ 779 public bool pathIsSelected(TreePath path) 780 { 781 return gtk_icon_view_path_is_selected(gtkIconView, (path is null) ? null : path.getTreePathStruct()) != 0; 782 } 783 784 /** 785 * Moves the alignments of @icon_view to the position specified by @path. 786 * @row_align determines where the row is placed, and @col_align determines 787 * where @column is placed. Both are expected to be between 0.0 and 1.0. 788 * 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means 789 * center. 790 * 791 * If @use_align is %FALSE, then the alignment arguments are ignored, and the 792 * tree does the minimum amount of work to scroll the item onto the screen. 793 * This means that the item will be scrolled to the edge closest to its current 794 * position. If the item is currently visible on the screen, nothing is done. 795 * 796 * This function only works if the model is set, and @path is a valid row on 797 * the model. If the model changes before the @icon_view is realized, the 798 * centered path will be modified to reflect this change. 799 * 800 * Params: 801 * path = The path of the item to move to. 802 * useAlign = whether to use alignment arguments, or %FALSE. 803 * rowAlign = The vertical alignment of the item specified by @path. 804 * colAlign = The horizontal alignment of the item specified by @path. 805 * 806 * Since: 2.8 807 */ 808 public void scrollToPath(TreePath path, bool useAlign, float rowAlign, float colAlign) 809 { 810 gtk_icon_view_scroll_to_path(gtkIconView, (path is null) ? null : path.getTreePathStruct(), useAlign, rowAlign, colAlign); 811 } 812 813 /** 814 * Selects all the icons. @icon_view must has its selection mode set 815 * to #GTK_SELECTION_MULTIPLE. 816 * 817 * Since: 2.6 818 */ 819 public void selectAll() 820 { 821 gtk_icon_view_select_all(gtkIconView); 822 } 823 824 /** 825 * Selects the row at @path. 826 * 827 * Params: 828 * path = The #GtkTreePath to be selected. 829 * 830 * Since: 2.6 831 */ 832 public void selectPath(TreePath path) 833 { 834 gtk_icon_view_select_path(gtkIconView, (path is null) ? null : path.getTreePathStruct()); 835 } 836 837 /** 838 * Calls a function for each selected icon. Note that the model or 839 * selection cannot be modified from within this function. 840 * 841 * Params: 842 * func = The function to call for each selected icon. 843 * data = User data to pass to the function. 844 * 845 * Since: 2.6 846 */ 847 public void selectedForeach(GtkIconViewForeachFunc func, void* data) 848 { 849 gtk_icon_view_selected_foreach(gtkIconView, func, data); 850 } 851 852 /** 853 * Causes the #GtkIconView::item-activated signal to be emitted on 854 * a single click instead of a double click. 855 * 856 * Params: 857 * single = %TRUE to emit item-activated on a single click 858 * 859 * Since: 3.8 860 */ 861 public void setActivateOnSingleClick(bool single) 862 { 863 gtk_icon_view_set_activate_on_single_click(gtkIconView, single); 864 } 865 866 /** 867 * Sets the ::column-spacing property which specifies the space 868 * which is inserted between the columns of the icon view. 869 * 870 * Params: 871 * columnSpacing = the column spacing 872 * 873 * Since: 2.6 874 */ 875 public void setColumnSpacing(int columnSpacing) 876 { 877 gtk_icon_view_set_column_spacing(gtkIconView, columnSpacing); 878 } 879 880 /** 881 * Sets the ::columns property which determines in how 882 * many columns the icons are arranged. If @columns is 883 * -1, the number of columns will be chosen automatically 884 * to fill the available area. 885 * 886 * Params: 887 * columns = the number of columns 888 * 889 * Since: 2.6 890 */ 891 public void setColumns(int columns) 892 { 893 gtk_icon_view_set_columns(gtkIconView, columns); 894 } 895 896 /** 897 * Sets the current keyboard focus to be at @path, and selects it. This is 898 * useful when you want to focus the user’s attention on a particular item. 899 * If @cell is not %NULL, then focus is given to the cell specified by 900 * it. Additionally, if @start_editing is %TRUE, then editing should be 901 * started in the specified cell. 902 * 903 * This function is often followed by `gtk_widget_grab_focus 904 * (icon_view)` in order to give keyboard focus to the widget. 905 * Please note that editing can only happen when the widget is realized. 906 * 907 * Params: 908 * path = A #GtkTreePath 909 * cell = One of the cell renderers of @icon_view, or %NULL 910 * startEditing = %TRUE if the specified cell should start being edited. 911 * 912 * Since: 2.8 913 */ 914 public void setCursor(TreePath path, CellRenderer cell, bool startEditing) 915 { 916 gtk_icon_view_set_cursor(gtkIconView, (path is null) ? null : path.getTreePathStruct(), (cell is null) ? null : cell.getCellRendererStruct(), startEditing); 917 } 918 919 /** 920 * Sets the item that is highlighted for feedback. 921 * 922 * Params: 923 * path = The path of the item to highlight, or %NULL. 924 * pos = Specifies where to drop, relative to the item 925 * 926 * Since: 2.8 927 */ 928 public void setDragDestItem(TreePath path, GtkIconViewDropPosition pos) 929 { 930 gtk_icon_view_set_drag_dest_item(gtkIconView, (path is null) ? null : path.getTreePathStruct(), pos); 931 } 932 933 /** 934 * Sets the ::item-orientation property which determines whether the labels 935 * are drawn beside the icons instead of below. 936 * 937 * Params: 938 * orientation = the relative position of texts and icons 939 * 940 * Since: 2.6 941 */ 942 public void setItemOrientation(GtkOrientation orientation) 943 { 944 gtk_icon_view_set_item_orientation(gtkIconView, orientation); 945 } 946 947 /** 948 * Sets the #GtkIconView:item-padding property which specifies the padding 949 * around each of the icon view’s items. 950 * 951 * Params: 952 * itemPadding = the item padding 953 * 954 * Since: 2.18 955 */ 956 public void setItemPadding(int itemPadding) 957 { 958 gtk_icon_view_set_item_padding(gtkIconView, itemPadding); 959 } 960 961 /** 962 * Sets the ::item-width property which specifies the width 963 * to use for each item. If it is set to -1, the icon view will 964 * automatically determine a suitable item size. 965 * 966 * Params: 967 * itemWidth = the width for each item 968 * 969 * Since: 2.6 970 */ 971 public void setItemWidth(int itemWidth) 972 { 973 gtk_icon_view_set_item_width(gtkIconView, itemWidth); 974 } 975 976 /** 977 * Sets the ::margin property which specifies the space 978 * which is inserted at the top, bottom, left and right 979 * of the icon view. 980 * 981 * Params: 982 * margin = the margin 983 * 984 * Since: 2.6 985 */ 986 public void setMargin(int margin) 987 { 988 gtk_icon_view_set_margin(gtkIconView, margin); 989 } 990 991 /** 992 * Sets the column with markup information for @icon_view to be 993 * @column. The markup column must be of type #G_TYPE_STRING. 994 * If the markup column is set to something, it overrides 995 * the text column set by gtk_icon_view_set_text_column(). 996 * 997 * Params: 998 * column = A column in the currently used model, or -1 to display no text 999 * 1000 * Since: 2.6 1001 */ 1002 public void setMarkupColumn(int column) 1003 { 1004 gtk_icon_view_set_markup_column(gtkIconView, column); 1005 } 1006 1007 /** 1008 * Sets the model for a #GtkIconView. 1009 * If the @icon_view already has a model set, it will remove 1010 * it before setting the new model. If @model is %NULL, then 1011 * it will unset the old model. 1012 * 1013 * Params: 1014 * model = The model. 1015 * 1016 * Since: 2.6 1017 */ 1018 public void setModel(TreeModelIF model) 1019 { 1020 gtk_icon_view_set_model(gtkIconView, (model is null) ? null : model.getTreeModelStruct()); 1021 } 1022 1023 /** 1024 * Sets the column with pixbufs for @icon_view to be @column. The pixbuf 1025 * column must be of type #GDK_TYPE_PIXBUF 1026 * 1027 * Params: 1028 * column = A column in the currently used model, or -1 to disable 1029 * 1030 * Since: 2.6 1031 */ 1032 public void setPixbufColumn(int column) 1033 { 1034 gtk_icon_view_set_pixbuf_column(gtkIconView, column); 1035 } 1036 1037 /** 1038 * This function is a convenience function to allow you to reorder models that 1039 * support the #GtkTreeDragSourceIface and the #GtkTreeDragDestIface. Both 1040 * #GtkTreeStore and #GtkListStore support these. If @reorderable is %TRUE, then 1041 * the user can reorder the model by dragging and dropping rows. The 1042 * developer can listen to these changes by connecting to the model's 1043 * row_inserted and row_deleted signals. The reordering is implemented by setting up 1044 * the icon view as a drag source and destination. Therefore, drag and 1045 * drop can not be used in a reorderable view for any other purpose. 1046 * 1047 * This function does not give you any degree of control over the order -- any 1048 * reordering is allowed. If more control is needed, you should probably 1049 * handle drag and drop manually. 1050 * 1051 * Params: 1052 * reorderable = %TRUE, if the list of items can be reordered. 1053 * 1054 * Since: 2.8 1055 */ 1056 public void setReorderable(bool reorderable) 1057 { 1058 gtk_icon_view_set_reorderable(gtkIconView, reorderable); 1059 } 1060 1061 /** 1062 * Sets the ::row-spacing property which specifies the space 1063 * which is inserted between the rows of the icon view. 1064 * 1065 * Params: 1066 * rowSpacing = the row spacing 1067 * 1068 * Since: 2.6 1069 */ 1070 public void setRowSpacing(int rowSpacing) 1071 { 1072 gtk_icon_view_set_row_spacing(gtkIconView, rowSpacing); 1073 } 1074 1075 /** 1076 * Sets the selection mode of the @icon_view. 1077 * 1078 * Params: 1079 * mode = The selection mode 1080 * 1081 * Since: 2.6 1082 */ 1083 public void setSelectionMode(GtkSelectionMode mode) 1084 { 1085 gtk_icon_view_set_selection_mode(gtkIconView, mode); 1086 } 1087 1088 /** 1089 * Sets the ::spacing property which specifies the space 1090 * which is inserted between the cells (i.e. the icon and 1091 * the text) of an item. 1092 * 1093 * Params: 1094 * spacing = the spacing 1095 * 1096 * Since: 2.6 1097 */ 1098 public void setSpacing(int spacing) 1099 { 1100 gtk_icon_view_set_spacing(gtkIconView, spacing); 1101 } 1102 1103 /** 1104 * Sets the column with text for @icon_view to be @column. The text 1105 * column must be of type #G_TYPE_STRING. 1106 * 1107 * Params: 1108 * column = A column in the currently used model, or -1 to display no text 1109 * 1110 * Since: 2.6 1111 */ 1112 public void setTextColumn(int column) 1113 { 1114 gtk_icon_view_set_text_column(gtkIconView, column); 1115 } 1116 1117 /** 1118 * Sets the tip area of @tooltip to the area which @cell occupies in 1119 * the item pointed to by @path. See also gtk_tooltip_set_tip_area(). 1120 * 1121 * See also gtk_icon_view_set_tooltip_column() for a simpler alternative. 1122 * 1123 * Params: 1124 * tooltip = a #GtkTooltip 1125 * path = a #GtkTreePath 1126 * cell = a #GtkCellRenderer or %NULL 1127 * 1128 * Since: 2.12 1129 */ 1130 public void setTooltipCell(Tooltip tooltip, TreePath path, CellRenderer cell) 1131 { 1132 gtk_icon_view_set_tooltip_cell(gtkIconView, (tooltip is null) ? null : tooltip.getTooltipStruct(), (path is null) ? null : path.getTreePathStruct(), (cell is null) ? null : cell.getCellRendererStruct()); 1133 } 1134 1135 /** 1136 * If you only plan to have simple (text-only) tooltips on full items, you 1137 * can use this function to have #GtkIconView handle these automatically 1138 * for you. @column should be set to the column in @icon_view’s model 1139 * containing the tooltip texts, or -1 to disable this feature. 1140 * 1141 * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and 1142 * @icon_view will connect a #GtkWidget::query-tooltip signal handler. 1143 * 1144 * Note that the signal handler sets the text with gtk_tooltip_set_markup(), 1145 * so &, <, etc have to be escaped in the text. 1146 * 1147 * Params: 1148 * column = an integer, which is a valid column number for @icon_view’s model 1149 * 1150 * Since: 2.12 1151 */ 1152 public void setTooltipColumn(int column) 1153 { 1154 gtk_icon_view_set_tooltip_column(gtkIconView, column); 1155 } 1156 1157 /** 1158 * Sets the tip area of @tooltip to be the area covered by the item at @path. 1159 * See also gtk_icon_view_set_tooltip_column() for a simpler alternative. 1160 * See also gtk_tooltip_set_tip_area(). 1161 * 1162 * Params: 1163 * tooltip = a #GtkTooltip 1164 * path = a #GtkTreePath 1165 * 1166 * Since: 2.12 1167 */ 1168 public void setTooltipItem(Tooltip tooltip, TreePath path) 1169 { 1170 gtk_icon_view_set_tooltip_item(gtkIconView, (tooltip is null) ? null : tooltip.getTooltipStruct(), (path is null) ? null : path.getTreePathStruct()); 1171 } 1172 1173 /** 1174 * Unselects all the icons. 1175 * 1176 * Since: 2.6 1177 */ 1178 public void unselectAll() 1179 { 1180 gtk_icon_view_unselect_all(gtkIconView); 1181 } 1182 1183 /** 1184 * Unselects the row at @path. 1185 * 1186 * Params: 1187 * path = The #GtkTreePath to be unselected. 1188 * 1189 * Since: 2.6 1190 */ 1191 public void unselectPath(TreePath path) 1192 { 1193 gtk_icon_view_unselect_path(gtkIconView, (path is null) ? null : path.getTreePathStruct()); 1194 } 1195 1196 /** 1197 * Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this 1198 * method sets #GtkIconView:reorderable to %FALSE. 1199 * 1200 * Since: 2.8 1201 */ 1202 public void unsetModelDragDest() 1203 { 1204 gtk_icon_view_unset_model_drag_dest(gtkIconView); 1205 } 1206 1207 /** 1208 * Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this 1209 * method sets #GtkIconView:reorderable to %FALSE. 1210 * 1211 * Since: 2.8 1212 */ 1213 public void unsetModelDragSource() 1214 { 1215 gtk_icon_view_unset_model_drag_source(gtkIconView); 1216 } 1217 1218 int[string] connectedSignals; 1219 1220 bool delegate(IconView)[] onActivateCursorItemListeners; 1221 /** 1222 * A [keybinding signal][GtkBindingSignal] 1223 * which gets emitted when the user activates the currently 1224 * focused item. 1225 * 1226 * Applications should not connect to it, but may emit it with 1227 * g_signal_emit_by_name() if they need to control activation 1228 * programmatically. 1229 * 1230 * The default bindings for this signal are Space, Return and Enter. 1231 */ 1232 void addOnActivateCursorItem(bool delegate(IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1233 { 1234 if ( "activate-cursor-item" !in connectedSignals ) 1235 { 1236 Signals.connectData( 1237 this, 1238 "activate-cursor-item", 1239 cast(GCallback)&callBackActivateCursorItem, 1240 cast(void*)this, 1241 null, 1242 connectFlags); 1243 connectedSignals["activate-cursor-item"] = 1; 1244 } 1245 onActivateCursorItemListeners ~= dlg; 1246 } 1247 extern(C) static int callBackActivateCursorItem(GtkIconView* iconviewStruct, IconView _iconview) 1248 { 1249 foreach ( bool delegate(IconView) dlg; _iconview.onActivateCursorItemListeners ) 1250 { 1251 if ( dlg(_iconview) ) 1252 { 1253 return 1; 1254 } 1255 } 1256 1257 return 0; 1258 } 1259 1260 void delegate(TreePath, IconView)[] onItemActivatedListeners; 1261 /** 1262 * The ::item-activated signal is emitted when the method 1263 * gtk_icon_view_item_activated() is called, when the user double 1264 * clicks an item with the "activate-on-single-click" property set 1265 * to %FALSE, or when the user single clicks an item when the 1266 * "activate-on-single-click" property set to %TRUE. It is also 1267 * emitted when a non-editable item is selected and one of the keys: 1268 * Space, Return or Enter is pressed. 1269 * 1270 * Params: 1271 * path = the #GtkTreePath for the activated item 1272 */ 1273 void addOnItemActivated(void delegate(TreePath, IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1274 { 1275 if ( "item-activated" !in connectedSignals ) 1276 { 1277 Signals.connectData( 1278 this, 1279 "item-activated", 1280 cast(GCallback)&callBackItemActivated, 1281 cast(void*)this, 1282 null, 1283 connectFlags); 1284 connectedSignals["item-activated"] = 1; 1285 } 1286 onItemActivatedListeners ~= dlg; 1287 } 1288 extern(C) static void callBackItemActivated(GtkIconView* iconviewStruct, GtkTreePath* path, IconView _iconview) 1289 { 1290 foreach ( void delegate(TreePath, IconView) dlg; _iconview.onItemActivatedListeners ) 1291 { 1292 dlg(ObjectG.getDObject!(TreePath)(path), _iconview); 1293 } 1294 } 1295 1296 bool delegate(GtkMovementStep, int, IconView)[] onMoveCursorListeners; 1297 /** 1298 * The ::move-cursor signal is a 1299 * [keybinding signal][GtkBindingSignal] 1300 * which gets emitted when the user initiates a cursor movement. 1301 * 1302 * Applications should not connect to it, but may emit it with 1303 * g_signal_emit_by_name() if they need to control the cursor 1304 * programmatically. 1305 * 1306 * The default bindings for this signal include 1307 * - Arrow keys which move by individual steps 1308 * - Home/End keys which move to the first/last item 1309 * - PageUp/PageDown which move by "pages" 1310 * All of these will extend the selection when combined with 1311 * the Shift modifier. 1312 * 1313 * Params: 1314 * step = the granularity of the move, as a #GtkMovementStep 1315 * count = the number of @step units to move 1316 */ 1317 void addOnMoveCursor(bool delegate(GtkMovementStep, int, IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1318 { 1319 if ( "move-cursor" !in connectedSignals ) 1320 { 1321 Signals.connectData( 1322 this, 1323 "move-cursor", 1324 cast(GCallback)&callBackMoveCursor, 1325 cast(void*)this, 1326 null, 1327 connectFlags); 1328 connectedSignals["move-cursor"] = 1; 1329 } 1330 onMoveCursorListeners ~= dlg; 1331 } 1332 extern(C) static int callBackMoveCursor(GtkIconView* iconviewStruct, GtkMovementStep step, int count, IconView _iconview) 1333 { 1334 foreach ( bool delegate(GtkMovementStep, int, IconView) dlg; _iconview.onMoveCursorListeners ) 1335 { 1336 if ( dlg(step, count, _iconview) ) 1337 { 1338 return 1; 1339 } 1340 } 1341 1342 return 0; 1343 } 1344 1345 void delegate(IconView)[] onSelectAllListeners; 1346 /** 1347 * A [keybinding signal][GtkBindingSignal] 1348 * which gets emitted when the user selects all items. 1349 * 1350 * Applications should not connect to it, but may emit it with 1351 * g_signal_emit_by_name() if they need to control selection 1352 * programmatically. 1353 * 1354 * The default binding for this signal is Ctrl-a. 1355 */ 1356 void addOnSelectAll(void delegate(IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1357 { 1358 if ( "select-all" !in connectedSignals ) 1359 { 1360 Signals.connectData( 1361 this, 1362 "select-all", 1363 cast(GCallback)&callBackSelectAll, 1364 cast(void*)this, 1365 null, 1366 connectFlags); 1367 connectedSignals["select-all"] = 1; 1368 } 1369 onSelectAllListeners ~= dlg; 1370 } 1371 extern(C) static void callBackSelectAll(GtkIconView* iconviewStruct, IconView _iconview) 1372 { 1373 foreach ( void delegate(IconView) dlg; _iconview.onSelectAllListeners ) 1374 { 1375 dlg(_iconview); 1376 } 1377 } 1378 1379 void delegate(IconView)[] onSelectCursorItemListeners; 1380 /** 1381 * A [keybinding signal][GtkBindingSignal] 1382 * which gets emitted when the user selects the item that is currently 1383 * focused. 1384 * 1385 * Applications should not connect to it, but may emit it with 1386 * g_signal_emit_by_name() if they need to control selection 1387 * programmatically. 1388 * 1389 * There is no default binding for this signal. 1390 */ 1391 void addOnSelectCursorItem(void delegate(IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1392 { 1393 if ( "select-cursor-item" !in connectedSignals ) 1394 { 1395 Signals.connectData( 1396 this, 1397 "select-cursor-item", 1398 cast(GCallback)&callBackSelectCursorItem, 1399 cast(void*)this, 1400 null, 1401 connectFlags); 1402 connectedSignals["select-cursor-item"] = 1; 1403 } 1404 onSelectCursorItemListeners ~= dlg; 1405 } 1406 extern(C) static void callBackSelectCursorItem(GtkIconView* iconviewStruct, IconView _iconview) 1407 { 1408 foreach ( void delegate(IconView) dlg; _iconview.onSelectCursorItemListeners ) 1409 { 1410 dlg(_iconview); 1411 } 1412 } 1413 1414 void delegate(IconView)[] onSelectionChangedListeners; 1415 /** 1416 * The ::selection-changed signal is emitted when the selection 1417 * (i.e. the set of selected items) changes. 1418 */ 1419 void addOnSelectionChanged(void delegate(IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1420 { 1421 if ( "selection-changed" !in connectedSignals ) 1422 { 1423 Signals.connectData( 1424 this, 1425 "selection-changed", 1426 cast(GCallback)&callBackSelectionChanged, 1427 cast(void*)this, 1428 null, 1429 connectFlags); 1430 connectedSignals["selection-changed"] = 1; 1431 } 1432 onSelectionChangedListeners ~= dlg; 1433 } 1434 extern(C) static void callBackSelectionChanged(GtkIconView* iconviewStruct, IconView _iconview) 1435 { 1436 foreach ( void delegate(IconView) dlg; _iconview.onSelectionChangedListeners ) 1437 { 1438 dlg(_iconview); 1439 } 1440 } 1441 1442 void delegate(IconView)[] onToggleCursorItemListeners; 1443 /** 1444 * A [keybinding signal][GtkBindingSignal] 1445 * which gets emitted when the user toggles whether the currently 1446 * focused item is selected or not. The exact effect of this 1447 * depend on the selection mode. 1448 * 1449 * Applications should not connect to it, but may emit it with 1450 * g_signal_emit_by_name() if they need to control selection 1451 * programmatically. 1452 * 1453 * There is no default binding for this signal is Ctrl-Space. 1454 */ 1455 void addOnToggleCursorItem(void delegate(IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1456 { 1457 if ( "toggle-cursor-item" !in connectedSignals ) 1458 { 1459 Signals.connectData( 1460 this, 1461 "toggle-cursor-item", 1462 cast(GCallback)&callBackToggleCursorItem, 1463 cast(void*)this, 1464 null, 1465 connectFlags); 1466 connectedSignals["toggle-cursor-item"] = 1; 1467 } 1468 onToggleCursorItemListeners ~= dlg; 1469 } 1470 extern(C) static void callBackToggleCursorItem(GtkIconView* iconviewStruct, IconView _iconview) 1471 { 1472 foreach ( void delegate(IconView) dlg; _iconview.onToggleCursorItemListeners ) 1473 { 1474 dlg(_iconview); 1475 } 1476 } 1477 1478 void delegate(IconView)[] onUnselectAllListeners; 1479 /** 1480 * A [keybinding signal][GtkBindingSignal] 1481 * which gets emitted when the user unselects all items. 1482 * 1483 * Applications should not connect to it, but may emit it with 1484 * g_signal_emit_by_name() if they need to control selection 1485 * programmatically. 1486 * 1487 * The default binding for this signal is Ctrl-Shift-a. 1488 */ 1489 void addOnUnselectAll(void delegate(IconView) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1490 { 1491 if ( "unselect-all" !in connectedSignals ) 1492 { 1493 Signals.connectData( 1494 this, 1495 "unselect-all", 1496 cast(GCallback)&callBackUnselectAll, 1497 cast(void*)this, 1498 null, 1499 connectFlags); 1500 connectedSignals["unselect-all"] = 1; 1501 } 1502 onUnselectAllListeners ~= dlg; 1503 } 1504 extern(C) static void callBackUnselectAll(GtkIconView* iconviewStruct, IconView _iconview) 1505 { 1506 foreach ( void delegate(IconView) dlg; _iconview.onUnselectAllListeners ) 1507 { 1508 dlg(_iconview); 1509 } 1510 } 1511 }