static void
grilo_browse_cb (GrlSource *grilo_source, guint operation_id, GrlMedia *media, guint remaining, RBGriloSource *source, const GError *error)
{
if (operation_id != source->priv->browse_op) {
return;
}
if (error != NULL) {
/* do something? */
rb_debug ("got error for %s: %s", grl_source_get_name (grilo_source), error->message);
source->priv->browse_op = 0;
return;
}
if (media != NULL) {
source->priv->browse_got_results = TRUE;
source->priv->browse_position++;
}
if (media && GRL_IS_MEDIA_BOX (media)) {
GtkTreeIter new_row;
if (source->priv->browse_container == NULL) {
/* insert at the end */
gtk_tree_store_insert_with_values (source->priv->browser_model,
&new_row,
NULL,
-1,
0, g_object_ref (media),
1, grl_media_get_title (media),
2, CONTAINER_UNKNOWN_MEDIA,
3, 0,
-1);
} else {
int n;
/* insert before the expand marker row */
n = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (source->priv->browser_model),
&source->priv->browse_container_iter);
gtk_tree_store_insert_with_values (source->priv->browser_model,
&new_row,
&source->priv->browse_container_iter,
n - 1,
0, g_object_ref (media),
1, grl_media_get_title (media),
2, CONTAINER_UNKNOWN_MEDIA,
3, 0,
-1);
}
/* and insert an expand marker below it too */
gtk_tree_store_insert_with_values (source->priv->browser_model,
NULL,
&new_row,
-1,
0, NULL,
1, "...", /* needs to be translatable? */
2, CONTAINER_MARKER,
3, 0,
-1);
} else if (media && GRL_IS_MEDIA_AUDIO (media)) {
source->priv->browse_got_media = TRUE;
}
if (remaining == 0) {
source->priv->browse_op = 0;
if (source->priv->browse_got_results == FALSE &&
source->priv->browse_container != NULL) {
/* no more results for this container, so delete the marker row */
delete_marker_row (source, &source->priv->browse_container_iter);
set_container_type (source,
&source->priv->browse_container_iter,
FALSE);
gtk_tree_store_set (source->priv->browser_model,
&source->priv->browse_container_iter,
3, -1,
-1);
} else if (source->priv->browse_container != NULL) {
if (source->priv->browse_got_media) {
set_container_type (source,
&source->priv->browse_container_iter,
TRUE);
}
if (source->priv->browse_position >= CONTAINER_GIVE_UP_POINT &&
gtk_tree_model_iter_n_children (GTK_TREE_MODEL (source->priv->browser_model),
&source->priv->browse_container_iter) == 1) {
/* no containers yet, so remove the marker row */
delete_marker_row (source, &source->priv->browse_container_iter);
} else {
/* store browse position for next time we want more */
gtk_tree_store_set (source->priv->browser_model,
&source->priv->browse_container_iter,
3, source->priv->browse_position,
-1);
maybe_expand_container (source);
}
} else if (source->priv->browse_container == NULL) {
if (source->priv->browse_got_results) {
/* get all top-level containers */
browse_next (source);
} else if (source->priv->browse_got_media) {
GtkTreeIter root_iter;
GtkTreeSelection *selection;
/* root container has media, so show it in the browser */
gtk_tree_store_insert_with_values (source->priv->browser_model,
&root_iter,
NULL,
0,
0, NULL,
1, grl_source_get_name (source->priv->grilo_source),
2, CONTAINER_HAS_MEDIA,
3, 0,
-1);
/* select it, so we start fetching the media */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view));
gtk_tree_selection_select_iter (selection, &root_iter);
}
}
}
}
static void
status_menu_clear_status_message_dialog_run (StatusMenu *self)
{
GtkTreeIter iter, liter;
GSList *conf_list [3] = { NULL, NULL, NULL };
GtkWidget *dialog = NULL;
GtkWidget *vbox = NULL;
GtkWidget *frame = NULL;
GtkWidget *tree_view = NULL;
GdkPixbuf *pixbuf = NULL;
GtkTreeSelection *selection = NULL;
GtkListStore *list_store = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget *label = NULL;
bool found = false;
bool close = false;
int response = 0;
int i = 0;
gchar *message = NULL;
gchar *presence = NULL;
gchar *status = NULL;
// Current status
presence = gm_conf_get_string (PERSONAL_DATA_KEY "short_status");
status = gm_conf_get_string (PERSONAL_DATA_KEY "long_status");
// Build the dialog
dialog = gtk_dialog_new_with_buttons (_("Custom Message"),
self->priv->parent,
(GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_DELETE,
GTK_RESPONSE_APPLY,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DELETE);
vbox = gtk_vbox_new (false, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), vbox, false, false, 2);
label = gtk_label_new (_("Delete custom messages:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, false, false, 2);
list_store = gtk_list_store_new (3,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_INT);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), false);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", 0,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", 1,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (frame), tree_view);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 2);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->priv->list_store), &iter)) {
do {
gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter,
COL_MESSAGE_TYPE, &i, -1);
if (i == TYPE_CUSTOM_ONLINE || i == TYPE_CUSTOM_AWAY || i == TYPE_CUSTOM_DND) {
gtk_tree_model_get (GTK_TREE_MODEL (self->priv->list_store), &iter,
COL_ICON, &pixbuf,
COL_MESSAGE, &message,
-1);
gtk_list_store_append (GTK_LIST_STORE (list_store), &liter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &liter,
COL_ICON, pixbuf,
COL_MESSAGE, message,
COL_MESSAGE_TYPE, i,
-1);
g_free (message);
g_object_unref (pixbuf);
}
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (self->priv->list_store), &iter));
}
// Select the first iter
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
gtk_tree_selection_select_iter (selection, &iter);
gtk_widget_show_all (dialog);
while (!close) {
response = gtk_dialog_run (GTK_DIALOG (dialog));
switch (response)
{
case GTK_RESPONSE_APPLY:
if (gtk_tree_selection_get_selected (selection, NULL, &iter))
gtk_list_store_remove (GTK_LIST_STORE (list_store), &iter);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
gtk_tree_selection_select_iter (selection, &iter);
else
close = true;
break;
case GTK_RESPONSE_CLOSE:
default:
close = true;
}
}
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter)) {
do {
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1, &message,
2, &i, -1);
if (status && message && !strcmp (status, message))
found = true;
conf_list[i - NUM_STATUS_TYPES - 1] = g_slist_append (conf_list[i - NUM_STATUS_TYPES - 1], g_strdup (message));
g_free (message);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter));
}
for (int j = 0 ; j < 3 ; j++) {
gm_conf_set_string_list (status_types_keys[j], conf_list[j]);
g_slist_foreach (conf_list[j], (GFunc) g_free, NULL);
g_slist_free (conf_list[j]);
}
if (!found) {
// Reset current config
self->priv->personal_details->set_presence_info ("online", "");
}
gtk_widget_destroy (dialog);
}
bool SidebarIndexPage::selectPageNr(size_t page, size_t pdfPage, GtkTreeIter* parent)
{
XOJ_CHECK_TYPE(SidebarIndexPage);
GtkTreeIter iter;
Document* doc = control->getDocument();
doc->lock();
GtkTreeModel* model = doc->getContentsModel();
if (model == NULL)
{
doc->unlock();
return false;
}
g_object_ref(model);
doc->unlock();
if (parent == NULL)
{
// check if there is already the current page selected
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeViewBookmarks));
if (gtk_tree_selection_get_selected(selection, &model, &iter))
{
XojLinkDest* link = NULL;
gtk_tree_model_get(model, &iter, DOCUMENT_LINKS_COLUMN_LINK, &link, -1);
if (link && link->dest)
{
LinkDestination* dest = link->dest;
if (dest->getPdfPage() == pdfPage)
{
g_object_unref(model);
g_object_unref(link);
// already bookmak from this page selected
return true;
}
}
g_object_unref(link);
}
}
gboolean valid = gtk_tree_model_iter_children(model, &iter, parent);
while (valid)
{
XojLinkDest* link = NULL;
gtk_tree_model_get(model, &iter, DOCUMENT_LINKS_COLUMN_LINK, &link, -1);
if (link->dest->getPdfPage() == pdfPage)
{
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeViewBookmarks));
gtk_tree_selection_select_iter(selection, &iter);
g_object_unref(link);
g_object_unref(model);
return true;
}
else
{
g_object_unref(link);
if (selectPageNr(page, pdfPage, &iter))
{
g_object_unref(model);
return true;
}
else
{
valid = gtk_tree_model_iter_next(model, &iter);
}
}
}
g_object_unref(model);
return false;
}
static void _xfdashboard_settings_xfconf_changed_theme(XfdashboardSettings *self,
const gchar *inProperty,
const GValue *inValue,
XfconfChannel *inChannel)
{
XfdashboardSettingsPrivate *priv;
const gchar *newValue;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean selectionFound;
g_return_if_fail(XFDASHBOARD_IS_SETTINGS(self));
g_return_if_fail(inValue);
g_return_if_fail(XFCONF_IS_CHANNEL(inChannel));
priv=self->priv;
newValue=DEFAULT_THEME;
/* Get new value to set at widget */
if(G_LIKELY(G_VALUE_TYPE(inValue)==G_TYPE_STRING)) newValue=g_value_get_string(inValue);
/* Iterate through themes' model and lookup matching item
* against new theme name and select it
*/
selectionFound=FALSE;
model=gtk_tree_view_get_model(GTK_TREE_VIEW(priv->widgetThemes));
if(newValue && gtk_tree_model_get_iter_first(model, &iter))
{
do
{
gchar *value;
gtk_tree_model_get(model,
&iter,
COLUMN_THEME_NAME, &value,
-1);
if(G_UNLIKELY(g_str_equal(value, newValue)))
{
GtkTreePath *selectionPath;
selectionPath=gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->widgetThemes)), &iter);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(priv->widgetThemes), selectionPath, NULL, TRUE, 0.5, 0.5);
gtk_tree_path_free(selectionPath);
selectionFound=TRUE;
}
g_free(value);
}
while(!selectionFound && gtk_tree_model_iter_next(model, &iter));
}
/* If no selection was found, deselect any selected entry at widget */
if(!selectionFound)
{
GtkTreeSelection *selection;
selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->widgetThemes));
gtk_tree_selection_unselect_all(selection);
}
}
static void
goa_panel_init (GoaPanel *panel)
{
GtkWidget *button;
GtkWidget *w;
GError *error;
GtkStyleContext *context;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter iter;
panel->builder = gtk_builder_new ();
error = NULL;
if (gtk_builder_add_from_file (panel->builder,
CINNAMONCC_UI_DIR "/online-accounts.ui",
&error) == 0)
{
goa_warning ("Error loading UI file: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
goto out;
}
panel->toolbar = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbar"));
panel->toolbar_add_button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbutton-add"));
g_signal_connect (panel->toolbar_add_button,
"clicked",
G_CALLBACK (on_toolbar_add_button_clicked),
panel);
panel->toolbar_remove_button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-toolbutton-remove"));
g_signal_connect (panel->toolbar_remove_button,
"clicked",
G_CALLBACK (on_toolbar_remove_button_clicked),
panel);
context = gtk_widget_get_style_context (GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-scrolledwindow")));
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
context = gtk_widget_get_style_context (panel->toolbar);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
panel->accounts_treeview = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-tree-treeview"));
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)),
"changed",
G_CALLBACK (on_tree_view_selection_changed),
panel);
button = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-button-add"));
g_signal_connect (button,
"clicked",
G_CALLBACK (on_add_button_clicked),
panel);
panel->accounts_vbox = GTK_WIDGET (gtk_builder_get_object (panel->builder, "accounts-vbox"));
/* TODO: probably want to avoid _sync() ... */
error = NULL;
panel->client = goa_client_new_sync (NULL /* GCancellable */, &error);
if (panel->client == NULL)
{
goa_warning ("Error getting a GoaClient: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "goa-top-widget"));
gtk_widget_set_sensitive (w, FALSE);
g_error_free (error);
goto out;
}
g_signal_connect (panel->client,
"account-changed",
G_CALLBACK (on_account_changed),
panel);
panel->accounts_model = goa_panel_accounts_model_new (panel->client);
gtk_tree_view_set_model (GTK_TREE_VIEW (panel->accounts_treeview), GTK_TREE_MODEL (panel->accounts_model));
g_signal_connect (panel->accounts_model, "row-deleted", G_CALLBACK (on_model_row_deleted), panel);
g_signal_connect (panel->accounts_model, "row-inserted", G_CALLBACK (on_model_row_inserted), panel);
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (panel->accounts_treeview), column);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
g_object_set (G_OBJECT (renderer),
"stock-size", GTK_ICON_SIZE_DIALOG,
NULL);
gtk_tree_view_column_set_attributes (column,
renderer,
"gicon", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_ICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
g_object_set (G_OBJECT (renderer),
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
"width-chars", 30,
NULL);
gtk_tree_view_column_set_attributes (column,
renderer,
"markup", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_MARKUP,
NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_end (column, renderer, FALSE);
g_object_set (G_OBJECT (renderer),
"icon-name", "dialog-error-symbolic",
NULL);
gtk_tree_view_column_set_attributes (column,
renderer,
"visible", GOA_PANEL_ACCOUNTS_MODEL_COLUMN_ATTENTION_NEEDED,
NULL);
/* Select the first row, if any */
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (panel->accounts_model),
&iter))
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)),
&iter);
out:
w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "goa-top-widget"));
gtk_widget_reparent (w, GTK_WIDGET (panel));
gtk_widget_show_all (w);
}
static void
fill_data (gint n_columns)
{
GtkTreeIter iter;
GtkListStore *model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (list_view)));
GIOChannel *channel;
if (options.extra_data && *options.extra_data)
{
gchar **args = options.extra_data;
gint i = 0;
gtk_widget_freeze_child_notify (list_view);
while (args[i] != NULL)
{
gint j;
gtk_list_store_append (model, &iter);
for (j = 0; j < n_columns; j++, i++)
{
YadColumn *col = (YadColumn *) g_slist_nth_data (options.list_data.columns, j);
GdkPixbuf *pb;
if (args[i] == NULL)
break;
switch (col->type)
{
case YAD_COLUMN_CHECK:
case YAD_COLUMN_RADIO:
if (strcasecmp ((gchar *) args[i], "true") == 0)
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, TRUE, -1);
else
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, FALSE, -1);
break;
case YAD_COLUMN_NUM:
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, g_ascii_strtoll (args[i], NULL, 10), -1);
break;
case YAD_COLUMN_FLOAT:
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, g_ascii_strtod (args[i], NULL), -1);
break;
case YAD_COLUMN_IMAGE:
pb = get_pixbuf (args[i], YAD_SMALL_ICON);
if (pb)
{
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, pb, -1);
g_object_unref (pb);
}
break;
default:
gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, args[i], -1);
break;
}
}
}
gtk_widget_thaw_child_notify (list_view);
if (settings.always_selected)
{
GtkTreeIter it;
GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (list_view));
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (list_view));
gtk_tree_model_get_iter_first (model, &it);
gtk_tree_selection_select_iter (sel, &it);
}
}
if (options.common_data.listen || !(options.extra_data && *options.extra_data))
{
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, GINT_TO_POINTER (n_columns));
}
}
void xa_create_open_with_dialog(gchar *filename,gchar *filenames,int nr)
{
Open_with_data *data = NULL;
GtkWidget *dialog_vbox1,*vbox1,*hbox1,*mime_icon,*open_text,*scrolledwindow1,*apps_treeview,*dialog_action_area1,
*custom_command_expander,*hbox_expander,*browse,*cancelbutton1,*okbutton1;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
gchar *text = NULL;
gchar *title;
const gchar *icon_name = NULL;
const gchar* const *desktop_dirs;
gint x = 0;
data = g_new0(Open_with_data,1);
data->file_list = filenames;
data->dialog1 = gtk_dialog_new ();
if (nr == 1)
title = _("Open With");
else
title = _("Open the selected files with");
gtk_window_set_title (GTK_WINDOW (data->dialog1),title);
gtk_window_set_position (GTK_WINDOW (data->dialog1), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal (GTK_WINDOW (data->dialog1), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (data->dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_transient_for(GTK_WINDOW(data->dialog1),GTK_WINDOW(xa_main_window));
gtk_dialog_set_has_separator (GTK_DIALOG (data->dialog1),FALSE);
gtk_container_set_border_width (GTK_CONTAINER (data->dialog1),5);
gtk_widget_set_size_request(data->dialog1,380,380);
dialog_vbox1 = GTK_DIALOG (data->dialog1)->vbox;
vbox1 = gtk_vbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (dialog_vbox1),vbox1,TRUE,TRUE,0);
hbox1 = gtk_hbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (vbox1),hbox1,FALSE,FALSE,0);
if (nr == 1)
{
icon_name = xa_get_stock_mime_icon(filename);
pixbuf = gtk_icon_theme_load_icon(icon_theme,icon_name,40,0,NULL);
mime_icon = gtk_image_new_from_pixbuf(pixbuf);
if (pixbuf)
g_object_unref(pixbuf);
gtk_box_pack_start (GTK_BOX (hbox1),mime_icon,FALSE,TRUE,0);
gtk_misc_set_alignment (GTK_MISC (mime_icon),0,0);
open_text = gtk_label_new("");
gtk_box_pack_start (GTK_BOX (hbox1),open_text,FALSE,FALSE,10);
text = g_strdup_printf(_("Open <i>%s</i> with:"),filename);
gtk_label_set_use_markup (GTK_LABEL (open_text),TRUE);
gtk_label_set_markup (GTK_LABEL (open_text),text);
g_free(text);
}
scrolledwindow1 = gtk_scrolled_window_new (NULL,NULL);
gtk_box_pack_start (GTK_BOX (vbox1),scrolledwindow1,TRUE,TRUE,0);
g_object_set (G_OBJECT (scrolledwindow1),"hscrollbar-policy",GTK_POLICY_AUTOMATIC,"shadow-type",GTK_SHADOW_IN,"vscrollbar-policy",GTK_POLICY_AUTOMATIC,NULL);
data->apps_liststore = gtk_list_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING);
apps_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(data->apps_liststore));
gtk_container_add (GTK_CONTAINER (scrolledwindow1),apps_treeview);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_treeview),FALSE);
GtkTreeSelection *sel = gtk_tree_view_get_selection( GTK_TREE_VIEW (apps_treeview));
g_signal_connect ((gpointer) sel,"changed",G_CALLBACK (xa_open_with_dialog_selection_changed),data);
/* First column: icon + text */
column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column,renderer, FALSE);
gtk_tree_view_column_set_attributes(column,renderer,"pixbuf",0,NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start(column,renderer, TRUE);
gtk_tree_view_column_set_attributes( column,renderer,"text",1,NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(data->apps_liststore),1,GTK_SORT_ASCENDING);
gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
/* Hidden column with the application executable name */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_visible(column,FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column);
custom_command_expander = gtk_expander_new_with_mnemonic(_("Use a custom command:"));
gtk_box_pack_start (GTK_BOX (vbox1),custom_command_expander,FALSE,FALSE,0);
hbox_expander = gtk_hbox_new(FALSE,5);
data->custom_command_entry = gtk_entry_new();
g_signal_connect (G_OBJECT (data->custom_command_entry),"activate",G_CALLBACK (xa_open_with_dialog_custom_entry_activated),data);
browse = gtk_button_new_with_label(_("Browse"));
g_signal_connect (G_OBJECT (browse),"clicked",G_CALLBACK (xa_open_with_dialog_browse_custom_command),data);
gtk_box_pack_start (GTK_BOX (hbox_expander),data->custom_command_entry,TRUE,TRUE,0);
gtk_box_pack_start (GTK_BOX (hbox_expander),browse,FALSE,TRUE,0);
gtk_container_add(GTK_CONTAINER(custom_command_expander),hbox_expander);
dialog_action_area1 = GTK_DIALOG (data->dialog1)->action_area;
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1),GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),cancelbutton1,GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
g_signal_connect_swapped (G_OBJECT (cancelbutton1),"clicked",G_CALLBACK (gtk_widget_destroy),G_OBJECT(data->dialog1));
okbutton1 = gtk_button_new_from_stock ("gtk-open");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),okbutton1,GTK_RESPONSE_OK);
g_signal_connect (G_OBJECT (okbutton1),"clicked",G_CALLBACK (xa_open_with_dialog_execute_command),data);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
gtk_widget_show_all(data->dialog1);
/* Let's parse the desktop files in all the system data dirs */
desktop_dirs = g_get_system_data_dirs();
while (desktop_dirs[x])
{
xa_read_desktop_directories(data->apps_liststore,desktop_dirs[x]);
x++;
}
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->apps_liststore),&iter);
gtk_tree_selection_select_iter(gtk_tree_view_get_selection (GTK_TREE_VIEW (apps_treeview)),&iter);
g_signal_connect (G_OBJECT (apps_treeview), "row-activated",G_CALLBACK(xa_open_with_dialog_row_selected),data);
g_signal_connect (G_OBJECT (data->dialog1), "destroy", G_CALLBACK(xa_destroy_open_with_dialog),data);
}
/*
* Open the window to select and type the picture properties
*/
void Picture_Properties_Button_Clicked (GObject *object)
{
GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow;
GtkWidget *type, *label, *desc;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkListStore *store;
GtkTreeIter type_iter_to_select, iter;
GtkTreeModel *model;
GtkWindow *parent_window = NULL;
GList *selection_list = NULL;
GList *l;
gint selection_nbr, selection_i = 1;
gint response;
EtPictureType pic_type;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
selection_list = gtk_tree_selection_get_selected_rows(selection, NULL);
selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection));
for (l = selection_list; l != NULL; l = g_list_next (l))
{
GtkTreePath *path = l->data;
Picture *pic = NULL;
GtkTreeSelection *selectiontype;
gchar *title;
GtkTreePath *rowPath;
gboolean valid;
// Get corresponding picture
valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path);
if (valid)
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1);
title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++,
selection_nbr);
PictureTypesWindow = gtk_dialog_new_with_buttons(title,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_free(title);
gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK);
ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT);
type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref (store);
gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_title (column, _("Image Type"));
gtk_tree_view_column_set_attributes(column, renderer,
"text", PICTURE_TYPE_COLUMN_TEXT,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(type), column);
gtk_widget_set_size_request(type, 256, 256);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0);
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
/* Load picture type (only Front Cover!). */
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype, G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
ET_PICTURE_TYPE_FRONT_COVER,
-1);
/* Line to select by default. */
type_iter_to_select = itertype;
break;
}
// Other tag types
default:
{
// Load pictures types
for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++)
{
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype,
G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (pic_type)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
pic_type, -1);
/* Line to select by default. */
if (pic->type == pic_type)
type_iter_to_select = itertype;
}
break;
}
}
// Select the line by default
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select);
// Set visible the current selected line
rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0);
gtk_tree_path_free(rowPath);
// Description of the picture
label = gtk_label_new (_("Image Description:"));
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4);
// Entry for the description
desc = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0);
if (pic->description)
{
gchar *tmp = Try_To_Validate_Utf8_String(pic->description);
gtk_entry_set_text(GTK_ENTRY(desc), tmp);
g_free(tmp);
}
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE);
break;
}
// Other tag types
default:
{
break;
}
}
gtk_widget_show_all(PictureTypesWindow);
response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow));
if (response == GTK_RESPONSE_OK)
{
GtkTreeModel *modeltype;
GtkTreeIter itertype;
modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type));
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype))
{
gchar *buffer, *pic_info;
gint t;
gtk_tree_model_get(modeltype, &itertype,
PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1);
pic->type = t;
buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc)));
Strip_String(buffer);
if (pic->description)
g_free(pic->description);
/* If the entry was empty, buffer will be the empty string "".
* This can be safely passed to the underlying
* FLAC__metadata_object_picture_set_description(). See
* https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804
* and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for
* downstream bugs when 0 was passed instead. */
pic->description = buffer;
// Update value in the PictureEntryView
pic_info = Picture_Info(pic);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
PICTURE_COLUMN_TEXT, pic_info,
-1);
g_free(pic_info);
}
}
gtk_widget_destroy(PictureTypesWindow);
}
g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free);
}
void PictureEntry_Update (Picture *pic, gboolean select_it)
{
GdkPixbufLoader *loader = 0;
GError *error = NULL;
g_return_if_fail (pic != NULL || PictureEntryView != NULL);
if (!pic->data)
{
PictureEntry_Clear();
return;
}
loader = gdk_pixbuf_loader_new();
if (loader)
{
if (gdk_pixbuf_loader_write(loader, pic->data, pic->size, &error))
{
GtkTreeSelection *selection;
GdkPixbuf *pixbuf;
if (!gdk_pixbuf_loader_close(loader, &error))
{
Log_Print(LOG_ERROR,_("Error with 'loader_close': %s"), error->message);
g_error_free(error);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf)
{
GtkListStore *picture_store;
GtkTreeIter iter1;
GdkPixbuf *scaled_pixbuf;
gint scaled_pixbuf_width;
gint scaled_pixbuf_height;
gchar *pic_info;
g_object_ref(pixbuf);
g_object_unref(loader);
// Keep aspect ratio of the picture
pic->width = gdk_pixbuf_get_width(pixbuf);
pic->height = gdk_pixbuf_get_height(pixbuf);
if (pic->width > pic->height)
{
scaled_pixbuf_width = 96;
scaled_pixbuf_height = 96 * pic->height / pic->width;
}else
{
scaled_pixbuf_width = 96 * pic->width / pic->height;
scaled_pixbuf_height = 96;
}
scaled_pixbuf = gdk_pixbuf_scale_simple(pixbuf,
scaled_pixbuf_width, scaled_pixbuf_height,
//GDK_INTERP_NEAREST); // Lower quality but better speed
GDK_INTERP_BILINEAR);
g_object_unref(pixbuf);
picture_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView)));
pic_info = Picture_Info(pic);
gtk_list_store_insert_with_values (picture_store, &iter1,
G_MAXINT,
PICTURE_COLUMN_PIC,
scaled_pixbuf,
PICTURE_COLUMN_TEXT,
pic_info,
PICTURE_COLUMN_DATA,
Picture_Copy_One (pic), -1);
g_free(pic_info);
if (select_it)
gtk_tree_selection_select_iter(selection, &iter1);
g_object_unref(scaled_pixbuf);
}else
{
GtkWidget *msgdialog;
g_object_unref(loader);
Log_Print (LOG_ERROR, "%s",
_("Cannot display the image because not enough data has been read to determine how to create the image buffer."));
msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s",
_("Cannot display the image"));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog),
_("Not enough data has been read to determine how to create the image buffer."));
gtk_window_set_title (GTK_WINDOW (msgdialog),
_("Load Image File"));
gtk_dialog_run(GTK_DIALOG(msgdialog));
gtk_widget_destroy(msgdialog);
}
}else
{
Log_Print(LOG_ERROR,_("Error with 'loader_write': %s"), error->message);
g_error_free(error);
}
}
// Do also for next picture
if (pic->next)
PictureEntry_Update(pic->next, select_it);
return;
}
/**
* gtr_message_table_navigate:
* @table:
* @navigation:
* @func: (scope call):
*
* Returns: (transfer none):
*/
GtrMsg *
gtr_message_table_navigate (GtrMessageTable * table,
GtrMessageTableNavigation navigation,
GtrMessageTableNavigationFunc func)
{
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
GtrMsg *msg;
gboolean cont = TRUE;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table->priv->treeview));
if (!gtk_tree_selection_get_selected (selection, &model, &iter))
return NULL;
switch (navigation)
{
case GTR_NAVIGATE_FIRST:
if (!gtk_tree_model_get_iter_first (model, &iter))
return NULL;
break;
case GTR_NAVIGATE_LAST:
{
gint n_children;
n_children = gtk_tree_model_iter_n_children (model, NULL);
if (n_children <= 0)
return NULL;
if (!gtk_tree_model_iter_nth_child (model, &iter, NULL, n_children - 1))
return NULL;
}
break;
case GTR_NAVIGATE_NEXT:
if (func)
{
while (cont)
{
if (!gtk_tree_model_iter_next (model, &iter))
return NULL;
gtk_tree_model_get (model, &iter,
GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg,
-1);
if (func (msg))
cont = FALSE;
}
}
else if (!gtk_tree_model_iter_next (model, &iter))
return NULL;
break;
case GTR_NAVIGATE_PREV:
if (func)
{
while (cont)
{
if (!gtk_tree_model_iter_previous (model, &iter))
return NULL;
gtk_tree_model_get (model, &iter,
GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg,
-1);
if (func (msg))
cont = FALSE;
}
}
else if (!gtk_tree_model_iter_previous (model, &iter))
return NULL;
break;
}
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (table->priv->treeview),
path, NULL, TRUE, 0.5, 0.0);
gtk_tree_model_get (model, &iter,
GTR_MESSAGE_TABLE_MODEL_POINTER_COLUMN, &msg,
-1);
return msg;
}
static void PopulateForm(int pgs)
{
if (pgs & (1<<TAB_CONFIG)) {
int mode3d, i;
GtkListStore *modes3d;
GtkTreeIter iter;
GtkComboBox *box3d;
char buf[64];
mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1);
if (mode3d < 0) {
int i, cd[] = { 32, 24, 16, 15, 8, 0 };
for (i=0; cd[i]; ) {
if (cd[i] >= settings.bpp3d) i++;
else break;
}
for ( ; cd[i]; i++) {
mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1);
if (mode3d < 0) continue;
settings.bpp3d = cd[i];
break;
}
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"fullscreencheck")), settings.fullscreen);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"alwaysshowcheck")), settings.forcesetup);
box3d = GTK_COMBO_BOX(lookup_widget(startwin,"vmode3dcombo"));
modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(box3d));
gtk_list_store_clear(modes3d);
for (i=0; i<validmodecnt; i++) {
if (validmode[i].fs != settings.fullscreen) continue;
// all modes get added to the 3D mode list
Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp);
gtk_list_store_append(modes3d, &iter);
gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1);
if (i == mode3d) {
g_signal_handlers_block_by_func(box3d, on_vmode3dcombo_changed, NULL);
gtk_combo_box_set_active_iter(box3d, &iter);
g_signal_handlers_unblock_by_func(box3d, on_vmode3dcombo_changed, NULL);
}
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputmousecheck")), settings.usemouse);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget(startwin,"inputjoycheck")), settings.usejoy);
}
if (pgs & (1<<TAB_GAME)) {
struct grpfile *fg;
int i;
GtkListStore *list;
GtkTreeIter iter;
GtkTreeView *gamelist;
gamelist = GTK_TREE_VIEW(lookup_widget(startwin,"gamelist"));
list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist));
gtk_list_store_clear(list);
for (fg = foundgrps; fg; fg=fg->next) {
for (i = 0; i<numgrpfiles; i++)
if (fg->crcval == grpfiles[i].crcval) break;
if (i == numgrpfiles) continue; // unrecognised grp file
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter, 0, grpfiles[i].name, 1, fg->name, 2, (gpointer)fg, -1);
if (!Bstrcasecmp(fg->name, settings.selectedgrp)) {
GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist);
g_signal_handlers_block_by_func(sel, on_gamelist_selection_changed, NULL);
gtk_tree_selection_select_iter(sel, &iter);
g_signal_handlers_unblock_by_func(sel, on_gamelist_selection_changed, NULL);
}
}
}
}
GtkWidget *
module_dialog_new (Gimp *gimp)
{
GtkWidget *shell;
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *view;
GtkWidget *image;
ModuleDialog *dialog;
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
dialog = g_slice_new0 (ModuleDialog);
dialog->gimp = gimp;
shell = gimp_dialog_new (_("Module Manager"),
"gimp-modules", NULL, 0,
gimp_standard_help_func, GIMP_HELP_MODULE_DIALOG,
GTK_STOCK_REFRESH, RESPONSE_REFRESH,
GTK_STOCK_CLOSE, GTK_STOCK_CLOSE,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (shell),
GTK_RESPONSE_CLOSE,
RESPONSE_REFRESH,
-1);
g_signal_connect (shell, "response",
G_CALLBACK (dialog_response),
dialog);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (shell))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
dialog->hint = gimp_hint_box_new (_("You will have to restart GIMP "
"for the changes to take effect."));
gtk_box_pack_start (GTK_BOX (vbox), dialog->hint, FALSE, FALSE, 0);
if (gimp->write_modulerc)
gtk_widget_show (dialog->hint);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_set_size_request (sw, 124, 100);
gtk_widget_show (sw);
dialog->list = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
GIMP_TYPE_MODULE);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list));
g_object_unref (dialog->list);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
g_list_foreach (gimp->module_db->modules, make_list_item, dialog);
rend = gtk_cell_renderer_toggle_new ();
g_signal_connect (rend, "toggled",
G_CALLBACK (dialog_enabled_toggled),
dialog);
col = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "active", COLUMN_ENABLED);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1,
_("Module"),
gtk_cell_renderer_text_new (),
"text", COLUMN_NAME,
NULL);
gtk_container_add (GTK_CONTAINER (sw), view);
gtk_widget_show (view);
dialog->table = gtk_table_new (2, N_INFOS, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (dialog->table), 6);
gtk_box_pack_start (GTK_BOX (vbox), dialog->table, FALSE, FALSE, 0);
gtk_widget_show (dialog->table);
dialog->error_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), dialog->error_box, FALSE, FALSE, 0);
image = gtk_image_new_from_stock (GIMP_STOCK_WARNING, GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (dialog->error_box), image, FALSE, FALSE, 0);
gtk_widget_show (image);
dialog->error_label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (dialog->error_label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (dialog->error_box),
dialog->error_label, TRUE, TRUE, 0);
gtk_widget_show (dialog->error_label);
dialog_info_init (dialog, dialog->table);
dialog_info_update (gimp->module_db, dialog->selected, dialog);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
g_signal_connect (sel, "changed",
G_CALLBACK (dialog_select_callback),
dialog);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->list), &iter))
gtk_tree_selection_select_iter (sel, &iter);
/* hook the GimpModuleDB signals so we can refresh the display
* appropriately.
*/
g_signal_connect (gimp->module_db, "add",
G_CALLBACK (dialog_info_add),
dialog);
g_signal_connect (gimp->module_db, "remove",
G_CALLBACK (dialog_info_remove),
dialog);
g_signal_connect (gimp->module_db, "module-modified",
G_CALLBACK (dialog_info_update),
dialog);
g_signal_connect (shell, "destroy",
G_CALLBACK (dialog_destroy_callback),
dialog);
return shell;
}
static void
examinee_tree_selection_changed_cb (GtkTreeSelection *selection,
gpointer user_data)
{
GPInstructAnalyzerExamineeView *view = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW (user_data);
GPInstructAnalyzerExamineeViewPrivate *priv = view->priv;
GPInstructLogAnalyzerExaminee *examinee;
GtkTreeIter iter, iterProject, iterCategory, iterLesson, iterGroup;
GtkTreeModel *model;
guint min;
gdouble sec;
guint items, frequency, score;
gdouble ave_score, percentage, time_spent, ave_time_spent;
gchar *items_text, *frequency_text, *score_text, *ave_score_text, *percentage_text, *time_text, *ave_time_text;
gtk_tree_store_clear (priv->project_store);
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter,
EXAMINEE_STRUCT_POINTER_COLUMN, &examinee,
-1);
if (examinee)
{
GPInstructLogAnalyzerProject *project = examinee->project;
items = project->items_length;
frequency = project->times_taken;
score = project->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = project->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterProject, NULL, -1,
PROJECT_TITLE_COLUMN, gpinstruct_project_get_title (project->object),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_PROJECT,
PROJECT_STRUCT_POINTER_COLUMN, project,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *categories = project->categories;
while (categories)
{
GPInstructLogAnalyzerCategory *category = (GPInstructLogAnalyzerCategory*) categories->data;
items = category->items_length;
frequency = category->times_taken;
score = category->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = category->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterCategory, &iterProject, -1,
PROJECT_TITLE_COLUMN, gpinstruct_category_get_title (category->object),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_CATEGORY,
PROJECT_STRUCT_POINTER_COLUMN, category,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *lessons = category->lessons;
while (lessons)
{
GPInstructLogAnalyzerLesson *lesson = (GPInstructLogAnalyzerLesson*) lessons->data;
items = lesson->items_length;
frequency = lesson->times_taken;
score = lesson->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = lesson->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterLesson, &iterCategory, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_get_title (lesson->object),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_LESSON,
PROJECT_STRUCT_POINTER_COLUMN, lesson,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *elements = lesson->elements;
while (elements)
{
if (((GPInstructLogAnalyzerLessonElement*) elements->data)->is_test)
{
GPInstructLogAnalyzerTest *test = ((GPInstructLogAnalyzerLessonElement*) elements->data)->test;
items = test->items_length;
frequency = test->times_taken;
score = test->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = test->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, NULL, &iterLesson, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (test->object)),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_TEST,
PROJECT_STRUCT_POINTER_COLUMN, test,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
}
else
{
GPInstructLogAnalyzerGroup *group = ((GPInstructLogAnalyzerLessonElement*) elements->data)->group;
items = group->items_length;
frequency = group->times_taken;
score = group->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = group->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterGroup, &iterLesson, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (group->object)),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_GROUP,
PROJECT_STRUCT_POINTER_COLUMN, group,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *tests = group->tests;
while (tests)
{
GPInstructLogAnalyzerTest *test = (GPInstructLogAnalyzerTest*) tests->data;
items = test->items_length;
frequency = test->times_taken;
score = test->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = test->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, NULL, &iterGroup, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (test->object)),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_TEST,
PROJECT_STRUCT_POINTER_COLUMN, test,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
tests = tests->next;
}
}
elements = elements->next;
}
lessons = lessons->next;
}
categories = categories->next;
}
gtk_tree_view_expand_all (GTK_TREE_VIEW (priv->project_treeview));
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->project_store), &iter))
{
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->project_treeview));
gtk_tree_selection_select_iter (selection, &iter);
GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->project_scrolledwindow));
gtk_adjustment_set_value (adjustment, gtk_adjustment_get_lower (adjustment));
}
}
}
}
static void
project_tree_selection_changed_cb (GtkTreeSelection *selection,
gpointer user_data)
{
GPInstructAnalyzerExamineeView *view = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW (user_data);
GPInstructAnalyzerExamineeViewPrivate *priv = view->priv;
GtkTreeIter iter, iterItem, iterChoice;
GtkTreeModel *model;
guint struct_type;
GPInstructLogAnalyzerTest *test;
guint min;
gdouble sec;
guint children, frequency, score;
gdouble percentage, time_spent, ave_time_spent;
gchar *title_text, *children_text, *frequency_text, *score_text,
*percentage_text, *time_text, *ave_time_text;
gtk_tree_store_clear (priv->test_store);
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter,
PROJECT_STRUCT_TYPE_COLUMN, &struct_type,
PROJECT_STRUCT_POINTER_COLUMN, &test,
-1);
if (struct_type == STRUCT_TYPE_TEST)
{
GList *items = test->items;
guint item_num = 0;
while (items)
{
GPInstructLogAnalyzerItem *item = items->data;
children = item->choices_length;
frequency = item->times_answered;
score = item->times_correctly_answered;
percentage = (frequency?((gdouble) score/frequency):0) * 100;
time_spent = item->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
title_text = gpinstruct_lesson_test_get_item (test->object,
item_num);
children_text = g_strdup_printf ("%d", children);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->test_store,
&iterItem, NULL,
-1,
TEST_TITLE_COLUMN, title_text,
TEST_ITEMS_COLUMN, children_text,
TEST_FREQUENCY_COLUMN, frequency_text,
TEST_SCORE_COLUMN, score_text,
TEST_PERCENTAGE_COLUMN, percentage_text,
TEST_TIME_COLUMN, time_text,
TEST_AVE_TIME_COLUMN, ave_time_text,
-1);
g_free (title_text);
g_free (children_text);
g_free (frequency_text);
g_free (score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *choices = item->choices;
guint choice_num = 0;
while (choices)
{
GPInstructLogAnalyzerChoice *choice = choices->data;
if (test->is_string)
title_text = g_strdup (choice->string);
else
title_text = gpinstruct_lesson_test_get_choice (test->object,
item_num,
choice_num);
frequency = choice->times_chosen;
percentage = (item->times_answered?((gdouble) frequency/item->times_answered):0) * 100;
time_spent = choice->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
frequency_text = g_strdup_printf ("%d", frequency);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->test_store,
&iterChoice, &iterItem,
-1,
TEST_TITLE_COLUMN, title_text,
TEST_FREQUENCY_COLUMN, frequency_text,
TEST_PERCENTAGE_COLUMN, percentage_text,
TEST_TIME_COLUMN, time_text,
TEST_AVE_TIME_COLUMN, ave_time_text,
-1);
g_free (title_text);
g_free (frequency_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
choice_num++;
choices = choices->next;
}
item_num++;
items = items->next;
}
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->test_store), &iter))
{
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->test_treeview));
gtk_tree_selection_select_iter (selection, &iter);
GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->test_scrolledwindow));
gtk_adjustment_set_value (adjustment, gtk_adjustment_get_lower (adjustment));
}
}
}
}
/**
@brief iterate over active pane file list to check for matches
@param from the button, menu item etc which was activated
@param art action runtime data
@return TRUE if action completed successfully, else FALSE
*/
static gboolean _e2p_select_same (gpointer from, E2_ActionRuntime *art)
{
E2_PaneRuntime *rt;
ViewInfo *selview;
GtkTreeModel *models;
GtkTreeIter iters;
rt = e2_pane_get_runtime (from, art->data, NULL);
selview = (ViewInfo *)rt;
WAIT_FOR_REFRESH(selview)
models = selview->model;
if (gtk_tree_model_get_iter_first (models, &iters))
{ //it's not empty
ViewInfo *othview;
GtkTreeModel *modelo;
GtkTreeSelection *sel;
GList *selpaths, *rowpath;
GHashTable *selitems;
FileInfo *info;
gboolean fullmatch, forward;
const gchar *seps;
e2_filelist_disable_refresh ();
othview = (rt == curr_pane) ? &other_pane->view : &curr_pane->view;
WAIT_FOR_REFRESH(othview)
selpaths = gtk_tree_selection_get_selected_rows (othview->selection, &modelo);
if (selpaths == NULL)
{
e2_filelist_enable_refresh ();
return FALSE;
}
// art->action->data is NULL for full name-scan, non-NULL for partial
fullmatch = (art->action->data == NULL);
if (fullmatch)
{ //warning prevention
seps = NULL;
forward = TRUE;
}
else
{
seps = e2_option_str_get ("selmatch-separators");
if (seps != NULL && *seps == '\0')
{
fullmatch = TRUE;
forward = TRUE;
}
else
forward = e2_option_bool_get ("selmatch-start");
}
// Log the selected items, for quick lookup
selitems = (fullmatch) ?
g_hash_table_new (g_str_hash, g_str_equal):
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for (rowpath = selpaths; rowpath != NULL; rowpath = rowpath->next)
{
GtkTreePath *path;
GtkTreeIter itero;
path = (GtkTreePath *) rowpath->data;
if (gtk_tree_model_get_iter (modelo, &itero, path))
{
gtk_tree_model_get (modelo, &itero, FINFO, &info, -1);
if (fullmatch)
g_hash_table_insert (selitems, info->filename, info); //no key dup, info must persist
else
{
gchar c;
gchar *target;
if (forward)
{
for (target = info->filename; (c = *target) != '\0'; target++)
{
if (strchr (seps, c) != NULL) //assumes no UTF-8 chars
{
target = g_strndup (info->filename, target - info->filename);
g_hash_table_insert (selitems, target, info);
break;
}
}
if (c == '\0')
g_hash_table_insert (selitems, g_strdup (info->filename), info);
}
else
{
for (target = info->filename + strlen (info->filename) - 1 ;
target >= info->filename; target--)
{
if (strchr (seps, *target) != NULL) //assumes no UTF-8 chars
{
target = g_strndup (info->filename, target - info->filename);
g_hash_table_insert (selitems, target, info);
break;
}
}
if (target < info->filename)
g_hash_table_insert (selitems, g_strdup (info->filename), info);
}
}
}
gtk_tree_path_free (path);
}
g_list_free (selpaths);
sel = selview->selection;
gtk_tree_selection_unselect_all (sel); //start with clean slate
do
{
gboolean partial;
gchar *scan;
gtk_tree_model_get (models, &iters, FINFO, &info, -1);
//We only check for name, ignore other statbuf parameters
partial = FALSE;
scan = NULL;
if (!fullmatch)
{
gchar c;
if (forward)
{
for (scan = info->filename; (c = *scan) != '\0'; scan++)
{
if (strchr (seps, c) != NULL) //assumes no UTF-8 chars, too bad if different sep from other pane
{
partial = TRUE;
break;
}
}
}
else
{
for (scan = info->filename + strlen (info->filename) - 1 ;
scan >= info->filename; scan--)
{
c = *scan;
if (strchr (seps, c) != NULL) //assumes no UTF-8 chars
{
partial = TRUE;
break;
}
}
}
}
if (partial)
scan = g_strndup (info->filename, scan - info->filename);
else
scan = info->filename;
if (g_hash_table_lookup (selitems, scan) != NULL)
gtk_tree_selection_select_iter (sel, &iters);
if (partial)
g_free (scan);
} while (gtk_tree_model_iter_next (models, &iters));
g_hash_table_destroy (selitems);
//ensure some part of selection is visible
selpaths = gtk_tree_selection_get_selected_rows (sel, NULL);
if (selpaths != NULL)
{
printd (DEBUG, "scroll to show selection");
GtkTreePath *tpath = gtk_tree_path_copy ((GtkTreePath *)selpaths->data);
//this kills other selections
gtk_tree_view_set_cursor (GTK_TREE_VIEW (selview->treeview), tpath, NULL, FALSE);
//so back again, and cleanup
g_list_foreach (selpaths, (GFunc)_e2p_selsame_reselect, sel);
g_list_free (selpaths);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (selview->treeview), tpath,
NULL, TRUE, 0.382, 0.0);
gtk_tree_path_free (tpath);
}
e2_filelist_enable_refresh ();
return TRUE;
}
return FALSE;
}
/*
* This function sets the custom list when the language list has changed in
* the language dialog (launched from language button or F10 menu).
*/
void
lang_set_custom_callback (gchar *language)
{
GtkListStore *lang_model = mdm_lang_get_model ();
GtkTreeIter iter;
gboolean valid;
char *locale_name;
int i=0;
/* Do nothing if there is no language widget */
if (language_widget == NULL)
return;
/*
* Handle for either combo box or list style, depending on which is being
* used.
. */
if (GTK_IS_COMBO_BOX (language_widget))
{
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (lang_model),
&iter);
while (valid)
{
gtk_tree_model_get (GTK_TREE_MODEL (lang_model), &iter,
LOCALE_COLUMN, &locale_name, -1);
if (strcmp (language, locale_name) == 0)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (language_widget), i);
break;
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (lang_model), &iter);
i++;
}
}
else if (GTK_IS_SCROLLED_WINDOW (language_widget) &&
GTK_IS_TREE_VIEW (GTK_BIN (language_widget)->child))
{
GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (language_widget)->child);
GtkTreeModel *tm = gtk_tree_view_get_model (tv);
GtkTreeSelection *selection = gtk_tree_view_get_selection (tv);
GtkTreeIter loopiter;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter))
{
do
{
char *locale_file;
gtk_tree_model_get (GTK_TREE_MODEL (tm), &loopiter, GREETER_LIST_ID, &locale_file, -1);
if (locale_file != NULL && strcmp (language, locale_file) == 0)
{
GtkTreePath *path = gtk_tree_model_get_path (tm, &loopiter);
gtk_tree_selection_select_iter (selection, &loopiter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv),
path, NULL,
FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
break;
}
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tm), &loopiter));
}
}
}
void
fe_userlist_insert (session *sess, struct User *newuser, int row, int sel)
{
GtkTreeModel *model = sess->res->user_model;
GdkPixbuf *pix = get_user_icon (sess->server, newuser);
GtkTreeIter iter;
char *nick;
int nick_color = 0;
if (prefs.pchat_away_track && newuser->away)
nick_color = COL_AWAY;
else if (prefs.pchat_gui_ulist_color)
nick_color = text_color_of(newuser->nick);
nick = newuser->nick;
if (!prefs.pchat_gui_ulist_icons)
{
nick = malloc (strlen (newuser->nick) + 2);
nick[0] = newuser->prefix[0];
if (!nick[0] || nick[0] == ' ')
strcpy (nick, newuser->nick);
else
strcpy (nick + 1, newuser->nick);
pix = NULL;
}
gtk_list_store_insert_with_values (GTK_LIST_STORE (model), &iter, row,
COL_PIX, pix,
COL_NICK, nick,
COL_HOST, newuser->hostname,
COL_USER, newuser,
COL_GDKCOLOR, nick_color ? &colors[nick_color] : NULL,
-1);
if (!prefs.pchat_gui_ulist_icons)
{
free (nick);
}
/* is it me? */
if (newuser->me && sess->gui->nick_box)
{
if (!sess->gui->is_tab || sess == current_tab)
mg_set_access_icon (sess->gui, pix, sess->server->is_away);
}
#if 0
if (prefs.hilitenotify && notify_isnotify (sess, newuser->nick))
{
gtk_clist_set_foreground ((GtkCList *) sess->gui->user_clist, row,
&colors[prefs.nu_color]);
}
#endif
/* is it the front-most tab? */
if (gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree))
== model)
{
if (sel)
gtk_tree_selection_select_iter (gtk_tree_view_get_selection
(GTK_TREE_VIEW (sess->gui->user_tree)), &iter);
}
}
/*
* This function sets the custom list when the session list has changed in
* the session dialog (launched from session button or F10 menu).
*/
void
greeter_custom_set_session (gchar *session)
{
GList *tmp;
int i=0;
/*
* Since the sessions are created before the session list is generated,
* keep track of the session and set active row when it is setup. This
* function will get a NULL when the session is initialized to NULL
* at startup, so just return.
*/
if (session == NULL)
return;
else
{
/*
* If the session_widget hasn't been setup yet (which it won't be when
* the greeter_sessioninit function is called, then just store the
* session and we'll set the value when the combo box is initialized later.
*/
g_free (session_key);
session_key = g_strdup (session);
}
/* Do nothing if there is no session widget */
if (session_widget == NULL)
return;
/* Last isn't in the session list, so handle separate. */
if (strcmp (session, LAST_SESSION) == 0)
{
if (GTK_IS_COMBO_BOX (session_widget))
{
gtk_combo_box_set_active (GTK_COMBO_BOX (session_widget), 0);
}
else if (GTK_IS_SCROLLED_WINDOW (session_widget) &&
GTK_IS_TREE_VIEW (GTK_BIN (session_widget)->child))
{
GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (session_widget)->child);
GtkTreeModel *tm = gtk_tree_view_get_model (tv);
GtkTreeSelection *selection = gtk_tree_view_get_selection (tv);
GtkTreeIter loopiter;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter))
gtk_tree_selection_select_iter (selection, &loopiter);
}
}
/*
* Handle for either combo box or list style, depending on which is being
* used.
. */
if (GTK_IS_COMBO_BOX (session_widget))
{
for (tmp = sessions; tmp != NULL; tmp = tmp->next)
{
char *file;
i++;
file = tmp->data;
if (strcmp (session, file) == 0)
{
gtk_combo_box_set_active (GTK_COMBO_BOX (session_widget), i);
break;
}
}
}
else if (GTK_IS_SCROLLED_WINDOW (session_widget) &&
GTK_IS_TREE_VIEW (GTK_BIN (session_widget)->child))
{
GtkTreeView *tv = GTK_TREE_VIEW (GTK_BIN (session_widget)->child);
GtkTreeModel *tm = gtk_tree_view_get_model (tv);
GtkTreeSelection *selection = gtk_tree_view_get_selection (tv);
GtkTreeIter loopiter;
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tm), &loopiter))
{
do
{
char *file;
gtk_tree_model_get (GTK_TREE_MODEL (tm), &loopiter, GREETER_LIST_ID, &file, -1);
if (file != NULL && strcmp (session, file) == 0)
{
GtkTreePath *path = gtk_tree_model_get_path (tm, &loopiter);
gtk_tree_selection_select_iter (selection, &loopiter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (tv),
path, NULL,
FALSE, 0.0, 0.0);
gtk_tree_path_free (path);
break;
}
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (tm), &loopiter));
}
}
}
static void PopulateForm(unsigned char pgs)
{
if ((pgs == ALL) || (pgs == POPULATE_VIDEO))
{
int32_t mode3d, i;
GtkListStore *modes3d;
GtkTreeIter iter;
char buf[64];
mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, settings.bpp3d, settings.fullscreen, 1);
if (mode3d < 0)
{
int32_t i, cd[] = { 32, 24, 16, 15, 8, 0 };
for (i=0; cd[i];) { if (cd[i] >= settings.bpp3d) i++; else break; }
for (; cd[i]; i++)
{
mode3d = checkvideomode(&settings.xdim3d, &settings.ydim3d, cd[i], settings.fullscreen, 1);
if (mode3d < 0) continue;
settings.bpp3d = cd[i];
break;
}
}
modes3d = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.vmode3dcombo)));
gtk_list_store_clear(modes3d);
for (i=0; i<validmodecnt; i++)
{
if (validmode[i].fs != settings.fullscreen) continue;
// all modes get added to the 3D mode list
Bsprintf(buf, "%d x %d %dbpp", validmode[i].xdim, validmode[i].ydim, validmode[i].bpp);
gtk_list_store_append(modes3d, &iter);
gtk_list_store_set(modes3d, &iter, 0,buf, 1,i, -1);
if (i == mode3d)
{
g_signal_handlers_block_by_func(stwidgets.vmode3dcombo, on_vmode3dcombo_changed, NULL);
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.vmode3dcombo), &iter);
g_signal_handlers_unblock_by_func(stwidgets.vmode3dcombo, on_vmode3dcombo_changed, NULL);
}
}
}
if ((pgs == ALL) || (pgs == POPULATE_CONFIG))
{
GtkListStore *devlist, *modsdir;
GtkTreeIter iter;
GtkTreePath *path;
char *value;
unsigned char i, r = 0;
const char *availabledev[] =
{
"Keyboard only",
"Keyboard and mouse",
"Keyboard and joystick",
"All supported devices"
};
// populate input devices combo
devlist = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.inputdevcombo)));
gtk_list_store_clear(devlist);
for (i=0; i<(int32_t)G_N_ELEMENTS(availabledev); i++)
{
gtk_list_store_append(devlist, &iter);
gtk_list_store_set(devlist, &iter, 0,availabledev[i], -1);
}
switch (settings.usemouse)
{
case 0: if (settings.usejoy)
gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_JOYSTICK);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_KB);
break;
case 1: if (settings.usejoy)
gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_ALL);
else
gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.inputdevcombo), INPUT_MOUSE);
break;
}
// populate custom mod combo
modsdir = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(stwidgets.custommodcombo)));
gtk_list_store_clear(modsdir);
gtk_list_store_append(modsdir, &iter);
gtk_list_store_set(modsdir, &iter, 0,"None", -1);
r = GetModsDirNames(modsdir);
for (i=0; i<=r; i++)
{
path = gtk_tree_path_new_from_indices(i, -1);
gtk_tree_model_get_iter(GTK_TREE_MODEL(modsdir), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(modsdir), &iter, 0,&value, -1);
if (Bstrcmp(settings.custommoddir, "/") == 0)
{
gtk_combo_box_set_active(GTK_COMBO_BOX(stwidgets.custommodcombo), NONE);
settings.custommoddir = NULL;
break;
}
if (Bstrcmp(settings.custommoddir, value) == 0)
{
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(stwidgets.custommodcombo),
&iter);
break;
}
}
// populate check buttons
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.fullscreencheck), settings.fullscreen);
#ifdef POLYMER
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.polymercheck), settings.polymer);
#endif
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.autoloadcheck), settings.autoload);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stwidgets.alwaysshowcheck), settings.forcesetup);
}
if ((pgs == ALL) || (pgs == POPULATE_GAME))
{
struct grpfile *fg;
int32_t i;
GtkListStore *list;
GtkTreeIter iter;
GtkTreeView *gamelist;
gamelist = GTK_TREE_VIEW(stwidgets.gamelist);
list = GTK_LIST_STORE(gtk_tree_view_get_model(gamelist));
gtk_list_store_clear(list);
for (fg = foundgrps; fg; fg=fg->next)
{
for (i = 0; i<numgrpfiles; i++)
if (fg->crcval == grpfiles[i].crcval) break;
if (i == numgrpfiles) continue; // unrecognised grp file
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter, 0, grpfiles[i].name, 1, fg->name, 2, (gpointer)fg, -1);
if (!Bstrcasecmp(fg->name, settings.selectedgrp))
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(gamelist);
g_signal_handlers_block_by_func(sel, on_gamelist_selection_changed, NULL);
gtk_tree_selection_select_iter(sel, &iter);
g_signal_handlers_unblock_by_func(sel, on_gamelist_selection_changed, NULL);
}
}
}
}
static void
choices_tree_view_row_activated (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
gpointer user_data)
{
GPInstructLessonTestMultiChoiceEditor *editor = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data);
GPInstructLessonTestMultiChoiceEditorPrivate *priv = editor->priv;
GPInstructObject *object;
GtkTreeIter iter;
GtkWidget *scrolled_window, *text_view;
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->choices_store), &iter, path))
{
object = questions_tree_view_get_current_data (editor);
if (GPINSTRUCT_IS_LESSON_TEST_MULTI_CHOICE_QUESTION (object))
{
guint choice = gtk_tree_path_get_indices (path)[0];
GPInstructLessonTestMultiChoiceQuestion *question = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_QUESTION (object);
GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Choice Properties"),
GTK_WINDOW (priv->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 300);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
text_view = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR);
gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)),
gpinstruct_lesson_test_multi_choice_question_get_choice (question, choice),
-1);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_box_pack_start (GTK_BOX (content_area),
gtk_label_new (_("Text:")),
FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (content_area),
scrolled_window,
TRUE, TRUE, 0);
gtk_widget_show_all (content_area);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
GtkTextIter start, end;
gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)),
&start, &end);
gchar *text = gtk_text_iter_get_text (&start, &end);
gpinstruct_lesson_test_multi_choice_question_set_choice (question, choice, text);
g_free (text);
update_choices_tree_view (GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data));
gpinstruct_editor_window_set_modified (priv->window, TRUE);
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->choices_store),
&iter, NULL, choice);
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
&iter);
}
gtk_widget_destroy (dialog);
}
}
}
gboolean edit_bookmarks( GtkWindow* parent )
{
GList* l;
GtkWidget* dlg;
GtkWidget* btn_box;
GtkWidget* add_btn;
GtkWidget* delete_btn;
GtkWidget* scroll;
GtkWidget* list_view;
GtkListStore* list;
GtkTreeViewColumn* col;
GtkTreeIter it;
GtkTreeSelection* sel;
gchar *name, *path, *item;
gboolean ret = FALSE;
PtkBookmarks* bookmarks;
GtkCellRenderer *renderer, *icon_renderer;
GdkPixbuf* icon;
dlg = gtk_dialog_new_with_buttons ( _("Edit Bookmarks"),
parent,
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL );
gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 );
list = gtk_list_store_new( NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING );
icon = gtk_icon_theme_load_icon( gtk_icon_theme_get_default(),
"gnome-fs-directory",
20, 0, NULL );
bookmarks = ptk_bookmarks_get();
for( l = bookmarks->list; l; l = l->next )
{
gtk_list_store_append( list, &it );
gtk_list_store_set( list, &it,
COL_ICON, icon,
COL_NAME, l->data,
COL_DIRPATH, ptk_bookmarks_item_get_path((char*)l->data),
-1);
}
if( icon )
g_object_unref( icon );
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scroll),
GTK_SHADOW_IN);
list_view = gtk_tree_view_new_with_model( GTK_TREE_MODEL(list) );
g_object_set_data( G_OBJECT(dlg), "list_view", list_view );
sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(list_view) );
gtk_tree_selection_set_mode( sel, GTK_SELECTION_BROWSE );
if( gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(list), &it ) )
{
gtk_tree_selection_select_iter( sel, &it );
}
icon_renderer = gtk_cell_renderer_pixbuf_new();
renderer = gtk_cell_renderer_text_new();
g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL );
g_signal_connect( renderer, "edited", G_CALLBACK(on_name_edited), list );
col = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", COL_ICON, NULL );
gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col );
col = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", COL_NAME, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_fixed_width(col, 160);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col );
renderer = gtk_cell_renderer_text_new();
g_object_set( G_OBJECT(renderer), "editable", TRUE, NULL );
g_signal_connect( renderer, "edited", G_CALLBACK(on_path_edited), list );
col = gtk_tree_view_column_new_with_attributes(_("Path"),
renderer, "text", COL_DIRPATH, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column( GTK_TREE_VIEW(list_view), col );
gtk_tree_view_set_reorderable ( GTK_TREE_VIEW(list_view), TRUE );
gtk_container_add( GTK_CONTAINER(scroll), list_view);
btn_box = gtk_hbutton_box_new();
gtk_button_box_set_layout ( GTK_BUTTON_BOX(btn_box), GTK_BUTTONBOX_START );
add_btn = gtk_button_new_from_stock ( GTK_STOCK_ADD );
g_signal_connect( add_btn, "clicked", G_CALLBACK(on_add), dlg );
gtk_box_pack_start ( GTK_BOX(btn_box), add_btn, TRUE, TRUE, 0 );
delete_btn = gtk_button_new_from_stock ( GTK_STOCK_DELETE );
g_signal_connect( delete_btn, "clicked", G_CALLBACK(on_delete), dlg );
gtk_box_pack_start ( GTK_BOX(btn_box), delete_btn, TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), btn_box,
FALSE, FALSE, 4 );
gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )), scroll, TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX(gtk_dialog_get_content_area ( GTK_DIALOG(dlg) )),
gtk_label_new(_("Use drag & drop to sort the items")),
FALSE, FALSE, 4 );
gtk_window_set_default_size ( GTK_WINDOW(dlg), 480, 400 );
gtk_widget_show_all( dlg );
gtk_widget_grab_focus( list_view );
pcmanfm_ref();
if( gtk_dialog_run( GTK_DIALOG(dlg) ) == GTK_RESPONSE_OK )
{
l = NULL;
if( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(list), &it ) )
{
do
{
gtk_tree_model_get( GTK_TREE_MODEL(list), &it,
COL_NAME, &name,
COL_DIRPATH, &path,
-1 );
if( ! name )
name = g_path_get_basename( path );
item = ptk_bookmarks_item_new( name, strlen(name),
path ? path : "", path ? strlen(path) : 0 );
l = g_list_append( l, item );
g_free(name);
g_free(path);
}
while( gtk_tree_model_iter_next( GTK_TREE_MODEL(list), &it) );
}
ptk_bookmarks_set( l );
ret = TRUE;
}
ptk_bookmarks_unref();
gtk_widget_destroy( dlg );
pcmanfm_unref();
return ret;
}
static void
questions_tree_view_row_activated (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
gpointer user_data)
{
GPInstructLessonTestMultiChoiceEditor *editor = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data);
GPInstructLessonTestMultiChoiceEditorPrivate *priv = editor->priv;
GPInstructObject *object;
GtkTreeIter iter;
GtkWidget *scrolled_window, *text_view, *explanation_view, *answer_combobox;
if (gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->questions_store), &iter, path))
{
gtk_tree_model_get (GTK_TREE_MODEL (priv->questions_store), &iter,
DATA_COLUMN, &object,
-1);
if (GPINSTRUCT_IS_LESSON_TEST_MULTI_CHOICE_QUESTION (object))
{
GPInstructLessonTestMultiChoiceQuestion *question = GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_QUESTION (object);
guint choices_num = gpinstruct_lesson_test_multi_choice_question_get_choices_length (question);
GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Question Properties"),
GTK_WINDOW (priv->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 300);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
text_view = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD_CHAR);
gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)),
gpinstruct_lesson_test_multi_choice_question_get_text (question),
-1);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_box_pack_start (GTK_BOX (content_area),
gtk_label_new (_("Text:")),
FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (content_area),
scrolled_window,
TRUE, TRUE, 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
explanation_view = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (explanation_view), GTK_WRAP_WORD_CHAR);
gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (explanation_view)),
gpinstruct_lesson_test_multi_choice_question_get_explanation (question),
-1);
gtk_container_add (GTK_CONTAINER (scrolled_window), explanation_view);
gtk_box_pack_start (GTK_BOX (content_area),
gtk_label_new (_("Explanation:")),
FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (content_area),
scrolled_window,
TRUE, TRUE, 0);
if (choices_num)
{
answer_combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->choices_store));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (answer_combobox), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (answer_combobox), renderer,
"text", TITLE_COLUMN,
NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (answer_combobox),
gpinstruct_lesson_test_multi_choice_question_get_answer (question));
gtk_box_pack_start (GTK_BOX (content_area),
gtk_label_new (_("Answer:")),
FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (content_area),
answer_combobox,
FALSE, TRUE, 0);
}
gtk_widget_show_all (content_area);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
GtkTextIter start, end;
gchar *text;
gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)),
&start, &end);
text = gtk_text_iter_get_text (&start, &end);
gpinstruct_lesson_test_multi_choice_question_set_text (question, text);
g_free (text);
gtk_text_buffer_get_bounds (gtk_text_view_get_buffer (GTK_TEXT_VIEW (explanation_view)),
&start, &end);
text = gtk_text_iter_get_text (&start, &end);
gpinstruct_lesson_test_multi_choice_question_set_explanation (question, text);
g_free (text);
if (choices_num)
gpinstruct_lesson_test_multi_choice_question_set_answer (question,
gtk_combo_box_get_active (GTK_COMBO_BOX (answer_combobox)));
update_questions_tree_view (GPINSTRUCT_LESSON_TEST_MULTI_CHOICE_EDITOR (user_data));
gpinstruct_editor_window_set_modified (priv->window, TRUE);
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->questions_store),
&iter, NULL, gtk_tree_path_get_indices (path)[0]);
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), &iter);
}
gtk_widget_destroy (dialog);
}
}
}
/****************************************************************
...
*****************************************************************/
void itree_select(GtkTreeSelection *selection, ITree *it)
{
gtk_tree_selection_select_iter(selection, &it->it);
}
static void
ft_manager_add_handler_to_list (EmpathyFTManager *manager,
EmpathyFTHandler *handler,
const GError *error)
{
GtkTreeRowReference *row_ref;
GtkTreeIter iter;
GtkTreeSelection *selection;
GtkTreePath *path;
GIcon *icon;
const char *content_type, *second_line;
char *first_line, *message;
EmpathyFTManagerPriv *priv = GET_PRIV (manager);
icon = NULL;
/* get the icon name from the mime-type of the file. */
content_type = empathy_ft_handler_get_content_type (handler);
if (content_type != NULL)
icon = g_content_type_get_icon (content_type);
/* append the handler in the store */
gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->model),
&iter, G_MAXINT, COL_FT_OBJECT, handler,
COL_ICON, icon, -1);
if (icon != NULL)
g_object_unref (icon);
/* insert the new row_ref in the hash table */
path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->model), &iter);
row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->model), path);
gtk_tree_path_free (path);
g_hash_table_insert (priv->ft_handler_to_row_ref, g_object_ref (handler),
row_ref);
/* select the new row */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
gtk_tree_selection_select_iter (selection, &iter);
if (error != NULL)
{
message = ft_manager_format_error_message (handler, error);
ft_manager_update_handler_message (manager, row_ref, message);
g_free (message);
return;
}
/* update the row with the initial values.
* the only case where we postpone this is in case we're managing
* an outgoing+hashing transfer, as the hashing started signal will
* take care of updating the information.
*/
if (empathy_ft_handler_is_incoming (handler) ||
!empathy_ft_handler_get_use_hash (handler)) {
first_line = ft_manager_format_contact_info (handler);
second_line = _("Waiting for the other participant's response");
message = g_strdup_printf ("%s\n%s", first_line, second_line);
ft_manager_update_handler_message (manager, row_ref, message);
g_free (first_line);
g_free (message);
}
/* hook up the signals and start the transfer */
ft_manager_start_transfer (manager, handler);
}
static void
add_account (GoaPanel *panel)
{
GtkWindow *parent;
GtkWidget *dialog;
gint response;
GList *providers;
GList *l;
GoaObject *object;
GError *error;
providers = NULL;
parent = GTK_WINDOW (cc_shell_get_toplevel (cc_panel_get_shell (CC_PANEL (panel))));
dialog = goa_panel_add_account_dialog_new (panel->client);
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
providers = goa_provider_get_all ();
for (l = providers; l != NULL; l = l->next)
{
GoaProvider *provider;
provider = GOA_PROVIDER (l->data);
goa_panel_add_account_dialog_add_provider (GOA_PANEL_ADD_ACCOUNT_DIALOG (dialog), provider);
}
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response != GTK_RESPONSE_OK)
{
gtk_widget_destroy (dialog);
goto out;
}
error = NULL;
object = goa_panel_add_account_dialog_get_account (GOA_PANEL_ADD_ACCOUNT_DIALOG (dialog), &error);
gtk_widget_destroy (dialog);
/* We might have an object even when error is set.
* eg., if we failed to store the credentials in the keyring.
*/
if (object != NULL)
{
GtkTreeIter iter;
/* navigate to newly created object */
if (goa_panel_accounts_model_get_iter_for_object (panel->accounts_model,
object,
&iter))
{
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->accounts_treeview)),
&iter);
}
g_object_unref (object);
}
if (error != NULL)
{
if (!(error->domain == GOA_ERROR && error->code == GOA_ERROR_DIALOG_DISMISSED))
{
dialog = gtk_message_dialog_new (parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Error creating account"));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
"%s",
error->message);
gtk_widget_show_all (dialog);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
g_error_free (error);
}
out:
g_list_foreach (providers, (GFunc) g_object_unref, NULL);
g_list_free (providers);
}
static GtkWidget *
ical_get_preview (icalcomponent *icalcomp)
{
GtkWidget *preview;
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkListStore *store;
GtkTreeIter iter;
GHashTable *timezones;
icalcomponent *subcomp;
icaltimezone *users_zone;
if (!icalcomp || !is_icalcomp_usable (icalcomp))
return NULL;
store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, E_TYPE_CAL_COMPONENT);
timezones = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, free_zone_cb);
users_zone = get_users_timezone ();
/* get timezones first */
for (subcomp = icalcomponent_get_first_component (icalcomp, ICAL_VTIMEZONE_COMPONENT);
subcomp;
subcomp = icalcomponent_get_next_component (icalcomp, ICAL_VTIMEZONE_COMPONENT)) {
icaltimezone *zone = icaltimezone_new ();
if (!icaltimezone_set_component (zone, icalcomponent_new_clone (subcomp)) || !icaltimezone_get_tzid (zone)) {
icaltimezone_free (zone, 1);
} else {
g_hash_table_insert (timezones, (gchar *) icaltimezone_get_tzid (zone), zone);
}
}
/* then each component */
for (subcomp = icalcomponent_get_first_component (icalcomp, ICAL_ANY_COMPONENT);
subcomp;
subcomp = icalcomponent_get_next_component (icalcomp, ICAL_ANY_COMPONENT)) {
icalcomponent_kind kind = icalcomponent_isa (subcomp);
if (kind == ICAL_VEVENT_COMPONENT ||
kind == ICAL_VTODO_COMPONENT ||
kind == ICAL_VJOURNAL_COMPONENT) {
ECalComponent *comp = e_cal_component_new ();
ECalComponentText summary = { 0 };
ECalComponentDateTime dt = { 0 };
gchar *formatted_dt;
if (!e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (subcomp))) {
g_object_unref (comp);
continue;
}
e_cal_component_get_summary (comp, &summary);
e_cal_component_get_dtstart (comp, &dt);
formatted_dt = format_dt (&dt, timezones, users_zone);
gtk_list_store_append (store, &iter);
gtk_list_store_set (
store, &iter,
0, kind == ICAL_VEVENT_COMPONENT ? (e_cal_component_has_attendees (comp) ? C_("iCalImp", "Meeting") : C_("iCalImp", "Event")) :
kind == ICAL_VTODO_COMPONENT ? C_("iCalImp", "Task") :
kind == ICAL_VJOURNAL_COMPONENT ? C_("iCalImp", "Memo") : "??? Other ???",
1, formatted_dt ? formatted_dt : "",
2, summary.value && *summary.value ? summary.value : summary.altrep && *summary.altrep ? summary.altrep : "",
3, comp,
-1);
g_free (formatted_dt);
e_cal_component_free_datetime (&dt);
g_object_unref (comp);
}
}
if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter)) {
g_object_unref (store);
g_hash_table_destroy (timezones);
return NULL;
}
preview = e_web_view_preview_new ();
gtk_widget_show (preview);
g_object_set_data_full (G_OBJECT (preview), "iCalImp-timezones", timezones, (GDestroyNotify) g_hash_table_destroy);
g_object_set_data (G_OBJECT (preview), "iCalImp-userszone", users_zone);
tree_view = e_web_view_preview_get_tree_view (E_WEB_VIEW_PREVIEW (preview));
g_return_val_if_fail (tree_view != NULL, NULL);
gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (store));
g_object_unref (store);
/* Translators: Column header for a component type; it can be Event, Task or Memo */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("iCalImp", "Type"),
gtk_cell_renderer_text_new (), "text", 0, NULL);
/* Translators: Column header for a component start date/time */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("iCalImp", "Start"),
gtk_cell_renderer_text_new (), "text", 1, NULL);
/* Translators: Column header for a component summary */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("iCalImp", "Summary"),
gtk_cell_renderer_text_new (), "text", 2, NULL);
if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL) > 1)
e_web_view_preview_show_tree_view (E_WEB_VIEW_PREVIEW (preview));
selection = gtk_tree_view_get_selection (tree_view);
gtk_tree_selection_select_iter (selection, &iter);
g_signal_connect (
selection, "changed",
G_CALLBACK (preview_selection_changed_cb), preview);
preview_selection_changed_cb (selection, E_WEB_VIEW_PREVIEW (preview));
return preview;
}
static void
activate (GApplication *app)
{
GtkBuilder *builder;
GtkWindow *window;
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter iter;
GError *error = NULL;
GtkWidget *sw;
GtkWidget *scrollbar;
GtkWidget *menu;
GtkWidget *item;
static GActionEntry win_entries[] = {
{ "run", activate_run, NULL, NULL, NULL }
};
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/ui/main.ui", &error);
if (error != NULL)
{
g_critical ("%s", error->message);
exit (1);
}
window = (GtkWindow *)gtk_builder_get_object (builder, "window");
gtk_application_add_window (GTK_APPLICATION (app), window);
g_action_map_add_action_entries (G_ACTION_MAP (window),
win_entries, G_N_ELEMENTS (win_entries),
window);
notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook");
info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview");
source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview");
headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar");
treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
sw = (GtkWidget *)gtk_builder_get_object (builder, "source-scrolledwindow");
scrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (sw));
menu = gtk_menu_new ();
item = gtk_menu_item_new_with_label ("Start");
g_signal_connect (item, "activate", G_CALLBACK (start_cb), scrollbar);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_menu_item_new_with_label ("End");
g_signal_connect (item, "activate", G_CALLBACK (end_cb), scrollbar);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show_all (menu);
g_signal_connect (scrollbar, "popup-menu", G_CALLBACK (scrollbar_popup), menu);
load_file (gtk_demos[0].name, gtk_demos[0].filename);
populate_model (model);
g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model);
widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection");
g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model);
gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter);
gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview));
gtk_widget_show_all (GTK_WIDGET (window));
g_object_unref (builder);
}
int handle_lobby(GladeXML* g_lobby_xml, GladeXML* g_table_info_xml, GladeXML* g_lobby_tabs_xml, GladeXML* g_cashier_button_xml, GladeXML* g_clock_xml, GtkLayout* screen, int init)
{
static int s_selected_table = 0;
s_screen = screen;
if(init) {
textdomain ("poker2d");
int i;
s_lobby_xml = g_lobby_xml;
s_lobby_window = gui_get_widget(g_lobby_xml, "lobby_window");
g_assert(s_lobby_window);
set_nil_draw_focus(s_lobby_window);
if(screen) gtk_layout_put(screen, s_lobby_window, 0, 0);
s_notebook = GTK_NOTEBOOK(gui_get_widget(g_lobby_xml, "notebook"));
g_assert(s_notebook);
for(i = 0; i < VARIANTS_COUNT; i++) {
char tmp[32];
s_variants_store[i] = gtk_list_store_new(12, G_TYPE_INT,
GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING
);
snprintf(tmp, 32, "%s_treeview", s_variants_names[i]);
GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_lobby_xml, tmp));
GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview);
g_signal_connect(selection, "changed", (GCallback)on_lobby_list_treeview_selection_changed, &s_selected_table);
s_variants_selection[i] = selection;
g_signal_connect(treeview, "row-activated", (GCallback)on_row_activated, &s_selected_table);
gtk_tree_view_set_rules_hint(treeview, TRUE);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_variants_store[i]));
GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new();
#define TABLE_COLUMN_ID 0
#define TABLE_COLUMN_MY 1
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_title(column, gettext("My") );
gtk_tree_view_column_pack_start(column, pixbuf_renderer, TRUE);
gtk_tree_view_column_add_attribute(column, pixbuf_renderer, "pixbuf", TABLE_COLUMN_MY);
}
{
GError* error = 0;
gchar* filename;
filename = glade_xml_relative_file(g_lobby_xml, "table_bullet_my.png");
if(g_file_test(filename, G_FILE_TEST_EXISTS)) {
pixbuf_table_my = gdk_pixbuf_new_from_file(filename, &error);
if(pixbuf_table_my == NULL) {
GtkIconTheme* theme = gtk_icon_theme_get_default();
error = 0;
pixbuf_table_my = gtk_icon_theme_load_icon(theme,
"stock_book_open",
16,
0,
&error);
if (!pixbuf_table_my) {
g_warning ("Couldn't load icon: %s", error->message);
}
}
}
g_free(filename);
}
#define SET_COLUMN(TITLE, INDEX) \
{ \
GtkTreeViewColumn* column = gtk_tree_view_column_new(); \
gtk_tree_view_append_column(treeview, column); \
gtk_tree_view_column_set_title(column, TITLE); \
gtk_tree_view_column_pack_start(column, text_renderer, TRUE); \
gtk_tree_view_column_add_attribute(column, text_renderer, "text", INDEX); \
}
#define TABLE_COLUMN_NAME 2
SET_COLUMN( gettext("Name"), TABLE_COLUMN_NAME);
#define TABLE_COLUMN_STRUCTURE 3
SET_COLUMN( gettext("Structure"), TABLE_COLUMN_STRUCTURE);
#define TABLE_COLUMN_SEATS 4
SET_COLUMN( gettext("Seats"), TABLE_COLUMN_SEATS);
#define TABLE_COLUMN_AVG_POT 5
SET_COLUMN( gettext("Avg.pot"), TABLE_COLUMN_AVG_POT);
#define TABLE_COLUMN_HANDS_PER_HOUR 6
SET_COLUMN( gettext("Hands/h"), TABLE_COLUMN_HANDS_PER_HOUR);
#define TABLE_COLUMN_PERCENT_FLOP 7
SET_COLUMN( gettext("Flop%"), TABLE_COLUMN_PERCENT_FLOP);
#define TABLE_COLUMN_PLAYING 8
SET_COLUMN( gettext("Playing"), TABLE_COLUMN_PLAYING);
#define TABLE_COLUMN_OBSERVING 9
#define TABLE_COLUMN_WAITING 10
#define TABLE_COLUMN_TIMEOUT 11
#undef SET_COLUMN
}
s_players_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "players_label"));
s_tables_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "tables_label"));
GUI_BRANCH(g_lobby_xml, on_all_radio_clicked);
GUI_BRANCH(g_lobby_xml, on_money_one_radio_clicked);
GUI_BRANCH(g_lobby_xml, on_money_two_radio_clicked);
s_table_info_window = gui_get_widget(g_table_info_xml, "table_info_window");
g_assert(s_table_info_window);
if(screen) gtk_layout_put(screen, s_table_info_window, 0, 0);
{
s_players_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_table_info_xml, "players_treeview"));
gtk_tree_view_set_rules_hint(treeview, TRUE);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_players_store));
GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new();
#define PLAYERS_COLUMN_NAME 0
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_title(column, gettext("Players") );
gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
gtk_tree_view_column_add_attribute(column, text_renderer, "text", 0);
}
#define PLAYERS_COLUMN_CHIPS 1
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_title(column, gettext("Chips") );
gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
gtk_tree_view_column_add_attribute(column, text_renderer, "text", 1);
}
#define PLAYERS_COLUMN_FLAG 2
}
s_go_to_label = GTK_LABEL(glade_xml_get_widget(g_table_info_xml, "label_go_to"));
s_go_to_button = GTK_BUTTON(glade_xml_get_widget(g_table_info_xml, "button_go_to"));
g_signal_connect(GTK_OBJECT(s_go_to_button), "clicked", (GtkSignalFunc)on_go_to_clicked, &s_selected_table);
s_lobby_tabs_window = gui_get_widget(g_lobby_tabs_xml, "lobby_tabs_window");
g_assert(s_lobby_tabs_window);
gtk_widget_set_size_request(s_lobby_tabs_window, gui_width(screen), -1);
if(screen) gtk_layout_put(screen, s_lobby_tabs_window, 0, 0);
GUI_BRANCH(g_lobby_tabs_xml, on_table_toggled);
GUI_BRANCH(g_lobby_tabs_xml, on_tourney_toggled);
s_cashier_button_window = gui_get_widget(g_cashier_button_xml, "cashier_button_window");
g_assert(s_cashier_button_window);
if(screen) gtk_layout_put(screen, s_cashier_button_window, 0, 0);
s_cashier_button = GTK_BUTTON(gui_get_widget(g_cashier_button_xml, "cashier_button"));
g_assert(s_cashier_button);
GUI_BRANCH(g_cashier_button_xml, on_cashier_button_pressed);
s_clock_window = gui_get_widget(g_clock_xml, "clock_window");
g_assert(s_clock_window);
if(screen) gtk_layout_put(screen, s_clock_window, 0, 0);
s_clock_label = gui_get_widget(g_clock_xml, "clock_label");
close_lobby();
}
char* tag = get_string();
if(!strcmp(tag, "show")) {
g_lobby_tab_state = lobby;
{
char* label = get_string();
gtk_button_set_label(s_cashier_button, label);
g_free(label);
}
if (screen != NULL || s_lobby_shown == 0)
{
//
// calculate windows position
//
int screen_width = gui_width(screen);
int screen_height = gui_height(screen);
int top_left_x = (screen_width - 1000) / 2;
int top_left_y = (screen_height - 450) / 2;
{
static position_t position;
position.x = screen_width - 610;
position.y = top_left_y;
gui_place(s_lobby_window, &position, screen);
}
{
static position_t position;
position.x = top_left_x;
position.y = top_left_y;
gui_place(s_table_info_window, &position, screen);
}
{
static position_t position;
position.x = 0;
position.y = 33;
gui_place(s_lobby_tabs_window, &position, screen);
}
{
static position_t position;
position.x = top_left_x;
position.y = top_left_y + 435;
gui_place(s_cashier_button_window, &position, screen);
}
s_lobby_shown = 1;
}
{
gui_bottom_right(s_clock_window, screen);
}
s_selected_table = 0;
{
char* type = get_string();
if(!strcmp(type, "holdem")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_HOLDEM);
} else if(!strcmp(type, "omaha")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA);
} else if(!strcmp(type, "omaha8")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA8);
} else if(!strcmp(type, "7stud")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_7STUD);
}
GtkToggleButton* button = GTK_TOGGLE_BUTTON(gui_get_widget(g_lobby_tabs_xml, type));
g_assert(button);
gtk_toggle_button_set_active(button, TRUE);
g_free(type);
}
{
char* currency_serial = get_string();
char* button;
GtkWidget* radio;
if(!strcmp(currency_serial, "money_two")) {
button = "money_two_radio";
} else if(!strcmp(currency_serial, "money_one")) {
button = "money_one_radio";
} else {
button = "all_radio";
}
{
//moneyone
GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_one_radio");
char* label = get_string();
gtk_button_set_label(GTK_BUTTON(sl), label);
g_free(label);
}
{
//moneytwo
GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_two_radio");
char* label = get_string();
gtk_button_set_label(GTK_BUTTON(sl), label);
g_free(label);
}
s_disable_buttons = 1;
radio = gui_get_widget(s_lobby_xml, button);
g_assert(radio);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE);
s_disable_buttons = 0;
g_free(currency_serial);
}
} else if(!strcmp(tag, "hide")) {
g_lobby_tab_state = none;
close_lobby();
} else if(!strcmp(tag, "info")) {
char* players_count = get_string();
char* tables_count = get_string();
gtk_label_set_text(s_players_label, players_count);
gtk_label_set_text(s_tables_label, tables_count);
g_free(players_count);
g_free(tables_count);
} else if(!strcmp(tag, "holdem") || !strcmp(tag, "omaha") ||
!strcmp(tag, "omaha8") || !strcmp(tag, "7stud")) {
int selected = get_int();
int rows = get_int();
int i;
int variant_index = VARIANT_HOLDEM;
if(!strcmp(tag, "holdem")) {
variant_index = VARIANT_HOLDEM;
} else if(!strcmp(tag, "omaha")) {
variant_index = VARIANT_OMAHA;
} else if(!strcmp(tag, "omaha8")) {
variant_index = VARIANT_OMAHA8;
} else if(!strcmp(tag, "7stud")) {
variant_index = VARIANT_7STUD;
}
gtk_list_store_clear(s_variants_store[variant_index]);
for(i = 0; i < rows; i++) {
int id = get_int();
GtkTreeIter iter;
gtk_list_store_append(s_variants_store[variant_index], &iter);
gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_ID, id, -1);
if(selected == id)
gtk_tree_selection_select_iter(s_variants_selection[variant_index], &iter);
{
char* my = get_string();
GdkPixbuf* pixbuf = 0;
if(!strcmp(my, "yes")) {
pixbuf = pixbuf_table_my;
}
gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_MY, pixbuf, -1);
}
#define SET_COLUMN(INDEX) \
{ \
char* content = get_string(); \
gtk_list_store_set(s_variants_store[variant_index], &iter, INDEX, content, -1); \
g_free(content); \
}
SET_COLUMN(TABLE_COLUMN_NAME);
SET_COLUMN(TABLE_COLUMN_STRUCTURE);
SET_COLUMN(TABLE_COLUMN_SEATS);
SET_COLUMN(TABLE_COLUMN_AVG_POT);
SET_COLUMN(TABLE_COLUMN_HANDS_PER_HOUR);
SET_COLUMN(TABLE_COLUMN_PERCENT_FLOP);
SET_COLUMN(TABLE_COLUMN_PLAYING);
SET_COLUMN(TABLE_COLUMN_OBSERVING);
SET_COLUMN(TABLE_COLUMN_WAITING);
SET_COLUMN(TABLE_COLUMN_TIMEOUT);
#undef SET_COLUMN
}
s_selected_table = selected;
if(!selected) {
gtk_list_store_clear(s_players_store);
gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), FALSE);
}
} else if(!strcmp(tag, "players")) {
int players_count = get_int();
int i;
gtk_label_set_text(s_go_to_label, gettext("GO TO TABLE") );
gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), TRUE);
gtk_list_store_clear(s_players_store);
for(i = 0; i < players_count; i++) {
char* name = get_string();
char* chips = get_string();
int flag = get_int();
GtkTreeIter iter;
gtk_list_store_append(s_players_store, &iter);
gtk_list_store_set(s_players_store, &iter, PLAYERS_COLUMN_NAME, name, PLAYERS_COLUMN_CHIPS, chips, PLAYERS_COLUMN_FLAG, flag, -1);
g_free(name);
g_free(chips);
}
}
//
// set clock time
//
{
time_t _time;
char date_buffer[8];
time(&_time);
struct tm* _tm = gmtime(&_time);
snprintf(date_buffer, sizeof (date_buffer), "%02d:%02d",
_tm->tm_hour, _tm->tm_min);
gtk_label_set_text(GTK_LABEL(s_clock_label), date_buffer);
}
g_free(tag);
return TRUE;
}
static void
add_ims(GevoAddBuddyDialog *dialog, EContact *contact, const char *name,
GList *list, const char *id)
{
PurpleAccount *account = NULL;
GList *l;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
if (list == NULL)
return;
for (l = purple_connections_get_all(); l != NULL; l = l->next)
{
PurpleConnection *gc = (PurpleConnection *)l->data;
account = purple_connection_get_account(gc);
if (!strcmp(purple_account_get_protocol_id(account), id))
break;
account = NULL;
}
if (account == NULL)
return;
pixbuf = pidgin_create_prpl_icon(account, 0.5);
for (l = list; l != NULL; l = l->next)
{
char *account_name = (char *)l->data;
if (account_name == NULL)
continue;
if (purple_find_buddy(dialog->account, account_name) != NULL)
continue;
gtk_list_store_append(dialog->model, &iter);
gtk_list_store_set(dialog->model, &iter,
COLUMN_NAME, name,
COLUMN_PRPL_ICON, pixbuf,
COLUMN_USERNAME, account_name,
COLUMN_DATA, contact,
-1);
if (!strcmp(purple_account_get_protocol_id(account),
purple_account_get_protocol_id(dialog->account)) &&
dialog->username != NULL &&
!strcmp(account_name, dialog->username))
{
GtkTreeSelection *selection;
/* This is it. Select it. */
selection = gtk_tree_view_get_selection(
GTK_TREE_VIEW(dialog->treeview));
gtk_tree_selection_select_iter(selection, &iter);
}
}
if (pixbuf != NULL)
g_object_unref(G_OBJECT(pixbuf));
g_list_foreach(list, (GFunc)g_free, NULL);
g_list_free(list);
}
int I_PickIWad_Gtk (WadStuff *wads, int numwads, bool showwin, int defaultiwad)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *bbox;
GtkWidget *widget;
GtkWidget *tree;
GtkWidget *check;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkTreeIter iter, defiter;
int close_style = 0;
int i;
char caption[100];
// Create the dialog window.
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
mysnprintf(caption, countof(caption), GAMESIG " %s: Select an IWAD to use", GetVersionString());
gtk_window_set_title (GTK_WINDOW(window), caption);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width (GTK_CONTAINER(window), 10);
g_signal_connect (window, "delete_event", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect (window, "key_press_event", G_CALLBACK(CheckEscape), NULL);
// Create the vbox container.
vbox = gtk_vbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER(window), vbox);
// Create the top label.
widget = gtk_label_new ("ZDoom found more than one IWAD\nSelect from the list below to determine which one to use:");
gtk_box_pack_start (GTK_BOX(vbox), widget, false, false, 0);
gtk_misc_set_alignment (GTK_MISC(widget), 0, 0);
// Create a list store with all the found IWADs.
store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
for (i = 0; i < numwads; ++i)
{
const char *filepart = strrchr (wads[i].Path, '/');
if (filepart == NULL)
filepart = wads[i].Path;
else
filepart++;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, filepart,
1, wads[i].Name.GetChars(),
2, i,
-1);
if (i == defaultiwad)
{
defiter = iter;
}
}
// Create the tree view control to show the list.
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("IWAD", renderer, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Game", renderer, "text", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(tree), true, true, 0);
g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(DoubleClickChecker), &close_style);
g_signal_connect(G_OBJECT(tree), "key_press_event", G_CALLBACK(AllowDefault), window);
// Select the default IWAD.
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_select_iter (selection, &defiter);
// Create the hbox for the bottom row.
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX(vbox), hbox, false, false, 0);
// Create the "Don't ask" checkbox.
check = gtk_check_button_new_with_label ("Don't ask me this again");
gtk_box_pack_start (GTK_BOX(hbox), check, false, false, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), !showwin);
// Create the OK/Cancel button box.
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX(bbox), 10);
gtk_box_pack_end (GTK_BOX(hbox), bbox, false, false, 0);
// Create the OK button.
widget = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0);
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
gtk_widget_grab_default (widget);
g_signal_connect (widget, "clicked", G_CALLBACK(ClickedOK), &close_style);
g_signal_connect (widget, "activate", G_CALLBACK(ClickedOK), &close_style);
// Create the cancel button.
widget = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0);
g_signal_connect (widget, "clicked", G_CALLBACK(gtk_main_quit), &window);
// Finally we can show everything.
gtk_widget_show_all (window);
gtk_main ();
if (close_style == 1)
{
GtkTreeModel *model;
GValue value = { 0, { {0} } };
// Find out which IWAD was selected.
gtk_tree_selection_get_selected (selection, &model, &iter);
gtk_tree_model_get_value (GTK_TREE_MODEL(model), &iter, 2, &value);
i = g_value_get_int (&value);
g_value_unset (&value);
// Set state of queryiwad based on the checkbox.
queryiwad = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check));
}
else
{
i = -1;
}
if (GTK_IS_WINDOW(window))
{
gtk_widget_destroy (window);
// If we don't do this, then the X window might not actually disappear.
while (g_main_context_iteration (NULL, FALSE)) {}
}
return i;
}
