//-------------------------------------------------------------
GtkWidget *create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *label1;
GtkWidget *label_time;
GtkWidget *progressbar1;
GtkWidget *dialog_action_area1;
GtkWidget *closebutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("dialog1"));
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
label1 = gtk_label_new (_("Time left :"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, TRUE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
label_time = gtk_label_new (_("0:0:0"));
gtk_widget_show (label_time);
gtk_box_pack_start (GTK_BOX (hbox1), label_time, TRUE, TRUE, 0);
gtk_label_set_justify (GTK_LABEL (label_time), GTK_JUSTIFY_LEFT);
progressbar1 = gtk_progress_bar_new ();
gtk_widget_show (progressbar1);
gtk_box_pack_start (GTK_BOX (vbox1), progressbar1, FALSE, FALSE, 0);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
closebutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (closebutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), closebutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (closebutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, label_time, "label_time");
GLADE_HOOKUP_OBJECT (dialog1, progressbar1, "progressbar1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, closebutton1, "closebutton1");
return dialog1;
}
static GtkWidget *
progress_widget_new (NautilusProgressInfo *info)
{
ProgressWidgetData *data;
GtkWidget *label, *bar, *hbox, *vbox, *button, *image;
data = g_new0 (ProgressWidgetData, 1);
data->info = g_object_ref (info);
hbox = gtk_hbox_new (FALSE, 0);
data->widget = hbox;
g_object_set_data_full (G_OBJECT (data->widget),
"data", data, (GDestroyNotify)progress_widget_data_free);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox),
vbox,
FALSE, FALSE,
2);
gtk_widget_show (vbox);
label = gtk_label_new ("details");
gtk_widget_set_size_request (label,
400, -1);
data->status = GTK_LABEL (label);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox),
label,
FALSE, FALSE,
2);
bar = gtk_progress_bar_new ();
data->progress_bar = GTK_PROGRESS_BAR (bar);
gtk_progress_bar_set_pulse_step (data->progress_bar, 0.05);
gtk_widget_show (bar);
gtk_box_pack_start (GTK_BOX (vbox),
bar,
FALSE, FALSE,
2);
label = gtk_label_new ("status");
gtk_widget_set_size_request (label,
400, -1);
data->details = GTK_LABEL (label);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox),
label,
FALSE, FALSE,
0);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox),
vbox,
FALSE, FALSE,
0);
gtk_widget_show (vbox);
image = gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (vbox),
button,
TRUE, FALSE,
0);
g_signal_connect (button, "clicked", (GCallback)cancel_clicked, data);
update_data (data);
update_progress (data);
g_signal_connect_swapped (data->info, "changed", (GCallback)update_data, data);
g_signal_connect_swapped (data->info, "progress_changed", (GCallback)update_progress, data);
g_signal_connect_swapped (data->info, "finished", (GCallback)op_finished, data);
gtk_widget_show (data->widget);
return data->widget;
}
static void
nautilus_progress_info_widget_constructed (GObject *obj)
{
GtkWidget *label, *progress_bar, *hbox, *box, *button, *image;
NautilusProgressInfoWidget *self = NAUTILUS_PROGRESS_INFO_WIDGET (obj);
G_OBJECT_CLASS (nautilus_progress_info_widget_parent_class)->constructed (obj);
label = gtk_label_new ("status");
gtk_widget_set_size_request (label, 500, -1);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (self),
label,
TRUE, FALSE,
0);
self->priv->status = label;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
progress_bar = gtk_progress_bar_new ();
self->priv->progress_bar = progress_bar;
gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (progress_bar), 0.05);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX (box),
progress_bar,
TRUE, FALSE,
0);
gtk_box_pack_start(GTK_BOX (hbox),
box,
TRUE, TRUE,
0);
image = gtk_image_new_from_icon_name ("gtk-cancel",
GTK_ICON_SIZE_BUTTON);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (button), image);
gtk_box_pack_start (GTK_BOX (hbox),
button,
FALSE,FALSE,
0);
g_signal_connect (button, "clicked",
G_CALLBACK (cancel_clicked), self);
gtk_box_pack_start (GTK_BOX (self),
hbox,
FALSE,FALSE,
0);
label = gtk_label_new ("details");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (self),
label,
TRUE, FALSE,
0);
self->priv->details = label;
gtk_widget_show_all (GTK_WIDGET (self));
update_data (self);
update_progress (self);
g_signal_connect_swapped (self->priv->info,
"changed",
G_CALLBACK (update_data), self);
g_signal_connect_swapped (self->priv->info,
"progress-changed",
G_CALLBACK (update_progress), self);
g_signal_connect_swapped (self->priv->info,
"finished",
G_CALLBACK (info_finished), self);
}
void import_dialog(GtkWidget *w, gpointer data)
{
int result;
GtkWidget *dialog, *hbox, *vbox, *label;
GtkComboBox *computer;
GtkEntry *device;
GtkWidget *XMLchooser;
device_data_t devicedata = {
.devname = NULL,
};
dialog = gtk_dialog_new_with_buttons("Import from dive computer",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
label = gtk_label_new("Import: \nLoad XML file or import directly from dive computer");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 3);
XMLchooser = xml_file_selector(vbox, dialog);
computer = dive_computer_selector(vbox);
device = dive_computer_device(vbox);
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 3);
devicedata.progress.bar = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(hbox), devicedata.progress.bar);
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result) {
int type;
GtkTreeIter iter;
GtkTreeModel *model;
const char *comp;
GSList *list;
case GTK_RESPONSE_ACCEPT:
/* what happened - did the user pick a file? In that case
* we ignore whether a dive computer model was picked */
list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(XMLchooser));
if (g_slist_length(list) == 0) {
if (!gtk_combo_box_get_active_iter(computer, &iter))
break;
model = gtk_combo_box_get_model(computer);
gtk_tree_model_get(model, &iter,
0, &comp,
1, &type,
-1);
devicedata.type = type;
devicedata.name = comp;
devicedata.devname = gtk_entry_get_text(device);
do_import(&devicedata);
} else {
g_slist_foreach(list,do_import_file,NULL);
g_slist_free(list);
}
break;
default:
break;
}
gtk_widget_destroy(dialog);
report_dives(TRUE);
}
GtkWidget *create_dialog1 (uint32_t max, float *value)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *progressbar1;
GtkWidget *progressbar2;
GtkWidget *dialog_action_area1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), "Bitrate Histogram");
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
table1 = gtk_table_new (20, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 0);
/*----*/
char string[200];
float p;
for(int j=0; j<20; j++)
{
sprintf(string,"%05d kbps :",(max*j)/20);
label1 = gtk_label_new (string);
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 20-j-1, 20-j,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
gtk_widget_set_usize(label1,100,-1);
progressbar1 = gtk_progress_bar_new ();
gtk_widget_show (progressbar1);
gtk_table_attach (GTK_TABLE (table1), progressbar1, 1, 2, 20-j-1, 20-j,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
p=value[j];
p=p/100.;
gtk_progress_set_percentage(GTK_PROGRESS(progressbar1),(gfloat)p);
}
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
void GUIShowMainWindow()
{
gui.windows.main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(gui.windows.main), "rcracki_mt-GUI");
gtk_window_set_default_size(GTK_WINDOW(gui.windows.main), 740, 540);
gtk_window_set_icon(GTK_WINDOW(gui.windows.main), gdk_pixbuf_new_from_file("icon.png", NULL));
gui.fixed.main = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(gui.windows.main), gui.fixed.main);
/* Menu bar */
gui.menu.bar = gtk_menu_bar_new();
gtk_widget_set_size_request(gui.menu.bar, 740, 28);
gui.menu.filemenu = gtk_menu_new();
gui.menu.settingsmenu = gtk_menu_new();
gui.menu.helpmenu = gtk_menu_new();
gui.menu.file = gtk_menu_item_new_with_mnemonic("_File");
gui.menu.tables = gtk_menu_item_new_with_label("Add tables");
gui.menu.hashes = gtk_menu_item_new_with_label("Add hashes");
gui.menu.session = gtk_menu_item_new_with_label("Load session");
gui.menu.quit = gtk_menu_item_new_with_label("Quit");
gui.menu.settings = gtk_menu_item_new_with_mnemonic("_Settings");
gui.menu.preferences = gtk_menu_item_new_with_label("Preferences");
gui.menu.help = gtk_menu_item_new_with_mnemonic("_Help");
gui.menu.info = gtk_menu_item_new_with_label("About");
gui.menu.seperator = gtk_separator_menu_item_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gui.menu.file), gui.menu.filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.tables);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.hashes);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.session);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.seperator);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.filemenu), gui.menu.quit);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.bar), gui.menu.file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gui.menu.settings), gui.menu.settingsmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.settingsmenu), gui.menu.preferences);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.bar), gui.menu.settings);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gui.menu.help), gui.menu.helpmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.helpmenu), gui.menu.info);
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu.bar), gui.menu.help);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.menu.bar, 0, 0);
/* Control buttons */
gui.buttons.run = gtk_button_new_with_label("Run");
gtk_widget_set_size_request(gui.buttons.run, 64, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.run, 8, 56);
gui.buttons.pause = gtk_button_new_with_label("Pause");
gtk_widget_set_size_request(gui.buttons.pause, 64, 32);
gtk_widget_set_sensitive(gui.buttons.pause, false);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.pause, 88, 56);
gui.buttons.abort = gtk_button_new_with_label("Abort");
gtk_widget_set_size_request(gui.buttons.abort, 64, 32);
gtk_widget_set_sensitive(gui.buttons.abort, false);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.abort, 168, 56);
gui.buttons.clear = gtk_button_new_with_label("Clear");
gtk_widget_set_size_request(gui.buttons.clear, 64, 32);
gtk_widget_set_tooltip_text(gui.buttons.clear, "Clear all messages");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.buttons.clear, 248, 56);
/* Message view */
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.frame = gtk_aspect_frame_new("Messages", 0.1, 0.1, 10, true);
gtk_widget_set_size_request(gui.frame, 740, 165);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.frame, 5, 100);
gui.txtview.msg = gtk_text_view_new();
gtk_widget_set_size_request(gui.txtview.msg, 712, 140);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(gui.txtview.msg), 5);
gtk_text_view_set_editable(GTK_TEXT_VIEW(gui.txtview.msg), false);
gui.txtview.msg_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gui.txtview.msg));
gtk_container_add(GTK_CONTAINER(scroll), gui.txtview.msg);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), scroll, 8, 120);
/* Plaintext view */
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.frame = gtk_aspect_frame_new("Plaintexts", 0.0, 0.0, 10, true);
gtk_widget_set_size_request(gui.frame, 740, 165);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.frame, 5, 280);
gui.txtview.hashes = gtk_text_view_new();
gtk_widget_set_size_request(gui.txtview.hashes, 712, 140);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(gui.txtview.hashes), 5);
gtk_text_view_set_editable(GTK_TEXT_VIEW(gui.txtview.hashes), false);
gui.txtview.hashes_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gui.txtview.hashes));
gtk_container_add(GTK_CONTAINER(scroll), gui.txtview.hashes);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), scroll, 8, 300);
gtk_text_buffer_get_iter_at_offset(gui.txtview.msg_buffer, &gui.txtview.msg_iter, 0);
gtk_text_buffer_get_iter_at_offset(gui.txtview.hashes_buffer, &gui.txtview.hashes_iter, 0);
GdkColor color;
gdk_color_parse("red", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-red", "foreground-gdk", &color, NULL);
gdk_color_parse("darkblue", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-blue", "foreground-gdk", &color, NULL);
gdk_color_parse("grey", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-grey", "foreground-gdk", &color, NULL);
gdk_color_parse("black", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-black", "foreground-gdk", &color, NULL);
gdk_color_parse("darkgreen", &color);
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-green", "foreground-gdk", &color, NULL);
color.red = color.green = color.blue = 12000;
gtk_text_buffer_create_tag(gui.txtview.msg_buffer, "col-darkgrey", "foreground-gdk", &color, NULL);
/* Progress bar */
gui.progbar = gtk_progress_bar_new();
gtk_widget_set_size_request(gui.progbar, 735, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.progbar, 8, 450);
/* Information bar */
gui.label = gtk_label_new("Current:");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.label, 20, 510);
gui.entries.current = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(gui.entries.current), false);
gtk_entry_set_text(GTK_ENTRY(gui.entries.current), "None");
gtk_widget_set_tooltip_text(gui.entries.current, "Current action");
gtk_widget_set_size_request(gui.entries.current, 120, 24);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.entries.current, 90, 505);
gui.label = gtk_label_new("Found:");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.label, 250, 510);
gui.entries.found = gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(gui.entries.found), false);
gtk_widget_set_tooltip_text(gui.entries.found, "Cracked hashes");
gtk_widget_set_size_request(gui.entries.found, 120, 24);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.entries.found, 320, 505);
gui.label = gtk_label_new("Elapsed time:");
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.label, 470, 510);
gui.entries.time= gtk_entry_new();
gtk_entry_set_editable(GTK_ENTRY(gui.entries.time), false);
gtk_widget_set_tooltip_text(gui.entries.time, "Elapsed time since start");
gtk_widget_set_size_request(gui.entries.time, 120, 24);
gtk_fixed_put(GTK_FIXED(gui.fixed.main), gui.entries.time, 570, 505);
gtk_widget_show_all(gui.windows.main);
g_signal_connect(gui.windows.main, "destroy", G_CALLBACK(QuitApplication), NULL);
g_signal_connect(gui.windows.main, "delete-event", G_CALLBACK(QuitApplication), NULL);
g_signal_connect(gui.menu.hashes, "activate", G_CALLBACK(ShowHashWindow), NULL);
g_signal_connect(gui.menu.tables, "activate", G_CALLBACK(GUIShowTableWindow), NULL);
g_signal_connect(gui.menu.preferences, "activate", G_CALLBACK(GUIShowSettingsWindow), NULL);
g_signal_connect(gui.buttons.run, "clicked", G_CALLBACK(StartSession), NULL);
g_signal_connect(gui.buttons.clear, "clicked", G_CALLBACK(ClearMessages), NULL);
g_signal_connect(gui.menu.session, "activate", G_CALLBACK(BrowseSessionFile), NULL);
g_signal_connect(gui.buttons.pause, "clicked", G_CALLBACK(PauseResumeSession), NULL);
g_signal_connect(gui.buttons.abort, "clicked", G_CALLBACK(AbortSession), NULL);
g_signal_connect(gui.menu.quit, "activate", G_CALLBACK(QuitApplication), NULL);
g_signal_connect(gui.menu.info, "activate", G_CALLBACK(GUIShowInfo), NULL);
}
// static
wxVisualAttributes
wxGauge::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
{
return GetDefaultAttributesFromGTKWidget(gtk_progress_bar_new(),
false, GTK_STATE_ACTIVE);
}
GtkWidget*
create_rs232 (void)
{
GtkWidget *rs232;
GtkWidget *eventbox1;
GtkWidget *vbox1;
GtkWidget *hbox5;
GtkWidget *exit;
GtkWidget *swap;
GtkWidget *clean_data_area;
GtkWidget *label7;
GtkWidget *label8;
GtkWidget *hseparator5;
GtkWidget *hbox3;
GtkWidget *vbox2;
GtkWidget *hbox18;
GtkWidget *label1;
GtkWidget *combo1;
GList *combo1_items = NULL;
GtkWidget *combo_entry_baudrate;
GtkWidget *hbox24;
GtkWidget *label2;
GtkWidget *entry5;
GtkWidget *label20;
GtkWidget *hbox19;
GtkWidget *label3;
GtkWidget *hbox25;
GtkWidget *combo3;
GList *combo3_items = NULL;
GtkWidget *combo_entry_port;
GtkWidget *hbox26;
GtkWidget *label4;
GtkWidget *entry2;
GtkWidget *label21;
GtkWidget *hbox27;
GtkWidget *togglebutton1;
GtkWidget *save_as_numeral;
GtkWidget *entry1;
GtkWidget *scrolledwindow1;
GtkWidget *text1;
GtkWidget *scrolledwindow2;
GtkWidget *text2;
GtkWidget *hseparator4;
GtkWidget *hbox4;
GtkWidget *label22;
GSList *_4_group = NULL;
GtkWidget *radiobutton1;
guint radiobutton2_key;
GtkWidget *radiobutton2;
GtkWidget *hseparator6;
GtkWidget *hbox29;
GtkWidget *spectrum;
GtkWidget *inspect;
GtkWidget *hbox30;
GtkWidget *big_spectrum;
GtkWidget *optionmenu1;
GtkWidget *optionmenu1_menu;
GtkWidget *glade_menuitem;
GtkWidget *print_spectrum;
GtkWidget *label19;
GtkWidget *printer_name;
GtkWidget *hbox17;
GtkWidget *label18;
GtkWidget *point;
GtkWidget *save_as_eps;
GtkWidget *entry4;
GtkWidget *hseparator1;
GtkWidget *hbox9;
GtkWidget *label9;
GSList *_1_group = NULL;
GtkWidget *specification_on;
GtkWidget *coefficient_on;
GtkWidget *hseparator3;
GtkWidget *hbox6;
GtkWidget *label11;
GSList *_2_group = NULL;
GtkWidget *move_average;
GtkWidget *window;
GtkWidget *butterworth;
GtkWidget *chebyshev;
GtkWidget *hbox8;
GtkWidget *fs_label;
GtkWidget *fs;
GtkWidget *pass_edge_label;
GtkWidget *pass_edge;
GtkWidget *stop_edge_label;
GtkWidget *stop_edge;
GtkWidget *pass_ripple_label;
GtkWidget *pass_ripple;
GtkWidget *stop_ripple_label;
GtkWidget *stop_ripple;
GtkWidget *hseparator2;
GtkWidget *hbox10;
GtkWidget *label12;
GSList *_3_group = NULL;
GtkWidget *fir_input_coefficient;
GtkWidget *iir_input_coefficient;
GtkWidget *identify_stability;
GtkWidget *hbox14;
GtkWidget *label16;
GtkWidget *a_value;
GtkWidget *label17;
GtkWidget *b_value;
GtkWidget *appbar1;
GtkWidget *hbox28;
GtkWidget *statusbar1;
GtkWidget *progressbar1;
GtkAccelGroup *accel_group;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
accel_group = gtk_accel_group_new ();
rs232 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (rs232), "rs232", rs232);
gtk_window_set_title (GTK_WINDOW (rs232), _("\246\263\255\255\257\337\275\304\305T\300\263 FIR \244\316\265L\255\255\257\337\275\304\305T\300\263 IIR \252\272\300W\303\320\244\300\252R\300\263\245\316"));
gtk_window_set_policy (GTK_WINDOW (rs232), FALSE, FALSE, TRUE);
eventbox1 = gtk_event_box_new ();
gtk_widget_ref (eventbox1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "eventbox1", eventbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (eventbox1);
gtk_container_add (GTK_CONTAINER (rs232), eventbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (eventbox1), vbox1);
hbox5 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox5);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox5", hbox5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox5);
gtk_box_pack_start (GTK_BOX (vbox1), hbox5, TRUE, TRUE, 10);
exit = gtk_button_new_with_label (_("\302\367\266}"));
gtk_widget_ref (exit);
gtk_object_set_data_full (GTK_OBJECT (rs232), "exit", exit,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (exit);
gtk_box_pack_start (GTK_BOX (hbox5), exit, FALSE, FALSE, 10);
gtk_widget_set_usize (exit, 100, -2);
swap = gtk_button_new_with_label (_("\261\265\246\254"));
gtk_widget_ref (swap);
gtk_object_set_data_full (GTK_OBJECT (rs232), "swap", swap,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (swap);
gtk_box_pack_start (GTK_BOX (hbox5), swap, FALSE, FALSE, 10);
gtk_widget_set_usize (swap, 100, -2);
gtk_tooltips_set_tip (tooltips, swap, _("\245i\261\265\246\254\245\321\246\352\246C\260\360\251\322\260e\250\323\252\272\270\352\256\306"), NULL);
clean_data_area = gtk_button_new_with_label (_("\262M\260\243\270\352\256\306\261\265\246\254\260\317"));
gtk_widget_ref (clean_data_area);
gtk_object_set_data_full (GTK_OBJECT (rs232), "clean_data_area", clean_data_area,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clean_data_area);
gtk_box_pack_start (GTK_BOX (hbox5), clean_data_area, FALSE, FALSE, 10);
label7 = gtk_label_new (_("\255\354\251l\270\352\256\306"));
gtk_widget_ref (label7);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label7", label7,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label7);
gtk_box_pack_start (GTK_BOX (hbox5), label7, FALSE, FALSE, 89);
label8 = gtk_label_new (_("\274\306\255\310\270\352\256\306"));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_box_pack_start (GTK_BOX (hbox5), label8, FALSE, FALSE, 52);
hseparator5 = gtk_hseparator_new ();
gtk_widget_ref (hseparator5);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator5", hseparator5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator5);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator5, TRUE, TRUE, 5);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox3", hbox3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, TRUE, 5);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "vbox2", vbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox3), vbox2, TRUE, TRUE, 0);
hbox18 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox18);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox18", hbox18,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox18);
gtk_box_pack_start (GTK_BOX (vbox2), hbox18, TRUE, TRUE, 5);
label1 = gtk_label_new (_("\266\307\277\351\300j\262v"));
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox18), label1, FALSE, FALSE, 10);
combo1 = gtk_combo_new ();
gtk_widget_ref (combo1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo1", combo1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo1);
gtk_box_pack_start (GTK_BOX (hbox18), combo1, TRUE, TRUE, 10);
gtk_widget_set_usize (combo1, 1, -2);
combo1_items = g_list_append (combo1_items, (gpointer) _("2400"));
combo1_items = g_list_append (combo1_items, (gpointer) _("4800"));
combo1_items = g_list_append (combo1_items, (gpointer) _("9600"));
combo1_items = g_list_append (combo1_items, (gpointer) _("19200"));
combo1_items = g_list_append (combo1_items, (gpointer) _("38400"));
combo1_items = g_list_append (combo1_items, (gpointer) _("57600"));
combo1_items = g_list_append (combo1_items, (gpointer) _("115200"));
gtk_combo_set_popdown_strings (GTK_COMBO (combo1), combo1_items);
g_list_free (combo1_items);
combo_entry_baudrate = GTK_COMBO (combo1)->entry;
gtk_widget_ref (combo_entry_baudrate);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo_entry_baudrate", combo_entry_baudrate,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo_entry_baudrate);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_baudrate), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_baudrate), _("4800"));
hbox24 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox24);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox24", hbox24,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox24);
gtk_box_pack_start (GTK_BOX (hbox18), hbox24, TRUE, TRUE, 0);
label2 = gtk_label_new (_("\270\352\256\306\252\370\253\327"));
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (hbox24), label2, FALSE, FALSE, 15);
entry5 = gtk_entry_new ();
gtk_widget_ref (entry5);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry5", entry5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry5);
gtk_box_pack_start (GTK_BOX (hbox24), entry5, TRUE, TRUE, 10);
gtk_widget_set_usize (entry5, 1, -2);
gtk_tooltips_set_tip (tooltips, entry5, _("\263\346\246\354\254O\246\354\244\270\262\325"), NULL);
gtk_entry_set_text (GTK_ENTRY (entry5), _("16"));
label20 = gtk_label_new (_("\246\354\244\270\262\325\274\306"));
gtk_widget_ref (label20);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label20", label20,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label20);
gtk_box_pack_start (GTK_BOX (hbox24), label20, FALSE, FALSE, 10);
hbox19 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox19);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox19", hbox19,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox19);
gtk_box_pack_start (GTK_BOX (vbox2), hbox19, TRUE, TRUE, 5);
label3 = gtk_label_new (_("\266\307\277\351\247\307\246C"));
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_box_pack_start (GTK_BOX (hbox19), label3, FALSE, FALSE, 10);
hbox25 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox25);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox25", hbox25,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox25);
gtk_box_pack_start (GTK_BOX (hbox19), hbox25, TRUE, TRUE, 0);
combo3 = gtk_combo_new ();
gtk_widget_ref (combo3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo3", combo3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo3);
gtk_box_pack_start (GTK_BOX (hbox25), combo3, TRUE, TRUE, 10);
gtk_widget_set_usize (combo3, 1, -2);
combo3_items = g_list_append (combo3_items, (gpointer) _("1"));
combo3_items = g_list_append (combo3_items, (gpointer) _("2"));
gtk_combo_set_popdown_strings (GTK_COMBO (combo3), combo3_items);
g_list_free (combo3_items);
combo_entry_port = GTK_COMBO (combo3)->entry;
gtk_widget_ref (combo_entry_port);
gtk_object_set_data_full (GTK_OBJECT (rs232), "combo_entry_port", combo_entry_port,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (combo_entry_port);
gtk_entry_set_editable (GTK_ENTRY (combo_entry_port), FALSE);
gtk_entry_set_text (GTK_ENTRY (combo_entry_port), _("1"));
hbox26 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox26);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox26", hbox26,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox26);
gtk_box_pack_start (GTK_BOX (hbox25), hbox26, TRUE, TRUE, 0);
label4 = gtk_label_new (_("\270\352\256\306\301`\274\306"));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_box_pack_start (GTK_BOX (hbox26), label4, FALSE, FALSE, 15);
entry2 = gtk_entry_new ();
gtk_widget_ref (entry2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry2", entry2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry2);
gtk_box_pack_start (GTK_BOX (hbox26), entry2, TRUE, TRUE, 10);
gtk_widget_set_usize (entry2, 1, -2);
gtk_entry_set_text (GTK_ENTRY (entry2), _("5"));
label21 = gtk_label_new (_("\265\247\270\352\256\306\274\306"));
gtk_widget_ref (label21);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label21", label21,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label21);
gtk_box_pack_start (GTK_BOX (hbox26), label21, FALSE, FALSE, 10);
hbox27 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox27);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox27", hbox27,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox27);
gtk_box_pack_start (GTK_BOX (vbox2), hbox27, FALSE, FALSE, 5);
togglebutton1 = gtk_toggle_button_new_with_label (_("\261j\250\356\274g\244J\300\311\256\327"));
gtk_widget_ref (togglebutton1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "togglebutton1", togglebutton1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (togglebutton1);
gtk_box_pack_start (GTK_BOX (hbox27), togglebutton1, FALSE, FALSE, 10);
gtk_tooltips_set_tip (tooltips, togglebutton1, _("\244\243\272\336\253\374\251w\252\272\300\311\256\327\270\364\256|\244\247\300\311\246W\246s\246b\273P\247_\241A\244@\253\337\261j\250\356\274g\244J"), NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton1), TRUE);
save_as_numeral = gtk_button_new_with_label (_("\300\311\256\327\270\364\256|"));
gtk_widget_ref (save_as_numeral);
gtk_object_set_data_full (GTK_OBJECT (rs232), "save_as_numeral", save_as_numeral,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (save_as_numeral);
gtk_box_pack_start (GTK_BOX (hbox27), save_as_numeral, FALSE, FALSE, 0);
entry1 = gtk_entry_new ();
gtk_widget_ref (entry1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry1", entry1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry1);
gtk_box_pack_start (GTK_BOX (hbox27), entry1, TRUE, TRUE, 10);
gtk_widget_set_usize (entry1, 1, -2);
gtk_entry_set_text (GTK_ENTRY (entry1), _("/home/allways/numeral.txt"));
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow1, TRUE, TRUE, 5);
gtk_widget_set_usize (scrolledwindow1, 1, -2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
text1 = gtk_text_new (NULL, NULL);
gtk_widget_ref (text1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "text1", text1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (text1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), text1);
gtk_tooltips_set_tip (tooltips, text1, _("\261q\246\352\246C\260\360\266\307\250\323\252\272\247\271\276\343\270\352\256\306"), NULL);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "scrolledwindow2", scrolledwindow2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow2);
gtk_box_pack_start (GTK_BOX (hbox3), scrolledwindow2, TRUE, TRUE, 5);
gtk_widget_set_usize (scrolledwindow2, 1, -2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
text2 = gtk_text_new (NULL, NULL);
gtk_widget_ref (text2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "text2", text2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (text2);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), text2);
gtk_tooltips_set_tip (tooltips, text2, _("\261q\247\271\276\343\270\352\256\306\251\322\261o\250\354\252\272\257\302\274\306\255\310\270\352\256\306"), NULL);
hseparator4 = gtk_hseparator_new ();
gtk_widget_ref (hseparator4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator4", hseparator4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator4);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator4, TRUE, TRUE, 5);
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox4", hbox4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (vbox1), hbox4, TRUE, TRUE, 5);
label22 = gtk_label_new (_("\250\317\245\316\245\273\263n\305\351\244\247\302o\252i\276\271"));
gtk_widget_ref (label22);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label22", label22,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label22);
gtk_box_pack_start (GTK_BOX (hbox4), label22, FALSE, FALSE, 10);
radiobutton1 = gtk_radio_button_new_with_label (_4_group, _("\254O"));
_4_group = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton1));
gtk_widget_ref (radiobutton1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "radiobutton1", radiobutton1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton1);
gtk_box_pack_start (GTK_BOX (hbox4), radiobutton1, FALSE, FALSE, 0);
radiobutton2 = gtk_radio_button_new_with_label (_4_group, "");
radiobutton2_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (radiobutton2)->child),
_("\247_"));
gtk_widget_add_accelerator (radiobutton2, "clicked", accel_group,
radiobutton2_key, GDK_MOD1_MASK, (GtkAccelFlags) 0);
_4_group = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton2));
gtk_widget_ref (radiobutton2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "radiobutton2", radiobutton2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton2);
gtk_box_pack_start (GTK_BOX (hbox4), radiobutton2, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton2), TRUE);
hseparator6 = gtk_hseparator_new ();
gtk_widget_ref (hseparator6);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator6", hseparator6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator6);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator6, TRUE, TRUE, 5);
hbox29 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox29);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox29", hbox29,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox29);
gtk_box_pack_start (GTK_BOX (vbox1), hbox29, TRUE, TRUE, 5);
spectrum = gtk_button_new_with_label (_("\266}\251l\303\270\273s\302o\252i\276\271\300W\303\320\271\317"));
gtk_widget_ref (spectrum);
gtk_object_set_data_full (GTK_OBJECT (rs232), "spectrum", spectrum,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (spectrum);
gtk_box_pack_start (GTK_BOX (hbox29), spectrum, FALSE, FALSE, 10);
gtk_tooltips_set_tip (tooltips, spectrum, _("\267\355\246U\260\321\274\306\244\316\263]\251w\246n\244F\244\247\253\341\241A\264N\245i\245H\253\366\246\271\266s\250\323\303\270\273s\271\317\247\316\244F"), NULL);
inspect = gtk_button_new_with_label (_("\300\313\265\370\271\317\300\311"));
gtk_widget_ref (inspect);
gtk_object_set_data_full (GTK_OBJECT (rs232), "inspect", inspect,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (inspect);
gtk_box_pack_start (GTK_BOX (hbox29), inspect, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, inspect, _("\245i\244\243\254O A \271\317\263\341\241I\254O\300W\303\320\271\317\260\325\241I"), NULL);
hbox30 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox30);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox30", hbox30,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox30);
gtk_box_pack_start (GTK_BOX (vbox1), hbox30, TRUE, TRUE, 5);
big_spectrum = gtk_toggle_button_new_with_label (_("\244j\261i\252\272\300W\303\320\271\317"));
gtk_widget_ref (big_spectrum);
gtk_object_set_data_full (GTK_OBJECT (rs232), "big_spectrum", big_spectrum,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (big_spectrum);
gtk_box_pack_start (GTK_BOX (hbox30), big_spectrum, FALSE, FALSE, 10);
optionmenu1 = gtk_option_menu_new ();
gtk_widget_ref (optionmenu1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "optionmenu1", optionmenu1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (optionmenu1);
gtk_box_pack_start (GTK_BOX (hbox30), optionmenu1, FALSE, FALSE, 10);
optionmenu1_menu = gtk_menu_new ();
glade_menuitem = gtk_menu_item_new_with_label (_(" \300W\303\320\271\317\252\355\245\334\244\350\252k"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\274\306\246\354\300W\262v Y\241G\275u\251\312\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\274\306\246\354\300W\262v Y\241G\244\300\250\251\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\303\376\244\361\300W\262v Y\241G\275u\251\312\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
glade_menuitem = gtk_menu_item_new_with_label (_("X \266b\241G\303\376\244\361\300W\262v Y\241G\244\300\250\251\274W\257q"));
gtk_widget_show (glade_menuitem);
gtk_menu_append (GTK_MENU (optionmenu1_menu), glade_menuitem);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), optionmenu1_menu);
print_spectrum = gtk_toggle_button_new_with_label (_("\300W\303\320\271\317\245\316\246L\252\355\276\367\246L\245X"));
gtk_widget_ref (print_spectrum);
gtk_object_set_data_full (GTK_OBJECT (rs232), "print_spectrum", print_spectrum,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (print_spectrum);
gtk_box_pack_start (GTK_BOX (hbox30), print_spectrum, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, print_spectrum, _("\300W\303\320\271\317\273\335\255n\245\316\246L\252\355\276\367\303\270\273s\245X\250\323\252\272\256\311\255\324\241A\250\317\244\247\244U\250H\241A\260O\261o\246L\252\355\276\367\252\272\246W\272\331\255n\245[\263\341\241I"), NULL);
label19 = gtk_label_new (_("\246L\252\355\276\367\252\272\271q\270\243\246W\272\331"));
gtk_widget_ref (label19);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label19", label19,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label19);
gtk_box_pack_start (GTK_BOX (hbox30), label19, FALSE, FALSE, 10);
printer_name = gtk_entry_new ();
gtk_widget_ref (printer_name);
gtk_object_set_data_full (GTK_OBJECT (rs232), "printer_name", printer_name,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (printer_name);
gtk_box_pack_start (GTK_BOX (hbox30), printer_name, TRUE, TRUE, 10);
gtk_widget_set_usize (printer_name, 1, -2);
gtk_tooltips_set_tip (tooltips, printer_name, _("\264N\254O\246b\272\364\270\364\244W\246L\252\355\276\367\252\272\246W\246r\241A\245i\244\243\254O\245L\252\272\241\247\262\243\253~\246W\246r\241\250\263\341"), NULL);
gtk_entry_set_text (GTK_ENTRY (printer_name), _("hp"));
hbox17 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox17);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox17", hbox17,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox17);
gtk_box_pack_start (GTK_BOX (vbox1), hbox17, TRUE, TRUE, 5);
label18 = gtk_label_new (_("\300W\303\320\271\317\245\255\267\306\253\327( X \266b )"));
gtk_widget_ref (label18);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label18", label18,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label18);
gtk_box_pack_start (GTK_BOX (hbox17), label18, FALSE, FALSE, 10);
point = gtk_entry_new ();
gtk_widget_ref (point);
gtk_object_set_data_full (GTK_OBJECT (rs232), "point", point,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (point);
gtk_box_pack_start (GTK_BOX (hbox17), point, TRUE, TRUE, 0);
gtk_widget_set_usize (point, 1, -2);
gtk_tooltips_set_tip (tooltips, point, _("\264N\254O\247A\247\306\261\346 X \266b\257\340\260\367\244\300\246\250\264X\255\323\265\245\244\300\251O\241H"), NULL);
gtk_entry_set_text (GTK_ENTRY (point), _("200"));
save_as_eps = gtk_button_new_with_label (_("eps\241Bps\241Bpdf \300\311\300x\246s\270\364\256|\241A\275\320\245[\244W\260\306\300\311\246W"));
gtk_widget_ref (save_as_eps);
gtk_object_set_data_full (GTK_OBJECT (rs232), "save_as_eps", save_as_eps,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (save_as_eps);
gtk_box_pack_start (GTK_BOX (hbox17), save_as_eps, FALSE, FALSE, 10);
entry4 = gtk_entry_new ();
gtk_widget_ref (entry4);
gtk_object_set_data_full (GTK_OBJECT (rs232), "entry4", entry4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (entry4);
gtk_box_pack_start (GTK_BOX (hbox17), entry4, TRUE, TRUE, 10);
gtk_widget_set_usize (entry4, 1, -2);
gtk_tooltips_set_tip (tooltips, entry4, _("\275\320\260O\261o\244@\251w\261o\247\342\271\317\300\311\252\272\260\306\300\311\246W\246\333\246\346\245[\244J\241C\246p eps ps pdf"), NULL);
gtk_entry_set_text (GTK_ENTRY (entry4), _("/home/allways/spectrum.eps"));
hseparator1 = gtk_hseparator_new ();
gtk_widget_ref (hseparator1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator1", hseparator1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator1);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, TRUE, TRUE, 5);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox9);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox9", hbox9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox9);
gtk_box_pack_start (GTK_BOX (vbox1), hbox9, TRUE, TRUE, 5);
label9 = gtk_label_new (_("\302o\252i\276\271\252\272\300W\303\320\271\317\262\243\245\315\244\350\246\241\241G"));
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label9);
gtk_box_pack_start (GTK_BOX (hbox9), label9, FALSE, FALSE, 5);
specification_on = gtk_radio_button_new_with_label (_1_group, _("\302o\252i\276\271\251\372\262\323\263W\256\346"));
_1_group = gtk_radio_button_group (GTK_RADIO_BUTTON (specification_on));
gtk_widget_ref (specification_on);
gtk_object_set_data_full (GTK_OBJECT (rs232), "specification_on", specification_on,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (specification_on);
gtk_box_pack_start (GTK_BOX (hbox9), specification_on, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, specification_on, _("\247A\245i\245H\246\333\246\346\245\321\302o\252i\276\271\252\272\246U\255\323\260\321\274\306\244@\244@\277\351\244J\247A\255n\252\272\300W\261a\275d\263\362"), NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (specification_on), TRUE);
coefficient_on = gtk_radio_button_new_with_label (_1_group, _("\260\262\263]\244\247\253Y\274\306\261a\244J\302\340\262\276\250\347\246\241"));
_1_group = gtk_radio_button_group (GTK_RADIO_BUTTON (coefficient_on));
gtk_widget_ref (coefficient_on);
gtk_object_set_data_full (GTK_OBJECT (rs232), "coefficient_on", coefficient_on,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (coefficient_on);
gtk_box_pack_start (GTK_BOX (hbox9), coefficient_on, FALSE, FALSE, 5);
gtk_tooltips_set_tip (tooltips, coefficient_on, _("\247A\245i\245H\245\321\265\352\300\300\244@\255\323\302\340\262\276\250\347\274\306\252\272\253Y\274\306\250\323\261o\250\354\247A\255n\252\272\300W\303\320\271\317\241A\265\245\250\354\271\272\245X\250\323\252\272\256\311\255\324\241A\246A\245h\255\327\245\277\247A\252\272\253Y\274\306\241A\244]\254O\244@\272\330\244\350\252k"), NULL);
hseparator3 = gtk_hseparator_new ();
gtk_widget_ref (hseparator3);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator3", hseparator3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator3);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator3, TRUE, TRUE, 5);
hbox6 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox6);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox6", hbox6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox6);
gtk_box_pack_start (GTK_BOX (vbox1), hbox6, TRUE, TRUE, 5);
label11 = gtk_label_new (_("\302o\252i\276\271\251\372\262\323\263W\256\346\241G"));
gtk_widget_ref (label11);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label11", label11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label11);
gtk_box_pack_start (GTK_BOX (hbox6), label11, FALSE, FALSE, 5);
move_average = gtk_radio_button_new_with_label (_2_group, _("FIR\241G\262\276\260\312\245\255\247\241\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (move_average));
gtk_widget_ref (move_average);
gtk_object_set_data_full (GTK_OBJECT (rs232), "move_average", move_average,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (move_average);
gtk_box_pack_start (GTK_BOX (hbox6), move_average, FALSE, FALSE, 0);
window = gtk_radio_button_new_with_label (_2_group, _("FIR\241G\265\370\265\241\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (window));
gtk_widget_ref (window);
gtk_object_set_data_full (GTK_OBJECT (rs232), "window", window,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (window);
gtk_box_pack_start (GTK_BOX (hbox6), window, FALSE, FALSE, 0);
butterworth = gtk_radio_button_new_with_label (_2_group, _("IIR\241G\245\244\252o\255\310\261o\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (butterworth));
gtk_widget_ref (butterworth);
gtk_object_set_data_full (GTK_OBJECT (rs232), "butterworth", butterworth,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (butterworth);
gtk_box_pack_start (GTK_BOX (hbox6), butterworth, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, butterworth, _("\250\344\271\352\264N\254O\244\332\257S\250U\264\376\260\325\241I"), NULL);
chebyshev = gtk_radio_button_new_with_label (_2_group, _("IIR\241G\253\264\244\361\263\267\244\322\302o\252i\276\271"));
_2_group = gtk_radio_button_group (GTK_RADIO_BUTTON (chebyshev));
gtk_widget_ref (chebyshev);
gtk_object_set_data_full (GTK_OBJECT (rs232), "chebyshev", chebyshev,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (chebyshev);
gtk_box_pack_start (GTK_BOX (hbox6), chebyshev, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chebyshev), TRUE);
hbox8 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox8);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox8", hbox8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox8);
gtk_box_pack_start (GTK_BOX (vbox1), hbox8, TRUE, TRUE, 5);
fs_label = gtk_label_new (_("\250\372\274\313\300W\262v"));
gtk_widget_ref (fs_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "fs_label", fs_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fs_label);
gtk_box_pack_start (GTK_BOX (hbox8), fs_label, FALSE, FALSE, 10);
fs = gtk_entry_new ();
gtk_widget_ref (fs);
gtk_object_set_data_full (GTK_OBJECT (rs232), "fs", fs,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fs);
gtk_box_pack_start (GTK_BOX (hbox8), fs, TRUE, TRUE, 0);
gtk_widget_set_usize (fs, 1, -2);
gtk_tooltips_set_tip (tooltips, fs, _("\263\346\246\354\254\260\273\256\257\367"), NULL);
gtk_entry_set_text (GTK_ENTRY (fs), _("20000"));
pass_edge_label = gtk_label_new (_("\263q\261a\272I\244\356\300W\262v"));
gtk_widget_ref (pass_edge_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_edge_label", pass_edge_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_edge_label);
gtk_box_pack_start (GTK_BOX (hbox8), pass_edge_label, FALSE, FALSE, 10);
pass_edge = gtk_entry_new ();
gtk_widget_ref (pass_edge);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_edge", pass_edge,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_edge);
gtk_box_pack_start (GTK_BOX (hbox8), pass_edge, TRUE, TRUE, 0);
gtk_widget_set_usize (pass_edge, 1, -2);
gtk_tooltips_set_tip (tooltips, pass_edge, _("\263\346\246\354\254\260\273\256\257\367"), NULL);
gtk_entry_set_text (GTK_ENTRY (pass_edge), _("5000"));
stop_edge_label = gtk_label_new (_("\244\356\261a\272I\244\356\300W\262v"));
gtk_widget_ref (stop_edge_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_edge_label", stop_edge_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_edge_label);
gtk_box_pack_start (GTK_BOX (hbox8), stop_edge_label, FALSE, FALSE, 10);
stop_edge = gtk_entry_new ();
gtk_widget_ref (stop_edge);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_edge", stop_edge,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_edge);
gtk_box_pack_start (GTK_BOX (hbox8), stop_edge, TRUE, TRUE, 0);
gtk_widget_set_usize (stop_edge, 1, -2);
gtk_tooltips_set_tip (tooltips, stop_edge, _("\263\346\246\354\254\260\273\256\257\367"), NULL);
gtk_entry_set_text (GTK_ENTRY (stop_edge), _("7500"));
pass_ripple_label = gtk_label_new (_("\263q\261a\272\247\252i"));
gtk_widget_ref (pass_ripple_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_ripple_label", pass_ripple_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_ripple_label);
gtk_box_pack_start (GTK_BOX (hbox8), pass_ripple_label, FALSE, FALSE, 10);
pass_ripple = gtk_entry_new ();
gtk_widget_ref (pass_ripple);
gtk_object_set_data_full (GTK_OBJECT (rs232), "pass_ripple", pass_ripple,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (pass_ripple);
gtk_box_pack_start (GTK_BOX (hbox8), pass_ripple, TRUE, TRUE, 0);
gtk_widget_set_usize (pass_ripple, 1, -2);
gtk_tooltips_set_tip (tooltips, pass_ripple, _("\263\346\246\354\254\260\244\300\250\251\274W\257q"), NULL);
gtk_entry_set_text (GTK_ENTRY (pass_ripple), _("1"));
stop_ripple_label = gtk_label_new (_("\244\356\261a\272\247\252i"));
gtk_widget_ref (stop_ripple_label);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_ripple_label", stop_ripple_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_ripple_label);
gtk_box_pack_start (GTK_BOX (hbox8), stop_ripple_label, FALSE, FALSE, 10);
stop_ripple = gtk_entry_new ();
gtk_widget_ref (stop_ripple);
gtk_object_set_data_full (GTK_OBJECT (rs232), "stop_ripple", stop_ripple,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (stop_ripple);
gtk_box_pack_start (GTK_BOX (hbox8), stop_ripple, TRUE, TRUE, 10);
gtk_widget_set_usize (stop_ripple, 1, -2);
gtk_tooltips_set_tip (tooltips, stop_ripple, _("\263\346\246\354\254\260\244\300\250\251\274W\257q"), NULL);
gtk_entry_set_text (GTK_ENTRY (stop_ripple), _("32"));
hseparator2 = gtk_hseparator_new ();
gtk_widget_ref (hseparator2);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hseparator2", hseparator2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hseparator2);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator2, TRUE, TRUE, 5);
hbox10 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox10);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox10", hbox10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox10);
gtk_box_pack_start (GTK_BOX (vbox1), hbox10, TRUE, TRUE, 5);
label12 = gtk_label_new (_("\260\262\263]\244\247\253Y\274\306\261a\244J\302\340\262\276\250\347\246\241\241G"));
gtk_widget_ref (label12);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label12", label12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label12);
gtk_box_pack_start (GTK_BOX (hbox10), label12, FALSE, FALSE, 5);
fir_input_coefficient = gtk_radio_button_new_with_label (_3_group, _("\246\263\255\255\257\337\275\304 FIR \302o\252i\276\271"));
_3_group = gtk_radio_button_group (GTK_RADIO_BUTTON (fir_input_coefficient));
gtk_widget_ref (fir_input_coefficient);
gtk_object_set_data_full (GTK_OBJECT (rs232), "fir_input_coefficient", fir_input_coefficient,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (fir_input_coefficient);
gtk_box_pack_start (GTK_BOX (hbox10), fir_input_coefficient, FALSE, FALSE, 10);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fir_input_coefficient), TRUE);
iir_input_coefficient = gtk_radio_button_new_with_label (_3_group, _("\265L\255\255\257\337\275\304 IIR \302o\252i\276\271"));
_3_group = gtk_radio_button_group (GTK_RADIO_BUTTON (iir_input_coefficient));
gtk_widget_ref (iir_input_coefficient);
gtk_object_set_data_full (GTK_OBJECT (rs232), "iir_input_coefficient", iir_input_coefficient,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (iir_input_coefficient);
gtk_box_pack_start (GTK_BOX (hbox10), iir_input_coefficient, FALSE, FALSE, 10);
identify_stability = gtk_button_new_with_label (_("IIR \302o\252i\276\271\303\255\251w\253\327\305\262\251w(\245\274\247\271\246\250)"));
gtk_widget_ref (identify_stability);
gtk_object_set_data_full (GTK_OBJECT (rs232), "identify_stability", identify_stability,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (identify_stability);
gtk_box_pack_start (GTK_BOX (hbox10), identify_stability, FALSE, FALSE, 10);
gtk_tooltips_set_tip (tooltips, identify_stability, _("\246]\254\260\247A\252\272\302\340\262\276\250\347\274\306\254O\260\262\263]\252\272\255\310\241A\251\322\245H\303\255\244\243\303\255\251w\247A\244]\244\243\275T\251w\241A\246\271\266s\245i\245H\247P\302_\244@\244U\241A\246]\254\260 FIR \244@\251w\254O\303\255\251w\252\272\241A\251\322\245H\244\243\245\316\264\372\244F\241C"), NULL);
hbox14 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox14);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox14", hbox14,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox14);
gtk_box_pack_start (GTK_BOX (vbox1), hbox14, TRUE, TRUE, 5);
label16 = gtk_label_new (_("\302\340\262\276\250\347\274\306\244\300\245\300 Y( n ) "));
gtk_widget_ref (label16);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label16", label16,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label16);
gtk_box_pack_start (GTK_BOX (hbox14), label16, FALSE, FALSE, 10);
a_value = gtk_entry_new ();
gtk_widget_ref (a_value);
gtk_object_set_data_full (GTK_OBJECT (rs232), "a_value", a_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (a_value);
gtk_box_pack_start (GTK_BOX (hbox14), a_value, TRUE, TRUE, 10);
gtk_widget_set_usize (a_value, 1, -2);
gtk_tooltips_set_tip (tooltips, a_value, _("\264N\254O\302\340\262\276\250\347\274\306\244\244\252\272\244\300\245\300\263\241\245\367\241A\267\355\265M\263o\245u\246\263 IIR \244~\267|\246\263\252\272"), NULL);
gtk_entry_set_text (GTK_ENTRY (a_value), _("1 -0.7757"));
label17 = gtk_label_new (_("\302\340\262\276\250\347\274\306\244\300\244l X( n )"));
gtk_widget_ref (label17);
gtk_object_set_data_full (GTK_OBJECT (rs232), "label17", label17,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label17);
gtk_box_pack_start (GTK_BOX (hbox14), label17, FALSE, FALSE, 10);
b_value = gtk_entry_new ();
gtk_widget_ref (b_value);
gtk_object_set_data_full (GTK_OBJECT (rs232), "b_value", b_value,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (b_value);
gtk_box_pack_start (GTK_BOX (hbox14), b_value, TRUE, TRUE, 10);
gtk_widget_set_usize (b_value, 1, -2);
gtk_entry_set_text (GTK_ENTRY (b_value), _("4.7 2.2 3.6 2.2 4.7"));
appbar1 = gnome_appbar_new (TRUE, TRUE, GNOME_PREFERENCES_NEVER);
gtk_widget_ref (appbar1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "appbar1", appbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (appbar1);
gtk_box_pack_start (GTK_BOX (vbox1), appbar1, TRUE, TRUE, 0);
hbox28 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox28);
gtk_object_set_data_full (GTK_OBJECT (rs232), "hbox28", hbox28,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox28);
gtk_box_pack_start (GTK_BOX (vbox1), hbox28, TRUE, TRUE, 0);
statusbar1 = gtk_statusbar_new ();
gtk_widget_ref (statusbar1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "statusbar1", statusbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (statusbar1);
gtk_box_pack_start (GTK_BOX (hbox28), statusbar1, FALSE, FALSE, 0);
gtk_widget_set_usize (statusbar1, 629, -2);
progressbar1 = gtk_progress_bar_new ();
gtk_widget_ref (progressbar1);
gtk_object_set_data_full (GTK_OBJECT (rs232), "progressbar1", progressbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (progressbar1);
gtk_box_pack_start (GTK_BOX (hbox28), progressbar1, FALSE, FALSE, 0);
gtk_progress_set_show_text (GTK_PROGRESS (progressbar1), TRUE);
gtk_progress_set_format_string (GTK_PROGRESS (progressbar1), _("%P %% \247\271\246\250"));
gtk_signal_connect (GTK_OBJECT (rs232), "delete_event",
GTK_SIGNAL_FUNC (on_rs232_delete_event),
NULL);
gtk_signal_connect (GTK_OBJECT (rs232), "show",
GTK_SIGNAL_FUNC (on_rs232_show),
NULL);
gtk_signal_connect (GTK_OBJECT (exit), "clicked",
GTK_SIGNAL_FUNC (on_exit_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (swap), "clicked",
GTK_SIGNAL_FUNC (on_swap_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (clean_data_area), "clicked",
GTK_SIGNAL_FUNC (on_clean_data_area_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (combo_entry_baudrate), "changed",
GTK_SIGNAL_FUNC (on_combo_entry_baudrate_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (combo_entry_port), "changed",
GTK_SIGNAL_FUNC (on_combo_entry_port_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (save_as_numeral), "clicked",
GTK_SIGNAL_FUNC (on_save_as_numeral_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (spectrum), "clicked",
GTK_SIGNAL_FUNC (on_spectrum_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (inspect), "clicked",
GTK_SIGNAL_FUNC (on_inspect_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (print_spectrum), "toggled",
GTK_SIGNAL_FUNC (on_print_spectrum_toggled),
NULL);
gtk_signal_connect (GTK_OBJECT (save_as_eps), "clicked",
GTK_SIGNAL_FUNC (on_save_as_eps_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (specification_on), "clicked",
GTK_SIGNAL_FUNC (on_specification_on_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (coefficient_on), "clicked",
GTK_SIGNAL_FUNC (on_coefficient_on_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (move_average), "clicked",
GTK_SIGNAL_FUNC (on_move_average_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (window), "clicked",
GTK_SIGNAL_FUNC (on_window_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (butterworth), "clicked",
GTK_SIGNAL_FUNC (on_butterworth_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (chebyshev), "clicked",
GTK_SIGNAL_FUNC (on_chebyshev_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (fir_input_coefficient), "clicked",
GTK_SIGNAL_FUNC (on_fir_input_coefficient_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (iir_input_coefficient), "clicked",
GTK_SIGNAL_FUNC (on_iir_input_coefficient_clicked),
NULL);
gtk_object_set_data (GTK_OBJECT (rs232), "tooltips", tooltips);
gtk_window_add_accel_group (GTK_WINDOW (rs232), accel_group);
return rs232;
}
/**
* stm_transfer_window_init_ui:
*
* Initialize user interface
*/
static void
stm_transfer_window_init_ui (StmTransferWindow *self)
{
StmTransferWindowPrivate *priv = self->priv;
GtkWidget *table = gtk_table_new (6, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
GtkWidget *label;
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Source:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Destination:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 1, 2,
GTK_FILL, GTK_SHRINK, 0, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Status:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 2, 3,
GTK_FILL, GTK_SHRINK, 0, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Total time:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 3, 4,
GTK_FILL, GTK_SHRINK, 0, 0);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Time remaining:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 4, 5,
GTK_FILL, GTK_SHRINK, 0, 0);
#ifdef HAVE_CRYPTO
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>MD5 Checksum:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 5, 6,
GTK_FILL, GTK_SHRINK, 0, 0);
#endif
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), _("<b>Progress:</b>"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 6, 7,
GTK_FILL, GTK_SHRINK, 0, 0);
/* Right column */
label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->source = label;
label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->destination = label;
label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->status = label;
label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 3, 4,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->time1 = label;
label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 4, 5,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->time2 = label;
#ifdef HAVE_CRYPTO
label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label,
1, 2, 5, 6,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->md5 = label;
#endif
GtkWidget *progress;
progress = gtk_progress_bar_new ();
gtk_table_attach (GTK_TABLE (table), progress,
1, 2, 6, 7,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
priv->progress = progress;
gtk_widget_show_all (table);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (self)->vbox), table,
FALSE, FALSE, 0);
/* Buttons */
GtkWidget *close = gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE);
g_signal_connect (G_OBJECT (close), "clicked",
G_CALLBACK (stm_transfer_window_close_clicked), self);
}
int
create_nasa_mapfile (double lat, double lon, int test, char *fn)
{
/* lat,lon= koordinates */
/* test= test if maps are present */
/* fn = filename of the generated file */
int fdout, uc = 0;
int scale, e, xsize_e, xsize_w;
int xstart, ystart, y, x_w, x_e;
double mylon;
GtkWidget *myprogress, *text, *vbox;
char textbuf[40];
char *basename;
if (!havenasamaps)
return -1;
scale = 2614061;
mylon = lon;
g_strlcpy (fn, "nofile.sorry", 255);
/* return if no map found */
if (lon > 0)
{
xstart = (int) (21600.0 * (lon / 180.0));
if (((xstart < 1280) || (xstart > 20320)) && (fdin_w < 0))
return -1;
if (fdin_e < 0)
return -1;
}
else
{
lon = 180.0 + lon;
xstart = (int) (21600.0 * (lon / 180.0));
if (((xstart < 1280) || (xstart > 20320)) && (fdin_e < 0))
return -1;
if (fdin_w < 0)
return -1;
}
if (!test)
{
fdout = open (outfilename, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 0644);
if (fdout < 0)
{
fprintf (stderr,
_("Could not create output map file \"%s\"!\n"),
outfilename);
return -1;
}
nasawindow = gtk_window_new (GTK_WINDOW_POPUP);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (nasawindow), vbox);
gtk_window_set_position (GTK_WINDOW (nasawindow),
GTK_WIN_POS_CENTER);
/* g_signal_connect (window, "destroy", */
/* G_CALLBACK (gtk_widget_destroyed), &window); */
gtk_window_set_title (GTK_WINDOW (nasawindow),
_("Creating map..."));
gtk_container_set_border_width (GTK_CONTAINER (nasawindow), 20);
myprogress = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (myprogress), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), myprogress, TRUE, TRUE, 2);
text = gtk_label_new (
_("Creating a temporary map from NASA satellite images"));
gtk_box_pack_start (GTK_BOX (vbox), text, TRUE, TRUE, 2);
/* gtk_widget_show_all (nasawindow); */
gtk_widget_show_all (nasawindow);
if (debug)
fprintf (stdout,
_("Converting map for latitude: %f and longitude: %f ...\n"),
lat, lon);
/* if (lon < 0.0) */
/* lon = 180.0 + lon; */
g_strlcpy (fn, "top_NASA_IMAGE.ppm", 255);
g_snprintf (mybuffer, sizeof (mybuffer),
"P6\n# CREATOR: GpsDrive\n1280 1024\n255\n");
e = write (fdout, mybuffer, strlen (mybuffer));
uc = e;
lon = mylon;
xstart = (int) (21600.0 * (lon / 180.0));
ystart = 3 * 21600 * (int) (10800 - 10800.0 * (lat / 90.0));
/* fprintf (stdout, "xstart: %d, ystart: %d\n", xstart, ystart); */
xstart -= 640;
ystart = ystart - 512 * 21600 * 3;
x_w = x_e = -1;
xsize_w = xsize_e = 1280;
if (xstart < 0)
{
x_w = 21600 + xstart;
x_e = 1280 - x_w;
if (x_e < -20320)
x_e = -1;
else if (x_e < 0)
x_e = 0;
if (x_w < -20320)
x_w = -1;
else if (x_w < 0)
x_w = 0;
xsize_w = 21600 - x_w;
xsize_e = 1280 - xsize_w;
}
else if (xstart > 20320)
{
x_w = (xstart + 1280) - 21600;
x_e = 1280 - x_w;
if (x_e < 20320)
x_e = -1;
if (x_e < 0)
x_e = 0;
xsize_w = x_w;
xsize_e = 1280 - xsize_w;
}
else
{
if (mylon >= 0.0)
x_e = xstart;
else
x_w = xstart;
}
if (xsize_w > 1280)
xsize_w = 1280;
if (xsize_e > 1280)
xsize_e = 1280;
x_w *= 3;
x_e *= 3;
for (y = 0; y < 1024; y++)
{
if ((y % 32) == 0)
{
gtk_progress_bar_set_fraction
(GTK_PROGRESS_BAR (myprogress),
y / 1024.0);
g_snprintf (textbuf, sizeof (textbuf), "%d%%",
(int) (100.0 * y / 1024));
gtk_progress_bar_set_text (GTK_PROGRESS_BAR
(myprogress),
textbuf);
while (gtk_events_pending ())
gtk_main_iteration ();
}
if (x_w != -3)
{
e = lseek (fdin_w,
x_w + ystart + y * 21600 * 3,
SEEK_SET);
e = read (fdin_w, mybuffer, xsize_w * 3);
e = write (fdout, mybuffer, xsize_w * 3);
uc += e;
}
if (x_e != -3)
{
e = lseek (fdin_e,
x_e + ystart + y * 21600 * 3,
SEEK_SET);
e = read (fdin_e, mybuffer, xsize_e * 3);
e = write (fdout, mybuffer, xsize_e * 3);
uc += e;
}
}
/* fprintf (stderr, "wrote %d bytes (%.1f MB) to mapfile\n", uc, */
/* uc / (1024.0 * 1024.0)); */
gtk_widget_destroy (GTK_WIDGET (nasawindow));
close (fdout);
basename = g_path_get_basename(outfilename);
g_strlcpy (mybuffer, basename, sizeof (mybuffer));
g_free(basename);
fprintf (stdout,
_("\nYou can permanently add this map file with following "
"line in your\n"
"map_koord.txt (rename the file!):\n"));
fprintf (stdout, "\n%s %f %f %d\n", mybuffer, lat, lon, scale);
} /* End of if !test */
return scale;
}
GtkWidget*
create_main_window (void)
{
GtkWidget *main_window;
GdkPixbuf *main_window_icon_pixbuf;
GtkWidget *hbox12;
GtkWidget *vbox30;
GtkWidget *expander1;
GtkWidget *hbox6;
GtkWidget *label11;
GtkWidget *vbox5;
GtkWidget *hbox7;
GtkWidget *label12;
GtkWidget *hbox9;
GtkWidget *server;
GtkWidget *connect;
GtkWidget *alignment7;
GtkWidget *hbox11;
GtkWidget *image7;
GtkWidget *label18;
GtkWidget *login_at_connect;
GtkWidget *hbox8;
GtkWidget *label14;
GtkWidget *table1;
GtkWidget *label13;
GtkWidget *label15;
GtkWidget *login;
GtkWidget *password;
GtkWidget *label17;
GtkWidget *label10;
GtkWidget *hbox1;
GtkWidget *frame1;
GtkWidget *alignment3;
GtkWidget *console_tabs;
GtkWidget *alignment4;
GtkWidget *vbox1;
GtkWidget *console_scroll;
GtkWidget *console_view;
GtkWidget *label4;
GtkWidget *hbox2;
GtkWidget *image1;
GtkWidget *cmd_entry;
GtkWidget *btn_cmdSend;
GtkWidget *label6;
GtkWidget *alignment5;
GtkWidget *pipe_scroll;
GtkWidget *pipe_view;
GtkWidget *label7;
GtkWidget *label2;
GtkWidget *vbox2;
GtkWidget *frame2;
GtkWidget *alignment2;
GtkWidget *vbox3;
GtkWidget *ctrlButton_0;
GtkWidget *ctrlButton_1;
GtkWidget *ctrlButton_2;
GtkWidget *ctrlButton_3;
GtkWidget *alignment6;
GtkWidget *hbox3;
GtkWidget *image2;
GtkWidget *hbox4;
GtkWidget *queue_progress;
GtkWidget *queue_usage;
GtkWidget *label9;
GtkWidget *image3;
GtkWidget *hbox5;
GtkWidget *belts_progress;
GtkWidget *belts_usage;
GtkWidget *ctrlButton_4;
GtkWidget *ctrlButton_5;
GtkWidget *ctrlButton_6;
GtkWidget *label5;
GtkWidget *label3;
GtkWidget *label8;
GtkWidget *image6;
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (main_window), _("WebTester Server Console"));
gtk_window_set_resizable (GTK_WINDOW (main_window), FALSE);
main_window_icon_pixbuf = create_pixbuf ("wt32.png");
if (main_window_icon_pixbuf)
{
gtk_window_set_icon (GTK_WINDOW (main_window), main_window_icon_pixbuf);
gdk_pixbuf_unref (main_window_icon_pixbuf);
}
hbox12 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox12);
gtk_container_add (GTK_CONTAINER (main_window), hbox12);
vbox30 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox30);
gtk_box_pack_start (GTK_BOX (hbox12), vbox30, TRUE, TRUE, 0);
expander1 = gtk_expander_new (NULL);
gtk_widget_show (expander1);
gtk_box_pack_start (GTK_BOX (vbox30), expander1, FALSE, TRUE, 0);
gtk_widget_set_size_request (expander1, 640, -1);
gtk_expander_set_expanded (GTK_EXPANDER (expander1), TRUE);
hbox6 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox6);
gtk_container_add (GTK_CONTAINER (expander1), hbox6);
label11 = gtk_label_new ("");
gtk_widget_show (label11);
gtk_box_pack_start (GTK_BOX (hbox6), label11, FALSE, FALSE, 0);
gtk_widget_set_size_request (label11, 16, -1);
vbox5 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox5);
gtk_box_pack_start (GTK_BOX (hbox6), vbox5, FALSE, TRUE, 0);
hbox7 = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox7);
gtk_box_pack_start (GTK_BOX (vbox5), hbox7, TRUE, TRUE, 0);
label12 = gtk_label_new (_("Server:Port"));
gtk_widget_show (label12);
gtk_box_pack_start (GTK_BOX (hbox7), label12, FALSE, FALSE, 0);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox9);
gtk_box_pack_start (GTK_BOX (hbox7), hbox9, TRUE, TRUE, 0);
server = gtk_entry_new ();
gtk_widget_show (server);
gtk_box_pack_start (GTK_BOX (hbox9), server, TRUE, TRUE, 0);
connect = gtk_toggle_button_new ();
gtk_widget_show (connect);
gtk_box_pack_start (GTK_BOX (hbox9), connect, FALSE, FALSE, 0);
alignment7 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment7);
gtk_container_add (GTK_CONTAINER (connect), alignment7);
hbox11 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox11);
gtk_container_add (GTK_CONTAINER (alignment7), hbox11);
image7 = create_pixmap (main_window, "connect.png");
gtk_widget_show (image7);
gtk_box_pack_start (GTK_BOX (hbox11), image7, FALSE, FALSE, 0);
label18 = gtk_label_new (_("Connect"));
gtk_widget_show (label18);
gtk_box_pack_start (GTK_BOX (hbox11), label18, FALSE, FALSE, 0);
login_at_connect = gtk_check_button_new_with_mnemonic (_("Login at connect"));
gtk_widget_show (login_at_connect);
gtk_box_pack_start (GTK_BOX (vbox5), login_at_connect, FALSE, FALSE, 0);
hbox8 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox8);
gtk_box_pack_start (GTK_BOX (hbox6), hbox8, TRUE, TRUE, 0);
label14 = gtk_label_new ("");
gtk_widget_show (label14);
gtk_box_pack_start (GTK_BOX (hbox8), label14, FALSE, FALSE, 0);
gtk_widget_set_size_request (label14, 8, -1);
table1 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (hbox8), table1, TRUE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table1), 4);
label13 = gtk_label_new (_("Login"));
gtk_widget_show (label13);
gtk_table_attach (GTK_TABLE (table1), label13, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5);
label15 = gtk_label_new (_("Password"));
gtk_widget_show (label15);
gtk_table_attach (GTK_TABLE (table1), label15, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5);
login = gtk_entry_new ();
gtk_widget_show (login);
gtk_table_attach (GTK_TABLE (table1), login, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_sensitive (login, FALSE);
password = gtk_entry_new ();
gtk_widget_show (password);
gtk_table_attach (GTK_TABLE (table1), password, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_sensitive (password, FALSE);
gtk_entry_set_visibility (GTK_ENTRY (password), FALSE);
label17 = gtk_label_new ("");
gtk_widget_show (label17);
gtk_box_pack_start (GTK_BOX (hbox8), label17, FALSE, FALSE, 0);
gtk_widget_set_size_request (label17, 8, -1);
label10 = gtk_label_new (_("Connection"));
gtk_widget_show (label10);
gtk_expander_set_label_widget (GTK_EXPANDER (expander1), label10);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox30), hbox1, TRUE, TRUE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0);
gtk_frame_set_label_align (GTK_FRAME (frame1), 0.5, 0.5);
alignment3 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment3);
gtk_container_add (GTK_CONTAINER (frame1), alignment3);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment3), 2, 4, 4, 4);
console_tabs = gtk_notebook_new ();
gtk_widget_show (console_tabs);
gtk_container_add (GTK_CONTAINER (alignment3), console_tabs);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (console_tabs), alignment4);
gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (console_tabs), alignment4,
TRUE, TRUE, GTK_PACK_START);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 2, 2, 2, 2);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (alignment4), vbox1);
console_scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (console_scroll);
gtk_box_pack_start (GTK_BOX (vbox1), console_scroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (console_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (console_scroll), GTK_SHADOW_IN);
console_view = gtk_text_view_new ();
gtk_widget_show (console_view);
gtk_container_add (GTK_CONTAINER (console_scroll), console_view);
gtk_text_view_set_editable (GTK_TEXT_VIEW (console_view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (console_view), GTK_WRAP_CHAR);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (console_view), 4);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (console_view), 4);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (console_view), 4);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (console_view), 4);
label4 = gtk_label_new ("");
gtk_widget_show (label4);
gtk_box_pack_start (GTK_BOX (vbox1), label4, FALSE, FALSE, 0);
gtk_widget_set_size_request (label4, 360, 3);
hbox2 = gtk_hbox_new (FALSE, 4);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, TRUE, 0);
image1 = create_pixmap (main_window, "go.png");
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox2), image1, FALSE, TRUE, 0);
cmd_entry = gtk_entry_new ();
gtk_widget_show (cmd_entry);
gtk_box_pack_start (GTK_BOX (hbox2), cmd_entry, TRUE, TRUE, 0);
btn_cmdSend = gtk_button_new_with_mnemonic (_("Send"));
gtk_widget_show (btn_cmdSend);
gtk_box_pack_start (GTK_BOX (hbox2), btn_cmdSend, FALSE, FALSE, 0);
label6 = gtk_label_new (_("User's console"));
gtk_widget_show (label6);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (console_tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (console_tabs), 0), label6);
alignment5 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment5);
gtk_container_add (GTK_CONTAINER (console_tabs), alignment5);
gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (console_tabs), alignment5,
TRUE, TRUE, GTK_PACK_START);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment5), 2, 2, 2, 2);
pipe_scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (pipe_scroll);
gtk_container_add (GTK_CONTAINER (alignment5), pipe_scroll);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pipe_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (pipe_scroll), GTK_SHADOW_IN);
pipe_view = gtk_text_view_new ();
gtk_widget_show (pipe_view);
gtk_container_add (GTK_CONTAINER (pipe_scroll), pipe_view);
gtk_text_view_set_editable (GTK_TEXT_VIEW (pipe_view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (pipe_view), GTK_WRAP_CHAR);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (pipe_view), 4);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (pipe_view), 4);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (pipe_view), 4);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (pipe_view), 4);
label7 = gtk_label_new (_("Pipe"));
gtk_widget_show (label7);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (console_tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (console_tabs), 1), label7);
gtk_label_set_line_wrap (GTK_LABEL (label7), TRUE);
label2 = gtk_label_new (_("<b>WebTester</b> Console"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, TRUE, 0);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (vbox2), frame2, TRUE, TRUE, 0);
gtk_frame_set_label_align (GTK_FRAME (frame2), 0.5, 0.5);
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (frame2), alignment2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 2, 4, 4, 4);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
gtk_container_add (GTK_CONTAINER (alignment2), vbox3);
ctrlButton_0 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_0);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_0, FALSE, FALSE, 0);
ctrlButton_1 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_1);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_1, FALSE, FALSE, 0);
ctrlButton_2 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_2);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_2, FALSE, FALSE, 0);
ctrlButton_3 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_3);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_3, FALSE, FALSE, 0);
alignment6 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment6);
gtk_box_pack_start (GTK_BOX (vbox3), alignment6, FALSE, FALSE, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment6), 2, 2, 0, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_container_add (GTK_CONTAINER (alignment6), hbox3);
image2 = create_pixmap (main_window, "queue.png");
gtk_widget_show (image2);
gtk_box_pack_start (GTK_BOX (hbox3), image2, FALSE, TRUE, 0);
hbox4 = gtk_hbox_new (FALSE, 1);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (hbox3), hbox4, FALSE, TRUE, 0);
queue_progress = gtk_progress_bar_new ();
gtk_widget_show (queue_progress);
gtk_box_pack_start (GTK_BOX (hbox4), queue_progress, FALSE, FALSE, 0);
gtk_widget_set_size_request (queue_progress, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (queue_progress), GTK_PROGRESS_BOTTOM_TO_TOP);
queue_usage = gtk_progress_bar_new ();
gtk_widget_show (queue_usage);
gtk_box_pack_start (GTK_BOX (hbox4), queue_usage, FALSE, FALSE, 0);
gtk_widget_set_size_request (queue_usage, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (queue_usage), GTK_PROGRESS_BOTTOM_TO_TOP);
label9 = gtk_label_new ("");
gtk_widget_show (label9);
gtk_box_pack_start (GTK_BOX (hbox3), label9, FALSE, FALSE, 0);
gtk_widget_set_size_request (label9, 6, -1);
image3 = create_pixmap (main_window, "belts.png");
gtk_widget_show (image3);
gtk_box_pack_start (GTK_BOX (hbox3), image3, FALSE, FALSE, 0);
hbox5 = gtk_hbox_new (FALSE, 1);
gtk_widget_show (hbox5);
gtk_box_pack_start (GTK_BOX (hbox3), hbox5, FALSE, FALSE, 0);
belts_progress = gtk_progress_bar_new ();
gtk_widget_show (belts_progress);
gtk_box_pack_start (GTK_BOX (hbox5), belts_progress, FALSE, FALSE, 0);
gtk_widget_set_size_request (belts_progress, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (belts_progress), GTK_PROGRESS_BOTTOM_TO_TOP);
belts_usage = gtk_progress_bar_new ();
gtk_widget_show (belts_usage);
gtk_box_pack_start (GTK_BOX (hbox5), belts_usage, FALSE, FALSE, 0);
gtk_widget_set_size_request (belts_usage, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (belts_usage), GTK_PROGRESS_BOTTOM_TO_TOP);
ctrlButton_4 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_4);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_4, FALSE, FALSE, 0);
ctrlButton_5 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_5);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_5, FALSE, FALSE, 0);
ctrlButton_6 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_6);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_6, FALSE, FALSE, 0);
label5 = gtk_label_new ("");
gtk_widget_show (label5);
gtk_box_pack_start (GTK_BOX (vbox3), label5, TRUE, FALSE, 0);
label3 = gtk_label_new (_("Control"));
gtk_widget_show (label3);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label3);
gtk_label_set_use_markup (GTK_LABEL (label3), TRUE);
label8 = gtk_label_new (_("2007 (c) nazgul"));
gtk_widget_show (label8);
gtk_box_pack_start (GTK_BOX (vbox2), label8, FALSE, FALSE, 0);
image6 = create_pixmap (main_window, "wt.png");
gtk_widget_show (image6);
gtk_box_pack_start (GTK_BOX (hbox12), image6, TRUE, TRUE, 0);
g_signal_connect ((gpointer) main_window, "remove",
G_CALLBACK (on_main_window_remove),
NULL);
g_signal_connect ((gpointer) connect, "toggled",
G_CALLBACK (on_connect_toggled),
NULL);
g_signal_connect ((gpointer) login_at_connect, "toggled",
G_CALLBACK (on_login_at_connect_toggled),
NULL);
g_signal_connect ((gpointer) cmd_entry, "key_press_event",
G_CALLBACK (on_cmd_entry_key_press_event),
NULL);
g_signal_connect ((gpointer) btn_cmdSend, "clicked",
G_CALLBACK (on_btn_cmdSend_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_0, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_1, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_2, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_3, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_4, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_5, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_6, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (main_window, main_window, "main_window");
GLADE_HOOKUP_OBJECT (main_window, hbox12, "hbox12");
GLADE_HOOKUP_OBJECT (main_window, vbox30, "vbox30");
GLADE_HOOKUP_OBJECT (main_window, expander1, "expander1");
GLADE_HOOKUP_OBJECT (main_window, hbox6, "hbox6");
GLADE_HOOKUP_OBJECT (main_window, label11, "label11");
GLADE_HOOKUP_OBJECT (main_window, vbox5, "vbox5");
GLADE_HOOKUP_OBJECT (main_window, hbox7, "hbox7");
GLADE_HOOKUP_OBJECT (main_window, label12, "label12");
GLADE_HOOKUP_OBJECT (main_window, hbox9, "hbox9");
GLADE_HOOKUP_OBJECT (main_window, server, "server");
GLADE_HOOKUP_OBJECT (main_window, connect, "connect");
GLADE_HOOKUP_OBJECT (main_window, alignment7, "alignment7");
GLADE_HOOKUP_OBJECT (main_window, hbox11, "hbox11");
GLADE_HOOKUP_OBJECT (main_window, image7, "image7");
GLADE_HOOKUP_OBJECT (main_window, label18, "label18");
GLADE_HOOKUP_OBJECT (main_window, login_at_connect, "login_at_connect");
GLADE_HOOKUP_OBJECT (main_window, hbox8, "hbox8");
GLADE_HOOKUP_OBJECT (main_window, label14, "label14");
GLADE_HOOKUP_OBJECT (main_window, table1, "table1");
GLADE_HOOKUP_OBJECT (main_window, label13, "label13");
GLADE_HOOKUP_OBJECT (main_window, label15, "label15");
GLADE_HOOKUP_OBJECT (main_window, login, "login");
GLADE_HOOKUP_OBJECT (main_window, password, "password");
GLADE_HOOKUP_OBJECT (main_window, label17, "label17");
GLADE_HOOKUP_OBJECT (main_window, label10, "label10");
GLADE_HOOKUP_OBJECT (main_window, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (main_window, frame1, "frame1");
GLADE_HOOKUP_OBJECT (main_window, alignment3, "alignment3");
GLADE_HOOKUP_OBJECT (main_window, console_tabs, "console_tabs");
GLADE_HOOKUP_OBJECT (main_window, alignment4, "alignment4");
GLADE_HOOKUP_OBJECT (main_window, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (main_window, console_scroll, "console_scroll");
GLADE_HOOKUP_OBJECT (main_window, console_view, "console_view");
GLADE_HOOKUP_OBJECT (main_window, label4, "label4");
GLADE_HOOKUP_OBJECT (main_window, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (main_window, image1, "image1");
GLADE_HOOKUP_OBJECT (main_window, cmd_entry, "cmd_entry");
GLADE_HOOKUP_OBJECT (main_window, btn_cmdSend, "btn_cmdSend");
GLADE_HOOKUP_OBJECT (main_window, label6, "label6");
GLADE_HOOKUP_OBJECT (main_window, alignment5, "alignment5");
GLADE_HOOKUP_OBJECT (main_window, pipe_scroll, "pipe_scroll");
GLADE_HOOKUP_OBJECT (main_window, pipe_view, "pipe_view");
GLADE_HOOKUP_OBJECT (main_window, label7, "label7");
GLADE_HOOKUP_OBJECT (main_window, label2, "label2");
GLADE_HOOKUP_OBJECT (main_window, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (main_window, frame2, "frame2");
GLADE_HOOKUP_OBJECT (main_window, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (main_window, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_0, "ctrlButton_0");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_1, "ctrlButton_1");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_2, "ctrlButton_2");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_3, "ctrlButton_3");
GLADE_HOOKUP_OBJECT (main_window, alignment6, "alignment6");
GLADE_HOOKUP_OBJECT (main_window, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (main_window, image2, "image2");
GLADE_HOOKUP_OBJECT (main_window, hbox4, "hbox4");
GLADE_HOOKUP_OBJECT (main_window, queue_progress, "queue_progress");
GLADE_HOOKUP_OBJECT (main_window, queue_usage, "queue_usage");
GLADE_HOOKUP_OBJECT (main_window, label9, "label9");
GLADE_HOOKUP_OBJECT (main_window, image3, "image3");
GLADE_HOOKUP_OBJECT (main_window, hbox5, "hbox5");
GLADE_HOOKUP_OBJECT (main_window, belts_progress, "belts_progress");
GLADE_HOOKUP_OBJECT (main_window, belts_usage, "belts_usage");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_4, "ctrlButton_4");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_5, "ctrlButton_5");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_6, "ctrlButton_6");
GLADE_HOOKUP_OBJECT (main_window, label5, "label5");
GLADE_HOOKUP_OBJECT (main_window, label3, "label3");
GLADE_HOOKUP_OBJECT (main_window, label8, "label8");
GLADE_HOOKUP_OBJECT (main_window, image6, "image6");
return main_window;
}
static GtkWidget *
pidgin_media_add_audio_widget(PidginMedia *gtkmedia,
PurpleMediaSessionType type)
{
GtkWidget *volume_widget, *progress_parent, *volume, *progress;
double value;
if (type & PURPLE_MEDIA_SEND_AUDIO) {
value = purple_prefs_get_int(
"/purple/media/audio/volume/input");
} else if (type & PURPLE_MEDIA_RECV_AUDIO) {
value = purple_prefs_get_int(
"/purple/media/audio/volume/output");
} else
g_return_val_if_reached(NULL);
#if GTK_CHECK_VERSION(2,12,0)
/* Setup widget structure */
volume_widget = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
progress_parent = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(volume_widget),
progress_parent, TRUE, TRUE, 0);
/* Volume button */
volume = gtk_volume_button_new();
gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), value/100.0);
gtk_box_pack_end(GTK_BOX(volume_widget),
volume, FALSE, FALSE, 0);
#else
/* Setup widget structure */
volume_widget = gtk_vbox_new(FALSE, 0);
progress_parent = volume_widget;
/* Volume slider */
volume = gtk_hscale_new_with_range(0.0, 100.0, 5.0);
gtk_range_set_increments(GTK_RANGE(volume), 5.0, 25.0);
gtk_range_set_value(GTK_RANGE(volume), value);
gtk_scale_set_draw_value(GTK_SCALE(volume), FALSE);
gtk_box_pack_end(GTK_BOX(volume_widget),
volume, TRUE, FALSE, 0);
#endif
/* Volume level indicator */
progress = gtk_progress_bar_new();
gtk_widget_set_size_request(progress, 250, 10);
gtk_box_pack_end(GTK_BOX(progress_parent), progress, TRUE, FALSE, 0);
if (type & PURPLE_MEDIA_SEND_AUDIO) {
g_signal_connect (G_OBJECT(volume), "value-changed",
G_CALLBACK(pidgin_media_input_volume_changed),
gtkmedia->priv->media);
gtkmedia->priv->send_progress = progress;
} else if (type & PURPLE_MEDIA_RECV_AUDIO) {
g_signal_connect (G_OBJECT(volume), "value-changed",
G_CALLBACK(pidgin_media_output_volume_changed),
gtkmedia->priv->media);
gtkmedia->priv->recv_progress = progress;
}
gtk_widget_show_all(volume_widget);
return volume_widget;
}
GtkWidget *
create_window1 (void)
{
GtkWidget *vbox1;
/* menu */
GtkWidget *menubar1;
GtkWidget *menuitem1;
GtkWidget *menuitem1_menu;
GtkWidget *open;
GtkWidget *apply;
GtkWidget *save;
GtkWidget *separatormenuitem1;
GtkWidget *save_picture;
GtkWidget *save_picture_image;
GtkWidget *xsane;
GtkWidget *separatormenuitem2;
GtkWidget *quit;
GtkWidget *menuitem2;
GtkWidget *menuitem2_menu;
GtkWidget *font;
GtkWidget *separator2;
GtkWidget *spell_check;
GtkWidget *separator3;
GtkWidget *menuitem3;
GtkWidget *menuitem3_menu;
GtkWidget *zoom_in;
GtkWidget *zoom_out;
GtkWidget *normal_size;
GtkWidget *menuitem4;
GtkWidget *menuitem4_menu;
GtkWidget *about;
GtkAccelGroup *accel_group;
/* toolbar */
GtkWidget *toolbar;
GtkIconSize tmp_toolbar_icon_size;
GtkWidget *toolbutton_open;
GtkWidget *toolbutton_apply;
GtkWidget *toolbutton_save;
GtkWidget *toolitem1;
GtkWidget *vseparator1;
GtkWidget *toolbutton_spell;
GtkWidget *toolitem2;
GtkWidget *vseparator2;
GtkWidget *toolbutton_zoom_in;
GtkWidget *toolbutton_zoom_out;
GtkWidget *toolbutton_zoom_fit;
/* image */
GtkWidget *vpaned1;
GtkWidget *scrolledwindow_image;
/* text */
GtkTooltips *tooltips;
PangoFontDescription *font_desc;
tooltips = gtk_tooltips_new ();
accel_group = gtk_accel_group_new ();
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window1, 600, 300);
gtk_window_maximize (GTK_WINDOW (window1));
gtk_window_set_title (GTK_WINDOW (window1), _("hocr-gtk"));
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (window1), vbox1);
/* menu */
menubar1 = gtk_menu_bar_new ();
gtk_widget_show (menubar1);
gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
menuitem1 = gtk_menu_item_new_with_mnemonic (_("_File"));
gtk_widget_show (menuitem1);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem1);
menuitem1_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menuitem1_menu);
open = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group);
gtk_widget_show (open);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), open);
apply = gtk_image_menu_item_new_from_stock ("gtk-apply", accel_group);
gtk_widget_show (apply);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), apply);
save = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group);
gtk_widget_show (save);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), save);
separatormenuitem1 = gtk_separator_menu_item_new ();
gtk_widget_show (separatormenuitem1);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), separatormenuitem1);
gtk_widget_set_sensitive (separatormenuitem1, FALSE);
save_picture = gtk_image_menu_item_new_with_label (_("Save Picture"));
save_picture_image =
gtk_image_new_from_stock ("gtk-save", GTK_ICON_SIZE_MENU);
gtk_widget_show (save_picture_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (save_picture),
save_picture_image);
gtk_widget_show (save_picture);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), save_picture);
xsane = gtk_menu_item_new_with_label (_("Xsane"));
gtk_widget_show (xsane);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), xsane);
separatormenuitem2 = gtk_separator_menu_item_new ();
gtk_widget_show (separatormenuitem2);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), separatormenuitem2);
gtk_widget_set_sensitive (separatormenuitem2, FALSE);
quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_widget_show (quit);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), quit);
menuitem2 = gtk_menu_item_new_with_mnemonic (_("_Edit"));
gtk_widget_show (menuitem2);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem2);
menuitem2_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem2), menuitem2_menu);
font = gtk_image_menu_item_new_from_stock ("gtk-select-font",
accel_group);
gtk_widget_show (font);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), font);
separator2 = gtk_separator_menu_item_new ();
gtk_widget_show (separator2);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), separator2);
gtk_widget_set_sensitive (separator2, FALSE);
#ifdef WITH_GTKSPELL
spell_check =
gtk_image_menu_item_new_from_stock ("gtk-spell-check",
accel_group);
gtk_widget_show (spell_check);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), spell_check);
separator3 = gtk_separator_menu_item_new ();
gtk_widget_show (separator3);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), separator3);
gtk_widget_set_sensitive (separator3, FALSE);
#endif
color_text_box =
gtk_check_menu_item_new_with_mnemonic (_("Color boxes"));
gtk_widget_show (color_text_box);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), color_text_box);
gtk_tooltips_set_tip (tooltips, color_text_box, _("Color text boxes"),
NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (color_text_box),
TRUE);
color_misread =
gtk_check_menu_item_new_with_mnemonic (_("Color misread"));
gtk_widget_show (color_misread);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), color_misread);
gtk_tooltips_set_tip (tooltips, color_misread, _("Color misread fonts"),
NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (color_misread),
TRUE);
clear_text = gtk_check_menu_item_new_with_mnemonic (_("Clear"));
gtk_widget_show (clear_text);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), clear_text);
gtk_tooltips_set_tip (tooltips, clear_text,
_("Clear text each time you ocr new scan"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (clear_text), TRUE);
ocr = gtk_check_menu_item_new_with_mnemonic (_("Ocr"));
gtk_widget_show (ocr);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), ocr);
gtk_tooltips_set_tip (tooltips, ocr,
_("Try to recognize fonts in scaned text"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ocr), TRUE);
use_dict = gtk_check_menu_item_new_with_mnemonic (_("Use dictionary"));
gtk_widget_show (use_dict);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_dict);
gtk_tooltips_set_tip (tooltips, use_dict,
_
("Try to guess unrecognized fonts in scaned text using internal dictionary"),
NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_dict), FALSE);
use_nikud = gtk_check_menu_item_new_with_mnemonic (_("Use nikud"));
gtk_widget_show (use_nikud);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_nikud);
gtk_tooltips_set_tip (tooltips, use_nikud,
_("Try to guess nikud"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_nikud), TRUE);
use_spaces = gtk_check_menu_item_new_with_mnemonic (_("Use spaces"));
gtk_widget_show (use_spaces);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_spaces);
gtk_tooltips_set_tip (tooltips, use_spaces,
_("Use spaces for tabs"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_spaces),
FALSE);
use_indent =
gtk_check_menu_item_new_with_mnemonic (_("Use indentation"));
gtk_widget_show (use_indent);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_indent);
gtk_tooltips_set_tip (tooltips, use_indent,
_("Try to guess line indentation"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_indent),
FALSE);
menuitem3 = gtk_menu_item_new_with_mnemonic (_("_View"));
gtk_widget_show (menuitem3);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem3);
menuitem3_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem3), menuitem3_menu);
zoom_in =
gtk_image_menu_item_new_from_stock ("gtk-zoom-in", accel_group);
gtk_widget_show (zoom_in);
gtk_container_add (GTK_CONTAINER (menuitem3_menu), zoom_in);
zoom_out =
gtk_image_menu_item_new_from_stock ("gtk-zoom-out",
accel_group);
gtk_widget_show (zoom_out);
gtk_container_add (GTK_CONTAINER (menuitem3_menu), zoom_out);
normal_size =
gtk_image_menu_item_new_from_stock ("gtk-zoom-100",
accel_group);
gtk_widget_show (normal_size);
gtk_container_add (GTK_CONTAINER (menuitem3_menu), normal_size);
menuitem4 = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_widget_show (menuitem4);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem4);
menuitem4_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menuitem4_menu);
about = gtk_menu_item_new_with_mnemonic (_("_About"));
gtk_widget_show (about);
gtk_container_add (GTK_CONTAINER (menuitem4_menu), about);
/* toolbar */
toolbar = gtk_toolbar_new ();
gtk_widget_show (toolbar);
gtk_box_pack_start (GTK_BOX (vbox1), toolbar, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH);
tmp_toolbar_icon_size =
gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
toolbutton_open =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-open");
gtk_widget_show (toolbutton_open);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_open);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_open), tooltips,
_("Open a new picture for the OCR"), NULL);
toolbutton_apply =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-apply");
gtk_widget_show (toolbutton_apply);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_apply);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_apply), tooltips,
_("Convert picture to text"), NULL);
toolbutton_save =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-save");
gtk_widget_show (toolbutton_save);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_save);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_save), tooltips,
_("Save the text created by the OCR"), NULL);
toolitem1 = (GtkWidget *) gtk_tool_item_new ();
gtk_widget_show (toolitem1);
gtk_container_add (GTK_CONTAINER (toolbar), toolitem1);
vseparator1 = gtk_vseparator_new ();
gtk_widget_show (vseparator1);
gtk_container_add (GTK_CONTAINER (toolitem1), vseparator1);
#ifdef WITH_GTKSPELL
toolbutton_spell =
(GtkWidget *)
gtk_tool_button_new_from_stock ("gtk-spell-check");
gtk_widget_show (toolbutton_spell);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_spell);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_spell), tooltips,
_("Spell check the text"), NULL);
toolitem2 = (GtkWidget *) gtk_tool_item_new ();
gtk_widget_show (toolitem2);
gtk_container_add (GTK_CONTAINER (toolbar), toolitem2);
vseparator2 = gtk_vseparator_new ();
gtk_widget_show (vseparator2);
gtk_container_add (GTK_CONTAINER (toolitem2), vseparator2);
#endif
toolbutton_zoom_in =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-zoom-in");
gtk_widget_show (toolbutton_zoom_in);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_zoom_in);
toolbutton_zoom_out =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-zoom-out");
gtk_widget_show (toolbutton_zoom_out);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_zoom_out);
toolbutton_zoom_fit =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-zoom-fit");
gtk_widget_show (toolbutton_zoom_fit);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_zoom_fit);
/* image */
vpaned1 = gtk_vpaned_new ();
gtk_widget_show (vpaned1);
gtk_container_add (GTK_CONTAINER (vbox1), vpaned1);
scrolledwindow_image = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *)
scrolledwindow_image,
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolledwindow_image);
gtk_container_add (GTK_CONTAINER (vpaned1), scrolledwindow_image);
viewport1 = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport1);
gtk_container_add (GTK_CONTAINER (scrolledwindow_image), viewport1);
image = gtk_image_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (viewport1), image);
/* text */
scrolledwindow_text = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *)
scrolledwindow_text,
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolledwindow_text);
gtk_container_add (GTK_CONTAINER (vpaned1), scrolledwindow_text);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW
(scrolledwindow_text),
GTK_SHADOW_IN);
textview = gtk_text_view_new ();
gtk_widget_show (textview);
gtk_container_add (GTK_CONTAINER (scrolledwindow_text), textview);
font_desc = pango_font_description_from_string (font_name);
gtk_widget_modify_font (textview, font_desc);
font_name = g_strdup (TEXT_FONT_NAME);
/* progress bar */
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 0);
pbar = gtk_progress_bar_new ();
gtk_widget_show (pbar);
gtk_box_pack_start (GTK_BOX (hbox2), pbar, FALSE, FALSE, 0);
gtk_widget_set_size_request (pbar, 100, -1);
statusbar1 = gtk_statusbar_new ();
gtk_widget_show (statusbar1);
gtk_box_pack_start (GTK_BOX (hbox2), statusbar1, TRUE, TRUE, 0);
/* main window */
g_signal_connect ((gpointer) window1, "delete_event",
G_CALLBACK (on_window1_delete_event), NULL);
/* toolbar */
g_signal_connect ((gpointer) toolbutton_open, "clicked",
G_CALLBACK (on_toolbutton_open_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_apply, "clicked",
G_CALLBACK (on_toolbutton_apply_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_save, "clicked",
G_CALLBACK (on_toolbutton_save_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_zoom_in, "clicked",
G_CALLBACK (on_toolbutton_zoom_in_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_zoom_out, "clicked",
G_CALLBACK (on_toolbutton_zoom_out_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_zoom_fit, "clicked",
G_CALLBACK (on_toolbutton_zoom_fit_clicked), NULL);
#ifdef WITH_GTKSPELL
g_signal_connect ((gpointer) toolbutton_spell, "clicked",
G_CALLBACK (on_toolbutton_spell_clicked), NULL);
#endif
/* menu */
g_signal_connect ((gpointer) open, "activate",
G_CALLBACK (on_open_activate), NULL);
g_signal_connect ((gpointer) apply, "activate",
G_CALLBACK (on_apply_activate), NULL);
g_signal_connect ((gpointer) save, "activate",
G_CALLBACK (on_save_activate), NULL);
g_signal_connect ((gpointer) save_picture, "activate",
G_CALLBACK (on_save_picture_activate), NULL);
g_signal_connect ((gpointer) xsane, "activate",
G_CALLBACK (on_xsane_activate), NULL);
g_signal_connect ((gpointer) quit, "activate",
G_CALLBACK (on_quit_activate), NULL);
g_signal_connect ((gpointer) font, "activate",
G_CALLBACK (on_font_activate), NULL);
#ifdef WITH_GTKSPELL
g_signal_connect ((gpointer) spell_check, "activate",
G_CALLBACK (on_spell_check_activate), NULL);
#endif
g_signal_connect ((gpointer) zoom_in, "activate",
G_CALLBACK (on_zoom_in_activate), NULL);
g_signal_connect ((gpointer) zoom_out, "activate",
G_CALLBACK (on_zoom_out_activate), NULL);
g_signal_connect ((gpointer) normal_size, "activate",
G_CALLBACK (on_normal_size_activate), NULL);
g_signal_connect ((gpointer) about, "activate",
G_CALLBACK (on_about_activate), NULL);
gtk_window_add_accel_group (GTK_WINDOW (window1), accel_group);
return window1;
}
static GtkWidget *
show_view_create_widget (PlannerShowView *view)
{
PlannerShowViewPriv *priv;
GtkWidget *pertlayout;
GtkWidget *tree;
GtkWidget *sw;
GtkWidget *frame;
GtkWidget *layout;
GtkWidget *vpaned;
GtkAdjustment *hadj, *vadj;
GtkTreeModel *model;
MrpTaskManager *task_manager;
GtkLabel *label;
GtkEntry *entry;
GtkButton *button;
GtkWidget *hbox,*vbox,*vbox2;
GtkWidget *progressbar;
GtkWidget *randomtogglebutton;
GtkWidget *deleteresourcetogglebutton;
GtkWidget *ganttcharttogglebutton;
GtkWidget *manulsettogglebutton;
GtkWidget *table;
MrpProject *project;
GtkTreeSelection *selection;
GList *task_list;
project = planner_window_get_project (PLANNER_VIEW (view)->main_window);
task_manager = imrp_project_get_task_manager(project);
priv = view->priv;
g_signal_connect (project,
"loaded",
G_CALLBACK (show_view_project_loaded_cb),
view);
model = GTK_TREE_MODEL (planner_gantt_model_new (project));
tree = planner_task_tree_new (PLANNER_VIEW (view)->main_window,
PLANNER_GANTT_MODEL (model),
FALSE,
TRUE,
COL_WBS, _("WBS"),
COL_NAME, _("Name"),
COL_START, _("Start"),
COL_FINISH, _("Finish"),
COL_WORK, _("Work"),
COL_DURATION, _("Duration"),
COL_SLACK, _("Slack"),
COL_COST, _("Cost"),
COL_ASSIGNED_TO, _("Assigned to"),
COL_COMPLETE, _("% Complete"),
-1);
priv->tree = tree;
priv->gantt = planner_gantt_chart_new_with_model (model);
g_object_set (priv->gantt,
"header_height", 50,
NULL);
planner_gantt_chart_set_view (PLANNER_GANTT_CHART (priv->gantt),
PLANNER_TASK_TREE (tree));
//*********************
//events sensitive on gantt widget
gtk_widget_set_events (GTK_WIDGET (priv->gantt), GDK_SCROLL_MASK);
g_signal_connect (priv->gantt, "scroll-event",
G_CALLBACK (show_view_chart_scroll_event), view);
g_object_unref (model);
g_signal_connect (priv->gantt,
"status_updated",
G_CALLBACK (show_view_gantt_status_updated_cb),
view);
g_signal_connect (priv->gantt,
"resource_clicked",
G_CALLBACK (show_view_gantt_resource_clicked_cb),
view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
//g_signal_connect (tree,
//"style_set",
//G_CALLBACK (show_view_tree_style_set_cb),
//view);
//*********************
//interface design
//GtkVPaned
// GtkFrame -> GtkScrollWindow ->GtkLayout (pert view showed here)A
// GtkHBox
// GtkVBox -> GtkHBox (show run-in-time data showed here)B
// GtkLabel
// GtkEntry
// GtkScrollWindow (gantt view showed here)C
//interface design in A
//GtkScrollWindow, let its scrollbar displayed if needed, put the pert view inside
layout = gtk_layout_new(NULL,NULL);
priv->pertlayout = layout;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw),
priv->pertlayout);
//GtkFrame, put the GtkScrollWindow in the GtkFrame
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), sw);
//GtkVPaned, add the GtkFrame in the GtkVPaned
vpaned = gtk_vpaned_new ();
gtk_paned_add1 (GTK_PANED (vpaned), frame);
//interface design in B
//GtkVBox, holds labels and entry and buttons
vbox = gtk_vbox_new(FALSE, 0);
vbox2 = gtk_vbox_new(FALSE,0);
progressbar = gtk_progress_bar_new();
//GtkLabel, "The Current Task Is: "
label = gtk_label_new("当前执行审计任务: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, holds task name
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->currenttaskentry = entry;
//GtkLabel, "The Current Delay Is:: "
label = gtk_label_new("当前审计延迟时间: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, holds task delay
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->currentdelayentry = entry;
//GtkLabel, "The Current duration is "
label = gtk_label_new("当前审计总时间: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, holds total duration
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->currentdurationentry = entry;
//GtkLabel, "The Duration has changed :: "
label = gtk_label_new("延迟后审计总时间: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, The Duration has changed to
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->lastdurationentry = entry;
lastdurationentry = entry;
//GtkLabel, "delete resource"
label = gtk_label_new("调整的审计人员: ");
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (label), FALSE, FALSE, 0);
//GtkEntry, delete resource
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (entry), FALSE, FALSE, 0);
priv->deleteresourceentry = entry;
GtkWidget *labelChild;
PangoFontDescription *font1;
short fontSize = 8;
//GtkButton, delete resource
button = gtk_button_new_with_label("重大事项显示");
GdkColor color;
color.red = 50000;
color.green = 20000;
color.blue = 15000;
gtk_widget_modify_bg(button, GTK_STATE_INSENSITIVE, &color);
// font1 = pango_font_description_from_string("Sans");//"Sans"字体名
//pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
// labelChild = gtk_bin_get_child(GTK_BIN(button));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (button), FALSE,FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (show_view_delete_resource_cb),
view);
priv->deleteresourcebutton = button;
//total duration display
button = gtk_button_new_with_label("审计总时间无延迟");
GdkColor color1;
color1.red = 50000;
color1.green = 20000;
color1.blue = 15000;
gtk_widget_modify_bg(button, GTK_STATE_INSENSITIVE, &color1);
// font1 = pango_font_description_from_string("Sans");//"Sans"字体名
// pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
// labelChild = gtk_bin_get_child(GTK_BIN(button));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (button), FALSE,FALSE, 0);
g_signal_connect(button, "clicked",
G_CALLBACK (show_view_delete_resource_cb), view);
priv->displaytotaldurationbutton = button;
//GtkButton, go to next task
button = gtk_button_new_with_label("执行下一审计任务");
GdkColor color2;
color2.red = 50000;
color2.green = 10000;
color2.blue = 10000;
gtk_widget_modify_bg(button, GTK_STATE_INSENSITIVE, &color2);
// font1 = pango_font_description_from_string("Sans");//"Sans"字体名
// pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
// labelChild = gtk_bin_get_child(GTK_BIN(button));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (button), FALSE,FALSE, 0);
g_signal_connect (button,
"clicked",
G_CALLBACK (show_view_next_task_cb),
view);
priv->nextstepbutton = button;
table = gtk_table_new(2, 2, FALSE);
manulsettogglebutton = gtk_toggle_button_new_with_label("手动设置审计任务延迟");
gtk_widget_set_size_request(manulsettogglebutton,5,7);
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( manulsettogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
randomtogglebutton = gtk_toggle_button_new_with_label("随机设置审计任务延迟");
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( randomtogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
deleteresourcetogglebutton = gtk_toggle_button_new_with_label("参审人员随机调整");
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( deleteresourcetogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
ganttcharttogglebutton = gtk_toggle_button_new_with_label("干特图路径选择");
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( ganttcharttogglebutton));//取出GtkButton里的label
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 2);
gtk_table_attach_defaults(GTK_TABLE(table), manulsettogglebutton, 0, 1, 0,1);
gtk_table_attach_defaults(GTK_TABLE(table), randomtogglebutton, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), deleteresourcetogglebutton, 1,
2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), ganttcharttogglebutton, 1, 2, 1,
2);
gtk_signal_connect(GTK_OBJECT(randomtogglebutton), "toggle",
GTK_SIGNAL_FUNC(select_random_task), view);
gtk_signal_connect(GTK_OBJECT(deleteresourcetogglebutton), "toggle",
GTK_SIGNAL_FUNC(select_deleteresource), view);
priv->manulsettogglebutton = manulsettogglebutton;
priv->randomtogglebutton = randomtogglebutton;
priv->deleteresourcetogglebutton = deleteresourcetogglebutton;
priv->ganttcharttogglebutton = ganttcharttogglebutton;
//gtk_table_attach_defaults(GTK_TABLE(table), labelprobability,1,2,2,3);
// gtk_table_attach_defaults(GTK_TABLE(table), togglebutton,0,2,3,4);
gtk_box_pack_start(GTK_BOX (vbox), GTK_WIDGET (table), FALSE, FALSE, 0);
//GtkButton, auto optimization
button = gtk_button_new_with_label("Auto Optimization");
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw),
priv->gantt);
gtk_box_pack_start(GTK_BOX (vbox2), GTK_WIDGET (sw), TRUE, TRUE,0);
gtk_widget_set_size_request(progressbar,150,36);
gtk_box_pack_start(GTK_BOX (vbox2), GTK_WIDGET (progressbar), FALSE, FALSE, 0);
priv->progressbar = progressbar;
//put the GtkHBox in the GtkFrame, put the GtkVBox and GtkScrollWindow in the GtkHBox
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox), GTK_WIDGET (vbox), FALSE,TRUE, 0);
gtk_box_pack_end(GTK_BOX (hbox), GTK_WIDGET (vbox2), TRUE, TRUE, 10);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET (hbox));
//add the GtkFrame in the GtkVPaned
gtk_paned_add2 (GTK_PANED (vpaned), frame);
gtk_paned_set_position (GTK_PANED (vpaned), 250);
g_signal_connect (tree,
"row_expanded",
G_CALLBACK (show_view_row_expanded),
priv->gantt);
g_signal_connect (tree,
"row_collapsed",
G_CALLBACK (show_view_row_collapsed),
priv->gantt);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree));
return vpaned;
}
static GtkWidget *
make_info_table(GaimGtkXferDialog *dialog)
{
GtkWidget *table;
GtkWidget *label;
GtkWidget *sep;
int i;
struct
{
GtkWidget **desc_label;
GtkWidget **val_label;
const char *desc;
} labels[] =
{
{ &dialog->local_user_desc_label, &dialog->local_user_label, NULL },
{ &dialog->remote_user_desc_label, &dialog->remote_user_label, NULL },
{ &label, &dialog->protocol_label, _("Protocol:") },
{ &label, &dialog->filename_label, _("Filename:") },
{ &label, &dialog->localfile_label, _("Local File:") },
{ &label, &dialog->status_label, _("Status:") },
{ &label, &dialog->speed_label, _("Speed:") },
{ &label, &dialog->time_elapsed_label, _("Time Elapsed:") },
{ &label, &dialog->time_remaining_label, _("Time Remaining:") }
};
/* Setup the initial table */
dialog->table = table = gtk_table_new(10, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), CONTAINER_BORDER_WIDTH);
gtk_table_set_col_spacings(GTK_TABLE(table), CONTAINER_BORDER_WIDTH);
/* Setup the labels */
for (i = 0; i < sizeof(labels) / sizeof(*labels); i++) {
GtkWidget *label;
char buf[256];
g_snprintf(buf, sizeof(buf), "<b>%s</b>",
labels[i].desc != NULL ? labels[i].desc : "");
*labels[i].desc_label = label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), buf);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, i, i + 1,
GTK_FILL, 0, 0, 0);
gtk_widget_show(label);
*labels[i].val_label = label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, i, i + 1,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(label);
}
/* Setup the progress bar */
dialog->progress = gtk_progress_bar_new();
gtk_table_attach(GTK_TABLE(table), dialog->progress, 0, 2, 8, 9,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show(dialog->progress);
sep = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table), sep, 0, 2, 9, 10,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show(sep);
return table;
}
GtkWidget *
gnomemeeting_progress_dialog (GtkWindow *parent,
const char *prim_text,
const char *format,
...)
{
GtkWidget *dialog = NULL;
GtkWidget *label = NULL;
GtkWidget *progressbar = NULL;
gchar *primary_text = NULL;
gchar *dialog_text = NULL;
char buffer [1025];
guint id = 0;
va_list args;
va_start (args, format);
primary_text =
g_strdup_printf ("<span weight=\"bold\" size=\"larger\">%s</span>",
prim_text);
if (format == NULL)
buffer[0] = 0;
else
g_vsnprintf (buffer, 1024, format, args);
dialog_text =
g_strdup_printf ("%s\n\n%s", primary_text, buffer);
dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog), "");
if (parent) {
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
}
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), dialog_text);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), label,
FALSE, FALSE, 0);
progressbar = gtk_progress_bar_new ();
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), progressbar,
FALSE, FALSE, 0);
id = g_timeout_add (100, progress_dialog_pulse_cb, progressbar);
g_signal_connect (dialog, "destroy",
G_CALLBACK (progress_dialog_destroyed_cb),
GINT_TO_POINTER (id));
g_signal_connect (dialog, "delete-event",
G_CALLBACK (progress_dialog_delete_event_cb),
NULL);
g_free (dialog_text);
g_free (primary_text);
va_end (args);
return dialog;
}
static int
passphrase_dialog(char *message)
{
const char *failed;
char *passphrase, *local;
int result, grab_tries, grab_server, grab_pointer;
GtkWidget *dialog, *entry, *progress, *hbox;
GdkGrabStatus status;
grab_server = (getenv("GNOME_SSH_ASKPASS_GRAB_SERVER") != NULL);
grab_pointer = (getenv("GNOME_SSH_ASKPASS_GRAB_POINTER") != NULL);
grab_tries = 0;
dialog = gtk_message_dialog_new(NULL, 0,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_OK_CANCEL,
"%s",
message);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE,
FALSE, 0);
gtk_widget_show(hbox);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE,
FALSE, 0);
gtk_entry_set_width_chars(GTK_ENTRY(entry), 2);
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
gtk_widget_grab_focus(entry);
gtk_widget_show(entry);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE,
FALSE, 8);
gtk_widget_show(hbox);
progress = gtk_progress_bar_new();
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress), "Passphrase length hidden intentionally");
gtk_box_pack_start(GTK_BOX(hbox), progress, TRUE,
TRUE, 5);
gtk_widget_show(progress);
gtk_window_set_title(GTK_WINDOW(dialog), "OpenSSH");
gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE);
gtk_label_set_line_wrap(GTK_LABEL((GTK_MESSAGE_DIALOG(dialog))->label),
TRUE);
/* Make <enter> close dialog */
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(ok_dialog), dialog);
g_signal_connect(G_OBJECT(entry), "changed",
G_CALLBACK(move_progress), progress);
gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE);
/* Grab focus */
gtk_widget_show_now(dialog);
if (grab_pointer) {
for(;;) {
status = gdk_pointer_grab(
(GTK_WIDGET(dialog))->window, TRUE, 0, NULL,
NULL, GDK_CURRENT_TIME);
if (status == GDK_GRAB_SUCCESS)
break;
usleep(GRAB_WAIT * 1000);
if (++grab_tries > GRAB_TRIES) {
failed = "mouse";
goto nograb;
}
}
}
for(;;) {
status = gdk_keyboard_grab((GTK_WIDGET(dialog))->window,
FALSE, GDK_CURRENT_TIME);
if (status == GDK_GRAB_SUCCESS)
break;
usleep(GRAB_WAIT * 1000);
if (++grab_tries > GRAB_TRIES) {
failed = "keyboard";
goto nograbkb;
}
}
if (grab_server) {
gdk_x11_grab_server();
}
result = gtk_dialog_run(GTK_DIALOG(dialog));
/* Ungrab */
if (grab_server)
XUngrabServer(GDK_DISPLAY());
if (grab_pointer)
gdk_pointer_ungrab(GDK_CURRENT_TIME);
gdk_keyboard_ungrab(GDK_CURRENT_TIME);
gdk_flush();
/* Report passphrase if user selected OK */
passphrase = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
if (result == GTK_RESPONSE_OK) {
local = g_locale_from_utf8(passphrase, strlen(passphrase),
NULL, NULL, NULL);
if (local != NULL) {
puts(local);
memset(local, '\0', strlen(local));
g_free(local);
} else {
puts(passphrase);
}
}
/* Zero passphrase in memory */
memset(passphrase, '\b', strlen(passphrase));
gtk_entry_set_text(GTK_ENTRY(entry), passphrase);
memset(passphrase, '\0', strlen(passphrase));
g_free(passphrase);
gtk_widget_destroy(dialog);
return (result == GTK_RESPONSE_OK ? 0 : -1);
/* At least one grab failed - ungrab what we got, and report
the failure to the user. Note that XGrabServer() cannot
fail. */
nograbkb:
gdk_pointer_ungrab(GDK_CURRENT_TIME);
nograb:
if (grab_server)
XUngrabServer(GDK_DISPLAY());
gtk_widget_destroy(dialog);
report_failed_grab(failed);
return (-1);
}
static void
trash_empty_start ()
{
GtkWidget *vbox1, *vbox2, *hbox;
GtkWidget *label1, *label3;
gchar *markup;
GCancellable *cancellable;
trash_empty_dialog = gtk_dialog_new ();
gtk_window_set_default_size (GTK_WINDOW (trash_empty_dialog), 400, -1);
gtk_window_set_icon_name (GTK_WINDOW (trash_empty_dialog), "user-trash");
gtk_window_set_title (GTK_WINDOW (trash_empty_dialog),
_("Emptying the trash"));
vbox1 = gtk_vbox_new (FALSE, 12);
vbox2 = gtk_vbox_new (FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
label1 = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (label1), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label1), 0.0);
gtk_label_set_yalign (GTK_LABEL (label1), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label1), 0.0, 0.5);
#endif
label3 = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (label3), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label3), 0.0);
gtk_label_set_yalign (GTK_LABEL (label3), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label3), 0.0, 0.5);
#endif
gtk_widget_hide (label3);
location_label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (location_label), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (location_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (location_label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (location_label), 0.0, 0.5);
#endif
file_label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (file_label), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (file_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (file_label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (file_label), 0.0, 0.5);
#endif
progressbar = gtk_progress_bar_new ();
gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (progressbar), 0.1);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar), _("Preparing to empty trash…"));
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (trash_empty_dialog))), vbox1, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), label1, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label3, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), location_label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), progressbar, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), file_label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
gtk_widget_show (label1);
gtk_widget_show (vbox1);
gtk_widget_show_all (vbox2);
gtk_widget_show (hbox);
gtk_widget_show (location_label);
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (trash_empty_dialog))), 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 6);
gtk_dialog_add_button (GTK_DIALOG (trash_empty_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
markup = g_markup_printf_escaped ("<big><b>%s</b></big>", _("Emptying the trash"));
gtk_label_set_markup (GTK_LABEL (label1), markup);
/* Translators: "Emptying trash from <device>" */
gtk_label_set_text (GTK_LABEL (label3), _("From: "));
cancellable = g_cancellable_new ();
g_signal_connect_object (trash_empty_dialog, "response",
G_CALLBACK (g_cancellable_cancel),
cancellable, G_CONNECT_SWAPPED);
g_io_scheduler_push_job (trash_empty_job, NULL, NULL, 0, cancellable);
gtk_widget_show (trash_empty_dialog);
g_free (markup);
g_object_unref (cancellable);
}
/* battery_init */
static Battery * _battery_init(PanelAppletHelper * helper, GtkWidget ** widget)
{
const int timeout = 5000;
Battery * battery;
GtkIconSize iconsize;
GtkWidget * vbox;
GtkWidget * hbox;
PangoFontDescription * bold;
if((battery = object_new(sizeof(*battery))) == NULL)
return NULL;
battery->helper = helper;
battery->level = -1;
battery->charging = -1;
battery->timeout = 0;
#if defined(__NetBSD__) || defined(__linux__)
battery->fd = -1;
#endif
iconsize = panel_window_get_icon_size(helper->window);
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
battery->box = hbox;
battery->image = gtk_image_new_from_icon_name("battery", iconsize);
gtk_box_pack_start(GTK_BOX(hbox), battery->image, TRUE, TRUE, 0);
battery->label = NULL;
battery->progress = NULL;
battery->pr_level = NULL;
if(panel_window_get_type(helper->window)
== PANEL_WINDOW_TYPE_NOTIFICATION)
{
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
#else
vbox = gtk_vbox_new(FALSE, 4);
#endif
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
battery->progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), battery->progress, TRUE, TRUE,
0);
battery->box = vbox;
pango_font_description_free(bold);
}
else
{
#ifndef EMBEDDED
battery->label = gtk_label_new(" ");
gtk_box_pack_start(GTK_BOX(hbox), battery->label, FALSE, TRUE,
0);
gtk_widget_show(battery->label);
#endif
battery->box = hbox;
}
battery->timeout = g_timeout_add(timeout, _battery_on_timeout, battery);
_battery_on_timeout(battery);
gtk_widget_show(battery->image);
*widget = battery->box;
return battery;
}
static void
netselect_dlg_show()
{
struct netselect_dlg * dlg;
GtkWidget * main_vbox, * scrolled,
* button_box, * manual_hbox,
* hbox, * vbox, * frame, * settings_vbox;
GtkTreeViewColumn * column;
gchar * text;
if(main_netselect_dlg) {
/* dialog is shown already */
gtk_window_present(GTK_WINDOW(dlg->dlg_w));
return;
}
dlg = main_netselect_dlg = g_new(struct netselect_dlg, 1);
dlg->detect_timeout_id = 0;
dlg->dlg_w = gtk_dialog_new_with_buttons(
_("Network detection and configuration"), gui_get_main_window(), 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_signal_connect(G_OBJECT(dlg->dlg_w), "response",
G_CALLBACK(dlg_response), (gpointer)dlg);
g_signal_connect(G_OBJECT(dlg->dlg_w), "delete-event", G_CALLBACK(gtk_true), NULL);
/* upper vertical box for list and port range controls
*/
main_vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg->dlg_w)->vbox), main_vbox, TRUE, TRUE, 0);
frame = gtk_frame_new(_("Detected networks"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(main_vbox), frame, TRUE, TRUE, 0);
dlg->list = gtk_list_store_new(
NETLISTCOL_NUM,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);
dlg->tree_w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dlg->list));
g_signal_connect(G_OBJECT(dlg->tree_w), "row-activated",
G_CALLBACK(list_row_activated), (gpointer)dlg);
g_signal_connect(G_OBJECT(dlg->tree_w), "cursor-changed",
G_CALLBACK(list_cursor_changed), (gpointer)dlg);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_TYPE),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_TYPE_STR, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_PORT),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_PORT_STR, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 1);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_USE_MULTICAST),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_USE_MULTICAST_STR, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrolled, -1, LIST_MIN_HEIGHT);
gtk_scrolled_window_set_policy(
GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), dlg->tree_w);
gtk_container_add(GTK_CONTAINER(frame), scrolled);
/* Make hbox for lower control frames */
manual_hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), manual_hbox, FALSE, FALSE, 0);
/*
* "Automatic scan" frame
*/
frame = gtk_frame_new(_("Automatic scan"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0);
/* vbox inside the frame */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* progress bar
*/
dlg->detect_progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_progress, FALSE, FALSE, 0);
/* the 'reset' and 'refresh' buttons
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
button_box = gtk_hbutton_box_new();
gtk_box_pack_end(GTK_BOX(hbox), button_box, FALSE, FALSE, 0);
dlg->detect_btn = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
g_signal_connect(G_OBJECT(dlg->detect_btn), "clicked",
G_CALLBACK(detect_button_clicked), (gpointer)dlg);
gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_btn, FALSE, FALSE, 0);
dlg->detect_stop_btn = gtk_button_new_from_stock(GTK_STOCK_STOP);
g_signal_connect(G_OBJECT(dlg->detect_stop_btn), "clicked",
G_CALLBACK(detect_button_clicked), (gpointer)dlg);
gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_stop_btn, FALSE, FALSE, 0);
/* settings vbox */
settings_vbox = gtk_vbox_new(FALSE, 4);
/* port range start spin
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_begin_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->detect_begin_spin), DEFAULT_DETECT_RANGE_BEGIN);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_begin_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("Scan UDP ports from")), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(dlg->detect_begin_spin), "value-changed",
G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg);
/* port range end spin
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_end_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->detect_end_spin), DEFAULT_DETECT_RANGE_END);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_end_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("to (including)")), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(dlg->detect_end_spin), "value-changed",
G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg);
/* broadcast mask */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_broadcast_mask_w = gtk_entry_new();
gtk_entry_set_text(
GTK_ENTRY(dlg->detect_broadcast_mask_w),
text = util_inet_ntoa(prefs_int(PREFS_NET_BROADCAST_MASK)));
g_free(text);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_broadcast_mask_w, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_BROADCAST_MASK)), FALSE, FALSE, 0);
/* multicast mask */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_multicast_addr_w = gtk_entry_new();
gtk_entry_set_text(
GTK_ENTRY(dlg->detect_multicast_addr_w),
text = util_inet_ntoa(prefs_int(PREFS_NET_MULTICAST_ADDR)));
g_free(text);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_multicast_addr_w, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_MULTICAST_ADDR)), FALSE, FALSE, 0);
/* pack settings vbox in to the window (through the expander widget) */
#if(HAVE_EXPANDER_WIDGET)
dlg->detect_expander_w = gtk_expander_new_with_mnemonic(_("Detection settings"));
gtk_container_add(GTK_CONTAINER(dlg->detect_expander_w), settings_vbox);
gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_expander_w, FALSE, FALSE, 0);
#else
gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), settings_vbox, FALSE, FALSE, 0);
#endif
/*
* Manual port/network entry frame
*/
frame = gtk_frame_new(_("Network settings"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0);
/* vbox inside the frame */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* use multicast toggle */
dlg->net_use_multicast_w = gtk_check_button_new_with_label(
prefs_description(PREFS_NET_USE_MULTICAST));
gtk_widget_set_sensitive(
dlg->net_use_multicast_w, prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(dlg->net_use_multicast_w),
prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS
? prefs_bool(PREFS_NET_USE_MULTICAST): FALSE);
/* network type option */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
dlg->net_type_option = util_net_type_option(
(util_option_changed_cb)dlg_net_type_option_changed, (gpointer)dlg);
gtk_box_pack_end(GTK_BOX(hbox), dlg->net_type_option, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_TYPE)), FALSE, FALSE, 0);
gtk_option_menu_set_history(
GTK_OPTION_MENU(dlg->net_type_option), prefs_int(PREFS_NET_TYPE));
/* network port number */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
dlg->net_port_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_box_pack_end(GTK_BOX(hbox), dlg->net_port_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_PORT)), FALSE, FALSE, 0);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->net_port_spin),
prefs_int(PREFS_NET_PORT));
/* append the multicast toggle */
gtk_box_pack_start(GTK_BOX(vbox), dlg->net_use_multicast_w, FALSE, FALSE, 0);
/* show dialog to the user */
dlg_search_mode(dlg, FALSE);
gtk_widget_show_all(dlg->dlg_w);
gtk_window_present(GTK_WINDOW(dlg->dlg_w));
}
static void serverstats_init(void)
{
/** Get an allready exposed widgets to grab theme colors from. */
GtkWidget *colw = (GtkWidget *) playlist3_get_category_tree_view();
GtkWidget *label = NULL;
GtkWidget *table = NULL;
GtkWidget *hbox = NULL;
GtkWidget *event = NULL;
GtkWidget *serverstats_vbox = gtk_vbox_new(FALSE, 0);
GtkWidget *serverstats_event;
gchar *markup = NULL;
int i = 0;
serverstats_sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
serverstats_event = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(serverstats_event), TRUE);
gtk_container_add(GTK_CONTAINER(serverstats_event), serverstats_vbox);
{
GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event));
gtk_style_context_add_class(cs, GTK_STYLE_CLASS_VIEW);
}
/* wrap in event box to set bg color */
event = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), TRUE);
//gtk_widget_set_state(GTK_WIDGET(event), GTK_STATE_SELECTED);
{
GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event));
gtk_style_context_add_class(cs, GTK_STYLE_CLASS_HEADER);
}
//gtk_widget_modify_bg(serverstats_event, GTK_STATE_NORMAL, &(colw->style->base[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(serverstats_vbox), "style-set", G_CALLBACK(serverstats_header_style_changed),
serverstats_event);
/* set label and padding */
hbox = gtk_hbox_new(FALSE, 6);
label = gtk_image_new_from_icon_name("mpd", GTK_ICON_SIZE_DND);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='xx-large' weight='bold'>%s</span>", _("Server Information"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(event), hbox);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
gtk_box_pack_start(GTK_BOX(serverstats_vbox), event, FALSE, TRUE, 0);
gtk_widget_show_all(event);
label = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(serverstats_vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
/**
* Data list
*/
table = gtk_grid_new();//(SERVERSTATS_NUM_FIELDS + 2, 2, FALSE);
gtk_grid_set_column_spacing(GTK_GRID(table), 6);
gtk_grid_set_row_spacing(GTK_GRID(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 12);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Server"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0,0,2,1);
i = 1;
/** Mpd version */
serverstats_add_entry(table, i++, _("Version"), SERVERSTATS_MPD_VERSION);
serverstats_add_entry(table, i++, _("Uptime"), SERVERSTATS_MPD_UPTIME);
serverstats_add_entry(table, i++, _("Time Playing"), SERVERSTATS_MPD_PLAYTIME);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Database"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1);
i++;
/** Mpd Playtime */
serverstats_add_entry(table, i++, _("Total Playtime"), SERVERSTATS_MPD_DB_PLAYTIME);
/** Mpd Artists*/
serverstats_add_entry(table, i++, _("Number of artists"), SERVERSTATS_MPD_DB_ARTISTS);
/** Mpd Albums */
serverstats_add_entry(table, i++, _("Number of albums"), SERVERSTATS_MPD_DB_ALBUMS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Number of songs"), SERVERSTATS_MPD_DB_SONGS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("URL Handlers"), SERVERSTATS_MPD_URLHANDLERS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Tag Types"), SERVERSTATS_MPD_TAG_TYPES);
/** Stats */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Tag statistics"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1);
i++;
gtk_widget_show_all(table);
/**
* Stats treeview
*/
{
int j;
GtkWidget *combo = NULL;
GtkWidget *sw = NULL, *cancel;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkWidget *pb = gtk_progress_bar_new();
combo = gtk_combo_box_text_new();
for (j = 0; j < MPD_TAG_NUM_OF_ITEM_TYPES - 1; j++)
{
if (mpd_server_tag_supported(connection, j))
{
gtk_combo_box_text_append(GTK_COMBO_BOX(combo),NULL, mpdTagItemKeys[j]);
}
}
gtk_grid_attach(GTK_GRID(table), combo, 0, i, 2, 1);
i++;
gtk_widget_show(combo);
hbox = gtk_hbox_new(FALSE, 6);
cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(cancel_clicked), NULL);
gtk_box_pack_start(GTK_BOX(hbox), pb, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), cancel, FALSE, TRUE, 0);
gtk_grid_attach(GTK_GRID(table), hbox, 0, i, 2, 1);
i++;
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(serverstats_combo_changed), pb);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_container_set_border_width(GTK_CONTAINER(sw), 6);
store = gtk_list_store_new(4, G_TYPE_ULONG, G_TYPE_STRING, G_TYPE_ULONG, G_TYPE_STRING);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_DESCENDING);
serverstats_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(serverstats_tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(serverstats_tree), TRUE);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, "width-chars", 30,
NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree), -1, "", renderer, "text", 1, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree),
-1, "", renderer, "value", 2, "text", 3, NULL);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1);
gtk_container_add(GTK_CONTAINER(sw), serverstats_tree);
gtk_grid_attach(GTK_GRID(table), sw, 0, i, 2, 1);
i++;
gtk_widget_show_all(sw);
}
/**
* Add table
*/
gtk_box_pack_start(GTK_BOX(serverstats_vbox), table, TRUE, TRUE, 0);
/* maintain my own reference to the widget, so it won't get destroyed removing
* from view
*/
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(serverstats_sw), serverstats_event);
gtk_widget_show(serverstats_vbox);
gtk_widget_show(serverstats_event);
gtk_widget_show(serverstats_sw);
g_object_ref_sink(serverstats_sw);
}
/*--------------------------------------------------------------------------*/
static void
add_downloading_page( GnomeDruid *wdruid, GdkPixbuf *logo )
{
GtkWidget *wpage, *wvbox, *wvbox2, *wvbox3, *wvbox4;
GtkWidget *whbox2, *whbox3, *whbox4;
GtkWidget *wlabel1, *wlabel2, *wframe;
GdkColor druid_bg_color = DRUID_BG_COLOR;
GdkColor druid_title_color = DRUID_TITLE_COLOR;
gb_debug (DEBUG_UPDATE, "START");
wpage = gnome_druid_page_standard_new_with_vals (_("Downloading..."),
logo,
NULL);
gnome_druid_page_standard_set_background(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_bg_color);
gnome_druid_page_standard_set_logo_background(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_bg_color);
gnome_druid_page_standard_set_title_foreground(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_title_color);
gnome_druid_append_page( wdruid, GNOME_DRUID_PAGE(wpage) );
wvbox = GNOME_DRUID_PAGE_STANDARD(wpage)->vbox;
wvbox2 = gtk_vbox_new( FALSE, 10 );
gtk_container_set_border_width( GTK_CONTAINER(wvbox2), 20 );
gtk_box_pack_start( GTK_BOX(wvbox), wvbox2, TRUE, FALSE, 0 );
wlabel1 = gtk_label_new( _("Please wait while GBonds downloads new redemption data.") );
gtk_box_pack_start( GTK_BOX(wvbox2), wlabel1, FALSE, TRUE, 0 );
wframe = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(wvbox2), wframe, FALSE, TRUE, 0 );
whbox2 = gtk_hbox_new( FALSE, 0 );
gtk_container_set_border_width( GTK_CONTAINER(whbox2), 5 );
gtk_container_add( GTK_CONTAINER(wframe), whbox2 );
status_label = gtk_label_new( _("Status") );
gtk_label_set_justify( GTK_LABEL(status_label), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox2), status_label, FALSE, TRUE, 0 );
wvbox3 = gtk_vbox_new( FALSE, 2 );
gtk_box_pack_start( GTK_BOX(wvbox2), wvbox3, TRUE, FALSE, 0 );
whbox3 = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX(wvbox3), whbox3, FALSE, TRUE, 0 );
file_label = gtk_label_new( _("File") );
gtk_label_set_justify( GTK_LABEL(file_label), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox3), file_label, FALSE, TRUE, 0 );
file_progress = gtk_progress_bar_new();
gtk_progress_bar_set_text( GTK_PROGRESS_BAR(file_progress), "" );
gtk_box_pack_start( GTK_BOX(wvbox3), file_progress, FALSE, TRUE, 0 );
wvbox4 = gtk_vbox_new( FALSE, 2 );
gtk_box_pack_start( GTK_BOX(wvbox2), wvbox4, TRUE, FALSE, 0 );
whbox4 = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX(wvbox4), whbox4, FALSE, TRUE, 0 );
wlabel2 = gtk_label_new( _("Total") );
gtk_label_set_justify( GTK_LABEL(wlabel2), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox4), wlabel2, FALSE, TRUE, 0 );
total_progress = gtk_progress_bar_new();
gtk_progress_bar_set_text( GTK_PROGRESS_BAR(total_progress), "" );
gtk_box_pack_start( GTK_BOX(wvbox4), total_progress, FALSE, TRUE, 0 );
g_signal_connect_after( G_OBJECT(wpage), "prepare",
G_CALLBACK(prepare_downloading_page), NULL );
gb_debug (DEBUG_UPDATE, "END");
}
static GtkWidget *
csm_get_dialog (CsmDialogLogoutType type,
GdkScreen *screen,
guint32 activate_time)
{
CsmLogoutDialog *logout_dialog;
GtkWidget *dialog_image;
GtkWidget *hbox;
const char *primary_text;
const char *icon_name;
if (current_dialog != NULL) {
gtk_widget_destroy (GTK_WIDGET (current_dialog));
}
logout_dialog = g_object_new (CSM_TYPE_LOGOUT_DIALOG, NULL);
current_dialog = logout_dialog;
gtk_window_set_title (GTK_WINDOW (logout_dialog), _("Session"));
logout_dialog->priv->type = type;
GSettings *settings = g_settings_new (SESSION_SCHEMA);
logout_dialog->priv->delay_toggle = g_settings_get_boolean (settings, KEY_TOGGLE_DELAY);
logout_dialog->priv->delay = g_settings_get_int (settings, KEY_DELAY);
icon_name = NULL;
primary_text = NULL;
switch (type) {
case CSM_DIALOG_LOGOUT_TYPE_LOGOUT:
icon_name = CSM_ICON_LOGOUT;
primary_text = _("Log out of this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_LOGOUT;
if (csm_logout_supports_switch_user (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Switch User"),
CSM_LOGOUT_RESPONSE_SWITCH_USER);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Log Out"),
CSM_LOGOUT_RESPONSE_LOGOUT);
break;
case CSM_DIALOG_LOGOUT_TYPE_SHUTDOWN:
icon_name = CSM_ICON_SHUTDOWN;
primary_text = _("Shut down this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_SHUTDOWN;
if (csm_logout_supports_system_suspend (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("S_uspend"),
CSM_LOGOUT_RESPONSE_SLEEP);
}
if (csm_logout_supports_system_hibernate (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Hibernate"),
CSM_LOGOUT_RESPONSE_HIBERNATE);
}
if (csm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
CSM_LOGOUT_RESPONSE_REBOOT);
}
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
if (csm_logout_supports_shutdown (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Shut Down"),
CSM_LOGOUT_RESPONSE_SHUTDOWN);
}
break;
case CSM_DIALOG_LOGOUT_TYPE_REBOOT:
icon_name = CSM_ICON_SHUTDOWN;
primary_text = _("Restart this system now?");
logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_REBOOT;
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
if (csm_logout_supports_reboot (logout_dialog)) {
gtk_dialog_add_button (GTK_DIALOG (logout_dialog),
_("_Restart"),
CSM_LOGOUT_RESPONSE_REBOOT);
}
break;
default:
g_assert_not_reached ();
}
dialog_image = gtk_message_dialog_get_image (GTK_MESSAGE_DIALOG (logout_dialog));
if (logout_dialog->priv->delay_toggle) {
hbox = gtk_box_new (FALSE, 0);
logout_dialog->priv->progressbar = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (logout_dialog->priv->progressbar), 1.0);
gtk_box_pack_start (GTK_BOX (hbox),
logout_dialog->priv->progressbar,
TRUE, TRUE, 12);
gtk_widget_show_all (hbox);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (logout_dialog))), hbox);
}
gtk_image_set_from_icon_name (GTK_IMAGE (dialog_image),
icon_name, GTK_ICON_SIZE_DIALOG);
gtk_window_set_icon_name (GTK_WINDOW (logout_dialog), icon_name);
gtk_window_set_position (GTK_WINDOW (logout_dialog), GTK_WIN_POS_CENTER);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (logout_dialog), primary_text);
gtk_dialog_set_default_response (GTK_DIALOG (logout_dialog),
logout_dialog->priv->default_response);
gtk_window_set_screen (GTK_WINDOW (logout_dialog), screen);
g_signal_connect (logout_dialog, "show", G_CALLBACK (on_show), NULL);
g_object_unref(settings);
return GTK_WIDGET (logout_dialog);
}
gint InsaneBumpDialog(GimpDrawable *drawable,
const gchar *szBinary,
PlugInVals *vals)
{
/** Adding the preview area for the second release*/
GtkWidget *hbox;
GtkWidget *table;
hbox = NULL;
if(_active != 'x') return 2;
copyPlugInVals(vals, &local_vals);
gimp_ui_init(szBinary, TRUE);
dialog = gimp_dialog_new(NAME_AND_VERSION, szBinary,
0, 0, gimp_standard_help_func, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL,
GTK_STOCK_EXECUTE, GTK_RESPONSE_OK,
NULL);
gtk_signal_connect(GTK_OBJECT(dialog), "response",
GTK_SIGNAL_FUNC(insanebump_dialog_response),
0);
gtk_signal_connect(GTK_OBJECT(dialog), "destroy",
GTK_SIGNAL_FUNC(do_cleanup),
0);
hbox = gtk_hbox_new(0, 8);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),hbox, 1, 1, 0);
gtk_widget_show(hbox);
/** Adding the preview area for the second release. */
/**
* Create the Preview area.
*/
/** Creates a new vbox put into hbox */
CreateLeftPreviewFrames(hbox);
/** Creates a new vbox put into hbox */
CreateRightPreviewToggleButton(hbox);
/**
* Create a table to place all the right hand items into.
* Really could just be a horizontal box with all packed into.
* Copied other persons code.
*/
table = gtk_table_new(18, 1, 0);
gtk_widget_show(table);
gtk_box_pack_start(GTK_BOX(hbox), table, 1, 1, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 8);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
/**
* Remove Lighting
* [ No ]
* button
*/
g_gwRemoveLtgBtn = CreateToggleButton(table, 1, (GCallback *)&remlightbtn_clicked, "Remove Lighting", vals->RemoveLighting);
/**
* Upscale(HD)
* [ No ]
* button
*/
g_gwUpscaleBtn = CreateToggleButton(table, 2, (GCallback *)&upscale_HD_clicked, "Upscale(HD)", vals->Resizie);
/**
* Tile
* [*********Yes***********]
* button
*/
g_gwTileBtn = CreateToggleButton(table, 3, (GCallback *)&tile_clicked, "Tile", vals->Tile);
/**
* New Width(Integer Times larger)
* [2 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwWidthSpin = CreateInteger255SpinButton(table, 4, (GCallback *)&new_width_changed, "New Width(Integer Times larger)", vals->newWidth, 0);
/**
* Edge Enhaning Specular
* [*********Yes***********]
* button
*/
g_gwEdgeBtn = CreateToggleButton(table, 5, (GCallback *)&edge_enhancing_specular_clicked, "Edge Enhancing Specular", vals->EdgeSpecular);
/**
* Specular Definition(0-255)
* [64 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwSpecDefSpin = CreateInteger255SpinButton(table, 6, (GCallback *)&def_specular_changed, "Specular Definition(0-255)", vals->defSpecular, 0);
/**
* Depth(+/-)
* [20 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwDepthSpin = CreateInteger255SpinButton(table, 7, (GCallback *)&depth_changed, "Depth(+/-)", vals->Depth, 1);
/**
* Large Detail Size
* [3 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwLargeDSpin = CreateInteger255SpinButton(table, 8, (GCallback *)&large_detail_size_changed, "Large Detail Size", vals->LargeDetails, 0);
/**
* Medium Detail Intensity(%)
* [50 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwMediumDSpin = CreateInteger255SpinButton(table, 9, (GCallback *)&medium_detail_intensity_changed, "Medium Detail Intensity(%)", vals->MediumDetails, 0);
/**
* Small Detail Intensity(%)
* [50 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwSmallDSpin = CreateInteger255SpinButton(table, 10, (GCallback *)&small_detail_intensity_changed, "Small Detail Intensity(%)", vals->SmallDetails, 0);
/**
* Shape Recognition(%)
* [50 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwShapeSpin = CreateInteger255SpinButton(table, 11, (GCallback *)&shape_recognition_changed, "Shape Recognition(%)", vals->ShapeRecog, 0);
/**
* Smooth Step
* [*********Yes***********]
* button
*/
g_gwSmoothBtn = CreateToggleButton(table, 12, (GCallback *)&smooth_step_clicked, "Smooth Step", vals->smoothstep);
/**
* Noise
* [ No ]
* button
*/
g_gwNoiseBtn = CreateToggleButton(table, 13, (GCallback *)&noise_clicked, "Noise", vals->Noise);
/**
* Invert Height Map
* [ No ]
* button
*/
g_gwInvertBtn = CreateToggleButton(table, 14, (GCallback *)&invert_height_map_clicked, "Invert Height Map", vals->invh);
/**
* ao
* [50 ][^][v]
* edit control with spinner arrows at end of control
*/
g_gwAOSpin = CreateInteger255SpinButton(table, 15, (GCallback *)&ao_changed, "ao", vals->ao, 0);
progress = gtk_progress_bar_new();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.0);
table_attach_progress(GTK_TABLE(table), 0, 17, "Idle...", 0, 0.5,
progress, 1, 0);
gtk_widget_show(progress);
gtk_widget_show(dialog);
update_preview = 1;
gtk_timeout_add(300, idle_callback, drawable);
runme = 0;
dialog_is_init = 1 ;
_active = 'x';
gtk_main();
return(runme);
}
static GtkWidget *
create_window (int confirm_mode)
{
GtkWidget *w;
GtkWidget *win, *box;
GtkWidget *wvbox, *chbox, *bbox;
GtkAccelGroup *acc;
gchar *msg;
tooltips = gtk_tooltips_new ();
/* FIXME: check the grabbing code against the one we used with the
old gpg-agent */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
acc = gtk_accel_group_new ();
g_signal_connect (G_OBJECT (win), "delete_event",
G_CALLBACK (delete_event), NULL);
#if 0
g_signal_connect (G_OBJECT (win), "destroy", G_CALLBACK (gtk_main_quit),
NULL);
#endif
g_signal_connect (G_OBJECT (win), "size-request",
G_CALLBACK (constrain_size), NULL);
if (!confirm_mode)
{
if (pinentry->grab)
g_signal_connect (G_OBJECT (win),
"realize", G_CALLBACK (make_transient), NULL);
g_signal_connect (G_OBJECT (win),
pinentry->grab ? "map-event" : "focus-in-event",
G_CALLBACK (grab_keyboard), NULL);
g_signal_connect (G_OBJECT (win),
pinentry->grab ? "unmap-event" : "focus-out-event",
G_CALLBACK (ungrab_keyboard), NULL);
}
gtk_window_add_accel_group (GTK_WINDOW (win), acc);
wvbox = gtk_vbox_new (FALSE, HIG_LARGE * 2);
gtk_container_add (GTK_CONTAINER (win), wvbox);
gtk_container_set_border_width (GTK_CONTAINER (wvbox), HIG_LARGE);
chbox = gtk_hbox_new (FALSE, HIG_LARGE);
gtk_box_pack_start (GTK_BOX (wvbox), chbox, FALSE, FALSE, 0);
w = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (chbox), w, FALSE, FALSE, 0);
box = gtk_vbox_new (FALSE, HIG_SMALL);
gtk_box_pack_start (GTK_BOX (chbox), box, TRUE, TRUE, 0);
if (pinentry->title)
{
msg = pinentry_utf8_validate (pinentry->title);
gtk_window_set_title (GTK_WINDOW(win), msg);
}
if (pinentry->description)
{
msg = pinentry_utf8_validate (pinentry->description);
w = gtk_label_new (msg);
g_free (msg);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_box_pack_start (GTK_BOX (box), w, TRUE, FALSE, 0);
}
if (pinentry->error && !confirm_mode)
{
GdkColor color = { 0, 0xffff, 0, 0 };
msg = pinentry_utf8_validate (pinentry->error);
w = gtk_label_new (msg);
g_free (msg);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_box_pack_start (GTK_BOX (box), w, TRUE, FALSE, 0);
gtk_widget_modify_fg (w, GTK_STATE_NORMAL, &color);
}
qualitybar = NULL;
if (!confirm_mode)
{
GtkWidget* table = gtk_table_new (pinentry->quality_bar ? 2 : 1, 2,
FALSE);
gtk_box_pack_start (GTK_BOX (box), table, FALSE, FALSE, 0);
if (pinentry->prompt)
{
msg = pinentry_utf8_validate (pinentry->prompt);
w = gtk_label_new_with_mnemonic (msg);
g_free (msg);
gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), w, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 4, 0);
}
entry = gtk_secure_entry_new ();
gtk_widget_set_size_request (entry, 200, -1);
g_signal_connect (G_OBJECT (entry), "activate",
G_CALLBACK (enter_callback), entry);
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (changed_text_handler), entry);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_widget_grab_focus (entry);
gtk_widget_show (entry);
if (pinentry->quality_bar)
{
msg = pinentry_utf8_validate (pinentry->quality_bar);
w = gtk_label_new (msg);
g_free (msg);
gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), w, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 4, 0);
qualitybar = gtk_progress_bar_new();
gtk_widget_add_events (qualitybar,
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (qualitybar),
QUALITYBAR_EMPTY_TEXT);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (qualitybar), 0.0);
if (pinentry->quality_bar_tt)
gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), qualitybar,
pinentry->quality_bar_tt, "");
gtk_table_attach (GTK_TABLE (table), qualitybar, 1, 2, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
}
#ifdef ENABLE_ENHANCED
if (pinentry->enhanced)
{
GtkWidget *sbox = gtk_hbox_new (FALSE, HIG_SMALL);
gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);
w = gtk_label_new ("Forget secret after");
gtk_box_pack_start (GTK_BOX (sbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
time_out = gtk_spin_button_new
(GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, HUGE_VAL, 1, 60, 60)),
2, 0);
gtk_box_pack_start (GTK_BOX (sbox), time_out, FALSE, FALSE, 0);
gtk_widget_show (time_out);
w = gtk_label_new ("seconds");
gtk_box_pack_start (GTK_BOX (sbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
gtk_widget_show (sbox);
insure = gtk_check_button_new_with_label ("ask before giving out "
"secret");
gtk_box_pack_start (GTK_BOX (box), insure, FALSE, FALSE, 0);
gtk_widget_show (insure);
}
#endif
}
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (bbox), 6);
gtk_box_pack_start (GTK_BOX (wvbox), bbox, TRUE, FALSE, 0);
if (!pinentry->one_button)
{
if (pinentry->cancel)
{
msg = pinentry_utf8_validate (pinentry->cancel);
w = gtk_button_new_with_mnemonic (msg);
g_free (msg);
}
else
w = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_container_add (GTK_CONTAINER (bbox), w);
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (confirm_mode ? confirm_button_clicked
: button_clicked),
(gpointer) CONFIRM_CANCEL);
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
}
if (confirm_mode && !pinentry->one_button && pinentry->notok)
{
msg = pinentry_utf8_validate (pinentry->notok);
w = gtk_button_new_with_mnemonic (msg);
g_free (msg);
gtk_container_add (GTK_CONTAINER (bbox), w);
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (confirm_button_clicked),
(gpointer) CONFIRM_NOTOK);
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
}
if (pinentry->ok)
{
msg = pinentry_utf8_validate (pinentry->ok);
w = gtk_button_new_with_mnemonic (msg);
g_free (msg);
}
else
w = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_container_add (GTK_CONTAINER(bbox), w);
if (!confirm_mode)
{
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (button_clicked), "ok");
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
gtk_widget_grab_default (w);
g_signal_connect_object (G_OBJECT (entry), "focus_in_event",
G_CALLBACK (gtk_widget_grab_default),
G_OBJECT (w), 0);
}
else
{
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK(confirm_button_clicked),
(gpointer) CONFIRM_OK);
GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
}
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_show_all(win);
return win;
}
GtkWidget *
gimp_thumb_box_new (GimpContext *context)
{
GimpThumbBox *box;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *ebox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
gchar *str;
gint h, v;
GtkRequisition info_requisition;
GtkRequisition progress_requisition;
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
box = g_object_new (GIMP_TYPE_THUMB_BOX, NULL);
box->context = context;
ebox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), ebox);
gtk_widget_show (ebox);
g_signal_connect (ebox, "button-press-event",
G_CALLBACK (gimp_thumb_box_ebox_button_press),
box);
str = g_strdup_printf (_("Click to update preview\n"
"%s%sClick to force update even "
"if preview is up-to-date"),
gimp_get_mod_string (GDK_CONTROL_MASK),
gimp_get_mod_separator ());
gimp_help_set_help_data (ebox, str, NULL);
g_free (str);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (ebox), vbox);
gtk_widget_show (vbox);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
label = gtk_label_new_with_mnemonic (_("Pr_eview"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (button), label);
gtk_widget_show (label);
g_signal_connect (button, "button-press-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "button-release-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "enter-notify-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "leave-notify-event",
G_CALLBACK (gtk_true),
NULL);
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 2);
gtk_container_add (GTK_CONTAINER (vbox), vbox2);
gtk_widget_show (vbox2);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
box->imagefile = gimp_imagefile_new (context->gimp, NULL);
g_signal_connect (box->imagefile, "info-changed",
G_CALLBACK (gimp_thumb_box_imagefile_info_changed),
box);
g_signal_connect (box->imagefile->thumbnail, "notify::thumb-state",
G_CALLBACK (gimp_thumb_box_thumb_state_notify),
box);
gimp_view_renderer_get_frame_size (&h, &v);
box->preview = gimp_view_new (context,
GIMP_VIEWABLE (box->imagefile),
/* add padding for the shadow frame */
context->gimp->config->thumbnail_size +
MAX (h, v),
0, FALSE);
gtk_box_pack_start (GTK_BOX (hbox), box->preview, TRUE, FALSE, 2);
gtk_widget_show (box->preview);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), box->preview);
g_signal_connect (box->preview, "clicked",
G_CALLBACK (gimp_thumb_box_thumbnail_clicked),
box);
box->filename = gtk_label_new (_("No selection"));
gtk_label_set_ellipsize (GTK_LABEL (box->filename), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_justify (GTK_LABEL (box->filename), GTK_JUSTIFY_CENTER);
gimp_label_set_attributes (GTK_LABEL (box->filename),
PANGO_ATTR_STYLE, PANGO_STYLE_OBLIQUE,
-1);
gtk_box_pack_start (GTK_BOX (vbox2), box->filename, FALSE, FALSE, 0);
gtk_widget_show (box->filename);
box->info = gtk_label_new (" \n \n \n ");
gtk_misc_set_alignment (GTK_MISC (box->info), 0.5, 0.0);
gtk_label_set_justify (GTK_LABEL (box->info), GTK_JUSTIFY_CENTER);
gimp_label_set_attributes (GTK_LABEL (box->info),
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_box_pack_start (GTK_BOX (vbox2), box->info, FALSE, FALSE, 0);
gtk_widget_show (box->info);
box->progress = gtk_progress_bar_new ();
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "Fog");
gtk_box_pack_end (GTK_BOX (vbox2), box->progress, FALSE, FALSE, 0);
gtk_widget_set_no_show_all (box->progress, TRUE);
/* don't gtk_widget_show (box->progress); */
/* eek */
gtk_widget_size_request (box->info, &info_requisition);
gtk_widget_size_request (box->progress, &progress_requisition);
gtk_widget_set_size_request (box->info,
progress_requisition.width,
info_requisition.height);
gtk_widget_set_size_request (box->filename,
progress_requisition.width, -1);
gtk_widget_set_size_request (box->progress, -1,
progress_requisition.height);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "");
return GTK_WIDGET (box);
}
GtkWidget *bar_pane_gps_new(const gchar *id, const gchar *title, const gchar *map_id,
const gint zoom, const gdouble latitude, const gdouble longitude,
gboolean expanded, gint height)
{
PaneGPSData *pgd;
GtkWidget *vbox, *frame;
GtkWidget *gpswidget, *viewport;
GtkWidget *status, *state, *progress, *slider;
ChamplainLayer *layer;
ChamplainView *view;
const gchar *slider_list[] = {GTK_STOCK_ZOOM_IN, GTK_STOCK_ZOOM_OUT, NULL};
const gchar **slider_icons = slider_list;
pgd = g_new0(PaneGPSData, 1);
pgd->pane.pane_set_fd = bar_pane_gps_set_fd;
pgd->pane.pane_notify_selection = bar_pane_gps_notify_selection;
pgd->pane.pane_event = bar_pane_gps_event;
pgd->pane.pane_write_config = bar_pane_gps_write_config;
pgd->pane.title = bar_pane_expander_title(title);
pgd->pane.id = g_strdup(id);
pgd->pane.type = PANE_GPS;
pgd->pane.expanded = expanded;
pgd->height = height;
frame = gtk_frame_new(NULL);
vbox = gtk_vbox_new(FALSE, 0);
gpswidget = gtk_champlain_embed_new();
view = gtk_champlain_embed_get_view(GTK_CHAMPLAIN_EMBED(gpswidget));
gtk_box_pack_start(GTK_BOX(vbox), gpswidget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
status = gtk_hbox_new(FALSE,0);
slider = gtk_scale_button_new(GTK_ICON_SIZE_SMALL_TOOLBAR, 1, 17, 1, slider_icons);
gtk_widget_set_tooltip_text(slider, "Zoom");
gtk_scale_button_set_value(GTK_SCALE_BUTTON(slider), (gdouble)zoom);
progress = gtk_progress_bar_new();
state = gtk_label_new("");
gtk_label_set_justify(GTK_LABEL(state), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(slider), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(status), GTK_WIDGET(state), FALSE, FALSE, 5);
gtk_box_pack_end(GTK_BOX(status), GTK_WIDGET(progress), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox),GTK_WIDGET(status), FALSE, FALSE, 0);
layer = champlain_layer_new();
champlain_view_add_layer(view, layer);
pgd->icon_layer = layer;
pgd->gps_view = CLUTTER_ACTOR(view);
pgd->widget = frame;
pgd->progress = progress;
pgd->slider = slider;
pgd->state = state;
bar_pane_gps_set_map_source(pgd, map_id);
g_object_set(G_OBJECT(view), "scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
"zoom-level", zoom,
"keep-center-on-resize", TRUE,
/* This seems to be broken, https://bugzilla.gnome.org/show_bug.cgi?id=596419
"decel-rate", 1.0,
*/
"show-license", TRUE,
"zoom-on-double-click", FALSE,
"max-zoom-level", 17,
"min-zoom-level", 1,
NULL);
champlain_view_center_on(view, latitude, longitude);
pgd->centre_map_checked = TRUE;
g_object_set_data(G_OBJECT(pgd->widget), "pane_data", pgd);
g_signal_connect(G_OBJECT(pgd->widget), "destroy", G_CALLBACK(bar_pane_gps_destroy), pgd);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_widget_set_size_request(pgd->widget, -1, height);
clutter_set_motion_events_enabled(TRUE);
g_signal_connect(G_OBJECT(gpswidget), "button_press_event", G_CALLBACK(bar_pane_gps_map_keypress_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::state", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(pgd->gps_view, "notify::zoom-level", G_CALLBACK(bar_pane_gps_view_state_changed_cb), pgd);
g_signal_connect(G_OBJECT(slider), "value-changed", G_CALLBACK(bar_pane_gps_slider_changed_cb), pgd);
file_data_register_notify_func(bar_pane_gps_notify_cb, pgd, NOTIFY_PRIORITY_LOW);
pgd->create_markers_id = 0;
pgd->enable_markers_checked = TRUE;
pgd->centre_map_checked = TRUE;
return pgd->widget;
}
int uosrbsw_r(class uosrbsw_data *datark,GtkWidget *wpredok)
{
char strsql[512];
iceb_u_str repl;
class uosrbsw_r_data data;
data.rk=datark;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
sprintf(strsql,"%s %s",name_system,gettext("Расчёт балансовой стоимости по мат.ответственным и счетам учёта"));
//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(uosrbsw_r_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, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
data.label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);
repl.plus(gettext("Расчёт балансовой стоимости по мат.ответственным и счетам учёта"));
sprintf(strsql,"%s:%s %s\n",gettext("База данных"),imabaz,organ);
repl.ps_plus(strsql);
GtkWidget *label=gtk_label_new(repl.ravno_toutf());
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),450,300);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
//PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 12");
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);
data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));
GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
//gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(uosrbsw_r_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);
gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_widget_show_all(data.window);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
//gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_idle_add((GtkFunction)uosrbsw_r1,&data);
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.voz);
}
gint
main (gint argc,
gchar **argv)
{
GCancellable *cancellable;
gchar *file = NULL, *oper = NULL;
const gchar *title = NULL;
gint ii;
GError *error = NULL;
#ifdef G_OS_WIN32
/* Reduce risks */
{
typedef BOOL (WINAPI *t_SetDllDirectoryA) (LPCSTR lpPathName);
t_SetDllDirectoryA p_SetDllDirectoryA;
p_SetDllDirectoryA = GetProcAddress (
GetModuleHandle ("kernel32.dll"),
"SetDllDirectoryA");
if (p_SetDllDirectoryA != NULL)
p_SetDllDirectoryA ("");
}
#ifndef _WIN64
{
typedef BOOL (WINAPI *t_SetProcessDEPPolicy) (DWORD dwFlags);
t_SetProcessDEPPolicy p_SetProcessDEPPolicy;
p_SetProcessDEPPolicy = GetProcAddress (
GetModuleHandle ("kernel32.dll"),
"SetProcessDEPPolicy");
if (p_SetProcessDEPPolicy)
p_SetProcessDEPPolicy (
PROCESS_DEP_ENABLE |
PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION);
}
#endif
#endif
bindtextdomain (GETTEXT_PACKAGE, EVOLUTION_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_init_with_args (
&argc, &argv, NULL, options, GETTEXT_PACKAGE, &error);
if (error != NULL) {
g_printerr ("%s\n", error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
if (opt_remaining != NULL) {
for (ii = 0; ii < g_strv_length (opt_remaining); ii++) {
if (backup_op) {
title = _("Evolution Back Up");
oper = _("Backing up to the folder %s");
d(g_message ("Backing up to the folder %s", (gchar *) opt_remaining[ii]));
bk_file = g_strdup ((gchar *) opt_remaining[ii]);
file = bk_file;
} else if (restore_op) {
title = _("Evolution Restore");
oper = _("Restoring from the folder %s");
d(g_message ("Restoring from the folder %s", (gchar *) opt_remaining[ii]));
res_file = g_strdup ((gchar *) opt_remaining[ii]);
file = res_file;
} else if (check_op) {
d(g_message ("Checking %s", (gchar *) opt_remaining[ii]));
chk_file = g_strdup ((gchar *) opt_remaining[ii]);
}
}
}
cancellable = g_cancellable_new ();
if (gui_arg && !check_op) {
GtkWidget *widget, *container;
GtkWidget *action_area;
GtkWidget *content_area;
const gchar *txt, *txt2;
gchar *str = NULL;
gchar *markup;
gtk_window_set_default_icon_name ("evolution");
/* Backup / Restore only can have GUI.
* We should restrict the rest. */
progress_dialog = gtk_dialog_new_with_buttons (
title, NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
gtk_container_set_border_width (
GTK_CONTAINER (progress_dialog), 12);
gtk_window_set_default_size (
GTK_WINDOW (progress_dialog), 450, 120);
action_area = gtk_dialog_get_action_area (
GTK_DIALOG (progress_dialog));
content_area = gtk_dialog_get_content_area (
GTK_DIALOG (progress_dialog));
/* Override GtkDialog defaults */
gtk_box_set_spacing (GTK_BOX (content_area), 12);
gtk_container_set_border_width (GTK_CONTAINER (content_area), 0);
gtk_box_set_spacing (GTK_BOX (action_area), 12);
gtk_container_set_border_width (GTK_CONTAINER (action_area), 0);
if (oper && file)
str = g_strdup_printf (oper, file);
container = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (container), 12);
gtk_table_set_row_spacings (GTK_TABLE (container), 12);
gtk_widget_show (container);
gtk_box_pack_start (
GTK_BOX (content_area), container, FALSE, TRUE, 0);
widget = gtk_image_new_from_stock (
GTK_STOCK_COPY, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
gtk_widget_show (widget);
gtk_table_attach (
GTK_TABLE (container), widget, 0, 1, 0, 3,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
if (backup_op) {
txt = _("Backing up Evolution Data");
txt2 = _("Please wait while Evolution is backing up your data.");
} else if (restore_op) {
txt = _("Restoring Evolution Data");
txt2 = _("Please wait while Evolution is restoring your data.");
} else {
g_return_val_if_reached (EXIT_FAILURE);
}
markup = g_markup_printf_escaped ("<b><big>%s</big></b>", txt);
widget = gtk_label_new (markup);
gtk_label_set_line_wrap (GTK_LABEL (widget), FALSE);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
gtk_widget_show (widget);
g_free (markup);
gtk_table_attach (
GTK_TABLE (container), widget, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
markup = g_strconcat (
txt2, " ", _("This may take a while depending "
"on the amount of data in your account."), NULL);
widget = gtk_label_new (markup);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_widget_show (widget);
g_free (markup);
gtk_table_attach (
GTK_TABLE (container), widget, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
pbar = gtk_progress_bar_new ();
if (str != NULL) {
markup = g_markup_printf_escaped ("<i>%s</i>", str);
widget = gtk_label_new (markup);
gtk_label_set_use_markup (GTK_LABEL (widget), TRUE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
g_free (markup);
g_free (str);
gtk_table_attach (
GTK_TABLE (container), widget, 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_set_row_spacing (GTK_TABLE (container), 2, 6);
gtk_table_attach (
GTK_TABLE (container), pbar, 1, 2, 3, 4,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
} else
gtk_table_attach (
GTK_TABLE (container), pbar, 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect (
progress_dialog, "response",
G_CALLBACK (dlg_response), cancellable);
gtk_widget_show_all (progress_dialog);
} else if (check_op) {
/* For sanity we don't need gui */
check (chk_file, NULL);
exit (result == 0 ? 0 : 1);
}
if (gui_arg)
g_timeout_add_full (
G_PRIORITY_DEFAULT, 50,
(GSourceFunc) pbar_update,
g_object_ref (cancellable),
(GDestroyNotify) g_object_unref);
g_io_scheduler_push_job (
start_job, NULL,
(GDestroyNotify) NULL,
G_PRIORITY_DEFAULT, cancellable);
gtk_main ();
g_object_unref (cancellable);
return result;
}
void gui_create_search_sidebar(void)
{
GtkWidget *vbox1;
GtkWidget *vbox90;
GtkWidget *vbox5;
GtkWidget *frame2;
GtkWidget *vbox2;
GtkWidget *frame3;
GtkWidget *vbox3;
GtkWidget *frame4;
GtkWidget *vbox4;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *scrolledwindow_search;
GtkWidget *viewport_search;
gchar *header;
//GtkListStore *store;
//ss = &sss;
scrolledwindow_search = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow_search);
gtk_container_add(GTK_CONTAINER(widgets.notebook_sidebar),
scrolledwindow_search);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow_search),
settings.shadow_type);
gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow_search), 2);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow_search),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
viewport_search = gtk_viewport_new(NULL, NULL);
gtk_widget_show(viewport_search);
gtk_container_add(GTK_CONTAINER(scrolledwindow_search),
viewport_search);
UI_VBOX(vbox1, FALSE, 4);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(viewport_search), vbox1);
UI_VBOX(vbox5, FALSE, 0);
gtk_widget_show(vbox5);
gtk_box_pack_start(GTK_BOX(vbox1), vbox5, FALSE, TRUE, 0);
/* text entry */
ss.entrySearch = gtk_entry_new();
gtk_widget_show(ss.entrySearch);
gtk_box_pack_start(GTK_BOX(vbox5), ss.entrySearch, TRUE, TRUE, 0);
gtk_widget_set_size_request(ss.entrySearch, 130, -1);
;
/* find button */
#ifdef HAVE_GTK_310
remember_search =
gtk_button_new_from_icon_name("edit-find-symbolic",
GTK_ICON_SIZE_BUTTON);
#else
remember_search = gtk_button_new_from_stock(GTK_STOCK_FIND);
#endif
gtk_widget_show(remember_search);
gtk_box_pack_start(GTK_BOX(vbox5), remember_search, TRUE, FALSE,
0);
gtk_widget_set_tooltip_text(remember_search,
_("This is an inclusive (\"AND\") search:\nFind matches showing all words."));
gtk_button_set_relief(GTK_BUTTON(remember_search),
GTK_RELIEF_HALF);
/* progress bar */
ss.progressbar_search = gtk_progress_bar_new();
gtk_widget_show(ss.progressbar_search);
gtk_box_pack_start(GTK_BOX(vbox5), ss.progressbar_search, FALSE,
TRUE, 0);
/* button to open advanced search */
ss.advanced_search =
gtk_button_new_with_mnemonic(_("_Open Advanced Search"));
gtk_widget_show(ss.advanced_search);
gtk_box_pack_start(GTK_BOX(vbox5), ss.advanced_search, TRUE, FALSE,
0);
gtk_widget_set_tooltip_text(ss.advanced_search,
_("Open the separate Advanced Search dialog."));
gtk_button_set_relief(GTK_BUTTON(ss.advanced_search),
GTK_RELIEF_HALF);
ss.frame_module = gtk_frame_new(NULL);
gtk_widget_show(ss.frame_module);
gtk_box_pack_start(GTK_BOX(vbox1), ss.frame_module, FALSE, FALSE,
0);
gtk_container_set_border_width(GTK_CONTAINER(ss.frame_module), 2);
gtk_frame_set_shadow_type(GTK_FRAME(ss.frame_module),
GTK_SHADOW_NONE);
label1 = gtk_label_new(NULL);
header =
g_strdup_printf("<span weight=\"bold\">%s</span>",
_("Search Module"));
gtk_label_set_markup(GTK_LABEL(label1), header);
g_free(header);
gtk_widget_show(label1);
gtk_frame_set_label_widget(GTK_FRAME(ss.frame_module), label1);
UI_VBOX(vbox90, FALSE, 0);
gtk_widget_show(vbox90);
gtk_container_add(GTK_CONTAINER(ss.frame_module), vbox90);
gtk_container_set_border_width(GTK_CONTAINER(vbox90), 4);
ss.radiobutton_search_text =
gtk_radio_button_new_with_label(NULL, _("Bible"));
gtk_widget_show(ss.radiobutton_search_text);
gtk_widget_set_size_request(ss.radiobutton_search_text, -1, 20);
gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_text,
FALSE, FALSE, 0);
ss.radiobutton_search_comm =
gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.radiobutton_search_text),
_("Commentary"));
gtk_widget_show(ss.radiobutton_search_comm);
gtk_widget_set_size_request(ss.radiobutton_search_comm, -1, 20);
gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_comm,
FALSE, FALSE, 0);
frame2 = gtk_frame_new(NULL);
gtk_widget_show(frame2);
gtk_box_pack_start(GTK_BOX(vbox1), frame2, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame2), 2);
gtk_frame_set_shadow_type(GTK_FRAME(frame2), GTK_SHADOW_NONE);
label1 = gtk_label_new(NULL);
header =
g_strdup_printf("<span weight=\"bold\">%s</span>",
_("Search Type"));
gtk_label_set_markup(GTK_LABEL(label1), header);
g_free(header);
gtk_widget_show(label1);
gtk_frame_set_label_widget(GTK_FRAME(frame2), label1);
UI_VBOX(vbox2, TRUE, 0);
gtk_widget_show(vbox2);
gtk_container_add(GTK_CONTAINER(frame2), vbox2);
gtk_container_set_border_width(GTK_CONTAINER(vbox2), 4);
ss.rbMultiword =
gtk_radio_button_new_with_label(NULL, _("Optimized (\"Lucene\")"));
gtk_widget_show(ss.rbMultiword);
gtk_box_pack_start(GTK_BOX(vbox2), ss.rbMultiword, FALSE,
FALSE, 0);
gtk_widget_set_size_request(ss.rbMultiword, -1, 20);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbMultiword), TRUE);
ss.rbRegExp =
gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword),
_("Regular expression"));
gtk_widget_show(ss.rbRegExp);
gtk_box_pack_start(GTK_BOX(vbox2), ss.rbRegExp, FALSE, FALSE, 0);
gtk_widget_set_size_request(ss.rbRegExp, -1, 20);
ss.rbPhraseSearch =
gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword),
_("Exact phrase"));
gtk_widget_show(ss.rbPhraseSearch);
gtk_box_pack_start(GTK_BOX(vbox2), ss.rbPhraseSearch,
FALSE, FALSE, 0);
gtk_widget_set_size_request(ss.rbPhraseSearch, -1, 20);
frame3 = gtk_frame_new(NULL);
gtk_widget_show(frame3);
gtk_box_pack_start(GTK_BOX(vbox1), frame3, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame3), 2);
gtk_frame_set_shadow_type(GTK_FRAME(frame3), GTK_SHADOW_NONE);
label1 = gtk_label_new(NULL);
header =
g_strdup_printf("<span weight=\"bold\">%s</span>",
_("Search Options"));
gtk_label_set_markup(GTK_LABEL(label1), header);
g_free(header);
gtk_widget_show(label1);
gtk_frame_set_label_widget(GTK_FRAME(frame3), label1);
UI_VBOX(vbox3, FALSE, 0);
gtk_widget_show(vbox3);
gtk_container_add(GTK_CONTAINER(frame3), vbox3);
gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
ss.ckbCaseSensitive =
gtk_check_button_new_with_label(_("Match case"));
gtk_widget_show(ss.ckbCaseSensitive);
gtk_box_pack_start(GTK_BOX(vbox3), ss.ckbCaseSensitive, FALSE,
FALSE, 0);
gtk_widget_set_size_request(ss.ckbCaseSensitive, -1, 20);
frame4 = gtk_frame_new(NULL);
gtk_widget_show(frame4);
gtk_box_pack_start(GTK_BOX(vbox1), frame4, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame4), 2);
gtk_frame_set_shadow_type(GTK_FRAME(frame4), GTK_SHADOW_NONE);
label1 = gtk_label_new(NULL);
header =
g_strdup_printf("<span weight=\"bold\">%s</span>",
_("Search Scope"));
gtk_label_set_markup(GTK_LABEL(label1), header);
g_free(header);
gtk_widget_show(label1);
gtk_frame_set_label_widget(GTK_FRAME(frame4), label1);
UI_VBOX(vbox4, TRUE, 0);
gtk_widget_show(vbox4);
gtk_container_add(GTK_CONTAINER(frame4), vbox4);
gtk_container_set_border_width(GTK_CONTAINER(vbox4), 4);
ss.rbNoScope =
gtk_radio_button_new_with_label(NULL, _("No scope"));
gtk_widget_show(ss.rbNoScope);
gtk_box_pack_start(GTK_BOX(vbox4), ss.rbNoScope, FALSE, FALSE, 0);
gtk_widget_set_size_request(ss.rbNoScope, -1, 20);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbNoScope),
TRUE);
ss.rrbUseBounds =
gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope),
_("Use bounds"));
gtk_widget_show(ss.rrbUseBounds);
gtk_box_pack_start(GTK_BOX(vbox4), ss.rrbUseBounds, FALSE,
FALSE, 0);
gtk_widget_set_size_request(ss.rrbUseBounds, -1, 20);
ss.rbLastSearch =
gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope),
_("Last search"));
gtk_widget_show(ss.rbLastSearch);
gtk_box_pack_start(GTK_BOX(vbox4), ss.rbLastSearch, FALSE,
FALSE, 0);
gtk_widget_set_size_request(ss.rbLastSearch, -1, 20);
ss.frame5 = gtk_frame_new(NULL);
gtk_widget_show(ss.frame5);
gtk_box_pack_start(GTK_BOX(vbox1), ss.frame5, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(ss.frame5), 2);
gtk_widget_hide(ss.frame5);
gtk_frame_set_shadow_type(GTK_FRAME(ss.frame5), GTK_SHADOW_NONE);
label1 = gtk_label_new(NULL);
header =
g_strdup_printf("<span weight=\"bold\">%s</span>",
_("Bounds"));
gtk_label_set_markup(GTK_LABEL(label1), header);
g_free(header);
gtk_widget_show(label1);
gtk_frame_set_label_widget(GTK_FRAME(ss.frame5), label1);
#ifdef HAVE_GTK_34
table1 = gtk_grid_new();
gtk_widget_show(table1);
gtk_container_add(GTK_CONTAINER(ss.frame5), table1);
gtk_grid_set_row_spacing(GTK_GRID(table1), 3);
gtk_grid_set_column_spacing(GTK_GRID(table1), 3);
gtk_container_set_border_width(GTK_CONTAINER(table1), 8);
label1 = gtk_label_new(_("Lower"));
gtk_widget_show(label1);
gtk_grid_attach(GTK_GRID(table1), label1, 0, 0, 1, 1);
#ifndef HAVE_GTK_310
gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5);
#endif
ss.entryLower = gtk_combo_box_text_new_with_entry();
gtk_widget_show(ss.entryLower);
gtk_grid_attach(GTK_GRID(table1), ss.entryLower, 1, 0, 1, 1);
gtk_widget_set_size_request(ss.entryLower, 114, 22);
label2 = gtk_label_new(_("Upper"));
gtk_widget_show(label2);
gtk_grid_attach(GTK_GRID(table1), label2, 0, 1, 1, 1);
#ifndef HAVE_GTK_310
gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5);
#endif
ss.entryUpper = gtk_combo_box_text_new_with_entry();
gtk_widget_show(ss.entryUpper);
gtk_grid_attach(GTK_GRID(table1), ss.entryUpper, 1, 1, 1, 1);
gtk_widget_set_size_request(ss.entryUpper, 114, 22);
#else
table1 = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table1);
gtk_container_add(GTK_CONTAINER(ss.frame5), table1);
gtk_table_set_row_spacings(GTK_TABLE(table1), 3);
gtk_table_set_col_spacings(GTK_TABLE(table1), 3);
gtk_container_set_border_width(GTK_CONTAINER(table1), 8);
label1 = gtk_label_new(_("Lower"));
gtk_widget_show(label1);
gtk_table_attach(GTK_TABLE(table1), label1, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5);
label2 = gtk_label_new(_("Upper"));
gtk_widget_show(label2);
gtk_table_attach(GTK_TABLE(table1), label2, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5);
#ifdef HAVE_GTK_224
ss.entryLower = gtk_combo_box_text_new_with_entry();
#else
ss.entryLower = gtk_combo_box_entry_new_text();
#endif
gtk_widget_show(ss.entryLower);
gtk_table_attach(GTK_TABLE(table1), ss.entryLower, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_widget_set_size_request(ss.entryLower, 114, 22);
#ifdef HAVE_GTK_224
ss.entryUpper = gtk_combo_box_text_new_with_entry();
#else
ss.entryUpper = gtk_combo_box_entry_new_text();
#endif
gtk_widget_show(ss.entryUpper);
gtk_table_attach(GTK_TABLE(table1), ss.entryUpper, 1, 2, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_widget_set_size_request(ss.entryUpper, 114, 22);
#endif
g_signal_connect(G_OBJECT(ss.rrbUseBounds),
"toggled",
G_CALLBACK(on_rrbUseBounds_toggled), NULL);
g_signal_connect(G_OBJECT(remember_search), "clicked",
G_CALLBACK(on_search_button_clicked), NULL);
g_signal_connect(G_OBJECT(ss.entrySearch), "activate",
G_CALLBACK(on_search_button_clicked), NULL);
g_signal_connect(G_OBJECT(ss.advanced_search), "clicked",
G_CALLBACK(main_open_search_dialog), NULL);
/* prep for toggle case sensitive availability per optimized */
g_signal_connect(ss.rbMultiword, "toggled",
G_CALLBACK(sidebar_optimized_toggled), NULL);
/* initialize it off */
gtk_widget_set_sensitive(ss.ckbCaseSensitive, FALSE);
}
