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.CellArea; 26 27 private import cairo.Context; 28 private import gdk.Event; 29 private import glib.ListG; 30 private import glib.Str; 31 private import gobject.ObjectG; 32 private import gobject.Signals; 33 private import gobject.Value; 34 private import gtk.BuildableIF; 35 private import gtk.BuildableT; 36 private import gtk.CellAreaContext; 37 private import gtk.CellEditableIF; 38 private import gtk.CellLayoutIF; 39 private import gtk.CellLayoutT; 40 private import gtk.CellRenderer; 41 private import gtk.TreeIter; 42 private import gtk.TreeModelIF; 43 private import gtk.Widget; 44 private import gtk.c.functions; 45 public import gtk.c.types; 46 public import gtkc.gtktypes; 47 private import std.algorithm; 48 49 50 /** 51 * The #GtkCellArea is an abstract class for #GtkCellLayout widgets 52 * (also referred to as "layouting widgets") to interface with an 53 * arbitrary number of #GtkCellRenderers and interact with the user 54 * for a given #GtkTreeModel row. 55 * 56 * The cell area handles events, focus navigation, drawing and 57 * size requests and allocations for a given row of data. 58 * 59 * Usually users dont have to interact with the #GtkCellArea directly 60 * unless they are implementing a cell-layouting widget themselves. 61 * 62 * # Requesting area sizes 63 * 64 * As outlined in 65 * [GtkWidget’s geometry management section][geometry-management], 66 * GTK+ uses a height-for-width 67 * geometry management system to compute the sizes of widgets and user 68 * interfaces. #GtkCellArea uses the same semantics to calculate the 69 * size of an area for an arbitrary number of #GtkTreeModel rows. 70 * 71 * When requesting the size of a cell area one needs to calculate 72 * the size for a handful of rows, and this will be done differently by 73 * different layouting widgets. For instance a #GtkTreeViewColumn 74 * always lines up the areas from top to bottom while a #GtkIconView 75 * on the other hand might enforce that all areas received the same 76 * width and wrap the areas around, requesting height for more cell 77 * areas when allocated less width. 78 * 79 * It’s also important for areas to maintain some cell 80 * alignments with areas rendered for adjacent rows (cells can 81 * appear “columnized” inside an area even when the size of 82 * cells are different in each row). For this reason the #GtkCellArea 83 * uses a #GtkCellAreaContext object to store the alignments 84 * and sizes along the way (as well as the overall largest minimum 85 * and natural size for all the rows which have been calculated 86 * with the said context). 87 * 88 * The #GtkCellAreaContext is an opaque object specific to the 89 * #GtkCellArea which created it (see gtk_cell_area_create_context()). 90 * The owning cell-layouting widget can create as many contexts as 91 * it wishes to calculate sizes of rows which should receive the 92 * same size in at least one orientation (horizontally or vertically), 93 * However, it’s important that the same #GtkCellAreaContext which 94 * was used to request the sizes for a given #GtkTreeModel row be 95 * used when rendering or processing events for that row. 96 * 97 * In order to request the width of all the rows at the root level 98 * of a #GtkTreeModel one would do the following: 99 * 100 * |[<!-- language="C" --> 101 * GtkTreeIter iter; 102 * gint minimum_width; 103 * gint natural_width; 104 * 105 * valid = gtk_tree_model_get_iter_first (model, &iter); 106 * while (valid) 107 * { 108 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); 109 * gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL); 110 * 111 * valid = gtk_tree_model_iter_next (model, &iter); 112 * } 113 * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width); 114 * ]| 115 * 116 * Note that in this example it’s not important to observe the 117 * returned minimum and natural width of the area for each row 118 * unless the cell-layouting object is actually interested in the 119 * widths of individual rows. The overall width is however stored 120 * in the accompanying #GtkCellAreaContext object and can be consulted 121 * at any time. 122 * 123 * This can be useful since #GtkCellLayout widgets usually have to 124 * support requesting and rendering rows in treemodels with an 125 * exceedingly large amount of rows. The #GtkCellLayout widget in 126 * that case would calculate the required width of the rows in an 127 * idle or timeout source (see g_timeout_add()) and when the widget 128 * is requested its actual width in #GtkWidgetClass.get_preferred_width() 129 * it can simply consult the width accumulated so far in the 130 * #GtkCellAreaContext object. 131 * 132 * A simple example where rows are rendered from top to bottom and 133 * take up the full width of the layouting widget would look like: 134 * 135 * |[<!-- language="C" --> 136 * static void 137 * foo_get_preferred_width (GtkWidget *widget, 138 * gint *minimum_size, 139 * gint *natural_size) 140 * { 141 * Foo *foo = FOO (widget); 142 * FooPrivate *priv = foo->priv; 143 * 144 * foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo); 145 * 146 * gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size); 147 * } 148 * ]| 149 * 150 * In the above example the Foo widget has to make sure that some 151 * row sizes have been calculated (the amount of rows that Foo judged 152 * was appropriate to request space for in a single timeout iteration) 153 * before simply returning the amount of space required by the area via 154 * the #GtkCellAreaContext. 155 * 156 * Requesting the height for width (or width for height) of an area is 157 * a similar task except in this case the #GtkCellAreaContext does not 158 * store the data (actually, it does not know how much space the layouting 159 * widget plans to allocate it for every row. It’s up to the layouting 160 * widget to render each row of data with the appropriate height and 161 * width which was requested by the #GtkCellArea). 162 * 163 * In order to request the height for width of all the rows at the 164 * root level of a #GtkTreeModel one would do the following: 165 * 166 * |[<!-- language="C" --> 167 * GtkTreeIter iter; 168 * gint minimum_height; 169 * gint natural_height; 170 * gint full_minimum_height = 0; 171 * gint full_natural_height = 0; 172 * 173 * valid = gtk_tree_model_get_iter_first (model, &iter); 174 * while (valid) 175 * { 176 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); 177 * gtk_cell_area_get_preferred_height_for_width (area, context, widget, 178 * width, &minimum_height, &natural_height); 179 * 180 * if (width_is_for_allocation) 181 * cache_row_height (&iter, minimum_height, natural_height); 182 * 183 * full_minimum_height += minimum_height; 184 * full_natural_height += natural_height; 185 * 186 * valid = gtk_tree_model_iter_next (model, &iter); 187 * } 188 * ]| 189 * 190 * Note that in the above example we would need to cache the heights 191 * returned for each row so that we would know what sizes to render the 192 * areas for each row. However we would only want to really cache the 193 * heights if the request is intended for the layouting widgets real 194 * allocation. 195 * 196 * In some cases the layouting widget is requested the height for an 197 * arbitrary for_width, this is a special case for layouting widgets 198 * who need to request size for tens of thousands of rows. For this 199 * case it’s only important that the layouting widget calculate 200 * one reasonably sized chunk of rows and return that height 201 * synchronously. The reasoning here is that any layouting widget is 202 * at least capable of synchronously calculating enough height to fill 203 * the screen height (or scrolled window height) in response to a single 204 * call to #GtkWidgetClass.get_preferred_height_for_width(). Returning 205 * a perfect height for width that is larger than the screen area is 206 * inconsequential since after the layouting receives an allocation 207 * from a scrolled window it simply continues to drive the scrollbar 208 * values while more and more height is required for the row heights 209 * that are calculated in the background. 210 * 211 * # Rendering Areas 212 * 213 * Once area sizes have been aquired at least for the rows in the 214 * visible area of the layouting widget they can be rendered at 215 * #GtkWidgetClass.draw() time. 216 * 217 * A crude example of how to render all the rows at the root level 218 * runs as follows: 219 * 220 * |[<!-- language="C" --> 221 * GtkAllocation allocation; 222 * GdkRectangle cell_area = { 0, }; 223 * GtkTreeIter iter; 224 * gint minimum_width; 225 * gint natural_width; 226 * 227 * gtk_widget_get_allocation (widget, &allocation); 228 * cell_area.width = allocation.width; 229 * 230 * valid = gtk_tree_model_get_iter_first (model, &iter); 231 * while (valid) 232 * { 233 * cell_area.height = get_cached_height_for_row (&iter); 234 * 235 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); 236 * gtk_cell_area_render (area, context, widget, cr, 237 * &cell_area, &cell_area, state_flags, FALSE); 238 * 239 * cell_area.y += cell_area.height; 240 * 241 * valid = gtk_tree_model_iter_next (model, &iter); 242 * } 243 * ]| 244 * 245 * Note that the cached height in this example really depends on how 246 * the layouting widget works. The layouting widget might decide to 247 * give every row its minimum or natural height or, if the model content 248 * is expected to fit inside the layouting widget without scrolling, it 249 * would make sense to calculate the allocation for each row at 250 * #GtkWidget::size-allocate time using gtk_distribute_natural_allocation(). 251 * 252 * # Handling Events and Driving Keyboard Focus 253 * 254 * Passing events to the area is as simple as handling events on any 255 * normal widget and then passing them to the gtk_cell_area_event() 256 * API as they come in. Usually #GtkCellArea is only interested in 257 * button events, however some customized derived areas can be implemented 258 * who are interested in handling other events. Handling an event can 259 * trigger the #GtkCellArea::focus-changed signal to fire; as well as 260 * #GtkCellArea::add-editable in the case that an editable cell was 261 * clicked and needs to start editing. You can call 262 * gtk_cell_area_stop_editing() at any time to cancel any cell editing 263 * that is currently in progress. 264 * 265 * The #GtkCellArea drives keyboard focus from cell to cell in a way 266 * similar to #GtkWidget. For layouting widgets that support giving 267 * focus to cells it’s important to remember to pass %GTK_CELL_RENDERER_FOCUSED 268 * to the area functions for the row that has focus and to tell the 269 * area to paint the focus at render time. 270 * 271 * Layouting widgets that accept focus on cells should implement the 272 * #GtkWidgetClass.focus() virtual method. The layouting widget is always 273 * responsible for knowing where #GtkTreeModel rows are rendered inside 274 * the widget, so at #GtkWidgetClass.focus() time the layouting widget 275 * should use the #GtkCellArea methods to navigate focus inside the area 276 * and then observe the GtkDirectionType to pass the focus to adjacent 277 * rows and areas. 278 * 279 * A basic example of how the #GtkWidgetClass.focus() virtual method 280 * should be implemented: 281 * 282 * |[<!-- language="C" --> 283 * static gboolean 284 * foo_focus (GtkWidget *widget, 285 * GtkDirectionType direction) 286 * { 287 * Foo *foo = FOO (widget); 288 * FooPrivate *priv = foo->priv; 289 * gint focus_row; 290 * gboolean have_focus = FALSE; 291 * 292 * focus_row = priv->focus_row; 293 * 294 * if (!gtk_widget_has_focus (widget)) 295 * gtk_widget_grab_focus (widget); 296 * 297 * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row); 298 * while (valid) 299 * { 300 * gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE); 301 * 302 * if (gtk_cell_area_focus (priv->area, direction)) 303 * { 304 * priv->focus_row = focus_row; 305 * have_focus = TRUE; 306 * break; 307 * } 308 * else 309 * { 310 * if (direction == GTK_DIR_RIGHT || 311 * direction == GTK_DIR_LEFT) 312 * break; 313 * else if (direction == GTK_DIR_UP || 314 * direction == GTK_DIR_TAB_BACKWARD) 315 * { 316 * if (focus_row == 0) 317 * break; 318 * else 319 * { 320 * focus_row--; 321 * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row); 322 * } 323 * } 324 * else 325 * { 326 * if (focus_row == last_row) 327 * break; 328 * else 329 * { 330 * focus_row++; 331 * valid = gtk_tree_model_iter_next (priv->model, &iter); 332 * } 333 * } 334 * } 335 * } 336 * return have_focus; 337 * } 338 * ]| 339 * 340 * Note that the layouting widget is responsible for matching the 341 * GtkDirectionType values to the way it lays out its cells. 342 * 343 * # Cell Properties 344 * 345 * The #GtkCellArea introduces cell properties for #GtkCellRenderers 346 * in very much the same way that #GtkContainer introduces 347 * [child properties][child-properties] 348 * for #GtkWidgets. This provides some general interfaces for defining 349 * the relationship cell areas have with their cells. For instance in a 350 * #GtkCellAreaBox a cell might “expand” and receive extra space when 351 * the area is allocated more than its full natural request, or a cell 352 * might be configured to “align” with adjacent rows which were requested 353 * and rendered with the same #GtkCellAreaContext. 354 * 355 * Use gtk_cell_area_class_install_cell_property() to install cell 356 * properties for a cell area class and gtk_cell_area_class_find_cell_property() 357 * or gtk_cell_area_class_list_cell_properties() to get information about 358 * existing cell properties. 359 * 360 * To set the value of a cell property, use gtk_cell_area_cell_set_property(), 361 * gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain 362 * the value of a cell property, use gtk_cell_area_cell_get_property(), 363 * gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist(). 364 */ 365 public class CellArea : ObjectG, BuildableIF, CellLayoutIF 366 { 367 /** the main Gtk struct */ 368 protected GtkCellArea* gtkCellArea; 369 370 /** Get the main Gtk struct */ 371 public GtkCellArea* getCellAreaStruct(bool transferOwnership = false) 372 { 373 if (transferOwnership) 374 ownedRef = false; 375 return gtkCellArea; 376 } 377 378 /** the main Gtk struct as a void* */ 379 protected override void* getStruct() 380 { 381 return cast(void*)gtkCellArea; 382 } 383 384 protected override void setStruct(GObject* obj) 385 { 386 gtkCellArea = cast(GtkCellArea*)obj; 387 super.setStruct(obj); 388 } 389 390 /** 391 * Sets our main struct and passes it to the parent class. 392 */ 393 public this (GtkCellArea* gtkCellArea, bool ownedRef = false) 394 { 395 this.gtkCellArea = gtkCellArea; 396 super(cast(GObject*)gtkCellArea, ownedRef); 397 } 398 399 // add the Buildable capabilities 400 mixin BuildableT!(GtkCellArea); 401 402 // add the CellLayout capabilities 403 mixin CellLayoutT!(GtkCellArea); 404 405 406 /** */ 407 public static GType getType() 408 { 409 return gtk_cell_area_get_type(); 410 } 411 412 /** 413 * Activates @area, usually by activating the currently focused 414 * cell, however some subclasses which embed widgets in the area 415 * can also activate a widget if it currently has the focus. 416 * 417 * Params: 418 * context = the #GtkCellAreaContext in context with the current row data 419 * widget = the #GtkWidget that @area is rendering on 420 * cellArea = the size and location of @area relative to @widget’s allocation 421 * flags = the #GtkCellRendererState flags for @area for this row of data. 422 * editOnly = if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE 423 * will be activated. 424 * 425 * Returns: Whether @area was successfully activated. 426 * 427 * Since: 3.0 428 */ 429 public bool activate(CellAreaContext context, Widget widget, GdkRectangle* cellArea, GtkCellRendererState flags, bool editOnly) 430 { 431 return gtk_cell_area_activate(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), cellArea, flags, editOnly) != 0; 432 } 433 434 /** 435 * This is used by #GtkCellArea subclasses when handling events 436 * to activate cells, the base #GtkCellArea class activates cells 437 * for keyboard events for free in its own GtkCellArea->activate() 438 * implementation. 439 * 440 * Params: 441 * widget = the #GtkWidget that @area is rendering onto 442 * renderer = the #GtkCellRenderer in @area to activate 443 * event = the #GdkEvent for which cell activation should occur 444 * cellArea = the #GdkRectangle in @widget relative coordinates 445 * of @renderer for the current row. 446 * flags = the #GtkCellRendererState for @renderer 447 * 448 * Returns: whether cell activation was successful 449 * 450 * Since: 3.0 451 */ 452 public bool activateCell(Widget widget, CellRenderer renderer, Event event, GdkRectangle* cellArea, GtkCellRendererState flags) 453 { 454 return gtk_cell_area_activate_cell(gtkCellArea, (widget is null) ? null : widget.getWidgetStruct(), (renderer is null) ? null : renderer.getCellRendererStruct(), (event is null) ? null : event.getEventStruct(), cellArea, flags) != 0; 455 } 456 457 /** 458 * Adds @renderer to @area with the default child cell properties. 459 * 460 * Params: 461 * renderer = the #GtkCellRenderer to add to @area 462 * 463 * Since: 3.0 464 */ 465 public void add(CellRenderer renderer) 466 { 467 gtk_cell_area_add(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct()); 468 } 469 470 /** 471 * Adds @sibling to @renderer’s focusable area, focus will be drawn 472 * around @renderer and all of its siblings if @renderer can 473 * focus for a given row. 474 * 475 * Events handled by focus siblings can also activate the given 476 * focusable @renderer. 477 * 478 * Params: 479 * renderer = the #GtkCellRenderer expected to have focus 480 * sibling = the #GtkCellRenderer to add to @renderer’s focus area 481 * 482 * Since: 3.0 483 */ 484 public void addFocusSibling(CellRenderer renderer, CellRenderer sibling) 485 { 486 gtk_cell_area_add_focus_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), (sibling is null) ? null : sibling.getCellRendererStruct()); 487 } 488 489 /** 490 * Applies any connected attributes to the renderers in 491 * @area by pulling the values from @tree_model. 492 * 493 * Params: 494 * treeModel = the #GtkTreeModel to pull values from 495 * iter = the #GtkTreeIter in @tree_model to apply values for 496 * isExpander = whether @iter has children 497 * isExpanded = whether @iter is expanded in the view and 498 * children are visible 499 * 500 * Since: 3.0 501 */ 502 public void applyAttributes(TreeModelIF treeModel, TreeIter iter, bool isExpander, bool isExpanded) 503 { 504 gtk_cell_area_apply_attributes(gtkCellArea, (treeModel is null) ? null : treeModel.getTreeModelStruct(), (iter is null) ? null : iter.getTreeIterStruct(), isExpander, isExpanded); 505 } 506 507 /** 508 * Connects an @attribute to apply values from @column for the 509 * #GtkTreeModel in use. 510 * 511 * Params: 512 * renderer = the #GtkCellRenderer to connect an attribute for 513 * attribute = the attribute name 514 * column = the #GtkTreeModel column to fetch attribute values from 515 * 516 * Since: 3.0 517 */ 518 public void attributeConnect(CellRenderer renderer, string attribute, int column) 519 { 520 gtk_cell_area_attribute_connect(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(attribute), column); 521 } 522 523 /** 524 * Disconnects @attribute for the @renderer in @area so that 525 * attribute will no longer be updated with values from the 526 * model. 527 * 528 * Params: 529 * renderer = the #GtkCellRenderer to disconnect an attribute for 530 * attribute = the attribute name 531 * 532 * Since: 3.0 533 */ 534 public void attributeDisconnect(CellRenderer renderer, string attribute) 535 { 536 gtk_cell_area_attribute_disconnect(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(attribute)); 537 } 538 539 /** 540 * Returns the model column that an attribute has been mapped to, 541 * or -1 if the attribute is not mapped. 542 * 543 * Params: 544 * renderer = a #GtkCellRenderer 545 * attribute = an attribute on the renderer 546 * 547 * Returns: the model column, or -1 548 * 549 * Since: 3.14 550 */ 551 public int attributeGetColumn(CellRenderer renderer, string attribute) 552 { 553 return gtk_cell_area_attribute_get_column(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(attribute)); 554 } 555 556 /** 557 * Gets the value of a cell property for @renderer in @area. 558 * 559 * Params: 560 * renderer = a #GtkCellRenderer inside @area 561 * propertyName = the name of the property to get 562 * value = a location to return the value 563 * 564 * Since: 3.0 565 */ 566 public void cellGetProperty(CellRenderer renderer, string propertyName, Value value) 567 { 568 gtk_cell_area_cell_get_property(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(propertyName), (value is null) ? null : value.getValueStruct()); 569 } 570 571 /** 572 * Gets the values of one or more cell properties for @renderer in @area. 573 * 574 * Params: 575 * renderer = a #GtkCellRenderer inside @area 576 * firstPropertyName = the name of the first property to get 577 * varArgs = return location for the first property, followed 578 * optionally by more name/return location pairs, followed by %NULL 579 * 580 * Since: 3.0 581 */ 582 public void cellGetValist(CellRenderer renderer, string firstPropertyName, void* varArgs) 583 { 584 gtk_cell_area_cell_get_valist(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(firstPropertyName), varArgs); 585 } 586 587 /** 588 * Sets a cell property for @renderer in @area. 589 * 590 * Params: 591 * renderer = a #GtkCellRenderer inside @area 592 * propertyName = the name of the cell property to set 593 * value = the value to set the cell property to 594 * 595 * Since: 3.0 596 */ 597 public void cellSetProperty(CellRenderer renderer, string propertyName, Value value) 598 { 599 gtk_cell_area_cell_set_property(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(propertyName), (value is null) ? null : value.getValueStruct()); 600 } 601 602 /** 603 * Sets one or more cell properties for @renderer in @area. 604 * 605 * Params: 606 * renderer = a #GtkCellRenderer which inside @area 607 * firstPropertyName = the name of the first cell property to set 608 * varArgs = a %NULL-terminated list of property names and values, starting 609 * with @first_prop_name 610 * 611 * Since: 3.0 612 */ 613 public void cellSetValist(CellRenderer renderer, string firstPropertyName, void* varArgs) 614 { 615 gtk_cell_area_cell_set_valist(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(firstPropertyName), varArgs); 616 } 617 618 /** 619 * This is sometimes needed for cases where rows need to share 620 * alignments in one orientation but may be separately grouped 621 * in the opposing orientation. 622 * 623 * For instance, #GtkIconView creates all icons (rows) to have 624 * the same width and the cells theirin to have the same 625 * horizontal alignments. However each row of icons may have 626 * a separate collective height. #GtkIconView uses this to 627 * request the heights of each row based on a context which 628 * was already used to request all the row widths that are 629 * to be displayed. 630 * 631 * Params: 632 * context = the #GtkCellAreaContext to copy 633 * 634 * Returns: a newly created #GtkCellAreaContext copy of @context. 635 * 636 * Since: 3.0 637 */ 638 public CellAreaContext copyContext(CellAreaContext context) 639 { 640 auto p = gtk_cell_area_copy_context(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct()); 641 642 if(p is null) 643 { 644 return null; 645 } 646 647 return ObjectG.getDObject!(CellAreaContext)(cast(GtkCellAreaContext*) p, true); 648 } 649 650 /** 651 * Creates a #GtkCellAreaContext to be used with @area for 652 * all purposes. #GtkCellAreaContext stores geometry information 653 * for rows for which it was operated on, it is important to use 654 * the same context for the same row of data at all times (i.e. 655 * one should render and handle events with the same #GtkCellAreaContext 656 * which was used to request the size of those rows of data). 657 * 658 * Returns: a newly created #GtkCellAreaContext which can be used with @area. 659 * 660 * Since: 3.0 661 */ 662 public CellAreaContext createContext() 663 { 664 auto p = gtk_cell_area_create_context(gtkCellArea); 665 666 if(p is null) 667 { 668 return null; 669 } 670 671 return ObjectG.getDObject!(CellAreaContext)(cast(GtkCellAreaContext*) p, true); 672 } 673 674 /** 675 * Delegates event handling to a #GtkCellArea. 676 * 677 * Params: 678 * context = the #GtkCellAreaContext for this row of data. 679 * widget = the #GtkWidget that @area is rendering to 680 * event = the #GdkEvent to handle 681 * cellArea = the @widget relative coordinates for @area 682 * flags = the #GtkCellRendererState for @area in this row. 683 * 684 * Returns: %TRUE if the event was handled by @area. 685 * 686 * Since: 3.0 687 */ 688 public int event(CellAreaContext context, Widget widget, Event event, GdkRectangle* cellArea, GtkCellRendererState flags) 689 { 690 return gtk_cell_area_event(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), (event is null) ? null : event.getEventStruct(), cellArea, flags); 691 } 692 693 /** 694 * This should be called by the @area’s owning layout widget 695 * when focus is to be passed to @area, or moved within @area 696 * for a given @direction and row data. 697 * 698 * Implementing #GtkCellArea classes should implement this 699 * method to receive and navigate focus in its own way particular 700 * to how it lays out cells. 701 * 702 * Params: 703 * direction = the #GtkDirectionType 704 * 705 * Returns: %TRUE if focus remains inside @area as a result of this call. 706 * 707 * Since: 3.0 708 */ 709 public bool focus(GtkDirectionType direction) 710 { 711 return gtk_cell_area_focus(gtkCellArea, direction) != 0; 712 } 713 714 /** 715 * Calls @callback for every #GtkCellRenderer in @area. 716 * 717 * Params: 718 * callback = the #GtkCellCallback to call 719 * callbackData = user provided data pointer 720 * 721 * Since: 3.0 722 */ 723 public void foreac(GtkCellCallback callback, void* callbackData) 724 { 725 gtk_cell_area_foreach(gtkCellArea, callback, callbackData); 726 } 727 728 /** 729 * Calls @callback for every #GtkCellRenderer in @area with the 730 * allocated rectangle inside @cell_area. 731 * 732 * Params: 733 * context = the #GtkCellAreaContext for this row of data. 734 * widget = the #GtkWidget that @area is rendering to 735 * cellArea = the @widget relative coordinates and size for @area 736 * backgroundArea = the @widget relative coordinates of the background area 737 * callback = the #GtkCellAllocCallback to call 738 * callbackData = user provided data pointer 739 * 740 * Since: 3.0 741 */ 742 public void foreachAlloc(CellAreaContext context, Widget widget, GdkRectangle* cellArea, GdkRectangle* backgroundArea, GtkCellAllocCallback callback, void* callbackData) 743 { 744 gtk_cell_area_foreach_alloc(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), cellArea, backgroundArea, callback, callbackData); 745 } 746 747 /** 748 * Derives the allocation of @renderer inside @area if @area 749 * were to be renderered in @cell_area. 750 * 751 * Params: 752 * context = the #GtkCellAreaContext used to hold sizes for @area. 753 * widget = the #GtkWidget that @area is rendering on 754 * renderer = the #GtkCellRenderer to get the allocation for 755 * cellArea = the whole allocated area for @area in @widget 756 * for this row 757 * allocation = where to store the allocation for @renderer 758 * 759 * Since: 3.0 760 */ 761 public void getCellAllocation(CellAreaContext context, Widget widget, CellRenderer renderer, GdkRectangle* cellArea, out GdkRectangle allocation) 762 { 763 gtk_cell_area_get_cell_allocation(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), (renderer is null) ? null : renderer.getCellRendererStruct(), cellArea, &allocation); 764 } 765 766 /** 767 * Gets the #GtkCellRenderer at @x and @y coordinates inside @area and optionally 768 * returns the full cell allocation for it inside @cell_area. 769 * 770 * Params: 771 * context = the #GtkCellAreaContext used to hold sizes for @area. 772 * widget = the #GtkWidget that @area is rendering on 773 * cellArea = the whole allocated area for @area in @widget 774 * for this row 775 * x = the x position 776 * y = the y position 777 * allocArea = where to store the inner allocated area of the 778 * returned cell renderer, or %NULL. 779 * 780 * Returns: the #GtkCellRenderer at @x and @y. 781 * 782 * Since: 3.0 783 */ 784 public CellRenderer getCellAtPosition(CellAreaContext context, Widget widget, GdkRectangle* cellArea, int x, int y, out GdkRectangle allocArea) 785 { 786 auto p = gtk_cell_area_get_cell_at_position(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), cellArea, x, y, &allocArea); 787 788 if(p is null) 789 { 790 return null; 791 } 792 793 return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p); 794 } 795 796 /** 797 * Gets the current #GtkTreePath string for the currently 798 * applied #GtkTreeIter, this is implicitly updated when 799 * gtk_cell_area_apply_attributes() is called and can be 800 * used to interact with renderers from #GtkCellArea 801 * subclasses. 802 * 803 * Returns: The current #GtkTreePath string for the current 804 * attributes applied to @area. This string belongs to the area and 805 * should not be freed. 806 * 807 * Since: 3.0 808 */ 809 public string getCurrentPathString() 810 { 811 return Str.toString(gtk_cell_area_get_current_path_string(gtkCellArea)); 812 } 813 814 /** 815 * Gets the #GtkCellEditable widget currently used 816 * to edit the currently edited cell. 817 * 818 * Returns: The currently active #GtkCellEditable widget 819 * 820 * Since: 3.0 821 */ 822 public CellEditableIF getEditWidget() 823 { 824 auto p = gtk_cell_area_get_edit_widget(gtkCellArea); 825 826 if(p is null) 827 { 828 return null; 829 } 830 831 return ObjectG.getDObject!(CellEditableIF)(cast(GtkCellEditable*) p); 832 } 833 834 /** 835 * Gets the #GtkCellRenderer in @area that is currently 836 * being edited. 837 * 838 * Returns: The currently edited #GtkCellRenderer 839 * 840 * Since: 3.0 841 */ 842 public CellRenderer getEditedCell() 843 { 844 auto p = gtk_cell_area_get_edited_cell(gtkCellArea); 845 846 if(p is null) 847 { 848 return null; 849 } 850 851 return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p); 852 } 853 854 /** 855 * Retrieves the currently focused cell for @area 856 * 857 * Returns: the currently focused cell in @area. 858 * 859 * Since: 3.0 860 */ 861 public CellRenderer getFocusCell() 862 { 863 auto p = gtk_cell_area_get_focus_cell(gtkCellArea); 864 865 if(p is null) 866 { 867 return null; 868 } 869 870 return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p); 871 } 872 873 /** 874 * Gets the #GtkCellRenderer which is expected to be focusable 875 * for which @renderer is, or may be a sibling. 876 * 877 * This is handy for #GtkCellArea subclasses when handling events, 878 * after determining the renderer at the event location it can 879 * then chose to activate the focus cell for which the event 880 * cell may have been a sibling. 881 * 882 * Params: 883 * renderer = the #GtkCellRenderer 884 * 885 * Returns: the #GtkCellRenderer for which @renderer 886 * is a sibling, or %NULL. 887 * 888 * Since: 3.0 889 */ 890 public CellRenderer getFocusFromSibling(CellRenderer renderer) 891 { 892 auto p = gtk_cell_area_get_focus_from_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct()); 893 894 if(p is null) 895 { 896 return null; 897 } 898 899 return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p); 900 } 901 902 /** 903 * Gets the focus sibling cell renderers for @renderer. 904 * 905 * Params: 906 * renderer = the #GtkCellRenderer expected to have focus 907 * 908 * Returns: A #GList of #GtkCellRenderers. 909 * The returned list is internal and should not be freed. 910 * 911 * Since: 3.0 912 */ 913 public ListG getFocusSiblings(CellRenderer renderer) 914 { 915 auto p = gtk_cell_area_get_focus_siblings(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct()); 916 917 if(p is null) 918 { 919 return null; 920 } 921 922 return new ListG(cast(GList*) p); 923 } 924 925 /** 926 * Retrieves a cell area’s initial minimum and natural height. 927 * 928 * @area will store some geometrical information in @context along the way; 929 * when requesting sizes over an arbitrary number of rows, it’s not important 930 * to check the @minimum_height and @natural_height of this call but rather to 931 * consult gtk_cell_area_context_get_preferred_height() after a series of 932 * requests. 933 * 934 * Params: 935 * context = the #GtkCellAreaContext to perform this request with 936 * widget = the #GtkWidget where @area will be rendering 937 * minimumHeight = location to store the minimum height, or %NULL 938 * naturalHeight = location to store the natural height, or %NULL 939 * 940 * Since: 3.0 941 */ 942 public void getPreferredHeight(CellAreaContext context, Widget widget, out int minimumHeight, out int naturalHeight) 943 { 944 gtk_cell_area_get_preferred_height(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), &minimumHeight, &naturalHeight); 945 } 946 947 /** 948 * Retrieves a cell area’s minimum and natural height if it would be given 949 * the specified @width. 950 * 951 * @area stores some geometrical information in @context along the way 952 * while calling gtk_cell_area_get_preferred_width(). It’s important to 953 * perform a series of gtk_cell_area_get_preferred_width() requests with 954 * @context first and then call gtk_cell_area_get_preferred_height_for_width() 955 * on each cell area individually to get the height for width of each 956 * fully requested row. 957 * 958 * If at some point, the width of a single row changes, it should be 959 * requested with gtk_cell_area_get_preferred_width() again and then 960 * the full width of the requested rows checked again with 961 * gtk_cell_area_context_get_preferred_width(). 962 * 963 * Params: 964 * context = the #GtkCellAreaContext which has already been requested for widths. 965 * widget = the #GtkWidget where @area will be rendering 966 * width = the width for which to check the height of this area 967 * minimumHeight = location to store the minimum height, or %NULL 968 * naturalHeight = location to store the natural height, or %NULL 969 * 970 * Since: 3.0 971 */ 972 public void getPreferredHeightForWidth(CellAreaContext context, Widget widget, int width, out int minimumHeight, out int naturalHeight) 973 { 974 gtk_cell_area_get_preferred_height_for_width(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), width, &minimumHeight, &naturalHeight); 975 } 976 977 /** 978 * Retrieves a cell area’s initial minimum and natural width. 979 * 980 * @area will store some geometrical information in @context along the way; 981 * when requesting sizes over an arbitrary number of rows, it’s not important 982 * to check the @minimum_width and @natural_width of this call but rather to 983 * consult gtk_cell_area_context_get_preferred_width() after a series of 984 * requests. 985 * 986 * Params: 987 * context = the #GtkCellAreaContext to perform this request with 988 * widget = the #GtkWidget where @area will be rendering 989 * minimumWidth = location to store the minimum width, or %NULL 990 * naturalWidth = location to store the natural width, or %NULL 991 * 992 * Since: 3.0 993 */ 994 public void getPreferredWidth(CellAreaContext context, Widget widget, out int minimumWidth, out int naturalWidth) 995 { 996 gtk_cell_area_get_preferred_width(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), &minimumWidth, &naturalWidth); 997 } 998 999 /** 1000 * Retrieves a cell area’s minimum and natural width if it would be given 1001 * the specified @height. 1002 * 1003 * @area stores some geometrical information in @context along the way 1004 * while calling gtk_cell_area_get_preferred_height(). It’s important to 1005 * perform a series of gtk_cell_area_get_preferred_height() requests with 1006 * @context first and then call gtk_cell_area_get_preferred_width_for_height() 1007 * on each cell area individually to get the height for width of each 1008 * fully requested row. 1009 * 1010 * If at some point, the height of a single row changes, it should be 1011 * requested with gtk_cell_area_get_preferred_height() again and then 1012 * the full height of the requested rows checked again with 1013 * gtk_cell_area_context_get_preferred_height(). 1014 * 1015 * Params: 1016 * context = the #GtkCellAreaContext which has already been requested for widths. 1017 * widget = the #GtkWidget where @area will be rendering 1018 * height = the height for which to check the width of this area 1019 * minimumWidth = location to store the minimum width, or %NULL 1020 * naturalWidth = location to store the natural width, or %NULL 1021 * 1022 * Since: 3.0 1023 */ 1024 public void getPreferredWidthForHeight(CellAreaContext context, Widget widget, int height, out int minimumWidth, out int naturalWidth) 1025 { 1026 gtk_cell_area_get_preferred_width_for_height(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), height, &minimumWidth, &naturalWidth); 1027 } 1028 1029 /** 1030 * Gets whether the area prefers a height-for-width layout 1031 * or a width-for-height layout. 1032 * 1033 * Returns: The #GtkSizeRequestMode preferred by @area. 1034 * 1035 * Since: 3.0 1036 */ 1037 public GtkSizeRequestMode getRequestMode() 1038 { 1039 return gtk_cell_area_get_request_mode(gtkCellArea); 1040 } 1041 1042 /** 1043 * Checks if @area contains @renderer. 1044 * 1045 * Params: 1046 * renderer = the #GtkCellRenderer to check 1047 * 1048 * Returns: %TRUE if @renderer is in the @area. 1049 * 1050 * Since: 3.0 1051 */ 1052 public bool hasRenderer(CellRenderer renderer) 1053 { 1054 return gtk_cell_area_has_renderer(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct()) != 0; 1055 } 1056 1057 /** 1058 * This is a convenience function for #GtkCellArea implementations 1059 * to get the inner area where a given #GtkCellRenderer will be 1060 * rendered. It removes any padding previously added by gtk_cell_area_request_renderer(). 1061 * 1062 * Params: 1063 * widget = the #GtkWidget that @area is rendering onto 1064 * cellArea = the @widget relative coordinates where one of @area’s cells 1065 * is to be placed 1066 * innerArea = the return location for the inner cell area 1067 * 1068 * Since: 3.0 1069 */ 1070 public void innerCellArea(Widget widget, GdkRectangle* cellArea, out GdkRectangle innerArea) 1071 { 1072 gtk_cell_area_inner_cell_area(gtkCellArea, (widget is null) ? null : widget.getWidgetStruct(), cellArea, &innerArea); 1073 } 1074 1075 /** 1076 * Returns whether the area can do anything when activated, 1077 * after applying new attributes to @area. 1078 * 1079 * Returns: whether @area can do anything when activated. 1080 * 1081 * Since: 3.0 1082 */ 1083 public bool isActivatable() 1084 { 1085 return gtk_cell_area_is_activatable(gtkCellArea) != 0; 1086 } 1087 1088 /** 1089 * Returns whether @sibling is one of @renderer’s focus siblings 1090 * (see gtk_cell_area_add_focus_sibling()). 1091 * 1092 * Params: 1093 * renderer = the #GtkCellRenderer expected to have focus 1094 * sibling = the #GtkCellRenderer to check against @renderer’s sibling list 1095 * 1096 * Returns: %TRUE if @sibling is a focus sibling of @renderer 1097 * 1098 * Since: 3.0 1099 */ 1100 public bool isFocusSibling(CellRenderer renderer, CellRenderer sibling) 1101 { 1102 return gtk_cell_area_is_focus_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), (sibling is null) ? null : sibling.getCellRendererStruct()) != 0; 1103 } 1104 1105 /** 1106 * Removes @renderer from @area. 1107 * 1108 * Params: 1109 * renderer = the #GtkCellRenderer to remove from @area 1110 * 1111 * Since: 3.0 1112 */ 1113 public void remove(CellRenderer renderer) 1114 { 1115 gtk_cell_area_remove(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct()); 1116 } 1117 1118 /** 1119 * Removes @sibling from @renderer’s focus sibling list 1120 * (see gtk_cell_area_add_focus_sibling()). 1121 * 1122 * Params: 1123 * renderer = the #GtkCellRenderer expected to have focus 1124 * sibling = the #GtkCellRenderer to remove from @renderer’s focus area 1125 * 1126 * Since: 3.0 1127 */ 1128 public void removeFocusSibling(CellRenderer renderer, CellRenderer sibling) 1129 { 1130 gtk_cell_area_remove_focus_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), (sibling is null) ? null : sibling.getCellRendererStruct()); 1131 } 1132 1133 /** 1134 * Renders @area’s cells according to @area’s layout onto @widget at 1135 * the given coordinates. 1136 * 1137 * Params: 1138 * context = the #GtkCellAreaContext for this row of data. 1139 * widget = the #GtkWidget that @area is rendering to 1140 * cr = the #cairo_t to render with 1141 * backgroundArea = the @widget relative coordinates for @area’s background 1142 * cellArea = the @widget relative coordinates for @area 1143 * flags = the #GtkCellRendererState for @area in this row. 1144 * paintFocus = whether @area should paint focus on focused cells for focused rows or not. 1145 * 1146 * Since: 3.0 1147 */ 1148 public void render(CellAreaContext context, Widget widget, Context cr, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags, bool paintFocus) 1149 { 1150 gtk_cell_area_render(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), (cr is null) ? null : cr.getContextStruct(), backgroundArea, cellArea, flags, paintFocus); 1151 } 1152 1153 /** 1154 * This is a convenience function for #GtkCellArea implementations 1155 * to request size for cell renderers. It’s important to use this 1156 * function to request size and then use gtk_cell_area_inner_cell_area() 1157 * at render and event time since this function will add padding 1158 * around the cell for focus painting. 1159 * 1160 * Params: 1161 * renderer = the #GtkCellRenderer to request size for 1162 * orientation = the #GtkOrientation in which to request size 1163 * widget = the #GtkWidget that @area is rendering onto 1164 * forSize = the allocation contextual size to request for, or -1 if 1165 * the base request for the orientation is to be returned. 1166 * minimumSize = location to store the minimum size, or %NULL 1167 * naturalSize = location to store the natural size, or %NULL 1168 * 1169 * Since: 3.0 1170 */ 1171 public void requestRenderer(CellRenderer renderer, GtkOrientation orientation, Widget widget, int forSize, out int minimumSize, out int naturalSize) 1172 { 1173 gtk_cell_area_request_renderer(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), orientation, (widget is null) ? null : widget.getWidgetStruct(), forSize, &minimumSize, &naturalSize); 1174 } 1175 1176 /** 1177 * Explicitly sets the currently focused cell to @renderer. 1178 * 1179 * This is generally called by implementations of 1180 * #GtkCellAreaClass.focus() or #GtkCellAreaClass.event(), 1181 * however it can also be used to implement functions such 1182 * as gtk_tree_view_set_cursor_on_cell(). 1183 * 1184 * Params: 1185 * renderer = the #GtkCellRenderer to give focus to 1186 * 1187 * Since: 3.0 1188 */ 1189 public void setFocusCell(CellRenderer renderer) 1190 { 1191 gtk_cell_area_set_focus_cell(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct()); 1192 } 1193 1194 /** 1195 * Explicitly stops the editing of the currently edited cell. 1196 * 1197 * If @canceled is %TRUE, the currently edited cell renderer 1198 * will emit the ::editing-canceled signal, otherwise the 1199 * the ::editing-done signal will be emitted on the current 1200 * edit widget. 1201 * 1202 * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget(). 1203 * 1204 * Params: 1205 * canceled = whether editing was canceled. 1206 * 1207 * Since: 3.0 1208 */ 1209 public void stopEditing(bool canceled) 1210 { 1211 gtk_cell_area_stop_editing(gtkCellArea, canceled); 1212 } 1213 1214 protected class OnAddEditableDelegateWrapper 1215 { 1216 void delegate(CellRenderer, CellEditableIF, GdkRectangle*, string, CellArea) dlg; 1217 gulong handlerId; 1218 1219 this(void delegate(CellRenderer, CellEditableIF, GdkRectangle*, string, CellArea) dlg) 1220 { 1221 this.dlg = dlg; 1222 onAddEditableListeners ~= this; 1223 } 1224 1225 void remove(OnAddEditableDelegateWrapper source) 1226 { 1227 foreach(index, wrapper; onAddEditableListeners) 1228 { 1229 if (wrapper.handlerId == source.handlerId) 1230 { 1231 onAddEditableListeners[index] = null; 1232 onAddEditableListeners = std.algorithm.remove(onAddEditableListeners, index); 1233 break; 1234 } 1235 } 1236 } 1237 } 1238 OnAddEditableDelegateWrapper[] onAddEditableListeners; 1239 1240 /** 1241 * Indicates that editing has started on @renderer and that @editable 1242 * should be added to the owning cell-layouting widget at @cell_area. 1243 * 1244 * Params: 1245 * renderer = the #GtkCellRenderer that started the edited 1246 * editable = the #GtkCellEditable widget to add 1247 * cellArea = the #GtkWidget relative #GdkRectangle coordinates 1248 * where @editable should be added 1249 * path = the #GtkTreePath string this edit was initiated for 1250 * 1251 * Since: 3.0 1252 */ 1253 gulong addOnAddEditable(void delegate(CellRenderer, CellEditableIF, GdkRectangle*, string, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1254 { 1255 auto wrapper = new OnAddEditableDelegateWrapper(dlg); 1256 wrapper.handlerId = Signals.connectData( 1257 this, 1258 "add-editable", 1259 cast(GCallback)&callBackAddEditable, 1260 cast(void*)wrapper, 1261 cast(GClosureNotify)&callBackAddEditableDestroy, 1262 connectFlags); 1263 return wrapper.handlerId; 1264 } 1265 1266 extern(C) static void callBackAddEditable(GtkCellArea* cellareaStruct, GtkCellRenderer* renderer, GtkCellEditable* editable, GdkRectangle* cellArea, char* path, OnAddEditableDelegateWrapper wrapper) 1267 { 1268 wrapper.dlg(ObjectG.getDObject!(CellRenderer)(renderer), ObjectG.getDObject!(CellEditableIF)(editable), cellArea, Str.toString(path), wrapper.outer); 1269 } 1270 1271 extern(C) static void callBackAddEditableDestroy(OnAddEditableDelegateWrapper wrapper, GClosure* closure) 1272 { 1273 wrapper.remove(wrapper); 1274 } 1275 1276 protected class OnApplyAttributesDelegateWrapper 1277 { 1278 void delegate(TreeModelIF, TreeIter, bool, bool, CellArea) dlg; 1279 gulong handlerId; 1280 1281 this(void delegate(TreeModelIF, TreeIter, bool, bool, CellArea) dlg) 1282 { 1283 this.dlg = dlg; 1284 onApplyAttributesListeners ~= this; 1285 } 1286 1287 void remove(OnApplyAttributesDelegateWrapper source) 1288 { 1289 foreach(index, wrapper; onApplyAttributesListeners) 1290 { 1291 if (wrapper.handlerId == source.handlerId) 1292 { 1293 onApplyAttributesListeners[index] = null; 1294 onApplyAttributesListeners = std.algorithm.remove(onApplyAttributesListeners, index); 1295 break; 1296 } 1297 } 1298 } 1299 } 1300 OnApplyAttributesDelegateWrapper[] onApplyAttributesListeners; 1301 1302 /** 1303 * This signal is emitted whenever applying attributes to @area from @model 1304 * 1305 * Params: 1306 * model = the #GtkTreeModel to apply the attributes from 1307 * iter = the #GtkTreeIter indicating which row to apply the attributes of 1308 * isExpander = whether the view shows children for this row 1309 * isExpanded = whether the view is currently showing the children of this row 1310 * 1311 * Since: 3.0 1312 */ 1313 gulong addOnApplyAttributes(void delegate(TreeModelIF, TreeIter, bool, bool, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1314 { 1315 auto wrapper = new OnApplyAttributesDelegateWrapper(dlg); 1316 wrapper.handlerId = Signals.connectData( 1317 this, 1318 "apply-attributes", 1319 cast(GCallback)&callBackApplyAttributes, 1320 cast(void*)wrapper, 1321 cast(GClosureNotify)&callBackApplyAttributesDestroy, 1322 connectFlags); 1323 return wrapper.handlerId; 1324 } 1325 1326 extern(C) static void callBackApplyAttributes(GtkCellArea* cellareaStruct, GtkTreeModel* model, GtkTreeIter* iter, bool isExpander, bool isExpanded, OnApplyAttributesDelegateWrapper wrapper) 1327 { 1328 wrapper.dlg(ObjectG.getDObject!(TreeModelIF)(model), ObjectG.getDObject!(TreeIter)(iter), isExpander, isExpanded, wrapper.outer); 1329 } 1330 1331 extern(C) static void callBackApplyAttributesDestroy(OnApplyAttributesDelegateWrapper wrapper, GClosure* closure) 1332 { 1333 wrapper.remove(wrapper); 1334 } 1335 1336 protected class OnFocusChangedDelegateWrapper 1337 { 1338 void delegate(CellRenderer, string, CellArea) dlg; 1339 gulong handlerId; 1340 1341 this(void delegate(CellRenderer, string, CellArea) dlg) 1342 { 1343 this.dlg = dlg; 1344 onFocusChangedListeners ~= this; 1345 } 1346 1347 void remove(OnFocusChangedDelegateWrapper source) 1348 { 1349 foreach(index, wrapper; onFocusChangedListeners) 1350 { 1351 if (wrapper.handlerId == source.handlerId) 1352 { 1353 onFocusChangedListeners[index] = null; 1354 onFocusChangedListeners = std.algorithm.remove(onFocusChangedListeners, index); 1355 break; 1356 } 1357 } 1358 } 1359 } 1360 OnFocusChangedDelegateWrapper[] onFocusChangedListeners; 1361 1362 /** 1363 * Indicates that focus changed on this @area. This signal 1364 * is emitted either as a result of focus handling or event 1365 * handling. 1366 * 1367 * It's possible that the signal is emitted even if the 1368 * currently focused renderer did not change, this is 1369 * because focus may change to the same renderer in the 1370 * same cell area for a different row of data. 1371 * 1372 * Params: 1373 * renderer = the #GtkCellRenderer that has focus 1374 * path = the current #GtkTreePath string set for @area 1375 * 1376 * Since: 3.0 1377 */ 1378 gulong addOnFocusChanged(void delegate(CellRenderer, string, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1379 { 1380 auto wrapper = new OnFocusChangedDelegateWrapper(dlg); 1381 wrapper.handlerId = Signals.connectData( 1382 this, 1383 "focus-changed", 1384 cast(GCallback)&callBackFocusChanged, 1385 cast(void*)wrapper, 1386 cast(GClosureNotify)&callBackFocusChangedDestroy, 1387 connectFlags); 1388 return wrapper.handlerId; 1389 } 1390 1391 extern(C) static void callBackFocusChanged(GtkCellArea* cellareaStruct, GtkCellRenderer* renderer, char* path, OnFocusChangedDelegateWrapper wrapper) 1392 { 1393 wrapper.dlg(ObjectG.getDObject!(CellRenderer)(renderer), Str.toString(path), wrapper.outer); 1394 } 1395 1396 extern(C) static void callBackFocusChangedDestroy(OnFocusChangedDelegateWrapper wrapper, GClosure* closure) 1397 { 1398 wrapper.remove(wrapper); 1399 } 1400 1401 protected class OnRemoveEditableDelegateWrapper 1402 { 1403 void delegate(CellRenderer, CellEditableIF, CellArea) dlg; 1404 gulong handlerId; 1405 1406 this(void delegate(CellRenderer, CellEditableIF, CellArea) dlg) 1407 { 1408 this.dlg = dlg; 1409 onRemoveEditableListeners ~= this; 1410 } 1411 1412 void remove(OnRemoveEditableDelegateWrapper source) 1413 { 1414 foreach(index, wrapper; onRemoveEditableListeners) 1415 { 1416 if (wrapper.handlerId == source.handlerId) 1417 { 1418 onRemoveEditableListeners[index] = null; 1419 onRemoveEditableListeners = std.algorithm.remove(onRemoveEditableListeners, index); 1420 break; 1421 } 1422 } 1423 } 1424 } 1425 OnRemoveEditableDelegateWrapper[] onRemoveEditableListeners; 1426 1427 /** 1428 * Indicates that editing finished on @renderer and that @editable 1429 * should be removed from the owning cell-layouting widget. 1430 * 1431 * Params: 1432 * renderer = the #GtkCellRenderer that finished editeding 1433 * editable = the #GtkCellEditable widget to remove 1434 * 1435 * Since: 3.0 1436 */ 1437 gulong addOnRemoveEditable(void delegate(CellRenderer, CellEditableIF, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 1438 { 1439 auto wrapper = new OnRemoveEditableDelegateWrapper(dlg); 1440 wrapper.handlerId = Signals.connectData( 1441 this, 1442 "remove-editable", 1443 cast(GCallback)&callBackRemoveEditable, 1444 cast(void*)wrapper, 1445 cast(GClosureNotify)&callBackRemoveEditableDestroy, 1446 connectFlags); 1447 return wrapper.handlerId; 1448 } 1449 1450 extern(C) static void callBackRemoveEditable(GtkCellArea* cellareaStruct, GtkCellRenderer* renderer, GtkCellEditable* editable, OnRemoveEditableDelegateWrapper wrapper) 1451 { 1452 wrapper.dlg(ObjectG.getDObject!(CellRenderer)(renderer), ObjectG.getDObject!(CellEditableIF)(editable), wrapper.outer); 1453 } 1454 1455 extern(C) static void callBackRemoveEditableDestroy(OnRemoveEditableDelegateWrapper wrapper, GClosure* closure) 1456 { 1457 wrapper.remove(wrapper); 1458 } 1459 }