int main(int argc, char **argv){ GtkWidget *window_main; GtkWidget *box_main; GtkWidget *box_base; GtkWidget* box_input; GtkWidget* box_input_b; GtkWidget* box_input_t; GtkWidget* box_output; GtkWidget* box_output_b; GtkWidget* box_output_t; GtkWidget* button_clear; GtkWidget* button_solve; GtkWidget* button_for; GtkWidget* button_bak; GtkWidget* scr; GtkWidget* scr2; GtkWidget* image_header; GtkWidget* label_out; GtkWidget* label_in; GtkWidget* label_out_2; gtk_init(&argc, &argv); window_main = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window_main), "---Gauss-Jordan Elimination---"); gtk_window_set_default_size(GTK_WINDOW(window_main), 800, 400); box_main = gtk_vbox_new (FALSE, 0); box_base = gtk_hbox_new (FALSE, 0); box_input = gtk_vbox_new (FALSE, 0); box_input_b = gtk_hbutton_box_new (); box_input_t = gtk_hbox_new (FALSE, 0); box_output = gtk_vbox_new (FALSE, 0); box_output_b = gtk_hbutton_box_new (); box_output_t = gtk_hbox_new (FALSE, 0); box_output_e = gtk_vbox_new (FALSE, 0); button_clear = gtk_button_new_with_label ("clear"); button_solve = gtk_button_new_with_label ("solve"); button_for = gtk_button_new_with_label ("forword"); button_bak = gtk_button_new_with_label ("backword"); entry_out = gtk_entry_new(); image_header = gtk_image_new(); label_in = gtk_label_new("input"); label_out = gtk_label_new("output"); label_out_2 = gtk_label_new("steps"); gtk_button_box_set_layout(GTK_BUTTON_BOX(box_input_b), GTK_BUTTONBOX_CENTER); gtk_box_set_spacing(GTK_BOX(box_input_b), 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(box_output_b), GTK_BUTTONBOX_CENTER); gtk_box_set_spacing(GTK_BOX(box_output_b), 0); gtk_image_set_from_file (GTK_IMAGE (image_header), "header.jpg"); gtk_box_pack_start (GTK_BOX (box_main), image_header, FALSE, FALSE, 1); gtk_widget_show (image_header); gtk_box_pack_start (GTK_BOX (box_input), label_in, FALSE, FALSE, 1); gtk_widget_show (label_in); gtk_signal_connect (GTK_OBJECT (button_clear), "clicked", GTK_SIGNAL_FUNC (clear), NULL); gtk_box_pack_start (GTK_BOX (box_input_b), button_clear, FALSE, FALSE, 1); gtk_widget_show (button_clear); gtk_signal_connect (GTK_OBJECT (button_solve), "clicked", GTK_SIGNAL_FUNC (get), NULL); gtk_box_pack_start (GTK_BOX (box_input_b), button_solve, FALSE, FALSE, 1); gtk_widget_show (button_solve); gtk_box_pack_start(GTK_BOX (box_input), box_input_b, FALSE, FALSE, 1); gtk_widget_show (box_input_b); text_rem = gtk_text_view_new(); scr = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scr), text_rem); gtk_box_pack_start(GTK_BOX (box_input_t), scr, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX (box_input), box_input_t, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX (box_base), box_input, TRUE, TRUE, 1); gtk_widget_show(scr); gtk_widget_show(text_rem); gtk_widget_show(box_input); gtk_widget_show(box_input_t); gtk_box_pack_start (GTK_BOX (box_output), label_out_2, FALSE, FALSE, 1); gtk_widget_show (label_out_2); gtk_signal_connect (GTK_OBJECT (button_bak), "clicked", GTK_SIGNAL_FUNC (set_steps_back), NULL); gtk_box_pack_start (GTK_BOX (box_output_b), button_bak, TRUE, TRUE, 1); gtk_widget_show (button_bak); gtk_signal_connect (GTK_OBJECT (button_for), "clicked", GTK_SIGNAL_FUNC (set_steps), NULL); gtk_box_pack_start (GTK_BOX (box_output_b), button_for, TRUE, TRUE, 1); gtk_widget_show (button_for); gtk_box_pack_start(GTK_BOX (box_output), box_output_b, FALSE, FALSE, 1); gtk_widget_show (box_output_b); text_step = gtk_text_view_new(); scr2 = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scr2), text_step); gtk_box_pack_start(GTK_BOX (box_output_t), scr2, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX (box_output), box_output_t, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX (box_base), box_output, TRUE, TRUE, 1); gtk_box_pack_start(GTK_BOX (box_main), box_base, TRUE, TRUE, 1); gtk_widget_show(scr2); gtk_widget_show(text_step); gtk_widget_show(box_output); gtk_widget_show(box_output_t); gtk_widget_show(box_base); gtk_box_pack_start(GTK_BOX (box_output_e), label_out, FALSE, FALSE, 1); gtk_widget_show(label_out); gtk_box_pack_start(GTK_BOX (box_output_e), entry_out, FALSE, FALSE, 1); gtk_widget_show(entry_out); gtk_box_pack_start(GTK_BOX (box_main), box_output_e, FALSE, FALSE, 3); gtk_widget_show(box_output_e); gtk_container_add(GTK_CONTAINER (window_main), box_main); gtk_widget_show(box_main); gtk_widget_show(window_main); gtk_main(); return 0; }
/** * create_directory_config_window(): Create the Directory Configuration Window. * @return Directory Configuration Window. */ GtkWidget* create_directory_config_window(void) { GdkPixbuf *directory_config_window_icon_pixbuf; GtkWidget *vbox_dc; GtkWidget *frame_direntry = NULL, *label_frame_direntry = NULL, *table_frame_direntry = NULL; GtkWidget *label_direntry = NULL, *entry_direntry = NULL, *button_direntry = NULL; GtkWidget *hbutton_box_dc_buttonRow; GtkWidget *button_dc_Cancel, *button_dc_Apply, *button_dc_Save; char tmp[64]; int dir = 0; if (directory_config_window) { // Directory Configuration window is already created. Set focus. gtk_widget_grab_focus(directory_config_window); return NULL; } accel_group = gtk_accel_group_new(); // Create the Directory Configuration window. CREATE_GTK_WINDOW(directory_config_window, "directory_config_window", "Configure Directories", directory_config_window_icon_pixbuf, "Gens2.ico"); // Callbacks for if the window is closed. g_signal_connect((gpointer)directory_config_window, "delete_event", G_CALLBACK(on_directory_config_window_close), NULL); g_signal_connect((gpointer)directory_config_window, "destroy_event", G_CALLBACK(on_directory_config_window_close), NULL); // Create the main VBox. vbox_dc = gtk_vbox_new(FALSE, 10); gtk_widget_set_name(vbox_dc, "vbox_dc"); gtk_widget_show(vbox_dc); gtk_container_add(GTK_CONTAINER(directory_config_window), vbox_dc); GLADE_HOOKUP_OBJECT(directory_config_window, vbox_dc, "vbox_dc"); // Create the directory entry frame. frame_direntry = gtk_frame_new(NULL); gtk_widget_set_name(frame_direntry, "frame_direntry"); gtk_container_set_border_width(GTK_CONTAINER(frame_direntry), 4); gtk_frame_set_shadow_type(GTK_FRAME(frame_direntry), GTK_SHADOW_ETCHED_IN); gtk_widget_show(frame_direntry); gtk_box_pack_start(GTK_BOX(vbox_dc), frame_direntry, TRUE, TRUE, 0); GLADE_HOOKUP_OBJECT(directory_config_window, frame_direntry, "frame_direntry"); // Add the frame label. label_frame_direntry = gtk_label_new("<b><i>Configure Directories</i></b>"); gtk_widget_set_name(label_frame_direntry, "label_frame_direntry"); gtk_label_set_use_markup(GTK_LABEL(label_frame_direntry), TRUE); gtk_widget_show(label_frame_direntry); gtk_frame_set_label_widget(GTK_FRAME(frame_direntry), label_frame_direntry); GLADE_HOOKUP_OBJECT(directory_config_window, label_frame_direntry, "label_frame_direntry"); // Add the frame table. table_frame_direntry = gtk_table_new(1, 3, FALSE); gtk_widget_set_name(table_frame_direntry, "table_frame_direntry"); gtk_container_set_border_width(GTK_CONTAINER(table_frame_direntry), 8); gtk_table_set_row_spacings(GTK_TABLE(table_frame_direntry), 4); gtk_table_set_col_spacings(GTK_TABLE(table_frame_direntry), 4); gtk_widget_show(table_frame_direntry); gtk_container_add(GTK_CONTAINER(frame_direntry), table_frame_direntry); GLADE_HOOKUP_OBJECT(directory_config_window, table_frame_direntry, "table_frame_direntry"); // Create all directory entries. while (DirEntries[dir].title) { // Check if the table needs to be resized. if (dir > 0) gtk_table_resize(GTK_TABLE(table_frame_direntry), dir + 1, 3); // Create the label for this file. sprintf(tmp, "label_%s", DirEntries[dir].tag); label_direntry = gtk_label_new(DirEntries[dir].title); gtk_widget_set_name(label_direntry, tmp); gtk_widget_set_size_request(label_direntry, 100, -1); gtk_misc_set_alignment(GTK_MISC(label_direntry), 0, 0.5); gtk_widget_show(label_direntry); gtk_table_attach(GTK_TABLE(table_frame_direntry), label_direntry, 0, 1, dir, dir + 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); GLADE_HOOKUP_OBJECT(directory_config_window, label_direntry, tmp); // Create the entry for this file. sprintf(tmp, "entry_%s", DirEntries[dir].tag); entry_direntry = gtk_entry_new(); gtk_widget_set_name(entry_direntry, tmp); gtk_entry_set_max_length(GTK_ENTRY(entry_direntry), GENS_PATH_MAX - 1); gtk_entry_set_text(GTK_ENTRY(entry_direntry), DirEntries[dir].entry); gtk_widget_set_size_request(entry_direntry, 250, -1); gtk_widget_show(entry_direntry); gtk_table_attach(GTK_TABLE(table_frame_direntry), entry_direntry, 1, 2, dir, dir + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(0), 0, 0); GLADE_HOOKUP_OBJECT(directory_config_window, entry_direntry, tmp); // Create the button for this file. // TODO: Use an icon? sprintf(tmp, "button_%s", DirEntries[dir].tag); button_direntry = gtk_button_new_with_label("Change..."); gtk_widget_set_name(button_direntry, tmp); gtk_widget_show(button_direntry); gtk_table_attach(GTK_TABLE(table_frame_direntry), button_direntry, 2, 3, dir, dir + 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); g_signal_connect((gpointer)button_direntry, "clicked", G_CALLBACK(on_button_dc_Change_clicked), GINT_TO_POINTER(dir)); GLADE_HOOKUP_OBJECT(directory_config_window, button_direntry, tmp); dir++; } // HButton Box for the row of buttons on the bottom of the window hbutton_box_dc_buttonRow = gtk_hbutton_box_new(); gtk_widget_set_name(hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow"); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbutton_box_dc_buttonRow), GTK_BUTTONBOX_END); gtk_widget_show(hbutton_box_dc_buttonRow); gtk_box_pack_start(GTK_BOX(vbox_dc), hbutton_box_dc_buttonRow, FALSE, FALSE, 0); GLADE_HOOKUP_OBJECT(directory_config_window, hbutton_box_dc_buttonRow, "hbutton_box_dc_buttonRow"); // Cancel button_dc_Cancel = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_set_name(button_dc_Cancel, "button_dc_cancel"); gtk_widget_show(button_dc_Cancel); gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Cancel, FALSE, FALSE, 0); gtk_widget_add_accelerator(button_dc_Cancel, "activate", accel_group, GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0)); AddButtonCallback_Clicked(button_dc_Cancel, on_button_dc_Cancel_clicked); GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Cancel, "button_dc_Cancel"); // Apply button_dc_Apply = gtk_button_new_from_stock("gtk-apply"); gtk_widget_set_name(button_dc_Apply, "button_dc_Apply"); gtk_widget_show(button_dc_Apply); gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Apply, FALSE, FALSE, 0); gtk_widget_add_accelerator(button_dc_Apply, "activate", accel_group, GDK_Escape, (GdkModifierType)(0), (GtkAccelFlags)(0)); AddButtonCallback_Clicked(button_dc_Apply, on_button_dc_Apply_clicked); GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Apply, "button_dc_Apply"); // Save button_dc_Save = gtk_button_new_from_stock("gtk-save"); gtk_widget_set_name(button_dc_Save, "button_dc_Save"); gtk_widget_show(button_dc_Save); gtk_box_pack_start(GTK_BOX(hbutton_box_dc_buttonRow), button_dc_Save, FALSE, FALSE, 0); gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group, GDK_Return, (GdkModifierType)(0), (GtkAccelFlags)(0)); gtk_widget_add_accelerator(button_dc_Save, "activate", accel_group, GDK_KP_Enter, (GdkModifierType)(0), (GtkAccelFlags)(0)); AddButtonCallback_Clicked(button_dc_Save, on_button_dc_Save_clicked); GLADE_HOOKUP_OBJECT(directory_config_window, button_dc_Save, "button_dc_Save"); // Add the accel group. gtk_window_add_accel_group(GTK_WINDOW(directory_config_window), accel_group); return directory_config_window; }
/* * Trace Capture Dialog Window * * +--------------------------------------------------------------------+ * | Dialog Window | * | +-------------------------------+-------------------------------+ | * | | Paned Window | +---------------------------+ | | * | | +---------------------------+ | | Scroll window | | | * | | | Hbox | | | +-----------------------+ | | | * | | | Label Plugin Combo | | | | Event Tree | | | | * | | +---------------------------+ | | | | | | | * | | | | | | | | | * | | | | +-----------------------+ | | | * | | | +---------------------------+ | | * | +-------------------------------+-------------------------------+ | * +--------------------------------------------------------------------+ */ static void tracing_dialog(struct shark_info *info, const char *tracing) { struct pevent *pevent; GtkWidget *dialog; GtkWidget *button; GtkWidget *combo; GtkWidget *label; GtkWidget *entry; GtkWidget *frame; GtkWidget *vbox; GtkWidget *scrollwin; GtkWidget *table; GtkWidget *table2; GtkWidget *event_tree; GtkWidget *viewport; GtkWidget *textview; GtkWidget *hbox; GtkTextBuffer *buffer; GtkTextIter start_iter; GtkTextIter end_iter; char **plugins; int nr_plugins; struct trace_capture cap; const gchar *file; const char *command; const char *val; GString *str; gint result; memset(&cap, 0, sizeof(cap)); cap.info = info; plugins = tracecmd_local_plugins(tracing); /* Skip latency plugins */ nr_plugins = trim_plugins(plugins); if (!nr_plugins && plugins) { tracecmd_free_list(plugins); plugins = NULL; } /* Send parse warnings to status display */ trace_dialog_register_alt_warning(vpr_stat); pevent = tracecmd_local_events(tracing); trace_dialog_register_alt_warning(NULL); cap.pevent = pevent; if (!pevent && !nr_plugins) { warning("No events or plugins found"); return; } dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), "Capture"); button = gtk_button_new_with_label("Run"); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button, GTK_RESPONSE_ACCEPT); gtk_widget_show(button); cap.run_button = button; gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_REJECT); cap.main_dialog = dialog; /* --- Top Level Hpaned --- */ table = gtk_table_new(4, 2, FALSE); /* It is possible that no pevents exist. */ if (pevent) { scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_table_attach(GTK_TABLE(table), scrollwin, 0, 1, 1, 2, GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0); gtk_widget_show(scrollwin); event_tree = trace_create_event_list_view(pevent, NULL, cap.info->cap_all_events, cap.info->cap_systems, cap.info->cap_events); gtk_container_add(GTK_CONTAINER(scrollwin), event_tree); gtk_widget_show(event_tree); cap.event_view = event_tree; } else { /* No events */ label = gtk_label_new("No events enabled on system"); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 10); gtk_widget_show(label); cap.event_view = NULL; } gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0); gtk_widget_show(table); /*------------------ Frame Settings --------------------------- */ frame = gtk_frame_new("Settings"); gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1, GTK_FILL, 0, 0, 10); gtk_widget_show(frame); table2 = gtk_table_new(2, 3, FALSE); gtk_container_add(GTK_CONTAINER(frame), table2); gtk_widget_show(table2); gtk_table_set_col_spacings(GTK_TABLE(table2), 5); button = gtk_button_new_with_label("Save Settings"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 0, 1, 0, 1); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (save_settings_clicked), (gpointer)&cap); button = gtk_button_new_with_label("Import Settings"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 1, 2, 0, 1); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (import_settings_clicked), (gpointer)&cap); button = gtk_button_new_with_label("Export Settings"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 0, 1); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (export_settings_clicked), (gpointer)&cap); if (cap.info->cap_settings_name) set_settings(&cap); label = gtk_label_new("Available Settings: "); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2); gtk_widget_show(label); combo = trace_create_combo_box(NULL, NULL, create_settings_model, NULL); gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 1, 2); cap.settings_combo = combo; g_signal_connect (combo, "changed", G_CALLBACK (settings_changed), (gpointer)&cap); /*------------------ Frame Settings --------------------------- */ frame = gtk_frame_new("Execute"); gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 3, 4, GTK_FILL, 0, 0, 10); gtk_widget_show(frame); table2 = gtk_table_new(3, 3, FALSE); gtk_container_add(GTK_CONTAINER(frame), table2); gtk_widget_show(table2); label = gtk_label_new("Plugin: "); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 0, 1); gtk_widget_show(label); combo = trace_create_combo_box(NULL, NULL, create_plugin_combo_model, plugins); cap.plugin_combo = combo; gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 0, 1); if (cap.info->cap_plugin) set_plugin(&cap); label = gtk_label_new("Command:"); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2); gtk_widget_show(label); entry = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 3, 1, 2); gtk_widget_show(entry); cap.command_entry = entry; if (cap.info->cap_command) gtk_entry_set_text(GTK_ENTRY(entry), cap.info->cap_command); label = gtk_label_new("Output file: "); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 2, 3); gtk_widget_show(label); entry = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 2, 2, 3); gtk_widget_show(entry); if (cap.info->cap_file) file = cap.info->cap_file; else file = default_output_file; gtk_entry_set_text(GTK_ENTRY(entry), file); cap.file_entry = entry; button = gtk_button_new_with_label("Browse"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 2, 3); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (file_clicked), (gpointer)&cap); /*------------------ Command Output ------------------ */ vbox = gtk_vbox_new(FALSE, 0); gtk_table_attach_defaults(GTK_TABLE(table), vbox, 1, 2, 0, 4); gtk_widget_show(vbox); gtk_widget_set_size_request(GTK_WIDGET(vbox), 500, 0); label = gtk_label_new("Output Display:"); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); gtk_widget_show(scrollwin); viewport = gtk_viewport_new(NULL, NULL); gtk_widget_show(viewport); gtk_container_add(GTK_CONTAINER(scrollwin), viewport); textview = gtk_text_view_new(); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); gtk_container_add(GTK_CONTAINER(viewport), textview); gtk_widget_show(textview); cap.output_text = textview; cap.output_buffer = buffer; /* set the buffer from its previous setting */ if (info->cap_buffer_output) gtk_text_buffer_set_text(buffer, info->cap_buffer_output, strlen(info->cap_buffer_output)); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); label = gtk_label_new("Max # of characters in output display: "); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_widget_show(label); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0); gtk_widget_show(entry); cap.max_num_entry = entry; if (!info->cap_max_buf_size) info->cap_max_buf_size = DEFAULT_MAX_BUF_SIZE; str = g_string_new(""); g_string_append_printf(str, "%d", info->cap_max_buf_size); gtk_entry_set_text(GTK_ENTRY(entry), str->str); g_string_free(str, TRUE); g_signal_connect (entry, "insert-text", G_CALLBACK (insert_text), (gpointer)&cap); gtk_widget_set_size_request(GTK_WIDGET(dialog), DIALOG_WIDTH, DIALOG_HEIGHT); gtk_widget_show(dialog); cont: result = gtk_dialog_run(GTK_DIALOG(dialog)); if (result == GTK_RESPONSE_ACCEPT) { execute_button_clicked(&cap); goto cont; } /* Make sure no capture is running */ end_capture(&cap); /* Get the max buffer size */ val = gtk_entry_get_text(GTK_ENTRY(entry)); info->cap_max_buf_size = atoi(val); gtk_text_buffer_get_start_iter(cap.output_buffer, &start_iter); gtk_text_buffer_get_end_iter(cap.output_buffer, &end_iter); g_free(info->cap_buffer_output); info->cap_buffer_output = gtk_text_buffer_get_text(cap.output_buffer, &start_iter, &end_iter, FALSE); /* save the plugin and file to reuse if we come back */ update_plugin(&cap); free(info->cap_file); cap.info->cap_file = strdup(gtk_entry_get_text(GTK_ENTRY(cap.file_entry))); free(info->cap_command); command = gtk_entry_get_text(GTK_ENTRY(cap.command_entry)); if (command && strlen(command) && !is_just_ws(command)) cap.info->cap_command = strdup(command); else cap.info->cap_command = NULL; update_events(&cap); gtk_widget_destroy(dialog); if (pevent) pevent_free(pevent); if (plugins) tracecmd_free_list(plugins); }
void cdda_configure(void) { GtkWidget *vbox, *notebook; GtkWidget *dev_vbox, *dev_notebook, *add_drive, *add_bbox; GtkWidget *cdi_vbox; GtkWidget *cdi_cddb_frame, *cdi_cddb_vbox, *cdi_cddb_hbox; GtkWidget *cdi_cddb_server_hbox, *cdi_cddb_server_label; GtkWidget *cdi_cddb_server_list, *cdi_cddb_debug_win; #if 0 GtkWidget *cdi_cdin_frame, *cdi_cdin_vbox; GtkWidget *cdi_cdin_server_hbox, *cdi_cdin_server_label; #endif GtkWidget *cdi_name_frame, *cdi_name_vbox, *cdi_name_hbox; GtkWidget *cdi_name_label, *cdi_desc; GtkWidget *cdi_name_enable_vbox; GtkWidget *bbox, *ok, *cancel; GList *node; int i = 1; if (cdda_configure_win) return; cdda_configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_signal_connect(GTK_OBJECT(cdda_configure_win), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &cdda_configure_win); gtk_window_set_title(GTK_WINDOW(cdda_configure_win), _("CD Audio Player Configuration")); gtk_window_set_policy(GTK_WINDOW(cdda_configure_win), FALSE, FALSE, FALSE); gtk_window_set_position(GTK_WINDOW(cdda_configure_win), GTK_WIN_POS_MOUSE); gtk_container_border_width(GTK_CONTAINER(cdda_configure_win), 10); vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(cdda_configure_win), vbox); notebook = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0); /* * Device config */ dev_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5); dev_notebook = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(dev_notebook), TRUE); gtk_box_pack_start(GTK_BOX(dev_vbox), dev_notebook, FALSE, FALSE, 0); for (node = cdda_cfg.drives; node; node = node->next) { struct driveinfo *drive = node->data; char *label = g_strdup_printf(_("Drive %d"), i++); GtkWidget *w; w = configurewin_add_drive(drive, dev_notebook); gtk_notebook_append_page(GTK_NOTEBOOK(dev_notebook), w, gtk_label_new(label)); g_free(label); } add_bbox = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(dev_vbox), add_bbox, FALSE, FALSE, 0); add_drive = gtk_button_new_with_label(_("Add drive")); gtk_signal_connect(GTK_OBJECT(add_drive), "clicked", GTK_SIGNAL_FUNC(configurewin_add_page), dev_notebook); GTK_WIDGET_SET_FLAGS(add_drive, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(add_bbox), add_drive, FALSE, FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dev_vbox, gtk_label_new(_("Device"))); /* * CD Info config */ cdi_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(cdi_vbox), 5); /* CDDB */ cdi_cddb_frame = gtk_frame_new(_("CDDB:")); gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cddb_frame, FALSE, FALSE, 0); cdi_cddb_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(cdi_cddb_vbox), 5); gtk_container_add(GTK_CONTAINER(cdi_cddb_frame), cdi_cddb_vbox); cdi_cddb_hbox = gtk_hbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(cdi_cddb_hbox), 0); gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox), cdi_cddb_hbox, FALSE, FALSE, 0); cdi_use_cddb = gtk_check_button_new_with_label(_("Use CDDB")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cddb), cdda_cfg.use_cddb); gtk_box_pack_start(GTK_BOX(cdi_cddb_hbox), cdi_use_cddb, FALSE, FALSE, 0); cdi_cddb_server_list = gtk_button_new_with_label(_("Get server list")); gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox), cdi_cddb_server_list, FALSE, FALSE, 0); cdi_cddb_debug_win = gtk_button_new_with_label(_("Show network window")); gtk_signal_connect(GTK_OBJECT(cdi_cddb_debug_win), "clicked", GTK_SIGNAL_FUNC(cdda_cddb_show_network_window), NULL); gtk_box_pack_end(GTK_BOX(cdi_cddb_hbox), cdi_cddb_debug_win, FALSE, FALSE, 0); cdi_cddb_server_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(cdi_cddb_vbox), cdi_cddb_server_hbox, FALSE, FALSE, 0); cdi_cddb_server_label = gtk_label_new(_("CDDB server:")); gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox), cdi_cddb_server_label, FALSE, FALSE, 0); cdi_cddb_server = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(cdi_cddb_server), cdda_cfg.cddb_server); gtk_box_pack_start(GTK_BOX(cdi_cddb_server_hbox), cdi_cddb_server, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(cdi_cddb_server_list), "clicked", GTK_SIGNAL_FUNC(cdda_cddb_show_server_dialog), cdi_cddb_server); #if 0 /* * CDindex */ cdi_cdin_frame = gtk_frame_new(_("CD Index:")); gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_cdin_frame, FALSE, FALSE, 0); cdi_cdin_vbox = gtk_vbox_new(FALSE, 10); gtk_container_border_width(GTK_CONTAINER(cdi_cdin_vbox), 5); gtk_container_add(GTK_CONTAINER(cdi_cdin_frame), cdi_cdin_vbox); cdi_use_cdin = gtk_check_button_new_with_label(_("Use CD Index")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_use_cdin), cdda_cfg.use_cdin); gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_use_cdin, FALSE, FALSE, 0); cdi_cdin_server_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(cdi_cdin_vbox), cdi_cdin_server_hbox, FALSE, FALSE, 0); cdi_cdin_server_label = gtk_label_new(_("CD Index server:")); gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server_label, FALSE, FALSE, 0); cdi_cdin_server = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(cdi_cdin_server), cdda_cfg.cdin_server); gtk_box_pack_start(GTK_BOX(cdi_cdin_server_hbox), cdi_cdin_server, TRUE, TRUE, 0); #ifndef WITH_CDINDEX gtk_widget_set_sensitive(cdi_cdin_frame, FALSE); #endif #endif /* * Track names */ cdi_name_frame = gtk_frame_new(_("Track names:")); gtk_box_pack_start(GTK_BOX(cdi_vbox), cdi_name_frame, FALSE, FALSE, 0); cdi_name_vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(cdi_name_frame), cdi_name_vbox); gtk_container_border_width(GTK_CONTAINER(cdi_name_vbox), 5); cdi_name_override = gtk_check_button_new_with_label(_("Override generic titles")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cdi_name_override), cdda_cfg.title_override); gtk_box_pack_start(GTK_BOX(cdi_name_vbox), cdi_name_override, FALSE, FALSE, 0); cdi_name_enable_vbox = gtk_vbox_new(FALSE, 10); gtk_container_add(GTK_CONTAINER(cdi_name_vbox), cdi_name_enable_vbox); gtk_widget_set_sensitive(cdi_name_enable_vbox, cdda_cfg.title_override); gtk_signal_connect(GTK_OBJECT(cdi_name_override), "toggled", toggle_set_sensitive_cb, cdi_name_enable_vbox); cdi_name_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_name_hbox, FALSE, FALSE, 0); cdi_name_label = gtk_label_new(_("Name format:")); gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name_label, FALSE, FALSE, 0); cdi_name = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(cdi_name), cdda_cfg.name_format); gtk_box_pack_start(GTK_BOX(cdi_name_hbox), cdi_name, TRUE, TRUE, 0); cdi_desc = xmms_titlestring_descriptions("patn", 2); gtk_box_pack_start(GTK_BOX(cdi_name_enable_vbox), cdi_desc, FALSE, FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), cdi_vbox, gtk_label_new(_("CD Info"))); bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); ok = gtk_button_new_with_label(_("OK")); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(cdda_configurewin_ok_cb), NULL); gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(configurewin_close), NULL); GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0); gtk_widget_grab_default(ok); cancel = gtk_button_new_with_label(_("Cancel")); gtk_signal_connect(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(configurewin_close), NULL); GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0); gtk_widget_show_all(cdda_configure_win); }
int main( int argc, char *argv[] ) { GtkWidget *window = NULL; GtkWidget *vbox; GtkWidget *entry; GtkWidget *label; GtkStatusIcon *tray_icon; GdkPixbuf *main_icon; GtkWidget* array_widget[2]; g_type_init (); connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (connection == NULL) { DEBUG ("Failed to make connection to session bus: %s", error->message); g_error_free (error); exit(1); } proxy = dbus_g_proxy_new_for_name ( connection, "org.opensplash.bot", "/org/opensplash/bot/language/Parser", "org.opensplash.bot.language" ); gtk_init (&argc, &argv); x_grab_key_init(); main_icon = gdk_pixbuf_new_from_xpm_data((const char**)splashbox_xpm); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_wmclass (GTK_WINDOW(window), "splashbox-bot-frontend-gtk", "splashbox-bot-frontend-gtk"); //gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_widget_set_size_request( window, 400, -1); gtk_window_set_has_frame(GTK_WINDOW(window), FALSE); gtk_window_set_resizable (GTK_WINDOW(window), FALSE); gtk_window_set_position (GTK_WINDOW(window),GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_keep_above(GTK_WINDOW(window), TRUE); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show(vbox); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(vbox), entry, TRUE, TRUE, 0); // gtk_entry_set_activates_default (GTK_ENTRY(entry), TRUE); gtk_widget_show(entry); label = gtk_label_new("Hi Master, what can I do for you?"); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); gtk_widget_show(label); tray_icon = gtk_status_icon_new (); gtk_status_icon_set_from_pixbuf(tray_icon, main_icon); gtk_status_icon_set_tooltip(tray_icon, "Use right Alt key to show/hide the input box."); /* array_widget[0] = window; array_widget[1] = label; */ g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK (entry_activated_cb), label); g_signal_connect(G_OBJECT(tray_icon), "activate", G_CALLBACK(tray_icon_activated_cb), window); gtk_widget_hide (window); g_idle_add(grab_key, (gpointer)window); gtk_main (); return 0; }
static void create_adapter(adapter_data *adapter) { GHashTable *hash = NULL; GValue *value; DBusGProxy *default_proxy; const gchar *name; gboolean powered, discoverable; guint timeout; GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *image; GtkWidget *button; GtkWidget *entry; GtkWidget *buttonbox; int page_num; dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash != NULL) { value = g_hash_table_lookup(hash, "Name"); name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Powered"); powered = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "Discoverable"); discoverable = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "DiscoverableTimeout"); timeout = value ? g_value_get_uint(value) : 0; } else { name = NULL; powered = FALSE; discoverable = FALSE; timeout = 0; } adapter->powered = powered; adapter->discoverable = discoverable; adapter->timeout_value = timeout; default_proxy = bluetooth_client_get_default_adapter (client); if (default_proxy != NULL) { adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy), dbus_g_proxy_get_path (adapter->proxy)); g_object_unref (default_proxy); } mainbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook), mainbox, NULL); adapter->child = mainbox; vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0); /* The discoverable checkbox */ button = gtk_check_button_new_with_mnemonic (_("Make computer _visible")); if (powered == FALSE) discoverable = FALSE; if (discoverable != FALSE && timeout == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); else if (discoverable == FALSE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); } gtk_widget_set_sensitive (button, adapter->powered); adapter->button_discoverable = button; adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(discoverable_changed_cb), adapter); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); /* The friendly name */ vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); label = create_label(_("Friendly name")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 248); gtk_widget_set_size_request(entry, 240, -1); gtk_container_add (GTK_CONTAINER (alignment), entry); if (name != NULL) gtk_entry_set_text(GTK_ENTRY(entry), name); adapter->entry = entry; adapter->name_vbox = vbox; g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(name_callback), adapter); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(focus_callback), adapter); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); /* The known devices */ table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0); label = create_label(_("Devices")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6); /* Note that this will only ever show the devices on the default * adapter, this is on purpose */ adapter->chooser = bluetooth_chooser_new (NULL); g_object_set (adapter->chooser, "show-searching", FALSE, "show-device-type", FALSE, "show-device-category", FALSE, "show-pairing", TRUE, "show-connected", TRUE, "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL); g_signal_connect (adapter->chooser, "notify::device-selected", G_CALLBACK(device_selected_cb), adapter); gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); adapter->devices_table = table; buttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(buttonbox), 6); gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE); gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 6, 6); button = gtk_button_new_with_mnemonic(_("Set up _new device...")); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wizard_callback), adapter); button = gtk_button_new_with_label(_("Disconnect")); image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(disconnect_callback), adapter); adapter->button_disconnect = button; button = gtk_button_new_with_mnemonic(_("_Remove")); image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_callback), adapter); adapter->button_delete = button; gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); g_object_set_data(G_OBJECT(mainbox), "adapter", adapter); gtk_widget_show_all(mainbox); if (adapter->is_default != FALSE) gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num); }
static void * search_get_widget (void) { GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); entry = gtk_entry_new (); gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find"); gtk_entry_set_placeholder_text ((GtkEntry *) entry, _("Search library")); g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry); gtk_box_pack_start ((GtkBox *) vbox, entry, FALSE, FALSE, 0); help_label = gtk_label_new (_("To import your music library into " "Audacious, choose a folder and then click the \"refresh\" icon.")); gtk_widget_set_size_request (help_label, 194, -1); gtk_label_set_line_wrap ((GtkLabel *) help_label, TRUE); g_signal_connect (help_label, "destroy", (GCallback) gtk_widget_destroyed, & help_label); gtk_widget_set_no_show_all (help_label, TRUE); gtk_box_pack_start ((GtkBox *) vbox, help_label, TRUE, FALSE, 0); wait_label = gtk_label_new (_("Please wait ...")); g_signal_connect (wait_label, "destroy", (GCallback) gtk_widget_destroyed, & wait_label); gtk_widget_set_no_show_all (wait_label, TRUE); gtk_box_pack_start ((GtkBox *) vbox, wait_label, TRUE, FALSE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); g_signal_connect (scrolled, "destroy", (GCallback) gtk_widget_destroyed, & scrolled); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolled, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_widget_set_no_show_all (scrolled, TRUE); gtk_box_pack_start ((GtkBox *) vbox, scrolled, TRUE, TRUE, 0); results_list = audgui_list_new (& list_callbacks, NULL, items ? index_count (items) : 0); g_signal_connect (results_list, "destroy", (GCallback) gtk_widget_destroyed, & results_list); gtk_tree_view_set_headers_visible ((GtkTreeView *) results_list, FALSE); audgui_list_add_column (results_list, NULL, 0, G_TYPE_STRING, -1); gtk_container_add ((GtkContainer *) scrolled, results_list); GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_end ((GtkBox *) vbox, hbox, FALSE, FALSE, 0); GtkWidget * chooser = gtk_file_chooser_button_new (_("Choose Folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_box_pack_start ((GtkBox *) hbox, chooser, TRUE, TRUE, 0); char * path = get_path (); gtk_file_chooser_set_filename ((GtkFileChooser *) chooser, path); str_unref (path); GtkWidget * button = gtk_button_new (); gtk_container_add ((GtkContainer *) button, gtk_image_new_from_icon_name ("view-refresh", GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief ((GtkButton *) button, GTK_RELIEF_NONE); gtk_box_pack_start ((GtkBox *) hbox, button, FALSE, FALSE, 0); g_signal_connect (entry, "changed", (GCallback) entry_cb, NULL); g_signal_connect (entry, "activate", (GCallback) action_play, NULL); g_signal_connect (button, "clicked", (GCallback) refresh_cb, chooser); gtk_widget_show_all (vbox); gtk_widget_show (results_list); show_hide_widgets (); return vbox; }
void gui_init(dt_lib_module_t *self) { dt_lib_styles_t *d = (dt_lib_styles_t *)malloc(sizeof(dt_lib_styles_t)); self->data = (void *)d; d->edit_button = NULL; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); GtkWidget *w; GtkWidget *scrolled; /* list */ d->list = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->list, FALSE); GtkListStore *liststore = gtk_list_store_new(DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(d->list), col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_STYLES_COL_NAME); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore)); g_object_unref(liststore); gtk_widget_set_tooltip_text(GTK_WIDGET(d->list), _("available styles,\ndoubleclick to apply")); g_signal_connect(d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d); /* filter entry */ w = gtk_entry_new(); d->entry = GTK_ENTRY(w); gtk_widget_set_tooltip_text(w, _("enter style name")); g_signal_connect(d->entry, "changed", G_CALLBACK(entry_callback), d); g_signal_connect(d->entry, "activate", G_CALLBACK(entry_activated), d); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), DT_PIXEL_APPLY_DPI(150)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->entry), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled), TRUE, FALSE, 0); gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(d->list)); d->duplicate = gtk_check_button_new_with_label(_("create duplicate")); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->duplicate), TRUE, FALSE, 0); g_signal_connect(d->duplicate, "toggled", G_CALLBACK(duplicate_callback), d); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->duplicate), dt_conf_get_bool("ui_last/styles_create_duplicate")); gtk_widget_set_tooltip_text(d->duplicate, _("creates a duplicate of the image before applying style")); GtkWidget *hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), hbox2, TRUE, FALSE, 0); // create GtkWidget *cbutton = gtk_button_new_with_label(_("create")); g_signal_connect(G_OBJECT(cbutton), "clicked", G_CALLBACK(create_clicked), d); gtk_widget_set_tooltip_text(cbutton, _("create styles from history stack of selected images")); gtk_box_pack_start(GTK_BOX(hbox1), cbutton, TRUE, TRUE, 0); // edit GtkWidget *widget = gtk_button_new_with_label(_("edit")); d->edit_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(edit_clicked), d); gtk_widget_set_tooltip_text(widget, _("edit the selected style in list above")); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // delete widget = gtk_button_new_with_label(_("delete")); d->delete_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(delete_clicked), d); gtk_widget_set_tooltip_text(widget, _("deletes the selected style in list above")); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // import button GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import")); d->import_button = importButton; gtk_widget_set_tooltip_text(importButton, _("import style from a style file")); g_signal_connect(importButton, "clicked", G_CALLBACK(import_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), importButton, TRUE, TRUE, 0); // export button GtkWidget *exportButton = gtk_button_new_with_label(_("export")); d->export_button = exportButton; gtk_widget_set_tooltip_text(exportButton, _("export the selected style into a style file")); g_signal_connect(exportButton, "clicked", G_CALLBACK(export_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), exportButton, TRUE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* update filtered list */ _gui_styles_update_view(d); dt_control_signal_connect(darktable.signals, DT_SIGNAL_STYLE_CHANGED, G_CALLBACK(_styles_changed_callback), d); }
static GtkWidget *create_custom_widget(GtkPrintOperation *operation, gpointer user_data) { /* copied from interface.c */ GtkWidget *page; GtkWidget *frame33; GtkWidget *alignment36; GtkWidget *vbox30; GtkWidget *hbox10; GtkWidget *label203; PrintWidgets *w = user_data; gtk_print_operation_set_custom_tab_label(operation, _("Document Setup")); page = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(page), 5); w->check_print_linenumbers = gtk_check_button_new_with_mnemonic(_("Print line numbers")); gtk_box_pack_start(GTK_BOX(page), w->check_print_linenumbers, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_linenumbers, _("Add line numbers to the printed page")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_linenumbers), printing_prefs.print_line_numbers); w->check_print_pagenumbers = gtk_check_button_new_with_mnemonic(_("Print page numbers")); gtk_box_pack_start(GTK_BOX(page), w->check_print_pagenumbers, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_pagenumbers, _("Add page numbers at the bottom of each page. It takes 2 lines of the page.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pagenumbers), printing_prefs.print_page_numbers); w->check_print_pageheader = gtk_check_button_new_with_mnemonic(_("Print page header")); gtk_box_pack_start(GTK_BOX(page), w->check_print_pageheader, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_pageheader, _("Add a little header to every page containing the page number, the filename and the current date (see below). It takes 3 lines of the page.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_pageheader), printing_prefs.print_page_header); g_signal_connect(w->check_print_pageheader, "toggled", G_CALLBACK(on_page_header_toggled), w); frame33 = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(page), frame33, FALSE, FALSE, 0); gtk_frame_set_label_align(GTK_FRAME(frame33), 0, 0); gtk_frame_set_shadow_type(GTK_FRAME(frame33), GTK_SHADOW_NONE); alignment36 = gtk_alignment_new(0, 0.5, 1, 1); gtk_container_add(GTK_CONTAINER(frame33), alignment36); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment36), 0, 0, 12, 0); vbox30 = gtk_vbox_new(FALSE, 1); gtk_container_add(GTK_CONTAINER(alignment36), vbox30); w->check_print_basename = gtk_check_button_new_with_mnemonic(_("Use the basename of the printed file")); gtk_box_pack_start(GTK_BOX(vbox30), w->check_print_basename, FALSE, FALSE, 0); gtk_widget_set_tooltip_text(w->check_print_basename, _("Print only the basename(without the path) of the printed file")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->check_print_basename), printing_prefs.page_header_basename); hbox10 = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox30), hbox10, TRUE, TRUE, 0); label203 = gtk_label_new(_("Date format:")); gtk_box_pack_start(GTK_BOX(hbox10), label203, FALSE, FALSE, 0); w->entry_print_dateformat = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(w->entry_print_dateformat)); gtk_box_pack_start(GTK_BOX(hbox10), w->entry_print_dateformat, TRUE, TRUE, 0); gtk_widget_set_tooltip_text(w->entry_print_dateformat, _("Specify a format for the date and time stamp which is added to the page header on each page. You can use any conversion specifiers which can be used with the ANSI C strftime function.")); gtk_entry_set_text(GTK_ENTRY(w->entry_print_dateformat), printing_prefs.page_header_datefmt); on_page_header_toggled(GTK_TOGGLE_BUTTON(w->check_print_pageheader), w); gtk_widget_show_all(page); return page; }
LPSTR create_keyval (HWND hwnd, LPCSTR attrs, BOOL *verify_conn) { GtkWidget *gensetup, *dialog_vbox1, *fixed1; GtkWidget *l_comment, *scrolledwindow1, *clist1; GtkWidget *l_key, *l_value, *t_keyword, *t_value, *l_copyright; GtkWidget *vbuttonbox1, *b_add, *b_update, *l_keyword, *l_valeur; GtkWidget *dialog_action_area1, *hbuttonbox1, *b_ok, *b_cancel; GtkWidget *cb_verify; guint button_key; GtkAccelGroup *accel_group; TGENSETUP gensetup_t; char buff[1024]; if (hwnd == NULL || !GTK_IS_WIDGET (hwnd)) return (LPSTR) attrs; accel_group = gtk_accel_group_new (); gensetup = gtk_dialog_new (); gtk_object_set_data (GTK_OBJECT (gensetup), "gensetup", gensetup); gtk_window_set_title (GTK_WINDOW (gensetup), "Advanced File DSN Creation Settings"); gtk_window_set_position (GTK_WINDOW (gensetup), GTK_WIN_POS_CENTER); gtk_window_set_modal (GTK_WINDOW (gensetup), TRUE); gtk_window_set_policy (GTK_WINDOW (gensetup), FALSE, FALSE, FALSE); #if GTK_CHECK_VERSION(2,0,0) gtk_widget_show (gensetup); #endif dialog_vbox1 = GTK_DIALOG (gensetup)->vbox; gtk_object_set_data (GTK_OBJECT (gensetup), "dialog_vbox1", dialog_vbox1); gtk_widget_show (dialog_vbox1); fixed1 = gtk_fixed_new (); gtk_widget_ref (fixed1); gtk_object_set_data_full (GTK_OBJECT (gensetup), "fixed1", fixed1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (fixed1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), fixed1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (fixed1), 6); l_comment = gtk_label_new ("If you know the driver-specific keywords for this data source, you can type them and their values here. For more information on driver-specific keywords, please consult your ODBC driver documentation."); gtk_widget_ref (l_comment); gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_comment", l_comment, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (l_comment); gtk_fixed_put (GTK_FIXED (fixed1), l_comment, 8, 7); gtk_widget_set_uposition (l_comment, 8, 7); gtk_widget_set_usize (l_comment, 330, 70); gtk_label_set_justify (GTK_LABEL (l_comment), GTK_JUSTIFY_LEFT); gtk_label_set_line_wrap (GTK_LABEL (l_comment), TRUE); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_ref (scrolledwindow1); gtk_object_set_data_full (GTK_OBJECT (gensetup), "scrolledwindow1", scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (scrolledwindow1); gtk_fixed_put (GTK_FIXED (fixed1), scrolledwindow1, 8, 88); gtk_widget_set_uposition (scrolledwindow1, 8, 88); gtk_widget_set_usize (scrolledwindow1, 320, 184); clist1 = gtk_clist_new (2); gtk_widget_ref (clist1); gtk_object_set_data_full (GTK_OBJECT (gensetup), "clist1", clist1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (clist1); gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist1); gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 137); gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 80); gtk_clist_column_titles_show (GTK_CLIST (clist1)); l_key = gtk_label_new (szKeysColumnNames[0]); gtk_widget_ref (l_key); gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_key", l_key, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (l_key); gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, l_key); l_value = gtk_label_new (szKeysColumnNames[1]); gtk_widget_ref (l_value); gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_value", l_value, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (l_value); gtk_clist_set_column_widget (GTK_CLIST (clist1), 1, l_value); t_keyword = gtk_entry_new (); gtk_widget_ref (t_keyword); gtk_object_set_data_full (GTK_OBJECT (gensetup), "t_keyword", t_keyword, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (t_keyword); gtk_fixed_put (GTK_FIXED (fixed1), t_keyword, 80, 288); gtk_widget_set_uposition (t_keyword, 80, 288); gtk_widget_set_usize (t_keyword, 158, 22); t_value = gtk_entry_new (); gtk_widget_ref (t_value); gtk_object_set_data_full (GTK_OBJECT (gensetup), "t_value", t_value, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (t_value); gtk_fixed_put (GTK_FIXED (fixed1), t_value, 80, 320); gtk_widget_set_uposition (t_value, 80, 320); gtk_widget_set_usize (t_value, 158, 22); vbuttonbox1 = gtk_vbutton_box_new (); gtk_widget_ref (vbuttonbox1); gtk_object_set_data_full (GTK_OBJECT (gensetup), "vbuttonbox1", vbuttonbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbuttonbox1); gtk_fixed_put (GTK_FIXED (fixed1), vbuttonbox1, 248, 280); gtk_widget_set_uposition (vbuttonbox1, 248, 280); gtk_widget_set_usize (vbuttonbox1, 85, 69); b_add = gtk_button_new_with_label (""); button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_add)->child), szKeysButtons[0]); gtk_widget_add_accelerator (b_add, "clicked", accel_group, button_key, GDK_MOD1_MASK, 0); gtk_widget_ref (b_add); gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_add", b_add, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (b_add); gtk_container_add (GTK_CONTAINER (vbuttonbox1), b_add); GTK_WIDGET_SET_FLAGS (b_add, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (b_add, "clicked", accel_group, 'A', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); b_update = gtk_button_new_with_label (""); button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_update)->child), szKeysButtons[1]); gtk_widget_add_accelerator (b_update, "clicked", accel_group, button_key, GDK_MOD1_MASK, 0); gtk_widget_ref (b_update); gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_update", b_update, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (b_update); gtk_container_add (GTK_CONTAINER (vbuttonbox1), b_update); GTK_WIDGET_SET_FLAGS (b_update, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (b_update, "clicked", accel_group, 'U', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_set_sensitive (b_update, FALSE); l_keyword = gtk_label_new ("Keyword : "); gtk_widget_ref (l_keyword); gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_keyword", l_keyword, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (l_keyword); gtk_fixed_put (GTK_FIXED (fixed1), l_keyword, 8, 290); gtk_widget_set_uposition (l_keyword, 8, 290); gtk_widget_set_usize (l_keyword, 69, 16); gtk_label_set_justify (GTK_LABEL (l_keyword), GTK_JUSTIFY_LEFT); l_valeur = gtk_label_new ("Value : "); gtk_widget_ref (l_valeur); gtk_object_set_data_full (GTK_OBJECT (gensetup), "l_valeur", l_valeur, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (l_valeur); gtk_fixed_put (GTK_FIXED (fixed1), l_valeur, 8, 323); gtk_widget_set_uposition (l_valeur, 8, 323); gtk_widget_set_usize (l_valeur, 51, 16); gtk_label_set_justify (GTK_LABEL (l_valeur), GTK_JUSTIFY_LEFT); cb_verify = gtk_check_button_new_with_label ("Verify this connection(recommended)"); gtk_widget_ref (cb_verify); gtk_object_set_data_full (GTK_OBJECT (gensetup), "cb_verify", cb_verify, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (cb_verify); gtk_fixed_put (GTK_FIXED (fixed1), cb_verify, 8, 350); gtk_widget_set_uposition (cb_verify, 8, 350); gtk_widget_set_usize (cb_verify, 230, 24); dialog_action_area1 = GTK_DIALOG (gensetup)->action_area; gtk_object_set_data (GTK_OBJECT (gensetup), "dialog_action_area1", dialog_action_area1); gtk_widget_show (dialog_action_area1); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 5); hbuttonbox1 = gtk_hbutton_box_new (); gtk_widget_ref (hbuttonbox1); gtk_object_set_data_full (GTK_OBJECT (gensetup), "hbuttonbox1", hbuttonbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbuttonbox1); gtk_box_pack_start (GTK_BOX (dialog_action_area1), hbuttonbox1, TRUE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END); gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10); b_ok = gtk_button_new_with_label (""); button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_ok)->child), "_Ok"); gtk_widget_add_accelerator (b_ok, "clicked", accel_group, button_key, GDK_MOD1_MASK, 0); gtk_widget_ref (b_ok); gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_ok", b_ok, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (b_ok); gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_ok); GTK_WIDGET_SET_FLAGS (b_ok, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (b_ok, "clicked", accel_group, 'O', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); b_cancel = gtk_button_new_with_label (""); button_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (b_cancel)->child), "_Cancel"); gtk_widget_add_accelerator (b_cancel, "clicked", accel_group, button_key, GDK_MOD1_MASK, 0); gtk_widget_ref (b_cancel); gtk_object_set_data_full (GTK_OBJECT (gensetup), "b_cancel", b_cancel, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (b_cancel); gtk_container_add (GTK_CONTAINER (hbuttonbox1), b_cancel); GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (b_cancel, "clicked", accel_group, 'C', GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); /* Ok button events */ gtk_signal_connect (GTK_OBJECT (b_ok), "clicked", GTK_SIGNAL_FUNC (gensetup_ok_clicked), &gensetup_t); /* Cancel button events */ gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked", GTK_SIGNAL_FUNC (gensetup_cancel_clicked), &gensetup_t); /* Add button events */ gtk_signal_connect (GTK_OBJECT (b_add), "clicked", GTK_SIGNAL_FUNC (gensetup_add_clicked), &gensetup_t); /* Update button events */ gtk_signal_connect (GTK_OBJECT (b_update), "clicked", GTK_SIGNAL_FUNC (gensetup_update_clicked), &gensetup_t); /* Close window button events */ gtk_signal_connect (GTK_OBJECT (gensetup), "delete_event", GTK_SIGNAL_FUNC (delete_event), &gensetup_t); gtk_signal_connect (GTK_OBJECT (gensetup), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); /* List events */ gtk_signal_connect (GTK_OBJECT (clist1), "select_row", GTK_SIGNAL_FUNC (gensetup_list_select), &gensetup_t); gtk_signal_connect (GTK_OBJECT (clist1), "unselect_row", GTK_SIGNAL_FUNC (gensetup_list_unselect), &gensetup_t); gtk_window_add_accel_group (GTK_WINDOW (gensetup), accel_group); gensetup_t.dsn_entry = NULL; gensetup_t.key_list = clist1; gensetup_t.bupdate = b_update; gensetup_t.key_entry = t_keyword; gensetup_t.value_entry = t_value; gensetup_t.mainwnd = gensetup; gensetup_t.verify_conn_cb = cb_verify; gensetup_t.verify_conn = *verify_conn; gtk_toggle_button_set_active(cb_verify, *verify_conn); /* Parse the attributes line */ parse_attribute_line (&gensetup_t, NULL, attrs, TRUE); gtk_widget_show_all (gensetup); gtk_main (); *verify_conn = gensetup_t.verify_conn; return gensetup_t.connstr; }
/* create the "add" dialog. */ void add_folder_cb (GtkWidget *widget, void *callback_data) { GtkWidget *file_sel; DialogData *data; GtkWidget *main_box; GtkWidget *vbox; GtkWidget *table; GtkWidget *align; data = g_new0 (DialogData, 1); data->settings = g_settings_new (ENGRAMPA_SCHEMA_ADD); data->window = callback_data; data->dialog = file_sel = gtk_file_chooser_dialog_new (_("Add a Folder"), GTK_WINDOW (data->window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, FR_STOCK_ADD_FOLDER, GTK_RESPONSE_OK, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK); data->add_if_newer_checkbutton = gtk_check_button_new_with_mnemonic (_("Add only if _newer")); data->include_subfold_checkbutton = gtk_check_button_new_with_mnemonic (_("_Include subfolders")); data->exclude_symlinks = gtk_check_button_new_with_mnemonic (_("Exclude folders that are symbolic lin_ks")); data->include_files_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (data->include_files_entry, _("example: *.o; *.bak")); data->include_files_label = gtk_label_new_with_mnemonic (_("Include _files:")); gtk_misc_set_alignment (GTK_MISC (data->include_files_label), 0.0, 0.5); gtk_label_set_mnemonic_widget (GTK_LABEL (data->include_files_label), data->include_files_entry); data->exclude_files_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (data->exclude_files_entry, _("example: *.o; *.bak")); data->exclude_files_label = gtk_label_new_with_mnemonic (_("E_xclude files:")); gtk_misc_set_alignment (GTK_MISC (data->exclude_files_label), 0.0, 0.5); gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_files_label), data->exclude_files_entry); data->exclude_folders_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (data->exclude_folders_entry, _("example: *.o; *.bak")); data->exclude_folders_label = gtk_label_new_with_mnemonic (_("_Exclude folders:")); gtk_misc_set_alignment (GTK_MISC (data->exclude_folders_label), 0.0, 0.5); gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_folders_label), data->exclude_folders_entry); data->load_button = gtk_button_new_with_mnemonic (_("_Load Options")); data->save_button = gtk_button_new_with_mnemonic (_("Sa_ve Options")); data->clear_button = gtk_button_new_with_mnemonic (_("_Reset Options")); main_box = gtk_hbox_new (FALSE, 20); gtk_container_set_border_width (GTK_CONTAINER (main_box), 0); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), main_box); vbox = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_box_pack_start (GTK_BOX (main_box), vbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->include_subfold_checkbutton, TRUE, TRUE, 0); align = gtk_alignment_new (0, 0, 0, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 12, 0); gtk_container_add (GTK_CONTAINER (align), data->exclude_symlinks); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->add_if_newer_checkbutton, TRUE, TRUE, 0); table = gtk_table_new (2, 4, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); gtk_table_attach (GTK_TABLE (table), data->include_files_label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); gtk_table_attach (GTK_TABLE (table), data->include_files_entry, 1, 4, 0, 1, GTK_FILL|GTK_EXPAND, 0, 0, 0); gtk_table_attach (GTK_TABLE (table), data->exclude_files_label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); gtk_table_attach (GTK_TABLE (table), data->exclude_files_entry, 1, 2, 1, 2, GTK_FILL|GTK_EXPAND, 0, 0, 0); gtk_table_attach (GTK_TABLE (table), data->exclude_folders_label, 2, 3, 1, 2, GTK_FILL, 0, 0, 0); gtk_table_attach (GTK_TABLE (table), data->exclude_folders_entry, 3, 4, 1, 2, GTK_FILL|GTK_EXPAND, 0, 0, 0); /**/ vbox = gtk_vbox_new (FALSE, 5); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_box_pack_start (GTK_BOX (main_box), vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->load_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->save_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), data->clear_button, FALSE, FALSE, 0); gtk_widget_show_all (main_box); /* set data */ dlg_add_folder_load_last_options (data); /* signals */ g_signal_connect (G_OBJECT (file_sel), "destroy", G_CALLBACK (open_file_destroy_cb), data); g_signal_connect (G_OBJECT (file_sel), "response", G_CALLBACK (file_sel_response_cb), data); g_signal_connect (G_OBJECT (data->include_subfold_checkbutton), "toggled", G_CALLBACK (include_subfold_toggled_cb), data); g_signal_connect (G_OBJECT (data->load_button), "clicked", G_CALLBACK (load_options_cb), data); g_signal_connect (G_OBJECT (data->save_button), "clicked", G_CALLBACK (save_options_cb), data); g_signal_connect (G_OBJECT (data->clear_button), "clicked", G_CALLBACK (clear_options_cb), data); gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE); gtk_widget_show (file_sel); }
void Set_Menu_Container() { GdkBitmap *mask ; GdkPixmap *pixmap; GtkStyle *style ; FILE *fp, *detail ; char data[400] ; char temp[100] ; char detail_filename[100] ; int x = 0 ; memset( data, '\0', 400 ) ; memset( temp, '\0', 100 ) ; memset( detail_filename, '\0', 100 ) ; menu_Container = gtk_notebook_new() ; gtk_notebook_set_tab_pos( GTK_NOTEBOOK( menu_Container ), GTK_POS_LEFT ) ; z_Monster_Tag = gtk_label_new( "Monster" ) ; gtk_widget_set_usize( z_Monster_Tag, 85, 75 ) ; z_Information_Tag = gtk_label_new( "Monster Detail" ) ; gtk_widget_set_usize( z_Information_Tag, 85, 75 ) ; z_Battle_Log_Tag = gtk_label_new( "Battle Log" ) ; gtk_widget_set_usize( z_Battle_Log_Tag, 85, 75 ) ; z_Battle_Tag = gtk_label_new( "Battle!!" ) ; gtk_widget_set_usize( z_Battle_Tag, 85, 75 ) ; style = gtk_widget_get_style(main_Window ) ; // for dektop linux // z_Monster_Page = gtk_image_new_from_file( "DataBase/resource/123.jpg" ) ; fp = fopen( gAccount, "r" ) ; //********************************* fscanf( fp, "%s", temp ) ; strcat( data, temp ) ; memset( temp, '\0', 100 ) ; fscanf( fp, "%s", temp ) ; strcpy( detail_filename, "DataBase/monster_detail/" ) ; if ( temp[0] == '1' ) { strcat( detail_filename, "a_monster" ) ; pixmap = gdk_pixmap_create_from_xpm_d( main_Window->window, &mask,&style->bg[GTK_STATE_NORMAL], (gchar **)a_XPM); } // else if else if ( temp[0] == '2' ) { strcat( detail_filename, "b_monster" ) ; pixmap = gdk_pixmap_create_from_xpm_d( main_Window->window, &mask,&style->bg[GTK_STATE_NORMAL], (gchar **)b_XPM); } // else if else if ( temp[0] == '3' ) { strcat( detail_filename, "c_monster" ) ; pixmap = gdk_pixmap_create_from_xpm_d( main_Window->window, &mask,&style->bg[GTK_STATE_NORMAL], (gchar **)c_XPM); } // else if z_Monster_Page = gtk_pixmap_new(pixmap,mask); gProperty[0] = temp[0] ; strcat( data, "\n\n" ) ; detail = fopen( detail_filename, "r" ) ; for ( x = strlen(data) ; !feof(detail); x++ ) fscanf( detail, "%c", &data[x] ) ; z_Information_Page = gtk_label_new( data ) ; //********************************** memset( data, '\0', 400 ) ; strcat( data, "Battle History\nRecord: " ) ; memset( temp, '\0', 100 ) ; fscanf( fp, "%s", temp ) ; strcat( data, temp ) ; strcat( data, " " ) ; memset( temp, '\0', 100 ) ; fscanf( fp, "%s", temp ) ; strcat( data, temp ) ; strcat( data, "\n\nMonster\t\tResult\n" ) ; for ( x = strlen(data) ; !feof(fp) ; x++ ) fscanf( fp, "%c", &data[x] ) ; z_Battle_Log_Page = gtk_label_new( data ) ; // ********************************** z_Battle_Page = gtk_fixed_new() ; fclose(fp) ; fclose(detail) ; z_Battle_IP_Entry = gtk_entry_new() ; gtk_fixed_put( GTK_FIXED(z_Battle_Page), z_Battle_IP_Entry, 100, 150 ) ; gtk_widget_set_usize( z_Battle_IP_Entry, 170,50 ) ; gtk_entry_set_text( z_Battle_IP_Entry , "192.168.0.50" ) ; z_Battle_Button = gtk_button_new_with_label( "Send!!" ) ; gtk_widget_set_usize( z_Battle_Button, 70,50 ) ; gtk_fixed_put( GTK_FIXED(z_Battle_Page), z_Battle_Button, 270, 150 ) ; gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ), z_Monster_Page, z_Monster_Tag ) ; gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ), z_Information_Page, z_Information_Tag ) ; gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ), z_Battle_Log_Page, z_Battle_Log_Tag ) ; gtk_notebook_append_page( GTK_NOTEBOOK( menu_Container ), z_Battle_Page, z_Battle_Tag ) ; gtk_container_add( GTK_WINDOW( main_Window ), menu_Container ) ; } // Set_Menu_Container()
static GtkWidget* _lib_import_get_extra_widget(dt_lib_import_metadata_t *data, gboolean import_folder) { // add extra lines to 'extra'. don't forget to destroy the widgets later. GtkWidget *expander = gtk_expander_new(_("import options")); gtk_expander_set_expanded(GTK_EXPANDER(expander), dt_conf_get_bool("ui_last/import_options_expanded")); GtkWidget *frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_IN); GtkWidget *alignment = gtk_alignment_new(1.0, 1.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 8, 8, 8, 8); GtkWidget *event_box = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(frame), event_box); gtk_container_add(GTK_CONTAINER(event_box), alignment); gtk_container_add(GTK_CONTAINER(alignment), expander); GtkWidget *extra; extra = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(expander), extra); GtkWidget *recursive = NULL, *ignore_jpeg = NULL; if(import_folder == TRUE) { // recursive opening. recursive = gtk_check_button_new_with_label (_("import directories recursively")); g_object_set(recursive, "tooltip-text", _("recursively import subdirectories. each directory goes into a new film roll."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (recursive), dt_conf_get_bool("ui_last/import_recursive")); gtk_box_pack_start(GTK_BOX (extra), recursive, FALSE, FALSE, 0); // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories. ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files")); g_object_set(ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs")); gtk_box_pack_start(GTK_BOX (extra), ignore_jpeg, FALSE, FALSE, 0); } // default metadata GtkWidget *apply_metadata; GtkWidget *table, *label, *creator, *publisher, *rights, *tags; apply_metadata = gtk_check_button_new_with_label (_("apply metadata on import")); g_object_set(apply_metadata, "tooltip-text", _("apply some metadata to all newly imported images."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (apply_metadata), dt_conf_get_bool("ui_last/import_apply_metadata")); gtk_box_pack_start(GTK_BOX (extra), apply_metadata, FALSE, FALSE, 0); GValue value = {0, }; g_value_init(&value, G_TYPE_INT); gtk_widget_style_get_property(apply_metadata, "indicator-size", &value); gint indicator_size = g_value_get_int(&value); // gtk_widget_style_get_property(apply_metadata, "indicator-spacing", &value); // gint indicator_spacing = g_value_get_int(&value); table = gtk_table_new(6, 3, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 5); alignment = gtk_alignment_new(0, 0, 1, 1); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 2*indicator_size, 0); gtk_container_add(GTK_CONTAINER(alignment), table); gtk_box_pack_start(GTK_BOX (extra), alignment, FALSE, FALSE, 0); creator = gtk_entry_new(); gtk_widget_set_size_request(creator, 300, -1); gtk_entry_set_text(GTK_ENTRY(creator), dt_conf_get_string("ui_last/import_last_creator")); publisher = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(publisher), dt_conf_get_string("ui_last/import_last_publisher")); rights = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(rights), dt_conf_get_string("ui_last/import_last_rights")); tags = gtk_entry_new(); g_object_set(tags, "tooltip-text", _("comma separated list of tags"), NULL); gtk_entry_set_text(GTK_ENTRY(tags), dt_conf_get_string("ui_last/import_last_tags")); // presets from the metadata plugin GtkCellRenderer *renderer; GtkTreeIter iter; GtkListStore *model = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING /*name*/, G_TYPE_STRING /*creator*/, G_TYPE_STRING /*publisher*/, G_TYPE_STRING /*rights*/); GtkWidget *presets = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(presets), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(presets), renderer, "text", NAME_COLUMN, NULL); sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params from presets where operation = \"metadata\"", -1, &stmt, NULL); while(sqlite3_step(stmt) == SQLITE_ROW) { void *op_params = (void *)sqlite3_column_blob(stmt, 1); int32_t op_params_size = sqlite3_column_bytes(stmt, 1); char *buf = (char* )op_params; char *title = buf; buf += strlen(title) + 1; char *description = buf; buf += strlen(description) + 1; char *rights = buf; buf += strlen(rights) + 1; char *creator = buf; buf += strlen(creator) + 1; char *publisher = buf; if(op_params_size == strlen(title) + strlen(description) + strlen(rights) + strlen(creator) + strlen(publisher) + 5) { gtk_list_store_append(model, &iter); gtk_list_store_set (model, &iter, NAME_COLUMN, (char *)sqlite3_column_text(stmt, 0), CREATOR_COLUMN, creator, PUBLISHER_COLUMN, publisher, RIGHTS_COLUMN, rights, -1); } } sqlite3_finalize(stmt); g_object_unref(model); int line = 0; label = gtk_label_new(_("preset")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), presets, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("creator")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), creator, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("publisher")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), publisher, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("rights")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), rights, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); line++; label = gtk_label_new(_("tags")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0); gtk_table_attach(GTK_TABLE(table), tags, 1, 2, line, line+1, GTK_FILL, 0, 0, 0); gtk_widget_show_all(frame); if(data != NULL) { data->frame = frame; data->recursive = recursive; data->ignore_jpeg = ignore_jpeg; data->expander = expander; data->apply_metadata = apply_metadata; data->presets = presets; data->creator = creator; data->publisher = publisher; data->rights = rights; data->tags = tags; } g_signal_connect(apply_metadata, "toggled", G_CALLBACK (_lib_import_apply_metadata_toggled), table); _lib_import_apply_metadata_toggled(apply_metadata, table); // needed since the apply_metadata starts being turned off, // and setting it to off doesn't emit the 'toggled' signal ... g_signal_connect(presets, "changed", G_CALLBACK(_lib_import_presets_changed), data); g_signal_connect(GTK_ENTRY(creator), "changed", G_CALLBACK (_lib_import_metadata_changed), presets); g_signal_connect(GTK_ENTRY(publisher), "changed", G_CALLBACK (_lib_import_metadata_changed), presets); g_signal_connect(GTK_ENTRY(rights), "changed", G_CALLBACK (_lib_import_metadata_changed), presets); return frame; }
void cal_notes_browser (GUI *appGUI) { GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *scrolledwindow; GtkWidget *hseparator; GtkWidget *hbuttonbox; GtkWidget *close_button; GtkWidget *notes_tools_table; GtkWidget *label; GtkObject *notes_month_spinbutton_adj; GtkObject *notes_year_spinbutton_adj; GtkTreeViewColumn *column; GtkCellRenderer *renderer; gchar tmpbuf[BUFFER_SIZE]; appGUI->cal->day_notes_list = NULL; appGUI->cal->day_notes_list_store = NULL; appGUI->cal->day_notes_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (appGUI->cal->day_notes_window), _("Calendar notes")); gtk_window_set_position (GTK_WINDOW (appGUI->cal->day_notes_window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_default_size (GTK_WINDOW(appGUI->cal->day_notes_window), config.cb_window_size_x, config.cb_window_size_y); gtk_window_set_modal (GTK_WINDOW (appGUI->cal->day_notes_window), TRUE); g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "delete_event", G_CALLBACK(day_notes_window_close_cb), appGUI); gtk_window_set_transient_for(GTK_WINDOW(appGUI->cal->day_notes_window), GTK_WINDOW(appGUI->main_window)); gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->day_notes_window), 8); g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "key_press_event", G_CALLBACK (day_notes_key_press_cb), appGUI); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (appGUI->cal->day_notes_window), vbox1); notes_tools_table = gtk_table_new (6, 3, FALSE); gtk_widget_show (notes_tools_table); gtk_box_pack_start (GTK_BOX (vbox1), notes_tools_table, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (notes_tools_table), 3); gtk_table_set_col_spacings (GTK_TABLE (notes_tools_table), 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); sprintf(tmpbuf, "<b>%s:</b>", _("Search")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (notes_tools_table), hbox1, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); notes_month_spinbutton_adj = gtk_adjustment_new (1, 1, 12, 1, 5, 0); appGUI->cal->notes_month_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_month_spinbutton_adj), 1, 0); gtk_widget_show (appGUI->cal->notes_month_spinbutton); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_month_spinbutton, TRUE, TRUE, 0); g_signal_connect (appGUI->cal->notes_month_spinbutton, "value-changed", G_CALLBACK (notes_filter_changed_cb), appGUI); notes_year_spinbutton_adj = gtk_adjustment_new (utl_date_get_current_year (), 1, 9999, 1, 10, 0); appGUI->cal->notes_year_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_year_spinbutton_adj), 1, 0); gtk_widget_show (appGUI->cal->notes_year_spinbutton); gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_year_spinbutton, TRUE, TRUE, 0); g_signal_connect (appGUI->cal->notes_year_spinbutton, "value-changed", G_CALLBACK (notes_filter_changed_cb), appGUI); sprintf(tmpbuf, "<b>%s:</b>", _("Filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); appGUI->cal->notes_filter_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->cal->notes_filter_combobox); g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "focus", G_CALLBACK(notes_filter_combo_box_focus_cb), NULL); g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "changed", G_CALLBACK(notes_filter_changed_cb), appGUI); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_filter_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current month")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month and year")); gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("All notes")); gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->cal->notes_filter_combobox), config.day_notes_browser_filter); appGUI->cal->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->cal->n_items_label); gtk_widget_set_size_request (appGUI->cal->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->n_items_label, 2, 3, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->cal->n_items_label), TRUE); appGUI->cal->notes_search_entry = gtk_entry_new (); gtk_widget_show (appGUI->cal->notes_search_entry); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_entry, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (appGUI->cal->notes_search_entry), "key_press_event", G_CALLBACK (search_entry_key_press_cb), appGUI); appGUI->cal->notes_search_checkbutton = gtk_check_button_new_with_mnemonic (_("Case sensitive")); gtk_widget_show (appGUI->cal->notes_search_checkbutton); GTK_WIDGET_UNSET_FLAGS(appGUI->cal->notes_search_checkbutton, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_checkbutton, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); appGUI->cal->past_notes_checkbutton = gtk_check_button_new_with_mnemonic (_("Strikethrough past day notes")); GTK_WIDGET_UNSET_FLAGS(appGUI->cal->past_notes_checkbutton, GTK_CAN_FOCUS); g_signal_connect (G_OBJECT (appGUI->cal->past_notes_checkbutton), "toggled", G_CALLBACK (browser_past_notes_cb), appGUI); gtk_widget_show (appGUI->cal->past_notes_checkbutton); gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->past_notes_checkbutton, 0, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 2); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->cal->day_notes_list_store = gtk_list_store_new(DAY_NOTES_NUM_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN); appGUI->cal->day_notes_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->cal->day_notes_list_store)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->cal->day_notes_list), TRUE); gtk_widget_show (appGUI->cal->day_notes_list); GTK_WIDGET_SET_FLAGS (appGUI->cal->day_notes_list, GTK_CAN_DEFAULT); gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->cal->day_notes_list); g_signal_connect(G_OBJECT(appGUI->cal->day_notes_list), "button_press_event", G_CALLBACK(day_notes_list_dbclick_cb), appGUI); appGUI->cal->day_notes_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->cal->day_notes_list)); /* create columns */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Date"), renderer, "text", DN_COLUMN_DATE, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Julian", renderer, "text", DN_COLUMN_DATE_JULIAN, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); gtk_tree_view_column_set_sort_column_id (column, DN_COLUMN_DATE_JULIAN); g_signal_emit_by_name(column, "clicked"); if (config.ascending_sorting_in_day_notes_browser == FALSE) { g_signal_emit_by_name(column, "clicked"); } renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes(_("Note"), renderer, "text", DN_COLUMN_NOTE_LINE, "strikethrough", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", DN_COLUMN_DONE, NULL); gtk_tree_view_column_set_visible (column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column); refresh_notes_list (config.day_notes_browser_filter, NULL, appGUI); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4); hbuttonbox = gtk_hbutton_box_new (); gtk_widget_show (hbuttonbox); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END); gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4); close_button = utl_gui_create_button (GTK_STOCK_CLOSE, OSMO_STOCK_BUTTON_CLOSE, _("Close")); gtk_widget_show (close_button); GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); g_signal_connect(close_button, "clicked", G_CALLBACK(button_day_notes_window_close_cb), appGUI); gtk_container_add(GTK_CONTAINER(hbuttonbox), close_button); gtk_widget_show(appGUI->cal->day_notes_window); gtk_widget_grab_focus (appGUI->cal->day_notes_list); }
/* used by editor and assistant - same code */ GtkWidget * org_gnome_activesync_server_url(EPlugin *epl, EConfigHookItemFactoryData *data) { EMConfigTargetAccount *target_account; const gchar *source_url; gchar *server_url = NULL, *username, *key; const char *address; GtkWidget *url_entry, *username_entry; CamelURL *url; gint row; GtkWidget *hbox, *label, *button; GConfClient *client = gconf_client_get_default(); EasEmailHandler* handler; GError *error = NULL; target_account = (EMConfigTargetAccount *)data->config->target; source_url = e_account_get_string (target_account->MODIFIED_ACCT, E_ACCOUNT_SOURCE_URL); if (source_url && source_url[0] != '\0') url = camel_url_new(source_url, NULL); else url = NULL; if (url == NULL || strcmp(url->protocol, "eas") != 0) { if (url) camel_url_free(url); if (data->old && (label = g_object_get_data((GObject *)data->old, "authenticate-label"))) gtk_widget_destroy(label); /* TODO: we could remove 'owa-url' from the url, but that will lose it if we come back. Maybe a commit callback could do it */ return NULL; } if (data->old) { camel_url_free(url); return data->old; } address = e_account_get_string (target_account->MODIFIED_ACCT, E_ACCOUNT_ID_ADDRESS); key = g_strdup_printf ("/apps/activesyncd/accounts/%s/username", address); username = gconf_client_get_string (client, key, NULL); if (!username || !*username) { gconf_client_set_string (client, key, address, NULL); username = g_strdup (address); } g_free (key); key = g_strdup_printf ("/apps/activesyncd/accounts/%s/serverUri", address); server_url = gconf_client_get_string (client, key, NULL); g_object_unref (client); g_free (key); g_object_get (data->parent, "n-rows", &row, NULL); label = gtk_label_new_with_mnemonic (_("User_name:")); gtk_widget_show (label); username_entry = gtk_entry_new (); gtk_widget_show (username_entry); if (username) gtk_entry_set_text (GTK_ENTRY (username_entry), username); gtk_label_set_mnemonic_widget (GTK_LABEL (label), username_entry); g_signal_connect (username_entry, "changed", G_CALLBACK (username_entry_changed), data->config); gtk_table_attach (GTK_TABLE (data->parent), label, 0, 1, row, row+1, 0, 0, 0, 0); gtk_table_attach (GTK_TABLE (data->parent), username_entry, 1, 2, row, row+1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); row++; hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new_with_mnemonic(_("_Server URL:")); gtk_widget_show(label); url_entry = gtk_entry_new(); camel_url_free (url); gtk_label_set_mnemonic_widget((GtkLabel *)label, url_entry); button = gtk_button_new_with_mnemonic (_("_Auto Detect")); gtk_box_pack_start (GTK_BOX (hbox), url_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show_all(hbox); gtk_table_attach (GTK_TABLE (data->parent), label, 0, 1, row, row+1, 0, 0, 0, 0); gtk_table_attach (GTK_TABLE (data->parent), hbox, 1, 2, row, row+1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); g_signal_connect (url_entry, "changed", G_CALLBACK(url_entry_changed), data->config); if (server_url) gtk_entry_set_text(GTK_ENTRY (url_entry), server_url); g_object_set_data ((GObject *)button, "url-entry", (gpointer) url_entry); g_signal_connect (button, "clicked", G_CALLBACK(discover_server_url), data->config); /* if the host is null, then user+other info is dropped silently, force it to be kept */ if (!server_url|| !*server_url) { gchar *uri; uri = g_strdup_printf (EVOLUTION_ACCOUNT_URL_FORMAT, address, address, ""); e_account_set_string(target_account->MODIFIED_ACCT, E_ACCOUNT_SOURCE_URL, uri); g_free(uri); } g_free (server_url); g_free (username); return hbox; }
/* The public functions */ GtkWidget * gnome_prefs_entry_new (GtkWidget *table, const gchar *label_txt, const gchar *conf_key, const gchar *tooltip, int row, gboolean box) { GnomePrefsWindow *gpw = NULL; GValue value = { 0, {{0}, {0}}}; int cols = 0; GtkWidget *entry = NULL; GtkWidget *label = NULL; GtkWidget *hbox = NULL; gchar *conf_string = NULL; gboolean writable = FALSE; writable = gm_conf_is_key_writable (conf_key); if (box) { hbox = gtk_hbox_new (FALSE, 0); g_value_init (&value, G_TYPE_INT); g_object_get_property (G_OBJECT (table), "n-columns", &value); cols = g_value_get_int (&value); g_value_unset (&value); } label = gtk_label_new_with_mnemonic (label_txt); if (!writable) gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE); if (box) gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 1 * 2); else gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); entry = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL(label), entry); if (!writable) gtk_widget_set_sensitive (GTK_WIDGET (entry), FALSE); if (box) gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 1 * 2); else gtk_table_attach (GTK_TABLE (table), entry, 1, 2, row, row+1, (GtkAttachOptions) (NULL), (GtkAttachOptions) (NULL), 0, 0); conf_string = gm_conf_get_string (conf_key); if (conf_string != NULL) gtk_entry_set_text (GTK_ENTRY (entry), conf_string); g_free (conf_string); g_signal_connect_after (entry, "focus-out-event", G_CALLBACK (entry_focus_changed), (gpointer)conf_key); g_signal_connect_after (entry, "activate", G_CALLBACK (entry_activate_changed), (gpointer)conf_key); gm_conf_notifier_add (conf_key, entry_changed_nt, (gpointer) entry); if (box) gtk_table_attach (GTK_TABLE (table), hbox, 0, cols, row, row+1, (GtkAttachOptions) (NULL), (GtkAttachOptions) (NULL), 0, 0); gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (table), "gpw"); if (gpw && tooltip) gtk_widget_set_tooltip_text (entry, tooltip); gtk_widget_show_all (table); return entry; }
int main(int argc, char* argv[]) { CefMainArgs main_args(argc, argv); CefRefPtr<ClientApp> app(new ClientApp); // Execute the secondary process, if any. int exit_code = CefExecuteProcess(main_args, app.get()); if (exit_code >= 0) return exit_code; if (!getcwd(szWorkingDir, sizeof (szWorkingDir))) return -1; GtkWidget* window; gtk_init(&argc, &argv); // Parse command line arguments. AppInitCommandLine(argc, argv); CefSettings settings; // Populate the settings based on command line arguments. AppGetSettings(settings); // Initialize CEF. CefInitialize(main_args, settings, app.get()); // Register the scheme handler. scheme_test::InitTest(); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), 800, 600); g_signal_connect(window, "focus", G_CALLBACK(&HandleFocus), NULL); GtkWidget* vbox = gtk_vbox_new(FALSE, 0); GtkWidget* menu_bar = CreateMenuBar(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0); GtkWidget* toolbar = gtk_toolbar_new(); // Turn off the labels on the toolbar buttons. gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); GtkToolItem* back = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); g_signal_connect(back, "clicked", G_CALLBACK(BackButtonClicked), NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), back, -1 /* append */); GtkToolItem* forward = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); g_signal_connect(forward, "clicked", G_CALLBACK(ForwardButtonClicked), NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), forward, -1 /* append */); GtkToolItem* reload = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH); g_signal_connect(reload, "clicked", G_CALLBACK(ReloadButtonClicked), NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), reload, -1 /* append */); GtkToolItem* stop = gtk_tool_button_new_from_stock(GTK_STOCK_STOP); g_signal_connect(stop, "clicked", G_CALLBACK(StopButtonClicked), NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), stop, -1 /* append */); GtkWidget* m_editWnd = gtk_entry_new(); g_signal_connect(G_OBJECT(m_editWnd), "activate", G_CALLBACK(URLEntryActivate), NULL); GtkToolItem* tool_item = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(tool_item), m_editWnd); gtk_tool_item_set_expand(tool_item, TRUE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1); // append gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(delete_event), window); // Create the handler. g_handler = new ClientHandler(); g_handler->SetMainHwnd(vbox); g_handler->SetEditHwnd(m_editWnd); g_handler->SetButtonHwnds(GTK_WIDGET(back), GTK_WIDGET(forward), GTK_WIDGET(reload), GTK_WIDGET(stop)); // Create the browser view. CefWindowInfo window_info; CefBrowserSettings browserSettings; window_info.SetAsChild(vbox); CefBrowserHost::CreateBrowserSync( window_info, g_handler.get(), g_handler->GetStartupURL(), browserSettings); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show_all(GTK_WIDGET(window)); // Install an signal handler so we clean up after ourselves. signal(SIGINT, TerminationSignalHandler); signal(SIGTERM, TerminationSignalHandler); CefRunMessageLoop(); CefShutdown(); return 0; }
// modified this to have 3 columns so we can display variable type void FreeVarsWindowInitGtk( ) { GtkWidget * hboxfreevars[ NBR_FREE_VAR_SPY ], *vboxMain; char * VarName= NULL; long ColumnVar; int NumVarSpy,NumEntry,i=NBR_FREE_VAR_SPY; GList *DisplayFormatItems = NULL; SpyFreeVarsWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title ((GtkWindow *)SpyFreeVarsWindow, "Watch Window"); vboxMain = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (SpyFreeVarsWindow), vboxMain); gtk_widget_show (vboxMain); DisplayFormatItems = g_list_append(DisplayFormatItems,"Dec"); DisplayFormatItems = g_list_append(DisplayFormatItems,"Hex"); DisplayFormatItems = g_list_append(DisplayFormatItems,"Bin"); if ( NBR_WORDS < NBR_FREE_VAR_SPY) { i=NBR_WORDS ;} for(NumVarSpy=0; NumVarSpy<i; NumVarSpy++) { hboxfreevars[ NumVarSpy ] = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (vboxMain), hboxfreevars[ NumVarSpy ]); gtk_widget_show (hboxfreevars[ NumVarSpy ]); for(ColumnVar=0; ColumnVar<3; ColumnVar++) { NumEntry = NumVarSpy+ColumnVar*NBR_FREE_VAR_SPY; if ( ColumnVar==0) { LabelFreeVars[NumEntry] = gtk_label_new(NULL); gtk_widget_set_usize((GtkWidget *)LabelFreeVars[NumEntry],100,0); gtk_box_pack_start (GTK_BOX (hboxfreevars[ NumVarSpy ]), LabelFreeVars[NumEntry], FALSE, FALSE, 0); gtk_widget_show (LabelFreeVars[NumEntry]); } if ( ColumnVar==1) { EntryVarSpy[ NumEntry ] = gtk_entry_new(); gtk_widget_show(EntryVarSpy[NumEntry]); gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0); gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==1)?80:110,0); VarName = CreateVarName(VarSpy[NumVarSpy][0],VarSpy[NumVarSpy][1]); TooltipsEntryVarSpy[ NumVarSpy ] = gtk_tooltips_new(); gtk_entry_set_text((GtkEntry *)EntryVarSpy[ NumEntry ],VarName); gtk_signal_connect(GTK_OBJECT (EntryVarSpy[ NumEntry ]), "activate", (GtkSignalFunc) EntryVarSpy_activate_event, (void *)(intptr_t)NumVarSpy); } if ( ColumnVar==2) { EntryVarSpy[ NumEntry ] = gtk_entry_new(); gtk_widget_show(EntryVarSpy[NumEntry]); gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0); gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==2)?80:110,0); } } DisplayFormatVarSpy[NumVarSpy] = gtk_combo_new(); gtk_combo_set_value_in_list(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), TRUE /*val*/, FALSE /*ok_if_empty*/); gtk_combo_set_popdown_strings(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), DisplayFormatItems); gtk_widget_set_usize((GtkWidget *)DisplayFormatVarSpy[NumVarSpy],65,0); gtk_box_pack_start (GTK_BOX(hboxfreevars[ NumVarSpy ]), DisplayFormatVarSpy[NumVarSpy], FALSE, FALSE, 0); gtk_widget_show(DisplayFormatVarSpy[NumVarSpy]); } gtk_signal_connect( GTK_OBJECT(SpyFreeVarsWindow), "delete_event", (GtkSignalFunc)FreeVarsWindowDeleteEvent, 0 ); }
static void fcitx_config_widget_create_option_widget( FcitxConfigWidget *self, FcitxConfigGroupDesc* cgdesc, FcitxConfigOptionDesc* codesc, char** label, char** tooltip, GtkWidget** inputWidget, void** newarg) { FcitxConfigFileDesc* cfdesc = self->cfdesc; FcitxConfigOptionDesc2* codesc2 = (FcitxConfigOptionDesc2*) codesc; void* oldarg = NULL; void* argument = NULL; char* name = g_strdup_printf("%s/%s", cgdesc->groupName, codesc->optionName); oldarg = g_hash_table_lookup(self->argmap, name); if (codesc->desc && strlen(codesc->desc) != 0) { *label = strdup(D_(cfdesc->domain, codesc->desc)); } else { *label = strdup(D_(cfdesc->domain, codesc->optionName)); } if (codesc2->longDesc && codesc2->longDesc[0]) { *tooltip = strdup(D_(cfdesc->domain, codesc2->longDesc)); } switch (codesc->type) { case T_Integer: *inputWidget = gtk_spin_button_new_with_range( codesc2->constrain.integerConstrain.min, codesc2->constrain.integerConstrain.max, 1.0); g_object_set(*inputWidget, "hexpand", TRUE, NULL); if (oldarg) { g_object_bind_property(*inputWidget, "value", oldarg, "value", G_BINDING_BIDIRECTIONAL); } else { g_signal_connect(*inputWidget, "notify::value", (GCallback) _fcitx_config_widget_changed, self); argument = *inputWidget; } break; case T_Color: *inputWidget = gtk_color_button_new(); g_object_set(*inputWidget, "hexpand", TRUE, NULL); if (oldarg) { g_object_bind_property(*inputWidget, "color", oldarg, "color", G_BINDING_BIDIRECTIONAL); } else { g_signal_connect(*inputWidget, "notify::color", (GCallback) _fcitx_config_widget_changed, self); argument = *inputWidget; } break; case T_Boolean: *inputWidget = gtk_check_button_new(); g_object_set(*inputWidget, "hexpand", TRUE, NULL); if (oldarg) { g_object_bind_property(*inputWidget, "active", oldarg, "active", G_BINDING_BIDIRECTIONAL); } else { g_signal_connect(*inputWidget, "notify::active", (GCallback) _fcitx_config_widget_changed, self); argument = *inputWidget; } break; case T_Font: { *inputWidget = gtk_grid_new(); g_object_set(*inputWidget, "hexpand", TRUE, NULL); GtkWidget* arg = gtk_font_button_new(); GtkWidget *button = gtk_button_new_with_label(_("Clear font setting")); g_object_set(arg, "hexpand", TRUE, NULL); gtk_grid_attach(GTK_GRID(*inputWidget), arg, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(*inputWidget), button, 1, 0, 2, 1); gtk_font_button_set_use_size(GTK_FONT_BUTTON(arg), FALSE); gtk_font_button_set_show_size(GTK_FONT_BUTTON(arg), FALSE); g_signal_connect(G_OBJECT(button), "clicked", (GCallback) set_none_font_clicked, arg); if (oldarg) { g_object_bind_property(arg, "font-name", oldarg, "font-name", G_BINDING_BIDIRECTIONAL); } else { g_signal_connect(arg, "notify::font-name", (GCallback) _fcitx_config_widget_changed, self); argument = arg; } } break; case T_Enum: { int i; FcitxConfigEnum *e = &codesc->configEnum; *inputWidget = gtk_combo_box_text_new(); for (i = 0; i < e->enumCount; i ++) { gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(*inputWidget), D_(cfdesc->domain, e->enumDesc[i])); } g_object_set(*inputWidget, "hexpand", TRUE, NULL); if (oldarg) { g_object_bind_property(*inputWidget, "active", oldarg, "active", G_BINDING_BIDIRECTIONAL); } else { g_signal_connect(*inputWidget, "notify::active", (GCallback) _fcitx_config_widget_changed, self); argument = *inputWidget; } } break; case T_Hotkey: { GtkWidget *button[2]; button[0] = keygrab_button_new(); button[1] = keygrab_button_new(); *inputWidget = gtk_grid_new(); gtk_grid_attach(GTK_GRID(*inputWidget), button[0], 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(*inputWidget), button[1], 1, 0, 2, 1); g_object_set(G_OBJECT(button[0]), "hexpand", TRUE, NULL); g_object_set(G_OBJECT(button[1]), "hexpand", TRUE, NULL); if (oldarg) { GArray* array = oldarg; int j; for (j = 0; j < 2; j ++) { GtkWidget *oldbutton = g_array_index(array, GtkWidget*, j); g_signal_connect(oldbutton, "changed", (GCallback) sync_hotkey, button[j]); g_signal_connect(button[j], "changed", (GCallback) sync_hotkey, oldbutton); } } else { argument = g_array_new(FALSE, FALSE, sizeof(void*)); int j; for (j = 0; j < 2; j ++) { g_signal_connect(button[j], "changed", (GCallback) _fcitx_config_widget_hotkey_changed, self); g_array_append_val(argument, button[j]); } } } break; case T_File: case T_Char: case T_String: *inputWidget = gtk_entry_new(); g_object_set(*inputWidget, "hexpand", TRUE, NULL); if (oldarg) { g_object_bind_property(*inputWidget, "text", oldarg, "text", G_BINDING_BIDIRECTIONAL); } else { g_signal_connect(*inputWidget, "notify::text", (GCallback) _fcitx_config_widget_changed, self); argument = *inputWidget; } break; default: break; }
LayerOptionsDialog * layer_options_dialog_new (GimpImage *image, GimpLayer *layer, GimpContext *context, GtkWidget *parent, const gchar *layer_name, GimpFillType layer_fill_type, const gchar *title, const gchar *role, const gchar *icon_name, const gchar *desc, const gchar *help_id) { LayerOptionsDialog *options; GimpViewable *viewable; GtkWidget *vbox; GtkWidget *table; GtkWidget *label; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *frame; GtkWidget *button; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (layer == NULL || GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); options = g_slice_new0 (LayerOptionsDialog); options->image = image; options->context = context; options->layer = layer; options->fill_type = layer_fill_type; if (layer) viewable = GIMP_VIEWABLE (layer); else viewable = GIMP_VIEWABLE (image); options->dialog = gimp_viewable_dialog_new (viewable, context, title, role, icon_name, desc, parent, gimp_standard_help_func, help_id, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_object_weak_ref (G_OBJECT (options->dialog), (GWeakNotify) layer_options_dialog_free, options); gtk_dialog_set_alternative_button_order (GTK_DIALOG (options->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_set_spacing (GTK_BOX (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (options->dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); table = gtk_table_new (layer ? 1 : 3, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* The name label and entry */ options->name_entry = gtk_entry_new (); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Layer _name:"), 0.0, 0.5, options->name_entry, 1, FALSE); gtk_entry_set_activates_default (GTK_ENTRY (options->name_entry), TRUE); gtk_entry_set_text (GTK_ENTRY (options->name_entry), layer_name); if (! layer) { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); /* The size labels */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0); gtk_widget_show (label); /* The size sizeentry */ spinbutton = gimp_spin_button_new (&adjustment, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); options->size_se = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_col_spacing (GTK_TABLE (options->size_se), 1, 4); gtk_table_set_row_spacing (GTK_TABLE (options->size_se), 0, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (options->size_se), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (options->size_se), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gtk_table_attach (GTK_TABLE (table), options->size_se, 1, 2, 1, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (options->size_se); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (options->size_se), GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 0, xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 1, yres, FALSE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 0, 0, gimp_image_get_width (image)); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 1, 0, gimp_image_get_height (image)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 0, gimp_image_get_width (image)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 1, gimp_image_get_height (image)); /* The radio frame */ frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_FILL_TYPE, GIMP_FOREGROUND_FILL, GIMP_TRANSPARENT_FILL, gtk_label_new (_("Layer Fill Type")), G_CALLBACK (gimp_radio_button_update), &options->fill_type, &button); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), options->fill_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } else { GimpContainer *filters; GtkWidget *frame; GtkWidget *view; /* For text layers add a toggle to control "auto-rename" */ if (gimp_item_is_text_layer (GIMP_ITEM (layer))) { options->rename_toggle = gtk_check_button_new_with_mnemonic (_("Set name from _text")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->rename_toggle), GIMP_TEXT_LAYER (layer)->auto_rename); gtk_table_attach (GTK_TABLE (table), options->rename_toggle, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (options->rename_toggle); g_signal_connect (options->rename_toggle, "toggled", G_CALLBACK (layer_options_dialog_toggle_rename), options); } frame = gimp_frame_new ("Active Filters"); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); filters = gimp_drawable_get_filters (GIMP_DRAWABLE (layer)); view = gimp_container_tree_view_new (filters, context, GIMP_VIEW_SIZE_SMALL, 0); gtk_container_add (GTK_CONTAINER (frame), view); gtk_widget_show (view); } return options; }
static GtkWidget* configurewin_add_drive(struct driveinfo *drive, void *nb) { GtkWidget *vbox, *bbox, *dev_frame, *dev_table, *dev_label; GtkWidget *dev_dir_label, *check_btn; GtkWidget *volume_frame, *volume_box, *volume_none; GtkWidget *readmode_frame, *readmode_box, *readmode_analog; struct driveconfig *d = g_malloc(sizeof (struct driveconfig)); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); dev_frame = gtk_frame_new(_("Device:")); gtk_box_pack_start(GTK_BOX(vbox), dev_frame, FALSE, FALSE, 0); dev_table = gtk_table_new(2, 2, FALSE); gtk_container_set_border_width(GTK_CONTAINER(dev_table), 5); gtk_container_add(GTK_CONTAINER(dev_frame), dev_table); gtk_table_set_row_spacings(GTK_TABLE(dev_table), 5); gtk_table_set_col_spacings(GTK_TABLE(dev_table), 5); dev_label = gtk_label_new(_("Device:")); gtk_misc_set_alignment(GTK_MISC(dev_label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(dev_table), dev_label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); d->device = gtk_entry_new(); gtk_table_attach(GTK_TABLE(dev_table), d->device, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, 0, 0 , 0); dev_dir_label = gtk_label_new(_("Directory:")); gtk_misc_set_alignment(GTK_MISC(dev_dir_label), 1.0, 0.5); gtk_table_attach(GTK_TABLE(dev_table), dev_dir_label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); d->directory = gtk_entry_new(); gtk_table_attach(GTK_TABLE(dev_table), d->directory, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, 0, 0, 0); readmode_frame = gtk_frame_new(_("Play mode:")); gtk_box_pack_start(GTK_BOX(vbox), readmode_frame, FALSE, FALSE, 0); readmode_box = gtk_vbox_new(5, FALSE); gtk_container_add(GTK_CONTAINER(readmode_frame), readmode_box); readmode_analog = gtk_radio_button_new_with_label(NULL, _("Analog")); gtk_box_pack_start(GTK_BOX(readmode_box), readmode_analog, FALSE, FALSE, 0); d->dae = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(readmode_analog), _("Digital audio extraction")); gtk_box_pack_start(GTK_BOX(readmode_box), d->dae, FALSE, FALSE, 0); #ifndef CDDA_HAS_READAUDIO gtk_widget_set_sensitive(readmode_frame, FALSE); #endif /* * Volume config */ volume_frame = gtk_frame_new(_("Volume control:")); gtk_box_pack_start(GTK_BOX(vbox), volume_frame, FALSE, FALSE, 0); volume_box = gtk_vbox_new(5, FALSE); gtk_container_add(GTK_CONTAINER(volume_frame), volume_box); volume_none = gtk_radio_button_new_with_label(NULL, _("No mixer")); gtk_box_pack_start(GTK_BOX(volume_box), volume_none, FALSE, FALSE, 0); d->mixer_drive = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(volume_none), _("CD-ROM drive")); gtk_box_pack_start(GTK_BOX(volume_box), d->mixer_drive, FALSE, FALSE, 0); d->mixer_oss = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(volume_none), _("OSS mixer")); gtk_box_pack_start(GTK_BOX(volume_box), d->mixer_oss, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(readmode_analog), "toggled", toggle_set_sensitive_cb, volume_frame); #ifndef HAVE_OSS gtk_widget_set_sensitive(d->mixer_oss, FALSE); #endif if (drive) { gtk_entry_set_text(GTK_ENTRY(d->device), drive->device); gtk_entry_set_text(GTK_ENTRY(d->directory), drive->directory); if (drive->mixer == CDDA_MIXER_DRIVE) SET_TB(d->mixer_drive); else if (drive->mixer == CDDA_MIXER_OSS) SET_TB(d->mixer_oss); if (drive->dae == CDDA_READ_DAE) SET_TB(d->dae); } bbox = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_SPREAD); check_btn = gtk_button_new_with_label(_("Check drive...")); GTK_WIDGET_SET_FLAGS(check_btn, GTK_CAN_DEFAULT); gtk_box_pack_start_defaults(GTK_BOX(bbox), check_btn); gtk_signal_connect(GTK_OBJECT(check_btn), "clicked", GTK_SIGNAL_FUNC(configurewin_check_drive), d); d->remove_button = gtk_button_new_with_label(_("Remove drive")); GTK_WIDGET_SET_FLAGS(d->remove_button, GTK_CAN_DEFAULT); gtk_box_pack_start_defaults(GTK_BOX(bbox), d->remove_button); gtk_signal_connect(GTK_OBJECT(d->remove_button), "clicked", GTK_SIGNAL_FUNC(configurewin_remove_page), nb); if (drives == NULL) gtk_widget_set_sensitive(d->remove_button, FALSE); else { struct driveconfig *tmp = drives->data; gtk_widget_set_sensitive(tmp->remove_button, TRUE); } drives = g_list_append(drives, d); return vbox; }
/** * dialog_init: * @state: * * Create the dialog (guru). * **/ static gboolean dialog_goto_init (GotoState *state) { GtkGrid *grid; GtkWidget *scrolled; GtkTreeViewColumn *column; grid = GTK_GRID (go_gtk_builder_get_widget (state->gui, "names")); state->goto_text = GTK_ENTRY (gtk_entry_new ()); gtk_widget_set_hexpand (GTK_WIDGET (state->goto_text), TRUE); gtk_grid_attach (grid, GTK_WIDGET (state->goto_text), 0, 2, 1, 1); g_signal_connect_after (G_OBJECT (state->goto_text), "changed", G_CALLBACK (cb_dialog_goto_update_sensitivity), state); state->spin_rows = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "spin-rows")); state->spin_cols = GTK_SPIN_BUTTON (go_gtk_builder_get_widget (state->gui, "spin-columns")); /* Set-up treeview */ scrolled = go_gtk_builder_get_widget (state->gui, "scrolled"); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_ETCHED_IN); state->model = gtk_tree_store_new (NUM_COLMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER); state->treeview = GTK_TREE_VIEW ( gtk_tree_view_new_with_model (GTK_TREE_MODEL (state->model))); state->selection = gtk_tree_view_get_selection (state->treeview); gtk_tree_selection_set_mode (state->selection, GTK_SELECTION_BROWSE); g_signal_connect (state->selection, "changed", G_CALLBACK (cb_dialog_goto_selection_changed), state); column = gtk_tree_view_column_new_with_attributes (_("Sheet"), gtk_cell_renderer_text_new (), "text", SHEET_NAME, NULL); gtk_tree_view_column_set_sort_column_id (column, SHEET_NAME); gtk_tree_view_append_column (state->treeview, column); column = gtk_tree_view_column_new_with_attributes (_("Cell"), gtk_cell_renderer_text_new (), "text", ITEM_NAME, NULL); gtk_tree_view_column_set_sort_column_id (column, ITEM_NAME); gtk_tree_view_append_column (state->treeview, column); gtk_tree_view_set_headers_visible (state->treeview, TRUE); gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->treeview)); dialog_goto_load_names (state); /* Finished set-up of treeview */ /* Listen for sheet changes */ state->sheet_order_changed_listener = g_signal_connect (G_OBJECT (state->wb), "sheet_order_changed", G_CALLBACK (cb_sheet_order_changed), state); state->sheet_added_listener = g_signal_connect (G_OBJECT (state->wb), "sheet_added", G_CALLBACK (cb_sheet_added), state); state->sheet_deleted_listener = g_signal_connect (G_OBJECT (state->wb), "sheet_deleted", G_CALLBACK (cb_sheet_deleted), state); state->close_button = go_gtk_builder_get_widget (state->gui, "close_button"); g_signal_connect (G_OBJECT (state->close_button), "clicked", G_CALLBACK (cb_dialog_goto_close_clicked), state); state->go_button = go_gtk_builder_get_widget (state->gui, "go_button"); g_signal_connect (G_OBJECT (state->go_button), "clicked", G_CALLBACK (cb_dialog_goto_go_clicked), state); gtk_window_set_default (GTK_WINDOW (state->dialog), state->go_button); gnm_init_help_button ( go_gtk_builder_get_widget (state->gui, "help_button"), GNUMERIC_HELP_LINK_GOTO_CELL); dialog_goto_load_selection (state); wbc_gtk_attach_guru (state->wbcg, state->dialog); g_object_set_data_full (G_OBJECT (state->dialog), "state", state, (GDestroyNotify) cb_dialog_goto_free); return FALSE; }
static gboolean gdict_applet_draw (GdictApplet *applet) { GdictAppletPrivate *priv = applet->priv; GtkWidget *box; GtkWidget *hbox; gchar *text = NULL; if (priv->entry) text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1); if (priv->box) gtk_widget_destroy (priv->box); switch (priv->orient) { case GTK_ORIENTATION_VERTICAL: box = gtk_vbox_new (FALSE, 0); break; case GTK_ORIENTATION_HORIZONTAL: box = gtk_hbox_new (FALSE, 0); break; default: g_assert_not_reached (); break; } gtk_container_add (GTK_CONTAINER (applet), box); gtk_widget_show (box); /* toggle button */ priv->toggle = gtk_toggle_button_new (); gtk_widget_set_tooltip_text (priv->toggle, _("Click to view the dictionary window")); set_atk_name_description (priv->toggle, _("Toggle dictionary window"), _("Show or hide the definition window")); gtk_button_set_relief (GTK_BUTTON (priv->toggle), GTK_RELIEF_NONE); g_signal_connect (priv->toggle, "toggled", G_CALLBACK (gdict_applet_icon_toggled_cb), applet); g_signal_connect (priv->toggle, "button-press-event", G_CALLBACK (gdict_applet_icon_button_press_event_cb), applet); gtk_box_pack_start (GTK_BOX (box), priv->toggle, FALSE, FALSE, 0); gtk_widget_show (priv->toggle); hbox = gtk_hbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); gtk_container_add (GTK_CONTAINER (priv->toggle), hbox); gtk_widget_show (hbox); if (priv->icon) { GdkPixbuf *scaled; priv->image = gtk_image_new (); gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10); scaled = gdk_pixbuf_scale_simple (priv->icon, priv->size - 5, priv->size - 5, GDK_INTERP_BILINEAR); gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled); g_object_unref (scaled); gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0); gtk_widget_show (priv->image); } else { priv->image = gtk_image_new (); gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10); gtk_image_set_from_stock (GTK_IMAGE (priv->image), GTK_STOCK_MISSING_IMAGE, -1); gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0); gtk_widget_show (priv->image); } /* entry */ priv->entry = gtk_entry_new (); gtk_widget_set_tooltip_text (priv->entry, _("Type the word you want to look up")); set_atk_name_description (priv->entry, _("Dictionary entry"), _("Look up words in dictionaries")); gtk_editable_set_editable (GTK_EDITABLE (priv->entry), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 12); g_signal_connect (priv->entry, "activate", G_CALLBACK (gdict_applet_entry_activate_cb), applet); g_signal_connect (priv->entry, "button-press-event", G_CALLBACK (gdict_applet_entry_button_press_event_cb), applet); g_signal_connect (priv->entry, "key-press-event", G_CALLBACK (gdict_applet_entry_key_press_cb), applet); gtk_box_pack_end (GTK_BOX (box), priv->entry, FALSE, FALSE, 0); gtk_widget_show (priv->entry); if (text) { gtk_entry_set_text (GTK_ENTRY (priv->entry), text); g_free (text); } priv->box = box; #if 0 gtk_widget_grab_focus (priv->entry); #endif gtk_widget_show_all (GTK_WIDGET (applet)); return FALSE; }
GtkWidget * do_overlay (GtkWidget *do_widget) { static GtkWidget *window = NULL; if (!window) { GtkWidget *overlay; GtkWidget *grid; GtkWidget *button; GtkWidget *vbox; GtkWidget *label; GtkWidget *entry; int i, j; char *text; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 500, 510); gtk_window_set_title (GTK_WINDOW (window), "Interactive Overlay"); overlay = gtk_overlay_new (); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (overlay), grid); entry = gtk_entry_new (); for (j = 0; j < 5; j++) { for (i = 0; i < 5; i++) { text = g_strdup_printf ("%d", 5*j + i); button = gtk_button_new_with_label (text); g_free (text); gtk_widget_set_hexpand (button, TRUE); gtk_widget_set_vexpand (button, TRUE); g_signal_connect (button, "clicked", G_CALLBACK (do_number), entry); gtk_grid_attach (GTK_GRID (grid), button, i, j, 1, 1); } } vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), vbox); gtk_overlay_set_overlay_pass_through (GTK_OVERLAY (overlay), vbox, TRUE); gtk_widget_set_halign (vbox, GTK_ALIGN_CENTER); gtk_widget_set_valign (vbox, GTK_ALIGN_CENTER); label = gtk_label_new ("<span foreground='blue' weight='ultrabold' font='40'>Numbers</span>"); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 8); gtk_entry_set_placeholder_text (GTK_ENTRY (entry), "Your Lucky Number"); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 8); gtk_container_add (GTK_CONTAINER (window), overlay); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_widget_show_all (overlay); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
/** * create the scheduled part : that widgets are created at the beginning * and normally never destroyed, they are showed only for * scheduled transactions * Cela ne fonctionne pas : tous les widgets sont détruits par la * fonction gsb_form_create_widgets ( ) * * \param table a GtkTable with the dimension SCHEDULED_HEIGHT*SCHEDULED_WIDTH to be filled * * \return FALSE * */ gboolean gsb_form_scheduler_create ( GtkWidget *table ) { gint row, column; struct_element *element; devel_debug (NULL); if (!table) return FALSE; /* just in case... be sure that not created */ if (scheduled_element_list) gsb_form_scheduler_free_list ( ); /* check the dimensions, * if problem give a warning message but continue the program with changing the values */ g_object_get ( G_OBJECT (table), "n-columns", &column, "n-rows", &row, NULL ); if ( column != SCHEDULED_WIDTH || row != SCHEDULED_HEIGHT ) { warning_debug ( _("gsb_form_scheduler_create is called with a bad table,\n" "the number of rows or columns is not good.\n" "The function will resize the table to the correct values but " "should check that warning.")); gtk_table_resize ( GTK_TABLE (table), SCHEDULED_HEIGHT, SCHEDULED_WIDTH ); } /* ok, now fill the form * we play with height and width, but for now it's fix : 6 columns and 1 line */ for ( row=0 ; row < SCHEDULED_HEIGHT ; row++ ) for ( column=0 ; column < SCHEDULED_WIDTH ; column++ ) { gint element_number; GtkWidget *widget = NULL; const gchar *tooltip_text = NULL; gchar *text_auto [] = { _("Manual"), _("Automatic"), NULL }; gchar *text_frequency [] = { _("Once"), _("Weekly"), _("Monthly"), _("Bimonthly"), _("Quarterly"), _("Yearly"), _("Custom"), NULL }; gchar *text_frequency_user [] = { _("Days"), _("Weeks"), _("Months"), _("Years"), NULL }; element_number = row*SCHEDULED_WIDTH + column; switch ( element_number ) { case SCHEDULED_FORM_ACCOUNT: widget = gsb_account_create_combo_list ( G_CALLBACK ( gsb_form_scheduler_change_account ), NULL, FALSE); gtk_combo_box_set_active ( GTK_COMBO_BOX (widget), 0 ); tooltip_text = _("Choose the account"); break; case SCHEDULED_FORM_AUTO: widget = gsb_combo_box_new_with_index ( text_auto, NULL, NULL ); tooltip_text = _("Automatic/manual scheduled transaction"); break; case SCHEDULED_FORM_FREQUENCY_BUTTON: widget = gsb_combo_box_new_with_index ( text_frequency, G_CALLBACK (gsb_form_scheduler_frequency_button_changed), NULL ); tooltip_text = _("Frequency"); break; case SCHEDULED_FORM_LIMIT_DATE: widget = gsb_calendar_entry_new (FALSE); g_signal_connect ( G_OBJECT (widget), "button-press-event", G_CALLBACK (gsb_form_scheduler_button_press_event), GINT_TO_POINTER (element_number)); g_signal_connect ( G_OBJECT (widget), "focus-in-event", G_CALLBACK (gsb_form_entry_get_focus), GINT_TO_POINTER (element_number)); g_signal_connect_after ( G_OBJECT (widget), "focus-out-event", G_CALLBACK (gsb_form_scheduler_entry_lose_focus), GINT_TO_POINTER (element_number)); tooltip_text = _("Limit date"); break; case SCHEDULED_FORM_FREQUENCY_USER_ENTRY: widget = gtk_entry_new (); g_signal_connect ( G_OBJECT (widget), "focus-in-event", G_CALLBACK (gsb_form_entry_get_focus), GINT_TO_POINTER (element_number)); g_signal_connect_after ( G_OBJECT (widget), "focus-out-event", G_CALLBACK (gsb_form_scheduler_entry_lose_focus), GINT_TO_POINTER (element_number)); tooltip_text = _("Own frequency"); break; case SCHEDULED_FORM_FREQUENCY_USER_BUTTON: widget = gsb_combo_box_new_with_index ( text_frequency_user, NULL, NULL ); tooltip_text = _("Custom frequency"); break; } if (!widget) continue; if (tooltip_text) gtk_widget_set_tooltip_text ( GTK_WIDGET (widget), tooltip_text); /* save the element */ element = g_malloc0 (sizeof (struct_element)); element -> element_number = element_number; element -> element_widget = widget; scheduled_element_list = g_slist_append ( scheduled_element_list, element ); /* set in the form */ gtk_table_attach ( GTK_TABLE (table), widget, column, column+1, row, row+1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); } gsb_form_scheduler_clean ( ); return FALSE; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *table; GtkWidget *label; GtkWidget *entry; GtkWidget *button; GIcon *icon; GtkTargetList *tlist; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Gtk Entry Icons Test"); gtk_container_set_border_width (GTK_CONTAINER (window), 12); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); table = gtk_table_new (2, 4, FALSE); gtk_container_add (GTK_CONTAINER (window), table); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); /* * Open File - Sets the icon using a GIcon */ label = gtk_label_new ("Open File:"); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0); icon = g_themed_icon_new ("folder"); g_themed_icon_append_name (G_THEMED_ICON (icon), "folder"); gtk_entry_set_icon_from_gicon (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, icon); gtk_entry_set_icon_sensitive (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, FALSE); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, "Open a file"); button = gtk_button_new_with_label ("Properties"); gtk_table_attach (GTK_TABLE (table), button, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (button, "clicked", G_CALLBACK (properties_cb), entry); /* * Save File - sets the icon using a stock id. */ label = gtk_label_new ("Save File:"); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5); entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0); gtk_entry_set_text (GTK_ENTRY (entry), "Right-to-left"); gtk_widget_set_direction (entry, GTK_TEXT_DIR_RTL); gtk_entry_set_icon_from_stock (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_SAVE); gtk_entry_set_icon_tooltip_text (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, "Save a file"); tlist = gtk_target_list_new (NULL, 0); gtk_target_list_add_text_targets (tlist, 0); gtk_entry_set_icon_drag_source (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, tlist, GDK_ACTION_COPY); g_signal_connect_after (entry, "drag-begin", G_CALLBACK (drag_begin_cb), NULL); g_signal_connect (entry, "drag-data-get", G_CALLBACK (drag_data_get_cb), NULL); gtk_target_list_unref (tlist); button = gtk_button_new_with_label ("Properties"); gtk_table_attach (GTK_TABLE (table), button, 2, 3, 1, 2, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (button, "clicked", G_CALLBACK (properties_cb), entry); /* * Search - Uses a helper function */ label = gtk_label_new ("Search:"); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0); gtk_entry_set_icon_from_stock (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND); gtk_entry_set_icon_from_stock (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); g_signal_connect (entry, "icon-press", G_CALLBACK (clear_pressed), NULL); button = gtk_button_new_with_label ("Properties"); gtk_table_attach (GTK_TABLE (table), button, 2, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (button, "clicked", G_CALLBACK (properties_cb), entry); /* * Password - Sets the icon using a stock id */ label = gtk_label_new ("Password:"******"Properties"); gtk_table_attach (GTK_TABLE (table), button, 2, 3, 3, 4, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (button, "clicked", G_CALLBACK (properties_cb), entry); /* Name - Does not set any icons. */ label = gtk_label_new ("Name:"); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 4, 5, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0); button = gtk_button_new_with_label ("Properties"); gtk_table_attach (GTK_TABLE (table), button, 2, 3, 4, 5, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect (button, "clicked", G_CALLBACK (properties_cb), entry); gtk_widget_show_all (window); gtk_main(); return 0; }
static void save_settings_clicked(GtkWidget *widget, gpointer data) { struct trace_capture *cap = data; struct stat st; GtkWidget *dialog; GtkWidget *hbox; GtkWidget *label; GtkWidget *entry; GString *file; const char *name; gint result; int ret; dialog = gtk_dialog_new_with_buttons("Save Settings", NULL, GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); label = gtk_label_new("Settings Name: "); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_widget_show(label); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0); gtk_widget_show(entry); again: result = gtk_dialog_run(GTK_DIALOG(dialog)); switch (result) { case GTK_RESPONSE_ACCEPT: name = gtk_entry_get_text(GTK_ENTRY(entry)); if (!name || is_just_ws(name)) { warning("Must enter a name"); goto again; } /* Make sure home settings exists */ if (create_home_settings() < 0) break; file = get_home_settings_new(); g_string_append_printf(file, "/%s.kss", name); ret = stat(file->str, &st); if (ret >= 0) { ret = trace_dialog(GTK_WINDOW(dialog), TRACE_GUI_ASK, "The setting '%s' already exists.\n" "Are you sure you want to replace it", name); if (ret == GTK_RESPONSE_NO) { g_string_free(file, TRUE); goto again; } } save_settings(cap, file->str); refresh_settings(cap); g_free(cap->info->cap_settings_name); cap->info->cap_settings_name = g_strdup(name); set_settings(cap); g_string_free(file, TRUE); break; case GTK_RESPONSE_REJECT: break; default: break; }; gtk_widget_destroy(dialog); }
GtkWidget * org_gnome_activesync_server_url(EPlugin *epl, EConfigHookItemFactoryData *data) { EMConfigTargetSettings *target_account; const gchar *source_url; gchar *server_url = NULL, *username, *key; const char *address; GtkWidget *url_entry, *username_entry; gint row; GtkWidget *hbox, *label, *button; GConfClient *client = gconf_client_get_default(); EasEmailHandler* handler; GError *error = NULL; CamelSettings *settings; CamelEasSettings *eas_settings; CamelNetworkSettings *network_settings; target_account = (EMConfigTargetSettings *)data->config->target; settings = target_account->storage_settings; if (!CAMEL_IS_EAS_SETTINGS (settings)) { if (data->old && (label = g_object_get_data((GObject *)data->old, "authenticate-label"))) gtk_widget_destroy(label); return NULL; } if (data->old) { return data->old; } eas_settings = CAMEL_EAS_SETTINGS (settings); network_settings = CAMEL_NETWORK_SETTINGS (settings); address = target_account->email_address; key = g_strdup_printf ("/apps/activesyncd/accounts/%s/username", address); username = gconf_client_get_string (client, key, NULL); if (!username || !*username) { gconf_client_set_string (client, key, address, NULL); username = g_strdup (address); } g_free (key); key = g_strdup_printf ("/apps/activesyncd/accounts/%s/serverUri", address); server_url = gconf_client_get_string (client, key, NULL); g_object_unref (client); g_free (key); g_object_get (data->parent, "n-rows", &row, NULL); label = gtk_label_new_with_mnemonic (_("User_name:")); gtk_widget_show (label); username_entry = gtk_entry_new (); gtk_widget_show (username_entry); if (username) gtk_entry_set_text (GTK_ENTRY (username_entry), username); gtk_label_set_mnemonic_widget (GTK_LABEL (label), username_entry); g_signal_connect (username_entry, "changed", G_CALLBACK (username_entry_changed), data->config); gtk_table_attach (GTK_TABLE (data->parent), label, 0, 1, row, row+1, 0, 0, 0, 0); gtk_table_attach (GTK_TABLE (data->parent), username_entry, 1, 2, row, row+1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); row++; hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new_with_mnemonic(_("_Server URL:")); gtk_widget_show(label); url_entry = gtk_entry_new(); gtk_label_set_mnemonic_widget((GtkLabel *)label, url_entry); button = gtk_button_new_with_mnemonic (_("_Auto Detect")); gtk_box_pack_start (GTK_BOX (hbox), url_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show_all(hbox); gtk_table_attach (GTK_TABLE (data->parent), label, 0, 1, row, row+1, 0, 0, 0, 0); gtk_table_attach (GTK_TABLE (data->parent), hbox, 1, 2, row, row+1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); g_signal_connect (url_entry, "changed", G_CALLBACK(url_entry_changed), data->config); if (server_url) gtk_entry_set_text(GTK_ENTRY (url_entry), server_url); g_object_set_data ((GObject *)button, "url-entry", (gpointer) url_entry); g_signal_connect (button, "clicked", G_CALLBACK(discover_server_url), data->config); g_free (server_url); g_free (username); return hbox; }
int zar_spisr_m(class zar_spisr_rek *rek,GtkWidget *wpredok) { class zar_spisr_m_data data; char strsql[512]; iceb_u_str kikz; data.rk=rek; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); GtkWidget *label=NULL; sprintf(strsql,"%s\n%s",gettext("Распечатать список работников"), gettext("Если код подразделения не ввести, то получите список по всем подразделениям")); label=gtk_label_new(iceb_u_toutf(strsql)); sprintf(strsql,"%s %s",name_system,gettext("Распечатать список работников")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(zar_spisr_m_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); GtkWidget *separator1=gtk_hseparator_new(); GtkWidget *separator3=gtk_hseparator_new(); gtk_container_add (GTK_CONTAINER (vbox), separator1); //Вставляем радиокнопки GSList *group; data.radiobutton2[0]=gtk_radio_button_new_with_label(NULL,gettext("Список всех работающих")); gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton2[0], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.radiobutton2[0]), "clicked",GTK_SIGNAL_FUNC(spisr_radio2_0),&data); //gtk_object_set_user_data(GTK_OBJECT(data.radiobutton0),(gpointer)"0"); group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton2[0])); data.radiobutton2[1]=gtk_radio_button_new_with_label(group,gettext("Список всех уволенных")); gtk_signal_connect(GTK_OBJECT(data.radiobutton2[1]), "clicked",GTK_SIGNAL_FUNC(spisr_radio2_1),&data); gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton2[1], TRUE, TRUE, 0); group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton2[1])); data.radiobutton2[2]=gtk_radio_button_new_with_label(group,gettext("Список всех совместителей")); gtk_signal_connect(GTK_OBJECT(data.radiobutton2[2]), "clicked",GTK_SIGNAL_FUNC(spisr_radio2_2),&data); gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton2[2], TRUE, TRUE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton2[data.rk->metka_ras]),TRUE); //Устанавливем активной кнопку gtk_container_add (GTK_CONTAINER (vbox), separator3); GtkWidget *separator4=gtk_hseparator_new(); GtkWidget *separator5=gtk_hseparator_new(); gtk_container_add (GTK_CONTAINER (vbox), separator4); GSList *group2; data.radiobutton1[0]=gtk_radio_button_new_with_label(NULL,gettext("Сортировка по табельным номерам")); gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton1[0], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.radiobutton1[0]), "clicked",GTK_SIGNAL_FUNC(spisr_radio1_0),&data); //gtk_object_set_user_data(GTK_OBJECT(data.radiobutton0),(gpointer)"0"); group2=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton1[0])); data.radiobutton1[1]=gtk_radio_button_new_with_label(group2,gettext("Сортировка по фамилиям")); gtk_signal_connect(GTK_OBJECT(data.radiobutton1[1]), "clicked",GTK_SIGNAL_FUNC(spisr_radio1_1),&data); gtk_box_pack_start (GTK_BOX (vbox),data.radiobutton1[1], TRUE, TRUE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton1[data.rk->metka_sort]),TRUE); //Устанавливем активной кнопку gtk_container_add (GTK_CONTAINER (vbox), separator5); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); GtkTooltips *tooltips_enter[KOLENTER]; sprintf(strsql,"%s (,,)",gettext("Код подразделения")); data.knopka_enter[E_PODR]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_PODR]), data.knopka_enter[E_PODR], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_PODR]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_PODR]),(gpointer)E_PODR); tooltips_enter[E_PODR]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_PODR],data.knopka_enter[E_PODR],gettext("Выбор подразделения"),NULL); data.entry[E_PODR] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_PODR]), data.entry[E_PODR], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_PODR]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_PODR]),data.rk->podr.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_PODR]),(gpointer)E_PODR); sprintf(strsql,"%s (,,)",gettext("Табельный номер")); data.knopka_enter[E_TABNOM]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.knopka_enter[E_TABNOM], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_TABNOM]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_TABNOM]),(gpointer)E_TABNOM); tooltips_enter[E_TABNOM]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_TABNOM],data.knopka_enter[E_TABNOM],gettext("Выбор табельного номера"),NULL); data.entry[E_TABNOM] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.entry[E_TABNOM], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_TABNOM]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_TABNOM]),data.rk->podr.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_TABNOM]),(gpointer)E_TABNOM); sprintf(strsql,"%s (,,)",gettext("Код звания")); data.knopka_enter[E_KOD_ZVAN]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZVAN]), data.knopka_enter[E_KOD_ZVAN], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_ZVAN]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_ZVAN]),(gpointer)E_KOD_ZVAN); tooltips_enter[E_KOD_ZVAN]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_KOD_ZVAN],data.knopka_enter[E_KOD_ZVAN],gettext("Выбор звания"),NULL); data.entry[E_KOD_ZVAN] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZVAN]), data.entry[E_KOD_ZVAN], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_ZVAN]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_ZVAN]),data.rk->kod_zvan.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_ZVAN]),(gpointer)E_KOD_ZVAN); sprintf(strsql,"%s (,,)",gettext("Код категории")); data.knopka_enter[E_KOD_KATEG]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_KATEG]), data.knopka_enter[E_KOD_KATEG], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_KATEG]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_KATEG]),(gpointer)E_KOD_KATEG); tooltips_enter[E_KOD_KATEG]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_KOD_KATEG],data.knopka_enter[E_KOD_KATEG],gettext("Выбор категории"),NULL); data.entry[E_KOD_KATEG] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_KATEG]), data.entry[E_KOD_KATEG], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_KATEG]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_KATEG]),data.rk->kod_kateg.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_KATEG]),(gpointer)E_KOD_KATEG); sprintf(strsql,"%s (,,)",gettext("Счёт")); data.knopka_enter[E_SHETU]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_SHETU]), data.knopka_enter[E_SHETU], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHETU]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHETU]),(gpointer)E_SHETU); tooltips_enter[E_SHETU]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_SHETU],data.knopka_enter[E_SHETU],gettext("Выбор счёта в плане счетов"),NULL); data.entry[E_SHETU] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_SHETU]), data.entry[E_SHETU], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_SHETU]), "activate",GTK_SIGNAL_FUNC(zar_spisr_m_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHETU]),data.rk->shetu.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHETU]),(gpointer)E_SHETU); GtkTooltips *tooltips[KOL_FK]; sprintf(strsql,"F2 %s",gettext("Расчёт")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать расчёт"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введеноой информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(zar_spisr_m_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
/** * @fn GtkWidget* create_mainwin (void) * Crea la ventana principal */ GtkWidget* create_mainwin (void) { GtkWidget *app1; GtkWidget *dock1; GtkWidget *eventbox1; GtkWidget *viewport1; GtkWidget *vbox_main; GtkWidget *vbox_paned; GtkWidget *scrolledwindow; GtkWidget *paned; GtkWidget *text; GtkWidget *inputline; GtkWidget *sw; GtkWidget *ahbox; app1 = gnome_app_new ( PACKAGE, "Tenes Empanadas Graciela"); gtk_object_set_data (GTK_OBJECT (app1), "app1", app1); gtk_window_set_default_size (GTK_WINDOW (app1), 664, 640); gtk_window_set_policy (GTK_WINDOW (app1), TRUE, TRUE, FALSE); dock1 = GNOME_APP (app1)->dock; gtk_widget_ref (dock1); gtk_object_set_data_full (GTK_OBJECT (app1), "dock1", dock1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (dock1); gnome_app_create_menus (GNOME_APP (app1), menubar_uiinfo); gnome_app_create_toolbar(GNOME_APP(app1), toolbar_main); /* TODO: ask in GNOME if this is wanted */ /* gtk_menu_item_right_justify( GTK_MENU_ITEM(menubar_uiinfo[4].widget)); */ gtk_widget_realize (app1); gtk_signal_connect ( GTK_OBJECT(app1), "destroy", GTK_SIGNAL_FUNC( on_exit_activate ), NULL ); gtk_signal_connect ( GTK_OBJECT(app1), "delete_event", GTK_SIGNAL_FUNC( on_exit_activate ), NULL ); SensiData.connect_button = toolbar_main[0].widget; SensiData.start_button = toolbar_main[1].widget; /* 2 is a separator */ SensiData.enviarfichas_button = toolbar_main[3].widget; SensiData.reagrupe_button = toolbar_main[4].widget; SensiData.getcard_button = toolbar_main[5].widget; SensiData.endturn_button = toolbar_main[6].widget; /* 7 is a separator */ SensiData.status_button = toolbar_main[8].widget; eventbox1 = gtk_event_box_new (); gtk_widget_ref (eventbox1); gtk_object_set_data_full (GTK_OBJECT (app1), "eventbox1", eventbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (eventbox1); gnome_app_set_contents (GNOME_APP (app1), eventbox1); viewport1 = gtk_viewport_new (NULL, NULL); gtk_widget_show (viewport1); gtk_container_add (GTK_CONTAINER (eventbox1), viewport1); vbox_main = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox_main); gtk_container_add (GTK_CONTAINER (viewport1), vbox_main); /* status map */ if( mainstatus_create(&window_mainstatus) != TEG_STATUS_SUCCESS ) goto error; gtk_box_pack_start( GTK_BOX(vbox_main), window_mainstatus, FALSE,FALSE,0); /* paned */ paned = gtk_vpaned_new(); gtk_box_pack_start( GTK_BOX( vbox_main ), paned, TRUE, TRUE, 0 ); vbox_paned = gtk_vbox_new (FALSE, 0); gtk_paned_add1(GTK_PANED(paned), vbox_paned); gtk_widget_show (vbox_paned); /* map */ scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize(scrolledwindow, 640, 394); if( canvas_create_map() != TEG_STATUS_SUCCESS ) goto error; gtk_container_add(GTK_CONTAINER(scrolledwindow), canvas_map); gtk_container_add(GTK_CONTAINER(vbox_paned),scrolledwindow); gtk_widget_show (canvas_map); gtk_widget_show (scrolledwindow); /* text */ ahbox = gtk_hbox_new(FALSE, 2); gtk_paned_pack2(GTK_PANED(paned), ahbox, TRUE, TRUE); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(ahbox), sw, TRUE, TRUE, 0); gtk_widget_set_size_request(sw, 620, 60); text = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE); gtk_container_add(GTK_CONTAINER(sw), text); gtk_widget_set_name(text, "chatline"); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD); gtk_widget_realize(text); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 5); main_message_area = GTK_TEXT_VIEW(text); /* set_output_window_text(_("Tenes Empanadas Graciela")); */ gtk_widget_show(text); gtk_widget_show(sw); gtk_widget_show(ahbox); gtk_widget_show(paned); /* the chat line */ inputline = gtk_entry_new(); gtk_box_pack_start( GTK_BOX( vbox_main ), inputline, FALSE, FALSE, 0 ); gtk_widget_show(inputline); g_signal_connect(inputline, "activate", G_CALLBACK(inputline_return), NULL); chatline_init(); /* status bar */ statusbar = gnome_appbar_new (FALSE, TRUE, GNOME_PREFERENCES_NEVER); gtk_widget_ref (statusbar); gtk_object_set_data_full (GTK_OBJECT (app1), "statusbar", statusbar, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (statusbar); gnome_app_set_statusbar (GNOME_APP (app1), statusbar); gtk_box_pack_start(GTK_BOX(statusbar), ministatus_build(), FALSE, TRUE, 0); gnome_appbar_set_status(GNOME_APPBAR(statusbar), _("Welcome to TEG!")); gnome_app_install_menu_hints( GNOME_APP(app1), menubar_uiinfo ); /* icono */ { GdkBitmap *mask; GdkPixmap *icono; #include "../teg_pix/teg_icono.xpm" gtk_widget_realize (app1); icono = gdk_pixmap_create_from_xpm_d( app1->window, &mask, &app1->style->bg[GTK_STATE_NORMAL],teg_icono_xpm ); gdk_window_set_icon (app1->window, NULL, icono , mask ); } gtk_widget_show(app1); return app1; error: g_error(_("Unable to create map!")); return NULL; }