static void
preferences_sound_cell_toggled_cb (GtkCellRendererToggle *toggle,
char *path_string,
EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkTreePath *path;
gboolean toggled, instore;
GtkTreeIter iter;
GtkTreeView *view;
GtkTreeModel *model;
char *key;
view = GTK_TREE_VIEW (priv->treeview_sounds);
model = gtk_tree_view_get_model (view);
path = gtk_tree_path_new_from_string (path_string);
toggled = gtk_cell_renderer_toggle_get_active (toggle);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, COL_SOUND_KEY, &key,
COL_SOUND_ENABLED, &instore, -1);
instore ^= 1;
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COL_SOUND_ENABLED, instore, -1);
g_settings_set_boolean (priv->gsettings_sound, key, instore);
g_free (key);
gtk_tree_path_free (path);
}
static void
handle_toggle(GtkCellRendererToggle *toggle,
char *path_str,
ParasiteWidgetTree *widget_tree,
int column,
void (*enable_func)(GtkWidget*),
void (*disable_func)(GtkWidget*))
{
GtkTreeIter iter;
GtkWidget *widget;
gboolean new_active = !gtk_cell_renderer_toggle_get_active(toggle);
if (!widget_tree->priv->edit_mode_enabled)
return;
gtk_tree_model_get_iter(GTK_TREE_MODEL(widget_tree->priv->model),
&iter,
gtk_tree_path_new_from_string(path_str));
gtk_tree_model_get(GTK_TREE_MODEL(widget_tree->priv->model), &iter,
WIDGET, &widget,
-1);
if (new_active)
enable_func(widget);
else
disable_func(widget);
gtk_tree_store_set(widget_tree->priv->model, &iter,
column, new_active,
-1);
}
static void
_gtk_user_list_dialog_tree_checkbox_toggled(GtkCellRendererToggle *renderer, gchar *path, GtkTreeView *widget)
{
GtkUserListDialogPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeIter child;
g_assert(GTK_IS_DELETABLE_DIALOG(widget));
priv = GTK_USER_LIST_DIALOG(widget)->priv;
if(priv->checkbox_column_activatable)
{
model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->tree));
if(gtk_tree_model_get_iter_from_string(model, &iter, path))
{
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(model), &child, &iter);
model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_list_store_set(GTK_LIST_STORE(model),
&child,
GTK_USER_LIST_TREEVIEW_COLUMN_CHECKBOX,
gtk_cell_renderer_toggle_get_active(renderer) ? FALSE : TRUE,
-1);
}
}
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkCellRendererToggle_gtk_1cell_1renderer_1toggle_1get_1active
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
gboolean result;
jboolean _result;
GtkCellRendererToggle* self;
// convert parameter self
self = (GtkCellRendererToggle*) _self;
// call function
result = gtk_cell_renderer_toggle_get_active(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
/**
* he_check_button_get_active:
* @button: A #HeCheckButton
*
* Gets the current state of @button.
*
* Return value: %TRUE if @button is active, %FALSE otherwise.
*
* Since: 2.2
**/
gboolean
he_check_button_get_active (HeCheckButton *button)
{
g_return_val_if_fail (HE_IS_CHECK_BUTTON (button), FALSE);
return gtk_cell_renderer_toggle_get_active (button->priv->toggle_renderer);
}
static void
field_toggled (const gchar *child_schema, GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
GtkTreeIter iter;
GtkTreeViewColumn *column;
gboolean toggled;
GSettings *settings = g_settings_get_child (ProcData::get_instance()->settings, child_schema);
gchar *key;
int id;
if (!path)
return;
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 2, &column, -1);
toggled = gtk_cell_renderer_toggle_get_active (cell);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1);
gtk_tree_view_column_set_visible (column, !toggled);
id = gtk_tree_view_column_get_sort_column_id (column);
key = g_strdup_printf ("col-%d-visible", id);
g_settings_set_boolean (settings, key, !toggled);
g_free (key);
gtk_tree_path_free (path);
}
/*
* enable / disable all breaks for a file when it's checkbox icon has been clicked
*/
void on_enable_for_file(GtkCellRendererToggle *cell_renderer, gchar *path, gpointer user_data)
{
/* do not process event is page is readonly (debug is running) */
if (readonly)
return;
GtkTreeIter iter;
GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
gtk_tree_model_get_iter (
model,
&iter,
tree_path);
gboolean current_state = gtk_cell_renderer_toggle_get_active(cell_renderer);
/* check if this is a file row */
if(1 == gtk_tree_path_get_depth(tree_path))
{
gchar *file;
gtk_tree_model_get (
model,
&iter,
FILEPATH, &file,
-1);
breaks_set_enabled_for_file(file, !current_state);
g_free(file);
}
gtk_tree_path_free(tree_path);
}
static void
photos_organize_collection_view_check_toggled (PhotosOrganizeCollectionView *self, gchar *path)
{
GApplication *app;
GList *urns;
GtkTreeIter iter;
GtkTreePath *tree_path;
PhotosSearchContextState *state;
PhotosSetCollectionJob *job;
gboolean active;
gchar *coll_urn;
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
tree_path = gtk_tree_path_new_from_string (path);
gtk_tree_model_get_iter (GTK_TREE_MODEL (self->model), &iter, tree_path);
gtk_tree_model_get (GTK_TREE_MODEL (self->model), &iter, PHOTOS_ORGANIZE_MODEL_ID, &coll_urn, -1);
active = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (self->renderer_check));
job = photos_set_collection_job_new (coll_urn, !active);
urns = photos_selection_controller_get_selection (self->sel_cntrlr);
photos_set_collection_job_run (job,
state,
urns,
self->cancellable,
photos_organize_collection_view_set_collection_executed,
self);
g_object_unref (job);
g_free (coll_urn);
}
void toggle_cell_checkbox(GtkTreeView *treeview, GtkListStore *listStore, GtkCellRendererToggle *cell_renderer, gchar *path, int row_index)
{
GtkTreeModel *model;
GtkTreeIter iter;
gboolean active = (gtk_cell_renderer_toggle_get_active(cell_renderer) ? FALSE : TRUE);
model = gtk_tree_view_get_model(treeview);
gtk_tree_model_get_iter_from_string(model, &iter, path);
gtk_list_store_set(listStore,&iter,
row_index, active,
-1);
}
static void todo_check_changed (GtkCellRendererToggle *cell_renderer, gchar *path, MaintainrProjectbox *item)
{
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (item->priv->todos));
gtk_tree_model_get_iter_from_string (model, &iter, path);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !gtk_cell_renderer_toggle_get_active (cell_renderer), -1);
g_signal_emit (item, signals [CONF_CHANGE], 0, NULL);
}
void gtkui_cheats_check(GtkWidget *widget, gchar *element, gpointer userdata) {
// This function doesn't work. Fix later.
GtkTreeIter iter;
bool value;
// Read the value of the checkbox
value = gtk_cell_renderer_toggle_get_active((GtkCellRendererToggle*)widget);
// Flip the value and set it
value ^= 1;
gtk_cell_renderer_toggle_set_active((GtkCellRendererToggle*)widget, value);
}
static void
enable_toggled (GtkCellRendererToggle *cell,
gchar *tree_path,
GtkListStore *store)
{
GtkTreePath *path = gtk_tree_path_new_from_string (tree_path);
GtkTreeIter iter;
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path))
gtk_list_store_set (store, &iter,
COLUMN_ENABLED,
!gtk_cell_renderer_toggle_get_active (cell),
-1);
gtk_tree_path_free (path);
}
static void
category_checkbox_toggled (GtkCellRendererToggle *toggle,
gchar *path,
GtkListStore *store)
{
GtkTreeIter iter;
gboolean active;
if (!gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store),
&iter, path))
return;
/* Get current state of the category */
active = gtk_cell_renderer_toggle_get_active(toggle);
gtk_list_store_set(store, &iter, COL_CHECKED, !active, -1);
}
void cell_edited_cb(GtkCellRendererToggle *cell_renderer,
gchar* path, gpointer user_data)
{
/* Get reference to model */
GtkTreePath* model_path = gtk_tree_path_new_from_string(path);
GtkTreeIter iter;
gtk_tree_model_get_iter(GTK_TREE_MODEL(format_model), &iter, model_path);
gtk_tree_path_free(model_path);
GValue value = G_VALUE_INIT;
g_value_init(&value, G_TYPE_BOOLEAN);
g_value_set_boolean(&value,
!gtk_cell_renderer_toggle_get_active(cell_renderer));
gtk_list_store_set_value(format_model, &iter, 1, &value);
}
static void
on_writable_toggled( GtkCellRendererToggle *renderer, gchar *path_string, BaseWindow *window )
{
static const gchar *thisfn = "cact_providers_list_on_writable_toggled";
GtkTreeView *treeview;
ProvidersListData *data;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean state;
gboolean writable_mandatory;
gchar *id;
if( !st_on_selection_change ){
treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
model = gtk_tree_view_get_model( treeview );
if( gtk_tree_model_get_iter_from_string( model, &iter, path_string )){
gtk_tree_model_get( model, &iter,
PROVIDER_WRITABLE_COLUMN, &state,
PROVIDER_ID_COLUMN, &id,
PROVIDER_WRITABLE_MANDATORY_COLUMN, &writable_mandatory,
-1 );
g_debug( "%s: id=%s, writable=%s (mandatory=%s)", thisfn, id,
state ? "True":"False", writable_mandatory ? "True":"False" );
data = get_providers_list_data( treeview );
if( writable_mandatory || data->preferences_locked ){
g_signal_handlers_block_by_func(( gpointer ) renderer, on_writable_toggled, window );
state = gtk_cell_renderer_toggle_get_active( renderer );
gtk_cell_renderer_toggle_set_active( renderer, !state );
g_signal_handlers_unblock_by_func(( gpointer ) renderer, on_writable_toggled, window );
} else {
gtk_list_store_set( GTK_LIST_STORE( model ), &iter, PROVIDER_WRITABLE_COLUMN, !state, -1 );
}
g_free( id );
}
}
}
/* callbacks */
void
on_service_toggled (GtkCellRenderer *renderer, gchar *path_str, gpointer data)
{
GtkTreeView *treeview = GTK_TREE_VIEW (gst_dialog_get_widget (tool->main_dialog, "services_list"));
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkTreePath *path;
GstTool *tool = GST_TOOL (data);
GtkTreeIter iter;
OobsService *service;
gboolean value, new_value, dangerous;
path = gtk_tree_path_new_from_string (path_str);
value = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (renderer));
new_value = !value;
if (!gtk_tree_model_get_iter (model, &iter, path))
return;
gtk_tree_model_get (model,
&iter,
COL_OBJECT, &service,
COL_DANGEROUS, &dangerous,
-1);
if (new_value || !dangerous || show_warning_dialog (tool, service)) {
OobsServicesRunlevel *rl;
rl = GST_SERVICES_TOOL (tool)->default_runlevel;
oobs_service_set_runlevel_configuration (service, rl,
(new_value) ? OOBS_SERVICE_START : OOBS_SERVICE_IGNORE,
/* FIXME: hardcoded value... */
50);
oobs_object_commit (GST_SERVICES_TOOL (tool)->services_config);
gtk_list_store_set (GTK_LIST_STORE (model),
&iter,
COL_ACTIVE, new_value,
-1);
}
gtk_tree_path_free (path);
}
static void
cipher_enable_toggled(GtkCellRendererToggle *renderer, gchar *path, AccountSecurityTab *self)
{
g_return_if_fail(IS_ACCOUNT_SECURITY_TAB(self));
AccountSecurityTabPrivate *priv = ACCOUNT_SECURITY_TAB_GET_PRIVATE(self);
/* we want to set it to the opposite of the current value */
gboolean toggle = !gtk_cell_renderer_toggle_get_active(renderer);
/* get iter which was clicked */
GtkTreePath *tree_path = gtk_tree_path_new_from_string(path);
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview_cipher_list));
GtkTreeIter iter;
gtk_tree_model_get_iter(model, &iter, tree_path);
/* get qmodelindex from iter and set the model data */
QModelIndex idx = gtk_q_tree_model_get_source_idx(GTK_Q_TREE_MODEL(model), &iter);
if (idx.isValid())
priv->account->cipherModel()->setData(idx, toggle ? Qt::Checked : Qt::Unchecked, Qt::CheckStateRole);
}
static void prop_toggled(GtkCellRendererToggle *cel, gchar *path,
GtkListStore *props)
{
struct sr_dev *dev = g_object_get_data(G_OBJECT(props), "dev");
GtkTreeIter iter;
int type, cap;
int ret;
gboolean val;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(props), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(props), &iter,
DEV_PROP_HWCAP, &cap,
DEV_PROP_TYPE, &type, -1);
val = !gtk_cell_renderer_toggle_get_active(cel);
ret = dev->driver->dev_config_set(dev->driver_index, cap,
GINT_TO_POINTER(val));
if (!ret)
gtk_list_store_set(props, &iter, DEV_PROP_BOOLVALUE, val, -1);
}
static void
import_dialog_cell_toggled_cb (GtkCellRendererToggle *cell_renderer,
const gchar *path_str,
EmpathyImportDialog *dialog)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
path = gtk_tree_path_new_from_string (path_str);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->treeview));
gtk_tree_model_get_iter (model, &iter, path);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COL_IMPORT, !gtk_cell_renderer_toggle_get_active (cell_renderer),
-1);
gtk_tree_path_free (path);
}
/************************************************************
* Callbacks *
************************************************************/
static void
gnc_tree_view_owner_active_toggled (GtkCellRendererToggle *cell,
const gchar *s_path_str,
gpointer user_data)
{
GncTreeViewOwner *tree_view;
GtkTreePath *s_path;
GncOwner *owner;
gboolean active;
/* Change the requested owner */
tree_view = user_data;
s_path = gtk_tree_path_new_from_string (s_path_str);
owner = gnc_tree_view_owner_get_owner_from_path (tree_view, s_path);
if (owner)
{
active = !gtk_cell_renderer_toggle_get_active (cell); // hasn't changed yet.
gncOwnerSetActive (owner, active);
}
/* Clean up */
gtk_tree_path_free (s_path);
}
static void
field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
GtkTreeIter iter;
GtkTreeViewColumn *column;
gboolean toggled;
if (!path)
return;
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 2, &column, -1);
toggled = gtk_cell_renderer_toggle_get_active (cell);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1);
gtk_tree_view_column_set_visible (column, !toggled);
gtk_tree_path_free (path);
}
static void
show_case_toggled (GtkCellRendererToggle *cell,
gchar *str,
struct _app_data *app)
{
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
test_case_t *c;
gboolean active;
active = ! gtk_cell_renderer_toggle_get_active (cell);
model = GTK_TREE_MODEL (app->case_store);
path = gtk_tree_path_new_from_string (str);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_store_set (app->case_store, &iter,
CASE_SHOWN, active,
CASE_INCONSISTENT, FALSE,
-1);
gtk_tree_model_get (model, &iter, CASE_DATA, &c, -1);
if (c != NULL) {
if (active == c->shown)
return;
c->shown = active;
} else {
recurse_set_shown (model, &iter, active);
}
check_consistent (model, &iter);
graph_view_update_visible ((GraphView *) app->gv);
}
static void
gimp_cell_renderer_toggle_render (GtkCellRenderer *cell,
cairo_t *cr,
GtkWidget *widget,
const GdkRectangle *background_area,
const GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
GdkRectangle toggle_rect;
GdkRectangle draw_rect;
GtkStyleContext *context = gtk_widget_get_style_context (widget);
GdkRectangle clip_rect;
GtkStateFlags state;
gboolean active;
gint xpad;
gint ypad;
if (! toggle->stock_id)
{
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell,
cr,
widget,
background_area,
cell_area,
flags);
return;
}
gtk_cell_renderer_get_size (cell, widget, cell_area,
&toggle_rect.x,
&toggle_rect.y,
&toggle_rect.width,
&toggle_rect.height);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
toggle_rect.x += cell_area->x + xpad;
toggle_rect.y += cell_area->y + ypad;
toggle_rect.width -= xpad * 2;
toggle_rect.height -= ypad * 2;
if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
return;
active =
gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
if (!gtk_cell_renderer_get_sensitive (cell))
{
state = GTK_STATE_FLAG_INSENSITIVE;
}
else if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
if (gtk_widget_has_focus (widget))
state = GTK_STATE_FLAG_SELECTED;
else
state = GTK_STATE_FLAG_ACTIVE;
}
else
{
if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell)))
state = GTK_STATE_FLAG_NORMAL;
else
state = GTK_STATE_FLAG_INSENSITIVE;
}
if ((flags & GTK_CELL_RENDERER_PRELIT) &&
gdk_cairo_get_clip_rectangle(cr, &clip_rect) &&
gdk_rectangle_intersect (&clip_rect, cell_area, &draw_rect))
{
cairo_save (cr);
gdk_cairo_rectangle (cr, &draw_rect);
cairo_clip (cr);
gtk_render_frame (context, //gtk_widget_get_style_context (widget),
cr,
toggle_rect.x, toggle_rect.y,
toggle_rect.width, toggle_rect.height);
gtk_style_context_restore (context);
cairo_restore (cr);
}
if (active)
{
GdkPixbuf *insensitive = NULL;
GdkPixbuf *pixbuf = toggle->pixbuf;
GtkBorder border = { 1, 1, 1, 1 };
#if 0
/* FIXME: for some reason calling gtk_style_context_get_border
* makes the icon only visible on hover, so use border = 1
* for now as a workaround
*/
gtk_style_context_get_border (context, state, &border);
#endif
toggle_rect.x += border.left;
toggle_rect.y += border.top;
toggle_rect.width -= (border.left + border.right);
toggle_rect.height -= (border.top + border.bottom);
if (state & GTK_STATE_FLAG_INSENSITIVE)
{
GtkIconSource *source;
source = gtk_icon_source_new ();
gtk_icon_source_set_pixbuf (source, pixbuf);
/* The size here is arbitrary; since size isn't
* wildcarded in the source, it isn't supposed to be
* scaled by the engine function
*/
gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_icon_source_set_size_wildcarded (source, FALSE);
gtk_style_context_save (context);
gtk_style_context_set_state (context, GTK_STATE_FLAG_INSENSITIVE);
insensitive = gtk_render_icon_pixbuf (context, source, (GtkIconSize)-1);
gtk_style_context_restore (context);
gtk_icon_source_free (source);
pixbuf = insensitive;
}
if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
{
gdk_cairo_set_source_pixbuf (cr, pixbuf, toggle_rect.x, toggle_rect.y);
gdk_cairo_rectangle (cr, &draw_rect);
cairo_fill (cr);
}
if (insensitive)
g_object_unref (insensitive);
}
}
static void
gimp_cell_renderer_toggle_render (GtkCellRenderer *cell,
GdkWindow *window,
GtkWidget *widget,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GdkRectangle *expose_area,
GtkCellRendererState flags)
{
GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell);
GtkStyle *style = gtk_widget_get_style (widget);
GdkRectangle toggle_rect;
GdkRectangle draw_rect;
GtkStateType state;
gboolean active;
gint xpad;
gint ypad;
if (! toggle->stock_id)
{
GTK_CELL_RENDERER_CLASS (parent_class)->render (cell, window, widget,
background_area,
cell_area, expose_area,
flags);
return;
}
gimp_cell_renderer_toggle_get_size (cell, widget, cell_area,
&toggle_rect.x,
&toggle_rect.y,
&toggle_rect.width,
&toggle_rect.height);
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
toggle_rect.x += cell_area->x + xpad;
toggle_rect.y += cell_area->y + ypad;
toggle_rect.width -= xpad * 2;
toggle_rect.height -= ypad * 2;
if (toggle_rect.width <= 0 || toggle_rect.height <= 0)
return;
active =
gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell));
if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
{
if (gtk_widget_has_focus (widget))
state = GTK_STATE_SELECTED;
else
state = GTK_STATE_ACTIVE;
}
else
{
if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell)))
state = GTK_STATE_NORMAL;
else
state = GTK_STATE_INSENSITIVE;
}
if (gdk_rectangle_intersect (expose_area, cell_area, &draw_rect) &&
(flags & GTK_CELL_RENDERER_PRELIT))
gtk_paint_shadow (style,
window,
state,
active ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
&draw_rect,
widget, NULL,
toggle_rect.x, toggle_rect.y,
toggle_rect.width, toggle_rect.height);
if (active)
{
toggle_rect.x += style->xthickness;
toggle_rect.y += style->ythickness;
toggle_rect.width -= style->xthickness * 2;
toggle_rect.height -= style->ythickness * 2;
if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect))
{
cairo_t *cr = gdk_cairo_create (window);
gboolean inconsistent;
gdk_cairo_rectangle (cr, &draw_rect);
cairo_clip (cr);
gdk_cairo_set_source_pixbuf (cr, toggle->pixbuf,
toggle_rect.x, toggle_rect.y);
cairo_paint (cr);
g_object_get (toggle,
"inconsistent", &inconsistent,
NULL);
if (inconsistent)
{
gdk_cairo_set_source_color (cr, &style->fg[state]);
cairo_set_line_width (cr, 1.5);
cairo_move_to (cr,
toggle_rect.x + toggle_rect.width - 1,
toggle_rect.y + 1);
cairo_line_to (cr,
toggle_rect.x + 1,
toggle_rect.y + toggle_rect.height - 1);
cairo_stroke (cr);
}
cairo_destroy (cr);
}
}
}
