RSProfileFactory *
rs_profile_factory_new(const gchar *search_path)
{
RSProfileFactory *factory = g_object_new(RS_TYPE_PROFILE_FACTORY, NULL);
g_return_val_if_fail(search_path != NULL, NULL);
g_return_val_if_fail(g_path_is_absolute(search_path), NULL);
rs_profile_factory_load_profiles(factory, search_path, TRUE, FALSE);
GtkTreeIter iter;
gtk_list_store_prepend(factory->profiles, &iter);
gtk_list_store_set(factory->profiles, &iter,
FACTORY_MODEL_COLUMN_TYPE, FACTORY_MODEL_TYPE_INFO,
FACTORY_MODEL_COLUMN_PROFILE, NULL,
FACTORY_MODEL_COLUMN_ID, "_embedded_image_profile_",
-1);
gtk_list_store_prepend(factory->profiles, &iter);
gtk_list_store_set(factory->profiles, &iter,
FACTORY_MODEL_COLUMN_TYPE, FACTORY_MODEL_TYPE_SEP,
-1);
gtk_list_store_prepend(factory->profiles, &iter);
gtk_list_store_set(factory->profiles, &iter,
FACTORY_MODEL_COLUMN_TYPE, FACTORY_MODEL_TYPE_ADD,
-1);
return factory;
}
/**
* snippet_vars_store_add_variable_to_snippet:
* @vars_store: A #SnippetVarsStore object.
* @variable_name: The name of the variable to be added to the snippet.
* @get_global: If it should add the global variable with the given name.
*
* Adds a variable to the snippet. If @get_global is TRUE, but no global variable
* with the given name is found, the added variable will be marked as undefined.
* If it's FALSE it will add it as local.
*/
void
snippet_vars_store_add_variable_to_snippet (SnippetVarsStore *vars_store,
const gchar *variable_name,
gboolean get_global)
{
SnippetVarsStorePrivate *priv = NULL;
GtkTreeIter iter;
/* Assertions */
g_return_if_fail (ANJUTA_IS_SNIPPET_VARS_STORE (vars_store));
g_return_if_fail (variable_name != NULL);
priv = ANJUTA_SNIPPET_VARS_STORE_GET_PRIVATE (vars_store);
g_return_if_fail (ANJUTA_IS_SNIPPETS_DB (priv->snippets_db));
g_return_if_fail (ANJUTA_IS_SNIPPET (priv->snippet));
/* We check to see if there is a variable with the same name in the snippet*/
if (snippet_has_variable (priv->snippet, variable_name))
return;
/* If we should get the global variable, we just change it's status to TRUE */
if (get_global)
{
if (!get_iter_at_variable (vars_store, &iter, variable_name, SNIPPET_VAR_TYPE_GLOBAL, FALSE))
{
/* If we didn't found a global variable with the given name, add one as
undefined. */
gtk_list_store_prepend (GTK_LIST_STORE (vars_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (vars_store), &iter,
VARS_STORE_COL_NAME, variable_name,
VARS_STORE_COL_TYPE, SNIPPET_VAR_TYPE_GLOBAL,
VARS_STORE_COL_DEFAULT_VALUE, "",
VARS_STORE_COL_INSTANT_VALUE, "",
VARS_STORE_COL_IN_SNIPPET, TRUE,
VARS_STORE_COL_UNDEFINED, TRUE,
-1);
}
else
{
gtk_list_store_set (GTK_LIST_STORE (vars_store), &iter,
VARS_STORE_COL_IN_SNIPPET, TRUE,
-1);
}
}
/* If not, we just add a local variable */
else
{
gtk_list_store_prepend (GTK_LIST_STORE (vars_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (vars_store), &iter,
VARS_STORE_COL_NAME, variable_name,
VARS_STORE_COL_TYPE, SNIPPET_VAR_TYPE_LOCAL,
VARS_STORE_COL_DEFAULT_VALUE, "",
VARS_STORE_COL_INSTANT_VALUE, "",
VARS_STORE_COL_IN_SNIPPET, TRUE,
VARS_STORE_COL_UNDEFINED, FALSE,
-1);
}
snippet_add_variable (priv->snippet, variable_name, "", get_global);
}
/**
* ajoute le nouveau path. S'il existe déjà dans la liste on le supprime
* de telle façon qu'il n'existe qu'une fois et apparaisse en premier dans
* la liste
*
* \param néant
*
* \return TRUE
* */
gboolean gsb_select_icon_add_path ( void )
{
GtkTreeIter iter;
gboolean result = FALSE;
result = gtk_tree_model_get_iter_first ( GTK_TREE_MODEL ( store ),
&iter );
while (result)
{
gchar * rep;
gtk_tree_model_get ( GTK_TREE_MODEL ( store ), &iter, 0, &rep, -1 );
if ( strcmp ( path_icon, rep ) == 0)
{
gtk_list_store_remove ( store, &iter );
break;
}
result = gtk_tree_model_iter_next ( GTK_TREE_MODEL ( store ), &iter);
}
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter, 0, path_icon, -1);
devel_debug ( g_strconcat ( "path ajouté ", path_icon, NULL ) );
return TRUE;
}
/**
* crée le GtkComboBox pour l'entrée d'un nom de fichier ou de répertoire
* mémorise la liste des répertoires utilisés
*
* \param nom de l'icône
*
* \return le GtkComboBox
* */
GtkWidget * gsb_select_icon_create_entry_text ( gchar * name_icon )
{
GtkWidget *combo;
GtkTreeIter iter;
if ( store )
{
devel_debug ( "combo existe" );
}
else
{
devel_debug ( "combo n'existe pas" );
store = gtk_list_store_new ( 2, G_TYPE_STRING, G_TYPE_INT );
gtk_list_store_append (store, &iter);
if ( g_strcmp0 ( gsb_dirs_get_pixmaps_dir ( ), path_icon ) != 0 )
{
gtk_list_store_set (store, &iter, 0, gsb_dirs_get_pixmaps_dir ( ), -1);
gtk_list_store_prepend (store, &iter);
}
gtk_list_store_set (store, &iter, 0, path_icon, -1);
}
combo = gtk_combo_box_entry_new_with_model ( GTK_TREE_MODEL ( store ), 0 );
gtk_entry_set_text ( GTK_ENTRY (GTK_BIN (combo)->child), name_icon );
return combo;
}
/* Testing scrolling to a newly created row */
static void
create_new_row (GtkListStore *store,
int n,
GtkTreeIter *iter)
{
switch (n) {
case 0:
/* Prepend a row */
gtk_list_store_prepend (store, iter);
break;
case 4:
/* Add a row in the middle of the visible area */
gtk_list_store_insert (store, iter, 4);
break;
case 8:
/* Add a row which is not completely visible */
gtk_list_store_insert (store, iter, 8);
break;
case 500:
/* Add a row in the middle */
gtk_list_store_insert (store, iter, 500);
break;
case 999:
/* Append a row */
gtk_list_store_append (store, iter);
break;
}
gtk_list_store_set (store, iter, 0, "New...", -1);
}
void
fe_url_add (const char *urltext)
{
GtkListStore *store;
GtkTreeIter iter;
gboolean valid;
if (urlgrabberwindow)
{
store = GTK_LIST_STORE (g_object_get_data (G_OBJECT (urlgrabberwindow),
"model"));
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
URL_COLUMN, urltext,
-1);
/* remove any overflow */
if (prefs.pchat_url_grabber_limit > 0)
{
valid = gtk_tree_model_iter_nth_child (
GTK_TREE_MODEL (store), &iter, NULL, prefs.pchat_url_grabber_limit);
while (valid)
valid = gtk_list_store_remove (store, &iter);
}
}
}
void display_command_history(int id, char *cmd)
{
GtkTreeIter iter;
if (id < 0) {
eprintf("DEL %d\n", -id);
if (display_command_find(-id, &iter))
gtk_list_store_remove(display_command_list, &iter);
}
else if (id == 0) {
eprintf("CLEAR\n");
gtk_list_store_clear(display_command_list);
}
else {
/* Command history reordering */
if (*cmd == '\0') {
eprintf("MOVE UP %d\n", id);
if (display_command_find(id, &iter)) {
gtk_list_store_move_after(display_command_list, &iter, NULL);
}
}
/* New command to prepend */
else {
eprintf("ADD %d '%s'\n", id, cmd);
gtk_list_store_prepend(display_command_list, &iter);
gtk_list_store_set(display_command_list, &iter,
COMMAND_TREE_ID, id,
COMMAND_TREE_TEXT, cmd,
-1);
}
}
}
int
clip_GTK_LISTSTOREPREPEND(ClipMachine * cm)
{
C_object *cslist = _fetch_co_arg(cm);
GtkTreeIter iter;
GtkTreePath *path;
gchar *path_string;
CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object));
gtk_list_store_prepend(GTK_LIST_STORE(cslist->object), &iter);
__list_store_set(cm, &iter, 2);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_LIST_STORE(cslist->object)),
&iter);
path_string = gtk_tree_path_to_string(path);
_clip_retc(cm, path_string);
g_free(path_string);
return 0;
err:
return 1;
}
static void
add_n_items (GtkIconView *icon_list, gint n)
{
static gint count = NUMBER_OF_ITEMS;
GtkTreeIter iter;
GtkListStore *store;
GdkPixbuf *pixbuf;
gchar *str, *str2;
gint i;
store = GTK_LIST_STORE (gtk_icon_view_get_model (icon_list));
pixbuf = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
for (i = 0; i < n; i++)
{
str = g_strdup_printf ("Icon %d", count);
str2 = g_strdup_printf ("Icon <b>%d</b>", count);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
0, pixbuf,
1, str,
2, i,
3, str2,
-1);
g_free (str);
g_free (str2);
count++;
}
}
static void
fill_model (GtkTreeModel *model)
{
GdkPixbuf *pixbuf;
int i;
char *str, *str2;
GtkTreeIter iter;
GtkListStore *store = GTK_LIST_STORE (model);
gint32 size;
pixbuf = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
i = 0;
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
0, pixbuf,
1, "Really really\nreally really loooooooooong item name",
2, 0,
3, "This is a <b>Test</b> of <i>markup</i>",
4, TRUE,
-1);
while (i < NUMBER_OF_ITEMS - 1)
{
GdkPixbuf *pb;
size = g_random_int_range (20, 70);
pb = gdk_pixbuf_scale_simple (pixbuf, size, size, GDK_INTERP_NEAREST);
str = g_strdup_printf ("Icon %d", i);
str2 = g_strdup_printf ("Icon <b>%d</b>", i);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
0, pb,
1, str,
2, i,
3, str2,
4, TRUE,
-1);
g_free (str);
g_free (str2);
i++;
}
// gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 2, GTK_SORT_ASCENDING);
}
/* react to a new call being inserted in history */
static void
on_contact_added (Ekiga::ContactPtr contact,
GtkListStore *store)
{
time_t t;
struct tm *timeinfo = NULL;
char buffer [80];
std::stringstream info;
std::string id;
boost::shared_ptr<History::Contact> hcontact = boost::dynamic_pointer_cast<History::Contact> (contact);
GtkTreeIter iter;
if (hcontact) {
switch (hcontact->get_type ()) {
case History::RECEIVED:
id = "go-previous-symbolic";
break;
case History::PLACED:
id = "go-next-symbolic";
break;
case History::MISSED:
id = "call-missed-symbolic";
break;
default:
break;
}
}
gtk_list_store_prepend (store, &iter);
t = hcontact->get_call_start ();
timeinfo = localtime (&t);
if (timeinfo != NULL) {
strftime (buffer, 80, "%x %X", timeinfo);
info << buffer;
if (!hcontact->get_call_duration ().empty ())
info << " (" << hcontact->get_call_duration () << ")";
else
gtk_list_store_set (store, &iter,
COLUMN_ERROR_PIXBUF, "error",
-1);
}
else
info << hcontact->get_call_duration ();
gtk_list_store_set (store, &iter,
COLUMN_CONTACT, contact.get (),
COLUMN_PIXBUF, id.c_str (),
COLUMN_NAME, contact->get_name ().c_str (),
COLUMN_INFO, info.str ().c_str (),
-1);
}
static gboolean serverstats_idle_handler(ss_str * s)
{
GtkTreeIter iter;
MpdDBStats *stats = NULL;
if (s->data == NULL || !mpd_check_connected(connection) || cancel_query)
{
if (gtk_tree_model_get_iter_first(s->model, &iter))
{
do
{
guint d;
gulong i;
gchar *value = NULL;
gtk_tree_model_get(s->model, &iter, 0, &i, -1);
d = (guint) 100 *(i / (double)s->max_i);
value = format_time_real(i, "");
gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 2, d, 3, value, -1);
g_free(value);
} while (gtk_tree_model_iter_next(s->model, &iter));
}
if (s->data)
mpd_data_free(s->data);
gtk_tree_view_set_model(GTK_TREE_VIEW(serverstats_tree), s->model);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1);
gtk_widget_set_sensitive(GTK_WIDGET(s->box), TRUE);
gtk_widget_hide(gtk_widget_get_parent(s->pb));
if (cancel_query)
gtk_list_store_clear(GTK_LIST_STORE(s->model));
g_free(s);
cancel_query = FALSE;
return FALSE;
}
mpd_database_search_stats_start(connection);
mpd_database_search_add_constraint(connection, s->tag, s->data->tag);
stats = mpd_database_search_stats_commit(connection);
if (stats)
{
gtk_list_store_prepend(GTK_LIST_STORE(s->model), &iter);
gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 0, (unsigned long)(stats->playTime), 1, s->data->tag, -1);
s->max_i = MAX(s->max_i, stats->playTime);
mpd_database_search_free_stats(stats);
}
/* limit the amount of updating to 0.2 % */
if ((int)((1000 * s->hits) / s->total) % 5 == 0)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(s->pb), s->hits / (double)s->total);
}
s->hits++;
s->data = mpd_data_get_next(s->data);
return TRUE;
}
static void artistlist_prepend(artist *artist, char *name)
{
GtkTreeIter iter;
gtk_list_store_prepend(artistlist, &iter);
gtk_list_store_set(artistlist, &iter,
ARTIST_PTR, artist,
ARTIST_COLUMN, name,
-1);
}
static void action_store_fill(GtkListStore *store)
{
GtkTreeIter iter;
GSList *tmp;
for (tmp = keyinfos; tmp != NULL; tmp = tmp->next) {
KeyAction *action = tmp->data;
gtk_list_store_prepend(store, &iter);
gtk_list_store_set(store, &iter, COL_PTR, action, -1);
}
}
static void
filefiltergui_addpattern_clicked_lcb(GtkWidget * widget, Tfilefiltergui * ffg)
{
Tfilterpattern *pat;
GtkTreeIter it;
pat = g_new(Tfilterpattern, 1);
pat->pattern = g_strdup(gtk_entry_get_text(GTK_ENTRY(ffg->patentry)));
pat->patspec = g_pattern_spec_new(pat->pattern);
ffg->curfilter->patterns = g_list_append(ffg->curfilter->patterns, pat);
gtk_list_store_prepend(ffg->lstore, &it);
gtk_list_store_set(ffg->lstore, &it, 0, pat->pattern, 1, NULL, 2, 1, -1);
}
static VALUE
rg_prepend(VALUE self)
{
VALUE ret;
GtkTreeIter iter;
GtkListStore* model = _SELF(self);
gtk_list_store_prepend(model, &iter);
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
return ret;
}
static void
dcc_chat_append (struct DCC *dcc, GtkListStore *store, gboolean prepend)
{
GtkTreeIter iter;
if (prepend)
gtk_list_store_prepend (store, &iter);
else
gtk_list_store_append (store, &iter);
dcc_prepare_row_chat (dcc, store, &iter, FALSE);
}
void
seahorse_combo_keys_attach (GtkComboBox *combo,
GcrCollection *collection,
const gchar *none_option)
{
GtkTreeModel *model;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GList *l, *objects;
g_object_set_data_full (G_OBJECT (combo), "combo-keys-closure",
combo_closure_new (), combo_closure_free);
/* Setup the None Option */
model = gtk_combo_box_get_model (combo);
if (!model) {
model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER));
gtk_combo_box_set_model (combo, model);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer,
"markup", COMBO_MARKUP);
}
/* Setup the object list */
objects = gcr_collection_get_objects (collection);
for (l = objects; l != NULL; l = g_list_next (l))
on_collection_added (collection, l->data, combo);
g_list_free (objects);
g_signal_connect_after (collection, "added", G_CALLBACK (on_collection_added), combo);
g_signal_connect_after (collection, "removed", G_CALLBACK (on_collection_removed), combo);
if (none_option) {
gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
COMBO_LABEL, NULL,
COMBO_MARKUP, none_option,
COMBO_POINTER, NULL,
-1);
}
gtk_tree_model_get_iter_first (model, &iter);
gtk_combo_box_set_active_iter (combo, &iter);
g_signal_connect_data (combo, "destroy", G_CALLBACK (on_combo_destroy),
g_object_ref (collection), (GClosureNotify)g_object_unref, 0);
}
static void
list_store_prepend (GtkTreeModel *model,
gint items,
gint i)
{
GtkListStore *store = GTK_LIST_STORE (model);
GtkTreeIter iter;
gchar *text;
text = g_strdup_printf ("row %d", i);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter, 0, i, 1, text, -1);
g_free (text);
}
/**
* gwy_app_recent_file_list_update:
* @data: A data container corresponding to the file.
* @filename_utf8: A recent file to insert or move to the first position in
* document history, in UTF-8.
* @filename_sys: A recent file to insert or move to the first position in
* document history, in GLib encoding.
* @hint: Preferred channel id to use for thumbnail, pass 0 if no channel
* is specificaly preferred.
*
* Moves @filename_utf8 to the first position in document history, possibly
* adding it if not present yet.
*
* At least one of @filename_utf8, @filename_sys should be set.
**/
void
gwy_app_recent_file_list_update(GwyContainer *data,
const gchar *filename_utf8,
const gchar *filename_sys,
gint hint)
{
gboolean free_utf8 = FALSE, free_sys = FALSE;;
g_return_if_fail(!data || GWY_IS_CONTAINER(data));
if (!gcontrols.store)
return;
if (!filename_utf8 && filename_sys) {
filename_utf8 = g_filename_to_utf8(filename_sys, -1,
NULL, NULL, NULL);
free_utf8 = TRUE;
}
if (!filename_sys && filename_utf8) {
filename_sys = g_filename_from_utf8(filename_utf8, -1,
NULL, NULL, NULL);
free_sys = TRUE;
}
if (filename_utf8) {
GtkTreeIter iter;
GwyRecentFile *rf;
if (gwy_app_recent_file_find(filename_utf8, &iter, &rf))
gtk_list_store_move_after(gcontrols.store, &iter, NULL);
else {
rf = gwy_app_recent_file_new(gwy_canonicalize_path(filename_utf8),
gwy_canonicalize_path(filename_sys));
gtk_list_store_prepend(gcontrols.store, &iter);
gtk_list_store_set(gcontrols.store, &iter, FILELIST_RAW, rf, -1);
}
if (data)
gwy_recent_file_update_thumbnail(rf, data, hint, NULL);
}
if (free_utf8)
g_free((gpointer)filename_utf8);
if (free_sys)
g_free((gpointer)filename_sys);
gwy_app_recent_file_list_update_menu(&gcontrols);
}
static void
dcc_append (struct DCC *dcc, GtkListStore *store, gboolean prepend)
{
GtkTreeIter iter;
if (prepend)
gtk_list_store_prepend (store, &iter);
else
gtk_list_store_append (store, &iter);
if (dcc->type == TYPE_RECV)
dcc_prepare_row_recv (dcc, store, &iter, FALSE);
else
dcc_prepare_row_send (dcc, store, &iter, FALSE);
}
static void
pragha_filter_dialog_fill_model (GtkListStore *filter_model, PraghaPlaylist *cplaylist)
{
GtkTreeIter filter_iter;
PraghaMusicobject *mobj = NULL;
gchar *ch_title = NULL, *ch_artist = NULL, *ch_album = NULL;
const gchar *file, *title, *artist, *album;
gchar *track_data_markup = NULL;
gint track_i = 0;
GList *list = NULL, *i;
list = pragha_playlist_get_mobj_list(cplaylist);
track_i = pragha_playlist_get_no_tracks(cplaylist);
if(list != NULL) {
for (i=list; i != NULL; i = i->next) {
mobj = i->data;
file = pragha_musicobject_get_file(mobj);
title = pragha_musicobject_get_title(mobj);
artist = pragha_musicobject_get_artist(mobj);
album = pragha_musicobject_get_album(mobj);
ch_title = string_is_not_empty(title) ? g_strdup(title) : get_display_filename (file, FALSE);
ch_artist = string_is_not_empty(artist) ? g_strdup(artist) : g_strdup(_("Unknown Artist"));
ch_album = string_is_not_empty(album) ? g_strdup(album) : g_strdup(_("Unknown Album"));
track_data_markup = g_markup_printf_escaped ("%s - %s - %s", ch_title, ch_artist, ch_album);
if (track_data_markup != NULL) {
gtk_list_store_prepend (filter_model, &filter_iter);
gtk_list_store_set (filter_model, &filter_iter,
0, track_i,
1, track_data_markup,
-1);
}
track_i--;
g_free (ch_title);
g_free (ch_artist);
g_free (ch_album);
g_free (track_data_markup);
}
g_list_free(list);
}
}
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);
}
/* MODIFY IT: columns */
void liststore_insert (GtkTreeView *treeview, const char *protocol, const char *sip, const int sport, const char *dip, const int dport, const int size, const char *pdata) {
GtkListStore *store;
GtkTreeIter iter;
store = GTK_LIST_STORE (gtk_tree_view_get_model (treeview));
/* MODIFY IT: columns */
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,
COL_PROTOCOL, protocol,
COL_SIP, sip,
COL_SPORT, sport,
COL_DIP, dip,
COL_DPORT, dport,
COL_SIZE, size,
COL_PDATA, g_convert (pdata, -1, "UTF-8", "GBK", NULL, NULL, NULL),
-1);
}
static void
editable_set_add_value_activated_cb (GtkWidget *entry,
gpointer data)
{
GtkTreeModel *model = NULL;
const char *value = NULL;
gchar *tree_value = NULL;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (data));
value = gtk_entry_get_text (GTK_ENTRY (entry));
if (!strcmp (value, ""))
return;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter)) {
do {
gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
EditableSetSubmitter::COLUMN_VALUE, &tree_value,
-1);
if (tree_value && !strcmp (tree_value, value)) {
g_free (tree_value);
return;
}
g_free (tree_value);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));
}
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter);
gtk_list_store_prepend (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
EditableSetSubmitter::COLUMN_ACTIVE, TRUE,
EditableSetSubmitter::COLUMN_VALUE, gtk_entry_get_text (GTK_ENTRY (entry)),
-1);
gtk_entry_set_text (GTK_ENTRY (entry), "");
}
/****************************************************************
Insert item to queue
*****************************************************************/
static void queue_insert(struct worklist_data *ptr, bool prepend)
{
GtkTreeModel *model;
GtkTreeIter it;
GtkTreePath *path;
GtkTreeModel *src_model, *dst_model;
GtkTreeIter src_it, dst_it;
gint i, ncols;
if (!gtk_widget_is_sensitive(ptr->dst_view)) {
return;
}
if (!gtk_tree_selection_get_selected(ptr->src_selection, &model, &it)) {
return;
}
path = gtk_tree_model_get_path(model, &it);
src_model = GTK_TREE_MODEL(ptr->src);
dst_model = GTK_TREE_MODEL(ptr->dst);
gtk_tree_model_get_iter(src_model, &src_it, path);
if (prepend) {
gtk_list_store_prepend(GTK_LIST_STORE(dst_model), &dst_it);
} else {
gtk_list_store_append(GTK_LIST_STORE(dst_model), &dst_it);
}
ncols = gtk_tree_model_get_n_columns(src_model);
for (i = 0; i < ncols; i++) {
GValue value = { 0, };
gtk_tree_model_get_value(src_model, &src_it, i, &value);
gtk_list_store_set_value(GTK_LIST_STORE(dst_model), &dst_it, i, &value);
}
commit_worklist(ptr);
gtk_tree_path_free(path);
}
static void on_command_send_button_clicked(G_GNUC_UNUSED GtkButton *button,
G_GNUC_UNUSED gpointer gdata)
{
gchar *text = utils_text_buffer_get_text(command_text, -1);
const gchar *start;
char *locale;
thread_synchronize();
utils_str_replace_all(&text, "\n", " ");
start = utils_skip_spaces(text);
locale = gtk_toggle_button_get_active(command_locale) ?
utils_get_locale_from_utf8(start) : strdup(start);
debug_send_command(N, locale);
g_free(locale);
gtk_widget_hide(command_dialog);
if (*start)
{
GtkTreePath *path;
GtkTreeIter iter;
gchar *display = strdup(start);
/* from ui_combo_box_add_to_history() */
if (model_find(command_model, &iter, COMMAND_TEXT, start))
gtk_list_store_remove(command_store, &iter);
if (strlen(display) >= 273)
strcpy(display + 270, _("\342\200\246")); /* For translators: ellipsis */
gtk_list_store_prepend(command_store, &iter);
gtk_list_store_set(command_store, &iter, COMMAND_DISPLAY, display, COMMAND_TEXT,
start, COMMAND_LOCALE, gtk_toggle_button_get_active(command_locale), -1);
g_free(display);
path = gtk_tree_path_new_from_indices(15, -1);
if (gtk_tree_model_get_iter(command_model, &iter, path))
gtk_list_store_remove(command_store, &iter);
gtk_tree_path_free(path);
}
g_free(text);
}
static void
servlist_addnet_cb (GtkWidget *item, GtkTreeView *treeview)
{
GtkTreeIter iter;
GtkListStore *store;
ircnet *net;
store = (GtkListStore *)gtk_tree_view_get_model (treeview);
net = servlist_net_add (_("New Network"), "", TRUE);
servlist_server_add (net, "newserver/6667");
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter, 0, net->name, 1, 1, -1);
/* select this network */
servlist_select_and_show (GTK_TREE_VIEW (networks_tree), &iter, store);
servlist_start_editing (GTK_TREE_VIEW (networks_tree));
servlist_network_row_cb (gtk_tree_view_get_selection (GTK_TREE_VIEW (networks_tree)), NULL);
}
static void
gimp_color_profile_store_create_separator (GimpColorProfileStore *store,
GtkTreeIter *iter,
gboolean top)
{
if (top)
{
gtk_list_store_prepend (GTK_LIST_STORE (store), iter);
}
else
{
GtkTreeModel *model = GTK_TREE_MODEL (store);
GtkTreeIter sibling;
gboolean iter_valid;
for (iter_valid = gtk_tree_model_get_iter_first (model, &sibling);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &sibling))
{
gint type;
gtk_tree_model_get (model, &sibling,
GIMP_COLOR_PROFILE_STORE_ITEM_TYPE, &type,
-1);
if (type == GIMP_COLOR_PROFILE_STORE_ITEM_DIALOG)
break;
}
if (iter_valid)
gtk_list_store_insert_before (GTK_LIST_STORE (store), iter, &sibling);
}
gtk_list_store_set (GTK_LIST_STORE (store), iter,
GIMP_COLOR_PROFILE_STORE_ITEM_TYPE,
top ?
GIMP_COLOR_PROFILE_STORE_ITEM_SEPARATOR_TOP :
GIMP_COLOR_PROFILE_STORE_ITEM_SEPARATOR_BOTTOM,
GIMP_COLOR_PROFILE_STORE_INDEX, -1,
-1);
}
static gboolean
add_dcp_profile(RSProfileFactory *factory, const gchar *path)
{
gboolean readable = FALSE;
RSDcpFile *profile = rs_dcp_file_new_from_file(path);
const gchar *model = rs_dcp_file_get_model(profile);
if (model)
{
GtkTreeIter iter;
gtk_list_store_prepend(factory->profiles, &iter);
gtk_list_store_set(factory->profiles, &iter,
FACTORY_MODEL_COLUMN_TYPE, FACTORY_MODEL_TYPE_DCP,
FACTORY_MODEL_COLUMN_PROFILE, profile,
FACTORY_MODEL_COLUMN_MODEL, model,
FACTORY_MODEL_COLUMN_ID, rs_dcp_get_id(profile),
-1);
readable = TRUE;
rs_tiff_free_data(RS_TIFF(profile));
}
return readable;
}
