/*
* 1. Gets rid of all the existing arguments
* 2. Only show the label if there are any arguments
*/
static void
prepare_action_arguments_grid (GtkContainer *grid,
GUPnPServiceActionArgDirection direction,
GList *arguments)
{
GList *child_node, *children;
/* reset expander state */
gtk_expander_set_expanded (GTK_EXPANDER (in_args_expander), TRUE);
gtk_expander_set_expanded (GTK_EXPANDER (out_args_expander), FALSE);
children = gtk_container_get_children (grid);
for (child_node = children;
child_node;
child_node = child_node->next) {
gtk_widget_destroy (GTK_WIDGET (child_node->data));
}
g_list_free (children);
if (direction == GUPNP_SERVICE_ACTION_ARG_DIRECTION_IN) {
gtk_widget_set_visible (in_args_expander,
arguments != NULL);
} else {
gtk_widget_set_visible (out_args_expander,
arguments != NULL);
}
}
void bar_add(GtkWidget *bar, GtkWidget *pane)
{
GtkWidget *expander;
BarData *bd = g_object_get_data(G_OBJECT(bar), "bar_data");
PaneData *pd = g_object_get_data(G_OBJECT(pane), "pane_data");
if (!bd) return;
pd->lw = bd->lw;
pd->bar = bar;
expander = gtk_expander_new(NULL);
if (pd && pd->title)
{
gtk_expander_set_label_widget(GTK_EXPANDER(expander), pd->title);
gtk_widget_show(pd->title);
}
gtk_box_pack_start(GTK_BOX(bd->vbox), expander, FALSE, TRUE, 0);
g_signal_connect(expander, "button_release_event", G_CALLBACK(bar_menu_cb), bd);
g_signal_connect(expander, "notify::expanded", G_CALLBACK(bar_expander_cb), pd);
gtk_container_add(GTK_CONTAINER(expander), pane);
gtk_expander_set_expanded(GTK_EXPANDER(expander), pd->expanded);
gtk_widget_show(expander);
if (bd->fd && pd && pd->pane_set_fd) pd->pane_set_fd(pane, bd->fd);
}
static void
test_click_content_widget (void)
{
GtkWidget *window = gtk_test_create_simple_window ("Test Window", "Test click on content widget");
GtkWidget *expander = gtk_expander_new ("Test Expander");
GtkWidget *entry = gtk_entry_new ();
gboolean expanded;
gboolean simsuccess;
gtk_container_add (GTK_CONTAINER (expander), entry);
gtk_container_add (GTK_CONTAINER (gtk_bin_get_child (GTK_BIN (window))), expander);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
gtk_widget_show (expander);
gtk_widget_show (entry);
gtk_widget_show_now (window);
/* check click on content with expander open */
expanded = gtk_expander_get_expanded (GTK_EXPANDER (expander));
g_assert (expanded);
simsuccess = gtk_test_widget_click (entry, 1, 0);
g_assert (simsuccess == TRUE);
gtk_test_widget_wait_for_draw (expander);
expanded = gtk_expander_get_expanded (GTK_EXPANDER (expander));
g_assert (expanded);
}
static void
test_click_content_widget (void)
{
GtkWidget *window = gtk_test_create_simple_window ("Test Window", "Test click on content widget");
GtkWidget *expander = gtk_expander_new ("Test Expander");
GtkWidget *entry = gtk_entry_new ();
gboolean expanded;
gboolean simsuccess;
gtk_container_add (GTK_CONTAINER (expander), entry);
gtk_container_add (GTK_CONTAINER (gtk_bin_get_child (GTK_BIN (window))), expander);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
gtk_widget_show (expander);
gtk_widget_show (entry);
gtk_widget_show_now (window);
/* check click on content with expander open */
expanded = gtk_expander_get_expanded (GTK_EXPANDER (expander));
g_assert (expanded);
simsuccess = gtk_test_widget_click (entry, 1, 0);
g_assert (simsuccess == TRUE);
while (gtk_events_pending ()) /* let expander timeout/idle handlers update */
gtk_main_iteration ();
expanded = gtk_expander_get_expanded (GTK_EXPANDER (expander));
g_assert (expanded);
}
int main (int argc,
char *argv[])
{
GtkWidget *window, *expander, *label;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Expander");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (window, 200, 100);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
expander = gtk_expander_new_with_mnemonic ("Click _Me For More!");
label = gtk_label_new ("Hide me or show me,\nthat is your choice.");
gtk_container_add (GTK_CONTAINER (expander), label);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
gtk_container_add (GTK_CONTAINER (window), expander);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
G_MODULE_EXPORT void
expand_expander (GtkWidget *widget)
{
reftest_inhibit_snapshot ();
gtk_expander_set_expanded (GTK_EXPANDER (widget), TRUE);
g_timeout_add (500, unblock, NULL);
}
/* Helper function to add contacts label/edit widget pairs to a table,
* with respect for structured field edits.
*/
void
contacts_append_to_edit_table (GtkTable *table, GtkWidget *label,
GtkWidget *edit, gboolean do_focus)
{
guint rows, cols;
g_object_get (table, "n-rows", &rows, NULL);
g_object_get (table, "n-columns", &cols, NULL);
gtk_widget_show (label);
gtk_widget_show (edit);
if (contacts_get_structured_field (
gtk_widget_get_name (GTK_WIDGET (label)), 0)) {
GtkWidget *expander = gtk_expander_new (NULL);
GtkWidget *viewport = gtk_viewport_new (NULL, NULL);
gtk_expander_set_label_widget (GTK_EXPANDER (expander), label);
gtk_container_add (GTK_CONTAINER (viewport), edit);
gtk_widget_show (viewport);
gtk_container_add (GTK_CONTAINER (expander), viewport);
gtk_expander_set_expanded (GTK_EXPANDER (expander),
TRUE);
gtk_widget_show (expander);
gtk_widget_set_name (expander, gtk_widget_get_name (edit));
/* Highlight selected field */
if (do_focus) {
expander = contacts_edit_add_focus_events (
expander, NULL, NULL);
}
gtk_table_attach (table,
GTK_WIDGET (expander), 0, cols,
rows, rows+1, GTK_FILL | GTK_EXPAND,
GTK_FILL, 0, 0);
} else {
/* Hide the label when the entry is hidden */
g_signal_connect_swapped (G_OBJECT (edit), "hide",
G_CALLBACK (gtk_widget_hide),
label);
/* Highlight selected field */
if (do_focus) {
GList *l;
GtkWidget *box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), edit);
gtk_widget_set_name (box, gtk_widget_get_name (edit));
gtk_widget_show (box);
l = g_list_prepend (NULL, box);
label = contacts_edit_add_focus_events (
label, NULL, l);
g_list_free (l);
l = g_list_prepend (NULL, label);
edit = contacts_edit_add_focus_events (edit, box, l);
g_list_free (l);
}
gtk_table_attach (table, label,
0, 1, rows, rows+1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (table, edit, 1, cols, rows, rows+1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
}
}
XeTeXDialog::XeTeXDialog(int dummy)
{
extern Settings *settings;
ProjectConfiguration *projectconfig = settings->projectconfig(settings->genconfig.project_get());
gtkbuilder = gtk_builder_new ();
gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.xetexdialog.xml").c_str(), NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog"));
label_portion = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_portion"));
button_portion = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_portion"));
g_signal_connect((gpointer) button_portion, "clicked", G_CALLBACK(on_button_portion_clicked), gpointer(this));
expander = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "expander"));
gtk_expander_set_expanded(GTK_EXPANDER(expander), settings->session.print_dialog_options_expanded);
label_expander = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_expander"));
notebook = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "notebook"));
g_signal_connect_after((gpointer) notebook, "switch_page", G_CALLBACK(on_notebook_switch_page), gpointer(this));
label_tab_notes = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_notes"));
checkbutton_full_references = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_full_references"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_full_references), settings->session.print_references_in_notes_in_full);
// Set widget insensitive since is has not yet been implemented.
gtk_widget_set_sensitive (checkbutton_full_references, false);
label_tab_page = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_page"));
checkbutton_cropmarks = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_cropmarks"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_cropmarks), settings->session.print_crop_marks);
label_tab_mapping = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_mapping"));
button_font_mapping_clear = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_font_mapping_clear"));
filechooserbutton_font_mapping_file = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "filechooserbutton_font_mapping_file"));
g_signal_connect((gpointer) button_font_mapping_clear, "clicked", G_CALLBACK(on_button_font_mapping_clear_clicked), gpointer(filechooserbutton_font_mapping_file));
if (!projectconfig->xetex_font_mapping_file_get().empty()) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filechooserbutton_font_mapping_file), projectconfig->xetex_font_mapping_file_get().c_str());
}
label_tab_engine = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_engine"));
GSList *shaping_engine_group = NULL;
radiobutton_shaping_engine_generic = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_shaping_engine_generic"));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_generic), shaping_engine_group);
shaping_engine_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_generic));
radiobutton_shaping_engine_arab = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_shaping_engine_arab"));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_arab), shaping_engine_group);
shaping_engine_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_arab));
shaping_engine_set (projectconfig->xetex_shaping_engine_get());
InDialogHelp * indialoghelp = new InDialogHelp(dialog, gtkbuilder, NULL, "file/print/project");
cancelbutton = indialoghelp->cancelbutton;
okbutton = indialoghelp->okbutton;
gtk_widget_grab_focus(okbutton);
gtk_widget_grab_default(okbutton);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
set_gui();
}
void viewer_add_renderer (Viewer *self, Renderer *renderer, int priority)
{
renderer->priority = priority;
renderer->cmi = gtk_check_menu_item_new_with_label (renderer->name);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (renderer->cmi), renderer->enabled);
g_object_set_data (G_OBJECT (renderer->cmi), "Viewer:plugin", renderer);
g_signal_connect (G_OBJECT (renderer->cmi), "toggled",
G_CALLBACK (on_renderer_enabled_toggled), self);
g_ptr_array_add(self->renderers, renderer);
g_ptr_array_add(self->renderers_sorted, renderer);
g_ptr_array_sort(self->renderers_sorted, renderer_name_compare_function);
// What position in the sorted array is this item?
unsigned int menu_idx = g_ptr_array_find_index(self->renderers_sorted, renderer);
// add the menu item, accounting for the tear-off tab at index 0
gtk_menu_shell_insert (GTK_MENU_SHELL (self->renderers_menu), renderer->cmi, menu_idx + 1);
gtk_widget_show (renderer->cmi);
// create a control widget
if (renderer->widget) {
g_ptr_array_add(self->renderers_sorted_with_controls, renderer);
g_ptr_array_sort(self->renderers_sorted_with_controls, renderer_name_compare_function);
unsigned int control_idx = g_ptr_array_find_index(self->renderers_sorted_with_controls, renderer);
renderer->expander = gtk_expander_new (renderer->name);
gtk_expander_set_expanded (GTK_EXPANDER (renderer->expander), TRUE);
renderer->control_frame = gtk_frame_new (NULL);
if (renderer->enabled) {
gtk_widget_show (renderer->control_frame);
} else {
gtk_widget_hide (renderer->control_frame);
}
gtk_frame_set_label_widget (GTK_FRAME (renderer->control_frame), renderer->expander);
gtk_container_add (GTK_CONTAINER (renderer->control_frame), renderer->widget);
gtk_box_pack_start (GTK_BOX (self->controls_box), renderer->control_frame,
FALSE, TRUE, 0);
gtk_box_reorder_child (GTK_BOX (self->controls_box), renderer->control_frame, control_idx);
gtk_widget_show (renderer->expander);
gtk_widget_show (renderer->widget);
g_signal_connect (G_OBJECT (renderer->expander), "notify::expanded",
G_CALLBACK (on_renderer_widget_expander_notify), self);
g_object_set_data (G_OBJECT (renderer->expander),
"Viewer:plugin", renderer);
g_object_set_data (G_OBJECT (renderer->widget),
"Viewer:expander", renderer->expander);
g_object_set_data (G_OBJECT (renderer->widget),
"Viewer:frame", renderer->control_frame);
}
g_ptr_array_sort(self->renderers, sort_renderers_priority_decreasing);
}
static EmpathyRosterGroup *
ensure_roster_group (EmpathyRosterView *self,
const gchar *group)
{
GtkWidget *roster_group;
roster_group = (GtkWidget *) lookup_roster_group (self, group);
if (roster_group != NULL)
return EMPATHY_ROSTER_GROUP (roster_group);
if (!tp_strdiff (group, EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP))
roster_group = empathy_roster_group_new (group, "emblem-favorite-symbolic");
else if (!tp_strdiff (group, EMPATHY_ROSTER_MODEL_GROUP_PEOPLE_NEARBY))
roster_group = empathy_roster_group_new (group, "im-local-xmpp");
else
roster_group = empathy_roster_group_new (group, NULL);
gtk_expander_set_expanded (EMPATHY_ROSTER_GROUP (roster_group)->expander,
empathy_contact_group_get_expanded (group));
g_signal_connect (EMPATHY_ROSTER_GROUP (roster_group)->expander,
"notify::expanded", G_CALLBACK (group_expanded_cb), roster_group);
gtk_widget_show (roster_group);
gtk_container_add (GTK_CONTAINER (self), roster_group);
g_hash_table_insert (self->priv->roster_groups, g_strdup (group),
roster_group);
return EMPATHY_ROSTER_GROUP (roster_group);
}
static void
selection_changed_cb(GtkTreeSelection *selection, PidginXferDialog *dialog)
{
GtkTreeIter iter;
PurpleXfer *xfer = NULL;
if (gtk_tree_selection_get_selected(selection, NULL, &iter)) {
GValue val;
gtk_widget_set_sensitive(dialog->expander, TRUE);
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
&iter, COLUMN_DATA, &val);
xfer = g_value_get_pointer(&val);
update_detailed_info(dialog, xfer);
dialog->selected_xfer = xfer;
}
else {
gtk_expander_set_expanded(GTK_EXPANDER(dialog->expander),
FALSE);
gtk_widget_set_sensitive(dialog->expander, FALSE);
dialog->selected_xfer = NULL;
}
update_buttons(dialog, xfer);
}
static void
attachment_paned_update_status (EAttachmentPaned *paned)
{
EAttachmentView *view;
EAttachmentStore *store;
GtkExpander *expander;
GtkLabel *label;
guint num_attachments;
guint64 total_size;
gchar *display_size;
gchar *markup;
view = E_ATTACHMENT_VIEW (paned);
store = e_attachment_view_get_store (view);
expander = GTK_EXPANDER (paned->priv->expander);
label = GTK_LABEL (paned->priv->status_label);
num_attachments = e_attachment_store_get_num_attachments (store);
total_size = e_attachment_store_get_total_size (store);
display_size = g_format_size (total_size);
if (total_size > 0)
markup = g_strdup_printf (
"<b>%d</b> %s (%s)", num_attachments, ngettext (
"Attachment", "Attachments", num_attachments),
display_size);
else
markup = g_strdup_printf (
"<b>%d</b> %s", num_attachments, ngettext (
"Attachment", "Attachments", num_attachments));
gtk_label_set_markup (label, markup);
g_free (markup);
g_free (display_size);
if (num_attachments > 0) {
gtk_widget_show (paned->priv->status_icon);
gtk_widget_show (paned->priv->status_label);
gtk_expander_set_expanded (expander, TRUE);
} else {
gtk_widget_hide (paned->priv->status_icon);
gtk_widget_hide (paned->priv->status_label);
gtk_expander_set_expanded (expander, FALSE);
}
}
static void __expand_cb(GtkWidget * widget, gpointer data)
{
if (GTK_IS_EXPANDER(widget)) {
gtk_expander_set_expanded(GTK_EXPANDER(widget), TRUE);
} else if (GTK_IS_CONTAINER(widget)) {
gtk_container_foreach(GTK_CONTAINER(widget),
(GtkCallback) __expand_cb, NULL);
}
}
void wxCollapsiblePane::Collapse(bool collapse)
{
// optimization
if (IsCollapsed() == collapse)
return;
// do not send event in next signal handler call
m_bIgnoreNextChange = true;
gtk_expander_set_expanded(GTK_EXPANDER(m_widget), !collapse);
}
/**
* builder: The GTKBuilder
* dialog: ignored
*
* Reads the input_data expands the details area depending on "details"-"expanded"
*
**/
static void
prepare_details (GtkBuilder *builder, GtkDialog *dialog)
{
GtkExpander *expander;
gboolean expanded;
expander = GTK_EXPANDER (gtk_builder_get_object (builder, "details_area"));
expanded = g_key_file_get_boolean (input_data, "details", "expanded", NULL);
gtk_expander_set_expanded (expander, expanded);
}
void
doodle_add_dir_images (gchar *dir, GtkWidget *box)
{
char base_name[255];
get_base_name (dir, base_name, 255);
GtkWidget *expander = gtk_expander_new (base_name);
GtkWidget *table = doodle_add_images (dir);
gtk_container_add (GTK_CONTAINER (expander), table);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
gtk_container_add (GTK_CONTAINER (box), expander);
}
static gboolean
expand_timeout (gpointer data)
{
GtkExpander *expander = GTK_EXPANDER (data);
GtkExpanderPrivate *priv = expander->priv;
priv->expand_timer = 0;
gtk_expander_set_expanded (expander, TRUE);
return FALSE;
}
void bar_update_expander(GtkWidget *pane)
{
PaneData *pd = g_object_get_data(G_OBJECT(pane), "pane_data");
GtkWidget *expander;
if (!pd) return;
expander = gtk_widget_get_parent(pane);
gtk_expander_set_expanded(GTK_EXPANDER(expander), pd->expanded);
}
static void SetExpanded(GtkWidget *widget, gpointer data)
{
if (GTK_IS_EXPANDER(widget))
{
gtk_expander_set_expanded(GTK_EXPANDER(widget), true);
}
else if (GTK_IS_CONTAINER(widget))
{
gtk_container_forall(GTK_CONTAINER(widget), SetExpanded, data);
}
return;
}
static void
gcm_picker_got_results (GcmPickerPrivate *priv)
{
GtkWidget *widget;
/* set expanded */
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "expander_results"));
gtk_expander_set_expanded (GTK_EXPANDER (widget), TRUE);
gtk_widget_set_sensitive (widget, TRUE);
/* we've got results so make sure it's sensitive */
priv->done_measure = TRUE;
}
/**
* mcm_picker_xyz_notify_cb:
**/
static void
mcm_picker_xyz_notify_cb (McmCalibrate *calibrate_, GParamSpec *pspec, gpointer user_data)
{
GtkWidget *widget;
/* set expanded */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "expander_results"));
gtk_expander_set_expanded (GTK_EXPANDER (widget), TRUE);
gtk_widget_set_sensitive (widget, TRUE);
/* we've got results so make sure it's sensitive */
done_measure = TRUE;
mcm_picker_refresh_results ();
}
static void gfire_game_manager_reload_ui()
{
if(!gfire_gtk_builder)
return;
GtkWidget *add_game_entry = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "add_game_entry"));
GtkWidget *add_detection_button = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "add_detection_button"));
GtkWidget *add_executable_check_button = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "add_executable_check_button"));
GtkWidget *add_launch_button = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "add_launch_button"));
GtkWidget *add_advanced_expander = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "add_advanced_expander"));
GtkWidget *add_prefix_entry = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "add_prefix_entry"));
GtkWidget *edit_game_combo = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "edit_game_combo"));
GtkListStore *edit_game_list_store = GTK_LIST_STORE(gtk_builder_get_object(gfire_gtk_builder, "edit_game_list_store"));
GtkWidget *edit_detection_button = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "edit_detection_button"));
GtkWidget *edit_executable_check_button = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "edit_executable_check_button"));
GtkWidget *edit_launch_button = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "edit_launch_button"));
GtkWidget *edit_prefix_entry = GTK_WIDGET(gtk_builder_get_object(gfire_gtk_builder, "edit_prefix_entry"));
// Reset widgets on "add" tab
gtk_entry_set_text(GTK_ENTRY(add_game_entry), "");
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(add_detection_button));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(add_executable_check_button), TRUE);
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(add_launch_button));
gtk_expander_set_expanded(GTK_EXPANDER(add_advanced_expander), FALSE);
gtk_entry_set_text(GTK_ENTRY(add_prefix_entry), "");
// Reset widgets on "edit" tab
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(edit_detection_button));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(edit_executable_check_button), TRUE);
gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(edit_launch_button));
gtk_entry_set_text(GTK_ENTRY(edit_prefix_entry), "");
// Clear games list combo box
gtk_list_store_clear(edit_game_list_store);
// Add all new configured games
GList *cur = gfire_games_config;
while(cur)
{
const gfire_game *game = gfire_game_by_id(((gfire_game_configuration*)cur->data)->game_id);
if(game)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(edit_game_combo), game->name);
}
cur = g_list_next(cur);
}
}
void
viewer_load_preferences (Viewer *viewer, const char *fname)
{
GKeyFile *preferences = g_key_file_new ();
int loaded = 0;
if (g_file_test (fname, G_FILE_TEST_IS_REGULAR)) {
loaded = g_key_file_load_from_file (preferences, fname, 0, NULL);
}
if (!loaded) goto done;
dbg ("loading viewer settings from %s\n", fname);
for (int ridx = 0; ridx < viewer->renderers->len; ridx++) {
Renderer *renderer = g_ptr_array_index (viewer->renderers, ridx);
GtkCheckMenuItem *cmi = GTK_CHECK_MENU_ITEM (renderer->cmi);
GError *err = NULL;
int enabled = g_key_file_get_boolean (preferences,
"__libviewer_enabled_renderers", renderer->name, &err);
if (err) {
err ("%s\n", err->message);
g_error_free (err);
} else {
gtk_check_menu_item_set_active (cmi, enabled);
}
if (renderer->widget) {
if (g_key_file_has_key (preferences, "__libviewer_show_renderers",
renderer->name, NULL)) {
renderer->expanded = g_key_file_get_boolean (preferences,
"__libviewer_show_renderers", renderer->name, NULL);
gtk_expander_set_expanded (GTK_EXPANDER (renderer->expander),
renderer->expanded);
}
}
}
g_signal_emit (G_OBJECT(viewer), viewer_signals[LOAD_PREFERENCES_SIGNAL], 0,
preferences);
done:
g_key_file_free (preferences);
}
GtkWidget*
pp_imagecontrol_new (Layout *layout)
{
pp_ImageControl *ob=PP_IMAGECONTROL(g_object_new (pp_imagecontrol_get_type (), NULL));
ob->layout=layout;
GtkWidget *frame;
// ImageInfo
ob->imageinfo=pp_imageinfo_new(layout);
gtk_box_pack_start(GTK_BOX(ob),ob->imageinfo,FALSE,FALSE,0);
gtk_widget_show(ob->imageinfo);
ob->histogram=pp_histogram_new(layout);
gtk_box_pack_start(GTK_BOX(ob),ob->histogram,FALSE,FALSE,0);
gtk_widget_show(ob->histogram);
// FIXME add transformations here
// FIXME add border selector here
// EffectSelector
ob->expander1=frame=gtk_expander_new(_("Effects"));
g_signal_connect(ob->expander1, "notify::expanded",G_CALLBACK (expander_callback), ob);
gtk_expander_set_expanded(GTK_EXPANDER(frame),layout->state.FindInt("ExpanderState_EffectSelector"));
gtk_box_pack_start(GTK_BOX(ob),frame,TRUE,TRUE,0);
gtk_widget_show(frame);
ob->effectselector=effectselector_new();
g_signal_connect(G_OBJECT(ob->effectselector),"changed",G_CALLBACK(effectselector_changed),ob);
g_signal_connect(G_OBJECT(ob->effectselector),"addeffect",G_CALLBACK(effectselector_addeffect),ob);
g_signal_connect(G_OBJECT(ob->effectselector),"removeeffect",G_CALLBACK(effectselector_removeeffect),ob);
gtk_container_add(GTK_CONTAINER(frame),ob->effectselector);
gtk_widget_show(ob->effectselector);
return(GTK_WIDGET(ob));
}
void on_reports_title_changed(GtkWidget *entry, Logbook *logbook)
{
if (GTK_WIDGET_HAS_FOCUS(entry)) {
reports_set_modified(logbook);
gtk_expander_set_expanded(GTK_EXPANDER(logbook->reports_sql_expander), TRUE);
} else {
db_bind_text(logbook->reports_sql_by_title, 1, gtk_entry_get_text(GTK_ENTRY(logbook->reports_title)));
db_step(logbook->reports_sql_by_title);
fprintf(stderr, "Error's from here ...\n");
text_view_set_text(GTK_TEXT_VIEW(logbook->reports_sql_text), (char*)db_column_text(logbook->reports_sql_by_title, 0));
fprintf(stderr, "... to here during delete.\n");
db_reset(logbook->reports_sql_by_title);
db_clear_bindings(logbook->reports_sql_by_title);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(logbook->reports_armdel_btn), FALSE);
gtk_widget_set_sensitive(logbook->reports_armdel_btn, TRUE);
gtk_widget_set_sensitive(logbook->reports_del_btn, FALSE);
gtk_widget_set_sensitive(logbook->reports_save_btn, FALSE);
}
}
/**
@brief toggle specified option flag
@param widget clicked button, UNUSED
@param flagnum pointerized number of the flag to be toggled
@return
*/
static void _e2pc_toggle_cb (GtkWidget *widget, gpointer flagnum)
{
flag_t flg = (flag_t) flagnum;
gboolean newflag = ! _e2pc_get_flag (flg);
_e2pc_set_flag (flg, newflag);
//handle here all the 'special cases', if any
/* if (newflag)
{
switch (GPOINTER_TO_INT(flagnum))
{
default:
break;
}
} */
if (flg == CUSTOM_P)
{
NEEDCLOSEBGL
gtk_expander_set_expanded (GTK_EXPANDER (srt->expander), newflag);
NEEDOPENBGL
}
int main(int argc, char *argv[])
{
GtkWidget *window,*expander,*label;
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"DEmo");
gtk_container_set_border_width(GTK_CONTAINER(window),10);
gtk_widget_set_size_request(window,200,100);
expander = gtk_expander_new_with_mnemonic("click here");
label = gtk_label_new("Sudip is a gtk Developer.");
gtk_container_add(GTK_CONTAINER(expander),label);
gtk_expander_set_expanded(GTK_EXPANDER(expander),FALSE);
gtk_container_add(GTK_CONTAINER(window),expander);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static GtkWidget *gebr_gui_program_edit_load_parameter(GebrGuiProgramEdit *program_edit,
GebrGeoXmlParameter *parameter,
GSList **radio_group)
{
GebrGeoXmlParameterType type;
type = gebr_geoxml_parameter_get_type(parameter);
if (type == GEBR_GEOXML_PARAMETER_TYPE_GROUP) {
GtkWidget *expander;
GtkWidget *label_widget;
GtkWidget *label;
GtkWidget *image_widget;
GtkWidget *depth_hbox;
GtkWidget *group_vbox;
GtkWidget *instanciate_button;
GtkWidget *deinstanciate_button;
GebrGeoXmlParameterGroup *parameter_group;
GebrGeoXmlSequence *instance;
GebrGeoXmlSequence *param;
gboolean required;
parameter_group = GEBR_GEOXML_PARAMETER_GROUP(parameter);
expander = gtk_expander_new("");
image_widget = gtk_image_new();
program_edit->group_warning_widget = image_widget;
gtk_widget_show(expander);
gtk_expander_set_expanded(GTK_EXPANDER(expander),
gebr_geoxml_parameter_group_get_expand(parameter_group));
label_widget = gtk_hbox_new(FALSE, 0);
gtk_widget_show(label_widget);
gtk_expander_set_label_widget(GTK_EXPANDER(expander), label_widget);
gebr_gui_gtk_expander_hacked_define(expander, label_widget);
GebrGeoXmlParameters *template;
static void
panel_run_dialog_setup_list_expander (PanelRunDialog *dialog,
GtkBuilder *gui)
{
dialog->list_expander = PANEL_GTK_BUILDER_GET (gui, "list_expander");
if (panel_profile_get_enable_program_list ()) {
gtk_expander_set_expanded (GTK_EXPANDER (dialog->list_expander),
panel_profile_get_show_program_list ());
if ( ! panel_profile_is_writable_show_program_list ())
gtk_widget_set_sensitive (dialog->list_expander, FALSE);
g_signal_connect (dialog->list_expander, "notify::expanded",
G_CALLBACK (list_expander_toggled),
dialog);
g_signal_connect (dialog->settings,
"changed::" PANEL_RUN_SHOW_PROGRAM_LIST_KEY,
G_CALLBACK (panel_run_dialog_content_notify),
dialog);
}
}
void
run_action_dialog (GUPnPServiceActionInfo *action_info,
GUPnPServiceProxy *proxy,
GUPnPServiceIntrospection *introspection)
{
GList *in_arguments;
GList *out_arguments;
setup_action_dialog_labels (GUPNP_SERVICE_INFO (proxy), action_info);
in_arguments = find_arguments_by_direction (
action_info->arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_IN);
populate_action_arguments_grid (
in_args_grid,
in_arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_IN,
introspection);
out_arguments = find_arguments_by_direction (
action_info->arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_OUT);
populate_action_arguments_grid (
out_args_grid,
out_arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_OUT,
introspection);
/* If the action only has out arguments, open the out expander */
if (!in_arguments)
gtk_expander_set_expanded (GTK_EXPANDER (out_args_expander), TRUE);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
