void nsgtk_history_parent_update(gchar *path, const struct url_data *data)
{
GtkTreeIter iter;
gint num_visits, last_visit;
gtk_tree_model_get_iter_from_string(
GTK_TREE_MODEL(history->domain_list), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(history->domain_list), &iter,
DOM_TOTALVISITS, &num_visits,
DOM_LASTVISIT, &last_visit,
-1);
gtk_list_store_set(history->domain_list, &iter,
DOM_TOTALVISITS, num_visits + data->visits,
DOM_LASTVISIT, max(last_visit,data->last_visit),
-1);
/* Handle "All" */
gtk_tree_model_get_iter_from_string(
GTK_TREE_MODEL(history->domain_list), &iter, "0");
gtk_tree_model_get(GTK_TREE_MODEL(history->domain_list), &iter,
DOM_TOTALVISITS, &num_visits,
DOM_LASTVISIT, &last_visit,
-1);
gtk_list_store_set(history->domain_list, &iter,
DOM_TOTALVISITS, num_visits + data->visits,
DOM_LASTVISIT, max(last_visit,data->last_visit),
-1);
}
static char*
set_row_data (GtkTreeStore *store, char *path, char *parent, const char *attribute, const char *value)
{
GtkTreeIter iter;
gchar *utf_attribute = NULL;
gchar *utf_value = NULL;
gboolean iter_valid = FALSE;
if (!attribute) return NULL;
if (path != NULL) {
iter_valid = gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &iter, path);
}
if (!iter_valid) {
GtkTreePath *tree_path;
GtkTreeIter parent_iter;
gboolean parent_valid = FALSE;
if (parent != NULL) {
parent_valid = gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store),
&parent_iter,
parent);
}
gtk_tree_store_append (store, &iter, parent_valid ? &parent_iter : NULL);
if (path == NULL) {
tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
if (tree_path != NULL) {
path = gtk_tree_path_to_string (tree_path);
gtk_tree_path_free (tree_path);
}
}
}
utf_attribute = eog_util_make_valid_utf8 (attribute);
gtk_tree_store_set (store, &iter, MODEL_COLUMN_ATTRIBUTE, utf_attribute, -1);
g_free (utf_attribute);
if (value != NULL) {
utf_value = eog_util_make_valid_utf8 (value);
gtk_tree_store_set (store, &iter, MODEL_COLUMN_VALUE, utf_value, -1);
g_free (utf_value);
}
return path;
}
static void
on_selected_renderer_toggled (GtkCellRendererToggle *renderer, gchar *tree_path,
GitStatusPane *self)
{
GtkTreeModel *status_model;
GtkTreeIter iter;
gboolean selected;
AnjutaVcsStatus status;
gchar *path;
StatusType type;
status_model = GTK_TREE_MODEL (gtk_builder_get_object (self->priv->builder,
"status_model"));
gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (status_model), &iter,
tree_path);
gtk_tree_model_get (status_model, &iter,
COL_SELECTED, &selected,
COL_STATUS, &status,
COL_PATH, &path,
COL_TYPE, &type,
-1);
selected = !selected;
gtk_tree_store_set (GTK_TREE_STORE (status_model), &iter,
COL_SELECTED, selected,
-1);
git_status_pane_set_path_selection_state (self, path, status, type,
selected);
g_free (path);
}
static void
extension_state_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeModel *model;
gboolean new_state;
Extension *ext;
path = gtk_tree_path_new_from_string (path_str);
model = gtk_tree_view_get_model (GTK_TREE_VIEW (data));
g_object_get (G_OBJECT (cell), "active", &new_state, NULL);
gtk_tree_model_get_iter_from_string (model, &iter, path_str);
new_state ^= 1;
if (&iter != NULL)
{
gtk_tree_model_get (model, &iter, EXT_STRUCT_COLUMN, &ext, -1);
if (caja_extension_set_state (ext, new_state))
{
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
EXT_STATE_COLUMN, new_state, -1);
}
}
gtk_tree_path_free (path);
}
static void
value_combo_spin_edited (GtkCellRendererText *cell,
const gchar *path,
const gchar *new_text,
GladeEPropAttrs *eprop_attrs)
{
GtkTreeIter iter;
PangoAttrType type;
if (!gtk_tree_model_get_iter_from_string (eprop_attrs->model, &iter, path))
return;
gtk_tree_model_get (eprop_attrs->model, &iter, COLUMN_TYPE, &type, -1);
/* Reset the column */
if (new_text && (*new_text == '\0' || strcmp (new_text, _("None")) == 0))
{
gtk_list_store_set (GTK_LIST_STORE (eprop_attrs->model), &iter,
COLUMN_TEXT, _("<Enter Value>"),
COLUMN_NAME_WEIGHT, PANGO_WEIGHT_NORMAL,
COLUMN_TEXT_STYLE, PANGO_STYLE_ITALIC,
COLUMN_TEXT_FG, "Grey", -1);
}
else
gtk_list_store_set (GTK_LIST_STORE (eprop_attrs->model), &iter,
COLUMN_TEXT, new_text,
COLUMN_NAME_WEIGHT, PANGO_WEIGHT_BOLD,
COLUMN_TEXT_STYLE, PANGO_STYLE_NORMAL,
COLUMN_TEXT_FG, "Black", -1);
sync_object (eprop_attrs, FALSE);
}
void cgraphics_treeview_item_to_iter( widget_t *widget, list_item_t *item, GtkTreeIter *iter )
{
GtkTreeStore *store;
char path[256], tmp[256];
GtkTreeIter parent;
list_item_t *curr;
store = (GtkTreeStore *)gtk_tree_view_get_model( GTK_TREE_VIEW(widget->container) );
if ( item->parent_item == NULL )
{
gtk_tree_model_iter_nth_child( GTK_TREE_MODEL(store), iter, NULL, item->row );
return;
}
curr = item->parent_item;
strcpy( tmp, "" );
strcpy( path, "" );
for ( ; curr != 0; curr = curr->parent_item )
{
sprintf( tmp, "%d:%s", curr->row, path );
strcpy( path, tmp );
}
path[strlen(path)-1] = 0;
gtk_tree_model_get_iter_from_string( GTK_TREE_MODEL(store), &parent, path );
gtk_tree_model_iter_nth_child( GTK_TREE_MODEL(store), iter, &parent, item->row );
}
void change_entity_model (GtkListStore * store, int entity, char *valuepath,
char *value)
{
if (!value || !value[0])
return;
char *p;
long int ivalue = strtol (value, &p, 10);
if (*p)
return;
GtkTreeIter iter;
gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &iter,
valuepath);
int offset;
unsigned int size;
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, ENTITY_REF_COLUMN,
&offset, ENTITY_SIZEOF_COLUMN, &size, -1);
switch (size) {
case 1:
*(((char *) &gent[entity]) + offset) = ivalue;
break;
case 2:
*(int16_t *) (((char *) &gent[entity]) + offset) = ivalue;
break;
case 4:
*(int32_t *) (((char *) &gent[entity]) + offset) = ivalue;
break;
default:
break;
}
// make_entity_sane(entity);
gtk_list_store_set (store, &iter, ENTITY_VALUE_COLUMN, ivalue, -1);
}
static void
hd_select_plugins_dialog_plugin_toggled
(GtkCellRendererToggle *cell_renderer,
gchar *path,
gpointer user_data)
{
GtkTreeIter iter;
gboolean active;
/* Get the GtkTreeModel iter */
GtkTreeModel *model = GTK_TREE_MODEL (user_data);
if (!gtk_tree_model_get_iter_from_string (model, &iter, path)) return;
/* Get boolean value */
gtk_tree_model_get (model,
&iter,
HD_SPD_COLUMN_ACTIVE, &active,
-1);
/* Change the iter value on the TreeModel */
gtk_list_store_set (GTK_LIST_STORE (model),
&iter,
HD_SPD_COLUMN_ACTIVE, !active,
-1);
}
/**
* @brief Callback called when a cell has been edited in the configuration
* dialog
* @param renderer field object
* @param path
* @param text the new text
* @param data column where event is called
*
* @return void
*
*/
static void
on_configure_cell_edited(GtkCellRendererText* renderer, gchar* path, gchar* text, gpointer data)
{
GtkTreeIter iter;
gchar character;
gint i;
Column col = (Column)(GPOINTER_TO_INT(data));
log_func();
character=text[0];
i=1;
while (character != '\0') {
if ( ! g_ascii_isalpha(character) && character != ',' ) {
log_debug("Not-valid char");
return; // invalid extension
}
character=text[i++];
}
/* Replace old text with new */
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(list_store), &iter, path);
gtk_list_store_set(list_store, &iter, col, text, -1);
}
static void
contact_list_start_voip_call (EmpathyCellRendererActivatable *cell,
const gchar *path_string,
EmpathyContactListView *view,
gboolean with_video)
{
EmpathyContactListViewPriv *priv = GET_PRIV (view);
GtkTreeModel *model;
GtkTreeIter iter;
EmpathyContact *contact;
if (!(priv->contact_features & EMPATHY_CONTACT_FEATURE_CALL)) {
return;
}
model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
if (!gtk_tree_model_get_iter_from_string (model, &iter, path_string)) {
return;
}
gtk_tree_model_get (model, &iter,
EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
-1);
if (contact) {
EmpathyCallFactory *factory;
factory = empathy_call_factory_get ();
empathy_call_factory_new_call_with_streams (factory, contact,
TRUE, with_video);
g_object_unref (contact);
}
}
static void
dialog_pref_add_item (PrefState *state, char const *page_name,
char const *icon_name,
int page, char const* parent_path)
{
GtkTreeIter iter, parent;
GdkPixbuf * icon = NULL;
if (icon_name != NULL)
icon = gtk_widget_render_icon_pixbuf (state->dialog, icon_name,
GTK_ICON_SIZE_MENU);
if ((parent_path != NULL) && gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (state->store),
&parent, parent_path))
gtk_tree_store_append (state->store, &iter, &parent);
else
gtk_tree_store_append (state->store, &iter, NULL);
gtk_tree_store_set (state->store, &iter,
ITEM_ICON, icon,
ITEM_NAME, _(page_name),
PAGE_NUMBER, page,
-1);
if (icon != NULL)
g_object_unref (icon);
}
gboolean nsgtk_history_filter_search(GtkTreeModel *model, GtkTreeIter *iter,
GtkWidget *search_entry)
{
gchar *title, *address, *domain, *path;
gint result;
GtkTreeIter new_iter;
const gchar *search = gtk_entry_get_text(GTK_ENTRY(search_entry));
gtk_tree_model_get(model, iter, SITE_TITLE, &title,
SITE_ADDRESS, &address,
SITE_DOMAIN, &domain,
-1);
if (title)
result = (strstr(title, search) || strstr(address, search));
else
result = FALSE;
if (result) {
path = g_hash_table_lookup(history->domain_hash, domain);
gtk_tree_model_get_iter_from_string(
GTK_TREE_MODEL(history->domain_list),&new_iter,
path);
nsgtk_history_domain_set_visible(
GTK_TREE_MODEL(history->domain_list), NULL,
&new_iter, result);
}
g_free(title);
g_free(address);
g_free(domain);
return result;
}
static void refresh_combo_box_icons(GtkIconTheme* theme, GtkComboBox* combo_box, GList* app_list)
{
GList *entry;
MateDAItem *item;
GtkTreeModel *model;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
for (entry = app_list; entry != NULL; entry = g_list_next (entry)) {
item = (MateDAItem *) entry->data;
model = gtk_combo_box_get_model (combo_box);
if (item->icon_path && gtk_tree_model_get_iter_from_string (model, &iter, item->icon_path)) {
pixbuf = gtk_icon_theme_load_icon (theme, item->icon_name, 22, 0, NULL);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PIXBUF_COL, pixbuf,
-1);
if (pixbuf)
g_object_unref (pixbuf);
}
}
}
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);
}
}
}
static
void cb_custom_toggled(GtkCellRendererToggle *cell, char *path, gpointer data)
{
GtkTreeIter iter;
GtkTreeModel *model = (GtkTreeModel*) data;
if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {
PurpleAccount *account;
GValue value;
memset(&value, 0, sizeof(value));
gtk_tree_model_get_value(model, &iter, 5, &value);
assert(G_VALUE_HOLDS_POINTER(&value));
account = g_value_get_pointer(&value);
g_value_unset(&value);
gboolean flag;
char pref[STRLEN];
build_pref(pref, PREF_CUSTOM_DISABLED, purple_account_get_username(account), purple_account_get_protocol_name(account));
memset(&value, 0, sizeof(value));
gtk_tree_model_get_value(model, &iter, 3, &value);
assert(G_VALUE_HOLDS_BOOLEAN(&value));
flag = !g_value_get_boolean(&value);
g_value_unset(&value);
gtk_list_store_set(GTK_LIST_STORE(model), &iter, 3, flag, -1);
purple_prefs_set_bool(pref, flag);
if (flag) {
set_status(account, "", 0);
}
}
}
static void
gnc_gen_trans_update_toggled_cb (GtkCellRendererToggle *cell_renderer,
gchar *path,
GNCImportMainMatcher *gui)
{
GtkTreeModel *model;
GtkTreeIter iter;
GNCImportTransInfo *trans_info;
model = gtk_tree_view_get_model(gui->view);
if (!gtk_tree_model_get_iter_from_string(model, &iter, path))
return;
gtk_tree_model_get(model, &iter, DOWNLOADED_COL_DATA, &trans_info, -1);
if ( gnc_import_TransInfo_get_action(trans_info) == GNCImport_UPDATE
&& gnc_import_Settings_get_action_skip_enabled (gui->user_settings) == TRUE)
{
gnc_import_TransInfo_set_action(trans_info, GNCImport_SKIP);
}
else
{
gnc_import_TransInfo_set_action(trans_info, GNCImport_UPDATE);
}
refresh_model_row(gui, model, &iter, trans_info);
}
static void
shortcuts_accel_cleared_cb (GtkCellRenderer* renderer,
const gchar* tree_path,
GtkTreeModel* model)
{
GtkTreeIter iter;
if (gtk_tree_model_get_iter_from_string (model, &iter, tree_path))
{
GtkAction* action;
const gchar* accel_path;
GtkTreeIter child_iter;
GtkTreeModel* liststore;
gtk_tree_model_get (model, &iter, 6, &action, -1);
accel_path = gtk_action_get_accel_path (action);
gtk_accel_map_change_entry (accel_path, 0, 0, FALSE);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model),
&child_iter, &iter);
liststore = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (model));
gtk_list_store_set (GTK_LIST_STORE (liststore),
&child_iter, 1, 0, 2, 0, -1);
g_object_unref (action);
}
}
static void prop_edited(GtkCellRendererText *cel, gchar *path, gchar *text,
GtkListStore *props)
{
(void)cel;
struct sr_dev *dev = g_object_get_data(G_OBJECT(props), "dev");
GtkTreeIter iter;
int type, cap;
guint64 tmp_u64;
int ret = SR_ERR;
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);
switch (type) {
case SR_T_UINT64:
if (sr_parse_sizestring(text, &tmp_u64) != SR_OK)
return;
ret = dev->driver->dev_config_set(dev->driver_index,
cap, &tmp_u64);
break;
case SR_T_CHAR:
ret = dev->driver->dev_config_set(dev->driver_index, cap, text);
break;
/* SR_T_BOOL will be handled by prop_toggled */
}
if (!ret)
gtk_list_store_set(props, &iter, DEV_PROP_TEXTVALUE, text, -1);
}
static void
on_control_name_edited (GtkCellRendererText * cellrenderertext,
gchar * path_string, gchar * new_text, gpointer user_data)
{
BtSettingsPageInteractionController *self =
BT_SETTINGS_PAGE_INTERACTION_CONTROLLER (user_data);
GtkTreeModel *store;
if ((store = gtk_tree_view_get_model (self->priv->controller_list))) {
GtkTreeIter iter;
if (gtk_tree_model_get_iter_from_string (store, &iter, path_string)) {
GObject *control;
if ((control =
bt_object_list_model_get_object ((BtObjectListModel *) store,
&iter))) {
GtkTreePath *path;
gint pos;
g_object_set (control, "name", new_text, NULL);
// resort the list
on_device_menu_changed (self->priv->device_menu, self);
// select control again
pos = get_control_pos (self->priv->device, (BtIcControl *) control);
path = gtk_tree_path_new_from_indices (pos, -1);
gtk_widget_grab_focus (GTK_WIDGET (self->priv->controller_list));
gtk_tree_view_set_cursor (self->priv->controller_list, path,
gtk_tree_view_get_column (self->priv->controller_list,
CONTROLLER_LIST_LABEL), TRUE);
gtk_tree_path_free (path);
}
}
}
}
static void
on_search_cell_toggled(GtkCellRendererToggle *renderer,
gchar *path,
GtkTreeView *p_treeview) {
GtkTreeModel *model;
GtkTreeIter iter;
gboolean value;
gchar *item_id;
gchar *module_name;
GdkPixbuf *gd;
gchar *name;
/* Toggle the cell renderer's current state to the logical not. */
model = gtk_tree_view_get_model(p_treeview);
if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {
gtk_tree_model_get(model, &iter, 0, &value, 1, &gd, 2, &name, 3, &item_id,
4, &module_name, -1);
BREAKPOINT;
gtk_tree_store_set(GTK_TREE_STORE(model), &iter, 0, !value, 1, gd, 2, name,
3, item_id, 4, module_name, -1);
}
}
/********************************
* Meg_MapSection_Close
*
*/
gboolean Meg_MapSection_Close( GtkWidget *widget, GdkEvent *event, gpointer user_data )
{
gint result = 0;
GtkWidget * dialog = gtk_message_dialog_new( Meg_Misc_ParentWindow( widget ), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "Save '%s'", gtk_window_get_title( GTK_WINDOW(widget) ) );
gtk_dialog_add_buttons( GTK_DIALOG(dialog), GTK_STOCK_YES, 1, GTK_STOCK_NO, 2, GTK_STOCK_CANCEL, 0, NULL );
result = gtk_dialog_run( GTK_DIALOG(dialog) );
gtk_widget_destroy( dialog );
if ( result == 0 )
{
return TRUE;
}
else
{
GtkTreeIter iter;
if ( gtk_tree_model_get_iter_from_string( GTK_TREE_MODEL(sectionFileStore), &iter,(gchar*)g_object_get_data( G_OBJECT(widget), "alchera-list-path") ) )
{
gtk_list_store_set( sectionFileStore, &iter, 1, "", 3, NULL, -1);
}
if ( result == 1 )
{
guint32 section_id = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT(widget), "alchera-section-id" ) );
AL_MapSection_Save( section_id, Meg_Misc_ParentWindow( widget ) );
}
}
return FALSE;
}
/********************************
* Meg_MapSection_CloseTab
*
*/
gboolean Meg_MapSection_CloseTab( GtkWidget *event_box, GdkEventButton *event, GtkWidget * overview )
{
gint result = 0;
GtkWidget * dialog = gtk_message_dialog_new( Meg_Misc_ParentWindow( overview ), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "Save '%s'", (gchar*)g_object_get_data( G_OBJECT(overview), "alchera-section-name" ) );
gtk_dialog_add_buttons( GTK_DIALOG(dialog), GTK_STOCK_YES, 1, GTK_STOCK_NO, 2, GTK_STOCK_CANCEL, 0, NULL );
result = gtk_dialog_run( GTK_DIALOG(dialog) );
gtk_widget_destroy( dialog );
if ( result == 0 )
{
return TRUE;
}
else
{
GtkTreeIter iter;
if ( gtk_tree_model_get_iter_from_string( GTK_TREE_MODEL(sectionFileStore), &iter,(gchar*)g_object_get_data( G_OBJECT(overview), "alchera-list-path") ) )
{
gtk_list_store_set( sectionFileStore, &iter, 1, "", 3, NULL, -1);
}
if ( result == 1 )
{
guint32 section_id = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT(overview), "alchera-section-id" ) );
AL_MapSection_Save( section_id, Meg_Misc_ParentWindow( overview ) );
}
gint page = gtk_notebook_page_num( GTK_NOTEBOOK(sectionNotebook), overview);
if ( page != -1 )
{
gtk_notebook_remove_page( GTK_NOTEBOOK(sectionNotebook), page );
}
}
return FALSE;
}
static void
contact_list_view_voip_activated_cb (EmpathyCellRendererActivatable *cell,
const gchar *path_string,
EmpathyContactListView *view)
{
EmpathyContactListViewPriv *priv = GET_PRIV (view);
GtkTreeModel *model;
GtkTreeIter iter;
EmpathyContact *contact;
if (!(priv->contact_features & EMPATHY_CONTACT_FEATURE_CALL)) {
return;
}
model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
if (!gtk_tree_model_get_iter_from_string (model, &iter, path_string)) {
return;
}
gtk_tree_model_get (model, &iter,
EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
-1);
if (contact) {
empathy_dispatcher_call_with_contact (contact);
g_object_unref (contact);
}
}
static void
close_button_clicked (GtkCellRenderer *cell,
const gchar *path,
GeditDocumentsPanel *panel)
{
GtkTreeIter iter;
GeditTab *tab;
GeditNotebook *notebook;
if (!gtk_tree_model_get_iter_from_string (panel->priv->model,
&iter, path))
{
return;
}
gtk_tree_model_get (panel->priv->model,
&iter,
NOTEBOOK_COLUMN, ¬ebook,
TAB_COLUMN, &tab,
-1);
if (tab == NULL)
{
gedit_notebook_remove_all_tabs (notebook);
}
else
{
gtk_container_remove (GTK_CONTAINER (notebook),
GTK_WIDGET (tab));
g_object_unref (tab);
}
g_object_unref (notebook);
}
static void
on_debug_tree_value_changed (GtkCellRendererText *cell,
gchar *path_string,
gchar *text,
gpointer user_data)
{
DebugTree *tree = (DebugTree *)user_data;
GtkTreeIter iter;
GtkTreeModel * model;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree->view));
if (gtk_tree_model_get_iter_from_string (model, &iter, path_string))
{
DmaVariableData *item;
DmaVariablePacket *tran;
gtk_tree_model_get (model, &iter, DTREE_ENTRY_COLUMN, &item, -1);
if ((item != NULL) && (item->name != NULL) && (tree->debugger != NULL))
{
/* Variable is valid */
dma_queue_assign_variable (tree->debugger, item->name, text);
tran = dma_variable_packet_new(model, &iter, tree, item);
dma_queue_evaluate_variable (
tree->debugger,
item->name,
(IAnjutaDebuggerCallback) gdb_var_evaluate_expression,
tran);
}
}
}
/**
* rb_display_page_menu_get_page:
* @model: the #RBDisplayPageModel
* @parameters: action parameters
*
* Retrieves the page instance for an action invocation
* given the action parameters.
*
* Return value: (transfer full): page instance
*/
RBDisplayPage *
rb_display_page_menu_get_page (RBDisplayPageModel *model, GVariant *parameters)
{
GtkTreeIter iter;
RBDisplayPage *page;
if (g_variant_is_of_type (parameters, G_VARIANT_TYPE_STRING) == FALSE) {
rb_debug ("can't find page, variant type is %s", g_variant_get_type_string (parameters));
return NULL;
}
rb_debug ("trying to find page for %s", g_variant_get_string (parameters, NULL));
if (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (model),
&iter,
g_variant_get_string (parameters, NULL)) == FALSE) {
return NULL;
}
gtk_tree_model_get (GTK_TREE_MODEL (model),
&iter,
RB_DISPLAY_PAGE_MODEL_COLUMN_PAGE, &page,
-1);
return page;
}
static void
value_attribute_toggled (GtkCellRendererToggle * cell_renderer,
gchar * path, GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GtkTreeIter iter;
GladeIconSources *icon_sources = NULL;
GtkIconSource *source;
gchar *icon_name;
gint index, edit_column;
gboolean edit_column_active = FALSE;
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_sources->store), &iter, path))
return;
edit_column =
GPOINTER_TO_INT (g_object_get_data
(G_OBJECT (cell_renderer), "attribute-column"));
gtk_tree_model_get (GTK_TREE_MODEL (eprop_sources->store), &iter,
COLUMN_ICON_NAME, &icon_name, COLUMN_LIST_INDEX, &index,
edit_column, &edit_column_active, -1);
glade_property_get (property, &icon_sources);
if (icon_sources)
icon_sources = glade_icon_sources_copy (icon_sources);
if (icon_sources &&
(source = get_icon_source (icon_sources, icon_name, index)) != NULL)
{
/* Note the reverse meaning of active toggles vs. wildcarded sources... */
switch (edit_column)
{
case COLUMN_DIRECTION_ACTIVE:
gtk_icon_source_set_direction_wildcarded (source,
edit_column_active);
break;
case COLUMN_SIZE_ACTIVE:
gtk_icon_source_set_size_wildcarded (source, edit_column_active);
break;
case COLUMN_STATE_ACTIVE:
gtk_icon_source_set_state_wildcarded (source, edit_column_active);
break;
default:
break;
}
update_icon_sources (eprop, icon_sources);
g_free (icon_name);
return;
}
if (icon_sources)
glade_icon_sources_free (icon_sources);
g_free (icon_name);
return;
}
void enclose_chars_changed (GtkCellRendererText *renderer, gchar *path, gchar *new_char_str,
gpointer column_num)
{
GtkTreeIter chars_iter;
gchar new_chars [2] = {0, 0};
new_chars [0] = new_char_str [0];
gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (chars_list), &chars_iter, path);
gtk_list_store_set (chars_list, &chars_iter, GPOINTER_TO_INT (column_num), new_chars, -1);
}
static void
user_toggled_cb (GtkCellRendererToggle *renderer,
gchar *path,
gpointer user_data)
{
GstSharesTool *tool;
GtkWidget *table;
GtkTreeModel *model;
GtkTreeIter iter;
OobsUser *user;
gboolean active;
tool = GST_SHARES_TOOL (user_data);
table = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "users_table");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (table));
if (! gtk_tree_model_get_iter_from_string (model, &iter, path))
return;
gtk_tree_model_get (model, &iter,
COL_ACTIVE, &active,
COL_USER, &user,
-1);
/* we want to invert the state */
active ^= 1;
if (!active) {
oobs_smb_config_delete_user_password (OOBS_SMB_CONFIG (tool->smb_config), user);
} else {
GtkWidget *dialog;
gint response;
dialog = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "smb_password_dialog");
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (GST_TOOL (tool)->main_dialog));
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
if (response == GTK_RESPONSE_OK) {
GtkWidget *entry;
const gchar *password;
entry = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "smb_password_entry");
password = gtk_entry_get_text (GTK_ENTRY (entry));
oobs_smb_config_set_user_password (OOBS_SMB_CONFIG (tool->smb_config), user, password);
}
}
active = oobs_smb_config_user_has_password (OOBS_SMB_CONFIG (tool->smb_config), user);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COL_ACTIVE, active,
-1);
g_object_unref (user);
gst_tool_commit_async (GST_TOOL (tool), tool->smb_config, NULL, NULL, NULL);
}
void gw_flashcardstore_trim (GwFlashCardStore *store, gint max)
{
//Sanity Checks
if (store == NULL) return;
if (max < 1) return;
//Declarations
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
gboolean valid;
gint children;
gchar *path_string;
GRand *random;
gint position;
gtk_tree_sortable_set_sort_column_id (
GTK_TREE_SORTABLE (store),
GW_FLASHCARDSTORE_COLUMN_WEIGHT,
GTK_SORT_DESCENDING);
model = GTK_TREE_MODEL (store);
random = g_rand_new ();
children = gtk_tree_model_iter_n_children (model, NULL);
if (random != NULL)
{
while (children > max && children > 0)
{
position = g_rand_int_range (random, 0, children);
path_string = g_strdup_printf ("%d", position);
if (path_string != NULL)
{
valid = gtk_tree_model_get_iter_from_string (model, &iter, path_string);
if (valid)
{
gtk_tree_model_get (model, &iter, GW_FLASHCARDSTORE_COLUMN_TREE_PATH, &path, -1);
if (path != NULL) gtk_tree_path_free (path); path = NULL;
gtk_list_store_remove (GTK_LIST_STORE (store), &iter);
}
g_free (path_string); path_string = NULL;
}
children--;
}
g_rand_free (random); random = NULL;
}
gtk_tree_sortable_set_sort_column_id (
GTK_TREE_SORTABLE (store),
GW_FLASHCARDSTORE_COLUMN_ORDER,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_column_id (
GTK_TREE_SORTABLE (store),
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
}
