static void update_playlist(GmpvMpv *mpv)
{
/* The length of "playlist//filename" including null-terminator (19)
* plus the number of digits in the maximum value of 64 bit int (19).
*/
const gsize filename_prop_str_size = 38;
GtkListStore *store = gmpv_playlist_get_store(mpv->playlist);
gchar *filename_prop_str = g_malloc(filename_prop_str_size);
gboolean iter_end = FALSE;
GtkTreeIter iter;
mpv_node mpv_playlist;
gint playlist_count;
gint i;
mpv_check_error(mpv_get_property( mpv->mpv_ctx,
"playlist",
MPV_FORMAT_NODE,
&mpv_playlist ));
playlist_count = mpv_playlist.u.list->num;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
for(i = 0; i < playlist_count; i++)
{
mpv_node_list *prop_list = mpv_playlist.u.list->values[i].u.list;
gchar *uri = NULL;
gchar *title = NULL;
gchar *name = NULL;
for(gint j = 0; j < prop_list->num; j++)
{
const gchar *key = prop_list->keys[j];
const mpv_node value = prop_list->values[j];
if(g_strcmp0(key, "filename") == 0)
{
g_assert(value.format == MPV_FORMAT_STRING);
uri = value.u.string;
}
else if(g_strcmp0(key, "title") == 0)
{
g_assert(value.format == MPV_FORMAT_STRING);
title = value.u.string;
}
}
name = title?g_strdup(title):get_name_from_path(uri);
/* Overwrite current entry if it doesn't match the new value */
if(!iter_end)
{
gchar *old_name = NULL;
gchar *old_uri = NULL;
gboolean name_update;
gboolean uri_update;
gtk_tree_model_get
( GTK_TREE_MODEL(store), &iter,
PLAYLIST_NAME_COLUMN, &old_name,
PLAYLIST_URI_COLUMN, &old_uri, -1 );
name_update = (g_strcmp0(name, old_name) != 0);
uri_update = (g_strcmp0(uri, old_uri) != 0);
/* Only set the name if either the title can be
* retrieved or the name is unset. This preserves the
* correct title if it becomes unavailable later such as
* when restarting mpv.
*/
if(name_update && (!old_name || title || uri_update))
{
gtk_list_store_set
( store, &iter,
PLAYLIST_NAME_COLUMN, name, -1 );
}
if(uri_update)
{
gtk_list_store_set
( store, &iter,
PLAYLIST_URI_COLUMN, uri, -1 );
}
iter_end = !gtk_tree_model_iter_next
(GTK_TREE_MODEL(store), &iter);
g_free(old_name);
g_free(old_uri);
}
/* Append entries to the playlist if there are fewer entries in
* the playlist widget than mpv's playlist.
*/
else
{
gmpv_playlist_append(mpv->playlist, name, uri);
}
g_free(name);
}
/* If there are more entries in the playlist widget than mpv's playlist,
* remove the excess entries from the playlist widget.
*/
if(!iter_end)
{
while(gtk_list_store_remove(store, &iter));
}
g_free(filename_prop_str);
mpv_free_node_contents(&mpv_playlist);
}
/*
* Update the tree by adding/removing entries
* Does not change other nodes
*/
static void update_tree(struct menu *src, GtkTreeIter * dst)
{
struct menu *child1;
GtkTreeIter iter, tmp;
GtkTreeIter *child2 = &iter;
gboolean valid;
GtkTreeIter *sibling;
struct symbol *sym;
struct property *prop;
struct menu *menu1, *menu2;
if (src == &rootmenu)
indent = 1;
valid = gtk_tree_model_iter_children(model2, child2, dst);
for (child1 = src->list; child1; child1 = child1->next) {
prop = child1->prompt;
sym = child1->sym;
reparse:
menu1 = child1;
if (valid)
gtk_tree_model_get(model2, child2, COL_MENU,
&menu2, -1);
else
menu2 = NULL; // force adding of a first child
#ifdef DEBUG
printf("%*c%s | %s\n", indent, ' ',
menu1 ? menu_get_prompt(menu1) : "nil",
menu2 ? menu_get_prompt(menu2) : "nil");
#endif
if (!menu_is_visible(child1) && !show_all) { // remove node
if (gtktree_iter_find_node(dst, menu1) != NULL) {
memcpy(&tmp, child2, sizeof(GtkTreeIter));
valid = gtk_tree_model_iter_next(model2,
child2);
gtk_tree_store_remove(tree2, &tmp);
if (!valid)
return; // next parent
else
goto reparse; // next child
} else
continue;
}
if (menu1 != menu2) {
if (gtktree_iter_find_node(dst, menu1) == NULL) { // add node
if (!valid && !menu2)
sibling = NULL;
else
sibling = child2;
gtk_tree_store_insert_before(tree2,
child2,
dst, sibling);
set_node(child2, menu1, fill_row(menu1));
if (menu2 == NULL)
valid = TRUE;
} else { // remove node
memcpy(&tmp, child2, sizeof(GtkTreeIter));
valid = gtk_tree_model_iter_next(model2,
child2);
gtk_tree_store_remove(tree2, &tmp);
if (!valid)
return; // next parent
else
goto reparse; // next child
}
} else if (sym && (sym->flags & SYMBOL_CHANGED)) {
set_node(child2, menu1, fill_row(menu1));
}
indent++;
update_tree(child1, child2);
indent--;
valid = gtk_tree_model_iter_next(model2, child2);
}
}
/*
* Set a column in the map provider table to a new value and mirror the changes
* in the key file. If value is NULL, restore the default value.
*/
void
ph_config_set_map_provider(GtkTreeIter *iter,
guint row,
gint column,
const GValue *value)
{
gchar *name;
gchar *group;
const gchar *key;
g_return_if_fail(ph_config != NULL);
g_return_if_fail(iter != NULL);
g_return_if_fail(column >= 0 && column < PH_MAP_PROVIDER_COLUMN_COUNT);
if (ph_config->map_providers == NULL)
(void) ph_config_get_map_providers();
g_return_if_fail(ph_config->map_providers != NULL);
gtk_tree_model_get(GTK_TREE_MODEL(ph_config->map_providers), iter,
PH_MAP_PROVIDER_COLUMN_NAME, &name, -1);
group = ph_config_get_map_provider_group(name);
key = ph_config_get_map_provider_key(column);
if (value == NULL && row < G_N_ELEMENTS(ph_config_default_map_providers)) {
/* restore default value for built-in provider */
ph_map_provider_to_list_single(&ph_config_default_map_providers[row],
ph_config->map_providers, iter, column);
(void) g_key_file_remove_key(ph_config->key_file, group, key, NULL);
}
else {
GValue target = { 0 };
GType target_type;
target_type = gtk_tree_model_get_column_type(
GTK_TREE_MODEL(ph_config->map_providers), column);
g_value_init(&target, target_type);
if (value == NULL) {
/* restore default value for another provider */
switch (column) {
case PH_MAP_PROVIDER_COLUMN_URL:
g_value_set_static_string(&target, "");
break;
case PH_MAP_PROVIDER_COLUMN_TILE_SIZE:
g_value_set_uint(&target, 256);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_MIN:
g_value_set_uint(&target, 0);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_MAX:
g_value_set_uint(&target, 18);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_DETAIL:
g_value_set_uint(&target, 14);
break;
default:
g_warn_if_reached();
}
}
else
/* actually set to a new value */
g_value_transform(value, &target);
gtk_list_store_set_value(ph_config->map_providers, iter,
column, &target);
ph_config_set_value(group, key, &target);
g_value_unset(&target);
}
g_free(name);
g_free(group);
}
static gint
gtk_app_chooser_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
gboolean a_recommended, b_recommended;
gboolean a_fallback, b_fallback;
gboolean a_heading, b_heading;
gboolean a_default, b_default;
gchar *a_name, *b_name, *a_casefold, *b_casefold;
gint retval = 0;
/* this returns:
* - <0 if a should show before b
* - =0 if a is the same as b
* - >0 if a should show after b
*/
gtk_tree_model_get (model, a,
COLUMN_NAME, &a_name,
COLUMN_RECOMMENDED, &a_recommended,
COLUMN_FALLBACK, &a_fallback,
COLUMN_HEADING, &a_heading,
COLUMN_DEFAULT, &a_default,
-1);
gtk_tree_model_get (model, b,
COLUMN_NAME, &b_name,
COLUMN_RECOMMENDED, &b_recommended,
COLUMN_FALLBACK, &b_fallback,
COLUMN_HEADING, &b_heading,
COLUMN_DEFAULT, &b_default,
-1);
/* the default one always wins */
if (a_default && !b_default)
{
retval = -1;
goto out;
}
if (b_default && !a_default)
{
retval = 1;
goto out;
}
/* the recommended one always wins */
if (a_recommended && !b_recommended)
{
retval = -1;
goto out;
}
if (b_recommended && !a_recommended)
{
retval = 1;
goto out;
}
/* the recommended one always wins */
if (a_fallback && !b_fallback)
{
retval = -1;
goto out;
}
if (b_fallback && !a_fallback)
{
retval = 1;
goto out;
}
/* they're both recommended/falback or not, so if one is a heading, wins */
if (a_heading)
{
retval = -1;
goto out;
}
if (b_heading)
{
retval = 1;
goto out;
}
/* don't order by name recommended applications, but use GLib's ordering */
if (!a_recommended)
{
a_casefold = a_name != NULL ?
g_utf8_casefold (a_name, -1) : NULL;
b_casefold = b_name != NULL ?
g_utf8_casefold (b_name, -1) : NULL;
retval = g_strcmp0 (a_casefold, b_casefold);
g_free (a_casefold);
g_free (b_casefold);
}
out:
g_free (a_name);
g_free (b_name);
return retval;
}
extern void popup_all_block(GtkTreeModel *model, GtkTreeIter *iter, int id)
{
char *name = NULL;
char title[100];
ListIterator itr = NULL;
popup_info_t *popup_win = NULL;
GError *error = NULL;
int i=0;
gtk_tree_model_get(model, iter, SORTID_BLOCK, &name, -1);
switch(id) {
case JOB_PAGE:
snprintf(title, 100, "Jobs(s) in block %s", name);
break;
case PART_PAGE:
snprintf(title, 100, "Partition(s) containing block %s", name);
break;
case RESV_PAGE:
snprintf(title, 100, "Reservations(s) containing block %s",
name);
break;
case NODE_PAGE:
snprintf(title, 100, "Midplane(s) in block %s", name);
break;
case SUBMIT_PAGE:
snprintf(title, 100, "Submit job on %s", name);
break;
case INFO_PAGE:
snprintf(title, 100, "Full info for block %s", name);
break;
default:
g_print("Block got %d\n", id);
}
itr = list_iterator_create(popup_list);
while ((popup_win = list_next(itr))) {
if (popup_win->spec_info)
if (!xstrcmp(popup_win->spec_info->title, title)) {
break;
}
}
list_iterator_destroy(itr);
if (!popup_win) {
if (id == INFO_PAGE)
popup_win = create_popup_info(id, BLOCK_PAGE, title);
else
popup_win = create_popup_info(BLOCK_PAGE, id, title);
} else {
g_free(name);
gtk_window_present(GTK_WINDOW(popup_win->popup));
return;
}
/* Pass the model and the structs from the iter so we can always get
the current node_inx.
*/
popup_win->model = model;
popup_win->iter = *iter;
popup_win->node_inx_id = SORTID_NODE_INX;
switch(id) {
case JOB_PAGE:
popup_win->spec_info->search_info->gchar_data = name;
break;
case PART_PAGE:
g_free(name);
gtk_tree_model_get(model, iter, SORTID_PARTITION, &name, -1);
popup_win->spec_info->search_info->gchar_data = name;
break;
case RESV_PAGE:
case NODE_PAGE:
g_free(name);
gtk_tree_model_get(model, iter, SORTID_NODELIST, &name, -1);
gtk_tree_model_get(model, iter, SORTID_SMALL_BLOCK, &i, -1);
if (i) {
i=0;
/* strip off the ionodes part */
while (name[i]) {
if (name[i] == '[') {
name[i] = '\0';
break;
}
i++;
}
}
popup_win->spec_info->search_info->gchar_data = name;
break;
case INFO_PAGE:
popup_win->spec_info->search_info->gchar_data = name;
break;
default:
g_print("block got %d\n", id);
}
if (!sview_thread_new((gpointer)popup_thr, popup_win, FALSE, &error)) {
g_printerr ("Failed to create part popup thread: %s\n",
error->message);
return;
}
}
/**
* Build data storage by querying the X server for all input devices.
* Can be called multiple times, in which case it'll clean out and re-fill
* update the tree store.
*/
static GtkTreeStore* query_devices(GDeviceSetup* gds)
{
GtkTreeStore *treestore;
GtkTreeModel *model;
GtkTreeIter iter, child;
XIDeviceInfo *devices, *dev;
int ndevices;
int i, j;
int icontype;
GdkPixbuf *icon;
int valid, child_valid;
int id, masterid;
if (!gds->treeview)
{
treestore = gtk_tree_store_new(NUM_COLS,
G_TYPE_UINT, /* deviceid*/
G_TYPE_STRING, /* name */
G_TYPE_UINT,
GDK_TYPE_PIXBUF,
G_TYPE_UINT
);
model = GTK_TREE_MODEL(treestore);
} else
{
model = gtk_tree_view_get_model(gds->treeview);
treestore = GTK_TREE_STORE(model);
}
gds->generation++;
devices = XIQueryDevice(gds->dpy, XIAllDevices, &ndevices);
/* First, run through all master device and append them to the tree store
*/
for (i = 0; i < ndevices; i++)
{
dev = &devices[i];
if (dev->use != XIMasterPointer && dev->use != XIMasterKeyboard)
continue;
valid = gtk_tree_model_get_iter_first(model, &iter);
g_debug("MD %d: %s", dev->deviceid, dev->name);
while(valid) {
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
if (id == dev->deviceid)
{
gtk_tree_store_set(treestore, &iter,
COL_GENERATION, gds->generation, -1);
valid = 0xFF;
break;
}
valid = gtk_tree_model_iter_next(model, &iter);
}
if (valid != 0xFF) /* new MD */
{
icontype = (dev->use == XIMasterPointer) ? ICON_MOUSE : ICON_KEYBOARD;
icon = load_icon(icontype);
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter,
COL_ID, dev->deviceid,
COL_NAME, dev->name,
COL_USE, dev->use,
COL_ICON, icon,
COL_GENERATION, gds->generation,
-1);
g_object_unref(icon);
}
}
/* search for Floating fake master device */
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid)
{
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
if (id == ID_FLOATING)
break;
valid = gtk_tree_model_iter_next(model, &iter);
}
if (!valid)
{
/* Attach a fake master device for "Floating" */
icon = load_icon(ICON_FLOATING);
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter,
COL_ID, ID_FLOATING,
COL_NAME, "Floating",
COL_USE, ID_FLOATING,
COL_ICON, icon,
COL_GENERATION, gds->generation,
-1);
g_object_unref(icon);
} else {
GtkTreeIter prev;
GtkTreeIter pos = iter; /* current position of Floating */
/* always move Floating fake device to end of list */
while(valid)
{
prev = iter;
valid = gtk_tree_model_iter_next(model, &iter);
}
gtk_tree_store_move_after(treestore, &pos, &prev);
/* update generation too */
gtk_tree_store_set(treestore, &pos,
COL_GENERATION, gds->generation, -1);
}
/* now that we added all MDs, run through again and add SDs to the
* respective MD */
for (i = 0; i < ndevices; i++)
{
dev = &devices[i];
if (dev->use == XIMasterPointer || dev->use == XIMasterKeyboard)
continue;
g_debug("SD %d: %s", dev->deviceid, dev->name);
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid) {
gtk_tree_model_get(model, &iter, COL_ID, &masterid, -1);
if(dev->attachment == masterid || (dev->use == XIFloatingSlave && masterid == ID_FLOATING))
{
/* found master, check if we're already attached to it in
* the tree model */
child_valid = gtk_tree_model_iter_children(model, &child, &iter);
while (child_valid)
{
gtk_tree_model_get(model, &child, COL_ID, &id);
if (id == dev->deviceid)
{
gtk_tree_store_set(treestore, &child,
COL_GENERATION, gds->generation, -1);
child_valid = 0xFF;
break;
}
child_valid = gtk_tree_model_iter_next(model, &child);
}
/* new slave device, attach */
if (child_valid != 0xFF)
{
gtk_tree_store_append(treestore, &child, &iter);
gtk_tree_store_set(treestore, &child,
COL_ID, dev->deviceid,
COL_NAME, dev->name,
COL_USE, dev->use,
COL_GENERATION, gds->generation,
-1);
}
break;
}
valid = gtk_tree_model_iter_next(model, &iter);
}
}
XIFreeDeviceInfo(devices);
/* clean tree store of anything that doesn't have the current
server generation */
valid = gtk_tree_model_get_iter_first(model, &iter);
while(valid)
{
int gen;
child_valid = gtk_tree_model_iter_children(model, &child, &iter);
while(child_valid)
{
gtk_tree_model_get(model, &child, COL_GENERATION, &gen, -1);
if (gen < gds->generation)
child_valid = gtk_tree_store_remove(treestore, &child);
else
child_valid = gtk_tree_model_iter_next(model, &child);
}
gtk_tree_model_get(model, &iter, COL_GENERATION, &gen, -1);
if (gen < gds->generation)
valid = gtk_tree_store_remove(treestore, &iter);
else
valid = gtk_tree_model_iter_next(model, &iter);
}
return treestore;
}
void
on_open_export_dialog_activate (GtkButton *button, gpointer user_data)
{
GSQL_TRACE_FUNC;
GladeXML* gxml;
GtkDialog *dialog;
GtkWidget *combo;
GtkWidget *combo_exptype;
GtkWidget *choosebutton;
GtkAlignment *alig;
GtkAlignment *alig_exptype;
GtkRadioButton *rbutton;
GtkWidget *target;
GtkWidget *headers;
GtkWidget *progressbar, *config_vbox, *save_button;
GSList *rgroup;
GSQLContent *content = NULL;
GSQLSession *session = NULL;
GSQLWorkspace *workspace = NULL;
gchar *encoding = NULL;
static gchar *filename = NULL;
static gboolean include_headers = TRUE;
static gboolean only_fetched = FALSE;
static gint exptype = 0;
GtkTreeIter iter;
GtkTreeModel *model;
gint ret;
gxml = glade_xml_new (GSQLP_EXPORTER_GLADE_DIALOG, "export_dialog", NULL);
g_return_if_fail(gxml);
dialog = (GtkDialog *) glade_xml_get_widget (gxml, "export_dialog");
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (gsql_window));
alig = (GtkAlignment *) glade_xml_get_widget (gxml, "alignment_enc");
alig_exptype = (GtkAlignment *) glade_xml_get_widget (gxml, "alignment_exptype");
combo = (GtkWidget *) gsql_enconding_list ();
combo_exptype = (GtkWidget *) get_export_types_combo ();
target = (GtkWidget *) glade_xml_get_widget (gxml, "target");
choosebutton = (GtkWidget *) glade_xml_get_widget (gxml, "choosebutton");
headers = (GtkWidget *) glade_xml_get_widget (gxml, "headers");
progressbar = (GtkWidget *) glade_xml_get_widget (gxml, "progressbar");
config_vbox = (GtkWidget *) glade_xml_get_widget (gxml, "config_vbox");
save_button = (GtkWidget *) glade_xml_get_widget (gxml, "save_button");
g_signal_connect ((gpointer) choosebutton, "clicked",
G_CALLBACK (on_choosebutton_activate),
(gpointer) target);
if (filename)
gtk_entry_set_text (GTK_ENTRY (target), filename);
if (exptype)
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_exptype), exptype);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (headers), include_headers);
gtk_container_add (GTK_CONTAINER (alig), combo);
gtk_container_add (GTK_CONTAINER (alig_exptype), combo_exptype);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (gsql_window));
// 2 - cancel, 3 - export complete (via gtk_dialog_response)
while ((ret != 2) && (ret !=3))
{
ret = gtk_dialog_run (dialog);
GSQL_DEBUG ("Export result dialog: [ret=%d]", ret);
if (ret == 1) // Save action selected
{
GSQL_DEBUG ("Start exporting...");
rbutton = (GtkRadioButton *) glade_xml_get_widget (gxml, "radiobutton1");
rgroup = gtk_radio_button_get_group (rbutton);
if (filename)
g_free (filename);
filename = g_strdup (gtk_entry_get_text (GTK_ENTRY (target)));
GSQL_DEBUG ("GSList length: %d", g_slist_length (rgroup));
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo_exptype), &iter))
{
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_exptype));
gtk_tree_model_get (model, &iter,
0, &exptype, -1);
}
session = gsql_session_get_active ();
workspace = gsql_session_get_workspace (session);
content = gsql_workspace_get_current_content (workspace);
gtk_widget_show (progressbar);
gtk_widget_hide (config_vbox);
gtk_widget_hide (save_button);
g_object_set_data (G_OBJECT (content), "dialog", dialog);
g_object_set_data (G_OBJECT (content), "progress", progressbar);
g_return_if_fail (GSQL_IS_CONTENT (content));
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
{
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
gtk_tree_model_get (model, &iter,
1, &encoding, -1);
GSQL_DEBUG ("Exporter: encoding selected. [%s]", encoding);
}
include_headers = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (headers));
GSQL_DEBUG ("Exporter: [filename=%s]", filename);
switch (exptype)
{
case 0: // CSV
GSQL_DEBUG ("Export type: CSV");
exporter_export_to_csv (content, filename,
encoding, include_headers);
break;
case 1: // HTML
GSQL_DEBUG ("Export type: HTML");
exporter_export_to_html (content, filename,
encoding, include_headers);
break;
case 2: // XML
GSQL_DEBUG ("Export type: XML");
exporter_export_to_xml (content, filename,
encoding, include_headers);
break;
case 3: // Plain text
GSQL_DEBUG ("Export type: Plain text");
exporter_export_to_plain_text (content, filename,
encoding, include_headers);
break;
}
}
}
if (encoding)
g_free (encoding);
gtk_widget_destroy ((GtkWidget *) dialog);
g_object_unref(G_OBJECT(gxml));
}
static gboolean confirm_overwrite()
{
GtkTreeIter iter;
gboolean valid;
gboolean exist = FALSE;
gboolean settings_different = TRUE;
Settings * user_settings;
user_settings = settings_get_from_gui();
if (settings_on_execute)
{
settings_different = !settings_equal(user_settings,
settings_on_execute);
}
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list_store), &iter);
while (valid)
{
gchar *output_file;
gchar *status;
gboolean done;
gtk_tree_model_get (GTK_TREE_MODEL(list_store), &iter,
COL_OUTPUT_FILE, &output_file,
COL_STATUS, &status, -1);
done = strcmp("Done", status) == 0;
if ((settings_different || !done) &&
g_file_test(output_file, G_FILE_TEST_EXISTS))
exist = TRUE;
g_free(output_file);
g_free(status);
if (exist)
break;
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(list_store), &iter);
}
settings_delete(user_settings);
if (exist)
{
GtkWidget * dialog_confirm_overwrite;
gint result;
dialog_confirm_overwrite =
get_widget_checked("dialog_confirm_overwrite");
result = gtk_dialog_run( GTK_DIALOG(dialog_confirm_overwrite) );
gtk_widget_hide( dialog_confirm_overwrite );
switch (result)
{
default:
return FALSE;
case GTK_RESPONSE_OK:
return TRUE;
}
}
else
{
/* no need to confirm -- no overwrites */
return TRUE;
}
}
static void
process_item(GtkTreeIter *iter, Settings *user_settings, gboolean skip_done,
int is_first)
{
gchar *in_file, *out_full, *ancillary_file, *meta_file,
*status, *polsarpro_aux_info, *interferogram_file,
*coherence_file, *slave_metadata_file, *baseline_file,
*uavsar_type;
int pid, isPolSARPro = FALSE;
pid = getpid();
gtk_tree_model_get(GTK_TREE_MODEL(list_store), iter,
COL_INPUT_FILE, &in_file,
COL_ANCILLARY_FILE, &ancillary_file,
COL_METADATA_FILE, &meta_file,
COL_OUTPUT_FILE, &out_full,
COL_STATUS, &status,
COL_POLSARPRO_INFO, &polsarpro_aux_info,
COL_INTERFEROGRAM, &interferogram_file,
COL_COHERENCE, &coherence_file,
COL_SLAVE_METADATA, &slave_metadata_file,
COL_BASELINE, &baseline_file,
COL_UAVSAR_TYPE, &uavsar_type,
-1);
int image_data_type = extract_image_data_type(polsarpro_aux_info);
if (image_data_type >= 0 && image_data_type < 3)
isPolSARPro = TRUE;
if (strcmp(status, "Done") != 0 || !skip_done)
{
//char *in_basename = stripExt(in_file);
char *out_basename = stripExt(out_full);
char *out_nameonly = get_basename(out_full);
char *output_dir = getPath(out_full);
char *config_file, *cmd_output, *tmp_dir, *intermediates_file;
gchar *err_string;
/* Ensure we have access to the output directory */
if (!have_access_to_dir(output_dir, &err_string))
{
/* We don't -- issue a message in the "Status" column. */
gtk_list_store_set(list_store, iter, COL_STATUS, err_string, -1);
g_free(err_string);
//free(in_basename);
free(out_basename);
free(output_dir);
return;
}
tmp_dir = MALLOC(sizeof(char)*
(strlen(output_dir)+strlen(out_nameonly)+32));
if (strlen(output_dir) > 0) {
sprintf(tmp_dir, "%s%c%s-%s", output_dir, DIR_SEPARATOR,
out_nameonly, time_stamp_dir());
}
else {
sprintf(tmp_dir, "%s-%s", out_nameonly, time_stamp_dir());
}
create_clean_dir(tmp_dir);
set_asf_tmp_dir(tmp_dir);
config_file =
settings_to_config_file(user_settings,
in_file, ancillary_file, meta_file,
out_full, output_dir,
tmp_dir, polsarpro_aux_info,
interferogram_file, coherence_file,
slave_metadata_file, baseline_file, uavsar_type);
if (!config_file) {
err_string = "Error creating configuration file.";
gtk_list_store_set(list_store, iter, COL_STATUS, err_string, -1);
free(out_basename);
free(output_dir);
free(tmp_dir);
return;
}
cmd_output = do_convert(pid, iter, config_file, TRUE,
user_settings->keep_files, &intermediates_file);
err_string = check_for_error(cmd_output);
if (err_string) {
// unsuccessful
gtk_list_store_set(list_store, iter, COL_STATUS, err_string,
COL_LOG, cmd_output, -1);
FREE(err_string);
}
else {
// successful -- move to "completed" list
GtkTreeIter completed_iter;
move_to_completed_files_list(iter, &completed_iter, cmd_output,
intermediates_file);
set_thumbnail(&completed_iter, tmp_dir, out_full, isPolSARPro);
input_data_formats_changed();
refresh_file_names();
}
// for subsequent runs, save the imported dem & mask
settings_update_dem(user_settings, output_dir);
settings_update_mask(user_settings, output_dir);
free(config_file);
free(out_basename);
free(output_dir);
free(out_nameonly);
free(intermediates_file);
g_free(cmd_output);
if (!user_settings->keep_files)
remove_dir(tmp_dir);
free(tmp_dir);
}
g_free(status);
g_free(out_full);
g_free(ancillary_file);
g_free(meta_file);
g_free(in_file);
g_free(polsarpro_aux_info);
}
static void
network_model_update_property (const gchar *property,
GValue *value,
gpointer user_data)
{
CarrickNetworkModel *self = user_data;
CarrickNetworkModelPrivate *priv = self->priv;
GtkListStore *store = GTK_LIST_STORE (self);
GList *new_services = NULL;
GList *old_services = NULL;
GList *list_iter = NULL;
GList *tmp = NULL;
GtkTreeIter iter;
gchar *path = NULL;
DBusGProxy *service;
guint index = 0;
if (g_str_equal (property, "Services"))
{
old_services = priv->services;
dbus_g_type_collection_value_iterate (value,
network_model_iterate_services,
&new_services);
priv->services = new_services;
for (list_iter = new_services;
list_iter != NULL;
list_iter = list_iter->next)
{
path = list_iter->data;
/* Remove from old list, if present.
* We only want stale services in old list
*/
tmp = g_list_find_custom (old_services,
path,
(GCompareFunc) g_strcmp0);
if (tmp)
{
old_services = g_list_delete_link (old_services, tmp);
}
/* if we don't have the service in the model, add it*/
if (network_model_have_service_by_path (store, &iter, path) == FALSE)
{
service = dbus_g_proxy_new_for_name (priv->connection,
CONNMAN_SERVICE, path,
CONNMAN_SERVICE_INTERFACE);
gtk_list_store_insert_with_values (store, &iter, -1,
CARRICK_COLUMN_PROXY, service,
CARRICK_COLUMN_INDEX, index,
-1);
dbus_g_proxy_add_signal (service,
"PropertyChanged",
G_TYPE_STRING,
G_TYPE_VALUE,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (service,
"PropertyChanged",
G_CALLBACK
(network_model_service_changed_cb),
self,
NULL);
net_connman_Service_get_properties_async
(service,
network_model_service_get_properties_cb,
self);
g_object_unref (service);
}
/* else update it */
else
{
guint current_index;
gtk_tree_model_get (GTK_TREE_MODEL (self), &iter,
CARRICK_COLUMN_INDEX, ¤t_index,
-1);
if (current_index != index)
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_INDEX, index,
-1);
}
index++;
}
/* Old list only contains items not in new list.
* Remove stale services */
for (list_iter = old_services;
list_iter != NULL;
list_iter = list_iter->next)
{
path = list_iter->data;
if (network_model_have_service_by_path (store, &iter, path) == TRUE)
gtk_list_store_remove (store, &iter);
g_free (path);
}
if (old_services)
{
g_list_free (old_services);
old_services = NULL;
}
}
}
void validate_menu(GtkTreeIter * iter)
{
struct validate *validate;
GtkWidget *scrolled_window;
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
gboolean updated = FALSE;
gdouble scroll_hvalue = 0;
gdouble scroll_vvalue = 0;
gtk_tree_model_get(GTK_TREE_MODEL(debr.ui_menu.model), iter, MENU_VALIDATE_POINTER, &validate, -1);
if (validate != NULL) {
updated = TRUE;
validate->menu_iter = *iter;
scroll_hvalue = gtk_adjustment_get_value(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(validate->widget)));
scroll_vvalue = gtk_adjustment_get_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(validate->widget)));
gtk_text_buffer_set_text(validate->text_buffer, "", 0);
goto out;
}
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_end(GTK_BOX(debr.ui_validate.text_view_vbox), scrolled_window, TRUE, TRUE, 0);
text_buffer = gtk_text_buffer_new(NULL);
text_view = gtk_text_view_new_with_buffer(text_buffer);
gtk_widget_show(text_view);
gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
g_object_set(G_OBJECT(text_view), "editable", FALSE, "cursor-visible", FALSE, NULL);
PangoFontDescription *font = pango_font_description_new();
pango_font_description_set_family(font, "monospace");
gtk_widget_modify_font(text_view, font);
pango_font_description_free(font);
GebrGeoXmlValidateOperations operations;
operations.append_text = (void(*)(gpointer,const gchar*,...))validate_append_text;
operations.append_text_emph = (void(*)(gpointer,const gchar*,...))validate_append_text_emph;
operations.append_text_error = NULL;
operations.append_text_error_with_paths = (void(*)(gpointer, gint, const gchar *, const gchar *, GebrValidateCaseName, const gchar *,
...))validate_append_text_error;
GebrGeoXmlValidateOptions options;
options.all = TRUE;
options.ehelp = -1;
validate = g_new(struct validate, 1);
validate->widget = scrolled_window;
validate->text_view = text_view;
validate->text_buffer = text_buffer;
validate->menu_iter = *iter;
validate->geoxml_validate = gebr_geoxml_validate_new(validate, operations, options);
gtk_list_store_append(debr.ui_validate.list_store, &validate->iter);
out:
gtk_tree_store_set(debr.ui_menu.model, iter, MENU_VALIDATE_NEED_UPDATE, FALSE,
MENU_VALIDATE_POINTER, validate, -1);
GebrGeoXmlFlow * menu = menu_get_xml_pointer(iter);
gint error_count = gebr_geoxml_validate_report_menu(validate->geoxml_validate, menu);
gtk_list_store_set(debr.ui_validate.list_store, &validate->iter,
VALIDATE_ICON, !error_count ? debr.pixmaps.stock_apply : debr.pixmaps.stock_warning,
VALIDATE_FILENAME, gebr_geoxml_document_get_filename(GEBR_GEOXML_DOCUMENT(menu)),
VALIDATE_POINTER, validate, -1);
validate_set_selected(&validate->iter);
if (updated) {
gtk_adjustment_set_value(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(validate->widget)), scroll_hvalue);
gtk_adjustment_set_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(validate->widget)), scroll_vvalue);
}
}
static void
network_model_service_changed_cb (DBusGProxy *service,
const gchar *property,
GValue *value,
gpointer user_data)
{
CarrickNetworkModel *self = user_data;
GtkListStore *store = GTK_LIST_STORE (self);
GtkTreeIter iter;
GHashTable *dict;
if (property == NULL || value == NULL)
return;
if (network_model_have_service_by_proxy (store, &iter, service) == FALSE)
return;
if (g_str_equal (property, "State"))
{
const char *type, *state;
DBusGProxy *service_proxy;
/* HACK: connman (0.61) vpn handling is not consistent, so we
* remove the provider on idle (otherwise it'll just hang there).
* But: set the state first, so notifications etc happen. */
state = g_value_get_string (value);
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_STATE, state,
-1);
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter,
CARRICK_COLUMN_TYPE, &type,
CARRICK_COLUMN_PROXY, &service_proxy,
-1);
if (g_strcmp0 (type, "vpn") == 0 &&
(g_strcmp0 (state, "idle") == 0 ||
g_strcmp0 (state, "failure") == 0))
net_connman_Manager_remove_provider_async (self->priv->manager,
dbus_g_proxy_get_path (service),
remove_provider_cb,
self);
}
else if (g_str_equal (property, "Favorite"))
{
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_FAVORITE, g_value_get_boolean (value),
-1);
}
else if (g_str_equal (property, "Strength"))
{
guint current_strength;
/* This is the most common change, and fairly unimportant...
* Round to nearest ten, and avoid change notification */
guint strength = 10 * ((g_value_get_uchar (value) + 5) / 10);
gtk_tree_model_get (GTK_TREE_MODEL (self), &iter,
CARRICK_COLUMN_STRENGTH, ¤t_strength,
-1);
if (current_strength != strength)
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_STRENGTH, strength,
-1);
}
else if (g_str_equal (property, "Name"))
{
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_NAME, g_value_get_string (value),
-1);
}
else if (g_str_equal (property, "PassphraseRequired") ||
g_str_equal (property, "SetupRequired"))
{
/* Rather than store this property we're just going to trigger
* GetProperties to pull the up-to-date passphrase
*/
net_connman_Service_get_properties_async
(service,
network_model_service_get_properties_cb,
self);
}
else if (g_str_equal (property, "IPv4"))
{
dict = g_value_get_boxed (value);
if (dict)
{
const char *method, *address, *netmask, *gateway;
method = get_string (dict, "Method");
address = get_string (dict, "Address");
netmask = get_string (dict, "Netmask");
gateway = get_string (dict, "Gateway");
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_METHOD, method,
CARRICK_COLUMN_ADDRESS, address,
CARRICK_COLUMN_NETMASK, netmask,
CARRICK_COLUMN_GATEWAY, gateway,
-1);
}
}
else if (g_str_equal (property, "IPv4.Configuration"))
{
dict = g_value_get_boxed (value);
if (dict)
{
const char *method, *address, *netmask, *gateway;
method = get_string (dict, "Method");
address = get_string (dict, "Address");
netmask = get_string (dict, "Netmask");
gateway = get_string (dict, "Gateway");
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_CONFIGURED_METHOD, method,
CARRICK_COLUMN_CONFIGURED_ADDRESS, address,
CARRICK_COLUMN_CONFIGURED_NETMASK, netmask,
CARRICK_COLUMN_CONFIGURED_GATEWAY, gateway,
-1);
}
}
else if (g_str_equal (property, "IPv6"))
{
dict = g_value_get_boxed (value);
if (dict)
{
const char *method, *address, *gateway;
guint prefix;
method = get_string (dict, "Method");
address = get_string (dict, "Address");
prefix = get_uint (dict, "PrefixLength");
gateway = get_string (dict, "Gateway");
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_IPV6_METHOD, method,
CARRICK_COLUMN_IPV6_ADDRESS, address,
CARRICK_COLUMN_IPV6_PREFIX_LENGTH, prefix,
CARRICK_COLUMN_IPV6_GATEWAY, gateway,
-1);
}
}
else if (g_str_equal (property, "IPv6.Configuration"))
{
dict = g_value_get_boxed (value);
if (dict)
{
const char *method, *address, *gateway;
guint prefix;
method = get_string (dict, "Method");
address = get_string (dict, "Address");
prefix = get_uint (dict, "PrefixLength");
gateway = get_string (dict, "Gateway");
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_CONFIGURED_IPV6_METHOD, method,
CARRICK_COLUMN_CONFIGURED_IPV6_ADDRESS, address,
CARRICK_COLUMN_CONFIGURED_IPV6_PREFIX_LENGTH, prefix,
CARRICK_COLUMN_CONFIGURED_IPV6_GATEWAY, gateway,
-1);
}
}
else if (g_str_equal (property, "Nameservers"))
{
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_NAMESERVERS,
g_value_get_boxed (value),
-1);
}
else if (g_str_equal (property, "Nameservers.Configuration"))
{
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_CONFIGURED_NAMESERVERS,
g_value_get_boxed (value),
-1);
}
else if (g_str_equal (property, "Immutable"))
{
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_IMMUTABLE, g_value_get_boolean (value),
-1);
}
else if (g_str_equal (property, "LoginRequired"))
{
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_LOGIN_REQUIRED, g_value_get_boolean (value),
-1);
}
else if (g_str_equal (property, "Ethernet"))
{
dict = g_value_get_boxed (value);
if (dict)
{
const char *mac_address;
mac_address = get_string (dict, "Address");
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_ETHERNET_MAC_ADDRESS, mac_address,
-1);
}
}
else if (g_str_equal (property, "Proxy"))
{
dict = g_value_get_boxed (value);
if (dict)
{
const char *proxy_method, *proxy_url;
const char **servers, **excludes;
proxy_method = get_string (dict, "Method");
proxy_url = get_string (dict, "URL");
servers = get_boxed (dict, "Servers");
excludes = get_boxed (dict, "Excludes");
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_PROXY_METHOD, proxy_method,
CARRICK_COLUMN_PROXY_URL, proxy_url,
CARRICK_COLUMN_PROXY_SERVERS, servers,
CARRICK_COLUMN_PROXY_EXCLUDES, excludes,
-1);
}
}
else if (g_str_equal (property, "Proxy.Configuration"))
{
dict = g_value_get_boxed (value);
if (dict)
{
const char *proxy_method, *proxy_url;
const char **servers, **excludes;
proxy_method = get_string (dict, "Method");
proxy_url = get_string (dict, "URL");
servers = get_boxed (dict, "Servers");
excludes = get_boxed (dict, "Excludes");
gtk_list_store_set (store, &iter,
CARRICK_COLUMN_PROXY_METHOD, proxy_method,
CARRICK_COLUMN_PROXY_URL, proxy_url,
CARRICK_COLUMN_PROXY_SERVERS, servers,
CARRICK_COLUMN_PROXY_EXCLUDES, excludes,
-1);
}
}
}
/*
* Note that this is called every time the user clicks on an item,
* whether it is already selected or not.
*/
static void
field_select_row_cb(GtkTreeSelection *sel, gpointer tree)
{
GtkWidget *window = (GtkWidget *)gtk_widget_get_toplevel((GtkWidget *)tree);
GtkWidget *relation_list = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_RELATION_LIST_KEY);
GtkWidget *range_label = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_RANGE_LABEL_KEY);
GtkWidget *range_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_RANGE_ENTRY_KEY);
GtkWidget *value_label = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_VALUE_LABEL_KEY);
GtkWidget *value_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_VALUE_ENTRY_KEY);
GtkWidget *value_list_label = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_VALUE_LIST_LABEL_KEY);
GtkWidget *value_list = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_VALUE_LIST_KEY);
GtkWidget *value_list_scrolled_win = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_VALUE_LIST_SW_KEY);
GtkWidget *ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(window),
E_DFILTER_EXPR_OK_BT_KEY);
header_field_info *hfinfo, *cur_hfinfo;
const char *value_type;
char value_label_string[1024+1]; /* XXX - should be large enough */
GtkTreeModel *model;
GtkTreeIter iter;
if (!gtk_tree_selection_get_selected(sel, &model, &iter))
return;
gtk_tree_model_get(model, &iter, 0, &hfinfo, -1);
/*
* What was the item that was last selected?
*/
cur_hfinfo = (header_field_info *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY);
if (cur_hfinfo == hfinfo) {
/*
* It's still selected; no need to change anything.
*/
return;
}
/*
* Mark it as currently selected.
*/
g_object_set_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY, hfinfo);
show_relations(relation_list, hfinfo->type);
/*
* Set the label for the value to indicate what type of value
* it is.
*/
value_type = ftype_pretty_name(hfinfo->type);
if (value_type != NULL) {
/*
* Indicate what type of value it is.
*/
g_snprintf(value_label_string, sizeof value_label_string,
"Value (%s)", value_type);
gtk_label_set_text(GTK_LABEL(value_label), value_label_string);
}
/*
* Clear the entry widget for the value, as whatever
* was there before doesn't apply.
*/
gtk_entry_set_text(GTK_ENTRY(value_entry), "");
switch (hfinfo->type) {
case FT_BOOLEAN:
/*
* The list of values should be the strings for "true"
* and "false"; show them in the value list.
*/
build_boolean_values(value_list_scrolled_win, value_list,
(const true_false_string *)hfinfo->strings);
break;
case FT_UINT8:
case FT_UINT16:
case FT_UINT24:
case FT_UINT32:
case FT_INT8:
case FT_INT16:
case FT_INT24:
case FT_INT32:
/*
* If this has a value_string table (not a range_string table) associated with it,
* fill up the list of values, otherwise clear the list of values.
*/
/* XXX: ToDo: Implement "range-string" filter ? */
if ((hfinfo->strings != NULL) &&
! (hfinfo->display & BASE_RANGE_STRING) &&
! (hfinfo->display & BASE_VAL64_STRING) &&
! ((hfinfo->display & FIELD_DISPLAY_E_MASK) == BASE_CUSTOM)) {
const value_string *vals = (const value_string *)hfinfo->strings;
if (hfinfo->display & BASE_EXT_STRING)
vals = VALUE_STRING_EXT_VS_P((value_string_ext *)vals);
build_enum_values(value_list_scrolled_win, value_list, vals);
} else
gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list))));
break;
default:
/*
* Clear the list of values.
*/
gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list))));
break;
}
/*
* Display various items for the value, as appropriate.
* The relation we start out with is never a comparison.
*/
display_value_fields(hfinfo, FALSE, value_label, value_entry,
value_list_label, value_list, value_list_scrolled_win, range_label, range_entry);
/*
* XXX - in browse mode, there always has to be something
* selected, so this should always be sensitive.
*/
gtk_widget_set_sensitive(ok_bt, TRUE);
}
void
cal_print_get_events (gchar *buffer, guint32 julian, GUI *appGUI)
{
GtkTreePath *path;
GtkTreeIter iter;
GtkTreeModel *model;
GSList *lnode;
struct note *a;
gint i;
gchar *wbuf1, *wbuf2;
gchar buf1[BUFFER_SIZE], buf2[BUFFER_SIZE];
GDate *date, *sdate;
gint age, syear;
guint32 tsk_julian;
gint time;
gint max_event_length;
GRegex *reg;
buffer[0] = '\0';
max_event_length = (config.cal_print_event_length + 2 > BUFFER_SIZE) ? BUFFER_SIZE : config.cal_print_event_length + 2;
#ifdef TASKS_ENABLED
/* tasks */
if (config.cal_print_tasks) {
model = GTK_TREE_MODEL (appGUI->tsk->tasks_list_store);
g_return_if_fail (model != NULL);
path = gtk_tree_path_new_first ();
while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) {
gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_DATE_JULIAN, &tsk_julian, TA_COLUMN_CATEGORY, &wbuf1, -1);
if (tsk_julian == julian && tasks_category_get_state (wbuf1, STATE_CALENDAR, appGUI) == TRUE) {
gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_TIME, &time, TA_COLUMN_SUMMARY, &wbuf2, -1);
if (time >= 0) {
g_snprintf (buf1, max_event_length, "\n[%02d:%02d] %s", time / 3600, time / 60 % 60, wbuf2);
} else {
g_snprintf (buf1, max_event_length, "\n%s", wbuf2);
}
g_strlcat (buffer, buf1, BUFFER_SIZE);
g_free (wbuf2);
}
g_free (wbuf1);
gtk_tree_path_next (path);
}
gtk_tree_path_free (path);
}
#endif /* TASKS_ENABLED */
#ifdef CONTACTS_ENABLED
/* birthdays */
if (config.cal_print_birthdays) {
model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store);
g_return_if_fail (model != NULL);
date = g_date_new ();
g_return_if_fail (date != NULL);
sdate = g_date_new_julian (julian);
g_return_if_fail (sdate != NULL);
syear = g_date_get_year (sdate);
path = gtk_tree_path_new_first ();
while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) {
gtk_tree_model_get (model, &iter, COLUMN_BIRTH_DAY_DATE, &tsk_julian, -1);
if (g_date_valid_julian (tsk_julian)) {
g_date_set_julian (date, tsk_julian);
age = syear - g_date_get_year (date);
if (age >= 0) {
if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == FALSE) {
g_date_subtract_days (date, 1);
}
g_date_set_year (date, syear);
if (g_date_compare (date, sdate) == 0) {
gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1);
utl_name_strcat (wbuf1, wbuf2, buf2);
g_snprintf (buf1, max_event_length, "\n%s (%d)", buf2, age);
g_strlcat (buffer, buf1, BUFFER_SIZE);
}
}
}
gtk_tree_path_next (path);
}
gtk_tree_path_free (path);
g_date_free (sdate);
g_date_free (date);
}
/* name days */
if (config.cal_print_namedays) {
model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store);
g_return_if_fail (model != NULL);
date = NULL;
date = g_date_new ();
g_return_if_fail (date != NULL);
sdate = NULL;
sdate = g_date_new_julian (julian);
g_return_if_fail (sdate != NULL);
syear = g_date_get_year (sdate);
path = gtk_tree_path_new_first ();
while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) {
gtk_tree_model_get (model, &iter, COLUMN_NAME_DAY_DATE, &tsk_julian, -1);
if (g_date_valid_julian (tsk_julian)) {
g_date_set_julian (date, tsk_julian);
if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == TRUE) {
g_date_set_year (date, syear);
if (g_date_compare (date, sdate) == 0) {
gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1);
utl_name_strcat (wbuf1, wbuf2, buf1);
g_snprintf (buf2, max_event_length, "\n%s (%s)", buf1, _("Name day"));
g_strlcat (buffer, buf2, BUFFER_SIZE);
}
}
}
gtk_tree_path_next (path);
}
gtk_tree_path_free (path);
g_date_free (sdate);
g_date_free (date);
}
#endif /* CONTACTS_ENABLED */
/* day note */
if (config.cal_print_day_notes) {
if (appGUI->cal->notes_list != NULL) {
wbuf1 = NULL;
reg = g_regex_new ("\n", 0, 0, NULL);
for (i = 0, lnode = appGUI->cal->notes_list; lnode != NULL; lnode = lnode->next, i++) {
a = g_slist_nth_data (appGUI->cal->notes_list, i);
if (a->date == julian) {
wbuf1 = g_regex_replace_literal (reg, a->note, -1, 0, " ", 0, NULL);
break;
}
}
g_regex_unref (reg);
}
if (wbuf1 != NULL) {
g_strstrip (wbuf1);
g_snprintf (buf1, max_event_length, "\n%s", wbuf1);
g_strlcat (buffer, buf1, BUFFER_SIZE);
g_free (wbuf1);
}
}
#ifdef HAVE_LIBICAL
/* ical */
if (config.cal_print_ical) {
}
#endif /* HAVE_LIBICAL */
g_strstrip (buffer);
}
/* "Add domain"-button was pressed */
static void _nojs_preferences_on_add_domain_clicked(NoJSPreferences *self,
gpointer *inUserData)
{
NoJSPreferencesPrivate *priv=self->priv;
gchar *domain;
const gchar *domainStart, *domainEnd;
gchar *realDomain;
GtkTreeIter policyIter;
g_return_if_fail(priv->database);
/* Get domain name entered */
domain=g_hostname_to_ascii(gtk_entry_get_text(GTK_ENTRY(priv->addDomainEntry)));
/* Trim whitespaces from start and end of entered domain name */
domainStart=domain;
while(*domainStart && g_ascii_isspace(*domainStart)) domainStart++;
domainEnd=domain+strlen(domain)-1;
while(*domainEnd && g_ascii_isspace(*domainEnd)) domainEnd--;
if(domainEnd<=domainStart) return;
/* Seperate domain name from whitespaces */
realDomain=g_strndup(domain, domainEnd-domainStart+1);
if(!realDomain) return;
/* Get policy from combo box */
if(gtk_combo_box_get_active_iter(GTK_COMBO_BOX(priv->addDomainPolicyCombo), &policyIter))
{
gchar *sql;
gchar *error=NULL;
gint success;
gint policy;
gchar *policyName;
/* Get policy value to set for domain */
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(priv->addDomainPolicyCombo)),
&policyIter,
0, &policy,
1, &policyName,
-1);
/* Add domain name and the selected policy to database */
sql=sqlite3_mprintf("INSERT OR REPLACE INTO policies (site, value) VALUES ('%q', %d);",
realDomain,
policy);
success=sqlite3_exec(priv->database, sql, NULL, NULL, &error);
/* Show error message if any */
if(success==SQLITE_OK)
{
gtk_list_store_append(priv->listStore, &policyIter);
gtk_list_store_set(priv->listStore,
&policyIter,
DOMAIN_COLUMN, realDomain,
POLICY_COLUMN, policyName,
-1);
}
else g_warning(_("SQL fails: %s"), error);
if(error) sqlite3_free(error);
/* Free allocated resources */
sqlite3_free(sql);
}
/* Free allocated resources */
g_free(realDomain);
g_free(domain);
}
static void
import_dialog_response_cb (GtkDialog *dialog,
int response_id,
gpointer user_data)
{
DialogData *data = user_data;
switch (response_id) {
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CANCEL:
gth_file_list_cancel (GTH_FILE_LIST (data->file_list), (DataFunc) gtk_widget_destroy, data->dialog);
break;
case GTK_RESPONSE_OK:
{
GtkTreeIter iter;
FacebookAlbum *album;
GList *file_list;
if (! gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("album_combobox")), &iter)) {
gtk_dialog_set_response_sensitive (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK, FALSE);
return;
}
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("album_liststore")), &iter,
ALBUM_DATA_COLUMN, &album,
-1);
file_list = get_files_to_download (data);
if (file_list != NULL) {
GSettings *settings;
GFile *destination;
gboolean single_subfolder;
GthSubfolderType subfolder_type;
GthSubfolderFormat subfolder_format;
char *custom_format;
GthTask *task;
settings = g_settings_new (GTHUMB_IMPORTER_SCHEMA);
destination = gth_import_preferences_get_destination ();
subfolder_type = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_TYPE);
subfolder_format = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_FORMAT);
single_subfolder = g_settings_get_boolean (settings, PREF_IMPORTER_SUBFOLDER_SINGLE);
custom_format = g_settings_get_string (settings, PREF_IMPORTER_SUBFOLDER_CUSTOM_FORMAT);
task = gth_import_task_new (data->browser,
file_list,
destination,
subfolder_type,
subfolder_format,
single_subfolder,
custom_format,
(album->name != NULL ? album->name : ""),
NULL,
FALSE,
FALSE,
FALSE);
gth_browser_exec_task (data->browser, task, GTH_TASK_FLAGS_DEFAULT);
gtk_widget_destroy (data->dialog);
g_object_unref (task);
_g_object_unref (destination);
g_object_unref (settings);
}
_g_object_list_unref (file_list);
g_object_unref (album);
}
break;
default:
break;
}
}
/**
* Drag-and-drop received.
*/
static void signal_dnd_recv(GtkTreeView *tv,
GdkDragContext *context,
int x, int y,
GtkSelectionData *selection,
guint info, guint time,
gpointer data)
{
GDeviceSetup *gds;
GtkTreeModel *model;
GtkTreeSelection *sel;
GtkTreeIter sel_iter, dest_iter, parent, ins_iter,
*final_parent, *final_sib;
GtkTreePath *path;
GtkTreeViewDropPosition pos;
int id, md_id;
int use, md_use;
gboolean status = False;
gds = (GDeviceSetup*)data;
model = gtk_tree_view_get_model(tv);
sel = gtk_tree_view_get_selection(tv);
if (!gtk_tree_selection_get_selected(sel, NULL, &sel_iter))
return;
gtk_tree_model_get(model, &sel_iter,
COL_ID, &id,
COL_USE, &use,
-1);
/* MD selected? */
if (use == XIMasterPointer || use == XIMasterKeyboard)
return;
if (!gtk_tree_view_get_dest_row_at_pos(tv, x, y, &path, &pos))
return;
gtk_tree_model_get_iter(model, &dest_iter, path);
/* check for parent, set final_parent to parent and final_sib to the
* sibling we're dropping onto. */
if (!gtk_tree_model_iter_parent(model, &parent, &dest_iter))
{
final_parent = &dest_iter;
final_sib = NULL;
} else
{
final_parent = &parent;
final_sib = &dest_iter;
}
gtk_tree_model_get(GTK_TREE_MODEL(model), final_parent,
COL_ID, &md_id, COL_USE, &md_use, -1);
g_debug("Trying to attach %d to %d\n", id, md_id);
/* try */
if(md_id == ID_FLOATING)
status = float_device(gds, id);
else
status = change_attachment(gds, id, md_id);
if(status)
toggle_undo_button(gds, TRUE);
}
/* Function to setup popup windows for Burst Buffer */
extern void popup_all_bb(GtkTreeModel *model, GtkTreeIter *iter, int id)
{
char *name = NULL;
char title[100];
ListIterator itr = NULL;
popup_info_t *popup_win = NULL;
GError *error = NULL;
gtk_tree_model_get(model, iter, SORTID_NAME, &name, -1);
switch(id) {
case INFO_PAGE:
snprintf(title, 100, "Full info for Burst Buffer %s", name);
break;
default:
g_print("Burst Buffer got %d\n", id);
}
itr = list_iterator_create(popup_list);
while ((popup_win = list_next(itr))) {
if (popup_win->spec_info)
if (!xstrcmp(popup_win->spec_info->title, title)) {
break;
}
}
list_iterator_destroy(itr);
if (!popup_win) {
if (id == INFO_PAGE) {
popup_win = create_popup_info(id, BB_PAGE, title);
} else {
popup_win = create_popup_info(BB_PAGE, id, title);
}
} else {
g_free(name);
gtk_window_present(GTK_WINDOW(popup_win->popup));
return;
}
/* Pass the model and the structs from the iter so we can always get
the current node_inx.
*/
popup_win->model = model;
popup_win->iter = *iter;
/* Sets up right click information */
switch(id) {
case JOB_PAGE:
case INFO_PAGE:
popup_win->spec_info->search_info->gchar_data = name;
specific_info_bb(popup_win);
break;
case BLOCK_PAGE:
case NODE_PAGE:
case PART_PAGE:
case SUBMIT_PAGE:
break;
default:
g_print("Burst Buffer got unknown type %d\n", id);
}
if (!sview_thread_new((gpointer)popup_thr, popup_win, false, &error)) {
g_printerr ("Failed to create burst buffer popup thread: %s\n",
error->message);
return;
}
}
static gboolean
category_filter_model_update( GtkTreeStore * store )
{
int i, n;
int low = 0;
int all = 0;
int high = 0;
int public = 0;
int normal = 0;
int private = 0;
int store_pos;
GtkTreeIter top;
GtkTreeIter iter;
GtkTreeModel * model = GTK_TREE_MODEL( store );
GPtrArray * hosts = g_ptr_array_new( );
GHashTable * hosts_hash = g_hash_table_new_full( g_str_hash, g_str_equal,
g_free, g_free );
GObject * o = G_OBJECT( store );
GtkTreeModel * tmodel = GTK_TREE_MODEL(
g_object_get_data( o, TORRENT_MODEL_KEY ) );
g_object_steal_data( o, DIRTY_KEY );
/* Walk through all the torrents, tallying how many matches there are
* for the various categories. Also make a sorted list of all tracker
* hosts s.t. we can merge it with the existing list */
if( gtk_tree_model_get_iter_first( tmodel, &iter )) do
{
tr_torrent * tor;
const tr_info * inf;
int keyCount;
char ** keys;
gtk_tree_model_get( tmodel, &iter, MC_TORRENT_RAW, &tor, -1 );
inf = tr_torrentInfo( tor );
keyCount = 0;
keys = g_new( char*, inf->trackerCount );
for( i=0, n=inf->trackerCount; i<n; ++i )
{
int k;
char * key = gtr_get_host_from_url( inf->trackers[i].announce );
int * count = g_hash_table_lookup( hosts_hash, key );
if( count == NULL )
{
count = tr_new0( int, 1 );
g_hash_table_insert( hosts_hash, g_strdup( key ), count );
g_ptr_array_add( hosts, g_strdup( key ) );
}
for( k=0; k<keyCount; ++k )
if( !strcmp( keys[k], key ) )
break;
if( k==keyCount )
keys[keyCount++] = key;
else
g_free( key );
}
for( i=0; i<keyCount; ++i )
{
int * incrementme = g_hash_table_lookup( hosts_hash, keys[i] );
++*incrementme;
g_free( keys[i] );
}
g_free( keys );
++all;
if( inf->isPrivate )
++private;
else
++public;
static gboolean ui_authenticate(dt_storage_facebook_gui_data_t *ui)
{
if(ui->facebook_api == NULL)
{
ui->facebook_api = fb_api_init();
}
FBContext *ctx = ui->facebook_api;
gboolean mustsaveaccount = FALSE;
gchar *uiselectedaccounttoken = NULL;
GtkTreeIter iter;
gtk_combo_box_get_active_iter(ui->comboBox_username, &iter);
GtkTreeModel *accountModel = gtk_combo_box_get_model(ui->comboBox_username);
gtk_tree_model_get(accountModel, &iter, 1, &uiselectedaccounttoken, -1);
g_free(ctx->token);
ctx->token = g_strdup(uiselectedaccounttoken);
// check selected token if we already have one
if(ctx->token != NULL && !fb_test_auth_token(ctx))
{
g_free(ctx->token);
ctx->token = NULL;
}
if(ctx->token == NULL)
{
mustsaveaccount = TRUE;
ctx->token = facebook_get_user_auth_token(ui); // ask user to log in
}
if(ctx->token == NULL) return FALSE;
if(mustsaveaccount)
{
FBAccountInfo *accountinfo = fb_get_account_info(ui->facebook_api);
g_return_val_if_fail(accountinfo != NULL, FALSE);
save_account_info(ui, accountinfo);
// add account to user list and select it
GtkListStore *model = GTK_LIST_STORE(gtk_combo_box_get_model(ui->comboBox_username));
GtkTreeIter iter;
gboolean r;
gchar *uid;
gboolean updated = FALSE;
for(r = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter); r == TRUE;
r = gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &iter))
{
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, COMBO_USER_MODEL_ID_COL, &uid, -1);
if(g_strcmp0(uid, accountinfo->id) == 0)
{
gtk_list_store_set(model, &iter, COMBO_USER_MODEL_NAME_COL, accountinfo->username,
COMBO_USER_MODEL_TOKEN_COL, accountinfo->token, -1);
updated = TRUE;
break;
}
}
if(!updated)
{
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter, COMBO_USER_MODEL_NAME_COL, accountinfo->username,
COMBO_USER_MODEL_TOKEN_COL, accountinfo->token, COMBO_USER_MODEL_ID_COL,
accountinfo->id, -1);
}
gtk_combo_box_set_active_iter(ui->comboBox_username, &iter);
// we have to re-set the current token here since ui_combo_username_changed is called
// on gtk_combo_box_set_active_iter (and thus is resetting the active token)
ctx->token = g_strdup(accountinfo->token);
fb_account_info_destroy(accountinfo);
}
return TRUE;
}
static gboolean
gtk_app_chooser_search_equal_func (GtkTreeModel *model,
gint column,
const gchar *key,
GtkTreeIter *iter,
gpointer user_data)
{
gchar *normalized_key;
gchar *name, *normalized_name;
gchar *path, *normalized_path;
gchar *basename, *normalized_basename;
gboolean ret;
if (key != NULL)
{
normalized_key = g_utf8_casefold (key, -1);
g_assert (normalized_key != NULL);
ret = TRUE;
gtk_tree_model_get (model, iter,
COLUMN_NAME, &name,
COLUMN_EXEC, &path,
-1);
if (name != NULL)
{
normalized_name = g_utf8_casefold (name, -1);
g_assert (normalized_name != NULL);
if (strncmp (normalized_name, normalized_key, strlen (normalized_key)) == 0)
ret = FALSE;
g_free (normalized_name);
}
if (ret && path != NULL)
{
normalized_path = g_utf8_casefold (path, -1);
g_assert (normalized_path != NULL);
basename = g_path_get_basename (path);
g_assert (basename != NULL);
normalized_basename = g_utf8_casefold (basename, -1);
g_assert (normalized_basename != NULL);
if (strncmp (normalized_path, normalized_key, strlen (normalized_key)) == 0 ||
strncmp (normalized_basename, normalized_key, strlen (normalized_key)) == 0)
ret = FALSE;
g_free (basename);
g_free (normalized_basename);
g_free (normalized_path);
}
g_free (name);
g_free (path);
g_free (normalized_key);
return ret;
}
else
{
return TRUE;
}
}
void add_ethernet_service(GtkWidget *mainbox, GtkTreeIter *iter, struct config_data *data)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
//GtkWidget *combo;
GtkWidget *entry;
GtkWidget *button;
struct ipv4_config ipv4_config = {
.method = NULL,
.address = NULL,
.netmask = NULL,
.gateway = NULL,
};
gtk_tree_model_get(data->model, iter,
CONNMAN_COLUMN_METHOD, &ipv4_config.method,
CONNMAN_COLUMN_ADDRESS, &ipv4_config.address,
CONNMAN_COLUMN_NETMASK, &ipv4_config.netmask,
CONNMAN_COLUMN_GATEWAY, &ipv4_config.gateway,
-1);
vbox = gtk_vbox_new(TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 24);
gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0);
table = gtk_table_new(5, 5, TRUE);
gtk_table_set_row_spacings(GTK_TABLE(table), 10);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
label = gtk_label_new(_("Configuration:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 0, 1);
//combo = gtk_combo_box_new_text();
//gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "DHCP");
//gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "MANUAL");
//gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo),
// separator_function, NULL, NULL);
//gtk_table_attach_defaults(GTK_TABLE(table), combo, 2, 4, 0, 1);
//data->policy.config = combo;
label = gtk_label_new(_("IP address:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 1, 2);
data->ipv4.label[0] = label;
entry = gtk_entry_new();
gtk_entry_set_max_length (GTK_ENTRY (entry), 15);
if (ipv4_config.address)
gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.address);
gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 1, 2);
data->ipv4.entry[0] = entry;
label = gtk_label_new(_("Netmask:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 2, 3);
data->ipv4.label[1] = label;
entry = gtk_entry_new();
gtk_entry_set_max_length (GTK_ENTRY (entry), 15);
if (ipv4_config.netmask)
gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.netmask);
gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 2, 3);
data->ipv4.entry[1] = entry;
label = gtk_label_new(_("Gateway:"));
gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 3, 4);
data->ipv4.label[2] = label;
entry = gtk_entry_new();
gtk_entry_set_max_length (GTK_ENTRY (entry), 15);
if (ipv4_config.gateway)
gtk_entry_set_text(GTK_ENTRY(entry), ipv4_config.gateway);
gtk_table_attach_defaults(GTK_TABLE(table), entry, 2, 4, 3, 4);
data->ipv4.entry[2] = entry;
data->ipv4_config = ipv4_config;
button = gtk_button_new_with_label(_("Apply"));
gtk_table_attach_defaults(GTK_TABLE(table), button, 3, 4, 4, 5);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(apply_callback), data);
data->button = button;
if (g_str_equal(ipv4_config.method, "dhcp") == TRUE)
update_ethernet_ipv4(data, CONNMAN_POLICY_DHCP);
else
update_ethernet_ipv4(data, CONNMAN_POLICY_MANUAL);
/* g_signal_connect(G_OBJECT(combo), "changed", */
/* G_CALLBACK(changed_callback), data); */
}
void prov_usl_vibor(GtkTreeSelection *selection,class prov_usl_data *data)
{
//printf("prov_usl_vibor\n");
GtkTreeModel *model;
GtkTreeIter iter;
if(gtk_tree_selection_get_selected(selection,&model,&iter) != TRUE)
return;
gchar *shet_d;
gchar *shet_k;
gchar *datap;
gchar *debet;
gchar *kredit;
gchar *koment;
gchar *kontr;
gint ktoz;
glong vrem;
gint val;
gint nomer;
gchar *kekv;
gtk_tree_model_get(model,&iter,
COL_SHET,&shet_d,
COL_SHET_KOR,&shet_k,
COL_DATA,&datap,
COL_DEBET,&debet,
COL_KREDIT,&kredit,
COL_KONTR,&kontr,
COL_KOMENT,&koment,
COL_KTOZ,&ktoz,
COL_VREM,&vrem,
COL_VAL,&val,
COL_KEKV,&kekv,
NUM_COLUMNS,&nomer,-1);
data->shet_v.new_plus(iceb_u_fromutf(shet_d));
data->shet_kor_v.new_plus(iceb_u_fromutf(shet_k));
data->kontr_v.new_plus(iceb_u_fromutf(kontr));
data->datap_v.new_plus(iceb_u_fromutf(datap));
data->koment_v.new_plus(iceb_u_fromutf(koment));
data->debet_v=atof(debet);
data->kredit_v=atof(kredit);
data->ktoz_v=ktoz;
data->vrem_v=vrem;
data->val_v=val;
data->snanomer=nomer;
data->kekv=atoi(kekv);
g_free(shet_d);
g_free(shet_k);
g_free(datap);
g_free(debet);
g_free(kredit);
g_free(kontr);
g_free(koment);
g_free(kekv);
/*
printf("%s %s %s %s %.2f %.2f %s %d\n",
data->datap_v.ravno(),
data->shet_v.ravno(),
data->shet_kor_v.ravno(),
data->kontr_v.ravno(),
data->debet_v,
data->kredit_v,
data->koment_v.ravno(),
data->snanomer);
*/
}
static gboolean
panel_run_dialog_find_command_idle (PanelRunDialog *dialog)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
char *text;
GIcon *found_icon;
char *found_name;
gboolean fuzzy;
model = GTK_TREE_MODEL (dialog->program_list_store);
path = gtk_tree_path_new_first ();
if (!path || !gtk_tree_model_get_iter (model, &iter, path)) {
if (path)
gtk_tree_path_free (path);
panel_run_dialog_set_icon (dialog, NULL, FALSE);
dialog->find_command_idle_id = 0;
return FALSE;
}
text = g_strdup (panel_run_dialog_get_combo_text (dialog));
found_icon = NULL;
found_name = NULL;
fuzzy = FALSE;
do {
char *exec = NULL;
GIcon *icon = NULL;
char *name = NULL;
char *comment = NULL;
gtk_tree_model_get (model, &iter,
COLUMN_EXEC, &exec,
COLUMN_GICON, &icon,
COLUMN_NAME, &name,
COLUMN_COMMENT, &comment,
-1);
if (!fuzzy && exec && icon &&
fuzzy_command_match (text, exec, &fuzzy)) {
g_clear_object (&found_icon);
g_free (found_name);
found_icon = g_object_ref (icon);
found_name = g_strdup (name);
gtk_list_store_set (dialog->program_list_store,
&iter,
COLUMN_VISIBLE, TRUE,
-1);
} else if (panel_g_utf8_strstrcase (exec, text) != NULL ||
panel_g_utf8_strstrcase (name, text) != NULL ||
panel_g_utf8_strstrcase (comment, text) != NULL) {
gtk_list_store_set (dialog->program_list_store,
&iter,
COLUMN_VISIBLE, TRUE,
-1);
} else {
gtk_list_store_set (dialog->program_list_store,
&iter,
COLUMN_VISIBLE, FALSE,
-1);
}
g_free (exec);
g_object_unref (icon);
g_free (name);
g_free (comment);
} while (gtk_tree_model_iter_next (model, &iter));
if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->program_list)),
&iter, path))
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->program_list),
path, NULL, FALSE, 0, 0);
gtk_tree_path_free (path);
panel_run_dialog_set_icon (dialog, found_icon, FALSE);
//FIXME update dialog->program_label
g_clear_object (&found_icon);
g_free (text);
g_free (dialog->item_name);
dialog->item_name = found_name;
dialog->find_command_idle_id = 0;
return FALSE;
}
void
IRC_Client_GUI_MessageHandler::remove (const std::string& nick_in)
{
RPG_TRACE (ACE_TEXT ("IRC_Client_GUI_MessageHandler::remove"));
// sanity check(s)
ACE_ASSERT (CBData_.GTKState);
ACE_Guard<ACE_Thread_Mutex> aGuard (CBData_.GTKState->lock);
Common_UI_GTKBuildersIterator_t iterator =
CBData_.GTKState->builders.find (builderLabel_);
// sanity check(s)
ACE_ASSERT (iterator != CBData_.GTKState->builders.end ());
// retrieve channel liststore handle
GtkListStore* list_store_p =
GTK_LIST_STORE (gtk_builder_get_object ((*iterator).second.second,
ACE_TEXT_ALWAYS_CHAR ("channel_liststore")));
ACE_ASSERT (list_store_p);
// step1: convert text
gchar* converted_nick_string = Common_UI_Tools::Locale2UTF8 (nick_in);
if (!converted_nick_string)
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to convert nickname: \"%s\", returning\n")));
return;
} // end IF
// step2: find matching entry
GtkTreeIter current_iter;
// GValue current_value;
gchar* current_value_string = NULL;
if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store_p),
¤t_iter))
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to gtk_tree_model_get_iter_first(%@), returning\n"),
list_store_p));
// clean up
g_free (converted_nick_string);
return;
} // end IF
bool found_row = false;
do
{
current_value_string = NULL;
// retrieve value
// gtk_tree_model_get_value(GTK_TREE_MODEL(list_store_p),
// current_iter,
// 0, ¤t_value);
gtk_tree_model_get (GTK_TREE_MODEL (list_store_p),
¤t_iter,
0, ¤t_value_string,
-1);
if (g_str_equal (current_value_string,
converted_nick_string) ||
(g_str_has_suffix (current_value_string,
converted_nick_string) &&
((current_value_string[0] == '@'))))
found_row = true;
// clean up
g_free (current_value_string);
if (found_row)
break; // found value
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store_p),
¤t_iter));
// clean up
g_free (converted_nick_string);
if (found_row)
gtk_list_store_remove (list_store_p,
¤t_iter);
else
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("failed to remove nick (was: \"%s\"), aborting\n"),
ACE_TEXT (nick_in.c_str ())));
}
static void
program_list_selection_changed (GtkTreeSelection *selection,
PanelRunDialog *dialog)
{
GtkTreeModel *filter_model;
GtkTreeModel *child_model;
GtkTreeIter iter;
GtkTreeIter filter_iter;
char *temp;
char *path, *stripped;
gboolean terminal;
GKeyFile *key_file;
GtkWidget *entry;
if (!gtk_tree_selection_get_selected (selection, &filter_model,
&filter_iter))
return;
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (filter_model),
&iter, &filter_iter);
path = NULL;
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
gtk_tree_model_get (child_model, &iter,
COLUMN_PATH, &path,
-1);
if (!path)
return;
key_file = g_key_file_new ();
if (!g_key_file_load_from_file (key_file, path,
G_KEY_FILE_NONE, NULL)) {
g_key_file_free (key_file);
g_free (path);
return;
}
dialog->use_program_list = TRUE;
if (dialog->desktop_path)
g_free (dialog->desktop_path);
dialog->desktop_path = g_strdup (path);
if (dialog->item_name)
g_free (dialog->item_name);
dialog->item_name = NULL;
/* Order is important here. We have to set the text first so that the
* drag source is enabled, otherwise the drag icon can't be set by
* panel_run_dialog_set_icon.
*/
entry = gtk_bin_get_child (GTK_BIN (dialog->combobox));
temp = panel_key_file_get_string (key_file, "Exec");
if (temp) {
stripped = remove_parameters (temp);
gtk_entry_set_text (GTK_ENTRY (entry), stripped);
g_free (stripped);
} else {
temp = panel_key_file_get_string (key_file, "URL");
gtk_entry_set_text (GTK_ENTRY (entry), sure_string (temp));
}
g_free (temp);
temp = panel_key_file_get_locale_string (key_file, "Icon");
GIcon *icon = panel_gicon_from_icon_name (temp);
panel_run_dialog_set_icon (dialog, icon, FALSE);
g_object_unref (icon);
g_free (temp);
temp = panel_key_file_get_locale_string (key_file, "Comment");
//FIXME: if sure_string () == "", we should display "Will run..." as in entry_changed()
gtk_label_set_text (GTK_LABEL (dialog->program_label),
sure_string (temp));
g_free (temp);
terminal = panel_key_file_get_boolean (key_file, "Terminal", FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->terminal_checkbox),
terminal);
g_key_file_free (key_file);
g_free (path);
}
static void
import_dialog_response_cb (GtkDialog *dialog,
int response_id,
gpointer user_data)
{
DialogData *data = user_data;
switch (response_id) {
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CANCEL:
gth_file_list_cancel (GTH_FILE_LIST (data->file_list), (DataFunc) gtk_widget_destroy, data->dialog);
break;
case GTK_RESPONSE_OK:
{
GtkTreeIter iter;
PicasaWebAlbum *album;
GList *file_list;
if (! gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("album_combobox")), &iter)) {
gtk_dialog_set_response_sensitive (GTK_DIALOG (data->dialog),
GTK_RESPONSE_OK,
FALSE);
return;
}
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("album_liststore")), &iter,
ALBUM_DATA_COLUMN, &album,
-1);
file_list = get_files_to_download (data);
if (file_list != NULL) {
GFile *destination;
GError *error = NULL;
GSettings *settings;
gboolean single_subfolder;
GthSubfolderType subfolder_type;
GthSubfolderFormat subfolder_format;
char *custom_format;
char **tags;
int i;
GthTask *task;
destination = gth_import_preferences_get_destination ();
if (! gth_import_task_check_free_space (destination, file_list, &error)) {
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (data->dialog),
_("Could not import the files"),
error);
g_clear_error (&error);
_g_object_unref (destination);
_g_object_list_unref (file_list);
g_object_unref (album);
return;
}
settings = g_settings_new (GTHUMB_IMPORTER_SCHEMA);
subfolder_type = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_TYPE);
subfolder_format = g_settings_get_enum (settings, PREF_IMPORTER_SUBFOLDER_FORMAT);
single_subfolder = g_settings_get_boolean (settings, PREF_IMPORTER_SUBFOLDER_SINGLE);
custom_format = g_settings_get_string (settings, PREF_IMPORTER_SUBFOLDER_CUSTOM_FORMAT);
tags = g_strsplit ((album->keywords != NULL ? album->keywords : ""), ",", -1);
for (i = 0; tags[i] != NULL; i++)
tags[i] = g_strstrip (tags[i]);
task = gth_import_task_new (data->browser,
file_list,
destination,
subfolder_type,
subfolder_format,
single_subfolder,
custom_format,
(album->title != NULL ? album->title : ""),
tags,
FALSE,
FALSE,
FALSE);
gth_browser_exec_task (data->browser, task, GTH_TASK_FLAGS_DEFAULT);
gtk_widget_destroy (data->dialog);
g_object_unref (task);
g_strfreev (tags);
g_object_unref (settings);
_g_object_unref (destination);
}
_g_object_list_unref (file_list);
g_object_unref (album);
}
break;
default:
break;
}
}
static void _nojs_preferences_on_policy_edited(NoJSPreferences *self,
gchar *path,
gchar *newText,
gpointer *inUserData)
{
NoJSPreferencesPrivate *priv=self->priv;
gchar *domain;
GtkTreeIter iter;
GtkTreeIter policyIter;
g_return_if_fail(priv->database);
if (priv->editingCombo == NULL) return;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(priv->listStore), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(priv->listStore),
&iter,
DOMAIN_COLUMN, &domain,
-1);
/* Get policy from combo box */
if(gtk_combo_box_get_active_iter(GTK_COMBO_BOX(priv->editingCombo), &policyIter))
{
gchar *sql;
gchar *error=NULL;
gint success;
gint policy;
gchar *policyName;
/* Get policy value to set for domain */
gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(priv->editingCombo)),
&policyIter,
0, &policy,
1, &policyName,
-1);
g_return_if_fail(g_strcmp0(policyName, newText)==0);
/* Add domain name and the selected policy to database */
sql=sqlite3_mprintf("UPDATE policies SET value = %d WHERE site = '%q';",
policy,
domain);
success=sqlite3_exec(priv->database, sql, NULL, NULL, &error);
/* Show error message if any */
if(success==SQLITE_OK)
{
gtk_list_store_set(priv->listStore,
&iter,
POLICY_COLUMN, newText,
-1);
}
else g_warning(_("SQL fails: %s"), error);
if(error) sqlite3_free(error);
/* Free allocated resources */
sqlite3_free(sql);
}
priv->editingCombo=NULL;
}
static void changed_cb(GtkTreeSelection * selection, gpointer conv)
{
g_return_if_fail(selection != NULL);
g_return_if_fail(conv != NULL);
GaimConversation *c = (GaimConversation *) conv;
GaymBuddy *cm;
struct gaym_conn *gaym = c->account->gc->proto_data;
GtkTreeIter iter;
GtkTreeModel *model;
gchar *name;
if (!gtk_tree_selection_get_selected(selection, &model, &iter))
return;
gtk_tree_model_get(model, &iter, CHAT_USERS_NAME_COLUMN, &name, -1);
/* Remove the current icon stuff */
GaymChatIcon *icon_data = g_hash_table_lookup(icons, c);
if (icon_data->event != NULL)
gtk_widget_destroy(icon_data->event);
icon_data->event = NULL;
char *dir = g_build_filename(gaim_user_dir(), "icons", "gaym", NULL);
char *filename = g_strdup_printf("%s.jpg", name);
char *path = NULL;
FILE *file;
struct stat st;
struct fetch_thumbnail_data *data =
g_new0(struct fetch_thumbnail_data, 1);
path = g_build_filename(dir, filename, NULL);
if (path && !g_stat(path, &st)) {
if (file = g_fopen(path, "rb")) {
data->pic_data = g_malloc(st.st_size);
data->who = name;
data->pic_data_len = st.st_size;
data->from_file = TRUE;
fread(data->pic_data, 1, st.st_size, file);
fclose(file);
}
g_free(dir);
g_free(filename);
g_free(path);
gaym_gtkconv_update_thumbnail(c, data);
fetch_thumbnail_cb(data, data->pic_data, data->pic_data_len);
return;
}
// Get GaymBuddy struct for the thumbnail URL.
cm = g_hash_table_lookup(gaym->channel_members, name);
if (!cm)
return;
// Fetch thumbnail.
char *hashurl = g_hash_table_lookup(gaym->confighash,
"mini-profile-panel.thumbnail-prefix");
data = g_new0(struct fetch_thumbnail_data, 1);
data->who = name;
data->from_file = FALSE;
char *url = g_strdup_printf("%s%s", hashurl, cm->thumbnail);
gaim_url_fetch(url, FALSE, "Mozilla/4.0", FALSE,
fetch_thumbnail_cb, data);
// Add entry to hash table for tracking.
g_hash_table_replace(pending_updates, c, name);
}
void gmpv_mpv_load( GmpvMpv *mpv,
const gchar *uri,
gboolean append,
gboolean update )
{
const gchar *load_cmd[] = {"loadfile", NULL, NULL, NULL};
GtkListStore *playlist_store = gmpv_playlist_get_store(mpv->playlist);
GtkTreeIter iter;
gboolean empty;
g_info( "Loading file (append=%s, update=%s): %s",
append?"TRUE":"FALSE",
update?"TRUE":"FALSE",
uri?:"<PLAYLIST_ITEMS>" );
empty = !gtk_tree_model_get_iter_first
(GTK_TREE_MODEL(playlist_store), &iter);
load_cmd[2] = (append && !empty)?"append":"replace";
if(!append && uri && update)
{
gmpv_playlist_clear(mpv->playlist);
mpv->state.new_file = TRUE;
mpv->state.loaded = FALSE;
}
if(!uri)
{
gboolean append = FALSE;
gboolean rc;
if(!mpv->state.init_load)
{
gmpv_mpv_set_property_flag(mpv, "pause", FALSE);
}
rc = gtk_tree_model_get_iter_first
(GTK_TREE_MODEL(playlist_store), &iter);
while(rc)
{
gchar *uri;
gtk_tree_model_get( GTK_TREE_MODEL(playlist_store),
&iter,
PLAYLIST_URI_COLUMN,
&uri,
-1 );
/* append = FALSE only on first iteration */
gmpv_mpv_load(mpv, uri, append, FALSE);
append = TRUE;
rc = gtk_tree_model_iter_next
(GTK_TREE_MODEL(playlist_store), &iter);
g_free(uri);
}
}
if(uri && playlist_store)
{
gchar *path = get_path_from_uri(uri);
load_cmd[1] = path;
if(!append)
{
mpv->state.loaded = FALSE;
if(!mpv->state.init_load)
{
gmpv_mpv_set_property_flag
(mpv, "pause", FALSE);
}
}
if(update)
{
gchar *name = get_name_from_path(path);
gmpv_playlist_append(mpv->playlist, name, uri);
g_free(name);
}
g_assert(mpv->mpv_ctx);
mpv_check_error(mpv_request_event( mpv->mpv_ctx,
MPV_EVENT_END_FILE,
0 ));
mpv_check_error(mpv_command(mpv->mpv_ctx, load_cmd));
mpv_check_error(mpv_request_event( mpv->mpv_ctx,
MPV_EVENT_END_FILE,
1 ));
g_free(path);
}
}
