static GtkTreeIter *
photos_organize_collection_model_find_collection_iter (PhotosOrganizeCollectionModel *self,
PhotosBaseItem *collection)
{
PhotosOrganizeCollectionModelPrivate *priv = self->priv;
gtk_tree_model_foreach (GTK_TREE_MODEL (self), photos_organize_collection_model_foreach, collection);
if (priv->coll_path != NULL)
{
GtkTreeIter iter;
gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, priv->coll_path);
g_clear_pointer (&priv->coll_path, (GDestroyNotify) gtk_tree_path_free);
return gtk_tree_iter_copy (&iter);
}
return NULL;
}
static FilterResultCallbackData *
filter_result_callback_data_new (EmpathyAccountChooser *self,
TpAccount *account,
GtkTreeIter *iter)
{
FilterResultCallbackData *data;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (account != NULL, NULL);
g_return_val_if_fail (iter != NULL, NULL);
data = g_slice_new0 (FilterResultCallbackData);
data->self = g_object_ref (self);
data->account = g_object_ref (account);
data->iter = gtk_tree_iter_copy (iter);
return data;
}
/*
* Allocates a GtkTreeIter by calling the boxed's _copy() function on a local
* struct variable. By definition, a "boxed" is a struct. Local variables, of
* course, all have local storage on the stack. So with the & operater you
* can pass them to a function that takes a pointer so it can modify them; in
* our usage we need one in pointer form so use gtk_tree_iter_copy() to get
* us one in a manner that will be safely released by a later call to
* gtk_tree_iter_free().
*/
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkTreeIterOverride_gtk_1tree_1iter_1new
(
JNIEnv* env,
jclass cls
)
{
GtkTreeIter blank = { 0, };
GtkTreeIter* result;
// blank is allocated locally on the stack
// copy blank
result = gtk_tree_iter_copy(&blank);
// and finally
return (jlong) result;
}
static void
gimp_int_store_add_empty (GimpIntStore *store)
{
GtkTreeIter iter = { 0, };
g_return_if_fail (store->empty_iter == NULL);
gtk_list_store_prepend (GTK_LIST_STORE (store), &iter);
gtk_list_store_set (GTK_LIST_STORE (store), &iter,
GIMP_INT_STORE_VALUE, -1,
/* This string appears in an empty menu as in
* "nothing selected and nothing to select"
*/
GIMP_INT_STORE_LABEL, (_("(Empty)")),
-1);
store->empty_iter = gtk_tree_iter_copy (&iter);
}
static void
manager_active_changed_cb (LogviewManager *manager,
LogviewLog *log,
LogviewLog *old_log,
gpointer user_data)
{
LogviewLoglist *list = user_data;
GtkTreeIter * iter, sel_iter;
GtkTreeSelection * selection;
if (list->priv->selection &&
gtk_tree_model_get_iter (GTK_TREE_MODEL (list->priv->model),
&sel_iter, list->priv->selection))
{
Day *day;
iter = gtk_tree_iter_copy (&sel_iter);
gtk_tree_model_get (GTK_TREE_MODEL (list->priv->model), iter,
LOG_DAY, &day, -1);
if (day) {
g_signal_emit (list, signals[DAY_SELECTED], 0, day, NULL);
}
gtk_tree_path_free (list->priv->selection);
list->priv->selection = NULL;
} else {
iter = logview_loglist_find_log (list, log);
}
if (!iter) {
return;
}
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list));
g_signal_handlers_block_by_func (selection, tree_selection_changed_cb, list);
gtk_tree_selection_select_iter (selection, iter);
g_signal_handlers_unblock_by_func (selection, tree_selection_changed_cb, list);
gtk_tree_iter_free (iter);
}
void move_down (GtkButton *button, gpointer user_data)
{
GtkTreeIter first_iter, *second_iter;
GtkTreeSelection *selected;
Widgets *widgets = (Widgets*)user_data;
selected = gtk_tree_view_get_selection (widgets->tree);
if(selected == NULL)
{
return 0;
}
gtk_tree_selection_get_selected (selected, NULL, &first_iter);
//gtk_tree_store_remove (store, &first_iter);
second_iter = gtk_tree_iter_copy (&first_iter);
if(gtk_tree_model_iter_next (widgets->store, second_iter))
{
gtk_tree_store_swap (widgets->store, &first_iter, second_iter);
}
}
static GtkTreeIter *
history_dialog_add_host_item (HistoryDialog *dialog,
HistoryItem *item)
{
GtkTreeIter iter;
GtkTreeIter *tmp;
if (!dialog->priv->group) return NULL;
gtk_tree_store_insert (GTK_TREE_STORE (dialog->priv->model),
&iter,
NULL,
0);
tmp = gtk_tree_iter_copy (&iter);
history_dialog_update_host_item (dialog, item, tmp);
return tmp;
}
gTreeRow* gTree::addRow(char *key, char *after, bool before)
{
GtkTreeIter iter;
GtkTreeIter *piter;
gTreeRow *row,*aft = NULL;
char *buf;
if (!key)
return NULL;
if (g_hash_table_lookup (datakey,(gconstpointer)key)) return NULL;
if (after)
{
aft=(gTreeRow*)g_hash_table_lookup (datakey,(gconstpointer)after);
if (!aft) return NULL;
}
piter = NULL;
//fprintf(stderr, "[0]: %d %d\n", columnResizable(0), gtk_tree_view_column_get_sizing(gt_tree_view_find_column(GTK_TREE_VIEW(widget), 0)));
if (aft)
{
if (before)
gtk_tree_store_insert_before(store, &iter, piter, aft->dataiter);
else
gtk_tree_store_insert_after(store, &iter, piter, aft->dataiter);
}
else
gtk_tree_store_append (store, &iter, piter);
buf = g_strdup(key); // Will be freed by ~gTreeRow()
row = new gTreeRow(this, buf, gtk_tree_iter_copy(&iter));
g_hash_table_insert(datakey, (gpointer)buf, (gpointer)row);
gtk_tree_store_set(store, &iter, 1, buf, -1);
//fprintf(stderr, "[0]: -> %d %d\n", columnResizable(0), gtk_tree_view_column_get_sizing(gt_tree_view_find_column(GTK_TREE_VIEW(widget), 0)));
return row;
}
GtkTreeIter *keyword_add_from_config(GtkTreeStore *keyword_tree, GtkTreeIter *parent, const gchar **attribute_names, const gchar **attribute_values)
{
gchar *name = NULL;
gboolean is_kw = TRUE;
gchar *mark_str = NULL;
while (*attribute_names)
{
const gchar *option = *attribute_names++;
const gchar *value = *attribute_values++;
if (READ_CHAR_FULL("name", name)) continue;
if (READ_BOOL_FULL("kw", is_kw)) continue;
if (READ_CHAR_FULL("mark", mark_str)) continue;
log_printf("unknown attribute %s = %s\n", option, value);
}
if (name && name[0])
{
GtkTreeIter iter;
/* re-use existing keyword if any */
if (!keyword_exists(GTK_TREE_MODEL(keyword_tree), parent, NULL, name, FALSE, &iter))
{
gtk_tree_store_append(keyword_tree, &iter, parent);
}
keyword_set(keyword_tree, &iter, name, is_kw);
if (mark_str)
{
gint i = (gint)atoi(mark_str);
if (i == 0) i = 10;
meta_data_connect_mark_with_keyword(GTK_TREE_MODEL(keyword_tree),
&iter, i - 1);
}
g_free(name);
return gtk_tree_iter_copy(&iter);
}
g_free(name);
return NULL;
}
static void
photos_organize_collection_model_fetch_collection_state_executed (GHashTable *collection_state, gpointer user_data)
{
PhotosOrganizeCollectionModel *self = PHOTOS_ORGANIZE_COLLECTION_MODEL (user_data);
GHashTableIter collection_state_iter;
const gchar *idx;
gpointer value;
photos_organize_collection_model_remove_placeholder (self);
g_hash_table_iter_init (&collection_state_iter, collection_state);
while (g_hash_table_iter_next (&collection_state_iter, (gpointer) &idx, (gpointer) &value))
{
GtkTreeIter *iter;
PhotosBaseItem *collection;
gint state = GPOINTER_TO_INT (value);
if (state & PHOTOS_COLLECTION_STATE_HIDDEN)
continue;
collection = PHOTOS_BASE_ITEM (photos_base_manager_get_object_by_id (self->priv->manager, idx));
iter = photos_organize_collection_model_find_collection_iter (self, collection);
if (iter == NULL)
{
GtkTreeIter tmp;
gtk_list_store_append (GTK_LIST_STORE (self), &tmp);
iter = gtk_tree_iter_copy (&tmp);
}
gtk_list_store_set (GTK_LIST_STORE (self),
iter,
PHOTOS_ORGANIZE_MODEL_ID, idx,
PHOTOS_ORGANIZE_MODEL_NAME, photos_base_item_get_name (collection),
PHOTOS_ORGANIZE_MODEL_STATE, state,
-1);
gtk_tree_iter_free (iter);
}
g_object_unref (self);
}
static void
add_child (GtkTreeStore *store,
GimpHelpDomain *domain,
GimpHelpLocale *locale,
GtkTreeIter *parent,
GimpHelpItem *item,
gint depth)
{
GtkTreeIter iter;
GList *list;
gchar *uri;
gtk_tree_store_append (store, &iter, parent);
gtk_tree_store_set (store, &iter,
0, item,
1, item->title,
-1);
uri = g_strconcat (domain->help_uri, "/",
locale->locale_id, "/",
item->ref,
NULL);
g_hash_table_insert (uri_hash_table,
uri,
gtk_tree_iter_copy (&iter));
if (depth + 1 == GIMP_HELP_BROWSER_INDEX_MAX_DEPTH)
return;
item->children = g_list_sort (item->children, help_item_compare);
for (list = item->children; list; list = g_list_next (list))
{
GimpHelpItem *item = list->data;
add_child (store, domain, locale, &iter, item, depth + 1);
}
}
static GtkTreeIter *
history_dialog_find_host_iter (HistoryDialog *dialog,
HistoryItem *item)
{
GtkTreeIter iter;
if (gtk_tree_model_get_iter (dialog->priv->model, &iter,
gtk_tree_path_new_first()) == TRUE)
{
do {
GValue val = { 0, };
HistoryItem *i;
gtk_tree_model_get_value (dialog->priv->model,
&iter, 5, &val);
i = (HistoryItem *) g_value_get_pointer (&val);
if (i == item) return gtk_tree_iter_copy (&iter);
}
while (gtk_tree_model_iter_next (dialog->priv->model, &iter));
}
return NULL;
}
static GtkTreeIter *
get_row_by_type (GtkTreeModel *model, PangoAttrType type)
{
GtkTreeIter iter, *ret_iter = NULL;
gboolean valid;
PangoAttrType iter_type;
valid = gtk_tree_model_iter_children (model, &iter, NULL);
while (valid)
{
gtk_tree_model_get (model, &iter, COLUMN_TYPE, &iter_type, -1);
if (iter_type == type)
{
ret_iter = gtk_tree_iter_copy (&iter);
break;
}
valid = gtk_tree_model_iter_next (model, &iter);
}
return ret_iter;
}
char *gTreeRow::parent()
{
GtkTreeIter *iter = gtk_tree_iter_copy(dataiter);
char *key;
//GtkTreePath* path;
if (!gtk_tree_model_iter_parent(GTK_TREE_MODEL(tree->store), iter, dataiter))
key = NULL;
else
key = tree->iterToKey(iter);
gtk_tree_iter_free(iter);
return key;
/*path = gtk_tree_model_get_path(GTK_TREE_MODEL(tree->store), dataiter);
if (!path)
return NULL;
if (!gtk_tree_path_up(path))
return NULL;
return tree->pathToKey(path);*/
}
static gboolean
contact_list_store_find_contact_foreach (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
FindContact *fc)
{
EmpathyContact *contact;
gtk_tree_model_get (model, iter,
EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
-1);
if (contact == fc->contact) {
fc->found = TRUE;
fc->iters = g_list_append (fc->iters, gtk_tree_iter_copy (iter));
}
if (contact) {
g_object_unref (contact);
}
return FALSE;
}
static void device_changed (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *_iter,
gpointer data)
{
GtkTreeIter iter, *default_iter;
gboolean powered, cont;
default_iter = NULL;
num_adapters_present = num_adapters_powered = 0;
cont = gtk_tree_model_get_iter_first (model, &iter);
while (cont) {
gboolean is_default;
num_adapters_present++;
gtk_tree_model_get (model, &iter,
BLUETOOTH_COLUMN_DEFAULT, &is_default,
BLUETOOTH_COLUMN_POWERED, &powered,
-1);
if (powered)
num_adapters_powered++;
if (is_default && powered)
default_iter = gtk_tree_iter_copy (&iter);
cont = gtk_tree_model_iter_next (model, &iter);
}
update_discoverability (default_iter);
update_icon_visibility ();
update_menu_items ();
update_device_list (default_iter);
if (default_iter != NULL)
gtk_tree_iter_free (default_iter);
}
static GtkTreeIter *
logview_loglist_find_log (LogviewLoglist *list, LogviewLog *log)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeIter *retval = NULL;
LogviewLog *current;
model = GTK_TREE_MODEL (list->priv->model);
if (!gtk_tree_model_get_iter_first (model, &iter)) {
return NULL;
}
do {
gtk_tree_model_get (model, &iter, LOG_OBJECT, ¤t, -1);
if (current == log) {
retval = gtk_tree_iter_copy (&iter);
}
g_object_unref (current);
} while (gtk_tree_model_iter_next (model, &iter) != FALSE && retval == NULL);
return retval;
}
static GtkTreeIter *
history_dialog_find_site_iter (HistoryDialog *dialog,
GtkTreeIter *host_iter,
HistoryItem *item)
{
GtkTreeIter iter;
gtk_tree_model_iter_children (dialog->priv->model,
&iter,
host_iter);
do
{
GValue val = { 0, };
HistoryItem *i;
gtk_tree_model_get_value (dialog->priv->model,
&iter, 5, &val);
i = (HistoryItem *) g_value_get_pointer (&val);
if (i == item) return gtk_tree_iter_copy (&iter);
}
while (gtk_tree_model_iter_next (dialog->priv->model, &iter));
return NULL;
}
static void
on_down_clicked( GtkButton *button, BaseWindow *window )
{
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter_selected;
GtkTreeIter *iter_next;
GtkTreePath *path_next;
treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
selection = gtk_tree_view_get_selection( treeview );
if( gtk_tree_selection_get_selected( selection, &model, &iter_selected )){
iter_next = gtk_tree_iter_copy( &iter_selected );
if( gtk_tree_model_iter_next( model, iter_next )){
path_next = gtk_tree_model_get_path( model, iter_next );
gtk_list_store_move_after( GTK_LIST_STORE( model ), &iter_selected, iter_next );
gtk_tree_selection_unselect_all( selection );
gtk_tree_selection_select_path( selection, path_next );
gtk_tree_path_free( path_next );
}
gtk_tree_iter_free( iter_next );
}
}
static gboolean
classify_openfiles (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
GHashTable *new_maps = static_cast<GHashTable*>(data);
GtkTreeIter *old_iter;
glibtop_open_files_entry *openfiles;
gchar *old_name;
gtk_tree_model_get (model, iter, 1, &old_name, -1);
openfiles = static_cast<glibtop_open_files_entry*>(g_hash_table_lookup (new_maps, old_name));
if (openfiles) {
g_hash_table_remove (new_maps, old_name);
g_free (old_name);
return FALSE;
}
old_iter = gtk_tree_iter_copy (iter);
old_maps = g_list_append (old_maps, old_iter);
g_free (old_name);
return FALSE;
}
static gpointer
pboditer_copy_cb(gpointer boxed)
{
return gtk_tree_iter_copy ((GtkTreeIter*)boxed);
}
GtkTreeIter *
gtk_adds_tree_iter_new ()
{
GtkTreeIter example;
return gtk_tree_iter_copy(&example);
}
static void
muine_update(EinaMuine *self)
{
g_return_if_fail(EINA_IS_MUINE(self));
EinaMuinePrivate *priv = self->priv;
typedef struct {
guint count; // How many items have been folded
gchar *artist, *album; // Metadata from DB
LomoStream *stream; // Fake stream
} data_set_t;
EinaMuineMode mode = eina_muine_get_mode(self);
gchar *markup_fmt = NULL;
// Build master query
gchar *q = NULL;
switch (mode)
{
case EINA_MUINE_MODE_ALBUM:
// q = "select count(*) as count,artist,album from fast_meta group by(lower(album)) order by artist ASC";
q = "select count(*) as count,artist,album from fast_meta group by(album) order by lower(artist) ASC";
markup_fmt = "<big><b>%s</b></big>\n%s <span size=\"small\" weight=\"light\">(%d streams)</span>";
break;
case EINA_MUINE_MODE_ARTIST:
// q = "select count(*) as count,artist,NULL from fast_meta group by(lower(artist)) order by artist ASC";
q = "select count(*) as count,artist,NULL from fast_meta group by(artist) order by lower(artist) ASC";
markup_fmt = "<big><b>%s</b></big>\n<span size=\"small\" weight=\"light\">(%d streams)</span>";
break;
default:
g_warning(N_("Unknow mode: %d"), mode);
return;
}
// Now fill the data_store;
EinaAdbResult *r = eina_adb_query(eina_muine_get_adb(self), q, NULL);
GList *db_data = NULL;
data_set_t *ds = NULL;
while (eina_adb_result_step(r))
{
if (ds == NULL)
ds = g_new0(data_set_t, 1);
eina_adb_result_get(r,
0, G_TYPE_UINT, &(ds->count),
1, G_TYPE_STRING, &(ds->artist),
2, G_TYPE_STRING, &(ds->album),
-1);
db_data = g_list_prepend(db_data, ds);
ds = NULL;
}
g_object_unref(r);
// Try to get a sample for each item
// q = "select uri from streams where sid = (select sid from fast_meta where lower(%s)=lower('%q') limit 1 offset %d)";
q = "select uri from streams where sid = (select sid from fast_meta where %s='%q' limit 1 offset %d)";
EinaAdb *adb = eina_muine_get_adb(self);
gchar *sample_uri = NULL;
gchar *field = (mode == EINA_MUINE_MODE_ALBUM) ? "album" : "artist";
gchar *key = NULL;
GList *ds_p = db_data;
while (ds_p)
{
data_set_t *ds = (data_set_t *) ds_p->data;
char *q2 = sqlite3_mprintf(q,
field,
key = ((mode == EINA_MUINE_MODE_ALBUM) ? ds->album : ds->artist),
g_random_int_range(0, ds->count));
EinaAdbResult *sr = eina_adb_query_raw(adb, q2);
if (!sr || !eina_adb_result_step(sr))
{
g_warning(N_("Unable to fetch sample URI for %s '%s', query was %s"), field, key, q2);
sample_uri = g_strdup("file:///nonexistent");
}
else
eina_adb_result_get(sr, 0, G_TYPE_STRING, &sample_uri, -1);
gel_free_and_invalidate(sr, NULL, g_object_unref);
gel_free_and_invalidate(q2, NULL, sqlite3_free);
ds->stream = lomo_stream_new(sample_uri);
g_free(sample_uri);
ds_p = ds_p->next;
}
// All data (and all I/O) from DB has been fetched, insert into interface
gtk_list_store_clear(muine_get_model(self));
g_hash_table_remove_all(priv->stream_iter_map);
ds_p = db_data;
GtkListStore *model = muine_get_model(self);
gchar *artist = NULL, *album = NULL;
gchar *markup = NULL;
GValue v = { 0 };
g_value_init(&v, G_TYPE_STRING);
while (ds_p)
{
data_set_t *ds = (data_set_t *) ds_p->data;
if (ds->artist)
{
artist = g_markup_escape_text(ds->artist, -1);
g_value_set_static_string(&v, artist);
lomo_stream_set_tag(ds->stream, LOMO_TAG_ARTIST, &v);
}
if (ds->album)
{
album = g_markup_escape_text(ds->album, -1);
g_value_set_static_string(&v, album);
lomo_stream_set_tag(ds->stream, LOMO_TAG_ALBUM, &v);
}
switch (mode)
{
case EINA_MUINE_MODE_INVALID:
case EINA_MUINE_MODE_ALBUM:
markup = g_strdup_printf(markup_fmt, album, artist, ds->count);
break;
case EINA_MUINE_MODE_ARTIST:
markup = g_strdup_printf(markup_fmt, artist, ds->count);
break;
}
static GdkPixbuf *default_pb = NULL;
if (!default_pb) {
GError *e = NULL;
GInputStream *stream = gel_io_open(lomo_em_art_provider_get_default_cover(), &e);
if (stream == NULL)
g_error(_("Can't open `%s': %s"), lomo_em_art_provider_get_default_cover(), e->message);
default_pb = gdk_pixbuf_new_from_stream_at_scale(stream, DEFAULT_SIZE, DEFAULT_SIZE, TRUE, NULL, NULL);
g_input_stream_close(stream, NULL, NULL);
}
GtkTreeIter iter;
gtk_list_store_insert_with_values(model, &iter, 0,
COMBO_COLUMN_MARKUP, markup,
COMBO_COLUMN_ID, (mode == EINA_MUINE_MODE_ALBUM) ? ds->album : ds->artist,
COMBO_COLUMN_STREAM, ds->stream,
COMBO_COLUMN_ICON, default_pb,
-1);
g_hash_table_insert(priv->stream_iter_map, ds->stream, gtk_tree_iter_copy(&iter));
lomo_stream_set_all_tags_flag(ds->stream, TRUE);
g_signal_connect(ds->stream, "extended-metadata-updated", (GCallback) stream_em_updated_cb, self);
lomo_em_art_provider_init_stream(priv->art, ds->stream);
g_free(ds->artist);
g_free(ds->album);
g_free(ds);
g_free(markup);
gel_free_and_invalidate(artist, NULL, g_free);
gel_free_and_invalidate(album, NULL, g_free);
ds_p = ds_p->next;
}
g_value_reset(&v);
g_list_free(db_data);
}
static void
on_presentity_added (RosterViewGtk* self,
G_GNUC_UNUSED Ekiga::ClusterPtr cluster,
Ekiga::HeapPtr heap,
Ekiga::PresentityPtr presentity)
{
GtkTreeIter heap_iter;
std::set<std::string> groups = presentity->get_groups ();
GtkTreeSelection* selection = gtk_tree_view_get_selection (self->priv->tree_view);
GtkTreeModelFilter* filtered_model = GTK_TREE_MODEL_FILTER (gtk_tree_view_get_model (self->priv->tree_view));
GtkTreeIter group_iter;
GtkTreeIter iter;
GtkTreeIter filtered_iter;
bool active = false;
bool away = false;
guint timeout = 0;
std::string status;
gchar *old_presence = NULL;
gboolean should_emit = FALSE;
roster_view_gtk_find_iter_for_heap (self, heap, &heap_iter);
active = presentity->get_presence () != "offline";
away = presentity->get_presence () == "away";
if (groups.empty ())
groups.insert (_("Unsorted"));
for (std::set<std::string>::const_iterator group = groups.begin ();
group != groups.end ();
group++) {
roster_view_gtk_find_iter_for_group (self, heap, &heap_iter,
*group, &group_iter);
roster_view_gtk_find_iter_for_presentity (self, &group_iter, presentity, &iter);
if (gtk_tree_model_filter_convert_child_iter_to_iter (filtered_model, &filtered_iter, &iter))
if (gtk_tree_selection_iter_is_selected (selection, &filtered_iter))
should_emit = TRUE;
// Find out what our presence was
gtk_tree_model_get (GTK_TREE_MODEL (self->priv->store), &iter,
COLUMN_PRESENCE, &old_presence, -1);
if (old_presence && presentity->get_presence () != old_presence
&& presentity->get_presence () != "unknown" && presentity->get_presence () != "offline"
&& (!g_strcmp0 (old_presence, "unknown") || !g_strcmp0 (old_presence, "offline"))) {
StatusIconInfo *info = new StatusIconInfo ();
info->model = GTK_TREE_MODEL (self->priv->store);
info->iter = gtk_tree_iter_copy (&iter);
info->cpt = 0;
timeout = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, 1, roster_view_gtk_icon_blink_cb,
(gpointer) info, (GDestroyNotify) status_icon_info_delete);
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_TIMEOUT, timeout, -1);
}
else {
std::string icon = "avatar-default";
if (!old_presence) {
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_PRESENCE_ICON, icon.c_str (),
-1);
}
else if (old_presence != presentity->get_presence ()) {
if (presentity->get_presence () != "unknown")
icon = "user-" + presentity->get_presence ();
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_PRESENCE_ICON, icon.c_str (),
-1);
}
}
status = presentity->get_status ();
if (status.empty ()) {
if (presentity->get_presence () == "away")
status = _("Away");
else if (presentity->get_presence () == "available")
status = _("Available");
else if (presentity->get_presence () == "offline")
status = _("Offline");
else if (presentity->get_presence () == "busy")
status = _("Busy");
}
gtk_tree_store_set (self->priv->store, &iter,
COLUMN_TYPE, TYPE_PRESENTITY,
COLUMN_OFFLINE, active,
COLUMN_HEAP, heap.get (),
COLUMN_PRESENTITY, presentity.get (),
COLUMN_NAME, presentity->get_name ().c_str (),
COLUMN_STATUS, status.c_str (),
COLUMN_PRESENCE, presentity->get_presence ().c_str (),
COLUMN_ACTIVE, (!active || away) ? "gray" : "black", -1);
gtk_tree_model_get (GTK_TREE_MODEL (self->priv->store), &iter,
COLUMN_TIMEOUT, &timeout,
-1);
g_free (old_presence);
}
GtkTreeModel* model = gtk_tree_view_get_model (self->priv->tree_view);
gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));
roster_view_gtk_update_groups (self, &heap_iter);
if (should_emit)
g_signal_emit (self, signals[SELECTION_CHANGED_SIGNAL], 0);
}
static void
gxi_update_string_box (GncXmlImportData *data)
{
gchar *string;
const gchar *utf8;
GtkBox *vbox;
GtkComboBox *combo;
GtkListStore *store;
GList *word_iter, *conv_iter;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GQuark chosen_encoding;
GtkTreeIter *chosen_iter, *default_iter;
ambiguous_type *amb;
conv_type *conv;
if (data->string_box)
gtk_widget_destroy (data->string_box);
data->string_box = gtk_vbox_new (FALSE, 6);
vbox = GTK_BOX (data->string_box);
data->n_unassigned = 0;
/* loop through words */
for (word_iter = data->ambiguous_list; word_iter; word_iter = word_iter->next)
{
store = gtk_list_store_new (WORD_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
combo = GTK_COMBO_BOX (gtk_combo_box_new_with_model (
GTK_TREE_MODEL (store)));
g_object_unref (store);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", WORD_COL_STRING, NULL);
/* add default string, if possible */
amb = (ambiguous_type*) word_iter->data;
utf8 = get_decoded_string (amb, data->default_encoding);
default_iter = NULL;
if (utf8)
{
string = g_strdup_printf ("%s (default)", utf8);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, WORD_COL_STRING, string,
WORD_COL_ENCODING,
GUINT_TO_POINTER (data->default_encoding), -1);
g_free (string);
default_iter = gtk_tree_iter_copy (&iter);
}
/* user has selected this previously */
conv = (conv_type*) g_hash_table_lookup (data->choices, amb->byte_sequence);
chosen_encoding = (conv) ? conv->encoding : 0;
chosen_iter = NULL;
/* loop through conversions */
for (conv_iter = amb->conv_list; conv_iter; conv_iter = conv_iter->next)
{
conv = (conv_type*) conv_iter->data;
string = g_strdup_printf ("%s (%s)", conv->utf8_string,
g_quark_to_string (conv->encoding));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, WORD_COL_STRING, string,
WORD_COL_ENCODING,
GUINT_TO_POINTER (conv->encoding), -1);
g_free (string);
if (chosen_encoding && conv->encoding == chosen_encoding)
{
chosen_iter = gtk_tree_iter_copy (&iter);
}
} /* next conversion */
if (chosen_iter)
{
/* select previous selection again, are not we cute */
gtk_combo_box_set_active_iter (combo, chosen_iter);
gtk_tree_iter_free (chosen_iter);
}
else
{
if (default_iter)
{
/* select default entry */
gtk_combo_box_set_active_iter (combo, default_iter);
}
else
{
/* count it */
data->n_unassigned++;
}
}
/* wire up combo */
g_object_set_data (G_OBJECT (combo), "ambiguous", amb);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (gxi_string_combo_changed_cb), data);
gtk_box_pack_start (vbox, GTK_WIDGET (combo), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (combo));
} /* next word */
/* wire up whole string vbox */
gtk_container_add (GTK_CONTAINER (data->string_box_container), GTK_WIDGET (vbox));
gtk_widget_show (GTK_WIDGET (vbox));
/* update label now, n_unassigned is calculated */
if (!data->summary_label)
data->summary_label = data->impossible_label;
gxi_update_summary_label (data);
}
static gboolean
repair_dialog_on_idle_update(GtkDialog* dialog)
{
GtkTreeIter iter;
GtkTreeIter* parent_iter;
char* name;
char* display_name;
char* new_name;
GFile* file;
GFileType ftype;
UpdateContext* context;
gint n;
int i;
context = repair_dialog_get_update_context(dialog);
if (context == NULL) {
return FALSE;
}
for (i = 0; i < 500; i++) {
if (context->file_stack == NULL) {
repair_dialog_set_update_context(dialog, NULL);
repair_dialog_on_update_end(dialog, context->success_all);
update_context_free(context);
return FALSE;
}
file = context->file_stack->data;
if (context->enum_stack != NULL) {
GFileInfo* info;
GFileEnumerator* e;
parent_iter = context->iter_stack->data;
e = context->enum_stack->data;
info = g_file_enumerator_next_file(e, NULL, NULL);
if (info != NULL) {
const char* name_const;
name_const = g_file_info_get_name(info);
display_name = get_display_name(name_const);
new_name = get_new_name(name_const, context->encoding);
file_list_model_append(context->store, &iter, parent_iter,
NULL, name_const, display_name, new_name);
if (new_name == NULL)
context->success_all = FALSE;
ftype = g_file_info_get_file_type(info);
if (ftype == G_FILE_TYPE_DIRECTORY) {
GFile* child;
GFileEnumerator* child_e;
GtkTreeIter* tmp_iter;
tmp_iter = gtk_tree_iter_copy(&iter);
child = g_file_get_child(file, name_const);
child_e = g_file_enumerate_children(child,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
update_context_push(context, child, tmp_iter, child_e);
}
g_object_unref(info);
g_free(display_name);
g_free(new_name);
n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(context->store), parent_iter);
if (n == 1) {
GtkTreePath* path;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(context->store), parent_iter);
gtk_tree_view_expand_row(context->treeview, path, FALSE);
gtk_tree_path_free(path);
}
} else {
g_object_unref(file);
gtk_tree_iter_free(parent_iter);
g_object_unref(e);
update_context_pop(context);
}
} else {
context->file_stack = g_slist_delete_link(context->file_stack, context->file_stack);
name = g_file_get_basename(file);
display_name = get_display_name(name);
new_name = get_new_name(name, context->encoding);
file_list_model_append(context->store, &iter, NULL,
file, name, display_name, new_name);
if (new_name == NULL)
context->success_all = FALSE;
if (context->include_subdir) {
ftype = g_file_query_file_type(file, G_FILE_QUERY_INFO_NONE, NULL);
if (ftype == G_FILE_TYPE_DIRECTORY) {
GtkTreeIter* tmp_iter;
GFileEnumerator* e;
tmp_iter = gtk_tree_iter_copy(&iter);
e = g_file_enumerate_children(file,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
update_context_push(context, file, tmp_iter, e);
}
}
g_free(name);
g_free(display_name);
g_free(new_name);
}
}
return TRUE;
}
void
mtscan_model_add(mtscan_model_t *model,
network_t *net,
gboolean merge)
{
GtkTreeIter *iter_merge;
GtkTreeIter iter;
gint8 current_maxrssi;
gint64 current_firstseen;
gint64 current_lastseen;
signals_t *current_signals;
gint64 *address;
if(merge && (iter_merge = g_hash_table_lookup(model->map, &net->address)))
{
/* Merge a network, check current values first */
gtk_tree_model_get(GTK_TREE_MODEL(model->store), iter_merge,
COL_MAXRSSI, ¤t_maxrssi,
COL_FIRSTLOG, ¤t_firstseen,
COL_LASTLOG, ¤t_lastseen,
COL_SIGNALS, ¤t_signals,
-1);
/* Merge signal samples */
signals_merge(current_signals, net->signals);
/* Update the first seen date, if required */
if(net->firstseen < current_firstseen)
{
gtk_list_store_set(model->store, iter_merge,
COL_FIRSTLOG, net->firstseen,
-1);
}
/* Update the last seen date along with other values, if required */
if(net->lastseen > current_lastseen)
{
gtk_list_store_set(model->store, iter_merge,
COL_FREQUENCY, net->frequency,
COL_CHANNEL, (net->channel ? net->channel : ""),
COL_STREAMS, net->streams,
COL_MODE, (net->mode ? net->mode : ""),
COL_SSID, (net->ssid ? net->ssid : ""),
COL_RADIONAME, (net->radioname ? net->radioname : ""),
COL_PRIVACY, net->flags.privacy,
COL_ROUTEROS, net->flags.routeros,
COL_NSTREME, net->flags.nstreme,
COL_TDMA, net->flags.tdma,
COL_WDS, net->flags.wds,
COL_BRIDGE, net->flags.bridge,
COL_ROUTEROS_VER, (net->routeros_ver ? net->routeros_ver : ""),
COL_AIRMAX, net->ubnt_airmax,
COL_AIRMAX_AC_PTP, net->ubnt_ptp,
COL_AIRMAX_AC_PTMP, net->ubnt_ptmp,
COL_AIRMAX_AC_MIXED, net->ubnt_mixed,
COL_LASTLOG, net->lastseen,
COL_DISTANCE, NAN,
-1);
}
/* Update the max signal level together with its coordinates, if required */
if(net->rssi > current_maxrssi)
{
gtk_list_store_set(model->store, iter_merge,
COL_MAXRSSI, net->rssi,
COL_LATITUDE, net->latitude,
COL_LONGITUDE, net->longitude,
COL_AZIMUTH, net->azimuth,
COL_DISTANCE, NAN,
-1);
}
}
else
{
/* Add a new network */
gtk_list_store_insert_with_values(model->store, &iter, -1,
COL_STATE, MODEL_STATE_INACTIVE,
COL_ADDRESS, net->address,
COL_FREQUENCY, net->frequency,
COL_CHANNEL, (net->channel ? net->channel : ""),
COL_STREAMS, net->streams,
COL_MODE, (net->mode ? net->mode : ""),
COL_SSID, (net->ssid ? net->ssid : ""),
COL_RADIONAME, (net->radioname ? net->radioname : ""),
COL_MAXRSSI, net->rssi,
COL_RSSI, MODEL_NO_SIGNAL,
COL_NOISE, net->noise,
COL_PRIVACY, net->flags.privacy,
COL_ROUTEROS, net->flags.routeros,
COL_NSTREME, net->flags.nstreme,
COL_TDMA, net->flags.tdma,
COL_WDS, net->flags.wds,
COL_BRIDGE, net->flags.bridge,
COL_ROUTEROS_VER, (net->routeros_ver ? net->routeros_ver : ""),
COL_AIRMAX, net->ubnt_airmax,
COL_AIRMAX_AC_PTP, net->ubnt_ptp,
COL_AIRMAX_AC_PTMP, net->ubnt_ptmp,
COL_AIRMAX_AC_MIXED, net->ubnt_mixed,
COL_FIRSTLOG, net->firstseen,
COL_LASTLOG, net->lastseen,
COL_LATITUDE, net->latitude,
COL_LONGITUDE, net->longitude,
COL_AZIMUTH, net->azimuth,
COL_DISTANCE, NAN,
COL_SIGNALS, net->signals,
-1);
address = gint64dup(&net->address);
g_hash_table_insert(model->map, address, gtk_tree_iter_copy(&iter));
/* Signals are stored in GtkListStore just as pointer,
so set it to NULL before freeing the struct */
net->signals = NULL;
}
}
gint
model_update_network(mtscan_model_t *model,
network_t *net)
{
GtkTreeIter *iter_ptr;
GtkTreeIter iter;
gint64 *address;
gchar *current_ssid;
gchar *current_radioname;
gint8 current_maxrssi;
guint8 current_state;
gboolean new_network_found;
gfloat distance = NAN;
if(g_hash_table_lookup_extended(model->map, &net->address, (gpointer*)&address, (gpointer*)&iter_ptr))
{
/* Update a network, check current values first */
gtk_tree_model_get(GTK_TREE_MODEL(model->store), iter_ptr,
COL_STATE, ¤t_state,
COL_SSID, ¤t_ssid,
COL_RADIONAME, ¤t_radioname,
COL_MAXRSSI, ¤t_maxrssi,
COL_SIGNALS, &net->signals,
-1);
/* Update state to active (keep MODEL_STATE_NEW untouched) */
if(current_state == MODEL_STATE_INACTIVE)
current_state = MODEL_STATE_ACTIVE;
/* Preserve hidden SSIDs */
if((net->ssid && !net->ssid[0]) ||
!net->ssid)
{
g_free(net->ssid);
net->ssid = current_ssid;
}
else
{
g_free(current_ssid);
}
/* ... and Radio Names */
if((net->radioname && !net->radioname[0]) ||
!net->radioname)
{
g_free(net->radioname);
net->radioname = current_radioname;
}
else
{
g_free(current_radioname);
}
#if MIKROTIK_LOW_SIGNAL_BUGFIX
if(net->rssi >= -12 && net->rssi <= -10 && current_maxrssi <= -15)
net->rssi = current_maxrssi;
#endif
#if MIKROTIK_HIGH_SIGNAL_BUGFIX
if(net->rssi >= 10)
net->rssi = current_maxrssi;
#endif
if(conf_get_preferences_signals())
signals_append(net->signals, signals_node_new(net->firstseen, net->rssi, net->latitude, net->longitude, net->azimuth));
/* At new signal peak, update additionally COL_MAXRSSI, COL_LATITUDE, COL_LONGITUDE, COL_AZIMUTH and COL_DISTANCE */
if(net->rssi > current_maxrssi)
{
if(conf_get_interface_geoloc())
geoloc_match(net->address, net->ssid, net->azimuth, FALSE, &distance);
gtk_list_store_set(model->store, iter_ptr,
COL_STATE, current_state,
COL_FREQUENCY, net->frequency,
COL_CHANNEL, (net->channel ? net->channel : ""),
COL_STREAMS, net->streams,
COL_MODE, (net->mode ? net->mode : ""),
COL_SSID, (net->ssid ? net->ssid : ""),
COL_RADIONAME, (net->radioname ? net->radioname : ""),
COL_MAXRSSI, net->rssi,
COL_RSSI, net->rssi,
COL_NOISE, net->noise,
COL_PRIVACY, net->flags.privacy,
COL_ROUTEROS, net->flags.routeros,
COL_NSTREME, net->flags.nstreme,
COL_TDMA, net->flags.tdma,
COL_WDS, net->flags.wds,
COL_BRIDGE, net->flags.bridge,
COL_ROUTEROS_VER, (net->routeros_ver ? net->routeros_ver : ""),
COL_AIRMAX, net->ubnt_airmax,
COL_AIRMAX_AC_PTP, net->ubnt_ptp,
COL_AIRMAX_AC_PTMP, net->ubnt_ptmp,
COL_AIRMAX_AC_MIXED, net->ubnt_mixed,
COL_LASTLOG, net->firstseen,
COL_LATITUDE, net->latitude,
COL_LONGITUDE, net->longitude,
COL_AZIMUTH, net->azimuth,
COL_DISTANCE, distance,
-1);
}
else
{
gtk_list_store_set(model->store, iter_ptr,
COL_STATE, current_state,
COL_FREQUENCY, net->frequency,
COL_CHANNEL, (net->channel ? net->channel : ""),
COL_STREAMS, net->streams,
COL_MODE, (net->mode ? net->mode : ""),
COL_SSID, (net->ssid ? net->ssid : ""),
COL_RADIONAME, (net->radioname ? net->radioname : ""),
COL_RSSI, net->rssi,
COL_NOISE, net->noise,
COL_PRIVACY, net->flags.privacy,
COL_ROUTEROS, net->flags.routeros,
COL_NSTREME, net->flags.nstreme,
COL_TDMA, net->flags.tdma,
COL_WDS, net->flags.wds,
COL_BRIDGE, net->flags.bridge,
COL_ROUTEROS_VER, (net->routeros_ver ? net->routeros_ver : ""),
COL_AIRMAX, net->ubnt_airmax,
COL_AIRMAX_AC_PTP, net->ubnt_ptp,
COL_AIRMAX_AC_PTMP, net->ubnt_ptmp,
COL_AIRMAX_AC_MIXED, net->ubnt_mixed,
COL_LASTLOG, net->firstseen,
-1);
}
/* Add address to the active network list */
g_hash_table_insert(model->active, address, iter_ptr);
new_network_found = MODEL_NETWORK_UPDATE;
}
else
{
/* Add a new network */
if(conf_get_interface_geoloc())
geoloc_match(net->address, net->ssid, net->azimuth, conf_get_preferences_location_wigle(), &distance);
net->signals = signals_new();
if(conf_get_preferences_signals())
signals_append(net->signals, signals_node_new(net->firstseen, net->rssi, net->latitude, net->longitude, net->azimuth));
gtk_list_store_insert_with_values(model->store, &iter, -1,
COL_STATE, MODEL_STATE_NEW,
COL_ADDRESS, net->address,
COL_FREQUENCY, net->frequency,
COL_CHANNEL, (net->channel ? net->channel : ""),
COL_STREAMS, net->streams,
COL_MODE, (net->mode ? net->mode : ""),
COL_SSID, (net->ssid ? net->ssid : ""),
COL_RADIONAME, (net->radioname ? net->radioname : ""),
COL_MAXRSSI, net->rssi,
COL_RSSI, net->rssi,
COL_NOISE, net->noise,
COL_PRIVACY, net->flags.privacy,
COL_ROUTEROS, net->flags.routeros,
COL_NSTREME, net->flags.nstreme,
COL_TDMA, net->flags.tdma,
COL_WDS, net->flags.wds,
COL_BRIDGE, net->flags.bridge,
COL_ROUTEROS_VER, (net->routeros_ver ? net->routeros_ver : ""),
COL_AIRMAX, net->ubnt_airmax,
COL_AIRMAX_AC_PTP, net->ubnt_ptp,
COL_AIRMAX_AC_PTMP, net->ubnt_ptmp,
COL_AIRMAX_AC_MIXED, net->ubnt_mixed,
COL_FIRSTLOG, net->firstseen,
COL_LASTLOG, net->firstseen,
COL_LATITUDE, net->latitude,
COL_LONGITUDE, net->longitude,
COL_AZIMUTH, net->azimuth,
COL_DISTANCE, distance,
COL_SIGNALS, net->signals,
-1);
iter_ptr = gtk_tree_iter_copy(&iter);
address = gint64dup(&net->address);
g_hash_table_insert(model->map, address, iter_ptr);
g_hash_table_insert(model->active, address, iter_ptr);
if(conf_get_preferences_alarmlist_enabled() && conf_get_preferences_alarmlist(*address))
{
new_network_found = MODEL_NETWORK_NEW_ALARM;
if(conf_get_preferences_events_new_network())
mtscan_exec(conf_get_preferences_events_new_network_exec(),
2,
model_format_address(*address, FALSE),
"ALARM");
}
else if(conf_get_preferences_highlightlist_enabled() && conf_get_preferences_highlightlist(*address))
{
new_network_found = MODEL_NETWORK_NEW_HIGHLIGHT;
if(conf_get_preferences_events_new_network())
mtscan_exec(conf_get_preferences_events_new_network_exec(),
2,
model_format_address(*address, FALSE),
"HIGHLIGHT");
}
else
{
new_network_found = MODEL_NETWORK_NEW;
if(conf_get_preferences_events_new_network())
mtscan_exec(conf_get_preferences_events_new_network_exec(),
2,
model_format_address(*address, FALSE),
"NORMAL");
}
}
/* Signals are stored in GtkListStore just as pointer,
so set it to NULL before freeing the struct */
net->signals = NULL;
return new_network_found;
}
static void
edit_partition_populate (EditPartitionData *data)
{
const gchar *cur_type;
GList *l;
guint n;
GtkTreeIter *active_iter = NULL;
GtkListStore *model;
GList *infos;
const gchar *cur_table_subtype;
UDisksClient *client;
GtkCellRenderer *renderer;
client = gdu_window_get_client (data->window);
model = gtk_list_store_new (MODEL_N_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_STRING);
cur_type = udisks_partition_get_type_ (data->partition);
infos = udisks_client_get_partition_type_infos (client,
data->partition_table_type,
NULL);
/* assume that table subtypes are in order */
cur_table_subtype = NULL;
for (l = infos, n = 0; l != NULL; l = l->next, n++)
{
UDisksPartitionTypeInfo *info = l->data;
const gchar *type_for_display;
gchar *escaped_type_for_display;
gchar *s;
GtkTreeIter iter;
/* skip type like 'Extended Partition' (dos 0x05) since we can't
* just change the partition type to that
*/
if (info->flags & UDISKS_PARTITION_TYPE_INFO_FLAGS_CREATE_ONLY)
continue;
if (g_strcmp0 (info->table_subtype, cur_table_subtype) != 0)
{
s = g_strdup_printf ("<i>%s</i>",
udisks_client_get_partition_table_subtype_for_display (client,
info->table_type,
info->table_subtype));
gtk_list_store_insert_with_values (model,
NULL, /* out iter */
G_MAXINT, /* position */
MODEL_COLUMN_SELECTABLE, FALSE,
MODEL_COLUMN_NAME_MARKUP, s,
MODEL_COLUMN_TYPE, NULL,
-1);
g_free (s);
cur_table_subtype = info->table_subtype;
}
#if UDISKS_CHECK_VERSION(2, 1, 1)
type_for_display = udisks_client_get_partition_type_and_subtype_for_display (client,
data->partition_table_type,
info->table_subtype,
info->type);
#else
type_for_display = udisks_client_get_partition_type_for_display (client,
data->partition_table_type,
info->type);
#endif
escaped_type_for_display = g_markup_escape_text (type_for_display, -1);
s = g_strdup_printf ("%s <span size=\"small\">(%s)</span>",
escaped_type_for_display,
info->type);
g_free (escaped_type_for_display);
gtk_list_store_insert_with_values (model,
&iter,
G_MAXINT, /* position */
MODEL_COLUMN_SELECTABLE, TRUE,
MODEL_COLUMN_NAME_MARKUP, s,
MODEL_COLUMN_TYPE, info->type,
-1);
if (active_iter == NULL && g_strcmp0 (info->type, cur_type) == 0)
active_iter = gtk_tree_iter_copy (&iter);
g_free (s);
}
gtk_combo_box_set_model (GTK_COMBO_BOX (data->type_combobox), GTK_TREE_MODEL (model));
if (active_iter != NULL)
{
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (data->type_combobox), active_iter);
gtk_tree_iter_free (active_iter);
}
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->type_combobox), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->type_combobox), renderer,
"sensitive", MODEL_COLUMN_SELECTABLE,
"markup", MODEL_COLUMN_NAME_MARKUP,
NULL);
if (g_strcmp0 (data->partition_table_type, "gpt") == 0)
{
guint64 flags;
gtk_entry_set_text (GTK_ENTRY (data->name_entry), udisks_partition_get_name (data->partition));
flags = udisks_partition_get_flags (data->partition);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->system_checkbutton), (flags & (1UL<< 0)) != 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->hide_from_firmware_checkbutton), (flags & (1UL<< 1)) != 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->bootable_checkbutton), (flags & (1UL<< 2)) != 0);
}
else if (g_strcmp0 (data->partition_table_type, "dos") == 0)
{
guint64 flags;
flags = udisks_partition_get_flags (data->partition);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->bootable_checkbutton), (flags & (1UL<< 7)) != 0);
}
g_list_foreach (infos, (GFunc) udisks_partition_type_info_free, NULL);
g_list_free (infos);
g_object_unref (model);
}
int __new_req_window_refresh_model_add_ca (void *pArg, int argc, char **argv, char **columnNames)
{
GValue *last_dn_value = g_new0 (GValue, 1);
GValue *last_parent_dn_value = g_new0 (GValue, 1);
GtkTreeIter iter;
__NewReqWindowRefreshModelAddCaUserData *pdata = (__NewReqWindowRefreshModelAddCaUserData *) pArg;
GtkTreeStore * new_model = pdata->new_model;
const gchar * string_value;
// First we check if this is the first CA, or is a self-signed certificate
if (! pdata->last_ca_iter || (! strcmp (argv[NEW_REQ_CA_MODEL_COLUMN_DN],argv[NEW_REQ_CA_MODEL_COLUMN_PARENT_DN])) ) {
if (pdata->last_parent_iter)
gtk_tree_iter_free (pdata->last_parent_iter);
pdata->last_parent_iter = NULL;
} else {
// If not, then we must find the parent of the current nod
gtk_tree_model_get_value (GTK_TREE_MODEL(new_model), pdata->last_ca_iter, NEW_REQ_CA_MODEL_COLUMN_DN, last_dn_value);
gtk_tree_model_get_value (GTK_TREE_MODEL(new_model), pdata->last_ca_iter, NEW_REQ_CA_MODEL_COLUMN_PARENT_DN,
last_parent_dn_value);
string_value = g_value_get_string (last_dn_value);
g_assert (string_value);
if (! strcmp (argv[NEW_REQ_CA_MODEL_COLUMN_PARENT_DN], string_value)) {
// Last node is parent of the current node
if (pdata->last_parent_iter)
gtk_tree_iter_free (pdata->last_parent_iter);
pdata->last_parent_iter = gtk_tree_iter_copy (pdata->last_ca_iter);
} else {
// We go back in the hierarchical tree, starting in the current parent, until we find the parent of the
// current certificate.
while (pdata->last_parent_iter &&
strcmp (argv[NEW_REQ_CA_MODEL_COLUMN_PARENT_DN], g_value_get_string(last_parent_dn_value))) {
if (! gtk_tree_model_iter_parent(GTK_TREE_MODEL(new_model), &iter, pdata->last_parent_iter)) {
// Last ca iter is a top_level
if (pdata->last_parent_iter)
gtk_tree_iter_free (pdata->last_parent_iter);
pdata->last_parent_iter = NULL;
} else {
if (pdata->last_parent_iter)
gtk_tree_iter_free (pdata->last_parent_iter);
pdata->last_parent_iter = gtk_tree_iter_copy (&iter);
}
g_value_unset (last_parent_dn_value);
gtk_tree_model_get_value (GTK_TREE_MODEL(new_model), pdata->last_parent_iter,
NEW_REQ_CA_MODEL_COLUMN_DN,
last_parent_dn_value);
}
}
}
gtk_tree_store_append (new_model, &iter, pdata->last_parent_iter);
gtk_tree_store_set (new_model, &iter,
0, atoll(argv[NEW_REQ_CA_MODEL_COLUMN_ID]),
1, argv[NEW_REQ_CA_MODEL_COLUMN_SERIAL],
2, argv[NEW_REQ_CA_MODEL_COLUMN_SUBJECT],
3, argv[NEW_REQ_CA_MODEL_COLUMN_DN],
4, argv[NEW_REQ_CA_MODEL_COLUMN_PARENT_DN],
5, argv[NEW_REQ_CA_MODEL_COLUMN_PEM],
-1);
if (pdata->last_ca_iter)
gtk_tree_iter_free (pdata->last_ca_iter);
pdata->last_ca_iter = gtk_tree_iter_copy (&iter);
g_free (last_dn_value);
g_free (last_parent_dn_value);
return 0;
}
