2005-09-13 Matthias Clasen <mclasen@redhat.com>
+ * gtk/*.c: Various cleanups. (#315360, Kjartan Maraas)
+
* gdk/*.c: Various cleanups. (#315359, Kjartan Maraas)
2005-09-13 Matthias Clasen <mclasen@redhat.com>
2005-09-13 Matthias Clasen <mclasen@redhat.com>
+ * gtk/*.c: Various cleanups. (#315360, Kjartan Maraas)
+
* gdk/*.c: Various cleanups. (#315359, Kjartan Maraas)
2005-09-13 Matthias Clasen <mclasen@redhat.com>
{
GObjectClass *object_class;
GtkWidgetClass *widget_class;
- GtkDialogClass *dialog_class;
object_class = (GObjectClass *)klass;
widget_class = (GtkWidgetClass *)klass;
- dialog_class = (GtkDialogClass *)klass;
object_class->set_property = gtk_about_dialog_set_property;
object_class->get_property = gtk_about_dialog_get_property;
gboolean
gtk_accel_label_refetch (GtkAccelLabel *accel_label)
{
- GtkAccelLabelClass *class;
-
g_return_val_if_fail (GTK_IS_ACCEL_LABEL (accel_label), FALSE);
- class = GTK_ACCEL_LABEL_GET_CLASS (accel_label);
-
if (accel_label->accel_string)
{
g_free (accel_label->accel_string);
if (change_accel && !simulate)
{
- guint old_accel_key, old_accel_mods;
-
/* ref accel groups */
for (slist = group_list; slist; slist = slist->next)
g_object_ref (slist->data);
internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, FALSE);
/* 9) install new accelerator */
- old_accel_key = entry->accel_key;
- old_accel_mods = entry->accel_mods;
entry->accel_key = accel_key;
entry->accel_mods = accel_mods;
entry->changed = TRUE;
gtk_alignment_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkAlignment *alignment;
GtkBin *bin;
GtkAlignmentPrivate *priv;
- alignment = GTK_ALIGNMENT (widget);
bin = GTK_BIN (widget);
priv = GTK_ALIGNMENT_GET_PRIVATE (widget);
calendar_set_year_next (GtkCalendar *calendar)
{
gint month_len;
- GtkWidget *widget;
g_return_if_fail (GTK_IS_WIDGET (calendar));
- widget = GTK_WIDGET (calendar);
-
calendar->year++;
calendar_compute_days (calendar);
g_signal_emit (calendar,
GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
gint xthickness = widget->style->xthickness;
gint ythickness = widget->style->xthickness;
- gboolean year_left;
guint i;
widget->allocation = *allocation;
-
- if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
- year_left = priv->year_before;
- else
- year_left = !priv->year_before;
-
+
if (calendar->display_flags & GTK_CALENDAR_SHOW_WEEK_NUMBERS)
{
priv->day_width = (priv->min_day_width
cairo_t *cr;
char buffer[255];
int x, y;
- gint header_width, cal_height;
+ gint header_width;
gint max_month_width;
gint max_year_width;
PangoLayout *layout;
cr = gdk_cairo_create (priv->header_win);
header_width = widget->allocation.width - 2 * widget->style->xthickness;
- cal_height = widget->allocation.height;
max_month_width = priv->max_month_width;
max_year_width = priv->max_year_width;
char buffer[255];
int day,i;
int day_width, cal_width;
- gint cal_height;
int day_wid_sep;
PangoLayout *layout;
PangoRectangle logical_rect;
day_width = priv->day_width;
cal_width = widget->allocation.width;
- cal_height = widget->allocation.height;
day_wid_sep = day_width + DAY_XSEP;
/*
}
else
{
- /*
+#if 0
if (calendar->highlight_row == row && calendar->highlight_col == col)
{
cairo_set_source_color (cr, HIGHLIGHT_BG_COLOR (widget));
gdk_cairo_rectangle (cr, &day_rect);
cairo_fill (cr);
}
- */
+#endif
if (calendar->selected_day == day)
{
gdk_cairo_set_source_color (cr, SELECTED_BG_COLOR (widget));
gtk_check_button_expose (GtkWidget *widget,
GdkEventExpose *event)
{
- GtkCheckButton *check_button;
GtkToggleButton *toggle_button;
GtkBin *bin;
- check_button = GTK_CHECK_BUTTON (widget);
toggle_button = GTK_TOGGLE_BUTTON (widget);
bin = GTK_BIN (widget);
real_remove_row (GtkCList *clist,
gint row)
{
- gint was_visible, was_selected;
+ gint was_visible;
GList *list;
GtkCListRow *clist_row;
return;
was_visible = (gtk_clist_row_is_visible (clist, row) != GTK_VISIBILITY_NONE);
- was_selected = 0;
/* get the row we're going to delete */
list = ROW_ELEMENT (clist, row);
gtk_color_button_class_init (GtkColorButtonClass *klass)
{
GObjectClass *gobject_class;
- GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkButtonClass *button_class;
gobject_class = G_OBJECT_CLASS (klass);
- object_class = GTK_OBJECT_CLASS (klass);
widget_class = GTK_WIDGET_CLASS (klass);
button_class = GTK_BUTTON_CLASS (klass);
gpointer data)
{
GtkColorSelection *colorsel = data;
- ColorSelectionPrivate *priv;
- priv = colorsel->private_data;
if (event->button != 1)
return FALSE;
gpointer data)
{
GtkColorSelection *colorsel = data;
- ColorSelectionPrivate *priv;
- priv = colorsel->private_data;
if (event->type == GDK_BUTTON_PRESS &&
event->button == 1)
{
ColorSelectionPrivate *priv;
gint i;
- gboolean previous_changed;
g_return_if_fail (GTK_IS_COLOR_SELECTION (colorsel));
g_return_if_fail (color != NULL);
&priv->color[COLORSEL_VALUE]);
if (priv->default_set == FALSE)
{
- previous_changed = TRUE;
for (i = 0; i < COLORSEL_NUM_CHANNELS; i++)
priv->old_color[i] = priv->color[i];
}
static void
gtk_color_selection_dialog_init (GtkColorSelectionDialog *colorseldiag)
{
- GtkWidget *action_area_button_box, *frame;
+ GtkWidget *frame;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (frame), colorseldiag->colorsel);
gtk_widget_show (colorseldiag->colorsel);
- action_area_button_box = GTK_DIALOG (colorseldiag)->action_area;
-
colorseldiag->cancel_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_combo_box_class_init (GtkComboBoxClass *klass)
{
GObjectClass *object_class;
- GtkBindingSet *binding_set;
GtkObjectClass *gtk_object_class;
GtkContainerClass *container_class;
GtkWidgetClass *widget_class;
- binding_set = gtk_binding_set_by_class (klass);
-
klass->get_active_text = gtk_combo_box_real_get_active_text;
container_class = (GtkContainerClass *)klass;
const gchar *first_property_name,
va_list var_args)
{
- GObject *object;
GObjectNotifyQueue *nqueue;
const gchar *name;
g_object_ref (container);
g_object_ref (child);
- object = G_OBJECT (container);
nqueue = g_object_notify_queue_freeze (G_OBJECT (child), _gtk_widget_child_property_notify_context);
name = first_property_name;
while (name)
const gchar *property_name,
const GValue *value)
{
- GObject *object;
GObjectNotifyQueue *nqueue;
GParamSpec *pspec;
g_object_ref (container);
g_object_ref (child);
- object = G_OBJECT (container);
nqueue = g_object_notify_queue_freeze (G_OBJECT (child), _gtk_widget_child_property_notify_context);
pspec = g_param_spec_pool_lookup (_gtk_widget_child_property_pool, property_name,
G_OBJECT_TYPE (container), TRUE);
{
GdkCursorType new_type = c->cursor_type;
gint i, src, dst, leftbound, rightbound;
- GdkEventButton *bevent;
GdkEventMotion *mevent;
GtkWidget *w;
gint tx, ty;
case GDK_BUTTON_PRESS:
gtk_grab_add (widget);
- bevent = (GdkEventButton *) event;
new_type = GDK_TCROSS;
switch (c->curve_type)
if (gtk_drag_check_threshold (widget, site->x, site->y,
event->motion.x, event->motion.y))
{
- GdkDragContext *context;
-
site->state = 0;
- context = gtk_drag_begin_internal (widget, site, site->target_list,
- site->actions,
- i, event);
+ gtk_drag_begin_internal (widget, site, site->target_list,
+ site->actions,
+ i, event);
retval = TRUE;
}
gtk_entry_realize (GtkWidget *widget)
{
GtkEntry *entry;
- GtkEditable *editable;
GdkWindowAttr attributes;
gint attributes_mask;
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
entry = GTK_ENTRY (widget);
- editable = GTK_EDITABLE (widget);
attributes.window_type = GDK_WINDOW_CHILD;
GdkDragContext *context,
gpointer data)
{
- GtkEntry *entry;
-
g_signal_handlers_disconnect_by_func (widget, drag_begin_cb, NULL);
-
- entry = GTK_ENTRY (widget);
-
}
static gint
gboolean visible_window)
{
GtkWidget *widget;
- GtkEventBoxPrivate *priv;
g_return_if_fail (GTK_IS_EVENT_BOX (event_box));
widget = GTK_WIDGET (event_box);
- priv = GTK_EVENT_BOX_GET_PRIVATE (event_box);
visible_window = visible_window != FALSE;
static void
gtk_event_box_unrealize (GtkWidget *widget)
{
- GtkEventBox *event_box;
GtkEventBoxPrivate *priv;
- event_box = GTK_EVENT_BOX (widget);
priv = GTK_EVENT_BOX_GET_PRIVATE (widget);
if (priv->event_window != NULL)
GdkRectangle *rect)
{
GtkWidget *widget;
- GtkBin *bin;
GtkExpanderPrivate *priv;
gint border_width;
gint expander_size;
gboolean ltr;
widget = GTK_WIDGET (expander);
- bin = GTK_BIN (expander);
priv = expander->priv;
border_width = GTK_CONTAINER (expander)->border_width;
gtk_file_chooser_button_style_set (GtkWidget *widget,
GtkStyle *old_style)
{
- GtkFileChooserButtonPrivate *priv;
-
if (GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->style_set)
(*GTK_WIDGET_CLASS (gtk_file_chooser_button_parent_class)->style_set) (widget,
old_style);
- priv = GTK_FILE_CHOOSER_BUTTON_GET_PRIVATE (widget);
-
if (gtk_widget_has_screen (widget))
change_icon_theme (GTK_FILE_CHOOSER_BUTTON (widget));
}
for (; paths; paths = paths->next)
{
GtkFilePath *path;
- GError *error;
path = paths->data;
- error = NULL;
if (impl->local_only &&
!gtk_file_system_path_is_local (impl->file_system, path))
GtkWidget *entry_vbox;
GtkWidget *label;
GtkWidget *list_hbox, *list_container;
- GtkWidget *confirm_area;
GtkWidget *pulldown_hbox;
GtkWidget *scrolled_win;
GtkWidget *eventbox;
gtk_widget_show (filesel->action_area);
/* The OK/Cancel button area */
- confirm_area = dialog->action_area;
/* The Cancel button */
filesel->cancel_button = gtk_dialog_add_button (dialog,
attempt_homedir_completion (gchar *text_to_complete,
CompletionState *cmpl_state)
{
- gint index, length;
+ gint index;
if (!cmpl_state->user_dir_name_buffer &&
!get_pwdb (cmpl_state))
return NULL;
- length = strlen (text_to_complete) - 1;
cmpl_state->user_completion_index += 1;
{
GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
FileModelNode *children;
- FileModelNode *prev = NULL;
GtkTreeIter iter;
GtkTreePath *path;
GSList *sorted_paths;
if (parent_node && parent_node->has_dummy)
{
- prev = children;
children = children->next;
gtk_tree_path_next (path);
}
while (children &&
(!children->path || gtk_file_path_compare (children->path, file_path) < 0))
{
- prev = children;
if (children->is_visible)
gtk_tree_path_next (path);
static void
gtk_font_button_class_init (GtkFontButtonClass *klass)
{
- GtkObjectClass *object_class;
GObjectClass *gobject_class;
GtkButtonClass *button_class;
- object_class = (GtkObjectClass *) klass;
gobject_class = (GObjectClass *) klass;
button_class = (GtkButtonClass *) klass;
GtkFontSelection *fontsel;
GtkTreeModel *model;
GtkTreeIter iter;
+#ifdef INCLUDE_FONT_ENTRIES
const gchar *family_name;
-
+#endif
+
fontsel = GTK_FONT_SELECTION (data);
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
fontsel->family = family;
- family_name = pango_font_family_get_name (fontsel->family);
-
#ifdef INCLUDE_FONT_ENTRIES
+ family_name = pango_font_family_get_name (fontsel->family);
gtk_entry_set_text (GTK_ENTRY (fontsel->font_entry), family_name);
#endif
{
gint i;
GtkListStore *model;
- GtkTreeSelection *selection;
gchar buffer[128];
gchar *p;
model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (fontsel->size_list)));
- selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (fontsel->size_list));
/* Insert the standard font sizes */
if (first_time)
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- GtkWidget *child;
GtkAllocation child_allocation;
guint border_width;
- child = bin->child;
border_width = GTK_CONTAINER (widget)->border_width;
child_allocation.x = border_width;
{
GtkBin *bin;
GtkHandleBox *hb;
- guint width;
- guint height;
+ guint width, height;
GdkRectangle rect;
GdkRectangle dest;
gint handle_position;
{
GtkBox *base_box;
GtkButtonBox *box;
- GtkHButtonBox *hbox;
GtkBoxChild *child;
GList *children;
GtkAllocation child_allocation;
base_box = GTK_BOX (widget);
box = GTK_BUTTON_BOX (widget);
- hbox = GTK_HBUTTON_BOX (widget);
spacing = base_box->spacing;
layout = box->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
? box->layout_style : default_layout_style;
gdouble *s,
gdouble *v)
{
- HSVPrivate *priv;
int ihx, ihy, isx, isy, ivx, ivy;
double hx, hy, sx, sy, vx, vy;
double center;
- priv = hsv->priv;
-
compute_triangle (hsv, &ihx, &ihy, &isx, &isy, &ivx, &ivy);
center = GTK_WIDGET (hsv)->requisition.width / 2.0;
hx = ihx - center;
gdouble x,
gdouble y)
{
- HSVPrivate *priv;
double center;
double dx, dy;
double angle;
- priv = hsv->priv;
-
center = GTK_WIDGET (hsv)->requisition.width / 2.0;
dx = x - center;
dy = center - y;
GtkCellRenderer *cell,
gboolean start_editing)
{
- GtkIconViewItem *item;
+ GtkIconViewItem *item = NULL;
GtkIconViewCellInfo *info = NULL;
GList *l;
gint i, cell_pos;
gint *maximum_width)
{
gint focus_width;
- gint spacing;
gint x, current_width;
GList *items, *last_item;
gint col;
"focus-line-width", &focus_width,
NULL);
- spacing = icon_view->priv->spacing;
-
x += icon_view->priv->margin + focus_width;
current_width += 2 * (icon_view->priv->margin + focus_width);
gboolean draw_focus)
{
gint focus_width, focus_pad;
- gint spacing, padding;
+ gint padding;
GdkRectangle cell_area, box;
GList *l;
gint i;
GtkStateType state;
- gboolean rtl;
GtkCellRendererState flags;
if (icon_view->priv->model == NULL)
gtk_icon_view_set_cell_data (icon_view, item);
- rtl = gtk_widget_get_direction (GTK_WIDGET (icon_view)) == GTK_TEXT_DIR_RTL;
-
gtk_widget_style_get (GTK_WIDGET (icon_view),
"focus-line-width", &focus_width,
"focus-padding", &focus_pad,
NULL);
- spacing = icon_view->priv->spacing;
padding = focus_width;
if (item->selected)
GtkTreeIter *iter,
gpointer data)
{
- gint length, index;
+ gint index;
GtkIconViewItem *item;
gboolean iters_persist;
GtkIconView *icon_view;
iters_persist = gtk_tree_model_get_flags (icon_view->priv->model) & GTK_TREE_MODEL_ITERS_PERSIST;
- length = gtk_tree_model_iter_n_children (model, NULL);
index = gtk_tree_path_get_indices(path)[0];
item = gtk_icon_view_item_new ();
if (use_align)
{
- gint x, y, width, height;
+ gint x, y;
gint focus_width;
gfloat offset, value;
{
gint start_index = -1;
gint end_index = -1;
- GtkIconViewItem *item;
GList *icons;
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), FALSE);
guint time)
{
GtkTreePath *path = NULL;
- GtkTreeModel *model;
GtkIconViewDropPosition pos;
GtkIconView *icon_view;
GdkDragAction suggested_action = 0;
gtk_icon_view_get_drag_dest_item (icon_view, &path, &pos);
/* we only know this *after* set_desination_row */
- model = gtk_icon_view_get_model (icon_view);
empty = icon_view->priv->empty_view_drop;
if (path == NULL && !empty)
gint i)
{
GtkIconViewItemAccessible *item;
- GtkIconView *icon_view;
if (i < 0 || i >= LAST_ACTION)
return FALSE;
if (atk_state_set_contains_state (item->state_set, ATK_STATE_DEFUNCT))
return FALSE;
- icon_view = GTK_ICON_VIEW (item->widget);
-
switch (i)
{
case ACTION_ACTIVATE:
return unichar;
}
+#if 0
static void
get_pango_text_offsets (PangoLayout *layout,
GtkTextBuffer *buffer,
gtk_text_buffer_get_iter_at_offset (buffer, start_iter, *start_offset);
gtk_text_buffer_get_iter_at_offset (buffer, end_iter, *end_offset);
}
+#endif
static gchar*
gtk_icon_view_item_accessible_text_get_text_before_offset (AtkText *text,
GtkIconViewItemAccessible *item;
GtkTextIter start, end;
GtkTextBuffer *buffer;
+#if 0
GtkIconView *icon_view;
+#endif
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);
break;
case ATK_TEXT_BOUNDARY_LINE_START:
case ATK_TEXT_BOUNDARY_LINE_END:
- icon_view = GTK_ICON_VIEW (item->widget);
#if 0
+ icon_view = GTK_ICON_VIEW (item->widget);
/* FIXME we probably have to use GailTextCell to salvage this */
gtk_icon_view_update_item_text (icon_view, item->item);
get_pango_text_offsets (icon_view->priv->layout,
GtkIconViewItemAccessible *item;
GtkTextIter start, end;
GtkTextBuffer *buffer;
+#if 0
GtkIconView *icon_view;
+#endif
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);
break;
case ATK_TEXT_BOUNDARY_LINE_START:
case ATK_TEXT_BOUNDARY_LINE_END:
- icon_view = GTK_ICON_VIEW (item->widget);
#if 0
+ icon_view = GTK_ICON_VIEW (item->widget);
/* FIXME we probably have to use GailTextCell to salvage this */
gtk_icon_view_update_item_text (icon_view, item->item);
get_pango_text_offsets (icon_view->priv->layout,
GtkIconViewItemAccessible *item;
GtkTextIter start, end;
GtkTextBuffer *buffer;
+#if 0
GtkIconView *icon_view;
+#endif
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);
break;
case ATK_TEXT_BOUNDARY_LINE_START:
case ATK_TEXT_BOUNDARY_LINE_END:
- icon_view = GTK_ICON_VIEW (item->widget);
#if 0
+ icon_view = GTK_ICON_VIEW (item->widget);
/* FIXME we probably have to use GailTextCell to salvage this */
gtk_icon_view_update_item_text (icon_view, item->item);
get_pango_text_offsets (icon_view->priv->layout,
AtkCoordType coord_type)
{
GtkIconViewItemAccessible *item;
+#if 0
GtkIconView *icon_view;
PangoRectangle char_rect;
const gchar *item_text;
gint index;
+#endif
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);
if (atk_state_set_contains_state (item->state_set, ATK_STATE_DEFUNCT))
return;
- icon_view = GTK_ICON_VIEW (item->widget);
#if 0
+ icon_view = GTK_ICON_VIEW (item->widget);
/* FIXME we probably have to use GailTextCell to salvage this */
gtk_icon_view_update_item_text (icon_view, item->item);
item_text = pango_layout_get_text (icon_view->priv->layout);
AtkCoordType coord_type)
{
GtkIconViewItemAccessible *item;
+ gint offset = 0;
+#if 0
GtkIconView *icon_view;
const gchar *item_text;
gint index;
- gint offset;
gint l_x, l_y;
+#endif
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);
if (atk_state_set_contains_state (item->state_set, ATK_STATE_DEFUNCT))
return -1;
- icon_view = GTK_ICON_VIEW (item->widget);
#if 0
+ icon_view = GTK_ICON_VIEW (item->widget);
/* FIXME we probably have to use GailTextCell to salvage this */
gtk_icon_view_update_item_text (icon_view, item->item);
atk_component_get_position (ATK_COMPONENT (text), &l_x, &l_y, coord_type);
GtkIconView *icon_view;
GtkWidget *widget;
AtkObject *atk_obj;
- GtkIconViewAccessible *view;
GtkIconViewAccessiblePrivate *priv;
if (strcmp (pspec->name, "model") == 0)
{
widget = GTK_WIDGET (obj);
atk_obj = gtk_widget_get_accessible (widget);
- view = GTK_ICON_VIEW_ACCESSIBLE (atk_obj);
priv = gtk_icon_view_accessible_get_priv (atk_obj);
if (priv->model)
{
GParamSpec *pspec)
{
GtkImage *image;
- GtkImagePrivate *priv;
image = GTK_IMAGE (object);
- priv = GTK_IMAGE_GET_PRIVATE (image);
switch (prop_id)
{
static void
gtk_item_factory_init (GtkItemFactory *ifactory)
{
- GtkObject *object;
-
- object = GTK_OBJECT (ifactory);
-
ifactory->path = NULL;
ifactory->accel_group = NULL;
ifactory->widget = NULL;
gtk_item_factory_delete_item (GtkItemFactory *ifactory,
const gchar *path)
{
- GtkItemFactoryClass *class;
GtkWidget *widget;
g_return_if_fail (GTK_IS_ITEM_FACTORY (ifactory));
g_return_if_fail (path != NULL);
- class = GTK_ITEM_FACTORY_GET_CLASS (ifactory);
-
widget = gtk_item_factory_get_widget (ifactory, path);
if (widget)
{
GtkWidget *widget;
PangoRectangle logical_rect;
- gint rwidth, rheight;
gboolean rtl;
widget = GTK_WIDGET (label);
rtl = gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL;
- rwidth = label->misc.xpad * 2;
- rheight = label->misc.ypad * 2;
if (!label->layout)
{
GtkAllocation *allocation)
{
GtkLabel *label;
- GtkLabelPrivate *priv;
label = GTK_LABEL (widget);
- priv = GTK_LABEL_GET_PRIVATE (widget);
(* GTK_WIDGET_CLASS (parent_class)->size_allocate) (widget, allocation);
label->select_info->drag_start_y,
event->x, event->y))
{
- GdkDragContext *context;
GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_text_targets (target_list, 0);
g_signal_connect (widget, "drag-begin",
G_CALLBACK (drag_begin_cb), NULL);
- context = gtk_drag_begin (widget, target_list,
- GDK_ACTION_COPY,
- 1, (GdkEvent *)event);
+ gtk_drag_begin (widget, target_list,
+ GDK_ACTION_COPY,
+ 1, (GdkEvent *)event);
label->select_info->in_drag = FALSE;
{
gint new_pos = g_utf8_pointer_to_offset (label->text,
label->text + start);
- gint length;
- length = g_utf8_strlen (label->text, -1);
-
if (new_pos > 0)
{
PangoLogAttr *log_attrs;
gtk_layout_adjustment_changed (GtkAdjustment *adjustment,
GtkLayout *layout)
{
- GtkWidget *widget;
-
- widget = GTK_WIDGET (layout);
-
if (layout->freeze_count)
return;
gtk_list_item_expose (GtkWidget *widget,
GdkEventExpose *event)
{
- GtkBin *bin;
-
g_return_val_if_fail (widget != NULL, FALSE);
if (GTK_WIDGET_DRAWABLE (widget))
{
- bin = GTK_BIN (widget);
-
if (widget->state == GTK_STATE_NORMAL)
{
gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
gtk_grab_add (GtkWidget *widget)
{
GtkWindowGroup *group;
- gboolean was_grabbed;
g_return_if_fail (widget != NULL);
group = gtk_main_get_window_group (widget);
- was_grabbed = (group->grabs != NULL);
-
g_object_ref (widget);
group->grabs = g_slist_prepend (group->grabs, widget);
{
GtkMenu *menu;
GtkMenuAttachData *data;
- GtkMenuPrivate *priv;
g_return_if_fail (GTK_IS_MENU (object));
if (menu->tearoff_window)
gtk_widget_destroy (menu->tearoff_window);
- priv = gtk_menu_get_private (menu);
-
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
GtkWidget *widget)
{
GtkMenu *menu;
- GtkMenuPrivate *priv;
g_return_if_fail (GTK_IS_MENU (container));
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
menu = GTK_MENU (container);
- priv = gtk_menu_get_private (menu);
/* Clear out old_active_menu_item if it matches the item we are removing
*/
GtkWidget *menu_item;
GtkMenu *menu;
GtkMenuShell *menu_shell;
- GtkMenuPrivate *priv;
gboolean need_enter;
menu_shell = GTK_MENU_SHELL (menu_item->parent);
menu = GTK_MENU (menu_shell);
- priv = gtk_menu_get_private (GTK_MENU (widget));
-
if (definitely_within_item (menu_item, event->x, event->y))
menu_shell->activate_time = 0;
gtk_menu_bar_class_init (GtkMenuBarClass *class)
{
GObjectClass *gobject_class;
- GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkMenuShellClass *menu_shell_class;
parent_class = g_type_class_peek_parent (class);
gobject_class = (GObjectClass*) class;
- object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
menu_shell_class = (GtkMenuShellClass*) class;
gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
{
GtkWidget *widget;
- GtkMenuShell *submenu;
g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
_gtk_menu_item_popup_submenu (widget);
gtk_menu_shell_select_first (GTK_MENU_SHELL (menu_item->submenu), TRUE);
- submenu = GTK_MENU_SHELL (menu_item->submenu);
}
}
}
gpointer callback_data)
{
GtkBin *bin;
- GtkMenuItem *menu_item;
g_return_if_fail (GTK_IS_MENU_ITEM (container));
g_return_if_fail (callback != NULL);
bin = GTK_BIN (container);
- menu_item = GTK_MENU_ITEM (container);
if (bin->child)
callback (bin->child, callback_data);
GtkObjectClass *gtk_object_class;
GtkWidgetClass *widget_class;
GtkToolItemClass *toolitem_class;
- GtkToolButtonClass *toolbutton_class;
parent_class = g_type_class_peek_parent (klass);
gtk_object_class = (GtkObjectClass *)klass;
widget_class = (GtkWidgetClass *)klass;
toolitem_class = (GtkToolItemClass *)klass;
- toolbutton_class = (GtkToolButtonClass *)klass;
object_class->set_property = gtk_menu_tool_button_set_property;
object_class->get_property = gtk_menu_tool_button_get_property;
static void
gtk_misc_realize (GtkWidget *widget)
{
- GtkMisc *misc;
GdkWindowAttr attributes;
gint attributes_mask;
g_return_if_fail (GTK_IS_MISC (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
- misc = GTK_MISC (widget);
if (GTK_WIDGET_NO_WINDOW (widget))
{
GdkEventCrossing *event)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- GtkNotebookArrow arrow;
gint x, y;
if (!get_widget_coordinates (widget, (GdkEvent *)event, &x, &y))
return FALSE;
- arrow = gtk_notebook_get_arrow (notebook, x, y);
-
if (notebook->in_child)
{
notebook->in_child = 0;
GList *new_child)
{
GList *old_child;
- GtkNotebookPage *old_page = NULL;
GtkNotebookPage *page;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
if (!notebook->show_tabs || !notebook->focus_tab)
return;
- if (old_child)
- old_page = old_child->data;
-
page = notebook->focus_tab->data;
if (GTK_WIDGET_MAPPED (page->tab_label))
gtk_notebook_redraw_tabs (notebook);
GObjectClass *gobject_class;
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
- GtkButtonClass *button_class;
GtkContainerClass *container_class;
gobject_class = (GObjectClass*) class;
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
- button_class = (GtkButtonClass*) class;
container_class = (GtkContainerClass*) class;
parent_class = g_type_class_peek_parent (class);
gtk_pixmap_class_init (GtkPixmapClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
- GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
- object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
parent_class = gtk_type_class (gtk_misc_get_type ());
* root window as the reliable end of the embedding protocol
*/
- return GDK_FILTER_REMOVE;
+ return_val = GDK_FILTER_REMOVE;
}
break;
case ReparentNotify:
}
}
- return GDK_FILTER_CONTINUE;
+ return return_val;
}
gtk_preview_class_init (GtkPreviewClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
- GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
- object_class = (GtkObjectClass*) klass;
widget_class = (GtkWidgetClass*) klass;
parent_class = gtk_type_class (GTK_TYPE_WIDGET);
gint width,
gint height)
{
- GtkWidget *widget;
GdkRectangle r1, r2, r3;
guchar *src;
guint bpp;
if (!preview->buffer)
return;
- widget = GTK_WIDGET (preview);
-
r1.x = 0;
r1.y = 0;
r1.width = preview->buffer_width;
{
GtkProgressBar *pbar;
GtkWidget *widget;
- gint size;
GtkProgressBarOrientation orientation;
pbar = GTK_PROGRESS_BAR (progress);
if (orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
{
- size = MAX (2, widget->allocation.width / pbar->activity_blocks);
-
if (orientation == GTK_PROGRESS_LEFT_TO_RIGHT)
{
pbar->activity_pos = widget->style->xthickness;
}
else
{
- size = MAX (2, widget->allocation.height / pbar->activity_blocks);
-
if (orientation == GTK_PROGRESS_TOP_TO_BOTTOM)
{
pbar->activity_pos = widget->style->ythickness;
GValue *value,
GParamSpec *pspec)
{
- GtkRadioButton *radio_button;
-
- radio_button = GTK_RADIO_BUTTON (object);
-
switch (prop_id)
{
default:
GValue *value,
GParamSpec *pspec)
{
- GtkRadioMenuItem *radio_menu_item;
-
- radio_menu_item = GTK_RADIO_MENU_ITEM (object);
-
switch (prop_id)
{
default:
GtkRBNode *x, *y;
GtkRBTree *tmp_tree;
GtkRBNode *tmp_node;
- gint node_height;
gint y_height;
g_return_if_fail (tree != NULL);
/* offsets and parity adjust all the way up through parent trees */
y_height = GTK_RBNODE_GET_HEIGHT (y);
- node_height = GTK_RBNODE_GET_HEIGHT (node) + (node->children?node->children->root->offset:0);
tmp_tree = tree;
tmp_node = y;
static void
gtk_scrollbar_init (GtkScrollbar *scrollbar)
{
- GtkRange *range;
-
- range = GTK_RANGE (scrollbar);
}
static void
cairo_antialias_t antialias_mode = CAIRO_ANTIALIAS_DEFAULT;
gchar *rgba_str;
cairo_subpixel_order_t subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
- gint dpi_int;
- double dpi;
cairo_font_options_t *options;
g_object_get (settings,
"gtk-xft-hinting", &hinting,
"gtk-xft-hintstyle", &hint_style_str,
"gtk-xft-rgba", &rgba_str,
- "gtk-xft-dpi", &dpi_int,
NULL);
- if (dpi_int > 0)
- dpi = dpi_int / 1024.;
- else
- dpi = -1.;
-
options = cairo_font_options_create ();
if (hinting >= 0 && !hinting)
GObjectClass *gobject_class;
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
- GtkContainerClass *container_class;
gobject_class = (GObjectClass *) class;
object_class = (GtkObjectClass *) class;
widget_class = (GtkWidgetClass *) class;
- container_class = (GtkContainerClass *) class;
parent_class = g_type_class_peek_parent (class);
gint width,
gint height)
{
- gint original_width, original_x;
-
sanitize_size (window, &width, &height);
- original_width = width;
- original_x = x;
-
calculate_arrow_geometry (arrow_type, &x, &y, &width, &height);
if (detail && strcmp (detail, "menu_scroll_arrow_up") == 0)
gint y,
const gchar *string)
{
- GdkDisplay *display;
-
g_return_if_fail (GTK_IS_STYLE (style));
g_return_if_fail (window != NULL);
- display = gdk_drawable_get_display (window);
-
if (area)
{
gdk_gc_set_clip_rectangle (style->white_gc, area);
static void
gtk_tearoff_menu_item_class_init (GtkTearoffMenuItemClass *klass)
{
- GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkMenuItemClass *menu_item_class;
- object_class = (GtkObjectClass*) klass;
widget_class = (GtkWidgetClass*) klass;
menu_item_class = (GtkMenuItemClass*) klass;
gtk_tearoff_menu_item_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkTearoffMenuItem *tearoff;
-
- tearoff = GTK_TEAROFF_MENU_ITEM (widget);
-
requisition->width = (GTK_CONTAINER (widget)->border_width +
widget->style->xthickness +
BORDER_SPACING) * 2;
GdkRectangle *area)
{
GtkMenuItem *menu_item;
- GtkTearoffMenuItem *tearoff_item;
GtkShadowType shadow_type;
gint width, height;
gint x, y;
if (GTK_WIDGET_DRAWABLE (widget))
{
menu_item = GTK_MENU_ITEM (widget);
- tearoff_item = GTK_TEAROFF_MENU_ITEM (widget);
direction = gtk_widget_get_direction (widget);
gtk_text_forward_delete (GtkText *text,
guint nchars)
{
- guint old_lines, old_height;
+ guint old_lines = 0, old_height = 0;
GtkOldEditable *old_editable = GTK_OLD_EDITABLE (text);
gboolean frozen = FALSE;
GtkAllocation *allocation)
{
GtkText *text;
- GtkOldEditable *old_editable;
g_return_if_fail (GTK_IS_TEXT (widget));
g_return_if_fail (allocation != NULL);
text = GTK_TEXT (widget);
- old_editable = GTK_OLD_EDITABLE (widget);
widget->allocation = *allocation;
if (GTK_WIDGET_REALIZED (widget))
static void
fetch_lines_backward (GtkText* text)
{
- GList* new_lines = NULL, *new_line_start;
+ GList *new_line_start;
GtkPropertyMark mark;
if (CACHE_DATA(text->line_start_cache).start.index == 0)
CACHE_DATA(text->line_start_cache).start.index - 1,
&CACHE_DATA(text->line_start_cache).start);
- new_line_start = new_lines = fetch_lines (text, &mark, NULL, FetchLinesCount, 1);
+ new_line_start = fetch_lines (text, &mark, NULL, FetchLinesCount, 1);
while (new_line_start->next)
new_line_start = new_line_start->next;
static gint
drawn_cursor_max (GtkText* text)
{
- GdkFont* font;
-
g_assert(text->cursor_mark.property);
- font = MARK_CURRENT_FONT(text, &text->cursor_mark);
-
return text->cursor_pos_y - text->cursor_char_offset;
}
GtkTextLineSegment *seg;
int chars_left;
int chars_in_line;
- int bytes_in_line;
node = tree->root_node;
*/
chars_in_line = 0;
- bytes_in_line = 0;
seg = NULL;
for (line = node->children.line; line != NULL; line = line->next)
{
int src, dst, index;
TagInfo tagInfo;
GtkTextLine *line;
- GtkTextBTree *tree;
gint byte_index;
#define NUM_TAG_INFOS 10
line = _gtk_text_iter_get_text_line (iter);
- tree = _gtk_text_iter_get_btree (iter);
byte_index = gtk_text_iter_get_line_index (iter);
tagInfo.numTags = 0;
GtkTextLineSegment *seg;
GtkTextLineSegment *end_seg;
GString *retval;
- GtkTextBTree *tree;
gchar *str;
GtkTextIter iter;
GtkTextIter start;
retval = g_string_new (NULL);
- tree = _gtk_text_iter_get_btree (&start);
-
end_seg = _gtk_text_iter_get_indexable_segment (&end);
iter = start;
seg = _gtk_text_iter_get_indexable_segment (&iter);
gint *line_byte_offset)
{
GtkTextLineSegment *seg;
- GtkTextLineSegment *after_prev_indexable;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
gint offset;
last_indexable = NULL;
after_last_indexable = line->segments;
- after_prev_indexable = line->segments;
seg = line->segments;
/* The loop ends when we're inside a segment;
offset -= seg->byte_count;
bytes_in_line += seg->byte_count;
last_indexable = seg;
- after_prev_indexable = after_last_indexable;
after_last_indexable = last_indexable->next;
}
gint *line_char_offset)
{
GtkTextLineSegment *seg;
- GtkTextLineSegment *after_prev_indexable;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
gint offset;
last_indexable = NULL;
after_last_indexable = line->segments;
- after_prev_indexable = line->segments;
seg = line->segments;
/* The loop ends when we're inside a segment;
offset -= seg->char_count;
chars_in_line += seg->char_count;
last_indexable = seg;
- after_prev_indexable = after_last_indexable;
after_last_indexable = last_indexable->next;
}
GtkTextIter range_start;
GtkTextIter range_end;
GtkTextIter start, end;
- GtkTextBuffer *src_buffer;
Range *r;
if (gtk_text_iter_equal (orig_start, orig_end))
start = *orig_start;
end = *orig_end;
- src_buffer = gtk_text_iter_get_buffer (&start);
-
range_start = start;
range_end = start;
GtkTextIter end = *orig_end;
GtkTextIter range_start;
GtkTextIter range_end;
- GtkTextBuffer *src_buffer;
if (gtk_text_iter_equal (orig_start, orig_end))
return;
- src_buffer = gtk_text_iter_get_buffer (orig_start);
-
gtk_text_iter_order (&start, &end);
range_start = start;
gboolean
gtk_text_iter_ends_line (const GtkTextIter *iter)
{
- GtkTextRealIter *real;
gunichar wc;
g_return_val_if_fail (iter != NULL, FALSE);
- real = gtk_text_iter_make_real (iter);
-
check_invariants (iter);
/* Only one character has type G_UNICODE_PARAGRAPH_SEPARATOR in
{
PangoAttribute *attr;
PangoRectangle logical_rect;
- GtkTextChildAnchor *anchor;
gint width, height;
GSList *tmp_list;
GtkWidget *widget;
width = 1;
height = 1;
- anchor = seg->body.child.obj;
-
tmp_list = seg->body.child.widgets;
while (tmp_list != NULL)
{
const GValue *value,
GParamSpec *pspec)
{
- GtkTextTagTable *table;
-
- table = GTK_TEXT_TAG_TABLE (object);
-
switch (prop_id)
{
GValue *value,
GParamSpec *pspec)
{
- GtkTextTagTable *table;
-
- table = GTK_TEXT_TAG_TABLE (object);
-
switch (prop_id)
{
PangoLayout *layout;
gint pixmap_height, pixmap_width;
gint layout_width, layout_height;
- gint n_lines;
g_return_val_if_fail (widget != NULL, NULL);
g_return_val_if_fail (text != NULL, NULL);
layout_width = MIN (layout_width, DRAG_ICON_MAX_WIDTH * PANGO_SCALE);
pango_layout_set_width (layout, layout_width);
- n_lines = pango_layout_get_line_count (layout);
limit_layout_lines (layout);
gtk_text_view_destroy (GtkObject *object)
{
GtkTextView *text_view;
- GtkTextLayout *layout;
text_view = GTK_TEXT_VIEW (object);
- layout = text_view->layout;
-
gtk_text_view_remove_validate_idles (text_view);
gtk_text_view_set_buffer (text_view, NULL);
gtk_text_view_destroy_layout (text_view);
GSList *tags;
GSList *tmp;
gboolean retval = FALSE;
- GtkTextView *text_view;
-
- text_view = GTK_TEXT_VIEW (widget);
tags = gtk_text_iter_get_tags (iter);
gtk_text_view_focus (GtkWidget *widget,
GtkDirectionType direction)
{
- GtkTextView *text_view;
GtkContainer *container;
gboolean result;
- text_view = GTK_TEXT_VIEW (widget);
container = GTK_CONTAINER (widget);
if (!gtk_widget_is_focus (widget) &&
const GtkTextIter *iter,
GdkEventMotion *event)
{
- GdkDragContext *context;
GtkTargetList *target_list;
text_view->drag_start_x = -1;
g_signal_connect (text_view, "drag-begin",
G_CALLBACK (drag_begin_cb), NULL);
- context = gtk_drag_begin (GTK_WIDGET (text_view), target_list,
- GDK_ACTION_COPY | GDK_ACTION_MOVE,
- 1, (GdkEvent*)event);
+ gtk_drag_begin (GTK_WIDGET (text_view), target_list,
+ GDK_ACTION_COPY | GDK_ACTION_MOVE,
+ 1, (GdkEvent*)event);
gtk_target_list_unref (target_list);
}
gtk_text_view_drag_end (GtkWidget *widget,
GdkDragContext *context)
{
- GtkTextView *text_view;
-
- text_view = GTK_TEXT_VIEW (widget);
}
static void
gtk_text_view_drag_data_delete (GtkWidget *widget,
GdkDragContext *context)
{
- GtkTextView *text_view;
-
- text_view = GTK_TEXT_VIEW (widget);
-
gtk_text_buffer_delete_selection (GTK_TEXT_VIEW (widget)->buffer,
TRUE, GTK_TEXT_VIEW (widget)->editable);
}
disconnect_proxy (GtkAction *action,
GtkWidget *proxy)
{
- GtkToggleAction *toggle_action;
-
- toggle_action = GTK_TOGGLE_ACTION (action);
-
(* GTK_ACTION_CLASS (parent_class)->disconnect_proxy) (action, proxy);
}
new_states[i] == NORMAL)
{
GtkAllocation alloc;
- GtkAllocation start_allocation;
+ GtkAllocation start_allocation = { 0, };
GtkAllocation goal_allocation;
if (priv->is_sliding)
{
GtkWidget *box;
ToolbarContent *content;
- GtkToolbarPrivate *priv;
char *free_me = NULL;
- gboolean is_button = FALSE;
GtkWidget *child_widget;
GtkWidget *child_label;
if (!gtk_toolbar_check_old_api (toolbar))
return NULL;
- priv = GTK_TOOLBAR_GET_PRIVATE (toolbar);
-
child_widget = NULL;
child_label = NULL;
child_icon = NULL;
case GTK_TOOLBAR_CHILD_BUTTON:
case GTK_TOOLBAR_CHILD_TOGGLEBUTTON:
case GTK_TOOLBAR_CHILD_RADIOBUTTON:
- is_button = TRUE;
if (type == GTK_TOOLBAR_CHILD_BUTTON)
{
child_widget = gtk_button_new ();
const double start_fraction = (SPACE_LINE_START / SPACE_LINE_DIVISION);
const double end_fraction = (SPACE_LINE_END / SPACE_LINE_DIVISION);
- GtkToolbarSpaceStyle space_style;
GtkOrientation orientation;
g_return_if_fail (GTK_IS_WIDGET (widget));
- space_style = toolbar? get_space_style (toolbar) : DEFAULT_SPACE_STYLE;
orientation = toolbar? toolbar->orientation : GTK_ORIENTATION_HORIZONTAL;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
gtk_tool_button_class_init (GtkToolButtonClass *klass)
{
GObjectClass *object_class;
- GtkWidgetClass *widget_class;
GtkToolItemClass *tool_item_class;
parent_class = g_type_class_peek_parent (klass);
object_class = (GObjectClass *)klass;
- widget_class = (GtkWidgetClass *)klass;
tool_item_class = (GtkToolItemClass *)klass;
object_class->set_property = gtk_tool_button_set_property;
{
GtkRequisition requisition;
GtkWidget *widget;
- GtkStyle *style;
gint x, y, w, h;
GtkTooltipsData *data;
gboolean keyboard_mode;
g_get_current_time (&tooltips->last_popdown);
gtk_widget_ensure_style (tooltips->tip_window);
- style = tooltips->tip_window->style;
widget = tooltips->active_tips_data->widget;
g_object_set_data (G_OBJECT (tooltips->tip_window), I_(tooltips_info_key),
gtk_tree_item_paint (GtkWidget *widget,
GdkRectangle *area)
{
- GtkBin *bin;
GdkRectangle child_area, item_area;
GtkTreeItem* tree_item;
*/
if (GTK_WIDGET_DRAWABLE (widget))
{
- bin = GTK_BIN (widget);
tree_item = GTK_TREE_ITEM(widget);
if (widget->state == GTK_STATE_NORMAL)
static void
gtk_real_tree_item_select (GtkItem *item)
{
- GtkTreeItem *tree_item;
GtkWidget *widget;
g_return_if_fail (GTK_IS_TREE_ITEM (item));
- tree_item = GTK_TREE_ITEM (item);
widget = GTK_WIDGET (item);
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_SELECTED);
{
FilterElt *elt, *parent;
FilterLevel *level, *parent_level;
- gint offset, i, length, level_refcount;
+ gint i, length, level_refcount;
/* FIXME: this function is very ugly. I need to rethink and
* rewrite it someday.
parent = level->parent_elt;
parent_level = level->parent_level;
length = level->array->len;
- offset = elt->offset;
/* ref counting */
while (elt->ref_count > 0)
FilterLevel *level;
FilterLevel *parent_level;
- gint i = 0, offset, index = -1;
+ gint i = 0, offset;
gboolean free_c_path = FALSE;
break;
g_array_insert_val (level->array, i, felt);
- index = i;
if (!level->parent_level)
filter->priv->root_level_visible++;
gtk_tree_selection_count_selected_rows (GtkTreeSelection *selection)
{
gint count = 0;
- GtkRBTree *tree;
- GtkRBNode *node;
g_return_val_if_fail (GTK_IS_TREE_SELECTION (selection), 0);
g_return_val_if_fail (selection->tree_view != NULL, 0);
return 0;
}
- tree = selection->tree_view->priv->tree;
- node = selection->tree_view->priv->tree->root;
-
_gtk_rbtree_traverse (selection->tree_view->priv->tree,
selection->tree_view->priv->tree->root,
G_PRE_ORDER,
{
GList *tmp_list;
GtkTreeView *tree_view;
- GdkGCValues values;
GdkWindowAttr attributes;
gint attributes_mask;
&attributes, attributes_mask);
gdk_window_set_user_data (tree_view->priv->header_window, widget);
-
- values.foreground = (widget->style->white.pixel==0 ?
- widget->style->black:widget->style->white);
- values.function = GDK_XOR;
- values.subwindow_mode = GDK_INCLUDE_INFERIORS;
-
/* Add them all up. */
widget->style = gtk_style_attach (widget->style, widget->window);
gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
GtkRBTree *drag_highlight_tree = NULL;
GtkTreeIter iter;
gint new_y;
- gint y_offset, x_offset, cell_offset;
+ gint y_offset, cell_offset;
gint max_height;
gint depth;
GdkRectangle background_area;
max_height = ROW_HEIGHT (tree_view, BACKGROUND_HEIGHT (node));
- x_offset = -event->area.x;
cell_offset = 0;
highlight_x = 0; /* should match x coord of first cell */
GdkDragContext *context,
guint time)
{
- TreeViewDragInfo *di;
-
- di = get_info (GTK_TREE_VIEW (widget));
-
/* unset any highlight row */
gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
NULL,
{
gboolean empty;
GtkTreePath *path = NULL;
- GtkTreeModel *model;
GtkTreeViewDropPosition pos;
GtkTreeView *tree_view;
GdkDragAction suggested_action = 0;
gtk_tree_view_get_drag_dest_row (tree_view, &path, &pos);
/* we only know this *after* set_desination_row */
- model = gtk_tree_view_get_model (tree_view);
empty = tree_view->priv->empty_view_drop;
if (path == NULL && !empty)
GtkDirectionType dir)
{
GtkWidget *focus_child;
- GtkContainer *container;
GList *last_column, *first_column;
GList *tmp_list;
return FALSE;
focus_child = GTK_CONTAINER (tree_view)->focus_child;
- container = GTK_CONTAINER (tree_view);
first_column = tree_view->priv->columns;
while (first_column)
gboolean collapse;
gint x, y;
GList *list;
- GdkDisplay *display;
GdkWindow *child, *parent;
remove_auto_expand_timeout (tree_view);
/* now that we've collapsed all rows, we want to try to set the prelight
* again. To do this, we fake a motion event and send it to ourselves. */
- display = gdk_drawable_get_display (tree_view->priv->bin_window);
child = tree_view->priv->bin_window;
parent = gdk_window_get_parent (child);
gboolean empty;
GList *children, *cur, *last;
GtkWidget *filler;
- gint i;
children = gtk_container_get_children (GTK_CONTAINER (parent));
empty = TRUE;
filler = NULL;
- i = 0;
cur = children;
while (cur)
{
{
GtkBox *base_box;
GtkButtonBox *box;
- GtkVButtonBox *hbox;
GtkBoxChild *child;
GList *children;
GtkAllocation child_allocation;
base_box = GTK_BOX (widget);
box = GTK_BUTTON_BOX (widget);
- hbox = GTK_VBUTTON_BOX (widget);
spacing = base_box->spacing;
layout = box->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
? box->layout_style : default_layout_style;
GdkEventExpose *event)
{
GtkViewport *viewport;
- GtkBin *bin;
if (GTK_WIDGET_DRAWABLE (widget))
{
viewport = GTK_VIEWPORT (widget);
- bin = GTK_BIN (widget);
if (event->window == widget->window)
gtk_viewport_paint (widget, &event->area);
gtk_viewport_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkViewport *viewport;
GtkBin *bin;
GtkRequisition child_requisition;
- viewport = GTK_VIEWPORT (widget);
bin = GTK_BIN (widget);
requisition->width = (GTK_CONTAINER (widget)->border_width +
gtk_widget_modify_style (GtkWidget *widget,
GtkRcStyle *style)
{
- GtkRcStyle *old_style;
-
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (GTK_IS_RC_STYLE (style));
- old_style = g_object_get_qdata (G_OBJECT (widget), quark_rc_style);
-
g_object_set_qdata_full (G_OBJECT (widget),
quark_rc_style,
gtk_rc_style_copy (style),
gtk_window_unrealize_icon (GtkWindow *window)
{
GtkWindowIconInfo *info;
- GtkWidget *widget;
- widget = GTK_WIDGET (window);
-
info = get_icon_info (window);
if (info == NULL)
gint *height)
{
gint w, h;
- GtkWidget *widget;
g_return_if_fail (GTK_IS_WINDOW (window));
- widget = GTK_WIDGET (window);
-
if (width == NULL && height == NULL)
return;
screen = gtk_window_check_screen (window);
gtk_widget_size_request (widget, NULL);
- gtk_window_compute_configure_request_size (window, &w, &h);
+ gtk_window_compute_configure_request_size (window, (guint *)&w, (guint *)&h);
gtk_window_compute_hints (window, &new_geometry, &new_flags);
gtk_window_constrain_size (window,
gtk_window_parse_geometry (GtkWindow *window,
const gchar *geometry)
{
- gint result, x, y;
+ gint result, x = 0, y = 0;
guint w, h;
GdkGravity grav;
gboolean size_set, pos_set;
size_set = TRUE;
}
- gtk_window_get_size (window, &w, &h);
+ gtk_window_get_size (window, (gint *)&w, (gint *)&h);
grav = GDK_GRAVITY_NORTH_WEST;
projects / ~andy / gtk / commitdiff