#include "claws-marshal.h"
#include "gtkcmclist.h"
#include <gdk/gdkkeysyms.h>
+#include "utils.h"
+#include "gtkutils.h"
/* length of button_actions array */
#define MAX_BUTTON 5
GtkRequisition *requisition);
static void gtk_cmclist_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
+static void gtk_cmclist_undraw_focus (GtkWidget *widget);
static void gtk_cmclist_draw_focus (GtkWidget *widget);
static gint gtk_cmclist_focus_in (GtkWidget *widget,
GdkEventFocus *event);
GtkCMCListRow *clist_row,
gint state,
gint column,
- GtkStyle **style,
- GdkGC **fg_gc,
- GdkGC **bg_gc);
-static gint draw_cell_pixmap (GdkWindow *window,
+ GtkStyle **style);
+static gint draw_cell_pixbuf (GdkWindow *window,
GdkRectangle *clip_rectangle,
- GdkGC *fg_gc,
- GdkPixmap *pixmap,
- GdkBitmap *mask,
+ cairo_t *cr,
+ GdkPixbuf *pixbuf,
gint x,
gint y,
gint width,
static void draw_rows (GtkCMCList *clist,
GdkRectangle *area);
static void clist_refresh (GtkCMCList *clist);
-static void draw_drag_highlight (GtkCMCList *clist,
- GtkCMCListRow *dest_row,
- gint dest_row_number,
- GtkCMCListDragPos drag_pos);
/* Size Allocation / Requisition */
static void size_allocate_title_buttons (GtkCMCList *clist);
GtkCMCellType type,
const gchar *text,
guint8 spacing,
- GdkPixmap *pixmap,
- GdkBitmap *mask);
+ GdkPixbuf *pixbuf);
static gint real_insert_row (GtkCMCList *clist,
gint row,
gchar *text[]);
widget_class = (GtkWidgetClass *) klass;
container_class = (GtkContainerClass *) klass;
- parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
+ parent_class = g_type_class_peek (GTK_TYPE_CONTAINER);
object_class->finalize = gtk_cmclist_finalize;
gtk_object_class->destroy = gtk_cmclist_destroy;
klass->click_column = NULL;
klass->resize_column = real_resize_column;
klass->draw_row = draw_row;
- klass->draw_drag_highlight = draw_drag_highlight;
klass->insert_row = real_insert_row;
klass->remove_row = real_remove_row;
klass->clear = real_clear;
G_TYPE_NONE, 0);
binding_set = gtk_binding_set_by_class (klass);
- gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Up, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Up, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Down, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Down, 0,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Home, GDK_CONTROL_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Home, GDK_CONTROL_MASK,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Home, GDK_CONTROL_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Home, GDK_CONTROL_MASK,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_End, GDK_CONTROL_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_End, GDK_CONTROL_MASK,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 1.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_End, GDK_CONTROL_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_End, GDK_CONTROL_MASK,
"scroll_vertical", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 1.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Up, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Up, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_Down, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Down, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Up, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Up, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_PAGE_BACKWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Page_Down, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Page_Down, GDK_SHIFT_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_PAGE_FORWARD,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_Home,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Home,
GDK_SHIFT_MASK | GDK_CONTROL_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Home,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Home,
GDK_SHIFT_MASK | GDK_CONTROL_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 0.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_End,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_End,
GDK_SHIFT_MASK | GDK_CONTROL_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 1.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_End,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_End,
GDK_SHIFT_MASK | GDK_CONTROL_MASK,
"extend_selection", 3,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 1.0, G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_Left, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Left, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Left, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Left, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_BACKWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Right, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Right, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Right, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Right, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_STEP_FORWARD,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Home, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Home, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Home, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Home, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 0.0);
- gtk_binding_entry_add_signal (binding_set, GDK_End, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_End, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 1.0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_End, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_End, 0,
"scroll_horizontal", 2,
G_TYPE_ENUM, GTK_SCROLL_JUMP,
G_TYPE_FLOAT, 1.0);
- gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0,
"undo_selection", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0,
"abort_column_resize", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_space, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0,
"toggle_focus_row", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0,
"toggle_focus_row", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_CONTROL_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, GDK_CONTROL_MASK,
"toggle_add_mode", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Space, GDK_CONTROL_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, GDK_CONTROL_MASK,
"toggle_add_mode", 0);
gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK,
"select_all", 0);
"select_all", 0);
gtk_binding_entry_add_signal (binding_set, '\\', GDK_CONTROL_MASK,
"unselect_all", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Shift_L,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Shift_L,
GDK_RELEASE_MASK | GDK_SHIFT_MASK,
"end_selection", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Shift_R,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Shift_R,
GDK_RELEASE_MASK | GDK_SHIFT_MASK,
"end_selection", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Shift_L,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Shift_L,
GDK_RELEASE_MASK | GDK_SHIFT_MASK |
GDK_CONTROL_MASK,
"end_selection", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Shift_R,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Shift_R,
GDK_RELEASE_MASK | GDK_SHIFT_MASK |
GDK_CONTROL_MASK,
"end_selection", 0);
g_value_set_boolean(value, TRUE);
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button &&
- !GTK_WIDGET_SENSITIVE (clist->column[i].button))
+ !gtk_widget_get_sensitive (clist->column[i].button))
{
g_value_set_boolean(value, FALSE);
break;
{
clist->flags = 0;
- GTK_WIDGET_UNSET_FLAGS (clist, GTK_NO_WINDOW);
- GTK_WIDGET_SET_FLAGS (clist, GTK_CAN_FOCUS);
+ gtkut_widget_set_has_window (GTK_WIDGET(clist), TRUE);
+ gtkut_widget_set_can_focus (GTK_WIDGET(clist), TRUE);
GTK_CMCLIST_SET_FLAG (clist, CMCLIST_DRAW_DRAG_LINE);
GTK_CMCLIST_SET_FLAG (clist, CMCLIST_USE_DRAG_ICONS);
clist->button_actions[4] = GTK_CMBUTTON_IGNORED;
clist->cursor_drag = NULL;
- clist->xor_gc = NULL;
- clist->fg_gc = NULL;
- clist->bg_gc = NULL;
clist->x_drag = 0;
clist->selection_mode = GTK_SELECTION_SINGLE;
{
GtkAdjustment *old_adjustment;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (adjustment)
- g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
+ cm_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
if (clist->hadjustment == adjustment)
return;
if (clist->hadjustment)
{
- g_signal_handlers_disconnect_matched(GTK_OBJECT (clist->hadjustment), G_SIGNAL_MATCH_DATA,
+ g_signal_handlers_disconnect_matched(G_OBJECT (clist->hadjustment), G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, clist);
- g_object_unref (GTK_OBJECT (clist->hadjustment));
+ g_object_unref (G_OBJECT (clist->hadjustment));
}
clist->hadjustment = adjustment;
#if GLIB_CHECK_VERSION(2,10,0)
g_object_ref_sink (clist->hadjustment);
#else
- gtk_object_ref (GTK_OBJECT (clist->hadjustment));
- gtk_object_sink (GTK_OBJECT (clist->hadjustment));
+ gtk_object_ref (G_OBJECT (clist->hadjustment));
+ gtk_object_sink (G_OBJECT (clist->hadjustment));
#endif
g_signal_connect (G_OBJECT (clist->hadjustment), "changed",
G_CALLBACK( hadjustment_changed),
GtkAdjustment *
gtk_cmclist_get_hadjustment (GtkCMCList *clist)
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
return clist->hadjustment;
}
{
GtkAdjustment *old_adjustment;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (adjustment)
- g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
+ cm_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
if (clist->vadjustment == adjustment)
return;
if (clist->vadjustment)
{
- g_signal_handlers_disconnect_matched(GTK_OBJECT (clist->vadjustment), G_SIGNAL_MATCH_DATA,
+ g_signal_handlers_disconnect_matched(G_OBJECT (clist->vadjustment), G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, clist);
- g_object_unref (GTK_OBJECT (clist->vadjustment));
+ g_object_unref (G_OBJECT (clist->vadjustment));
}
clist->vadjustment = adjustment;
#if GLIB_CHECK_VERSION(2,10,0)
g_object_ref_sink (clist->vadjustment);
#else
- gtk_object_ref (GTK_OBJECT (clist->vadjustment));
- gtk_object_sink (GTK_OBJECT (clist->vadjustment));
+ gtk_object_ref (G_OBJECT (clist->vadjustment));
+ gtk_object_sink (G_OBJECT (clist->vadjustment));
#endif
- g_signal_connect (GTK_OBJECT (clist->vadjustment), "changed",
+ g_signal_connect (G_OBJECT (clist->vadjustment), "changed",
G_CALLBACK(vadjustment_changed),
(gpointer) clist);
- g_signal_connect (GTK_OBJECT (clist->vadjustment), "value_changed",
+ g_signal_connect (G_OBJECT (clist->vadjustment), "value_changed",
G_CALLBACK(vadjustment_value_changed),
(gpointer) clist);
}
GtkAdjustment *
gtk_cmclist_get_vadjustment (GtkCMCList *clist)
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
return clist->vadjustment;
}
gtk_cmclist_set_shadow_type (GtkCMCList *clist,
GtkShadowType type)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
clist->shadow_type = type;
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET(clist)))
gtk_widget_queue_resize (GTK_WIDGET (clist));
}
gtk_cmclist_set_selection_mode (GtkCMCList *clist,
GtkSelectionMode mode)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
- g_return_if_fail (mode != GTK_SELECTION_NONE);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (mode != GTK_SELECTION_NONE);
if (mode == clist->selection_mode)
return;
void
gtk_cmclist_freeze (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
clist->freeze_count++;
}
void
gtk_cmclist_thaw (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist->freeze_count)
{
void
gtk_cmclist_column_titles_show (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (!GTK_CMCLIST_SHOW_TITLES(clist))
{
void
gtk_cmclist_column_titles_hide (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (GTK_CMCLIST_SHOW_TITLES(clist))
{
gtk_cmclist_column_title_active (GtkCMCList *clist,
gint column)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
clist->column[column].button_passive = FALSE;
- g_signal_handlers_disconnect_matched(GTK_OBJECT (clist->column[column].button), G_SIGNAL_MATCH_FUNC,
+ g_signal_handlers_disconnect_matched(G_OBJECT (clist->column[column].button), G_SIGNAL_MATCH_FUNC,
0, 0, 0, column_title_passive_func, 0);
- GTK_WIDGET_SET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
- if (GTK_WIDGET_VISIBLE (clist))
+ gtkut_widget_set_can_focus (clist->column[column].button, TRUE);
+ if (gtk_widget_get_visible (GTK_WIDGET(clist)))
gtk_widget_queue_draw (clist->column[column].button);
}
gtk_cmclist_column_title_passive (GtkCMCList *clist,
gint column)
{
- GtkButton *button;
+ GtkToggleButton *button;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
if (!clist->column[column].button || clist->column[column].button_passive)
return;
- button = GTK_BUTTON (clist->column[column].button);
+ button = GTK_TOGGLE_BUTTON (clist->column[column].button);
clist->column[column].button_passive = TRUE;
- if (button->button_down)
- gtk_button_released (button);
- if (button->in_button)
- gtk_button_leave (button);
+ if (gtk_toggle_button_get_active(button))
+ g_signal_connect(G_OBJECT (clist->column[column].button),
+ "button-release-event",
+ G_CALLBACK(column_title_passive_func),
+ NULL);
+ if (gtk_widget_is_focus(gtk_bin_get_child(GTK_BIN(button))))
+ g_signal_connect(G_OBJECT (clist->column[column].button),
+ "leave-notify-event",
+ G_CALLBACK(column_title_passive_func),
+ NULL);
g_signal_connect (G_OBJECT (clist->column[column].button), "event",
G_CALLBACK(column_title_passive_func), NULL);
- GTK_WIDGET_UNSET_FLAGS (clist->column[column].button, GTK_CAN_FOCUS);
- if (GTK_WIDGET_VISIBLE (clist))
+ gtkut_widget_set_can_focus (clist->column[column].button, FALSE);
+ if (gtk_widget_get_visible (GTK_WIDGET(clist)))
gtk_widget_queue_draw (clist->column[column].button);
}
{
gint i;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
for (i = 0; i < clist->columns; i++)
gtk_cmclist_column_title_active (clist, i);
{
gint i;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
for (i = 0; i < clist->columns; i++)
gtk_cmclist_column_title_passive (clist, i);
GtkWidget *alignment = NULL;
GtkWidget *label;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
column_title_new (clist, column, title);
/* remove and destroy the old widget */
- old_widget = GTK_BIN (clist->column[column].button)->child;
+ old_widget = gtk_bin_get_child (GTK_BIN (clist->column[column].button));
if (old_widget)
gtk_container_remove (GTK_CONTAINER (clist->column[column].button), old_widget);
/* if this button didn't previously exist, then the
* column button positions have to be re-computed */
- if (GTK_WIDGET_VISIBLE (clist) && new_button)
+ if (gtk_widget_get_visible (GTK_WIDGET(clist)) && new_button)
size_allocate_title_buttons (clist);
}
gtk_cmclist_get_column_title (GtkCMCList *clist,
gint column)
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
if (column < 0 || column >= clist->columns)
return NULL;
gint new_button = 0;
GtkWidget *old_widget;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
column_title_new (clist, column, NULL);
/* remove and destroy the old widget */
- old_widget = GTK_BIN (clist->column[column].button)->child;
+ old_widget = gtk_bin_get_child (GTK_BIN (clist->column[column].button));
if (old_widget)
gtk_container_remove (GTK_CONTAINER (clist->column[column].button),
old_widget);
/* if this button didn't previously exist, then the
* column button positions have to be re-computed */
- if (GTK_WIDGET_VISIBLE (clist) && new_button)
+ if (gtk_widget_get_visible (GTK_WIDGET(clist)) && new_button)
size_allocate_title_buttons (clist);
}
gtk_cmclist_get_column_widget (GtkCMCList *clist,
gint column)
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
if (column < 0 || column >= clist->columns)
return NULL;
if (clist->column[column].button)
- return GTK_BIN (clist->column[column].button)->child;
+ return gtk_bin_get_child (GTK_BIN (clist->column[column].button));
return NULL;
}
{
GtkWidget *alignment;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
* custom widget */
if (clist->column[column].title)
{
- alignment = GTK_BIN (clist->column[column].button)->child;
+ alignment = gtk_bin_get_child (GTK_BIN (clist->column[column].button));
switch (clist->column[column].justification)
{
gint column,
gboolean visible)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
gint column,
gboolean resizeable)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
if (resizeable)
clist->column[column].auto_resize = FALSE;
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET(clist)))
size_allocate_title_buttons (clist);
}
gint column,
gboolean auto_resize)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
}
}
- if (GTK_WIDGET_VISIBLE (clist))
+ if (gtk_widget_get_visible (GTK_WIDGET(clist)))
size_allocate_title_buttons (clist);
}
gint i;
gint width;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
gtk_cmclist_freeze (clist);
width = 0;
GList *list;
gint width;
- g_return_val_if_fail (GTK_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_CMCLIST (clist), 0);
if (column < 0 || column >= clist->columns)
return 0;
if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[column].button)
- width = (clist->column[column].button->requisition.width)
+ {
+ gtk_widget_get_requisition (clist->column[column].button, &requisition);
+ width = requisition.width
#if 0
(CELL_SPACING + (2 * COLUMN_INSET)))
#endif
;
+ }
else
width = 0;
gint column,
gint width)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
- g_signal_emit (GTK_OBJECT (clist), clist_signals[RESIZE_COLUMN], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[RESIZE_COLUMN], 0,
column, width);
}
gint column,
gint min_width)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
gint column,
gint max_width)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
/* run a "gtk_cmclist_optimal_column_width" but break, if
* the column doesn't shrink */
if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[column].button)
- new_width = (clist->column[column].button->requisition.width -
+ {
+ gtk_widget_get_requisition (clist->column[column].button, &requisition);
+ new_width = (requisition.width -
(CELL_SPACING + (2 * COLUMN_INSET)));
+ }
else
new_width = 0;
gint column,
gint width)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
static void
abort_column_resize (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (!GTK_CMCLIST_IN_DRAG(clist))
return;
clist->drag_pos = -1;
if (clist->x_drag >= 0 && clist->x_drag <= clist->clist_window_width - 1)
- draw_xor_line (clist);
-
- if (GTK_CMCLIST_ADD_MODE(clist))
- {
- gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_ON_OFF_DASH, 0,0);
- gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
- }
+ clist_refresh(clist);
}
static void
gint last_button = 0;
gint i;
- if (!GTK_WIDGET_REALIZED (clist))
+ if (!gtk_widget_get_realized (GTK_WIDGET(clist)))
return;
button_allocation.x = clist->hoffset;
size_allocate_columns (GtkCMCList *clist,
gboolean block_resize)
{
+ GtkRequisition requisition;
gint xoffset = CELL_SPACING + COLUMN_INSET;
gint last_column;
gint i;
{
gint width;
- width = (clist->column[i].button->requisition.width -
+ gtk_widget_get_requisition (clist->column[i].button, &requisition);
+ width = (requisition.width -
(CELL_SPACING + (2 * COLUMN_INSET)));
if (width > clist->column[i].width)
}
else if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[i].button)
{
+ gtk_widget_get_requisition (clist->column[i].button, &requisition);
clist->column[i].area.width =
- clist->column[i].button->requisition.width -
+ requisition.width -
(CELL_SPACING + (2 * COLUMN_INSET));
- xoffset += clist->column[i].button->requisition.width;
+ xoffset += requisition.width;
}
}
static gint
list_requisition_width (GtkCMCList *clist)
{
+ GtkRequisition requisition;
gint width = CELL_SPACING;
gint i;
if (clist->column[i].width_set)
width += clist->column[i].width + CELL_SPACING + (2 * COLUMN_INSET);
else if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[i].button)
- width += clist->column[i].button->requisition.width;
+ {
+ gtk_widget_get_requisition (clist->column[i].button, &requisition);
+ width += requisition.width;
+ }
}
return width;
gint column,
gint *x)
{
- gint xthickness = GTK_WIDGET (clist)->style->xthickness;
+ gint xthickness = gtk_widget_get_style (GTK_WIDGET (clist))->xthickness;
gint width;
gint cx;
gint dx;
gtk_widget_push_composite_child ();
button = clist->column[column].button = gtk_button_new ();
+ GtkRcStyle *style = gtk_rc_style_new();
+ style->ythickness = 0;
+ gtk_widget_modify_style(clist->column[column].button, style);
+ g_object_unref(style);
gtk_container_set_border_width(GTK_CONTAINER(button), 0);
gtk_widget_pop_composite_child ();
- if (GTK_WIDGET_REALIZED (clist) && clist->title_window)
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)) && clist->title_window)
gtk_widget_set_parent_window (clist->column[column].button,
clist->title_window);
gtk_widget_set_parent (button, GTK_WIDGET (clist));
- g_signal_connect (GTK_OBJECT (button), "clicked",
+ g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK(column_button_clicked),
(gpointer) clist);
gtk_widget_show (button);
gint i;
GtkCMCList *clist;
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_CMCLIST (data));
+ cm_return_if_fail (widget != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (data));
clist = GTK_CMCLIST (data);
if (clist->column[i].button == widget)
break;
- g_signal_emit (GTK_OBJECT (clist), clist_signals[CLICK_COLUMN], 0, i);
+ g_signal_emit (G_OBJECT (clist), clist_signals[CLICK_COLUMN], 0, i);
}
static gint
GdkEvent *event,
gpointer data)
{
- g_return_val_if_fail (event != NULL, FALSE);
+ cm_return_val_if_fail (event != NULL, FALSE);
switch (event->type)
{
* gtk_cmclist_get_cell_type
* gtk_cmclist_set_text
* gtk_cmclist_get_text
- * gtk_cmclist_set_pixmap
- * gtk_cmclist_get_pixmap
+ * gtk_cmclist_set_pixbuf
+ * gtk_cmclist_get_pixbuf
* gtk_cmclist_set_pixtext
* gtk_cmclist_get_pixtext
* gtk_cmclist_set_shift
{
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
if (row < 0 || row >= clist->rows)
return -1;
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
/* if text is null, then the cell is empty */
GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
- (clist, clist_row, column, GTK_CMCELL_TEXT, text, 0, NULL, NULL);
+ (clist, clist_row, column, GTK_CMCELL_TEXT, text, 0, NULL);
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
{
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
if (row < 0 || row >= clist->rows)
return 0;
}
void
-gtk_cmclist_set_pixmap (GtkCMCList *clist,
+gtk_cmclist_set_pixbuf (GtkCMCList *clist,
gint row,
gint column,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
+ GdkPixbuf *pixbuf)
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
clist_row = ROW_ELEMENT (clist, row)->data;
- g_object_ref (pixmap);
-
- if (mask) g_object_ref (mask);
+ g_object_ref (pixbuf);
GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
- (clist, clist_row, column, GTK_CMCELL_PIXMAP, NULL, 0, pixmap, mask);
+ (clist, clist_row, column, GTK_CMCELL_PIXBUF, NULL, 0, pixbuf);
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
}
gint
-gtk_cmclist_get_pixmap (GtkCMCList *clist,
+gtk_cmclist_get_pixbuf (GtkCMCList *clist,
gint row,
gint column,
- GdkPixmap **pixmap,
- GdkBitmap **mask)
+ GdkPixbuf **pixbuf)
{
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
if (row < 0 || row >= clist->rows)
return 0;
clist_row = ROW_ELEMENT (clist, row)->data;
- if (clist_row->cell[column].type != GTK_CMCELL_PIXMAP)
+ if (clist_row->cell[column].type != GTK_CMCELL_PIXBUF)
return 0;
- if (pixmap)
+ if (pixbuf)
{
- *pixmap = GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap;
- /* mask can be NULL */
- *mask = GTK_CMCELL_PIXMAP (clist_row->cell[column])->mask;
+ *pixbuf = GTK_CMCELL_PIXBUF (clist_row->cell[column])->pixbuf;
}
return 1;
gint column,
const gchar *text,
guint8 spacing,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
+ GdkPixbuf *pixbuf)
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
clist_row = ROW_ELEMENT (clist, row)->data;
- g_object_ref (pixmap);
- if (mask) g_object_ref (mask);
+ g_object_ref (pixbuf);
GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
- (clist, clist_row, column, GTK_CMCELL_PIXTEXT, text, spacing, pixmap, mask);
+ (clist, clist_row, column, GTK_CMCELL_PIXTEXT, text, spacing, pixbuf);
/* redraw the list if it's not frozen */
if (CLIST_UNFROZEN (clist))
gint column,
gchar **text,
guint8 *spacing,
- GdkPixmap **pixmap,
- GdkBitmap **mask)
+ GdkPixbuf **pixbuf)
{
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
if (row < 0 || row >= clist->rows)
return 0;
*text = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->text;
if (spacing)
*spacing = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->spacing;
- if (pixmap)
- *pixmap = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap;
-
- /* mask can be NULL */
- if (mask)
- *mask = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->mask;
+ if (pixbuf)
+ *pixbuf = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixbuf;
return 1;
}
GtkRequisition requisition = { 0 };
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
GtkCMCellType type,
const gchar *text,
guint8 spacing,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
+ GdkPixbuf *pixbuf)
{
GtkRequisition requisition;
gchar *old_text = NULL;
- GdkPixmap *old_pixmap = NULL;
- GdkBitmap *old_mask = NULL;
+ GdkPixbuf *old_pixbuf = NULL;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
- g_return_if_fail (clist_row != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (clist_row != NULL);
if (clist->column[column].auto_resize &&
!GTK_CMCLIST_AUTO_RESIZE_BLOCKED (clist))
case GTK_CMCELL_TEXT:
old_text = GTK_CMCELL_TEXT (clist_row->cell[column])->text;
break;
- case GTK_CMCELL_PIXMAP:
- old_pixmap = GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap;
- old_mask = GTK_CMCELL_PIXMAP (clist_row->cell[column])->mask;
+ case GTK_CMCELL_PIXBUF:
+ old_pixbuf = GTK_CMCELL_PIXBUF (clist_row->cell[column])->pixbuf;
break;
case GTK_CMCELL_PIXTEXT:
old_text = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->text;
- old_pixmap = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap;
- old_mask = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->mask;
+ old_pixbuf = GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixbuf;
break;
case GTK_CMCELL_WIDGET:
/* unimplemented */
clist_row->cell[column].type = GTK_CMCELL_EMPTY;
- /* Note that pixmap and mask were already ref'ed by the caller
+ /* Note that pixbuf and mask were already ref'ed by the caller
*/
switch (type)
{
GTK_CMCELL_TEXT (clist_row->cell[column])->text = g_strdup (text);
}
break;
- case GTK_CMCELL_PIXMAP:
- if (pixmap)
+ case GTK_CMCELL_PIXBUF:
+ if (pixbuf)
{
- clist_row->cell[column].type = GTK_CMCELL_PIXMAP;
- GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap = pixmap;
- /* We set the mask even if it is NULL */
- GTK_CMCELL_PIXMAP (clist_row->cell[column])->mask = mask;
+ clist_row->cell[column].type = GTK_CMCELL_PIXBUF;
+ GTK_CMCELL_PIXBUF (clist_row->cell[column])->pixbuf = pixbuf;
}
break;
case GTK_CMCELL_PIXTEXT:
- if (text && pixmap)
+ if (text && pixbuf)
{
clist_row->cell[column].type = GTK_CMCELL_PIXTEXT;
GTK_CMCELL_PIXTEXT (clist_row->cell[column])->text = g_strdup (text);
GTK_CMCELL_PIXTEXT (clist_row->cell[column])->spacing = spacing;
- GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap = pixmap;
- GTK_CMCELL_PIXTEXT (clist_row->cell[column])->mask = mask;
+ GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixbuf = pixbuf;
}
break;
default:
column_auto_resize (clist, clist_row, column, requisition.width);
g_free (old_text);
- if (old_pixmap)
- g_object_unref (old_pixmap);
- if (old_mask)
- g_object_unref (old_mask);
+ if (old_pixbuf)
+ g_object_unref (old_pixbuf);
}
PangoLayout *
GtkCMCell *cell;
gchar *text;
- get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style,
- NULL, NULL);
+ get_cell_style (clist, clist_row, GTK_STATE_NORMAL, column, &style);
cell = &clist_row->cell[column];
PangoLayout *layout;
PangoRectangle logical_rect;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
- g_return_if_fail (requisition != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (requisition != NULL);
layout = _gtk_cmclist_create_cell_layout (clist, clist_row, column);
if (layout)
switch (clist_row->cell[column].type)
{
case GTK_CMCELL_PIXTEXT:
- gdk_drawable_get_size (GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixmap,
- &width, &height);
+ width = gdk_pixbuf_get_width(GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixbuf);
+ height = gdk_pixbuf_get_height(GTK_CMCELL_PIXTEXT (clist_row->cell[column])->pixbuf);
requisition->width += width;
requisition->height = MAX (requisition->height, height);
break;
- case GTK_CMCELL_PIXMAP:
- gdk_drawable_get_size (GTK_CMCELL_PIXMAP (clist_row->cell[column])->pixmap,
- &width, &height);
+ case GTK_CMCELL_PIXBUF:
+ width = gdk_pixbuf_get_width(GTK_CMCELL_PIXBUF (clist_row->cell[column])->pixbuf);
+ height = gdk_pixbuf_get_height(GTK_CMCELL_PIXBUF (clist_row->cell[column])->pixbuf);
requisition->width += width;
requisition->height = MAX (requisition->height, height);
break;
gtk_cmclist_prepend (GtkCMCList *clist,
gchar *text[])
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
- g_return_val_if_fail (text != NULL, -1);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
+ cm_return_val_if_fail (text != NULL, -1);
return GTK_CMCLIST_GET_CLASS (clist)->insert_row (clist, 0, text);
}
gtk_cmclist_append (GtkCMCList *clist,
gchar *text[])
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
- g_return_val_if_fail (text != NULL, -1);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
+ cm_return_val_if_fail (text != NULL, -1);
return GTK_CMCLIST_GET_CLASS (clist)->insert_row (clist, clist->rows, text);
}
gint row,
gchar *text[])
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
- g_return_val_if_fail (text != NULL, -1);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
+ cm_return_val_if_fail (text != NULL, -1);
if (row < 0 || row > clist->rows)
row = clist->rows;
void
gtk_cmclist_clear (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
GTK_CMCLIST_GET_CLASS (clist)->clear (clist);
}
gint i;
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
- g_return_val_if_fail (text != NULL, -1);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
+ cm_return_val_if_fail (text != NULL, -1);
/* return if out of bounds */
if (row < 0 || row > clist->rows)
for (i = 0; i < clist->columns; i++)
if (text[i])
GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
- (clist, clist_row, i, GTK_CMCELL_TEXT, text[i], 0, NULL ,NULL);
+ (clist, clist_row, i, GTK_CMCELL_TEXT, text[i], 0, NULL);
if (!clist->rows)
{
GList *list;
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
/* return if out of bounds */
if (row < 0 || row > (clist->rows - 1))
* list to reflect the deincrimented indexies of rows after the
* removal */
if (clist_row->state == GTK_STATE_SELECTED)
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
row, -1, NULL);
sync_selection (clist, row, SYNC_REMOVE);
if (clist->selection_mode == GTK_SELECTION_BROWSE && !clist->selection &&
clist->focus_row >= 0)
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
clist->focus_row, -1, NULL);
/* toast the row */
{
GList *list;
GList *free_list;
+ GtkRequisition requisition;
gint i;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
/* free up the selection list */
g_list_free (clist->selection);
if (clist->column[i].auto_resize)
{
if (GTK_CMCLIST_SHOW_TITLES(clist) && clist->column[i].button)
+ {
+ gtk_widget_get_requisition (clist->column[i].button, &requisition);
gtk_cmclist_set_column_width
- (clist, i, (clist->column[i].button->requisition.width -
+ (clist, i, (requisition.width -
(CELL_SPACING + (2 * COLUMN_INSET))));
+ }
else
gtk_cmclist_set_column_width (clist, i, 0);
}
gint first, last;
gint d;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (GTK_CMCLIST_AUTO_SORT(clist))
return;
gfloat row_align,
gfloat col_align)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < -1 || row >= clist->rows)
return;
gtk_cmclist_set_row_height (GtkCMCList *clist,
guint height)
{
+ GtkStyle *style;
GtkWidget *widget;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
widget = GTK_WIDGET (clist);
+ style = gtk_widget_get_style (widget);
+
if (height > 0)
{
clist->row_height = height;
clist->row_height = 0;
}
- if (widget->style->font_desc)
+ if (style->font_desc)
{
PangoContext *context = gtk_widget_get_pango_context (widget);
PangoFontMetrics *metrics;
metrics = pango_context_get_metrics (context,
- widget->style->font_desc,
+ style->font_desc,
pango_context_get_language (context));
-
+
if (!GTK_CMCLIST_ROW_HEIGHT_SET(clist))
{
clist->row_height = (pango_font_metrics_get_ascent (metrics) +
pango_font_metrics_get_descent (metrics));
- clist->row_height = PANGO_PIXELS (clist->row_height);
+ clist->row_height = PANGO_PIXELS (clist->row_height) + 1;
}
pango_font_metrics_unref (metrics);
}
-
+
CLIST_REFRESH (clist);
}
gtk_cmclist_set_row_data_full (GtkCMCList *clist,
gint row,
gpointer data,
- GtkDestroyNotify destroy)
+ GDestroyNotify destroy)
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row > (clist->rows - 1))
return;
{
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
if (row < 0 || row > (clist->rows - 1))
return NULL;
GList *list;
gint n;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), -1);
for (n = 0, list = clist->row_list; list; n++, list = list->next)
if (GTK_CMCLIST_ROW (list)->data == data)
{
gint first, last;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
- g_return_if_fail (row1 != row2);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (row1 != row2);
if (GTK_CMCLIST_AUTO_SORT(clist))
return;
gint source_row,
gint dest_row)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (GTK_CMCLIST_AUTO_SORT(clist))
return;
source_row == dest_row)
return;
- g_signal_emit (GTK_OBJECT (clist), clist_signals[ROW_MOVE], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[ROW_MOVE], 0,
source_row, dest_row);
}
{
gint top;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
if (row < 0 || row >= clist->rows)
return GTK_VISIBILITY_NONE;
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
{
clist_row->foreground = *color;
clist_row->fg_set = TRUE;
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (clist)),
&clist_row->foreground, TRUE, TRUE);
}
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
{
clist_row->background = *color;
clist_row->bg_set = TRUE;
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (clist)),
&clist_row->background, TRUE, TRUE);
}
GtkRequisition requisition = { 0 };
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
if (clist_row->cell[column].style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
gtk_style_detach (clist_row->cell[column].style);
g_object_unref (clist_row->cell[column].style);
}
{
g_object_ref (clist_row->cell[column].style);
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
clist_row->cell[column].style =
gtk_style_attach (clist_row->cell[column].style,
clist->clist_window);
{
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
if (row < 0 || row >= clist->rows || column < 0 || column >= clist->columns)
return NULL;
gint *old_width;
gint i;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
if (clist_row->style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
gtk_style_detach (clist_row->style);
g_object_unref (clist_row->style);
}
{
g_object_ref (clist_row->style);
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
clist_row->style = gtk_style_attach (clist_row->style,
clist->clist_window);
}
{
GtkCMCListRow *clist_row;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), NULL);
if (row < 0 || row >= clist->rows)
return NULL;
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
remove_grab (clist);
GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
}
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
row, -1, NULL);
}
}
gtk_cmclist_get_selectable (GtkCMCList *clist,
gint row)
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), FALSE);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), FALSE);
if (row < 0 || row >= clist->rows)
return FALSE;
gint row,
gint column)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
if (column < -1 || column >= clist->columns)
return;
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
row, column, NULL);
}
gint row,
gint column)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row >= clist->rows)
return;
if (column < -1 || column >= clist->columns)
return;
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
row, column, NULL);
}
void
gtk_cmclist_select_all (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
GTK_CMCLIST_GET_CLASS (clist)->select_all (clist);
}
void
gtk_cmclist_unselect_all (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
GTK_CMCLIST_GET_CLASS (clist)->unselect_all (clist);
}
void
gtk_cmclist_undo_selection (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist->selection_mode == GTK_SELECTION_MULTIPLE &&
(clist->undo_selection || clist->undo_unselection))
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNDO_SELECTION], 0);
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNDO_SELECTION], 0);
}
/* PRIVATE SELECTION FUNCTIONS
if (clist_row->state == GTK_STATE_SELECTED)
{
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
row, column, event);
return;
}
case GTK_SELECTION_BROWSE:
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
row, column, event);
break;
default:
static gboolean
clist_has_grab (GtkCMCList *clist)
{
- return (GTK_WIDGET_HAS_GRAB (clist) &&
+ return (gtk_widget_has_grab (GTK_WIDGET(clist)) &&
gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))));
}
static void
toggle_focus_row (GtkCMCList *clist)
{
- g_return_if_fail (clist != 0);
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (clist != 0);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist) ||
clist->focus_row < 0 || clist->focus_row >= clist->rows)
static void
toggle_add_mode (GtkCMCList *clist)
{
- g_return_if_fail (clist != 0);
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (clist != 0);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist) ||
clist->selection_mode != GTK_SELECTION_MULTIPLE)
return;
- gtk_cmclist_draw_focus (GTK_WIDGET (clist));
+ gtk_cmclist_undraw_focus (GTK_WIDGET (clist));
if (!GTK_CMCLIST_ADD_MODE(clist))
{
GTK_CMCLIST_SET_FLAG (clist, CMCLIST_ADD_MODE);
- gdk_gc_set_line_attributes (clist->xor_gc, 1,
- GDK_LINE_ON_OFF_DASH, 0, 0);
- gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
}
else
{
GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_ADD_MODE);
- gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_SOLID, 0, 0);
clist->anchor_state = GTK_STATE_SELECTED;
}
gtk_cmclist_draw_focus (GTK_WIDGET (clist));
gint sel_row;
gboolean row_selected;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row > (clist->rows - 1))
return;
if (row == sel_row)
row_selected = TRUE;
else
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
sel_row, column, event);
}
{
GtkCMCListRow *clist_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (row < 0 || row > (clist->rows - 1))
return;
static void
real_select_all (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist))
return;
GList *list;
gint i;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist))
return;
case GTK_SELECTION_BROWSE:
if (clist->focus_row >= 0)
{
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[SELECT_ROW], 0,
clist->focus_row, -1, NULL);
return;
{
i = GPOINTER_TO_INT (list->data);
list = list->next;
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[UNSELECT_ROW], 0, i, -1, NULL);
}
}
{
GList *work;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist) ||
clist->selection_mode != GTK_SELECTION_MULTIPLE)
}
for (work = clist->undo_selection; work; work = work->next)
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
GPOINTER_TO_INT (work->data), -1, NULL);
for (work = clist->undo_unselection; work; work = work->next)
{
/* g_print ("unselect %d\n",GPOINTER_TO_INT (work->data)); */
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
GPOINTER_TO_INT (work->data), -1, NULL);
}
- if (GTK_WIDGET_HAS_FOCUS(clist) && clist->focus_row != clist->undo_anchor)
+ if (gtk_widget_has_focus(GTK_WIDGET(clist)) && clist->focus_row != clist->undo_anchor)
{
- gtk_cmclist_draw_focus (GTK_WIDGET (clist));
+ gtk_cmclist_undraw_focus (GTK_WIDGET (clist));
clist->focus_row = clist->undo_anchor;
gtk_cmclist_draw_focus (GTK_WIDGET (clist));
}
gint anchor,
gint undo_anchor)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist->selection_mode != GTK_SELECTION_MULTIPLE || clist->anchor >= 0)
return;
if (clist_row->selectable)
{
clist_row->state = GTK_STATE_SELECTED;
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[UNSELECT_ROW], 0,
row, -1, event);
clist->undo_selection = g_list_prepend
if (GTK_CMCLIST_ROW (list)->state == GTK_STATE_NORMAL)
{
GTK_CMCLIST_ROW (list)->state = GTK_STATE_SELECTED;
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[UNSELECT_ROW], 0,
i, -1, event);
clist->undo_selection =
if (GTK_CMCLIST_ROW (list)->state == GTK_STATE_NORMAL)
{
GTK_CMCLIST_ROW (list)->state = GTK_STATE_SELECTED;
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[UNSELECT_ROW], 0,
e, -1, event);
clist->undo_selection =
clist->undo_unselection = g_list_reverse (clist->undo_unselection);
for (list = clist->undo_unselection; list; list = list->next)
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
GPOINTER_TO_INT (list->data), -1, event);
clist->anchor = -1;
static void
start_selection (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist))
return;
static void
end_selection (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) &&
- GTK_WIDGET_HAS_FOCUS (clist))
+ gtk_widget_has_focus (GTK_WIDGET(clist)))
return;
GTK_CMCLIST_GET_CLASS (clist)->resync_selection (clist, NULL);
gfloat position,
gboolean auto_start_selection)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist) ||
clist->selection_mode != GTK_SELECTION_MULTIPLE)
gint i;
GtkCMCList *clist;
- g_return_if_fail (GTK_IS_CMCLIST (object));
+ cm_return_if_fail (GTK_IS_CMCLIST (object));
clist = GTK_CMCLIST (object);
/* unref adjustments */
if (clist->hadjustment)
{
- g_signal_handlers_disconnect_matched(GTK_OBJECT (clist->hadjustment), G_SIGNAL_MATCH_DATA,
+ g_signal_handlers_disconnect_matched(G_OBJECT (clist->hadjustment), G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, clist);
- g_object_unref (GTK_OBJECT (clist->hadjustment));
+ g_object_unref (G_OBJECT (clist->hadjustment));
clist->hadjustment = NULL;
}
if (clist->vadjustment)
{
- g_signal_handlers_disconnect_matched(GTK_OBJECT (clist->vadjustment), G_SIGNAL_MATCH_DATA,
+ g_signal_handlers_disconnect_matched(G_OBJECT (clist->vadjustment), G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, clist);
- g_object_unref (GTK_OBJECT (clist->vadjustment));
+ g_object_unref (G_OBJECT (clist->vadjustment));
clist->vadjustment = NULL;
}
{
GtkCMCList *clist;
- g_return_if_fail (GTK_IS_CMCLIST (object));
+ cm_return_if_fail (GTK_IS_CMCLIST (object));
clist = GTK_CMCLIST (object);
static void
gtk_cmclist_realize (GtkWidget *widget)
{
+ GtkAllocation allocation;
GtkCMCList *clist;
+ GtkStyle *style;
+ GdkWindow *window;
GdkWindowAttr attributes;
GdkGCValues values;
GtkCMCListRow *clist_row;
gint i;
gint j;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
clist = GTK_CMCLIST (widget);
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ gtkut_widget_set_realized (widget, TRUE);
+
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
- border_width = GTK_CONTAINER (widget)->border_width;
+ gtk_widget_get_allocation (widget, &allocation);
attributes.window_type = GDK_WINDOW_CHILD;
- attributes.x = widget->allocation.x + border_width;
- attributes.y = widget->allocation.y + border_width;
- attributes.width = widget->allocation.width - border_width * 2;
- attributes.height = widget->allocation.height - border_width * 2;
+ attributes.x = allocation.x + border_width;
+ attributes.y = allocation.y + border_width;
+ attributes.width = allocation.width - border_width * 2;
+ attributes.height = allocation.height - border_width * 2;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
/* main window */
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ window = gtk_widget_get_window (widget);
+ window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, clist);
+ gdk_window_set_user_data (window, clist);
+ gtk_widget_set_window (widget, window);
- widget->style = gtk_style_attach (widget->style, widget->window);
+ style = gtk_widget_get_style (widget);
+ style = gtk_style_attach (style, window);
+ gtk_widget_set_style (widget, style);
- gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
+ gtk_style_set_background (style, window, GTK_STATE_NORMAL);
/* column-title window */
attributes.width = clist->column_title_area.width;
attributes.height = clist->column_title_area.height;
- clist->title_window = gdk_window_new (widget->window, &attributes,
+ clist->title_window = gdk_window_new (window, &attributes,
attributes_mask);
gdk_window_set_user_data (clist->title_window, clist);
- gtk_style_set_background (widget->style, clist->title_window,
+ gtk_style_set_background (style, clist->title_window,
GTK_STATE_NORMAL);
gdk_window_show (clist->title_window);
/* clist-window */
attributes.x = (clist->internal_allocation.x +
- widget->style->xthickness);
+ style->xthickness);
attributes.y = (clist->internal_allocation.y +
- widget->style->ythickness +
+ style->ythickness +
clist->column_title_area.height);
attributes.width = clist->clist_window_width;
attributes.height = clist->clist_window_height;
- clist->clist_window = gdk_window_new (widget->window, &attributes,
+ clist->clist_window = gdk_window_new (window, &attributes,
attributes_mask);
gdk_window_set_user_data (clist->clist_window, clist);
gdk_window_set_background (clist->clist_window,
- &widget->style->base[GTK_STATE_NORMAL]);
+ &style->base[GTK_STATE_NORMAL]);
gdk_window_show (clist->clist_window);
gdk_drawable_get_size (clist->clist_window, &clist->clist_window_width,
&clist->clist_window_height);
*/
size_allocate_title_buttons (clist);
- /* GCs */
- clist->fg_gc = gdk_gc_new (widget->window);
- clist->bg_gc = gdk_gc_new (widget->window);
-
- /* We'll use this gc to do scrolling as well */
- gdk_gc_set_exposures (clist->fg_gc, TRUE);
-
- values.foreground = (widget->style->white.pixel==0 ?
- widget->style->black:widget->style->white);
- values.function = GDK_XOR;
- values.subwindow_mode = GDK_INCLUDE_INFERIORS;
- clist->xor_gc = gdk_gc_new_with_values (widget->window,
- &values,
- GDK_GC_FOREGROUND |
- GDK_GC_FUNCTION |
- GDK_GC_SUBWINDOW);
-
/* attach optional row/cell styles, allocate foreground/background colors */
list = clist->row_list;
for (i = 0; i < clist->rows; i++)
gint i;
GtkCMCList *clist;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
clist = GTK_CMCLIST (widget);
/* freeze the list */
clist->freeze_count++;
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
gtk_cmclist_unmap (widget);
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+ gtkut_widget_set_mapped (widget, FALSE);
/* detach optional row/cell styles */
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GtkCMCListRow *clist_row;
GList *list;
}
gdk_cursor_unref (clist->cursor_drag);
- g_object_unref (clist->xor_gc);
- g_object_unref (clist->fg_gc);
- g_object_unref (clist->bg_gc);
for (i = 0; i < clist->columns; i++)
{
clist->title_window = NULL;
clist->cursor_drag = NULL;
- clist->xor_gc = NULL;
- clist->fg_gc = NULL;
- clist->bg_gc = NULL;
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
gint i;
GtkCMCList *clist;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
clist = GTK_CMCLIST (widget);
- if (!GTK_WIDGET_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
{
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+ gtkut_widget_set_mapped (widget, TRUE);
/* map column buttons */
for (i = 0; i < clist->columns; i++)
{
if (clist->column[i].button &&
- GTK_WIDGET_VISIBLE (clist->column[i].button) &&
- !GTK_WIDGET_MAPPED (clist->column[i].button))
+ gtk_widget_get_visible (clist->column[i].button) &&
+ !gtk_widget_get_mapped (clist->column[i].button))
gtk_widget_map (clist->column[i].button);
}
gdk_window_show (clist->title_window);
gdk_window_show (clist->clist_window);
- gdk_window_show (widget->window);
+ gdk_window_show (gtk_widget_get_window (widget));
/* unfreeze the list */
clist->freeze_count = 0;
gint i;
GtkCMCList *clist;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
clist = GTK_CMCLIST (widget);
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+ gtkut_widget_set_mapped (widget, FALSE);
if (clist_has_grab (clist))
{
gdk_window_hide (clist->clist_window);
gdk_window_hide (clist->title_window);
- gdk_window_hide (widget->window);
+ gdk_window_hide (gtk_widget_get_window (widget));
/* unmap column buttons */
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button &&
- GTK_WIDGET_MAPPED (clist->column[i].button))
+ gtk_widget_get_mapped (clist->column[i].button))
gtk_widget_unmap (clist->column[i].button);
/* freeze the list */
gtk_cmclist_expose (GtkWidget *widget,
GdkEventExpose *event)
{
+ GdkWindow *window;
GtkCMCList *clist;
+ GtkStyle *style;
+
+ cm_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
+ cm_return_val_if_fail (event != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+ window = gtk_widget_get_window (widget);
+ style = gtk_widget_get_style (widget);
- if (GTK_WIDGET_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
{
clist = GTK_CMCLIST (widget);
/* draw border */
- if (event->window == widget->window)
- gtk_paint_shadow (widget->style, widget->window,
+ if (event->window == window)
+ gtk_paint_shadow (style, window,
GTK_STATE_NORMAL, clist->shadow_type,
NULL, NULL, NULL,
0, 0,
clist->clist_window_width +
- (2 * widget->style->xthickness),
+ (2 * style->xthickness),
clist->clist_window_height +
- (2 * widget->style->ythickness) +
+ (2 * style->ythickness) +
clist->column_title_area.height);
/* exposure events on the list */
if (event->window == clist->clist_window)
draw_rows (clist, &event->area);
- if (event->window == clist->clist_window &&
- clist->drag_highlight_row >= 0)
- GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
- (clist, g_list_nth (clist->row_list,
- clist->drag_highlight_row)->data,
- clist->drag_highlight_row, clist->drag_highlight_pos);
-
if (event->window == clist->title_window)
{
gint i;
for (i = 0; i < clist->columns; i++)
{
- if (clist->column[i].button)
+ if (clist->column[i].button) {
gtk_container_propagate_expose (GTK_CONTAINER (clist),
clist->column[i].button,
event);
+ }
}
}
}
GtkStyle *previous_style)
{
GtkCMCList *clist;
+ GtkStyle *style;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
if (GTK_WIDGET_CLASS (parent_class)->style_set)
(*GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous_style);
clist = GTK_CMCLIST (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
- gtk_style_set_background (widget->style, widget->window, widget->state);
- gtk_style_set_background (widget->style, clist->title_window, GTK_STATE_NORMAL);
- gdk_window_set_background (clist->clist_window, &widget->style->base[GTK_STATE_NORMAL]);
+ style = gtk_widget_get_style (widget);
+ gtk_style_set_background (style, gtk_widget_get_window (widget),
+ gtk_widget_get_state(widget));
+ gtk_style_set_background (style, clist->title_window, GTK_STATE_NORMAL);
+ gdk_window_set_background (clist->clist_window, &style->base[GTK_STATE_NORMAL]);
}
/* Fill in data after widget has correct style */
gint column;
gint button_actions;
- g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
+ cm_return_val_if_fail (event != NULL, FALSE);
clist = GTK_CMCLIST (widget);
if (GTK_CMCLIST_ADD_MODE(clist))
{
GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_ADD_MODE);
- if (GTK_WIDGET_HAS_FOCUS(widget))
+ if (gtk_widget_has_focus(widget))
{
- gtk_cmclist_draw_focus (widget);
- gdk_gc_set_line_attributes (clist->xor_gc, 1,
- GDK_LINE_SOLID, 0, 0);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row = row;
gtk_cmclist_draw_focus (widget);
}
else
{
- gdk_gc_set_line_attributes (clist->xor_gc, 1,
- GDK_LINE_SOLID, 0, 0);
clist->focus_row = row;
}
}
else if (row != clist->focus_row)
{
- if (GTK_WIDGET_HAS_FOCUS(widget))
+ if (gtk_widget_has_focus(widget))
{
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row = row;
gtk_cmclist_draw_focus (widget);
}
}
}
- if (!GTK_WIDGET_HAS_FOCUS(widget))
+ if (!gtk_widget_has_focus(widget))
gtk_widget_grab_focus (widget);
if (button_actions & GTK_CMBUTTON_SELECTS)
case GTK_SELECTION_SINGLE:
if (event->type != GDK_BUTTON_PRESS)
{
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[SELECT_ROW], 0,
row, column, event);
clist->anchor = -1;
clist->anchor = row;
break;
case GTK_SELECTION_BROWSE:
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[SELECT_ROW], 0,
row, column, event);
break;
GTK_CMCLIST_GET_CLASS (clist)->resync_selection
(clist, (GdkEvent *) event);
}
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[SELECT_ROW], 0,
row, column, event);
break;
g_signal_handlers_block_matched(G_OBJECT(clist), G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, drag_data);
- if (!GTK_WIDGET_HAS_FOCUS(widget))
+ if (!gtk_widget_has_focus(widget))
gtk_widget_grab_focus (widget);
clist->drag_pos = i;
clist->x_drag = (COLUMN_LEFT_XPIXEL(clist, i) + COLUMN_INSET +
clist->column[i].area.width + CELL_SPACING);
- if (GTK_CMCLIST_ADD_MODE(clist))
- gdk_gc_set_line_attributes (clist->xor_gc, 1, GDK_LINE_SOLID, 0, 0);
- draw_xor_line (clist);
-
return TRUE;
}
GtkCMCList *clist;
gint button_actions;
- g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
+ cm_return_val_if_fail (event != NULL, FALSE);
clist = GTK_CMCLIST (widget);
gdk_display_pointer_ungrab (gtk_widget_get_display (widget), event->time);
if (clist->x_drag >= 0)
- draw_xor_line (clist);
-
- if (GTK_CMCLIST_ADD_MODE(clist))
- {
- gdk_gc_set_line_attributes (clist->xor_gc, 1,
- GDK_LINE_ON_OFF_DASH, 0, 0);
- gdk_gc_set_dashes (clist->xor_gc, 0, "\4\4", 2);
- }
+ clist_refresh(clist);
width = new_column_width (clist, i, &x);
gtk_cmclist_set_column_width (clist, i, width);
{
case GTK_SELECTION_MULTIPLE:
if (!(event->state & GDK_SHIFT_MASK) ||
- !GTK_WIDGET_CAN_FOCUS (widget) ||
+ !gtk_widget_get_can_focus (widget) ||
event->x < 0 || event->x >= clist->clist_window_width ||
event->y < 0 || event->y >= clist->clist_window_height)
GTK_CMCLIST_GET_CLASS (clist)->resync_selection
gint row;
gint new_width;
gint button_actions = 0;
+ guint value;
- g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
clist = GTK_CMCLIST (widget);
if (!clist_has_grab (clist))
if (GTK_CMCLIST_IN_DRAG(clist))
{
- if (event->is_hint || event->window != widget->window)
+ if (event->is_hint || event->window != gtk_widget_get_window (widget))
gtk_widget_get_pointer (widget, &x, NULL);
else
x = event->x;
{
/* x_drag < 0 indicates that the xor line is already invisible */
if (clist->x_drag >= 0)
- draw_xor_line (clist);
+ clist_refresh(clist);
clist->x_drag = x;
if (clist->htimer)
return FALSE;
-#if GTK_CHECK_VERSION(2,12,0)
clist->htimer = gdk_threads_add_timeout
(SCROLL_TIME, (GSourceFunc) horizontal_timeout, clist);
-#else
- clist->htimer = g_timeout_add
- (SCROLL_TIME, (GSourceFunc) horizontal_timeout, clist);
-#endif
- if (!((x < 0 && clist->hadjustment->value == 0) ||
+ value = gtk_adjustment_get_value (clist->hadjustment);
+ if (!((x < 0 && value == 0) ||
(x >= clist->clist_window_width &&
- clist->hadjustment->value ==
+ value ==
LIST_WIDTH (clist) - clist->clist_window_width)))
{
if (x < 0)
{
if (clist->vtimer)
return FALSE;
-#if GTK_CHECK_VERSION(2,12,0)
clist->vtimer = gdk_threads_add_timeout (SCROLL_TIME,
(GSourceFunc) vertical_timeout, clist);
-#else
- clist->vtimer = g_timeout_add (SCROLL_TIME,
- (GSourceFunc) vertical_timeout, clist);
-#endif
if (clist->drag_button &&
((y < 0 && clist->focus_row == 0) ||
(y >= clist->clist_window_height &&
if (row == clist->focus_row)
return FALSE;
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row = row;
gtk_cmclist_draw_focus (widget);
switch (clist->selection_mode)
{
case GTK_SELECTION_BROWSE:
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
clist->focus_row, -1, event);
break;
case GTK_SELECTION_MULTIPLE:
GtkRequisition *requisition)
{
GtkCMCList *clist;
+ GtkStyle *style;
gint i;
gint font_height = 0;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
- g_return_if_fail (requisition != NULL);
+ guint border_width;
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (requisition != NULL);
clist = GTK_CMCLIST (widget);
+ style = gtk_widget_get_style (widget);
requisition->width = 0;
requisition->height = 0;
/* compute the size of the column title (title) area */
clist->column_title_area.height = 0;
if (GTK_CMCLIST_SHOW_TITLES(clist)) {
- font_height = (pango_font_description_get_size((GTK_WIDGET(clist)->style)->font_desc)/PANGO_SCALE)*2+4;
+ font_height = (pango_font_description_get_size(style->font_desc)/PANGO_SCALE)*2+4;
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button)
{
&child_requisition);
clist->column_title_area.height =
MAX (clist->column_title_area.height,
- child_requisition.height - 2);
+ child_requisition.height);
}
- clist->column_title_area.height = font_height;
+ //clist->column_title_area.height = font_height;
}
- requisition->width += (widget->style->xthickness +
- GTK_CONTAINER (widget)->border_width) * 2;
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+ requisition->width += (style->xthickness +
+ border_width) * 2;
requisition->height += (clist->column_title_area.height +
- (widget->style->ythickness +
- GTK_CONTAINER (widget)->border_width) * 2);
+ (style->ythickness +
+ border_width) * 2);
/* if (!clist->hadjustment) */
requisition->width += list_requisition_width (clist);
gtk_cmclist_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
+ GtkStyle *style;
GtkCMCList *clist;
GtkAllocation clist_allocation;
gint border_width;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
- g_return_if_fail (allocation != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (allocation != NULL);
+ style = gtk_widget_get_style (widget);
clist = GTK_CMCLIST (widget);
- widget->allocation = *allocation;
- border_width = GTK_CONTAINER (widget)->border_width;
+ gtk_widget_set_allocation (widget, allocation);
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
- gdk_window_move_resize (widget->window,
+ gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x + border_width,
allocation->y + border_width,
allocation->width - border_width * 2,
/* allocate clist window assuming no scrollbars */
clist_allocation.x = (clist->internal_allocation.x +
- widget->style->xthickness);
+ style->xthickness);
clist_allocation.y = (clist->internal_allocation.y +
- widget->style->ythickness +
+ style->ythickness +
clist->column_title_area.height);
clist_allocation.width = MAX (1, (gint)clist->internal_allocation.width -
- (2 * (gint)widget->style->xthickness));
+ (2 * (gint)style->xthickness));
clist_allocation.height = MAX (1, (gint)clist->internal_allocation.height -
- (2 * (gint)widget->style->ythickness) -
+ (2 * (gint)style->ythickness) -
(gint)clist->column_title_area.height);
clist->clist_window_width = clist_allocation.width;
clist->clist_window_height = clist_allocation.height;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (clist->clist_window,
clist_allocation.x,
}
/* position the window which holds the column title buttons */
- clist->column_title_area.x = widget->style->xthickness;
- clist->column_title_area.y = widget->style->ythickness;
+ clist->column_title_area.x = style->xthickness;
+ clist->column_title_area.y = style->ythickness;
clist->column_title_area.width = clist_allocation.width;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (clist->title_window,
clist->column_title_area.x,
GtkCMCList *clist;
guint i;
- g_return_if_fail (GTK_IS_CMCLIST (container));
- g_return_if_fail (callback != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (container));
+ cm_return_if_fail (callback != NULL);
if (!include_internals)
return;
/* PRIVATE DRAWING FUNCTIONS
* get_cell_style
- * draw_cell_pixmap
+ * draw_cell_pixbuf
* draw_row
* draw_rows
* draw_xor_line
GtkCMCListRow *clist_row,
gint state,
gint column,
- GtkStyle **style,
- GdkGC **fg_gc,
- GdkGC **bg_gc)
+ GtkStyle **style)
{
- gint fg_state;
-
- if ((state == GTK_STATE_NORMAL) &&
- (GTK_WIDGET (clist)->state == GTK_STATE_INSENSITIVE))
- fg_state = GTK_STATE_INSENSITIVE;
- else
- fg_state = state;
+ GtkStyle *gtkstyle;
if (clist_row->cell[column].style)
{
if (style)
*style = clist_row->cell[column].style;
- if (fg_gc)
- *fg_gc = clist_row->cell[column].style->fg_gc[fg_state];
- if (bg_gc) {
- if (state == GTK_STATE_SELECTED)
- *bg_gc = clist_row->cell[column].style->bg_gc[state];
- else
- *bg_gc = clist_row->cell[column].style->base_gc[state];
- }
}
else if (clist_row->style)
{
if (style)
*style = clist_row->style;
- if (fg_gc)
- *fg_gc = clist_row->style->fg_gc[fg_state];
- if (bg_gc) {
- if (state == GTK_STATE_SELECTED)
- *bg_gc = clist_row->style->bg_gc[state];
- else
- *bg_gc = clist_row->style->base_gc[state];
- }
}
else
{
+ gtkstyle = gtk_widget_get_style (GTK_WIDGET (clist));
if (style)
- *style = GTK_WIDGET (clist)->style;
- if (fg_gc)
- *fg_gc = GTK_WIDGET (clist)->style->fg_gc[fg_state];
- if (bg_gc) {
- if (state == GTK_STATE_SELECTED)
- *bg_gc = GTK_WIDGET (clist)->style->bg_gc[state];
- else
- *bg_gc = GTK_WIDGET (clist)->style->base_gc[state];
- }
-
- if (state != GTK_STATE_SELECTED)
- {
- if (fg_gc && clist_row->fg_set)
- *fg_gc = clist->fg_gc;
- if (bg_gc && clist_row->bg_set)
- *bg_gc = clist->bg_gc;
- }
+ *style = gtkstyle;
}
}
static gint
-draw_cell_pixmap (GdkWindow *window,
+draw_cell_pixbuf (GdkWindow *window,
GdkRectangle *clip_rectangle,
- GdkGC *fg_gc,
- GdkPixmap *pixmap,
- GdkBitmap *mask,
+ cairo_t *cr,
+ GdkPixbuf *pixbuf,
gint x,
gint y,
gint width,
gint xsrc = 0;
gint ysrc = 0;
- if (mask)
- {
- gdk_gc_set_clip_mask (fg_gc, mask);
- gdk_gc_set_clip_origin (fg_gc, x, y);
- }
+ if (!pixbuf || (width == 0 && height == 0))
+ return x;
if (x < clip_rectangle->x)
{
height -= ysrc;
y = clip_rectangle->y;
}
+
if (y + height > clip_rectangle->y + clip_rectangle->height)
height = clip_rectangle->y + clip_rectangle->height - y;
- gdk_draw_drawable (window, fg_gc, pixmap, xsrc, ysrc, x, y, width, height);
- gdk_gc_set_clip_origin (fg_gc, 0, 0);
- if (mask)
- gdk_gc_set_clip_mask (fg_gc, NULL);
+ gdk_cairo_set_source_pixbuf(cr, pixbuf, x, y);
+ cairo_paint(cr);
return x + MAX (width, 0);
}
+static void cairo_dash_from_add_mode(GtkCMCList *clist, cairo_t *cr)
+{
+ const double dashes[] = { 4.0, 4.0 };
+ if (GTK_CMCLIST_ADD_MODE(clist))
+ cairo_set_dash(cr, dashes, 2, 0);
+ else
+ cairo_set_dash(cr, NULL, 0, 0);
+}
+
static void
draw_row (GtkCMCList *clist,
GdkRectangle *area,
gint row,
GtkCMCListRow *clist_row)
{
+ GtkStyle *style;
GtkWidget *widget;
GdkRectangle *rect;
GdkRectangle row_rectangle;
gint last_column;
gint state;
gint i;
-
- g_return_if_fail (clist != NULL);
+ cairo_t *cr;
+ const double dashes[] = {4.0, 4.0};
+ cm_return_if_fail (clist != NULL);
/* bail now if we arn't drawable yet */
- if (!GTK_WIDGET_DRAWABLE (clist) || row < 0 || row >= clist->rows)
+ if (!gtk_widget_is_drawable (GTK_WIDGET(clist)) || row < 0 || row >= clist->rows)
return;
widget = GTK_WIDGET (clist);
+ style = gtk_widget_get_style (widget);
/* if the function is passed the pointer to the row instead of null,
* it avoids this expensive lookup */
clip_rectangle.y = row_rectangle.y;
clip_rectangle.height = row_rectangle.height;
- if (clist_row->state == GTK_STATE_NORMAL)
- {
- if (clist_row->fg_set)
- gdk_gc_set_foreground (clist->fg_gc, &clist_row->foreground);
- if (clist_row->bg_set)
- gdk_gc_set_foreground (clist->bg_gc, &clist_row->background);
- }
-
state = clist_row->state;
+ cr = gdk_cairo_create(clist->clist_window);
/* draw the cell borders and background */
if (area)
{
rect = &intersect_rectangle;
if (gdk_rectangle_intersect (area, &cell_rectangle,
- &intersect_rectangle))
- gdk_draw_rectangle (clist->clist_window,
- widget->style->base_gc[GTK_STATE_NORMAL],
- TRUE,
- intersect_rectangle.x,
- intersect_rectangle.y,
- intersect_rectangle.width,
- intersect_rectangle.height);
+ &intersect_rectangle)) {
+ gdk_cairo_rectangle(cr, &intersect_rectangle);
+ gdk_cairo_set_source_color(cr, &style->base[GTK_STATE_NORMAL]);
+ cairo_fill(cr);
+ }
/* the last row has to clear its bottom cell spacing too */
if (clist_row == clist->row_list_end->data)
cell_rectangle.y += clist->row_height + CELL_SPACING;
if (gdk_rectangle_intersect (area, &cell_rectangle,
- &intersect_rectangle))
- gdk_draw_rectangle (clist->clist_window,
- widget->style->base_gc[GTK_STATE_NORMAL],
- TRUE,
- intersect_rectangle.x,
- intersect_rectangle.y,
- intersect_rectangle.width,
- intersect_rectangle.height);
+ &intersect_rectangle)) {
+ gdk_cairo_rectangle(cr, &intersect_rectangle);
+ gdk_cairo_set_source_color(cr, &style->base[GTK_STATE_NORMAL]);
+ cairo_fill(cr);
+ }
}
if (!gdk_rectangle_intersect (area, &row_rectangle,&intersect_rectangle))
else
{
rect = &clip_rectangle;
- gdk_draw_rectangle (clist->clist_window,
- widget->style->base_gc[GTK_STATE_NORMAL],
- TRUE,
- cell_rectangle.x,
- cell_rectangle.y,
- cell_rectangle.width,
- cell_rectangle.height);
+ gdk_cairo_rectangle(cr, &cell_rectangle);
+ gdk_cairo_set_source_color(cr, &style->base[GTK_STATE_NORMAL]);
+ cairo_fill(cr);
/* the last row has to clear its bottom cell spacing too */
if (clist_row == clist->row_list_end->data)
{
cell_rectangle.y += clist->row_height + CELL_SPACING;
-
- gdk_draw_rectangle (clist->clist_window,
- widget->style->base_gc[GTK_STATE_NORMAL],
- TRUE,
- cell_rectangle.x,
- cell_rectangle.y,
- cell_rectangle.width,
- cell_rectangle.height);
+ gdk_cairo_rectangle(cr, &cell_rectangle);
+ gdk_cairo_set_source_color(cr, &style->base[GTK_STATE_NORMAL]);
+ cairo_fill(cr);
}
}
for (i = 0; i < clist->columns; i++)
{
GtkStyle *style;
- GdkGC *fg_gc;
- GdkGC *bg_gc;
PangoLayout *layout;
PangoRectangle logical_rect;
gint width;
gint height;
- gint pixmap_width;
+ gint pixbuf_width;
gint offset = 0;
if (!clist->column[i].visible)
continue;
- get_cell_style (clist, clist_row, state, i, &style, &fg_gc, &bg_gc);
+ get_cell_style (clist, clist_row, state, i, &style);
clip_rectangle.x = clist->column[i].area.x + clist->hoffset;
clip_rectangle.width = clist->column[i].area.width;
&intersect_rectangle))
continue;
- gdk_draw_rectangle (clist->clist_window, bg_gc, TRUE,
- rect->x, rect->y, rect->width, rect->height);
+ gdk_cairo_rectangle(cr, rect);
+ gdk_cairo_set_source_color(cr, &style->base[state]);
+ cairo_fill(cr);
clip_rectangle.x += COLUMN_INSET + CELL_SPACING;
clip_rectangle.width -= (2 * COLUMN_INSET + CELL_SPACING +
else
width = 0;
- pixmap_width = 0;
+ pixbuf_width = 0;
+ height = 0;
offset = 0;
switch (clist_row->cell[i].type)
{
- case GTK_CMCELL_PIXMAP:
- gdk_drawable_get_size (GTK_CMCELL_PIXMAP (clist_row->cell[i])->pixmap,
- &pixmap_width, &height);
- width += pixmap_width;
+ case GTK_CMCELL_PIXBUF:
+ pixbuf_width = gdk_pixbuf_get_width(GTK_CMCELL_PIXBUF (clist_row->cell[i])->pixbuf);
+ height = gdk_pixbuf_get_height(GTK_CMCELL_PIXBUF (clist_row->cell[i])->pixbuf);
+ width += pixbuf_width;
break;
case GTK_CMCELL_PIXTEXT:
- gdk_drawable_get_size (GTK_CMCELL_PIXTEXT (clist_row->cell[i])->pixmap,
- &pixmap_width, &height);
- width += pixmap_width + GTK_CMCELL_PIXTEXT (clist_row->cell[i])->spacing;
+ pixbuf_width = gdk_pixbuf_get_width(GTK_CMCELL_PIXTEXT (clist_row->cell[i])->pixbuf);
+ height = gdk_pixbuf_get_height(GTK_CMCELL_PIXTEXT (clist_row->cell[i])->pixbuf);
+ width += pixbuf_width + GTK_CMCELL_PIXTEXT (clist_row->cell[i])->spacing;
break;
default:
break;
break;
};
- /* Draw Text and/or Pixmap */
+ /* Draw Text and/or Pixbuf */
switch (clist_row->cell[i].type)
{
- case GTK_CMCELL_PIXMAP:
- draw_cell_pixmap (clist->clist_window, &clip_rectangle, fg_gc,
- GTK_CMCELL_PIXMAP (clist_row->cell[i])->pixmap,
- GTK_CMCELL_PIXMAP (clist_row->cell[i])->mask,
+ case GTK_CMCELL_PIXBUF:
+ draw_cell_pixbuf (clist->clist_window, &clip_rectangle, cr,
+ GTK_CMCELL_PIXBUF (clist_row->cell[i])->pixbuf,
offset,
clip_rectangle.y + clist_row->cell[i].vertical +
(clip_rectangle.height - height) / 2,
- pixmap_width, height);
+ pixbuf_width, height);
break;
case GTK_CMCELL_PIXTEXT:
offset =
- draw_cell_pixmap (clist->clist_window, &clip_rectangle, fg_gc,
- GTK_CMCELL_PIXTEXT (clist_row->cell[i])->pixmap,
- GTK_CMCELL_PIXTEXT (clist_row->cell[i])->mask,
+ draw_cell_pixbuf (clist->clist_window, &clip_rectangle, cr,
+ GTK_CMCELL_PIXTEXT (clist_row->cell[i])->pixbuf,
offset,
clip_rectangle.y + clist_row->cell[i].vertical+
(clip_rectangle.height - height) / 2,
- pixmap_width, height);
+ pixbuf_width, height);
offset += GTK_CMCELL_PIXTEXT (clist_row->cell[i])->spacing;
/* Fall through */
if (layout)
{
gint row_center_offset = (clist->row_height - logical_rect.height - 1) / 2;
-
- gdk_gc_set_clip_rectangle (fg_gc, &clip_rectangle);
- gdk_draw_layout (clist->clist_window, fg_gc,
- offset,
- row_rectangle.y + row_center_offset + clist_row->cell[i].vertical,
- layout);
+ gdk_cairo_set_source_color(cr, >k_widget_get_style(GTK_WIDGET(clist))->fg[state]);
+ cairo_move_to(cr, offset, row_rectangle.y + row_center_offset + clist_row->cell[i].vertical);
+ pango_cairo_show_layout(cr, layout);
g_object_unref (G_OBJECT (layout));
- gdk_gc_set_clip_rectangle (fg_gc, NULL);
}
break;
default:
}
/* draw focus rectangle */
+ cairo_dash_from_add_mode(clist, cr);
+ cairo_set_line_width(cr, 1.0);
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
if (clist->focus_row == row &&
- GTK_WIDGET_CAN_FOCUS (widget) && GTK_WIDGET_HAS_FOCUS(widget))
+ gtk_widget_get_can_focus (widget) && gtk_widget_has_focus(widget))
{
- if (!area)
- gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
- row_rectangle.x, row_rectangle.y,
- row_rectangle.width - 1, row_rectangle.height - 1);
+ if (!area) {
+ cairo_rectangle(cr, row_rectangle.x, row_rectangle.y,
+ row_rectangle.width + 1, row_rectangle.height);
+ gdk_cairo_set_source_color(cr, &style->fg[GTK_STATE_NORMAL]);
+ cairo_stroke(cr);
+ }
else if (gdk_rectangle_intersect (area, &row_rectangle,
&intersect_rectangle))
{
- gdk_gc_set_clip_rectangle (clist->xor_gc, &intersect_rectangle);
- gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
- row_rectangle.x, row_rectangle.y,
- row_rectangle.width - 1,
- row_rectangle.height - 1);
- gdk_gc_set_clip_rectangle (clist->xor_gc, NULL);
+ cairo_rectangle(cr, row_rectangle.x, row_rectangle.y,
+ row_rectangle.width + 1, row_rectangle.height);
+ gdk_cairo_set_source_color(cr, &style->fg[GTK_STATE_NORMAL]);
+ cairo_stroke(cr);
}
}
+ cairo_destroy(cr);
+
}
static void
gint first_row;
gint last_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist->row_height == 0 ||
- !GTK_WIDGET_DRAWABLE (clist))
+ !gtk_widget_is_drawable (GTK_WIDGET(clist)))
return;
if (area)
i++;
}
- if (!area)
- gdk_window_clear_area (clist->clist_window, 0,
- ROW_TOP_YPIXEL (clist, i), 0, 0);
+ if (!area) {
+ int w, h, y;
+ cairo_t *cr;
+#if GTK_CHECK_VERSION(2,24,0)
+ w = gdk_window_get_width(clist->clist_window);
+ h = gdk_window_get_height(clist->clist_window);
+#else
+ gdk_drawable_get_size(clist->clist_window, &w, &h);
+#endif
+ cr = gdk_cairo_create(clist->clist_window);
+ y = ROW_TOP_YPIXEL (clist, i);
+ gdk_cairo_set_source_color(cr, >k_widget_get_style(GTK_WIDGET(clist))->base[GTK_STATE_NORMAL]);
+ cairo_rectangle(cr, 0, y, w, h - y);
+ cairo_fill(cr);
+ cairo_destroy(cr);
+ }
}
static void
draw_xor_line (GtkCMCList *clist)
{
- GtkWidget *widget;
-
- g_return_if_fail (clist != NULL);
-
- widget = GTK_WIDGET (clist);
-
- gdk_draw_line (widget->window, clist->xor_gc,
- clist->x_drag,
- widget->style->ythickness,
- clist->x_drag,
+ cairo_t *cr;
+ cr = gdk_cairo_create(clist->clist_window);
+ cairo_set_line_width(cr, 1.0);
+ cairo_move_to(cr, clist->x_drag,
+ gtk_widget_get_style (GTK_WIDGET(clist))->ythickness);
+ cairo_line_to(cr, clist->x_drag,
clist->column_title_area.height +
clist->clist_window_height + 1);
+ cairo_stroke(cr);
+ cairo_destroy(cr);
}
static void
clist_refresh (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (CLIST_UNFROZEN (clist))
{
{
gint trow, tcol;
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
/* bounds checking, return false if the user clicked
* on a blank area */
gint *row,
gint *column)
{
- g_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (clist), 0);
return get_selection_info (clist, x, y, row, column);
}
{
if (clist->vadjustment)
{
- clist->vadjustment->page_size = clist->clist_window_height;
- clist->vadjustment->step_increment = clist->row_height;
- clist->vadjustment->page_increment =
- MAX (clist->vadjustment->page_size - clist->vadjustment->step_increment,
- clist->vadjustment->page_size / 2);
- clist->vadjustment->lower = 0;
- clist->vadjustment->upper = LIST_HEIGHT (clist);
+ gtk_adjustment_set_page_size (clist->vadjustment, clist->clist_window_height);
+ gtk_adjustment_set_step_increment (clist->vadjustment, clist->row_height);
+ gtk_adjustment_set_page_increment (clist->vadjustment,
+ MAX (clist->clist_window_height - clist->row_height,
+ clist->clist_window_height / 2));
+ gtk_adjustment_set_lower (clist->vadjustment, 0);
+ gtk_adjustment_set_upper (clist->vadjustment, LIST_HEIGHT (clist));
- if (clist->clist_window_height - clist->voffset > LIST_HEIGHT (clist) ||
- (clist->voffset + (gint)clist->vadjustment->value) != 0)
+ if ((clist->clist_window_height - clist->voffset) > LIST_HEIGHT (clist) ||
+ (clist->voffset + (gint)gtk_adjustment_get_value (clist->vadjustment)) != 0)
{
- clist->vadjustment->value = MAX (0, (LIST_HEIGHT (clist) -
- clist->clist_window_height));
- g_signal_emit_by_name (GTK_OBJECT (clist->vadjustment),
+ gtk_adjustment_set_value (clist->vadjustment,
+ MAX (0, (LIST_HEIGHT (clist) - clist->clist_window_height)));
+ g_signal_emit_by_name (G_OBJECT (clist->vadjustment),
"value_changed");
}
- g_signal_emit_by_name (GTK_OBJECT (clist->vadjustment), "changed");
+ g_signal_emit_by_name (G_OBJECT (clist->vadjustment), "changed");
}
if (clist->hadjustment)
{
- clist->hadjustment->page_size = clist->clist_window_width;
- clist->hadjustment->step_increment = 10;
- clist->hadjustment->page_increment =
- MAX (clist->hadjustment->page_size - clist->hadjustment->step_increment,
- clist->hadjustment->page_size / 2);
- clist->hadjustment->lower = 0;
- clist->hadjustment->upper = LIST_WIDTH (clist);
-
- if (clist->clist_window_width - clist->hoffset > LIST_WIDTH (clist) ||
- (clist->hoffset + (gint)clist->hadjustment->value) != 0)
+ gtk_adjustment_set_page_size (clist->hadjustment, clist->clist_window_width);
+ gtk_adjustment_set_step_increment (clist->hadjustment, 10);
+ gtk_adjustment_set_page_increment (clist->hadjustment,
+ MAX (clist->clist_window_width -
+ gtk_adjustment_get_step_increment (clist->hadjustment),
+ clist->clist_window_width / 2));
+ gtk_adjustment_set_lower (clist->hadjustment, 0);
+ gtk_adjustment_set_upper (clist->hadjustment, LIST_WIDTH (clist));
+
+ if ((clist->clist_window_width - clist->hoffset) > LIST_WIDTH (clist) ||
+ (clist->hoffset + (gint)gtk_adjustment_get_value (clist->hadjustment)) != 0)
{
- clist->hadjustment->value = MAX (0, (LIST_WIDTH (clist) -
- clist->clist_window_width));
- g_signal_emit_by_name (GTK_OBJECT (clist->hadjustment),
+ gtk_adjustment_set_value (clist->hadjustment, MAX (0, (LIST_WIDTH (clist) -
+ clist->clist_window_width)));
+ g_signal_emit_by_name (G_OBJECT (clist->hadjustment),
"value_changed");
}
- g_signal_emit_by_name (GTK_OBJECT (clist->hadjustment), "changed");
+ g_signal_emit_by_name (G_OBJECT (clist->hadjustment), "changed");
}
if (!block_resize && (!clist->vadjustment || !clist->hadjustment))
{
GtkWidget *widget;
GtkRequisition requisition;
+ GtkAllocation allocation;
widget = GTK_WIDGET (clist);
gtk_widget_size_request (widget, &requisition);
+ gtk_widget_get_allocation (widget, &allocation);
if ((!clist->hadjustment &&
- requisition.width != widget->allocation.width) ||
+ requisition.width != allocation.width) ||
(!clist->vadjustment &&
- requisition.height != widget->allocation.height))
+ requisition.height != allocation.height))
gtk_widget_queue_resize (widget);
}
}
{
GtkCMCList *clist;
- g_return_if_fail (adjustment != NULL);
- g_return_if_fail (data != NULL);
+ cm_return_if_fail (adjustment != NULL);
+ cm_return_if_fail (data != NULL);
clist = GTK_CMCLIST (data);
}
{
GtkCMCList *clist;
- g_return_if_fail (adjustment != NULL);
- g_return_if_fail (data != NULL);
+ cm_return_if_fail (adjustment != NULL);
+ cm_return_if_fail (data != NULL);
clist = GTK_CMCLIST (data);
}
GtkCMCList *clist;
gint dy, value;
- g_return_if_fail (adjustment != NULL);
- g_return_if_fail (GTK_IS_CMCLIST (data));
+ cm_return_if_fail (adjustment != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (data));
clist = GTK_CMCLIST (data);
if (adjustment != clist->vadjustment)
return;
- value = -adjustment->value;
+ value = -gtk_adjustment_get_value (adjustment);
dy = value - clist->voffset;
clist->voffset = value;
- if (GTK_WIDGET_DRAWABLE (clist))
+ if (gtk_widget_is_drawable (GTK_WIDGET(clist)))
{
gdk_window_scroll (clist->clist_window, 0, dy);
gdk_window_process_updates (clist->clist_window, FALSE);
/* The window to which widget->window is relative */
#define ALLOCATION_WINDOW(widget) \
- (GTK_WIDGET_NO_WINDOW (widget) ? \
- (widget)->window : \
- gdk_window_get_parent ((widget)->window))
+ (!gtk_widget_get_has_window (widget) ? \
+ gtk_widget_get_window (widget) : \
+ gdk_window_get_parent (gtk_widget_get_window(widget)))
static void
adjust_allocation_recurse (GtkWidget *widget,
gpointer data)
{
+ GtkAllocation allocation;
ScrollData *scroll_data = data;
+
+ gtk_widget_get_allocation (widget, &allocation);
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
- GdkRectangle tmp_rectangle = widget->allocation;
+ GdkRectangle tmp_rectangle = allocation;
tmp_rectangle.x += scroll_data->dx;
gtk_widget_size_allocate (widget, &tmp_rectangle);
{
if (ALLOCATION_WINDOW (widget) == scroll_data->window)
{
- widget->allocation.x += scroll_data->dx;
+ allocation.x += scroll_data->dx;
+ gtk_widget_set_allocation (widget, &allocation);
if (GTK_IS_CONTAINER (widget))
gtk_container_forall (GTK_CONTAINER (widget),
{
ScrollData scroll_data;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
scroll_data.window = ALLOCATION_WINDOW (widget);
else
scroll_data.window = NULL;
gint y = 0;
gint value;
gint dx;
+ cairo_t *cr;
- g_return_if_fail (adjustment != NULL);
- g_return_if_fail (GTK_IS_CMCLIST (data));
+ cm_return_if_fail (adjustment != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (data));
clist = GTK_CMCLIST (data);
container = GTK_CONTAINER (data);
if (adjustment != clist->hadjustment)
return;
- value = adjustment->value;
+ value = gtk_adjustment_get_value (adjustment);
dx = -value - clist->hoffset;
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
gdk_window_scroll (clist->title_window, dx, 0);
/* adjust the column button's allocations */
clist->hoffset = -value;
- if (GTK_WIDGET_DRAWABLE (clist))
+ cr = gdk_cairo_create(clist->clist_window);
+ cairo_dash_from_add_mode(clist, cr);
+ cairo_set_line_width(cr, 1.0);
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+ if (gtk_widget_is_drawable (GTK_WIDGET(clist)))
{
- if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
- !container->focus_child && GTK_CMCLIST_ADD_MODE(clist))
- {
- y = ROW_TOP_YPIXEL (clist, clist->focus_row);
-
- gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE, 0, y,
- clist->clist_window_width - 1,
- clist->row_height - 1);
- }
+ GtkWidget *focus_child = gtk_container_get_focus_child (container);
gdk_window_scroll (clist->clist_window, dx, 0);
gdk_window_process_updates (clist->clist_window, FALSE);
- if (GTK_WIDGET_CAN_FOCUS(clist) && GTK_WIDGET_HAS_FOCUS(clist) &&
- !container->focus_child)
+ if (gtk_widget_get_can_focus(GTK_WIDGET(clist)) &&
+ gtk_widget_has_focus(GTK_WIDGET(clist)) &&
+ !focus_child && GTK_CMCLIST_ADD_MODE(clist))
+ {
+ y = ROW_TOP_YPIXEL (clist, clist->focus_row);
+ cairo_rectangle(cr, 0, y, clist->clist_window_width + 1,
+ clist->row_height);
+ cairo_stroke(cr);
+ }
+
+ if (gtk_widget_get_can_focus(GTK_WIDGET(clist)) &&
+ gtk_widget_has_focus(GTK_WIDGET(clist)) &&
+ !focus_child)
{
if (GTK_CMCLIST_ADD_MODE(clist))
{
draw_rows (clist, &area);
clist->focus_row = focus_row;
- gdk_draw_rectangle (clist->clist_window, clist->xor_gc,
- FALSE, 0, y, clist->clist_window_width - 1,
- clist->row_height - 1);
+ cairo_rectangle(cr, 0, y, clist->clist_window_width + 1,
+ clist->row_height);
+ cairo_stroke(cr);
return;
}
- else if (ABS(dx) < clist->clist_window_width - 1)
- {
- gint x0;
- gint x1;
-
- if (dx > 0)
- {
- x0 = clist->clist_window_width - 1;
- x1 = dx;
- }
- else
- {
- x0 = 0;
- x1 = clist->clist_window_width - 1 + dx;
- }
-
- y = ROW_TOP_YPIXEL (clist, clist->focus_row);
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- x0, y + 1, x0, y + clist->row_height - 2);
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- x1, y + 1, x1, y + clist->row_height - 2);
- }
}
}
+ cairo_destroy(cr);
}
/* PRIVATE
for (i = 0; i < clist->columns; i++)
{
GTK_CMCLIST_GET_CLASS (clist)->set_cell_contents
- (clist, clist_row, i, GTK_CMCELL_EMPTY, NULL, 0, NULL, NULL);
+ (clist, clist_row, i, GTK_CMCELL_EMPTY, NULL, 0, NULL);
if (clist_row->cell[i].style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
gtk_style_detach (clist_row->cell[i].style);
g_object_unref (clist_row->cell[i].style);
}
if (clist_row->style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET(clist)))
gtk_style_detach (clist_row->style);
g_object_unref (clist_row->style);
}
if ((clist->selection_mode == GTK_SELECTION_BROWSE ||
clist->selection_mode == GTK_SELECTION_MULTIPLE) &&
!clist->selection)
- g_signal_emit (GTK_OBJECT (clist),
+ g_signal_emit (G_OBJECT (clist),
clist_signals[SELECT_ROW], 0,
clist->focus_row, -1, NULL);
}
GtkWidget *focus_child;
gboolean is_current_focus;
- if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ if (!gtk_widget_is_sensitive (widget))
return FALSE;
- focus_child = GTK_CONTAINER (widget)->focus_child;
+ focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget));
is_current_focus = gtk_widget_is_focus (GTK_WIDGET (clist));
gtk_cmclist_draw_focus (GtkWidget *widget)
{
GtkCMCList *clist;
+ cairo_t *cr;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
- if (!GTK_WIDGET_DRAWABLE (widget) || !GTK_WIDGET_CAN_FOCUS (widget))
+ if (!gtk_widget_is_drawable (widget) || !gtk_widget_get_can_focus (widget))
return;
clist = GTK_CMCLIST (widget);
- if (clist->focus_row >= 0)
- gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE,
- 0, ROW_TOP_YPIXEL(clist, clist->focus_row),
- clist->clist_window_width - 1,
- clist->row_height - 1);
+ if (clist->focus_row >= 0) {
+ cr = gdk_cairo_create(clist->clist_window);
+ cairo_dash_from_add_mode(clist, cr);
+ cairo_set_line_width(cr, 1.0);
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle(cr, 0, ROW_TOP_YPIXEL(clist, clist->focus_row),
+ clist->clist_window_width + 1,
+ clist->row_height);
+ cairo_stroke(cr);
+ cairo_destroy(cr);
+ }
+}
+
+static void
+gtk_cmclist_undraw_focus (GtkWidget *widget)
+{
+ GtkCMCList *clist;
+ int row;
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+
+ clist = GTK_CMCLIST(widget);
+
+ if (clist->focus_row < 0)
+ return;
+
+ if (!gtk_widget_is_drawable (widget) || !gtk_widget_get_can_focus (widget))
+ return;
+
+ clist = GTK_CMCLIST (widget);
+ if (clist->focus_row >= 0) {
+ cairo_t *cr = gdk_cairo_create(clist->clist_window);
+ cairo_set_line_width(cr, 1.0);
+ gdk_cairo_set_source_color(cr, >k_widget_get_style(widget)->base[GTK_STATE_NORMAL]);
+ cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
+ cairo_rectangle(cr, 0, ROW_TOP_YPIXEL(clist, clist->focus_row),
+ clist->clist_window_width + 1,
+ clist->row_height);
+ cairo_stroke(cr);
+ cairo_destroy(cr);
+ }
+
+ row = clist->focus_row;
+ GTK_CMCLIST_GET_CLASS(GTK_CMCLIST(widget))->draw_row(clist, NULL, row, ROW_ELEMENT (clist, row)->data);
}
static gint
list = g_list_nth (clist->row_list, clist->focus_row);
if (list && GTK_CMCLIST_ROW (list)->selectable)
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
clist->focus_row, -1, event);
else
gtk_cmclist_draw_focus (widget);
}
else
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
return FALSE;
}
{
GtkCMCList *clist = GTK_CMCLIST (widget);
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
GTK_CMCLIST_GET_CLASS (widget)->resync_selection (clist, (GdkEvent *) event);
{
return TRUE;
}
- else if (GTK_WIDGET_CAN_FOCUS (child))
+ else if (gtk_widget_get_can_focus (child))
{
gtk_widget_grab_focus (child);
return TRUE;
if (!GTK_CMCLIST_SHOW_TITLES(clist))
return FALSE;
- focus_child = GTK_CONTAINER (clist)->focus_child;
+ focus_child = gtk_container_get_focus_child (GTK_CONTAINER (clist));
g_assert (focus_child);
/* Movement direction within headers
while (!return_val && j >= 0 && j < clist->columns)
{
if (clist->column[j].button &&
- GTK_WIDGET_VISIBLE (clist->column[j].button))
+ gtk_widget_get_visible (clist->column[j].button))
{
if (focus_column (clist, j, dir))
{
while (!return_val && j != i)
{
if (clist->column[j].button &&
- GTK_WIDGET_VISIBLE (clist->column[j].button))
+ gtk_widget_get_visible (clist->column[j].button))
{
if (focus_column (clist, j, dir))
{
{
GtkWidget *widget;
- g_return_if_fail (clist != 0);
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (clist != 0);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
widget = GTK_WIDGET (clist);
case GTK_SCROLL_STEP_BACKWARD:
if (clist->focus_row <= 0)
return;
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row--;
gtk_cmclist_draw_focus (widget);
break;
case GTK_SCROLL_STEP_FORWARD:
if (clist->focus_row >= clist->rows - 1)
return;
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row++;
gtk_cmclist_draw_focus (widget);
break;
case GTK_SCROLL_PAGE_BACKWARD:
if (clist->focus_row <= 0)
return;
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row = MAX (0, clist->focus_row -
(2 * clist->clist_window_height -
clist->row_height - CELL_SPACING) /
case GTK_SCROLL_PAGE_FORWARD:
if (clist->focus_row >= clist->rows - 1)
return;
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row = MIN (clist->rows - 1, clist->focus_row +
(2 * clist->clist_window_height -
clist->row_height - CELL_SPACING) /
case GTK_SCROLL_JUMP:
if (position >= 0 && position <= 1)
{
- gtk_cmclist_draw_focus (widget);
+ gtk_cmclist_undraw_focus (widget);
clist->focus_row = position * (clist->rows - 1);
gtk_cmclist_draw_focus (widget);
}
gint column = 0;
gint last_column;
- g_return_if_fail (clist != 0);
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (clist != 0);
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist))
return;
{
gint old_focus_row;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist_has_grab (clist))
return;
if (old_focus_row != clist->focus_row)
{
if (clist->selection_mode == GTK_SELECTION_BROWSE)
- g_signal_emit (GTK_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[UNSELECT_ROW], 0,
old_focus_row, -1, NULL);
else if (!GTK_CMCLIST_ADD_MODE(clist))
{
if (old_focus_row != clist->focus_row &&
!(clist->selection_mode == GTK_SELECTION_MULTIPLE &&
GTK_CMCLIST_ADD_MODE(clist)))
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
clist->focus_row, -1, NULL);
switch (scroll_type)
{
if (old_focus_row != clist->focus_row &&
!(clist->selection_mode == GTK_SELECTION_MULTIPLE &&
GTK_CMCLIST_ADD_MODE(clist)))
- g_signal_emit (GTK_OBJECT (clist), clist_signals[SELECT_ROW], 0,
+ g_signal_emit (G_OBJECT (clist), clist_signals[SELECT_ROW], 0,
clist->focus_row, -1, NULL);
break;
}
if (!clist->hadjustment)
return;
- value = CLAMP (clist->hadjustment->value + diff, 0.0,
- clist->hadjustment->upper - clist->hadjustment->page_size);
+ value = CLAMP (gtk_adjustment_get_value (clist->hadjustment) + diff, 0.0,
+ gtk_adjustment_get_upper (clist->hadjustment) -
+ gtk_adjustment_get_page_size (clist->hadjustment));
gtk_adjustment_set_value (clist->hadjustment, value);
}
gfloat align)
{
gdouble value;
+ gdouble upper;
+ gdouble page_size;
if (!clist->vadjustment)
return;
align * (clist->clist_window_height - clist->row_height) +
(2 * align - 1) * CELL_SPACING);
- if (value + clist->vadjustment->page_size > clist->vadjustment->upper)
- value = clist->vadjustment->upper - clist->vadjustment->page_size;
+ upper = gtk_adjustment_get_upper (clist->vadjustment);
+ page_size = gtk_adjustment_get_page_size (clist->vadjustment);
+ if ((value + page_size) > upper)
+ value = upper - page_size;
gtk_adjustment_set_value (clist->vadjustment, value);
}
{
GtkWidget *widget = GTK_WIDGET (clist);
- if (GTK_WIDGET_HAS_GRAB (clist))
+ if (gtk_widget_has_grab (widget))
{
GdkDisplay *display = gtk_widget_get_display (widget);
void
gtk_cmclist_sort (GtkCMCList *clist)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
GTK_CMCLIST_GET_CLASS (clist)->sort_list (clist);
}
gtk_cmclist_set_compare_func (GtkCMCList *clist,
GtkCMCListCompareFunc cmp_func)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
clist->compare = (cmp_func) ? cmp_func : default_compare;
}
gtk_cmclist_set_auto_sort (GtkCMCList *clist,
gboolean auto_sort)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (GTK_CMCLIST_AUTO_SORT(clist) && !auto_sort)
GTK_CMCLIST_UNSET_FLAG (clist, CMCLIST_AUTO_SORT);
gtk_cmclist_set_sort_type (GtkCMCList *clist,
GtkSortType sort_type)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
clist->sort_type = sort_type;
}
gtk_cmclist_set_sort_column (GtkCMCList *clist,
gint column)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (column < 0 || column >= clist->columns)
return;
GList *work;
gint i;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (clist->rows <= 1)
return;
GtkCMCListDestInfo *dest_info)
{
GtkWidget *widget;
+ GtkStyle *style;
+ guint border_width;
widget = GTK_WIDGET (clist);
+ style = gtk_widget_get_style (widget);
dest_info->insert_pos = GTK_CMCLIST_DRAG_NONE;
- y -= (GTK_CONTAINER (clist)->border_width +
- widget->style->ythickness +
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
+ y -= (border_width +
+ style->ythickness +
clist->column_title_area.height);
dest_info->cell.row = ROW_FROM_YPIXEL (clist, y);
if (dest_info->cell.row < -1)
dest_info->cell.row = -1;
- x -= GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
+ x -= border_width + style->xthickness;
dest_info->cell.column = COLUMN_FROM_XPIXEL (clist, x);
GtkCMCList *clist;
GtkCMCListCellInfo *info;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
- g_return_if_fail (context != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (context != NULL);
clist = GTK_CMCLIST (widget);
{
GtkCMCList *clist;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
- g_return_if_fail (context != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (context != NULL);
clist = GTK_CMCLIST (widget);
GtkCMCList *clist;
GtkCMCListDestInfo *dest_info;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
- g_return_if_fail (context != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (context != NULL);
clist = GTK_CMCLIST (widget);
GTK_CMCLIST_REORDERABLE(clist) &&
gtk_drag_get_source_widget (context) == widget)
{
- GList *list;
GdkAtom atom = gdk_atom_intern_static_string ("gtk-clist-drag-reorder");
+ GdkAtom found = gtk_drag_dest_find_target(widget, context, NULL);
- list = context->targets;
- while (list)
- {
- if (atom == GDK_POINTER_TO_ATOM (list->data))
+ if (atom == found)
{
- GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
- (clist,
- g_list_nth (clist->row_list, dest_info->cell.row)->data,
- dest_info->cell.row, dest_info->insert_pos);
clist->drag_highlight_row = -1;
- break;
}
- list = list->next;
- }
}
g_dataset_remove_data (context, "gtk-clist-drag-dest");
}
GtkCMCListDestInfo new_info;
GtkCMCListDestInfo *dest_info;
- g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
clist = GTK_CMCLIST (widget);
if (GTK_CMCLIST_REORDERABLE (clist))
{
- GList *list;
GdkAtom atom = gdk_atom_intern_static_string ("gtk-clist-drag-reorder");
+ GdkAtom found = gtk_drag_dest_find_target(widget, context, NULL);
- list = context->targets;
- while (list)
- {
- if (atom == GDK_POINTER_TO_ATOM (list->data))
- break;
- list = list->next;
- }
-
- if (list)
+ if (atom == found)
{
if (gtk_drag_get_source_widget (context) != widget ||
new_info.insert_pos == GTK_CMCLIST_DRAG_NONE ||
(new_info.cell.row == dest_info->cell.row &&
dest_info->insert_pos != new_info.insert_pos))
{
- if (dest_info->cell.row >= 0)
- GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
- (clist, g_list_nth (clist->row_list,
- dest_info->cell.row)->data,
- dest_info->cell.row, dest_info->insert_pos);
dest_info->insert_pos = new_info.insert_pos;
dest_info->cell.row = new_info.cell.row;
dest_info->cell.column = new_info.cell.column;
- GTK_CMCLIST_GET_CLASS (clist)->draw_drag_highlight
- (clist, g_list_nth (clist->row_list,
- dest_info->cell.row)->data,
- dest_info->cell.row, dest_info->insert_pos);
-
clist->drag_highlight_row = dest_info->cell.row;
clist->drag_highlight_pos = dest_info->insert_pos;
- gdk_drag_status (context, context->suggested_action, time);
+ gdk_drag_status (context,
+ gdk_drag_context_get_suggested_action(context), time);
}
return TRUE;
}
gint y,
guint time)
{
- g_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
- g_return_val_if_fail (context != NULL, FALSE);
+ cm_return_val_if_fail (GTK_IS_CMCLIST (widget), FALSE);
+ cm_return_val_if_fail (context != NULL, FALSE);
if (GTK_CMCLIST_REORDERABLE (widget) &&
gtk_drag_get_source_widget (context) == widget)
{
- GList *list;
GdkAtom atom = gdk_atom_intern_static_string ("gtk-clist-drag-reorder");
+ GdkAtom found = gtk_drag_dest_find_target(widget, context, NULL);
- list = context->targets;
- while (list)
- {
- if (atom == GDK_POINTER_TO_ATOM (list->data))
+ if (atom == found)
return TRUE;
- list = list->next;
- }
}
return FALSE;
}
{
GtkCMCList *clist;
- g_return_if_fail (GTK_IS_CMCLIST (widget));
- g_return_if_fail (context != NULL);
- g_return_if_fail (selection_data != NULL);
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (context != NULL);
+ cm_return_if_fail (selection_data != NULL);
clist = GTK_CMCLIST (widget);
if (GTK_CMCLIST_REORDERABLE (clist) &&
gtk_drag_get_source_widget (context) == widget &&
- selection_data->target ==
+ gtk_selection_data_get_target (selection_data) ==
gdk_atom_intern_static_string ("gtk-clist-drag-reorder") &&
- selection_data->format == 8 &&
- selection_data->length == sizeof (GtkCMCListCellInfo))
+ gtk_selection_data_get_format (selection_data) == 8 &&
+ gtk_selection_data_get_length (selection_data) == sizeof (GtkCMCListCellInfo))
{
GtkCMCListCellInfo *source_info;
- source_info = (GtkCMCListCellInfo *)(selection_data->data);
+ source_info = (GtkCMCListCellInfo *)(gtk_selection_data_get_data (selection_data));
if (source_info)
{
GtkCMCListDestInfo dest_info;
guint info,
guint time)
{
- g_return_if_fail (GTK_IS_CMCLIST (widget));
- g_return_if_fail (context != NULL);
- g_return_if_fail (selection_data != NULL);
+ GdkAtom target;
+ cm_return_if_fail (GTK_IS_CMCLIST (widget));
+ cm_return_if_fail (context != NULL);
+ cm_return_if_fail (selection_data != NULL);
- if (selection_data->target == gdk_atom_intern_static_string ("gtk-clist-drag-reorder"))
+ target = gtk_selection_data_get_target (selection_data);
+ if (target == gdk_atom_intern_static_string ("gtk-clist-drag-reorder"))
{
GtkCMCListCellInfo *info;
ret_info.row = info->row;
ret_info.column = info->column;
- gtk_selection_data_set (selection_data, selection_data->target,
+ gtk_selection_data_set (selection_data, target,
8, (guchar *) &ret_info,
sizeof (GtkCMCListCellInfo));
}
}
}
-static void
-draw_drag_highlight (GtkCMCList *clist,
- GtkCMCListRow *dest_row,
- gint dest_row_number,
- GtkCMCListDragPos drag_pos)
-{
- gint y;
-
- y = ROW_TOP_YPIXEL (clist, dest_row_number) - 1;
-
- switch (drag_pos)
- {
- case GTK_CMCLIST_DRAG_NONE:
- break;
- case GTK_CMCLIST_DRAG_AFTER:
- y += clist->row_height + 1;
- case GTK_CMCLIST_DRAG_BEFORE:
- gdk_draw_line (clist->clist_window, clist->xor_gc,
- 0, y, clist->clist_window_width, y);
- break;
- case GTK_CMCLIST_DRAG_INTO:
- gdk_draw_rectangle (clist->clist_window, clist->xor_gc, FALSE, 0, y,
- clist->clist_window_width - 1, clist->row_height);
- break;
- }
-}
-
void
gtk_cmclist_set_reorderable (GtkCMCList *clist,
gboolean reorderable)
{
GtkWidget *widget;
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if ((GTK_CMCLIST_REORDERABLE(clist) != 0) == reorderable)
return;
gtk_cmclist_set_use_drag_icons (GtkCMCList *clist,
gboolean use_icons)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (use_icons != 0)
GTK_CMCLIST_SET_FLAG (clist, CMCLIST_USE_DRAG_ICONS);
guint button,
guint8 button_actions)
{
- g_return_if_fail (GTK_IS_CMCLIST (clist));
+ cm_return_if_fail (GTK_IS_CMCLIST (clist));
if (button < MAX_BUTTON)
{
if (gdk_display_pointer_is_grabbed (gtk_widget_get_display (GTK_WIDGET (clist))) ||
- GTK_WIDGET_HAS_GRAB (clist))
+ gtk_widget_has_grab (GTK_WIDGET(clist)))
{
remove_grab (clist);
clist->drag_button = 0;
projects / claws.git / blobdiff