AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
2da234d70d
gtk2/gtk/gtkcellarea.c

3689 lines
127 KiB
C
Raw Normal View History

Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
/* gtkcellarea.c
*
* Copyright (C) 2010 Openismus GmbH
*
* Authors:
* Tristan Van Berkom <tristanvb@openismus.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
*/
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
/**
* SECTION:gtkcellarea
No links in title, please
2010-12-17 19:58:21 +00:00
* @Short_Description: An abstract class for laying out GtkCellRenderers
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* @Title: GtkCellArea
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* The #GtkCellArea is an abstract class for #GtkCellLayout widgets
* (also referred to as "layouting widgets") to interface with an
* arbitrary number of #GtkCellRenderers and interact with the user
* for a given #GtkTreeModel row.
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* The cell area handles events, focus navigation, drawing and
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* size requests and allocations for a given row of data.
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* Usually users dont have to interact with the #GtkCellArea directly
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* unless they are implementing a cell-layouting widget themselves.
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
* # Requesting area sizes
*
docs: Use markup for links
2014-02-07 02:07:03 +00:00
* As outlined in
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* [GtkWidget’s geometry management section][geometry-management],
docs: Use markup for links
2014-02-07 02:07:03 +00:00
* GTK+ uses a height-for-width
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* geometry management system to compute the sizes of widgets and user
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* interfaces. #GtkCellArea uses the same semantics to calculate the
* size of an area for an arbitrary number of #GtkTreeModel rows.
*
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* When requesting the size of a cell area one needs to calculate
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* the size for a handful of rows, and this will be done differently by
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* different layouting widgets. For instance a #GtkTreeViewColumn
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* always lines up the areas from top to bottom while a #GtkIconView
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* on the other hand might enforce that all areas received the same
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* width and wrap the areas around, requesting height for more cell
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* areas when allocated less width.
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* It’s also important for areas to maintain some cell
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* alignments with areas rendered for adjacent rows (cells can
docs: use proper quotes
2014-02-05 18:07:34 +00:00
* appear “columnized” inside an area even when the size of
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* cells are different in each row). For this reason the #GtkCellArea
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* uses a #GtkCellAreaContext object to store the alignments
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* and sizes along the way (as well as the overall largest minimum
* and natural size for all the rows which have been calculated
* with the said context).
*
* The #GtkCellAreaContext is an opaque object specific to the
* #GtkCellArea which created it (see gtk_cell_area_create_context()).
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* The owning cell-layouting widget can create as many contexts as
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* it wishes to calculate sizes of rows which should receive the
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* same size in at least one orientation (horizontally or vertically),
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* However, it’s important that the same #GtkCellAreaContext which
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* was used to request the sizes for a given #GtkTreeModel row be
* used when rendering or processing events for that row.
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*
* In order to request the width of all the rows at the root level
* of a #GtkTreeModel one would do the following:
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* |[<!-- language="C" -->
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* GtkTreeIter iter;
* gint minimum_width;
* gint natural_width;
*
* valid = gtk_tree_model_get_iter_first (model, &iter);
* while (valid)
* {
* gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
* gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
*
* valid = gtk_tree_model_iter_next (model, &iter);
* }
* gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* ]|
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Note that in this example it’s not important to observe the
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* returned minimum and natural width of the area for each row
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* unless the cell-layouting object is actually interested in the
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* widths of individual rows. The overall width is however stored
* in the accompanying #GtkCellAreaContext object and can be consulted
* at any time.
*
* This can be useful since #GtkCellLayout widgets usually have to
* support requesting and rendering rows in treemodels with an
* exceedingly large amount of rows. The #GtkCellLayout widget in
* that case would calculate the required width of the rows in an
* idle or timeout source (see g_timeout_add()) and when the widget
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* is requested its actual width in #GtkWidgetClass.get_preferred_width()
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* it can simply consult the width accumulated so far in the
* #GtkCellAreaContext object.
*
* A simple example where rows are rendered from top to bottom and
* take up the full width of the layouting widget would look like:
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* |[<!-- language="C" -->
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* static void
* foo_get_preferred_width (GtkWidget *widget,
* gint *minimum_size,
* gint *natural_size)
* {
* Foo *foo = FOO (widget);
* FooPrivate *priv = foo->priv;
*
* foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo);
*
* gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
* }
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* ]|
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* In the above example the Foo widget has to make sure that some
* row sizes have been calculated (the amount of rows that Foo judged
* was appropriate to request space for in a single timeout iteration)
* before simply returning the amount of space required by the area via
* the #GtkCellAreaContext.
*
* Requesting the height for width (or width for height) of an area is
* a similar task except in this case the #GtkCellAreaContext does not
* store the data (actually, it does not know how much space the layouting
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* widget plans to allocate it for every row. It’s up to the layouting
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* widget to render each row of data with the appropriate height and
* width which was requested by the #GtkCellArea).
*
* In order to request the height for width of all the rows at the
* root level of a #GtkTreeModel one would do the following:
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* |[<!-- language="C" -->
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* GtkTreeIter iter;
* gint minimum_height;
* gint natural_height;
* gint full_minimum_height = 0;
* gint full_natural_height = 0;
*
* valid = gtk_tree_model_get_iter_first (model, &iter);
* while (valid)
* {
* gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* gtk_cell_area_get_preferred_height_for_width (area, context, widget,
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* width, &minimum_height, &natural_height);
*
* if (width_is_for_allocation)
* cache_row_height (&iter, minimum_height, natural_height);
*
* full_minimum_height += minimum_height;
* full_natural_height += natural_height;
*
* valid = gtk_tree_model_iter_next (model, &iter);
* }
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* ]|
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* Note that in the above example we would need to cache the heights
* returned for each row so that we would know what sizes to render the
* areas for each row. However we would only want to really cache the
* heights if the request is intended for the layouting widgets real
* allocation.
*
* In some cases the layouting widget is requested the height for an
* arbitrary for_width, this is a special case for layouting widgets
* who need to request size for tens of thousands of rows. For this
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* case it’s only important that the layouting widget calculate
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* one reasonably sized chunk of rows and return that height
* synchronously. The reasoning here is that any layouting widget is
* at least capable of synchronously calculating enough height to fill
* the screen height (or scrolled window height) in response to a single
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* call to #GtkWidgetClass.get_preferred_height_for_width(). Returning
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* a perfect height for width that is larger than the screen area is
* inconsequential since after the layouting receives an allocation
Fix a typo in the the comments https://bugzilla.gnome.org/show_bug.cgi?id=682724
2012-08-26 14:52:08 +00:00
* from a scrolled window it simply continues to drive the scrollbar
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* values while more and more height is required for the row heights
* that are calculated in the background.
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
* # Rendering Areas
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* Once area sizes have been aquired at least for the rows in the
* visible area of the layouting widget they can be rendered at
* #GtkWidgetClass.draw() time.
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* A crude example of how to render all the rows at the root level
* runs as follows:
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* |[<!-- language="C" -->
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* GtkAllocation allocation;
* GdkRectangle cell_area = { 0, };
* GtkTreeIter iter;
* gint minimum_width;
* gint natural_width;
*
* gtk_widget_get_allocation (widget, &allocation);
* cell_area.width = allocation.width;
*
* valid = gtk_tree_model_get_iter_first (model, &iter);
* while (valid)
* {
* cell_area.height = get_cached_height_for_row (&iter);
*
* gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* gtk_cell_area_render (area, context, widget, cr,
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* &cell_area, &cell_area, state_flags, FALSE);
*
* cell_area.y += cell_area.height;
*
* valid = gtk_tree_model_iter_next (model, &iter);
* }
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* ]|
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* Note that the cached height in this example really depends on how
* the layouting widget works. The layouting widget might decide to
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* give every row its minimum or natural height or, if the model content
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* is expected to fit inside the layouting widget without scrolling, it
* would make sense to calculate the allocation for each row at
More documentation fixes
2011-01-06 14:06:24 +00:00
* #GtkWidget::size-allocate time using gtk_distribute_natural_allocation().
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
*
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
* # Handling Events and Driving Keyboard Focus
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* Passing events to the area is as simple as handling events on any
* normal widget and then passing them to the gtk_cell_area_event()
* API as they come in. Usually #GtkCellArea is only interested in
* button events, however some customized derived areas can be implemented
* who are interested in handling other events. Handling an event can
* trigger the #GtkCellArea::focus-changed signal to fire; as well as
* #GtkCellArea::add-editable in the case that an editable cell was
* clicked and needs to start editing. You can call
Added "Cell Properties" section to the GtkCellArea documentation.
2010-12-04 06:02:53 +00:00
* gtk_cell_area_stop_editing() at any time to cancel any cell editing
* that is currently in progress.
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* The #GtkCellArea drives keyboard focus from cell to cell in a way
* similar to #GtkWidget. For layouting widgets that support giving
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* focus to cells it’s important to remember to pass %GTK_CELL_RENDERER_FOCUSED
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* to the area functions for the row that has focus and to tell the
* area to paint the focus at render time.
*
* Layouting widgets that accept focus on cells should implement the
* #GtkWidgetClass.focus() virtual method. The layouting widget is always
* responsible for knowing where #GtkTreeModel rows are rendered inside
* the widget, so at #GtkWidgetClass.focus() time the layouting widget
* should use the #GtkCellArea methods to navigate focus inside the area
* and then observe the GtkDirectionType to pass the focus to adjacent
* rows and areas.
*
* A basic example of how the #GtkWidgetClass.focus() virtual method
* should be implemented:
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* |[<!-- language="C" -->
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* static gboolean
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* foo_focus (GtkWidget *widget,
* GtkDirectionType direction)
* {
* Foo *foo = FOO (widget);
* FooPrivate *priv = foo->priv;
* gint focus_row;
* gboolean have_focus = FALSE;
*
* focus_row = priv->focus_row;
*
* if (!gtk_widget_has_focus (widget))
* gtk_widget_grab_focus (widget);
*
* valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
* while (valid)
* {
* gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
*
* if (gtk_cell_area_focus (priv->area, direction))
* {
* priv->focus_row = focus_row;
* have_focus = TRUE;
* break;
* }
* else
* {
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* if (direction == GTK_DIR_RIGHT ||
* direction == GTK_DIR_LEFT)
* break;
* else if (direction == GTK_DIR_UP ||
* direction == GTK_DIR_TAB_BACKWARD)
* {
* if (focus_row == 0)
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* break;
* else
* {
* focus_row--;
* valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
* }
* }
* else
* {
* if (focus_row == last_row)
Added "Cell Properties" section to the GtkCellArea documentation.
2010-12-04 06:02:53 +00:00
* break;
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
* else
* {
* focus_row++;
* valid = gtk_tree_model_iter_next (priv->model, &iter);
* }
* }
* }
* }
* return have_focus;
* }
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
* ]|
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* Note that the layouting widget is responsible for matching the
* GtkDirectionType values to the way it lays out its cells.
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
*
docs: Use "#" for refsect2 instead of ##
2014-02-05 02:00:58 +00:00
* # Cell Properties
docs: Convert to markdown Specifically, switch to using markdown syntax for sections.
2014-02-02 05:29:00 +00:00
*
* The #GtkCellArea introduces cell properties for #GtkCellRenderers
* in very much the same way that #GtkContainer introduces
docs: Use markup for links
2014-02-07 02:07:03 +00:00
* [child properties][child-properties]
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* for #GtkWidgets. This provides some general interfaces for defining
* the relationship cell areas have with their cells. For instance in a
docs: use proper quotes
2014-02-05 18:07:34 +00:00
* #GtkCellAreaBox a cell might “expand” and receive extra space when
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* the area is allocated more than its full natural request, or a cell
docs: use proper quotes
2014-02-05 18:07:34 +00:00
* might be configured to “align” with adjacent rows which were requested
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* and rendered with the same #GtkCellAreaContext.
*
* Use gtk_cell_area_class_install_cell_property() to install cell
* properties for a cell area class and gtk_cell_area_class_find_cell_property()
* or gtk_cell_area_class_list_cell_properties() to get information about
* existing cell properties.
Added "Cell Properties" section to the GtkCellArea documentation.
2010-12-04 06:02:53 +00:00
*
* To set the value of a cell property, use gtk_cell_area_cell_set_property(),
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain
* the value of a cell property, use gtk_cell_area_cell_get_property(),
* gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist().
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
#include "config.h"
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
#include "gtkintl.h"
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
#include "gtkcelllayout.h"
#include "gtkcellarea.h"
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
#include "gtkcellareacontext.h"
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
#include "gtkmarshalers.h"
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
#include "gtkprivate.h"
stylecontext: Split render functions out into gtkrender.[ch]
2014-06-15 15:57:59 +00:00
#include "gtkrender.h"
cellview: Implement snapshot() This also adds gtk_cell_area_snapshot().
2016-12-19 15:34:25 +00:00
#include "gtksnapshot.h"
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
#include <gobject/gvaluecollector.h>
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
/* GObjectClass */
static void gtk_cell_area_dispose (GObject *object);
static void gtk_cell_area_finalize (GObject *object);
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
static void gtk_cell_area_set_property (GObject *object,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
guint prop_id,
const GValue *value,
GParamSpec *pspec);
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
static void gtk_cell_area_get_property (GObject *object,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
guint prop_id,
GValue *value,
GParamSpec *pspec);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
/* GtkCellAreaClass */
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
static void gtk_cell_area_real_add (GtkCellArea *area,
GtkCellRenderer *renderer);
static void gtk_cell_area_real_remove (GtkCellArea *area,
GtkCellRenderer *renderer);
static void gtk_cell_area_real_foreach (GtkCellArea *area,
GtkCellCallback callback,
gpointer callback_data);
static void gtk_cell_area_real_foreach_alloc (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
const GdkRectangle *background_area,
GtkCellAllocCallback callback,
gpointer callback_data);
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
static gint gtk_cell_area_real_event (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
GdkEvent *event,
const GdkRectangle *cell_area,
GtkCellRendererState flags);
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
static void gtk_cell_area_real_snapshot (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
GtkSnapshot *snapshot,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags,
gboolean paint_focus);
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
static void gtk_cell_area_real_apply_attributes (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gboolean is_expander,
gboolean is_expanded);
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
static GtkCellAreaContext *gtk_cell_area_real_create_context (GtkCellArea *area);
static GtkCellAreaContext *gtk_cell_area_real_copy_context (GtkCellArea *area,
GtkCellAreaContext *context);
static GtkSizeRequestMode gtk_cell_area_real_get_request_mode (GtkCellArea *area);
static void gtk_cell_area_real_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_width,
gint *natural_width);
static void gtk_cell_area_real_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_height,
gint *natural_height);
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
static void gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
gint width,
gint *minimum_height,
gint *natural_height);
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
static void gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
gint height,
gint *minimum_width,
gint *natural_width);
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
static gboolean gtk_cell_area_real_is_activatable (GtkCellArea *area);
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
static gboolean gtk_cell_area_real_activate (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
GtkCellRendererState flags,
gboolean edit_only);
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
static gboolean gtk_cell_area_real_focus (GtkCellArea *area,
GtkDirectionType direction);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
/* GtkCellLayoutIface */
static void gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface);
static void gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
gboolean expand);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
static void gtk_cell_area_clear (GtkCellLayout *cell_layout);
static void gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *attribute,
gint column);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
static void gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *cell,
GtkCellLayoutDataFunc func,
gpointer func_data,
GDestroyNotify destroy);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
static void gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
static void gtk_cell_area_reorder (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *cell,
gint position);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
static GList *gtk_cell_area_get_cells (GtkCellLayout *cell_layout);
Make GtkCellArea independantly GtkBuildable. Simply use the GtkCellLayoutIface hooks for this.
2010-12-14 06:52:40 +00:00
static GtkCellArea *gtk_cell_area_get_area (GtkCellLayout *cell_layout);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
Make GtkCellArea independantly GtkBuildable. Simply use the GtkCellLayoutIface hooks for this.
2010-12-14 06:52:40 +00:00
/* GtkBuildableIface */
static void gtk_cell_area_buildable_init (GtkBuildableIface *iface);
static void gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkBuilder *builder,
GObject *child,
const gchar *tagname,
gpointer *data);
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
/* Used in foreach loop to check if a child renderer is present */
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
typedef struct {
GtkCellRenderer *renderer;
gboolean has_renderer;
} HasRendererCheck;
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
/* Used in foreach loop to get a cell's allocation */
typedef struct {
GtkCellRenderer *renderer;
GdkRectangle allocation;
} RendererAllocationData;
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
/* Used in foreach loop to render cells */
typedef struct {
GtkCellArea *area;
GtkWidget *widget;
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
GtkSnapshot *snapshot;
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
GdkRectangle focus_rect;
GtkCellRendererState render_flags;
guint paint_focus : 1;
guint focus_all : 1;
guint first_focus : 1;
} CellRenderData;
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
/* Used in foreach loop to get a cell by position */
typedef struct {
gint x;
gint y;
GtkCellRenderer *renderer;
GdkRectangle cell_area;
} CellByPositionData;
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
/* Attribute/Cell metadata */
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
typedef struct {
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
const gchar *attribute;
gint column;
} CellAttribute;
typedef struct {
Removed cell margin apis and now deal with "focus-line-width".
2010-11-23 07:26:46 +00:00
GSList *attributes;
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
GtkCellLayoutDataFunc func;
gpointer data;
GDestroyNotify destroy;
Fixed gtk_cell_layout_set_cell_data_func() to pass the correct layout object Added _gtk_cell_area_set_cell_data_func_with_proxy() to be called by gtk_cell_layout_set_cell_data_func() when the layouting object itself is not the underlying cell area.
2010-12-20 10:37:30 +00:00
GtkCellLayout *proxy;
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
} CellInfo;
static CellInfo *cell_info_new (GtkCellLayoutDataFunc func,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gpointer data,
GDestroyNotify destroy);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
static void cell_info_free (CellInfo *info);
static CellAttribute *cell_attribute_new (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const gchar *attribute,
gint column);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
static void cell_attribute_free (CellAttribute *attribute);
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
static gint cell_attribute_find (CellAttribute *cell_attribute,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const gchar *attribute);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/* Internal functions/signal emissions */
static void gtk_cell_area_add_editable (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellEditable *editable,
const GdkRectangle *cell_area);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
static void gtk_cell_area_remove_editable (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellEditable *editable);
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
static void gtk_cell_area_set_edit_widget (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellEditable *editable);
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
static void gtk_cell_area_set_edited_cell (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
/* Struct to pass data along while looping over
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
* cell renderers to apply attributes
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
*/
typedef struct {
GtkCellArea *area;
GtkTreeModel *model;
GtkTreeIter *iter;
Extended gtk_cell_area_apply_attributes() to account for expander/expanded cells The state of expanded cells must come from the view, since these states can vary across views accessing the same model (also "finished up" the applying of attributes code).
2010-11-02 09:01:03 +00:00
gboolean is_expander;
gboolean is_expanded;
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
} AttributeData;
struct _GtkCellAreaPrivate
{
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
/* The GtkCellArea bookkeeps any connected
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
* attributes in this hash table.
*/
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
GHashTable *cell_info;
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/* Current path is saved as a side-effect
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* of gtk_cell_area_apply_attributes()
*/
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
gchar *current_path;
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
/* Current cell being edited and editable widget used */
GtkCellEditable *edit_widget;
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
GtkCellRenderer *edited_cell;
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
/* Signal connections to the editable widget */
gulong remove_widget_id;
/* Currently focused cell */
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
GtkCellRenderer *focus_cell;
Distribute portions of GtkCellArea:render() background_area argument to cells Also added gtk_cell_area_get/set_style_detail() to set the string to be used by the area in gtk_paint_* functions.
2010-11-12 05:06:00 +00:00
/* Tracking which cells are focus siblings of focusable cells */
GHashTable *focus_siblings;
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
};
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
enum {
PROP_0,
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
PROP_FOCUS_CELL,
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
PROP_EDITED_CELL,
PROP_EDIT_WIDGET
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
};
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
enum {
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
SIGNAL_APPLY_ATTRIBUTES,
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
SIGNAL_ADD_EDITABLE,
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
SIGNAL_REMOVE_EDITABLE,
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
SIGNAL_FOCUS_CHANGED,
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
LAST_SIGNAL
};
/* Keep the paramspec pool internal, no need to deliver notifications
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* on cells. at least no perceived need for now
*/
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
static GParamSpecPool *cell_property_pool = NULL;
static guint cell_area_signals[LAST_SIGNAL] = { 0 };
#define PARAM_SPEC_PARAM_ID(pspec) ((pspec)->param_id)
#define PARAM_SPEC_SET_PARAM_ID(pspec, id) ((pspec)->param_id = (id))
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkCellArea, gtk_cell_area, G_TYPE_INITIALLY_UNOWNED,
gtk: Use new macros for defining private data https://bugzilla.gnome.org/show_bug.cgi?id=702996
2013-06-27 19:02:52 +00:00
G_ADD_PRIVATE (GtkCellArea)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
gtk_cell_area_cell_layout_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_cell_area_buildable_init))
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
static void
gtk_cell_area_init (GtkCellArea *area)
{
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
GtkCellAreaPrivate *priv;
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
gtk: Use new macros for defining private data https://bugzilla.gnome.org/show_bug.cgi?id=702996
2013-06-27 19:02:52 +00:00
area->priv = gtk_cell_area_get_instance_private (area);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
priv = area->priv;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
priv->cell_info = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify)cell_info_free);
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
priv->focus_siblings = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify)g_list_free);
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
priv->focus_cell = NULL;
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
priv->edited_cell = NULL;
priv->edit_widget = NULL;
priv->remove_widget_id = 0;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
}
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
static void
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
gtk_cell_area_class_init (GtkCellAreaClass *class)
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
{
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
GObjectClass *object_class = G_OBJECT_CLASS (class);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
/* GObjectClass */
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
object_class->dispose = gtk_cell_area_dispose;
object_class->finalize = gtk_cell_area_finalize;
object_class->get_property = gtk_cell_area_get_property;
object_class->set_property = gtk_cell_area_set_property;
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
/* general */
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
class->add = gtk_cell_area_real_add;
class->remove = gtk_cell_area_real_remove;
class->foreach = gtk_cell_area_real_foreach;
class->foreach_alloc = gtk_cell_area_real_foreach_alloc;
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
class->event = gtk_cell_area_real_event;
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
class->snapshot = gtk_cell_area_real_snapshot;
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
class->apply_attributes = gtk_cell_area_real_apply_attributes;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
/* geometry */
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
class->create_context = gtk_cell_area_real_create_context;
class->copy_context = gtk_cell_area_real_copy_context;
class->get_request_mode = gtk_cell_area_real_get_request_mode;
class->get_preferred_width = gtk_cell_area_real_get_preferred_width;
class->get_preferred_height = gtk_cell_area_real_get_preferred_height;
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
class->get_preferred_height_for_width = gtk_cell_area_real_get_preferred_height_for_width;
class->get_preferred_width_for_height = gtk_cell_area_real_get_preferred_width_for_height;
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
/* focus */
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
class->is_activatable = gtk_cell_area_real_is_activatable;
class->activate = gtk_cell_area_real_activate;
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
class->focus = gtk_cell_area_real_focus;
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
/* Signals */
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
/**
* GtkCellArea::apply-attributes:
* @area: the #GtkCellArea to apply the attributes to
* @model: the #GtkTreeModel to apply the attributes from
* @iter: the #GtkTreeIter indicating which row to apply the attributes of
* @is_expander: whether the view shows children for this row
* @is_expanded: whether the view is currently showing the children of this row
*
* This signal is emitted whenever applying attributes to @area from @model
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
*/
cell_area_signals[SIGNAL_APPLY_ATTRIBUTES] =
g_signal_new (I_("apply-attributes"),
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GtkCellAreaClass, apply_attributes),
NULL, NULL,
_gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN,
G_TYPE_NONE, 4,
GTK_TYPE_TREE_MODEL,
GTK_TYPE_TREE_ITER,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
Add custom va_marshallers in some places This is a slight performance optimization in the common case.
2012-03-05 11:39:09 +00:00
g_signal_set_va_marshaller (cell_area_signals[SIGNAL_APPLY_ATTRIBUTES], G_TYPE_FROM_CLASS (class),
_gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEANv);
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* GtkCellArea::add-editable:
* @area: the #GtkCellArea where editing started
* @renderer: the #GtkCellRenderer that started the edited
* @editable: the #GtkCellEditable widget to add
* @cell_area: the #GtkWidget relative #GdkRectangle coordinates
* where @editable should be added
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* @path: the #GtkTreePath string this edit was initiated for
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
* Indicates that editing has started on @renderer and that @editable
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* should be added to the owning cell-layouting widget at @cell_area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*/
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
cell_area_signals[SIGNAL_ADD_EDITABLE] =
g_signal_new (I_("add-editable"),
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
0, /* No class closure here */
NULL, NULL,
_gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING,
G_TYPE_NONE, 4,
GTK_TYPE_CELL_RENDERER,
GTK_TYPE_CELL_EDITABLE,
GDK_TYPE_RECTANGLE,
G_TYPE_STRING);
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* GtkCellArea::remove-editable:
* @area: the #GtkCellArea where editing finished
* @renderer: the #GtkCellRenderer that finished editeding
* @editable: the #GtkCellEditable widget to remove
*
* Indicates that editing finished on @renderer and that @editable
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* should be removed from the owning cell-layouting widget.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*/
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
cell_area_signals[SIGNAL_REMOVE_EDITABLE] =
g_signal_new (I_("remove-editable"),
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
0, /* No class closure here */
NULL, NULL,
_gtk_marshal_VOID__OBJECT_OBJECT,
G_TYPE_NONE, 2,
GTK_TYPE_CELL_RENDERER,
GTK_TYPE_CELL_EDITABLE);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* GtkCellArea::focus-changed:
* @area: the #GtkCellArea where focus changed
* @renderer: the #GtkCellRenderer that has focus
* @path: the current #GtkTreePath string set for @area
*
* Indicates that focus changed on this @area. This signal
* is emitted either as a result of focus handling or event
* handling.
*
* It's possible that the signal is emitted even if the
* currently focused renderer did not change, this is
* because focus may change to the same renderer in the
* same cell area for a different row of data.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*/
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
cell_area_signals[SIGNAL_FOCUS_CHANGED] =
g_signal_new (I_("focus-changed"),
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
0, /* No class closure here */
NULL, NULL,
_gtk_marshal_VOID__OBJECT_STRING,
G_TYPE_NONE, 2,
GTK_TYPE_CELL_RENDERER,
G_TYPE_STRING);
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
/* Properties */
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
/**
* GtkCellArea:focus-cell:
*
* The cell in the area that currently has focus
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*/
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
g_object_class_install_property (object_class,
PROP_FOCUS_CELL,
g_param_spec_object
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
("focus-cell",
P_("Focus Cell"),
P_("The cell which currently has focus"),
GTK_TYPE_CELL_RENDERER,
GTK_PARAM_READWRITE));
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
/**
* GtkCellArea:edited-cell:
*
* The cell in the area that is currently edited
*
* This property is read-only and only changes as
* a result of a call gtk_cell_area_activate_cell().
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*/
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
g_object_class_install_property (object_class,
PROP_EDITED_CELL,
g_param_spec_object
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
("edited-cell",
P_("Edited Cell"),
P_("The cell which is currently being edited"),
GTK_TYPE_CELL_RENDERER,
G_PARAM_READABLE));
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
/**
* GtkCellArea:edit-widget:
*
* The widget currently editing the edited cell
*
* This property is read-only and only changes as
* a result of a call gtk_cell_area_activate_cell().
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Added initial detailed docs for GtkCellArea.
2010-11-29 01:54:07 +00:00
*/
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
g_object_class_install_property (object_class,
PROP_EDIT_WIDGET,
g_param_spec_object
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
("edit-widget",
P_("Edit Widget"),
P_("The widget currently editing the edited cell"),
Fix GtkCellArea:edit-widget to be of type GtkCellEditable More correct, and consistent with gtk_cell_area_get_editable_widget().
2011-01-05 13:47:16 +00:00
GTK_TYPE_CELL_EDITABLE,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_PARAM_READABLE));
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
/* Pool for Cell Properties */
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (!cell_property_pool)
cell_property_pool = g_param_spec_pool_new (FALSE);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
}
/*************************************************************
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
* CellInfo Basics *
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
*************************************************************/
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
static CellInfo *
cell_info_new (GtkCellLayoutDataFunc func,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gpointer data,
GDestroyNotify destroy)
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
{
Removed cell margin apis and now deal with "focus-line-width".
2010-11-23 07:26:46 +00:00
CellInfo *info = g_slice_new0 (CellInfo);
info->func = func;
info->data = data;
info->destroy = destroy;
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
return info;
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
}
static void
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
cell_info_free (CellInfo *info)
{
if (info->destroy)
info->destroy (info->data);
Code cleanup Use g_slist_free_full more consistently. This commit just converts the obvious cases where g_slist_forall is directly followed by g_slist_free.
2015-07-31 21:57:04 +00:00
g_slist_free_full (info->attributes, (GDestroyNotify)cell_attribute_free);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
g_slice_free (CellInfo, info);
}
static CellAttribute *
cell_attribute_new (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const gchar *attribute,
gint column)
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
{
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
GParamSpec *pspec;
/* Check if the attribute really exists and point to
* the property string installed on the cell renderer
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* class (dont dup the string)
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
*/
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (renderer), attribute);
if (pspec)
{
CellAttribute *cell_attribute = g_slice_new (CellAttribute);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
cell_attribute->attribute = pspec->name;
cell_attribute->column = column;
return cell_attribute;
}
return NULL;
}
static void
cell_attribute_free (CellAttribute *attribute)
{
g_slice_free (CellAttribute, attribute);
}
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
/* GCompareFunc for g_slist_find_custom() */
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
static gint
cell_attribute_find (CellAttribute *cell_attribute,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const gchar *attribute)
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
{
return g_strcmp0 (cell_attribute->attribute, attribute);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
}
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
/*************************************************************
* GObjectClass *
*************************************************************/
static void
gtk_cell_area_finalize (GObject *object)
{
GtkCellArea *area = GTK_CELL_AREA (object);
GtkCellAreaPrivate *priv = area->priv;
/* All cell renderers should already be removed at this point,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* just kill our (empty) hash tables here.
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
*/
g_hash_table_destroy (priv->cell_info);
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
g_hash_table_destroy (priv->focus_siblings);
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
g_free (priv->current_path);
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
G_OBJECT_CLASS (gtk_cell_area_parent_class)->finalize (object);
}
static void
gtk_cell_area_dispose (GObject *object)
{
/* This removes every cell renderer that may be added to the GtkCellArea,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* subclasses should be breaking references to the GtkCellRenderers
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
* at this point.
*/
gtk_cell_layout_clear (GTK_CELL_LAYOUT (object));
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/* Remove any ref to a focused/edited cell */
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
gtk_cell_area_set_focus_cell (GTK_CELL_AREA (object), NULL);
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
gtk_cell_area_set_edited_cell (GTK_CELL_AREA (object), NULL);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
gtk_cell_area_set_edit_widget (GTK_CELL_AREA (object), NULL);
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
G_OBJECT_CLASS (gtk_cell_area_parent_class)->dispose (object);
}
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
static void
gtk_cell_area_set_property (GObject *object,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
guint prop_id,
const GValue *value,
GParamSpec *pspec)
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
{
GtkCellArea *area = GTK_CELL_AREA (object);
switch (prop_id)
{
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
case PROP_FOCUS_CELL:
gtk_cell_area_set_focus_cell (area, (GtkCellRenderer *)g_value_get_object (value));
break;
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_cell_area_get_property (GObject *object,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
guint prop_id,
GValue *value,
GParamSpec *pspec)
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
{
GtkCellArea *area = GTK_CELL_AREA (object);
GtkCellAreaPrivate *priv = area->priv;
switch (prop_id)
{
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
case PROP_FOCUS_CELL:
g_value_set_object (value, priv->focus_cell);
break;
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
case PROP_EDITED_CELL:
g_value_set_object (value, priv->edited_cell);
break;
case PROP_EDIT_WIDGET:
g_value_set_object (value, priv->edit_widget);
break;
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
/*************************************************************
* GtkCellAreaClass *
*************************************************************/
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
static void
gtk_cell_area_real_add (GtkCellArea *area,
GtkCellRenderer *renderer)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::add not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
static void
gtk_cell_area_real_remove (GtkCellArea *area,
GtkCellRenderer *renderer)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::remove not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
static void
gtk_cell_area_real_foreach (GtkCellArea *area,
GtkCellCallback callback,
gpointer callback_data)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::foreach not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
static void
gtk_cell_area_real_foreach_alloc (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
const GdkRectangle *background_area,
GtkCellAllocCallback callback,
gpointer callback_data)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::foreach_alloc not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
static gint
gtk_cell_area_real_event (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
GdkEvent *event,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
{
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
GtkCellAreaPrivate *priv = area->priv;
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
gboolean retval = FALSE;
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
GdkEventType event_type = gdk_event_get_event_type (event);
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
if (event_type == GDK_KEY_PRESS && (flags & GTK_CELL_RENDERER_FOCUSED) != 0)
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
{
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
guint keyval;
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
/* Cancel any edits in progress */
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
if (priv->edited_cell &&
gdk_event_get_keyval (event, &keyval) &&
keyval == GDK_KEY_Escape)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
gtk_cell_area_stop_editing (area, TRUE);
retval = TRUE;
}
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
}
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
else if (event_type == GDK_BUTTON_PRESS)
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
{
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
guint button;
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
if (gdk_event_get_button (event, &button) && button == GDK_BUTTON_PRIMARY)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
GtkCellRenderer *renderer = NULL;
GtkCellRenderer *focus_renderer;
GdkRectangle alloc_area;
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
gdouble event_x, event_y;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
/* We may need some semantics to tell us the offset of the event
* window we are handling events for (i.e. GtkTreeView has a bin_window) */
cellarea: Update to using GdkEvent API
2017-08-25 14:43:52 +00:00
gdk_event_get_coords (event, &event_x, &event_y);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
/* Dont try to search for an event coordinate that is not in the area, that will
* trigger a runtime warning.
*/
if (event_x >= cell_area->x && event_x <= cell_area->x + cell_area->width &&
event_y >= cell_area->y && event_y <= cell_area->y + cell_area->height)
renderer =
gtk_cell_area_get_cell_at_position (area, context, widget,
cell_area, event_x, event_y,
&alloc_area);
if (renderer)
{
focus_renderer = gtk_cell_area_get_focus_from_sibling (area, renderer);
if (!focus_renderer)
focus_renderer = renderer;
/* If we're already editing, cancel it and set focus */
if (gtk_cell_area_get_edited_cell (area))
{
/* XXX Was it really canceled in this case ? */
gtk_cell_area_stop_editing (area, TRUE);
gtk_cell_area_set_focus_cell (area, focus_renderer);
retval = TRUE;
}
else
{
/* If we are activating via a focus sibling,
* we need to fetch the right cell area for the real event renderer */
if (focus_renderer != renderer)
gtk_cell_area_get_cell_allocation (area, context, widget, focus_renderer,
cell_area, &alloc_area);
gtk_cell_area_set_focus_cell (area, focus_renderer);
retval = gtk_cell_area_activate_cell (area, widget, focus_renderer,
event, &alloc_area, flags);
}
}
}
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
}
return retval;
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
}
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
static gboolean
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
snapshot_cell (GtkCellRenderer *renderer,
const GdkRectangle *cell_area,
const GdkRectangle *cell_background,
CellRenderData *data)
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
{
GtkCellRenderer *focus_cell;
GtkCellRendererState flags;
GdkRectangle inner_area;
focus_cell = gtk_cell_area_get_focus_cell (data->area);
flags = data->render_flags;
gtk_cell_area_inner_cell_area (data->area, data->widget, cell_area, &inner_area);
if ((flags & GTK_CELL_RENDERER_FOCUSED) &&
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
(data->focus_all ||
(focus_cell &&
(renderer == focus_cell ||
gtk_cell_area_is_focus_sibling (data->area, focus_cell, renderer)))))
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
{
GdkRectangle cell_focus;
gtk_cell_renderer_get_aligned_area (renderer, data->widget, flags, &inner_area, &cell_focus);
if (data->first_focus)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
data->first_focus = FALSE;
data->focus_rect = cell_focus;
}
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
gdk_rectangle_union (&data->focus_rect, &cell_focus, &data->focus_rect);
}
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
}
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
gtk_cell_renderer_snapshot (renderer, data->snapshot, data->widget,
cell_background, &inner_area, flags);
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
return FALSE;
}
static void
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
gtk_cell_area_real_snapshot (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
GtkSnapshot *snapshot,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags,
gboolean paint_focus)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
CellRenderData render_data =
{
area,
widget,
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
snapshot,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{ 0, },
flags,
paint_focus,
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
FALSE, TRUE
};
/* Make sure we dont paint a focus rectangle while there
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* is an editable widget in play
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
*/
if (gtk_cell_area_get_edited_cell (area))
render_data.paint_focus = FALSE;
Make focus rectangles optional This commit introduces a new setting, gtk-visible-focus, backed by the Gtk/VisibleFocus X setting. Its three values control how focus rectangles are displayed. 'always' is equivalent to the traditional GTK+ behaviour of always rendering focus rectangles. 'never' does what it says, and is intended for keyboardless situations, e.g. tablets. 'automatic' hides focus rectangles initially, until the user interacts with the keyboard, at which point focus rectangles become visible. https://bugzilla.gnome.org/show_bug.cgi?id=649567
2011-08-10 14:00:38 +00:00
if (!gtk_widget_has_visible_focus (widget))
render_data.paint_focus = FALSE;
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
/* If no cell can activate but the caller wants focus painted,
* then we paint focus around all cells */
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
if ((flags & GTK_CELL_RENDERER_FOCUSED) != 0 && paint_focus &&
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
!gtk_cell_area_is_activatable (area))
render_data.focus_all = TRUE;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_area_foreach_alloc (area, context, widget, cell_area, background_area,
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
(GtkCellAllocCallback) snapshot_cell, &render_data);
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
if (render_data.paint_focus &&
render_data.focus_rect.width != 0 &&
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
render_data.focus_rect.height != 0)
{
Make GtkCellArea use GtkStyleContext gtk_cell_area_[gs]et_style_detail() is no longer needed, as the passed widget's context would already have all necessary info.
2011-01-12 20:07:05 +00:00
GtkStyleContext *style_context;
GtkStateFlags renderer_state = 0;
style_context = gtk_widget_get_style_context (widget);
gtk_style_context_save (style_context);
renderer_state = gtk_cell_renderer_get_state (NULL, widget, flags);
gtk_style_context_set_state (style_context, renderer_state);
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
gtk_snapshot_render_focus (snapshot, style_context,
render_data.focus_rect.x, render_data.focus_rect.y,
render_data.focus_rect.width, render_data.focus_rect.height);
Clip focus rectangle to background area
2010-12-16 11:33:00 +00:00
Make GtkCellArea use GtkStyleContext gtk_cell_area_[gs]et_style_detail() is no longer needed, as the passed widget's context would already have all necessary info.
2011-01-12 20:07:05 +00:00
gtk_style_context_restore (style_context);
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
}
}
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
static void
apply_cell_attributes (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
CellInfo *info,
AttributeData *data)
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
{
CellAttribute *attribute;
GSList *list;
Use G_VALUE_INIT Instead of an explicit { 0, } when declaring the variable.
2011-09-30 15:31:04 +00:00
GValue value = G_VALUE_INIT;
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
gboolean is_expander;
gboolean is_expanded;
g_object_freeze_notify (G_OBJECT (renderer));
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
/* Whether a row expands or is presently expanded can only be
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
* provided by the view (as these states can vary across views
* accessing the same model).
*/
g_object_get (renderer, "is-expander", &is_expander, NULL);
if (is_expander != data->is_expander)
g_object_set (renderer, "is-expander", data->is_expander, NULL);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
g_object_get (renderer, "is-expanded", &is_expanded, NULL);
if (is_expanded != data->is_expanded)
g_object_set (renderer, "is-expanded", data->is_expanded, NULL);
/* Apply the attributes directly to the renderer */
for (list = info->attributes; list; list = list->next)
{
attribute = list->data;
gtk_tree_model_get_value (data->model, data->iter, attribute->column, &value);
g_object_set_property (G_OBJECT (renderer), attribute->attribute, &value);
g_value_unset (&value);
}
/* Call any GtkCellLayoutDataFunc that may have been set by the user
*/
if (info->func)
Fixed gtk_cell_layout_set_cell_data_func() to pass the correct layout object Added _gtk_cell_area_set_cell_data_func_with_proxy() to be called by gtk_cell_layout_set_cell_data_func() when the layouting object itself is not the underlying cell area.
2010-12-20 10:37:30 +00:00
info->func (info->proxy ? info->proxy : GTK_CELL_LAYOUT (data->area), renderer,
data->model, data->iter, info->data);
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
g_object_thaw_notify (G_OBJECT (renderer));
}
static void
gtk_cell_area_real_apply_attributes (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gboolean is_expander,
gboolean is_expanded)
Added GtkCellAreaClass->apply_attributes() Made gtk_cell_area_apply_attributes use a vfunc & signal so that subclasses might do specialized things picking up attributes from the model possibly for embedding widgets, and as specially for GtkTreeMenu to connect to the signal and synchronize the menu sensitivity states in a more convenient way than going through the GtkCellLayoutDataFunc.
2010-11-23 14:37:58 +00:00
{
GtkCellAreaPrivate *priv;
AttributeData data;
GtkTreePath *path;
priv = area->priv;
/* Feed in data needed to apply to every renderer */
data.area = area;
data.model = tree_model;
data.iter = iter;
data.is_expander = is_expander;
data.is_expanded = is_expanded;
/* Go over any cells that have attributes or custom GtkCellLayoutDataFuncs and
* apply the data from the treemodel */
g_hash_table_foreach (priv->cell_info, (GHFunc)apply_cell_attributes, &data);
/* Update the currently applied path */
g_free (priv->current_path);
path = gtk_tree_model_get_path (tree_model, iter);
priv->current_path = gtk_tree_path_to_string (path);
gtk_tree_path_free (path);
}
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
static GtkCellAreaContext *
gtk_cell_area_real_create_context (GtkCellArea *area)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::create_context not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
return NULL;
}
static GtkCellAreaContext *
gtk_cell_area_real_copy_context (GtkCellArea *area,
GtkCellAreaContext *context)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::copy_context not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
return NULL;
}
static GtkSizeRequestMode
gtk_cell_area_real_get_request_mode (GtkCellArea *area)
{
/* By default cell areas are height-for-width. */
return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
}
static void
gtk_cell_area_real_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_width,
gint *natural_width)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::get_preferred_width not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
static void
gtk_cell_area_real_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_height,
gint *natural_height)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::get_preferred_height not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
static void
gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
gint width,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gint *minimum_height,
gint *natural_height)
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
{
/* If the area doesnt do height-for-width, fallback on base preferred height */
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_height (area, context, widget, minimum_height, natural_height);
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
}
static void
gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
gint height,
gint *minimum_width,
gint *natural_width)
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
{
/* If the area doesnt do width-for-height, fallback on base preferred width */
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_width, natural_width);
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
}
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
static gboolean
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
get_is_activatable (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gboolean *activatable)
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
{
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
if (gtk_cell_renderer_is_activatable (renderer))
*activatable = TRUE;
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
return *activatable;
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
}
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
static gboolean
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
gtk_cell_area_real_is_activatable (GtkCellArea *area)
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
{
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
gboolean activatable = FALSE;
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
/* Checks if any renderer can focus for the currently applied
* attributes.
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
* Subclasses can override this in the case that they are also
* rendering widgets as well as renderers.
*/
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
gtk_cell_area_foreach (area, (GtkCellCallback)get_is_activatable, &activatable);
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
return activatable;
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
}
static gboolean
gtk_cell_area_real_activate (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
GtkCellRendererState flags,
gboolean edit_only)
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
{
GtkCellAreaPrivate *priv = area->priv;
Changed misleading variable name in gtk_cell_area_real_activate.
2010-12-09 04:57:21 +00:00
GdkRectangle renderer_area;
Fixed GtkCellArea to always activate a cell at gtk_cell_area_activate() time even if no cells have focus.
2010-12-01 07:21:09 +00:00
GtkCellRenderer *activate_cell = NULL;
Added "edit_only" argument to gtk_cell_area_activate() This argument allows the caller to specify that only an editable cell should start editing but an activatable cell should not toggle it's state, this is important for public apis like gtk_tree_view_set_cursor_on_cell() which are only intended to programatically bring attention to the editing of a specific row or cell but not actually change any data. GtkTreeView & CellAreaScaffold updated for the last minute api change.
2010-12-12 08:15:46 +00:00
GtkCellRendererMode mode;
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
if (priv->focus_cell)
Added "edit_only" argument to gtk_cell_area_activate() This argument allows the caller to specify that only an editable cell should start editing but an activatable cell should not toggle it's state, this is important for public apis like gtk_tree_view_set_cursor_on_cell() which are only intended to programatically bring attention to the editing of a specific row or cell but not actually change any data. GtkTreeView & CellAreaScaffold updated for the last minute api change.
2010-12-12 08:15:46 +00:00
{
g_object_get (priv->focus_cell, "mode", &mode, NULL);
if (gtk_cell_renderer_get_visible (priv->focus_cell) &&
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
(edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
mode != GTK_CELL_RENDERER_MODE_INERT))
activate_cell = priv->focus_cell;
Added "edit_only" argument to gtk_cell_area_activate() This argument allows the caller to specify that only an editable cell should start editing but an activatable cell should not toggle it's state, this is important for public apis like gtk_tree_view_set_cursor_on_cell() which are only intended to programatically bring attention to the editing of a specific row or cell but not actually change any data. GtkTreeView & CellAreaScaffold updated for the last minute api change.
2010-12-12 08:15:46 +00:00
}
Fixed GtkCellArea to always activate a cell at gtk_cell_area_activate() time even if no cells have focus.
2010-12-01 07:21:09 +00:00
else
{
GList *cells, *l;
/* GtkTreeView sometimes wants to activate a cell when no
* cells are in focus.
*/
cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
for (l = cells; l && !activate_cell; l = l->next)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
GtkCellRenderer *renderer = l->data;
Fixed GtkCellArea to always activate a cell at gtk_cell_area_activate() time even if no cells have focus.
2010-12-01 07:21:09 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_object_get (renderer, "mode", &mode, NULL);
Added "edit_only" argument to gtk_cell_area_activate() This argument allows the caller to specify that only an editable cell should start editing but an activatable cell should not toggle it's state, this is important for public apis like gtk_tree_view_set_cursor_on_cell() which are only intended to programatically bring attention to the editing of a specific row or cell but not actually change any data. GtkTreeView & CellAreaScaffold updated for the last minute api change.
2010-12-12 08:15:46 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
if (gtk_cell_renderer_get_visible (renderer) &&
(edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
mode != GTK_CELL_RENDERER_MODE_INERT))
activate_cell = renderer;
}
Fixed GtkCellArea to always activate a cell at gtk_cell_area_activate() time even if no cells have focus.
2010-12-01 07:21:09 +00:00
g_list_free (cells);
}
if (activate_cell)
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
{
/* Get the allocation of the focused cell.
*/
Fixed GtkCellArea to always activate a cell at gtk_cell_area_activate() time even if no cells have focus.
2010-12-01 07:21:09 +00:00
gtk_cell_area_get_cell_allocation (area, context, widget, activate_cell,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
cell_area, &renderer_area);
Fixed GtkCellArea to always activate a cell at gtk_cell_area_activate() time even if no cells have focus.
2010-12-01 07:21:09 +00:00
/* Activate or Edit the cell
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
*
* Currently just not sending an event, renderers afaics dont use
* the event argument anyway, worst case is we can synthesize one.
*/
Fixed GtkCellArea to always activate a cell at gtk_cell_area_activate() time even if no cells have focus.
2010-12-01 07:21:09 +00:00
if (gtk_cell_area_activate_cell (area, widget, activate_cell, NULL,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
&renderer_area, flags))
return TRUE;
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
}
Focus driving in GtkCellArea now works. - Fixed focus driving in GtkCellArea with refined apis - Added gtk_cell_area_activate() to be called when the area has focus (to activate or start editing the focused cell) - Added support for this in cellareascaffold - testcellarea now watches the "toggled" signal for a toggle renderer and updates the model state accordingly, this currently works with keyboard navigation, however focus is still not painted on cells.
2010-11-10 13:25:13 +00:00
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
return FALSE;
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
}
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
static gboolean
gtk_cell_area_real_focus (GtkCellArea *area,
GtkDirectionType direction)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::focus not implemented for '%s'",
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
return FALSE;
}
Implemented basic child list handling on GtkCellAreaBox Added the child list to GtkCellAreaBox, added _pack_start() and _pack_end() apis to GtkCellAreaBox since they are appropriate there and implemented GtkCellLayoutIface to override the _pack_start()/end() methods (since the base GtkCellArea class simply forwards these apis to the generic ->add() api on the base class).
2010-10-24 11:01:04 +00:00
/*************************************************************
* GtkCellLayoutIface *
*************************************************************/
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
static void
gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface)
{
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
iface->pack_start = gtk_cell_area_pack_default;
iface->pack_end = gtk_cell_area_pack_default;
iface->clear = gtk_cell_area_clear;
iface->add_attribute = gtk_cell_area_add_attribute;
iface->set_cell_data_func = gtk_cell_area_set_cell_data_func;
iface->clear_attributes = gtk_cell_area_clear_attributes;
iface->reorder = gtk_cell_area_reorder;
iface->get_cells = gtk_cell_area_get_cells;
Make GtkCellArea independantly GtkBuildable. Simply use the GtkCellLayoutIface hooks for this.
2010-12-14 06:52:40 +00:00
iface->get_area = gtk_cell_area_get_area;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
}
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
static void
gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
gboolean expand)
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
{
gtk_cell_area_add (GTK_CELL_AREA (cell_layout), renderer);
}
static void
gtk_cell_area_clear (GtkCellLayout *cell_layout)
{
GtkCellArea *area = GTK_CELL_AREA (cell_layout);
GList *l, *cells =
gtk_cell_layout_get_cells (cell_layout);
for (l = cells; l; l = l->next)
{
GtkCellRenderer *renderer = l->data;
gtk_cell_area_remove (area, renderer);
}
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
g_list_free (cells);
}
static void
gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *attribute,
gint column)
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
{
gtk_cell_area_attribute_connect (GTK_CELL_AREA (cell_layout),
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
renderer, attribute, column);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
}
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
static void
gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellLayoutDataFunc func,
gpointer func_data,
GDestroyNotify destroy)
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
{
Fixed gtk_cell_layout_set_cell_data_func() to pass the correct layout object Added _gtk_cell_area_set_cell_data_func_with_proxy() to be called by gtk_cell_layout_set_cell_data_func() when the layouting object itself is not the underlying cell area.
2010-12-20 10:37:30 +00:00
GtkCellArea *area = GTK_CELL_AREA (cell_layout);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Fixed gtk_cell_layout_set_cell_data_func() to pass the correct layout object Added _gtk_cell_area_set_cell_data_func_with_proxy() to be called by gtk_cell_layout_set_cell_data_func() when the layouting object itself is not the underlying cell area.
2010-12-20 10:37:30 +00:00
_gtk_cell_area_set_cell_data_func_with_proxy (area, renderer, (GFunc)func, func_data, destroy, NULL);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
}
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
static void
gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
{
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
GtkCellArea *area = GTK_CELL_AREA (cell_layout);
GtkCellAreaPrivate *priv = area->priv;
CellInfo *info;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
info = g_hash_table_lookup (priv->cell_info, renderer);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
if (info)
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
{
Code cleanup Use g_slist_free_full more consistently. This commit just converts the obvious cases where g_slist_forall is directly followed by g_slist_free.
2015-07-31 21:57:04 +00:00
g_slist_free_full (info->attributes, (GDestroyNotify)cell_attribute_free);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
info->attributes = NULL;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
}
}
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
static void
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
gtk_cell_area_reorder (GtkCellLayout *cell_layout,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *cell,
gint position)
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellLayout::reorder not implemented for '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (cell_layout)));
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
}
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
static gboolean
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
accum_cells (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GList **accum)
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
{
*accum = g_list_prepend (*accum, renderer);
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
return FALSE;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
}
static GList *
gtk_cell_area_get_cells (GtkCellLayout *cell_layout)
{
GList *cells = NULL;
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_area_foreach (GTK_CELL_AREA (cell_layout),
(GtkCellCallback)accum_cells,
&cells);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
return g_list_reverse (cells);
}
Make GtkCellArea independantly GtkBuildable. Simply use the GtkCellLayoutIface hooks for this.
2010-12-14 06:52:40 +00:00
static GtkCellArea *
gtk_cell_area_get_area (GtkCellLayout *cell_layout)
{
return GTK_CELL_AREA (cell_layout);
}
/*************************************************************
* GtkBuildableIface *
*************************************************************/
static void
gtk_cell_area_buildable_init (GtkBuildableIface *iface)
{
iface->add_child = _gtk_cell_layout_buildable_add_child;
iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;
iface->custom_tag_end = gtk_cell_area_buildable_custom_tag_end;
}
static void
gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkBuilder *builder,
GObject *child,
const gchar *tagname,
gpointer *data)
Make GtkCellArea independantly GtkBuildable. Simply use the GtkCellLayoutIface hooks for this.
2010-12-14 06:52:40 +00:00
{
/* Just ignore the boolean return from here */
_gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname, data);
}
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
/*************************************************************
* API *
*************************************************************/
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
* gtk_cell_area_add:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer to add to @area
*
* Adds @renderer to @area with the default child cell properties.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
void
gtk_cell_area_add (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
GTK_CELL_AREA_GET_CLASS (area)->add (area, renderer);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
* gtk_cell_area_remove:
* @area: a #GtkCellArea
Fixed typo in GtkCellArea docs.
2010-12-04 11:54:36 +00:00
* @renderer: the #GtkCellRenderer to remove from @area
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*
* Removes @renderer from @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
void
gtk_cell_area_remove (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
GtkCellAreaPrivate *priv;
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
GList *renderers, *l;
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
priv = area->priv;
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
/* Remove any custom attributes and custom cell data func here first */
g_hash_table_remove (priv->cell_info, renderer);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
/* Remove focus siblings of this renderer */
g_hash_table_remove (priv->focus_siblings, renderer);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
/* Remove this renderer from any focus renderer's sibling list */
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
for (l = renderers; l; l = l->next)
{
GtkCellRenderer *focus_renderer = l->data;
if (gtk_cell_area_is_focus_sibling (area, focus_renderer, renderer))
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
gtk_cell_area_remove_focus_sibling (area, focus_renderer, renderer);
break;
}
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
}
g_list_free (renderers);
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
GTK_CELL_AREA_GET_CLASS (area)->remove (area, renderer);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
static gboolean
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
get_has_renderer (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
HasRendererCheck *check)
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
{
if (renderer == check->renderer)
check->has_renderer = TRUE;
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
return check->has_renderer;
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_has_renderer:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer to check
*
* Checks if @area contains @renderer.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: %TRUE if @renderer is in the @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
gboolean
gtk_cell_area_has_renderer (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
{
HasRendererCheck check = { renderer, FALSE };
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
gtk_cell_area_foreach (area, (GtkCellCallback)get_has_renderer, &check);
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
return check.has_renderer;
}
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
* gtk_cell_area_foreach:
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
* @area: a #GtkCellArea
[GI] Add missing (scope) annotations
2011-01-18 09:14:56 +00:00
* @callback: (scope call): the #GtkCellCallback to call
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
* @callback_data: user provided data pointer
*
* Calls @callback for every #GtkCellRenderer in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
void
Changed gtk_cell_area_forall to gtk_cell_area_foreach since thats more widely used semantics. Also gave a boolean return value to the callback to allow breaking out of the loop.
2010-12-06 03:41:38 +00:00
gtk_cell_area_foreach (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellCallback callback,
gpointer callback_data)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (callback != NULL);
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
GTK_CELL_AREA_GET_CLASS (area)->foreach (area, callback, callback_data);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
* gtk_cell_area_foreach_alloc:
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
* @area: a #GtkCellArea
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
* @context: the #GtkCellAreaContext for this row of data.
* @widget: the #GtkWidget that @area is rendering to
* @cell_area: the @widget relative coordinates and size for @area
Added 'background_area' calculation to GtkCellAreaClass->foreach_alloc vfunc This allows us to reduce code allocation code paths in subclasses, as a result GtkCellArea implements the ->render() vfunc and the subclass only decides the cell area and background area distributions in a single code path.
2010-12-08 12:18:05 +00:00
* @background_area: the @widget relative coordinates of the background area
[GI] Add missing (scope) annotations
2011-01-18 09:14:56 +00:00
* @callback: (scope call): the #GtkCellAllocCallback to call
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
* @callback_data: user provided data pointer
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
* Calls @callback for every #GtkCellRenderer in @area with the
* allocated rectangle inside @cell_area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
void
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
gtk_cell_area_foreach_alloc (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
const GdkRectangle *background_area,
GtkCellAllocCallback callback,
gpointer callback_data)
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
{
g_return_if_fail (GTK_IS_CELL_AREA (area));
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (cell_area != NULL);
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
g_return_if_fail (callback != NULL);
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
GTK_CELL_AREA_GET_CLASS (area)->foreach_alloc (area, context, widget,
cell_area, background_area,
callback, callback_data);
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_event:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext for this row of data.
* @widget: the #GtkWidget that @area is rendering to
* @event: the #GdkEvent to handle
* @cell_area: the @widget relative coordinates for @area
* @flags: the #GtkCellRendererState for @area in this row.
*
* Delegates event handling to a #GtkCellArea.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: %TRUE if the event was handled by @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
gint
Added GtkCellRendererState flags to GtkCellArea->event/render() methods
2010-11-01 03:39:00 +00:00
gtk_cell_area_event (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
GdkEvent *event,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
{
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
GtkCellAreaClass *class;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA (area), 0);
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), 0);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
g_return_val_if_fail (event != NULL, 0);
g_return_val_if_fail (cell_area != NULL, 0);
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
class = GTK_CELL_AREA_GET_CLASS (area);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
if (class->event)
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
return class->event (area, context, widget, event, cell_area, flags);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::event not implemented for '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
return 0;
}
cellview: Implement snapshot() This also adds gtk_cell_area_snapshot().
2016-12-19 15:34:25 +00:00
/**
* gtk_cell_area_snapshot:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext for this row of data.
* @widget: the #GtkWidget that @area is rendering to
* @snapshot: the #GtkSnapshot to draw to
* @background_area: the @widget relative coordinates for @area’s background
* @cell_area: the @widget relative coordinates for @area
* @flags: the #GtkCellRendererState for @area in this row.
* @paint_focus: whether @area should paint focus on focused cells for focused rows or not.
*
* Snapshots @area’s cells according to @area’s layout onto at
* the given coordinates.
*
* Since: 3.90
*/
void
gtk_cell_area_snapshot (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
GtkSnapshot *snapshot,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags,
gboolean paint_focus)
{
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
GtkCellAreaClass *class;
cellview: Implement snapshot() This also adds gtk_cell_area_snapshot().
2016-12-19 15:34:25 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (snapshot != NULL);
g_return_if_fail (background_area != NULL);
g_return_if_fail (cell_area != NULL);
cellrenderer: Move snapshotting down into cell renderers Now that every call to GtkCellArea is a snapshot call and no more cairo calls are left, move the actual differentiation between Cairo and Snapshot down to the cell renderer.
2016-12-23 08:09:42 +00:00
class = GTK_CELL_AREA_GET_CLASS (area);
if (class->snapshot)
class->snapshot (area, context, widget, snapshot, background_area, cell_area, flags, paint_focus);
else
g_warning ("GtkCellAreaClass::snapshot not implemented for '%s'",
g_type_name (G_TYPE_FROM_INSTANCE (area)));
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
}
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
static gboolean
get_cell_allocation (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const GdkRectangle *cell_area,
const GdkRectangle *cell_background,
RendererAllocationData *data)
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
{
if (data->renderer == renderer)
data->allocation = *cell_area;
return (data->renderer == renderer);
}
/**
* gtk_cell_area_get_cell_allocation:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext used to hold sizes for @area.
* @widget: the #GtkWidget that @area is rendering on
* @renderer: the #GtkCellRenderer to get the allocation for
* @cell_area: the whole allocated area for @area in @widget
* for this row
* @allocation: (out): where to store the allocation for @renderer
*
* Derives the allocation of @renderer inside @area if @area
* were to be renderered in @cell_area.
*
* Since: 3.0
*/
void
gtk_cell_area_get_cell_allocation (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
GtkCellRenderer *renderer,
const GdkRectangle *cell_area,
GdkRectangle *allocation)
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
{
RendererAllocationData data = { renderer, { 0, } };
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (cell_area != NULL);
g_return_if_fail (allocation != NULL);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
(GtkCellAllocCallback)get_cell_allocation, &data);
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
*allocation = data.allocation;
}
static gboolean
get_cell_by_position (GtkCellRenderer *renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const GdkRectangle *cell_area,
const GdkRectangle *cell_background,
CellByPositionData *data)
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
{
if (data->x >= cell_area->x && data->x < cell_area->x + cell_area->width &&
data->y >= cell_area->y && data->y < cell_area->y + cell_area->height)
{
data->renderer = renderer;
data->cell_area = *cell_area;
}
return (data->renderer != NULL);
}
/**
* gtk_cell_area_get_cell_at_position:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext used to hold sizes for @area.
* @widget: the #GtkWidget that @area is rendering on
* @cell_area: the whole allocated area for @area in @widget
* for this row
* @x: the x position
* @y: the y position
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* @alloc_area: (out) (allow-none): where to store the inner allocated area of the
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
* returned cell renderer, or %NULL.
*
* Gets the #GtkCellRenderer at @x and @y coordinates inside @area and optionally
* returns the full cell allocation for it inside @cell_area.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (transfer none): the #GtkCellRenderer at @x and @y.
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
*
* Since: 3.0
*/
GtkCellRenderer *
gtk_cell_area_get_cell_at_position (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
gint x,
gint y,
GdkRectangle *alloc_area)
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
{
CellByPositionData data = { x, y, NULL, { 0, } };
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
g_return_val_if_fail (cell_area != NULL, NULL);
g_return_val_if_fail (x >= cell_area->x && x <= cell_area->x + cell_area->width, NULL);
g_return_val_if_fail (y >= cell_area->y && y <= cell_area->y + cell_area->height, NULL);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
(GtkCellAllocCallback)get_cell_by_position, &data);
Added gtk_cell_area_foreach_alloc() to further simplify GtkCellArea subclasses gtk_cell_area_foreach_alloc() itterates over an allocated list of cells and calls a callback with the cell's allocation until the callback returns TRUE. - Removed vfunc get_cell_allocation() and implemented gtk_cell_area_get_cell_allocation() using foreach_alloc() - Added gtk_cell_area_get_cell_at_position() using foreach_alloc() - Removed GtkCellAreaBox ->event() implementation and implemented mouse "click" cell activation in GtkCellArea class directly using gtk_cell_area_get_cell_at_position().
2010-12-06 05:11:28 +00:00
if (alloc_area)
*alloc_area = data.cell_area;
return data.renderer;
}
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
/*************************************************************
* API: Geometry *
*************************************************************/
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_create_context:
* @area: a #GtkCellArea
*
* Creates a #GtkCellAreaContext to be used with @area for
* all purposes. #GtkCellAreaContext stores geometry information
* for rows for which it was operated on, it is important to use
* the same context for the same row of data at all times (i.e.
* one should render and handle events with the same #GtkCellAreaContext
* which was used to request the size of those rows of data).
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (transfer full): a newly created #GtkCellAreaContext which can be used with @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
GtkCellAreaContext *
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
gtk_cell_area_create_context (GtkCellArea *area)
Added GtkCellAreaIter class Added base class to hold alignment and overall size request information while itterating over the size requests of various rows of a GtkTreeModel, updated GtkCellArea/GtkCellAreaBox classes accordingly.
2010-10-26 08:14:20 +00:00
{
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
return GTK_CELL_AREA_GET_CLASS (area)->create_context (area);
Added GtkCellAreaIter class Added base class to hold alignment and overall size request information while itterating over the size requests of various rows of a GtkTreeModel, updated GtkCellArea/GtkCellAreaBox classes accordingly.
2010-10-26 08:14:20 +00:00
}
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
/**
* gtk_cell_area_copy_context:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext to copy
*
* This is sometimes needed for cases where rows need to share
* alignments in one orientation but may be separately grouped
* in the opposing orientation.
*
* For instance, #GtkIconView creates all icons (rows) to have
* the same width and the cells theirin to have the same
* horizontal alignments. However each row of icons may have
* a separate collective height. #GtkIconView uses this to
* request the heights of each row based on a context which
* was already used to request all the row widths that are
* to be displayed.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (transfer full): a newly created #GtkCellAreaContext copy of @context.
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
*
* Since: 3.0
*/
GtkCellAreaContext *
gtk_cell_area_copy_context (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context)
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
{
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), NULL);
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
return GTK_CELL_AREA_GET_CLASS (area)->copy_context (area, context);
Added apis to GtkCellArea for GtkIconView purposes. Added a few apis, - GtkCellAreaContext get_preferred_height_for_width & width for height apis and vfuncs, this lets the icon view request the collective (and aligned) height for width for a said row. - gtk_cell_area_copy_context() this creates a duplicate of an already created and requested context, this way the icon view uses a global context to request the widths of all rows and then makes a copy with all the stored alignments and uses a separate copy to calculate the height and alignments of each row separately.
2010-12-12 15:18:00 +00:00
}
Added GtkCellAreaIter class Added base class to hold alignment and overall size request information while itterating over the size requests of various rows of a GtkTreeModel, updated GtkCellArea/GtkCellAreaBox classes accordingly.
2010-10-26 08:14:20 +00:00
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* gtk_cell_area_get_request_mode:
* @area: a #GtkCellArea
*
* Gets whether the area prefers a height-for-width layout
* or a width-for-height layout.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: The #GtkSizeRequestMode preferred by @area.
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
* Since: 3.0
*/
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkSizeRequestMode
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
gtk_cell_area_get_request_mode (GtkCellArea *area)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA (area),
GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH);
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
return GTK_CELL_AREA_GET_CLASS (area)->get_request_mode (area);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* gtk_cell_area_get_preferred_width:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext to perform this request with
* @widget: the #GtkWidget where @area will be rendering
* @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
* @natural_width: (out) (allow-none): location to store the natural width, or %NULL
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Retrieves a cell area’s initial minimum and natural width.
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
docs: correct various spelling and grammar errors I noticed a few cases of "wether", and while fixing them noticed a few "its" which should be "it's". It all went downhill from there.
2012-02-29 17:19:55 +00:00
* @area will store some geometrical information in @context along the way;
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* when requesting sizes over an arbitrary number of rows, it’s not important
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
* to check the @minimum_width and @natural_width of this call but rather to
Touching up GtkCellArea docs.
2010-11-29 02:02:29 +00:00
* consult gtk_cell_area_context_get_preferred_width() after a series of
* requests.
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
* Since: 3.0
*/
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
void
gtk_cell_area_get_preferred_width (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_width,
gint *natural_width)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_WIDGET (widget));
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget,
minimum_width, natural_width);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* gtk_cell_area_get_preferred_height_for_width:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext which has already been requested for widths.
* @widget: the #GtkWidget where @area will be rendering
* @width: the width for which to check the height of this area
* @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
* @natural_height: (out) (allow-none): location to store the natural height, or %NULL
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Retrieves a cell area’s minimum and natural height if it would be given
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
* the specified @width.
*
* @area stores some geometrical information in @context along the way
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* while calling gtk_cell_area_get_preferred_width(). It’s important to
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
* perform a series of gtk_cell_area_get_preferred_width() requests with
* @context first and then call gtk_cell_area_get_preferred_height_for_width()
* on each cell area individually to get the height for width of each
* fully requested row.
*
* If at some point, the width of a single row changes, it should be
* requested with gtk_cell_area_get_preferred_width() again and then
Touching up GtkCellArea docs.
2010-11-29 02:02:29 +00:00
* the full width of the requested rows checked again with
* gtk_cell_area_context_get_preferred_width().
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
* Since: 3.0
*/
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
void
gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
gint width,
gint *minimum_height,
gint *natural_height)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
GtkCellAreaClass *class;
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_WIDGET (widget));
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
class = GTK_CELL_AREA_GET_CLASS (area);
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
class->get_preferred_height_for_width (area, context, widget, width, minimum_height, natural_height);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* gtk_cell_area_get_preferred_height:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext to perform this request with
* @widget: the #GtkWidget where @area will be rendering
* @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
* @natural_height: (out) (allow-none): location to store the natural height, or %NULL
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Retrieves a cell area’s initial minimum and natural height.
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
docs: correct various spelling and grammar errors I noticed a few cases of "wether", and while fixing them noticed a few "its" which should be "it's". It all went downhill from there.
2012-02-29 17:19:55 +00:00
* @area will store some geometrical information in @context along the way;
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* when requesting sizes over an arbitrary number of rows, it’s not important
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
* to check the @minimum_height and @natural_height of this call but rather to
Touching up GtkCellArea docs.
2010-11-29 02:02:29 +00:00
* consult gtk_cell_area_context_get_preferred_height() after a series of
* requests.
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
* Since: 3.0
*/
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
void
gtk_cell_area_get_preferred_height (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
gint *minimum_height,
gint *natural_height)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_WIDGET (widget));
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_height (area, context, widget,
minimum_height, natural_height);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
/**
* gtk_cell_area_get_preferred_width_for_height:
* @area: a #GtkCellArea
* @context: the #GtkCellAreaContext which has already been requested for widths.
* @widget: the #GtkWidget where @area will be rendering
* @height: the height for which to check the width of this area
* @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
* @natural_width: (out) (allow-none): location to store the natural width, or %NULL
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Retrieves a cell area’s minimum and natural width if it would be given
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
* the specified @height.
*
* @area stores some geometrical information in @context along the way
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* while calling gtk_cell_area_get_preferred_height(). It’s important to
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
* perform a series of gtk_cell_area_get_preferred_height() requests with
* @context first and then call gtk_cell_area_get_preferred_width_for_height()
* on each cell area individually to get the height for width of each
* fully requested row.
*
Touching up GtkCellArea docs.
2010-11-29 02:02:29 +00:00
* If at some point, the height of a single row changes, it should be
* requested with gtk_cell_area_get_preferred_height() again and then
* the full height of the requested rows checked again with
* gtk_cell_area_context_get_preferred_height().
More documentation in gtkcellarea.c
2010-11-15 02:23:55 +00:00
*
* Since: 3.0
*/
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
void
gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
gint height,
gint *minimum_width,
gint *natural_width)
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
{
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
GtkCellAreaClass *class;
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Added GtkCellArea to the build Starting to form a good api, implemented most of GtkCellLayout iface on the base class routing the apis through the new class vfuncs.
2010-10-22 07:41:52 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_WIDGET (widget));
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
Adding initial code skeleton for GtkCellAreaBox.
2010-10-23 08:01:58 +00:00
class = GTK_CELL_AREA_GET_CLASS (area);
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
class->get_preferred_width_for_height (area, context, widget, height, minimum_width, natural_width);
Adding vague initial draft of GtkCellArea to the codebase (treeview-refactor branch).
2010-10-21 13:46:10 +00:00
}
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
/*************************************************************
* API: Attributes *
*************************************************************/
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
* gtk_cell_area_attribute_connect:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer to connect an attribute for
* @attribute: the attribute name
* @column: the #GtkTreeModel column to fetch attribute values from
*
* Connects an @attribute to apply values from @column for the
* #GtkTreeModel in use.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
void
gtk_cell_area_attribute_connect (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *attribute,
gint column)
{
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
GtkCellAreaPrivate *priv;
CellInfo *info;
CellAttribute *cell_attribute;
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (attribute != NULL);
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
priv = area->priv;
info = g_hash_table_lookup (priv->cell_info, renderer);
if (!info)
{
info = cell_info_new (NULL, NULL, NULL);
g_hash_table_insert (priv->cell_info, renderer, info);
}
else
{
GSList *node;
/* Check we are not adding the same attribute twice */
if ((node = g_slist_find_custom (info->attributes, attribute,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
(GCompareFunc)cell_attribute_find)) != NULL)
{
cell_attribute = node->data;
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("Cannot connect attribute '%s' for cell renderer class '%s' "
"since '%s' is already attributed to column %d",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
attribute,
cellarea: Fix warning messages to display the right type The warning displayed the type of the area instead of the cell renderer's type before.
2011-05-02 16:36:14 +00:00
G_OBJECT_TYPE_NAME (renderer),
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
attribute, cell_attribute->column);
return;
}
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
}
cell_attribute = cell_attribute_new (renderer, attribute, column);
if (!cell_attribute)
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("Cannot connect attribute '%s' for cell renderer class '%s' "
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
"since attribute does not exist",
attribute,
cellarea: Fix warning messages to display the right type The warning displayed the type of the area instead of the cell renderer's type before.
2011-05-02 16:36:14 +00:00
G_OBJECT_TYPE_NAME (renderer));
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
return;
}
info->attributes = g_slist_prepend (info->attributes, cell_attribute);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
}
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
* gtk_cell_area_attribute_disconnect:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer to disconnect an attribute for
* @attribute: the attribute name
*
* Disconnects @attribute for the @renderer in @area so that
* attribute will no longer be updated with values from the
* model.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
void
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
gtk_cell_area_attribute_disconnect (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *attribute)
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
{
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
GtkCellAreaPrivate *priv;
CellInfo *info;
CellAttribute *cell_attribute;
GSList *node;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (attribute != NULL);
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
priv = area->priv;
info = g_hash_table_lookup (priv->cell_info, renderer);
if (info)
{
node = g_slist_find_custom (info->attributes, attribute,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
(GCompareFunc)cell_attribute_find);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
if (node)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
cell_attribute = node->data;
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
cell_attribute_free (cell_attribute);
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
info->attributes = g_slist_delete_link (info->attributes, node);
}
Removed attribute handling from class vfuncs of GtkCellArea. Now GtkCellArea handles attribute connections in the base class, subclasses only need to add/remove the renderers, render them, do geometry and handle events.
2010-10-24 10:20:10 +00:00
}
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
}
GtkCellArea: allow finding attributes at runtime This will allow e.g. GtkInspector to display attribute mappings. http://bugzilla.gnome.org/show_bug.cgi?id=729817
2014-05-08 18:06:03 +00:00
/**
* gtk_cell_area_attribute_get_column:
gtkcellarea: Fix docs
2014-06-29 22:05:49 +00:00
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer
GtkCellArea: allow finding attributes at runtime This will allow e.g. GtkInspector to display attribute mappings. http://bugzilla.gnome.org/show_bug.cgi?id=729817
2014-05-08 18:06:03 +00:00
* @attribute: an attribute on the renderer
*
* Returns the model column that an attribute has been mapped to,
* or -1 if the attribute is not mapped.
*
* Returns: the model column, or -1
*
* Since: 3.14
*/
gint
gtk_cell_area_attribute_get_column (GtkCellArea *area,
GtkCellRenderer *renderer,
const gchar *attribute)
{
GtkCellAreaPrivate *priv;
CellInfo *info;
CellAttribute *cell_attribute;
GSList *node;
priv = area->priv;
info = g_hash_table_lookup (priv->cell_info, renderer);
if (info)
{
node = g_slist_find_custom (info->attributes, attribute,
(GCompareFunc)cell_attribute_find);
if (node)
{
cell_attribute = node->data;
return cell_attribute->column;
}
}
return -1;
}
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
Fix malformed doc comments Most of these are forgotten :'s and similar details which gtk-doc now warns about.
2012-04-13 00:07:28 +00:00
* gtk_cell_area_apply_attributes:
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
* @area: a #GtkCellArea
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* @tree_model: the #GtkTreeModel to pull values from
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
* @iter: the #GtkTreeIter in @tree_model to apply values for
* @is_expander: whether @iter has children
* @is_expanded: whether @iter is expanded in the view and
* children are visible
*
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
* Applies any connected attributes to the renderers in
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
* @area by pulling the values from @tree_model.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
void
gtk_cell_area_apply_attributes (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gboolean is_expander,
gboolean is_expanded)
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
{
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
g_return_if_fail (iter != NULL);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_signal_emit (area, cell_area_signals[SIGNAL_APPLY_ATTRIBUTES], 0,
tree_model, iter, is_expander, is_expanded);
Implemented remaining portions of GtkCellLayout iface Now GtkCellArea provides a generic way of applying attributes from a GtkTreeModel/GtkTreeIter, GtkCellArea bookkeeps a hashtable of GtkCellLayoutDataFunc's and completely abstracts the applying of data to cells... GtkCellArea implementations need only to bookkeep the added renderers and attributes (probably we can abstract the attribute bookkeeping in the base class as well). Things starting to take a good and practical shape.
2010-10-24 06:44:48 +00:00
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
/**
* gtk_cell_area_get_current_path_string:
* @area: a #GtkCellArea
*
* Gets the current #GtkTreePath string for the currently
* applied #GtkTreeIter, this is implicitly updated when
* gtk_cell_area_apply_attributes() is called and can be
* used to interact with renderers from #GtkCellArea
* subclasses.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: The current #GtkTreePath string for the current
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* attributes applied to @area. This string belongs to the area and
* should not be freed.
*
* Since: 3.0
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
*/
gtk: Use const instead G_CONST_RETURN
2011-06-06 18:13:44 +00:00
const gchar *
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
gtk_cell_area_get_current_path_string (GtkCellArea *area)
{
GtkCellAreaPrivate *priv;
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
priv = area->priv;
return priv->current_path;
}
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
/*************************************************************
* API: Cell Properties *
*************************************************************/
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_class_install_cell_property:
* @aclass: a #GtkCellAreaClass
* @property_id: the id for the property
* @pspec: the #GParamSpec for the property
*
* Installs a cell property on a cell area class.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_class_install_cell_property (GtkCellAreaClass *aclass,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
guint property_id,
GParamSpec *pspec)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
g_return_if_fail (GTK_IS_CELL_AREA_CLASS (aclass));
g_return_if_fail (G_IS_PARAM_SPEC (pspec));
if (pspec->flags & G_PARAM_WRITABLE)
g_return_if_fail (aclass->set_cell_property != NULL);
if (pspec->flags & G_PARAM_READABLE)
g_return_if_fail (aclass->get_cell_property != NULL);
g_return_if_fail (property_id > 0);
g_return_if_fail (PARAM_SPEC_PARAM_ID (pspec) == 0); /* paranoid */
g_return_if_fail ((pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) == 0);
if (g_param_spec_pool_lookup (cell_property_pool, pspec->name, G_OBJECT_CLASS_TYPE (aclass), TRUE))
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning (G_STRLOC ": class '%s' already contains a cell property named '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_CLASS_NAME (aclass), pspec->name);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
return;
}
g_param_spec_ref (pspec);
g_param_spec_sink (pspec);
PARAM_SPEC_SET_PARAM_ID (pspec, property_id);
g_param_spec_pool_insert (cell_property_pool, pspec, G_OBJECT_CLASS_TYPE (aclass));
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_class_find_cell_property:
* @aclass: a #GtkCellAreaClass
* @property_name: the name of the child property to find
*
* Finds a cell property of a cell area class by name.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (transfer none): the #GParamSpec of the child property
[GI] Add missing (transfer) annotations
2011-01-18 09:01:17 +00:00
* or %NULL if @aclass has no child property with that name.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
GParamSpec*
gtk_cell_area_class_find_cell_property (GtkCellAreaClass *aclass,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
const gchar *property_name)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
g_return_val_if_fail (property_name != NULL, NULL);
return g_param_spec_pool_lookup (cell_property_pool,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
property_name,
G_OBJECT_CLASS_TYPE (aclass),
TRUE);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_class_list_cell_properties:
* @aclass: a #GtkCellAreaClass
Add missing introspection annotations https://bugzilla.gnome.org/show_bug.cgi?id=707519
2013-09-05 00:08:41 +00:00
* @n_properties: (out): location to return the number of cell properties found
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*
* Returns all cell properties of a cell area class.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (array length=n_properties) (transfer container): a newly
[GI] Add missing (out) and (array) annotations
2011-01-18 09:10:30 +00:00
* allocated %NULL-terminated array of #GParamSpec*. The array
* must be freed with g_free().
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
GParamSpec**
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
gtk_cell_area_class_list_cell_properties (GtkCellAreaClass *aclass,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
guint *n_properties)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
GParamSpec **pspecs;
guint n;
g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
pspecs = g_param_spec_pool_list (cell_property_pool,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_CLASS_TYPE (aclass),
&n);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (n_properties)
*n_properties = n;
return pspecs;
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_add_with_properties:
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer to be placed inside @area
* @first_prop_name: the name of the first cell property to set
Documentation fixes Mostly making sure that return values and varargs don't loose their docs.
2011-09-26 00:58:59 +00:00
* @...: a %NULL-terminated list of property names and values, starting
* with @first_prop_name
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*
* Adds @renderer to @area, setting cell properties at the same time.
Forgotten documentation fix
2011-01-06 16:27:38 +00:00
* See gtk_cell_area_add() and gtk_cell_area_cell_set() for more details.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_add_with_properties (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *first_prop_name,
...)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
GtkCellAreaClass *class;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
class = GTK_CELL_AREA_GET_CLASS (area);
if (class->add)
{
va_list var_args;
class->add (area, renderer);
va_start (var_args, first_prop_name);
gtk_cell_area_cell_set_valist (area, renderer, first_prop_name, var_args);
va_end (var_args);
}
else
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("GtkCellAreaClass::add not implemented for '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_type_name (G_TYPE_FROM_INSTANCE (area)));
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_cell_set:
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer which is a cell inside @area
* @first_prop_name: the name of the first cell property to set
Documentation fixes Mostly making sure that return values and varargs don't loose their docs.
2011-09-26 00:58:59 +00:00
* @...: a %NULL-terminated list of property names and values, starting
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
* with @first_prop_name
*
* Sets one or more cell properties for @cell in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_cell_set (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *first_prop_name,
...)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
va_list var_args;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
va_start (var_args, first_prop_name);
gtk_cell_area_cell_set_valist (area, renderer, first_prop_name, var_args);
va_end (var_args);
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_cell_get:
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer which is inside @area
* @first_prop_name: the name of the first cell property to get
Documentation fixes Mostly making sure that return values and varargs don't loose their docs.
2011-09-26 00:58:59 +00:00
* @...: return location for the first cell property, followed
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
* optionally by more name/return location pairs, followed by %NULL
*
* Gets the values of one or more cell properties for @renderer in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_cell_get (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *first_prop_name,
...)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
va_list var_args;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
va_start (var_args, first_prop_name);
gtk_cell_area_cell_get_valist (area, renderer, first_prop_name, var_args);
va_end (var_args);
}
static inline void
area_get_cell_property (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GParamSpec *pspec,
GValue *value)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
class->get_cell_property (area, renderer, PARAM_SPEC_PARAM_ID (pspec), value, pspec);
}
static inline void
area_set_cell_property (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GParamSpec *pspec,
const GValue *value)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
Use G_VALUE_INIT Instead of an explicit { 0, } when declaring the variable.
2011-09-30 15:31:04 +00:00
GValue tmp_value = G_VALUE_INIT;
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
/* provide a copy to work from, convert (if necessary) and validate */
g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
if (!g_value_transform (value, &tmp_value))
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("unable to set cell property '%s' of type '%s' from value of type '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
pspec->name,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
G_VALUE_TYPE_NAME (value));
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
else if (g_param_value_validate (pspec, &tmp_value) && !(pspec->flags & G_PARAM_LAX_VALIDATION))
{
gchar *contents = g_strdup_value_contents (value);
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("value \"%s\" of type '%s' is invalid for property '%s' of type '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
contents,
G_VALUE_TYPE_NAME (value),
pspec->name,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
g_free (contents);
}
else
{
class->set_cell_property (area, renderer, PARAM_SPEC_PARAM_ID (pspec), &tmp_value, pspec);
}
g_value_unset (&tmp_value);
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_cell_set_valist:
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer which inside @area
* @first_property_name: the name of the first cell property to set
* @var_args: a %NULL-terminated list of property names and values, starting
* with @first_prop_name
*
* Sets one or more cell properties for @renderer in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_cell_set_valist (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *first_property_name,
va_list var_args)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
const gchar *name;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
name = first_property_name;
while (name)
{
Use G_VALUE_INIT Instead of an explicit { 0, } when declaring the variable.
2011-09-30 15:31:04 +00:00
GValue value = G_VALUE_INIT;
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
gchar *error = NULL;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GParamSpec *pspec =
g_param_spec_pool_lookup (cell_property_pool, name,
G_OBJECT_TYPE (area), TRUE);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (!pspec)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell area class '%s' has no cell property named '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
break;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (!(pspec->flags & G_PARAM_WRITABLE))
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell property '%s' of cell area class '%s' is not writable",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
break;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
Use faster new G_VALUE_COLLECT_INIT variant instead G_VALUE_COLLECT Fixes https://bugzilla.gnome.org/show_bug.cgi?id=641621
2011-02-05 17:54:02 +00:00
G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec),
var_args, 0, &error);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (error)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
g_warning ("%s: %s", G_STRLOC, error);
g_free (error);
/* we purposely leak the value here, it might not be
* in a sane state if an error condition occoured
*/
break;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
area_set_cell_property (area, renderer, pspec, &value);
g_value_unset (&value);
name = va_arg (var_args, gchar*);
}
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_cell_get_valist:
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer inside @area
* @first_property_name: the name of the first property to get
* @var_args: return location for the first property, followed
* optionally by more name/return location pairs, followed by %NULL
*
* Gets the values of one or more cell properties for @renderer in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_cell_get_valist (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *first_property_name,
va_list var_args)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
const gchar *name;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
name = first_property_name;
while (name)
{
Use G_VALUE_INIT Instead of an explicit { 0, } when declaring the variable.
2011-09-30 15:31:04 +00:00
GValue value = G_VALUE_INIT;
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
GParamSpec *pspec;
gchar *error;
pspec = g_param_spec_pool_lookup (cell_property_pool, name,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_TYPE (area), TRUE);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (!pspec)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell area class '%s' has no cell property named '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
break;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (!(pspec->flags & G_PARAM_READABLE))
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell property '%s' of cell area class '%s' is not readable",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
break;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
area_get_cell_property (area, renderer, pspec, &value);
G_VALUE_LCOPY (&value, var_args, 0, &error);
if (error)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
g_warning ("%s: %s", G_STRLOC, error);
g_free (error);
g_value_unset (&value);
break;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
g_value_unset (&value);
name = va_arg (var_args, gchar*);
}
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_cell_set_property:
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer inside @area
* @property_name: the name of the cell property to set
* @value: the value to set the cell property to
*
* Sets a cell property for @renderer in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_cell_set_property (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *property_name,
const GValue *value)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
GParamSpec *pspec;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (property_name != NULL);
g_return_if_fail (G_IS_VALUE (value));
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_TYPE (area), TRUE);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (!pspec)
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell area class '%s' has no cell property named '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
else if (!(pspec->flags & G_PARAM_WRITABLE))
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell property '%s' of cell area class '%s' is not writable",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
else
{
area_set_cell_property (area, renderer, pspec, value);
}
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_cell_get_property:
* @area: a #GtkCellArea
* @renderer: a #GtkCellRenderer inside @area
* @property_name: the name of the property to get
* @value: a location to return the value
*
* Gets the value of a cell property for @renderer in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
*/
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
void
gtk_cell_area_cell_get_property (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
const gchar *property_name,
GValue *value)
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
{
GParamSpec *pspec;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (property_name != NULL);
g_return_if_fail (G_IS_VALUE (value));
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_OBJECT_TYPE (area), TRUE);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
if (!pspec)
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell area class '%s' has no cell property named '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
else if (!(pspec->flags & G_PARAM_READABLE))
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("%s: cell property '%s' of cell area class '%s' is not readable",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
else
{
Use G_VALUE_INIT Instead of an explicit { 0, } when declaring the variable.
2011-09-30 15:31:04 +00:00
GValue *prop_value, tmp_value = G_VALUE_INIT;
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
/* auto-conversion of the callers value type
*/
if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
g_value_reset (value);
prop_value = value;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
else if (!g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
Use stupid quotes instead of dumb quotes Following a similar change in GLib a while ago. 'bla' may by stupid, but it looks less dumb than `bla'.
2015-09-20 06:32:48 +00:00
g_warning ("can't retrieve cell property '%s' of type '%s' as value of type '%s'",
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
pspec->name,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
G_VALUE_TYPE_NAME (value));
return;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
prop_value = &tmp_value;
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
area_get_cell_property (area, renderer, pspec, prop_value);
if (prop_value != value)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
g_value_transform (prop_value, value);
g_value_unset (&tmp_value);
}
Implemented "cell properties" on the GtkCellArea Added cell "packing" properties for generic configuration of child cells inside an area.
2010-10-31 08:13:15 +00:00
}
}
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
/*************************************************************
* API: Focus *
*************************************************************/
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
/**
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
* gtk_cell_area_is_activatable:
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
* @area: a #GtkCellArea
*
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
* Returns whether the area can do anything when activated,
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* after applying new attributes to @area.
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: whether @area can do anything when activated.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*/
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
gboolean
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
gtk_cell_area_is_activatable (GtkCellArea *area)
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
{
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
Changed cell area/renderer "can_focus" semantics to "is_activatable" across the board. This is because focus in treeviews can be given to cells that cannot do anything with activation (for better keynav), so we dissociate the concept of cell activation and focusing.
2010-11-29 07:29:09 +00:00
return GTK_CELL_AREA_GET_CLASS (area)->is_activatable (area);
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
}
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
/**
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* gtk_cell_area_focus:
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
* @area: a #GtkCellArea
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* @direction: the #GtkDirectionType
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* This should be called by the @area’s owning layout widget
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* when focus is to be passed to @area, or moved within @area
* for a given @direction and row data.
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* Implementing #GtkCellArea classes should implement this
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* method to receive and navigate focus in its own way particular
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* to how it lays out cells.
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: %TRUE if focus remains inside @area as a result of this call.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*/
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
gboolean
gtk_cell_area_focus (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkDirectionType direction)
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
{
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
Added default implementations of various GtkCellArea vfuncs. Having default implementations on abstract classes that do nothing or print errors make life easier for language bindings implementors, inside GTK+ this makes little or no difference.
2011-02-03 10:03:49 +00:00
return GTK_CELL_AREA_GET_CLASS (area)->focus (area, direction);
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
}
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
/**
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* gtk_cell_area_activate:
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
* @area: a #GtkCellArea
Mass rename GtkCellAreaIter --> GtkCellAreaContext
2010-11-13 07:23:01 +00:00
* @context: the #GtkCellAreaContext in context with the current row data
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* @widget: the #GtkWidget that @area is rendering on
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* @cell_area: the size and location of @area relative to @widget’s allocation
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* @flags: the #GtkCellRendererState flags for @area for this row of data.
Added "edit_only" argument to gtk_cell_area_activate() This argument allows the caller to specify that only an editable cell should start editing but an activatable cell should not toggle it's state, this is important for public apis like gtk_tree_view_set_cursor_on_cell() which are only intended to programatically bring attention to the editing of a specific row or cell but not actually change any data. GtkTreeView & CellAreaScaffold updated for the last minute api change.
2010-12-12 08:15:46 +00:00
* @edit_only: if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE
* will be activated.
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
* Activates @area, usually by activating the currently focused
* cell, however some subclasses which embed widgets in the area
* can also activate a widget if it currently has the focus.
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: Whether @area was successfully activated.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*/
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
gboolean
Committing new (and simplified) focus handling approach for GtkCellArea. Also adding missing file cellareascaffold.h
2010-11-10 10:17:06 +00:00
gtk_cell_area_activate (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
GtkCellRendererState flags,
gboolean edit_only)
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
{
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
Added "edit_only" argument to gtk_cell_area_activate() This argument allows the caller to specify that only an editable cell should start editing but an activatable cell should not toggle it's state, this is important for public apis like gtk_tree_view_set_cursor_on_cell() which are only intended to programatically bring attention to the editing of a specific row or cell but not actually change any data. GtkTreeView & CellAreaScaffold updated for the last minute api change.
2010-12-12 08:15:46 +00:00
return GTK_CELL_AREA_GET_CLASS (area)->activate (area, context, widget, cell_area, flags, edit_only);
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
}
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
/**
* gtk_cell_area_set_focus_cell:
* @area: a #GtkCellArea
Fix some parameter name mismatches in the docs
2011-01-05 15:04:48 +00:00
* @renderer: the #GtkCellRenderer to give focus to
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*
Fixed documentation of gtk_cell_area_set_focus_cell().
2011-01-07 06:47:13 +00:00
* Explicitly sets the currently focused cell to @renderer.
*
* This is generally called by implementations of
* #GtkCellAreaClass.focus() or #GtkCellAreaClass.event(),
* however it can also be used to implement functions such
* as gtk_tree_view_set_cursor_on_cell().
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*/
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
void
gtk_cell_area_set_focus_cell (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
{
GtkCellAreaPrivate *priv;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (renderer == NULL || GTK_IS_CELL_RENDERER (renderer));
priv = area->priv;
if (priv->focus_cell != renderer)
{
if (priv->focus_cell)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_object_unref (priv->focus_cell);
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
priv->focus_cell = renderer;
if (priv->focus_cell)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_object_ref (priv->focus_cell);
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
g_object_notify (G_OBJECT (area), "focus-cell");
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
}
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
/* Signal that the current focus renderer for this path changed
* (it may be that the focus cell did not change, but the row
* may have changed so we need to signal it) */
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_signal_emit (area, cell_area_signals[SIGNAL_FOCUS_CHANGED], 0,
priv->focus_cell, priv->current_path);
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
}
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
/**
* gtk_cell_area_get_focus_cell:
* @area: a #GtkCellArea
*
* Retrieves the currently focused cell for @area
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (transfer none): the currently focused cell in @area.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Committing half-way done focus work.
2010-11-05 04:05:20 +00:00
*/
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
GtkCellRenderer *
gtk_cell_area_get_focus_cell (GtkCellArea *area)
{
GtkCellAreaPrivate *priv;
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
priv = area->priv;
return priv->focus_cell;
}
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
/*************************************************************
* API: Focus Siblings *
*************************************************************/
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_add_focus_sibling:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer expected to have focus
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* @sibling: the #GtkCellRenderer to add to @renderer’s focus area
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Adds @sibling to @renderer’s focusable area, focus will be drawn
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* around @renderer and all of its siblings if @renderer can
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
* focus for a given row.
*
* Events handled by focus siblings can also activate the given
* focusable @renderer.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
void
gtk_cell_area_add_focus_sibling (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellRenderer *sibling)
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
{
GtkCellAreaPrivate *priv;
GList *siblings;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (GTK_IS_CELL_RENDERER (sibling));
g_return_if_fail (renderer != sibling);
g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
g_return_if_fail (gtk_cell_area_has_renderer (area, sibling));
g_return_if_fail (!gtk_cell_area_is_focus_sibling (area, renderer, sibling));
/* XXX We should also check that sibling is not in any other renderer's sibling
* list already, a renderer can be sibling of only one focusable renderer
* at a time.
*/
priv = area->priv;
siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
if (siblings)
siblings = g_list_append (siblings, sibling);
else
{
siblings = g_list_append (siblings, sibling);
g_hash_table_insert (priv->focus_siblings, renderer, siblings);
}
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_remove_focus_sibling:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer expected to have focus
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* @sibling: the #GtkCellRenderer to remove from @renderer’s focus area
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Removes @sibling from @renderer’s focus sibling list
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
* (see gtk_cell_area_add_focus_sibling()).
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
void
gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellRenderer *sibling)
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
{
GtkCellAreaPrivate *priv;
GList *siblings;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (GTK_IS_CELL_RENDERER (sibling));
g_return_if_fail (gtk_cell_area_is_focus_sibling (area, renderer, sibling));
priv = area->priv;
siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
siblings = g_list_copy (siblings);
siblings = g_list_remove (siblings, sibling);
if (!siblings)
g_hash_table_remove (priv->focus_siblings, renderer);
else
g_hash_table_insert (priv->focus_siblings, renderer, siblings);
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_is_focus_sibling:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer expected to have focus
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* @sibling: the #GtkCellRenderer to check against @renderer’s sibling list
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
*
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* Returns whether @sibling is one of @renderer’s focus siblings
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
* (see gtk_cell_area_add_focus_sibling()).
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: %TRUE if @sibling is a focus sibling of @renderer
Add some missing symbols to the docs
2011-02-09 04:14:46 +00:00
*
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
gboolean
gtk_cell_area_is_focus_sibling (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellRenderer *sibling)
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
{
GtkCellAreaPrivate *priv;
GList *siblings, *l;
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
g_return_val_if_fail (GTK_IS_CELL_RENDERER (sibling), FALSE);
priv = area->priv;
siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
for (l = siblings; l; l = l->next)
{
GtkCellRenderer *a_sibling = l->data;
if (a_sibling == sibling)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
return TRUE;
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
}
return FALSE;
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_get_focus_siblings:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer expected to have focus
*
* Gets the focus sibling cell renderers for @renderer.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (element-type GtkCellRenderer) (transfer none): A #GList of #GtkCellRenderers.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* The returned list is internal and should not be freed.
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
const GList *
gtk_cell_area_get_focus_siblings (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
{
GtkCellAreaPrivate *priv;
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), NULL);
priv = area->priv;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
return g_hash_table_lookup (priv->focus_siblings, renderer);
GtkCellArea now paints focus on cells Added concept of "Focus Siblings" to GtkCellArea so that some static text/icon may be included in the focus/click area of an activatable or editable cell, implemented focus drawing as well, updated testcellarea to reflect the changes.
2010-11-11 07:13:06 +00:00
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_get_focus_from_sibling:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer
*
* Gets the #GtkCellRenderer which is expected to be focusable
* for which @renderer is, or may be a sibling.
*
* This is handy for #GtkCellArea subclasses when handling events,
* after determining the renderer at the event location it can
* then chose to activate the focus cell for which the event
* cell may have been a sibling.
*
introspection: This patch fixes nullable return values fixes for the following symbols in gtk gtk_accel_group_query gtk_accel_group_from_accel_closure gtk_accel_label_get_accel_widget gtk_accessible_get_widget gtk_actionable_get_action_name gtk_app_chooser_get_app_info gtk_app_chooser_button_get_heading gtk_app_chooser_dialog_get_heading gtk_application_get_window_by_id gtk_assistant_get_nth_page gtk_binding_set_find gtk_builder_get_object gtk_builder_lookup_callback_symbol gtk_builder_get_application gtk_button_get_image gtk_cell_area_get_focus_from_sibling gtk_cell_renderer_start_editing gtk_cell_view_get_model gtk_cell_view_get_displayed_row gtk_clipboard_get_owner gtk_container_get_focus_child gtk_container_get_focus_vadjustment gtk_container_get_focus_hadjustment gtk_dialog_get_widget_for_response gtk_drag_get_source_widget gtk_drag_dest_get_target_list gtk_drag_source_get_target_list gtk_entry_completion_get_model gtk_entry_completion_compute_prefix gtk_expander_get_label_widget gtk_file_chooser_get_filename gtk_file_chooser_get_current_folder gtk_file_chooser_get_uri gtk_file_chooser_get_current_folder_uri gtk_file_chooser_get_preview_widget gtk_file_chooser_get_preview_file gtk_file_chooser_get_preview_filename gtk_file_chooser_get_preview_uri gtk_file_chooser_get_extra_widget gtk_file_chooser_get_filter gtk_file_chooser_native_get_accept_label gtk_file_chooser_native_get_cancel_label gtk_file_filter_get_name gtk_font_chooser_get_font_family gtk_font_chooser_get_font_face gtk_font_chooser_get_font gtk_font_chooser_get_font_desc gtk_font_chooser_get_font_map gtk_frame_get_label gtk_gesture_get_device gtk_gesture_get_window gtk_gl_area_get_error gtk_header_bar_get_title gtk_header_bar_get_subtitle gtk_header_bar_get_custom_title gtk_icon_info_get_filename gtk_icon_view_get_path_at_pos gtk_icon_view_get_model gtk_image_get_pixbuf gtk_image_get_animation gtk_label_get_mnemonic_widget gtk_label_get_attributes gtk_check_version gtk_menu_button_get_popup gtk_menu_button_get_menu_model gtk_menu_button_get_align_widget gtk_menu_button_get_popover gtk_menu_item_get_submenu gtk_menu_item_get_accel_path gtk_native_dialog_get_title gtk_native_dialog_get_transient_for gtk_notebook_get_nth_page gtk_notebook_get_tab_label_text gtk_notebook_get_menu_label gtk_notebook_get_menu_label_text gtk_notebook_get_group_name gtk_notebook_get_action_widget gtk_offscreen_window_get_surface gtk_offscreen_window_get_pixbuf gtk_paned_get_child1 gtk_paned_get_child2 gtk_places_sidebar_get_location gtk_places_sidebar_get_nth_bookmark gtk_plug_get_socket_window gtk_popover_get_default_widget gtk_progress_bar_get_text gtk_recent_filter_get_name gtk_recent_manager_lookup_item gtk_settings_get_default gtk_socket_get_plug_window gtk_stack_sidebar_get_stack gtk_stack_switcher_get_stack gtk_style_context_get_section gtk_style_context_get_parent gtk_style_context_get_frame_clock gtk_test_find_widget gtk_text_buffer_get_mark gtk_text_tag_table_lookup gtk_text_view_get_tabs gtk_text_view_toggle_cursor_visible gtk_text_view_get_window gtk_toolbar_get_nth_item gtk_tool_button_get_label gtk_tool_button_get_icon_name gtk_tool_button_get_label_widget gtk_tool_button_get_icon_widget gtk_tool_palette_get_drop_item gtk_tool_palette_get_drop_group gtk_tree_model_filter_convert_child_path_to_path gtk_tree_model_filter_convert_path_to_child_path gtk_tree_model_sort_convert_child_path_to_path gtk_tree_model_sort_convert_path_to_child_path gtk_tree_view_get_column gtk_tree_view_get_bin_window gtk_tree_view_column_get_widget gtk_tree_view_column_get_tree_view gtk_widget_get_frame_clock gtk_window_group_get_current_device_grab GtkTextBufferSerializeFunc
2015-12-28 20:14:08 +00:00
* Returns: (nullable) (transfer none): the #GtkCellRenderer for which @renderer
[GI] Add missing (transfer) annotations
2011-01-18 09:01:17 +00:00
* is a sibling, or %NULL.
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
GtkCellRenderer *
gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
{
GtkCellRenderer *ret_renderer = NULL;
GList *renderers, *l;
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), NULL);
renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
for (l = renderers; l; l = l->next)
{
GtkCellRenderer *a_renderer = l->data;
const GList *list;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
for (list = gtk_cell_area_get_focus_siblings (area, a_renderer);
list; list = list->next)
{
GtkCellRenderer *sibling_renderer = list->data;
if (sibling_renderer == renderer)
{
ret_renderer = a_renderer;
break;
}
}
Added event handling to GtkCellAreaBox Now GtkCellAreaBox handles the click event to activate renderers and checks if the area is in a sibling of a focus renderer, possibly activating the proper focus sibling renderer. Also GtkCellArea gains a "focus-changed" signal to allow it to change the currently focused row according to the button events.
2010-11-11 09:13:54 +00:00
}
g_list_free (renderers);
return ret_renderer;
}
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
/*************************************************************
* API: Cell Activation/Editing *
*************************************************************/
static void
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
gtk_cell_area_add_editable (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellEditable *editable,
const GdkRectangle *cell_area)
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
{
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_signal_emit (area, cell_area_signals[SIGNAL_ADD_EDITABLE], 0,
renderer, editable, cell_area, area->priv->current_path);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
}
static void
gtk_cell_area_remove_editable (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkCellEditable *editable)
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
{
g_signal_emit (area, cell_area_signals[SIGNAL_REMOVE_EDITABLE], 0, renderer, editable);
}
static void
cell_area_remove_widget_cb (GtkCellEditable *editable,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellArea *area)
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
{
GtkCellAreaPrivate *priv = area->priv;
g_assert (priv->edit_widget == editable);
g_assert (priv->edited_cell != NULL);
gtk_cell_area_remove_editable (area, priv->edited_cell, priv->edit_widget);
/* Now that we're done with editing the widget and it can be removed,
* remove our references to the widget and disconnect handlers */
gtk_cell_area_set_edited_cell (area, NULL);
gtk_cell_area_set_edit_widget (area, NULL);
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
static void
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
gtk_cell_area_set_edited_cell (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer)
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
{
GtkCellAreaPrivate *priv;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (renderer == NULL || GTK_IS_CELL_RENDERER (renderer));
priv = area->priv;
if (priv->edited_cell != renderer)
{
if (priv->edited_cell)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_object_unref (priv->edited_cell);
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
priv->edited_cell = renderer;
if (priv->edited_cell)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_object_ref (priv->edited_cell);
Made progress on focus handling. - Added vfunc to get the allocation of a cell inside an area - Superclass GtkCellArea handles activation of focused cells by handling key events (as well as editing of editable cells) - Added signal "editing-started" to GtkCellArea to signal that editing has started (generally signaled from inside event handling) - Added properties "focus-cell" and "edited-cell"
2010-11-05 13:16:32 +00:00
g_object_notify (G_OBJECT (area), "edited-cell");
}
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
static void
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
gtk_cell_area_set_edit_widget (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellEditable *editable)
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
{
GtkCellAreaPrivate *priv;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (editable == NULL || GTK_IS_CELL_EDITABLE (editable));
priv = area->priv;
if (priv->edit_widget != editable)
{
if (priv->edit_widget)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
g_signal_handler_disconnect (priv->edit_widget, priv->remove_widget_id);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_object_unref (priv->edit_widget);
}
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
priv->edit_widget = editable;
if (priv->edit_widget)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
priv->remove_widget_id =
g_signal_connect (priv->edit_widget, "remove-widget",
G_CALLBACK (cell_area_remove_widget_cb), area);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
g_object_ref (priv->edit_widget);
}
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
g_object_notify (G_OBJECT (area), "edit-widget");
}
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_get_edited_cell:
* @area: a #GtkCellArea
*
* Gets the #GtkCellRenderer in @area that is currently
* being edited.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (transfer none): The currently edited #GtkCellRenderer
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
GtkCellRenderer *
gtk_cell_area_get_edited_cell (GtkCellArea *area)
{
GtkCellAreaPrivate *priv;
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
priv = area->priv;
return priv->edited_cell;
}
/**
* gtk_cell_area_get_edit_widget:
* @area: a #GtkCellArea
*
* Gets the #GtkCellEditable widget currently used
* to edit the currently edited cell.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: (transfer none): The currently active #GtkCellEditable widget
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
GtkCellEditable *
gtk_cell_area_get_edit_widget (GtkCellArea *area)
{
GtkCellAreaPrivate *priv;
g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
priv = area->priv;
return priv->edit_widget;
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_activate_cell:
* @area: a #GtkCellArea
* @widget: the #GtkWidget that @area is rendering onto
* @renderer: the #GtkCellRenderer in @area to activate
* @event: the #GdkEvent for which cell activation should occur
* @cell_area: the #GdkRectangle in @widget relative coordinates
* of @renderer for the current row.
* @flags: the #GtkCellRendererState for @renderer
*
* This is used by #GtkCellArea subclasses when handling events
* to activate cells, the base #GtkCellArea class activates cells
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* for keyboard events for free in its own GtkCellArea->activate()
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
* implementation.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: whether cell activation was successful
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
gboolean
gtk_cell_area_activate_cell (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkWidget *widget,
GtkCellRenderer *renderer,
GdkEvent *event,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
{
GtkCellRendererMode mode;
GtkCellAreaPrivate *priv;
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
g_return_val_if_fail (cell_area != NULL, FALSE);
priv = area->priv;
Fixed GtkCellArea to never activate/start editing insensitive cells. Included extension to tests/testtreeedit to show this is working properly.
2011-01-10 08:56:51 +00:00
if (!gtk_cell_renderer_get_sensitive (renderer))
return FALSE;
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
g_object_get (renderer, "mode", &mode, NULL);
if (mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
{
if (gtk_cell_renderer_activate (renderer,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
event, widget,
priv->current_path,
cell_area,
cell_area,
flags))
return TRUE;
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
}
else if (mode == GTK_CELL_RENDERER_MODE_EDITABLE)
{
GtkCellEditable *editable_widget;
Should pass inner_area to cell in gtk_cell_area_activate_cell()
2010-12-16 21:42:10 +00:00
GdkRectangle inner_area;
gtk_cell_area_inner_cell_area (area, widget, cell_area, &inner_area);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
editable_widget =
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_renderer_start_editing (renderer,
event, widget,
priv->current_path,
&inner_area,
&inner_area,
flags);
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
if (editable_widget != NULL)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
g_return_val_if_fail (GTK_IS_CELL_EDITABLE (editable_widget), FALSE);
gtk_cell_area_set_edited_cell (area, renderer);
gtk_cell_area_set_edit_widget (area, editable_widget);
/* Signal that editing started so that callers can get
* a handle on the editable_widget */
gtk_cell_area_add_editable (area, priv->focus_cell, editable_widget, cell_area);
/* If the signal was successfully handled start the editing */
if (gtk_widget_get_parent (GTK_WIDGET (editable_widget)))
{
Fix mouse interaction in combo cell renderer Pass the event on when calling gtk_cell_editable_start_editing. https://bugzilla.gnome.org/show_bug.cgi?id=504901
2013-04-19 14:07:44 +00:00
gtk_cell_editable_start_editing (editable_widget, event);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_widget_grab_focus (GTK_WIDGET (editable_widget));
}
else
{
/* Otherwise clear the editing state and fire a warning */
gtk_cell_area_set_edited_cell (area, NULL);
gtk_cell_area_set_edit_widget (area, NULL);
g_warning ("GtkCellArea::add-editable fired in the dark, no cell editing was started.");
}
return TRUE;
}
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
}
return FALSE;
}
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
/**
* gtk_cell_area_stop_editing:
* @area: a #GtkCellArea
* @canceled: whether editing was canceled.
*
Fixed gtk_cell_area_stop_editing() to properly notify when editing is not canceled This fixes bug 653289, in gtk+-2 gtk_tree_view_stop_editing() was previously responsible for notifying with gtk_cell_editable_editing_done(), this detail was missed when porting the cell renderer management to GtkCellArea.
2011-10-03 23:32:00 +00:00
* Explicitly stops the editing of the currently edited cell.
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*
Fixed gtk_cell_area_stop_editing() to properly notify when editing is not canceled This fixes bug 653289, in gtk+-2 gtk_tree_view_stop_editing() was previously responsible for notifying with gtk_cell_editable_editing_done(), this detail was missed when porting the cell renderer management to GtkCellArea.
2011-10-03 23:32:00 +00:00
* If @canceled is %TRUE, the currently edited cell renderer
* will emit the ::editing-canceled signal, otherwise the
* the ::editing-done signal will be emitted on the current
* edit widget.
*
* See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
*
* Since: 3.0
Cleaned up cell editing api in GtkCellArea Now layouting widgets need only concern themselves with the "add-editable" and "remove-editable" signals, also added lots of gtk-doc comments.
2010-11-14 14:33:26 +00:00
*/
Added gtk_cell_area_stop_editing to allow explicit stopping of cell editing.
2010-11-06 06:42:37 +00:00
void
gtk_cell_area_stop_editing (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gboolean canceled)
Added gtk_cell_area_stop_editing to allow explicit stopping of cell editing.
2010-11-06 06:42:37 +00:00
{
GtkCellAreaPrivate *priv;
g_return_if_fail (GTK_IS_CELL_AREA (area));
priv = area->priv;
if (priv->edited_cell)
{
Ironed out the kinks in editing apis for GtkCellArea - Added gtk_cell_area_aligned_cell_area() to get the aligned internal area use by a cell (for focus painting and for event areas). - Provide the event area in "editing-started" signal - Fire "remove-editable" when editing is canceled by the user, an implementing layouting widget need only catch "editing-started" and "remove-editable" now. - CellAreaScaffold/testcellarea now edit textrenderers.
2010-11-12 10:25:07 +00:00
GtkCellEditable *edit_widget = g_object_ref (priv->edit_widget);
GtkCellRenderer *edit_cell = g_object_ref (priv->edited_cell);
Added gtk_cell_area_stop_editing to allow explicit stopping of cell editing.
2010-11-06 06:42:37 +00:00
/* Stop editing of the cell renderer */
gtk_cell_renderer_stop_editing (priv->edited_cell, canceled);
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
Fixed gtk_cell_area_stop_editing() to properly notify when editing is not canceled This fixes bug 653289, in gtk+-2 gtk_tree_view_stop_editing() was previously responsible for notifying with gtk_cell_editable_editing_done(), this detail was missed when porting the cell renderer management to GtkCellArea.
2011-10-03 23:32:00 +00:00
/* When editing is explicitly halted either
* the "editing-canceled" signal is emitted on the cell
* renderer or the "editing-done" signal on the GtkCellEditable widget
*/
if (!canceled)
gtk_cell_editable_editing_done (edit_widget);
Added gtk_cell_area_stop_editing to allow explicit stopping of cell editing.
2010-11-06 06:42:37 +00:00
/* Remove any references to the editable widget */
gtk_cell_area_set_edited_cell (area, NULL);
gtk_cell_area_set_edit_widget (area, NULL);
Ironed out the kinks in editing apis for GtkCellArea - Added gtk_cell_area_aligned_cell_area() to get the aligned internal area use by a cell (for focus painting and for event areas). - Provide the event area in "editing-started" signal - Fire "remove-editable" when editing is canceled by the user, an implementing layouting widget need only catch "editing-started" and "remove-editable" now. - CellAreaScaffold/testcellarea now edit textrenderers.
2010-11-12 10:25:07 +00:00
/* Send the remove-widget signal explicitly (this is done after setting
* the edit cell/widget NULL to avoid feedback)
*/
gtk_cell_area_remove_editable (area, edit_cell, edit_widget);
g_object_unref (edit_cell);
g_object_unref (edit_widget);
Added gtk_cell_area_stop_editing to allow explicit stopping of cell editing.
2010-11-06 06:42:37 +00:00
}
}
Added gtk_cell_area_activate_cell() and some cell editing management Now: - The current edit cell and editable widget in use can be fetched with properties and accessors - gtk_cell_area_activate_cell() handles bookkeeping of the currently edited cell, starting the editing of a cell, activating a cell etc - Exported signals are available on GtkCellArea: "editing-started", "editing-canceled", "editing-done", "remove-editable". - Upon receiving GDK_KEY_Escape current editing gets canceled.
2010-11-06 06:29:27 +00:00
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
/*************************************************************
Removed cell margin apis and now deal with "focus-line-width".
2010-11-23 07:26:46 +00:00
* API: Convenience for area implementations *
Added cell focus apis to GtkCellArea.
2010-11-01 07:01:25 +00:00
*************************************************************/
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
/**
* gtk_cell_area_inner_cell_area:
* @area: a #GtkCellArea
* @widget: the #GtkWidget that @area is rendering onto
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* @cell_area: the @widget relative coordinates where one of @area’s cells
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* is to be placed
* @inner_area: (out): the return location for the inner cell area
*
* This is a convenience function for #GtkCellArea implementations
* to get the inner area where a given #GtkCellRenderer will be
* rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
*
* Since: 3.0
*/
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
void
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
gtk_cell_area_inner_cell_area (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkWidget *widget,
const GdkRectangle *cell_area,
GdkRectangle *inner_area)
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
{
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
GtkBorder border;
GtkStyleContext *context;
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
Removed cell margin apis and now deal with "focus-line-width".
2010-11-23 07:26:46 +00:00
g_return_if_fail (GTK_IS_WIDGET (widget));
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
g_return_if_fail (cell_area != NULL);
Ironed out the kinks in editing apis for GtkCellArea - Added gtk_cell_area_aligned_cell_area() to get the aligned internal area use by a cell (for focus painting and for event areas). - Provide the event area in "editing-started" signal - Fire "remove-editable" when editing is canceled by the user, an implementing layouting widget need only catch "editing-started" and "remove-editable" now. - CellAreaScaffold/testcellarea now edit textrenderers.
2010-11-12 10:25:07 +00:00
g_return_if_fail (inner_area != NULL);
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
context = gtk_widget_get_style_context (widget);
API: stylecontext: Remove state argument from getters The argument must always be the current state.
2016-10-08 03:07:23 +00:00
gtk_style_context_get_padding (context, &border);
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
Ironed out the kinks in editing apis for GtkCellArea - Added gtk_cell_area_aligned_cell_area() to get the aligned internal area use by a cell (for focus painting and for event areas). - Provide the event area in "editing-started" signal - Fire "remove-editable" when editing is canceled by the user, an implementing layouting widget need only catch "editing-started" and "remove-editable" now. - CellAreaScaffold/testcellarea now edit textrenderers.
2010-11-12 10:25:07 +00:00
*inner_area = *cell_area;
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
inner_area->x += border.left;
inner_area->width -= border.left + border.right;
inner_area->y += border.top;
inner_area->height -= border.top + border.bottom;
Ironed out the kinks in editing apis for GtkCellArea - Added gtk_cell_area_aligned_cell_area() to get the aligned internal area use by a cell (for focus painting and for event areas). - Provide the event area in "editing-started" signal - Fire "remove-editable" when editing is canceled by the user, an implementing layouting widget need only catch "editing-started" and "remove-editable" now. - CellAreaScaffold/testcellarea now edit textrenderers.
2010-11-12 10:25:07 +00:00
}
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
/**
* gtk_cell_area_request_renderer:
* @area: a #GtkCellArea
* @renderer: the #GtkCellRenderer to request size for
* @orientation: the #GtkOrientation in which to request size
* @widget: the #GtkWidget that @area is rendering onto
* @for_size: the allocation contextual size to request for, or -1 if
* the base request for the orientation is to be returned.
* @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
* @natural_size: (out) (allow-none): location to store the natural size, or %NULL
*
* This is a convenience function for #GtkCellArea implementations
docs: use proper apostrophe https://wiki.gnome.org/Design/OS/Typography
2014-02-07 18:01:26 +00:00
* to request size for cell renderers. It’s important to use this
Added gtk-doc to GtkCellArea & GtkCellAreaContext.
2010-12-03 07:29:11 +00:00
* function to request size and then use gtk_cell_area_inner_cell_area()
* at render and event time since this function will add padding
* around the cell for focus painting.
*
* Since: 3.0
*/
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
void
gtk_cell_area_request_renderer (GtkCellArea *area,
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
GtkCellRenderer *renderer,
GtkOrientation orientation,
GtkWidget *widget,
gint for_size,
gint *minimum_size,
gint *natural_size)
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
{
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
GtkBorder border;
GtkStyleContext *context;
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (minimum_size != NULL);
g_return_if_fail (natural_size != NULL);
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
context = gtk_widget_get_style_context (widget);
API: stylecontext: Remove state argument from getters The argument must always be the current state.
2016-10-08 03:07:23 +00:00
gtk_style_context_get_padding (context, &border);
Removed cell margin apis and now deal with "focus-line-width".
2010-11-23 07:26:46 +00:00
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
if (for_size < 0)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_renderer_get_preferred_width (renderer, widget, minimum_size, natural_size);
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
for_size = MAX (0, for_size - border.left - border.right);
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_renderer_get_preferred_width_for_height (renderer, widget, for_size,
minimum_size, natural_size);
}
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
*minimum_size += border.left + border.right;
*natural_size += border.left + border.right;
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
}
else /* GTK_ORIENTATION_VERTICAL */
{
if (for_size < 0)
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_renderer_get_preferred_height (renderer, widget, minimum_size, natural_size);
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
else
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
{
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
for_size = MAX (0, for_size - border.top - border.bottom);
Changed GtkCellArea margin-left/right... for cell-margin-left/right... The rationale here is that every cell in an area needs to have space reserved around it, requests have to be fully margin inclusive... cells need to have the full size fed as the "background area" and the "cell area" has margins removed... This will be used by GtkTreeViewColumn to set the focus line width so that cells can paint a background on the full background, then render themselves into the cell area... and parents can go ahead and draw focus and other indicators on the background area but outside of the cell area.
2010-10-31 13:50:53 +00:00
Trivial changes Whitespace fixes, comment formatting, etc
2010-12-18 00:14:35 +00:00
gtk_cell_renderer_get_preferred_height_for_width (renderer, widget, for_size,
minimum_size, natural_size);
}
Removed cell margin apis and now deal with "focus-line-width".
2010-11-23 07:26:46 +00:00
cellarea: don't use focus-line-width Use CSS padding instead.
2014-05-04 18:01:12 +00:00
*minimum_size += border.top + border.bottom;
*natural_size += border.top + border.bottom;
}
Added margins to the cell area Added margin properties to the cell area, margins will be removed from the area given to ->render() when creating the inner cell area.
2010-10-31 09:55:51 +00:00
}
Fixed gtk_cell_layout_set_cell_data_func() to pass the correct layout object Added _gtk_cell_area_set_cell_data_func_with_proxy() to be called by gtk_cell_layout_set_cell_data_func() when the layouting object itself is not the underlying cell area.
2010-12-20 10:37:30 +00:00
void
_gtk_cell_area_set_cell_data_func_with_proxy (GtkCellArea *area,
GtkCellRenderer *cell,
GFunc func,
gpointer func_data,
GDestroyNotify destroy,
gpointer proxy)
{
GtkCellAreaPrivate *priv;
CellInfo *info;
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
priv = area->priv;
info = g_hash_table_lookup (priv->cell_info, cell);
/* Note we do not take a reference to the proxy, the proxy is a GtkCellLayout
Minor documentation improvements Mostly correcting it's to its and changing some , to .
2011-02-23 09:26:21 +00:00
* that is forwarding its implementation to a delegate GtkCellArea therefore
* its life-cycle is longer than the area's life cycle.
Fixed gtk_cell_layout_set_cell_data_func() to pass the correct layout object Added _gtk_cell_area_set_cell_data_func_with_proxy() to be called by gtk_cell_layout_set_cell_data_func() when the layouting object itself is not the underlying cell area.
2010-12-20 10:37:30 +00:00
*/
if (info)
{
if (info->destroy && info->data)
info->destroy (info->data);
if (func)
{
info->func = (GtkCellLayoutDataFunc)func;
info->data = func_data;
info->destroy = destroy;
info->proxy = proxy;
}
else
{
info->func = NULL;
info->data = NULL;
info->destroy = NULL;
info->proxy = NULL;
}
}
else
{
info = cell_info_new ((GtkCellLayoutDataFunc)func, func_data, destroy);
_gtk_cell_area_set_cell_data_func_with_proxy: set the proxy when creating a new CellInfo (#637965)
2011-01-12 13:33:27 +00:00
info->proxy = proxy;
Fixed gtk_cell_layout_set_cell_data_func() to pass the correct layout object Added _gtk_cell_area_set_cell_data_func_with_proxy() to be called by gtk_cell_layout_set_cell_data_func() when the layouting object itself is not the underlying cell area.
2010-12-20 10:37:30 +00:00
g_hash_table_insert (priv->cell_info, cell, info);
}
}
Reference in New Issue Copy Permalink