void CreateInfoDialog(InfoDialog * infoDialog, GtkWidget * window)
{
GtkWidget *hbox, *pixmap;
infoDialog->dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(infoDialog->dialog), _("Info"));
gtk_window_set_modal(GTK_WINDOW(infoDialog->dialog), TRUE);
gtk_window_position(GTK_WINDOW(infoDialog->dialog), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(infoDialog->dialog), 5);
gtk_signal_connect(GTK_OBJECT(infoDialog->dialog), "delete_event",
GTK_SIGNAL_FUNC(DeleteEvent), NULL);
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(infoDialog->dialog)->vbox), hbox);
gtk_widget_show_now(hbox);
if (window) {
pixmap = NewPixmap(info_xpm, window->window, &window->style->bg[GTK_STATE_NORMAL]);
gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, FALSE, 10);
gtk_widget_show_now(pixmap);
}
infoDialog->text = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), infoDialog->text, FALSE, FALSE, 10);
gtk_widget_show_now(infoDialog->text);
}
void CreateErrorDialog(ErrorDialog * errorDialog, GtkWidget * window)
{
GtkWidget *button, *hbox, *pixmap;
errorDialog->dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(errorDialog->dialog), _("Error"));
gtk_window_set_modal(GTK_WINDOW(errorDialog->dialog), TRUE);
gtk_window_position(GTK_WINDOW(errorDialog->dialog), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(errorDialog->dialog), 5);
gtk_signal_connect(GTK_OBJECT(errorDialog->dialog), "delete_event",
GTK_SIGNAL_FUNC(DeleteEvent), NULL);
button = gtk_button_new_with_label(_("Cancel"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(errorDialog->dialog)->action_area),
button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(CancelDialog), (gpointer) errorDialog->dialog);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
gtk_widget_show(button);
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(errorDialog->dialog)->vbox), hbox);
gtk_widget_show(hbox);
if (window) {
pixmap = NewPixmap(stop_xpm, window->window, &window->style->bg[GTK_STATE_NORMAL]);
gtk_box_pack_start(GTK_BOX(hbox), pixmap, FALSE, FALSE, 10);
gtk_widget_show(pixmap);
}
errorDialog->text = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), errorDialog->text, FALSE, FALSE, 10);
gtk_widget_show(errorDialog->text);
}
void calendar_select_font( GtkWidget *button,
CalendarData *calendar )
{
GtkWidget *window;
if (!calendar->font_dialog) {
window = gtk_font_selection_dialog_new ("Font Selection Dialog");
g_return_if_fail(GTK_IS_FONT_SELECTION_DIALOG(window));
calendar->font_dialog = window;
gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&calendar->font_dialog);
gtk_signal_connect (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->ok_button),
"clicked", GTK_SIGNAL_FUNC(calendar_font_selection_ok),
calendar);
gtk_signal_connect_object (GTK_OBJECT (GTK_FONT_SELECTION_DIALOG (window)->cancel_button),
"clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (calendar->font_dialog));
}
window=calendar->font_dialog;
if (!gtk_widget_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
}
GtkWidget*
file_selection_create (const gchar *title,
void(*clickfunc)())
{
GtkWidget *window;
window = gtk_file_selection_new (title);
gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
gtk_signal_connect(GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_signal_connect(GTK_OBJECT (GTK_FILE_SELECTION (window)->ok_button),
"clicked", GTK_SIGNAL_FUNC(clickfunc),
window);
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(gtk_widget_hide),
window);
gtk_signal_connect_object(GTK_OBJECT (GTK_FILE_SELECTION (window)->cancel_button),
"clicked", GTK_SIGNAL_FUNC(gtk_widget_hide),
GTK_OBJECT (window));
return window;
}
// Set file as specified by dialog
// data is *fullPath
void pt_find_file( GtkWidget *widget, gpointer data )
{
GtkWidget *filew;
static wdata wd;
filew = gtk_file_selection_new ("Find/Set file...");
gtk_window_position (GTK_WINDOW (filew), GTK_WIN_POS_MOUSE);
wd.data = data;
wd.widg = filew;
/* Connect the ok_button to file_ok_sel function */
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
"clicked", (GtkSignalFunc) pt_set_file, (gpointer)&wd );
/* Connect the cancel_button to destroy the widget */
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(filew)->cancel_button),
"clicked", (GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (GTK_WINDOW (filew)));
gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew), "");
gtk_widget_show (filew);
}
GenericDialog *
file_util_gen_dlg (const gchar * title, const gchar * message,
const gchar * wmclass, const gchar * wmsubclass,
gint auto_close, void (*cb_cancel) (GenericDialog *,
gpointer),
gpointer data)
{
GenericDialog *gd;
gd = generic_dialog_new (title, message, wmclass, wmsubclass, auto_close,
cb_cancel, data);
if (place_dialogs_under_mouse)
gtk_window_position (GTK_WINDOW (gd->dialog), GTK_WIN_POS_MOUSE);
else if (place_dialogs_center)
gtk_window_position (GTK_WINDOW (gd->dialog), GTK_WIN_POS_CENTER);
return gd;
}
FileDialog *
file_util_file_dlg (const gchar * title, const gchar * message,
const gchar * wmclass, const gchar * wmsubclass,
void (*cb_cancel) (FileDialog *, gpointer), gpointer data)
{
FileDialog *fd;
fd = file_dialog_new (title, message, wmclass, wmsubclass, cb_cancel,
data);
if (place_dialogs_under_mouse)
gtk_window_position (GTK_WINDOW (GENERIC_DIALOG (fd)->dialog),
GTK_WIN_POS_MOUSE);
else if (place_dialogs_center)
gtk_window_position (GTK_WINDOW (GENERIC_DIALOG (fd)->dialog),
GTK_WIN_POS_CENTER);
return fd;
}
GenericDialog *
file_util_warning_dialog (const gchar * title, const gchar * message)
{
GenericDialog *gd;
gd = file_util_gen_dlg (title, message, "PornView", "warning", TRUE, NULL,
NULL);
generic_dialog_add (gd, _("Ok"), cb_file_util_warning_dialog_ok, TRUE);
if (place_dialogs_under_mouse)
gtk_window_position (GTK_WINDOW (gd->dialog), GTK_WIN_POS_MOUSE);
else if (place_dialogs_center)
gtk_window_position (GTK_WINDOW (gd->dialog), GTK_WIN_POS_CENTER);
gtk_widget_show (gd->dialog);
return gd;
}
void preference_dlg(void) {
GtkWidget *button;
GtkWidget *bbox;
GtkWidget *frame;
prefer_dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(prefer_dialog), TRUE);
GTK_WINDOW(prefer_dialog)->type = GTK_WINDOW_DIALOG;
gtk_window_set_title(GTK_WINDOW(prefer_dialog), _("Preference"));
gtk_window_set_policy(GTK_WINDOW(prefer_dialog), FALSE, FALSE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(prefer_dialog), 10);
gtk_window_position(GTK_WINDOW(prefer_dialog), GTK_WIN_POS_MOUSE);
gtk_widget_show(prefer_dialog);
frame = gtk_frame_new(_("Not implemented!!"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(prefer_dialog)->vbox), frame , TRUE, TRUE, 2);
gtk_widget_show(frame);
bbox = gtk_hbutton_box_new();
gtk_container_set_border_width(GTK_CONTAINER(bbox), 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(prefer_dialog)->action_area), bbox, TRUE, TRUE, 2);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 10);
gtk_button_box_set_child_size(GTK_BUTTON_BOX(bbox), 85, 20);
gtk_widget_show(bbox);
button = gtk_button_new_with_label(_("OK"));
gtk_container_add(GTK_CONTAINER(bbox),button);
gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(prefer_dialog));
gtk_widget_show(button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
button = gtk_button_new_with_label(_("Apply"));
gtk_container_add(GTK_CONTAINER(bbox),button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(prefer_dlg_apply),
NULL);
gtk_widget_show(button);
button = gtk_button_new_with_label(_("Close"));
gtk_container_add(GTK_CONTAINER(bbox),button);
gtk_signal_connect_object(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(prefer_dialog));
gtk_widget_show(button);
return;
}
/*----------------------------------------------------------------------*/
int
static qm_configure(void)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *buttonbox;
DB(_("qm_configure\n"));
/* Set the Window Dialog up */
dialog = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(dialog), "Camera Configuration");
gtk_window_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
/* Set the buttonbox up */
buttonbox = gtk_hbutton_box_new();
gtk_container_border_width(GTK_CONTAINER(buttonbox), 10);
/* One nice button which calls formatCf please... */
button = gtk_button_new_with_label ( "Format CF Card" );
gtk_signal_connect ( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(qm_formatCF),
NULL);
gtk_signal_connect_object ( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(dialog) );
gtk_container_add ( GTK_CONTAINER(buttonbox), GTK_WIDGET(button));
gtk_widget_show ( button );
/* Another to kill this whole window if you will Sir */
button = gtk_button_new_with_label ( " Cancel " );
gtk_signal_connect_object ( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(dialog) );
gtk_container_add ( GTK_CONTAINER(buttonbox), GTK_WIDGET(button));
gtk_widget_show ( button );
/* Stick the buttonbox to the window and show it all */
gtk_container_add ( GTK_CONTAINER(dialog), GTK_WIDGET(buttonbox));
gtk_widget_show( buttonbox );
gtk_widget_show ( dialog );
return ANS_OK;
}
int wFilSelect( struct wFilSel_t * fs, const char * dirName )
{
char name[1024];
char * cp;
if (fs->window == NULL) {
fs->window = gtk_file_selection_new( fs->title );
if (fs->window==0) abort();
gtk_window_position( GTK_WINDOW(fs->window), GTK_WIN_POS_MOUSE );
gtk_signal_connect (GTK_OBJECT (fs->window), "destroy",
GTK_SIGNAL_FUNC(file_selection_cancel),
fs );
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (fs->window)->ok_button),
"clicked", GTK_SIGNAL_FUNC(file_selection_ok),
fs );
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (fs->window)->cancel_button),
"clicked", GTK_SIGNAL_FUNC(file_selection_cancel),
fs );
#ifdef LATER
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (fs->window)),
"event", GTK_SIGNAL_FUNC(filesel_event),
fs );
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (fs->window)->file_list),
"event", GTK_SIGNAL_FUNC(filelist_event),
fs );
#endif
}
strcpy( name, dirName );
cp = name+strlen(name);
if (cp[-1] != '/') {
*cp++ = '/';
*cp = 0;
}
gtk_file_selection_set_filename( GTK_FILE_SELECTION(fs->window), name );
if ( fs->patts && fs->patts[0] )
gtk_file_selection_complete( GTK_FILE_SELECTION(fs->window), fs->patts[0] );
gtk_widget_show( fs->window );
gtkDoModal( NULL, TRUE );
return 1;
}
void ptool_save_callback (GtkWidget *widget, gpointer data)
{
GtkWidget *filew;
static wdata wd;
filew = gtk_file_selection_new ("Save corrections as...");
gtk_window_position (GTK_WINDOW (filew), GTK_WIN_POS_MOUSE);
wd.data = data;
wd.widg = filew;
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
"clicked", (GtkSignalFunc) pt_save_corr, (gpointer) &wd );
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION(filew)->cancel_button),
"clicked", (GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (GTK_WINDOW (filew)));
gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew), "Corrections");
gtk_widget_show (filew);
}
int show_gui(int *argc, char ***argv) {
gtk_init(argc, argv);
init_attr_list();
GtkWidget *wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(wnd), "AppLauncher");
g_signal_connect(wnd, "destroy", G_CALLBACK(destroy), 0);
GtkTable *table = GTK_TABLE(gtk_table_new(cmd_count(), 2, FALSE));
gtk_container_add(GTK_CONTAINER(wnd), GTK_WIDGET(table));
labels = malloc(cmd_count() * sizeof (entry));
for (int i = 0; i < cmd_count(); i++) {
create_labels(nth_command(i), labels + i);
gtk_table_attach(table, labels[i].shortcut_label, 0, 1, i, i + 1,
GTK_EXPAND, GTK_EXPAND, 2, 0);
gtk_table_attach(table, labels[i].name_label, 1, 2, i, i + 1,
GTK_EXPAND, GTK_EXPAND, 2, 0);
}
g_signal_connect(wnd, "key-press-event", G_CALLBACK(key_pressed), 0);
gtk_window_position(GTK_WINDOW(wnd), GTK_WIN_POS_CENTER);
gtk_widget_show_all(wnd);
if (get_time() > 0) g_timeout_add_seconds(get_time(), timer_exit, 0);
gtk_main();
free(labels);
return 0;
}
void about_dialog_create()
{
GtkStyle *style;
GtkWidget *vbox;
GtkWidget *aboutframe;
GtkWidget *label;
GtkWidget *alignment;
if (!about_dialog) {
about_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(about_dialog),
"about_dialog", "Aube");
gtk_window_set_title(GTK_WINDOW(about_dialog),
"About AUBE");
gtk_window_set_policy(GTK_WINDOW(about_dialog), FALSE,
FALSE, FALSE);
gtk_window_position(GTK_WINDOW(about_dialog),
GTK_WIN_POS_CENTER);
g_signal_connect(G_OBJECT(about_dialog), "destroy",
(GtkSignalFunc) about_dialog_destroy,
NULL);
g_signal_connect(G_OBJECT(about_dialog),
"button_press_event",
(GtkSignalFunc) about_dialog_button,
NULL);
gtk_widget_set_events(about_dialog, GDK_BUTTON_PRESS_MASK);
if (!about_dialog_load_logo(about_dialog)) {
gtk_widget_destroy(about_dialog);
about_dialog = NULL;
return;
}
vbox = gtk_vbox_new(FALSE, 1);
gtk_container_border_width(GTK_CONTAINER(vbox), 1);
gtk_container_add(GTK_CONTAINER(about_dialog), vbox);
gtk_widget_show(vbox);
aboutframe = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(aboutframe),
GTK_SHADOW_IN);
gtk_container_border_width(GTK_CONTAINER(aboutframe), 0);
gtk_box_pack_start(GTK_BOX(vbox), aboutframe, TRUE, TRUE,
0);
gtk_widget_show(aboutframe);
logo_area = gtk_drawing_area_new();
g_signal_connect(G_OBJECT(logo_area), "expose_event",
(GtkSignalFunc) about_dialog_logo_expose,
NULL);
gtk_drawing_area_size(GTK_DRAWING_AREA(logo_area),
logo_width, logo_height);
gtk_widget_set_events(logo_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(aboutframe), logo_area);
gtk_widget_show(logo_area);
gtk_widget_realize(logo_area);
gdk_window_set_background(logo_area->window,
&logo_area->style->black);
style = gtk_style_new();
/* FIXME: use pango or remove entirely?
gdk_font_unref(style->font);
style->font = gdk_font_load("-Adobe-Helvetica-Medium-R-Normal--*-140-*-*-*-*-*-*");
gtk_widget_push_style(style);
*/
label = gtk_label_new("This is AUBE Version " VERSION);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
label =
gtk_label_new
("Copyright (c) 1998 - 2002 Conrad Parker, [email protected]");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
/* FIXME
gtk_widget_pop_style();
*/
alignment = gtk_alignment_new(0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE,
0);
gtk_widget_show(alignment);
#ifndef HAVE_LIBSNDFILE
label =
gtk_label_new
("This copy of AUBE was built without sample support\ndue to libsndfile being unavailable on the build host");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
alignment = gtk_alignment_new(0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE,
0);
gtk_widget_show(alignment);
#endif
label =
gtk_label_new
("Visit http://www.metadecks.org/software/aube/ for more info");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
}
if (!GTK_WIDGET_MAPPED(about_dialog)) {
gtk_widget_show(about_dialog);
} else {
gdk_window_raise(about_dialog->window);
}
}
static void exec_autoforward_menu_cb(void)
{
/* show modal dialog */
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *confirm_area;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *radio1;
GtkWidget *radio2;
GtkWidget *frame;
GtkWidget *vbox_cond;
GtkTreeIter iter;
GtkTreeViewColumn *column;
GtkWidget *view;
GtkWidget *sw;
GtkWidget *bbox;
gchar *rcpath;
gchar *to;
gsize sz=0;
GError *errval;
gchar **folders;
int nindex;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
/*gtk_widget_set_size_request(window, 200, 100);*/
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, FALSE);
gtk_widget_realize(window);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
confirm_area = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(confirm_area), 6);
ok_btn = gtk_button_new_from_stock(GTK_STOCK_OK);
GTK_WIDGET_SET_FLAGS(ok_btn, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(confirm_area), ok_btn, FALSE, FALSE, 0);
gtk_widget_show(ok_btn);
cancel_btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(cancel_btn, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(confirm_area), cancel_btn, FALSE, FALSE, 0);
gtk_widget_show(cancel_btn);
gtk_widget_show(confirm_area);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_btn);
gtk_window_set_title(GTK_WINDOW(window), _("Autoforward Settings [autoforward]"));
g_signal_connect(G_OBJECT(ok_btn), "clicked",
G_CALLBACK(prefs_ok_cb), window);
g_signal_connect(G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(prefs_cancel_cb), window);
/* email settings */
hbox = gtk_hbox_new(FALSE, 6);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Forward to(E-mail):"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
g_address = gtk_entry_new();
gtk_widget_show(g_address);
gtk_box_pack_start(GTK_BOX(hbox), g_address, FALSE, TRUE, 0);
/* email settings */
g_startup = gtk_check_button_new_with_label(_("Enable plugin on startup"));
gtk_widget_show(g_startup);
gtk_box_pack_start(GTK_BOX(vbox), g_startup, FALSE, FALSE, 0);
#if 0
g_unreadonly = gtk_check_button_new_with_label(_("Forward unread mail only"));
gtk_widget_show(g_unreadonly);
gtk_box_pack_start(GTK_BOX(vbox), g_unreadonly, FALSE, FALSE, 0);
#endif
/* all */
radio1 = gtk_radio_button_new_with_label(NULL, _("Forward all mail"));
/* folder filtered */
radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
_("Forward mail in folder"));
frame = gtk_frame_new(_("Forward condition:"));
gtk_widget_show(frame);
gtk_container_add(GTK_CONTAINER(vbox), frame);
vbox_cond = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox_cond);
gtk_container_add(GTK_CONTAINER(frame), vbox_cond);
gtk_box_pack_start(GTK_BOX(vbox_cond), radio1, FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox_cond), radio2, FALSE, FALSE, 6);
/* treeview */
g_folders = gtk_list_store_new(1, G_TYPE_STRING);
column = gtk_tree_view_column_new_with_attributes (_("Forward mail in following folder:"),
gtk_cell_renderer_text_new (),
"text", 0,
NULL);
view=gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_folders));
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw), view);
gtk_box_pack_start (GTK_BOX(vbox_cond), sw, TRUE, TRUE, 2);
/* add and delete */
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);
g_add_btn = gtk_button_new_from_stock(GTK_STOCK_ADD);
g_delete_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_box_pack_start(GTK_BOX(bbox), g_add_btn, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bbox), g_delete_btn, FALSE, FALSE, 0);
gtk_widget_show_all(bbox);
gtk_box_pack_end(GTK_BOX(vbox_cond), bbox, FALSE, FALSE, 6);
gtk_widget_show_all(vbox_cond);
g_signal_connect (g_add_btn, "clicked",
G_CALLBACK (add_mail_folder_cb), view);
g_signal_connect (g_delete_btn, "clicked",
G_CALLBACK (delete_mail_folder_cb), view);
g_signal_connect(GTK_BUTTON(radio1), "clicked",
G_CALLBACK(forward_mail_all_cb), view);
g_signal_connect(GTK_BUTTON(radio2), "clicked",
G_CALLBACK(forward_mail_folder_cb), view);
/* load settings */
rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL);
g_keyfile = g_key_file_new();
if (g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL)){
g_startup_flg = g_key_file_get_boolean (g_keyfile, "forward", "startup", NULL);
debug_print("startup:%s\n", g_startup_flg ? "true" : "false");
if (g_startup_flg){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_startup), TRUE);
}
#if 0
g_unreadonly_flg = g_key_file_get_boolean (g_keyfile, "forward", "unreadonly", NULL);
debug_print("unreadonly:%s\n", g_unreadonly_flg ? "true" : "false");
if (g_unreadonly_flg){
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_unreadonly), TRUE);
}
#endif
to=g_key_file_get_string (g_keyfile, "forward", "to", NULL);
gtk_entry_set_text(GTK_ENTRY(g_address), to);
g_forward_flg=g_key_file_get_boolean (g_keyfile, "forward", "all", NULL);
if (g_forward_flg){
gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE);
}else{
g_print("activate view and radio2\n");
gtk_widget_set_sensitive(GTK_WIDGET(view), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), TRUE);
}
/**/
folders = g_key_file_get_string_list(g_keyfile, "forward", "folder", &sz, &errval);
if (folders!=NULL){
nindex=0;
for (nindex = 0; nindex < sz; nindex++){
gtk_list_store_append(g_folders, &iter);
gtk_list_store_set(g_folders, &iter, 0, folders[nindex], -1);
}
}
}else{
/* default settings */
g_startup_flg = FALSE;
g_forward_flg = TRUE;
gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE);
}
g_free(rcpath);
gtk_widget_show(window);
}
void ReallyReStart (GtkWidget *rrw, GtkFileSelection *rrfs)
{
gfloat pvalue = 0;
if ((ihistory > 0) && (isave == 1))
{
JudgeBoard ('w');
Save ();
}
if (isavemes == 1)
{
Message (ssavemes, 2, 1);
}
x = 0;
y = 0;
iCapturedW = 0;
iCapturedB = 0;
ilimit = 0;
ijustundo = 0;
ifilestuff = 0;
iduh = 0;
iother = 0;
isave = 1;
iquit = 0;
isavemes = 0;
iiamblack = 0;
ihistory = 0;
imoves = 0;
ilastmoveb = 1000;
ilastmovew = 1000;
StatusBar ();
for (iPlace = 1; iPlace <= 361; iPlace++)
{
sprintf (Board[iPlace], "%s", "mme");
}
sprintf (Board[1], "%s", "lte");
for (iPlace = 2; iPlace <= 18; iPlace++)
{
sprintf (Board[iPlace], "%s", "mte");
}
sprintf (Board[19], "%s", "rte");
sprintf (Board[20], "%s", "lme");
sprintf (Board[38], "%s", "rme");
sprintf (Board[39], "%s", "lme");
sprintf (Board[57], "%s", "rme");
sprintf (Board[58], "%s", "lme");
sprintf (Board[61], "%s", "mms");
sprintf (Board[67], "%s", "mms");
sprintf (Board[73], "%s", "mms");
sprintf (Board[76], "%s", "rme");
sprintf (Board[77], "%s", "lme");
sprintf (Board[95], "%s", "rme");
sprintf (Board[96], "%s", "lme");
sprintf (Board[114], "%s", "rme");
sprintf (Board[115], "%s", "lme");
sprintf (Board[133], "%s", "rme");
sprintf (Board[134], "%s", "lme");
sprintf (Board[152], "%s", "rme");
sprintf (Board[153], "%s", "lme");
sprintf (Board[171], "%s", "rme");
sprintf (Board[172], "%s", "lme");
sprintf (Board[175], "%s", "mms");
sprintf (Board[181], "%s", "mms");
sprintf (Board[187], "%s", "mms");
sprintf (Board[190], "%s", "rme");
sprintf (Board[191], "%s", "lme");
sprintf (Board[209], "%s", "rme");
sprintf (Board[210], "%s", "lme");
sprintf (Board[228], "%s", "rme");
sprintf (Board[229], "%s", "lme");
sprintf (Board[247], "%s", "rme");
sprintf (Board[248], "%s", "lme");
sprintf (Board[266], "%s", "rme");
sprintf (Board[267], "%s", "lme");
sprintf (Board[285], "%s", "rme");
sprintf (Board[286], "%s", "lme");
sprintf (Board[289], "%s", "mms");
sprintf (Board[295], "%s", "mms");
sprintf (Board[301], "%s", "mms");
sprintf (Board[304], "%s", "rme");
sprintf (Board[305], "%s", "lme");
sprintf (Board[323], "%s", "rme");
sprintf (Board[324], "%s", "lme");
sprintf (Board[342], "%s", "rme");
sprintf (Board[343], "%s", "lue");
for (iPlace = 344; iPlace <= 360; iPlace++)
{
sprintf (Board[iPlace], "%s", "mue");
}
sprintf (Board[361], "%s", "rue");
DoHandicap ();
for (ibuttonrr = 1; ibuttonrr <= 361; ibuttonrr++)
{
sprintf (History[ihistory][ibuttonrr], "%s", Board[ibuttonrr]);
}
gtk_widget_hide (window1);
loadingw = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_position (GTK_WINDOW (loadingw), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (loadingw), "loading...");
gtk_signal_connect (GTK_OBJECT (loadingw), "delete_event",
GTK_SIGNAL_FUNC (Quit), NULL);
gtk_window_set_policy (GTK_WINDOW (loadingw), 0, 0, 1);
gtk_container_border_width (GTK_CONTAINER (loadingw), 0);
gtk_widget_realize (loadingw);
lbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (lbox1), 0);
gtk_container_add (GTK_CONTAINER (loadingw), lbox1);
gtk_widget_show (lbox1);
lbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (lbox2), 0);
gtk_box_pack_start (GTK_BOX (lbox1), lbox2, FALSE, FALSE, 0);
gtk_widget_show (lbox2);
ltable1 = gtk_table_new (1, 2, FALSE);
gtk_box_pack_start (GTK_BOX (lbox2), ltable1, TRUE, TRUE, 0);
gtk_widget_show (ltable1);
#ifdef USE_GNOME
im9 = gdk_imlib_load_image (PKGDATADIR"pix/gologog.png");
#else
im9 = gdk_imlib_load_image (PKGDATADIR"pix/gologo.png");
#endif
w9 = im9->rgb_width;
h9 = im9->rgb_height;
gdk_imlib_render (im9, w9, h9);
lpixmap = gdk_imlib_move_image (im9);
lpixmapwid = gtk_pixmap_new (lpixmap, NULL);
gtk_table_attach (GTK_TABLE (ltable1), lpixmapwid, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (lpixmapwid);
gdk_flush ();
lbar = gtk_progress_bar_new ();
gtk_table_attach (GTK_TABLE (ltable1), lbar, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (lbar);
gtk_widget_show (loadingw);
while (gtk_events_pending ())
{
gtk_main_iteration ();
}
for (ibuttonrr = 1; ibuttonrr <= 361; ibuttonrr++)
{
PixmapOnButton (ibuttonrr);
pvalue = lprogress (pvalue);
}
gtk_widget_destroy (loadingw);
if (itooltips == 0)
{
itooltips = 1;
Tooltips ();
}
gtk_widget_show (window1);
}
gint load_dialog(struct raw_data* img_data, gchar* check_button_label)
{
int i;
GtkWidget* dlg;
GtkWidget* wgt;
gchar** argv = g_new(gchar*, 1);
gint argc = 1;
struct load_dlg_data dlg_data;
static char *labs[] = {"Width", "Height"};
if (!img_data) return ERROR;
dlg_data.img_data = img_data;
argv[0] = g_strdup("load");
gtk_init (&argc, &argv);
gtk_rc_parse(gimp_gtkrc());
gdk_set_use_xshm(TRUE);
dlg_data.id = gtk_dialog_new();
dlg = dlg_data.id;
gtk_window_set_title(GTK_WINDOW (dlg), "Load raw image");
gtk_window_position(GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect(GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) load_on_close, NULL);
/* OK button */
wgt = gtk_button_new_with_label("OK");
GTK_WIDGET_SET_FLAGS(wgt, GTK_CAN_DEFAULT);
gtk_signal_connect(GTK_OBJECT (wgt), "clicked",
(GtkSignalFunc) load_on_ok, &dlg_data);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->action_area), wgt,
TRUE, TRUE, 0);
gtk_widget_grab_default(wgt);
gtk_widget_show(wgt);
/* Cancel button */
wgt = gtk_button_new_with_label("Cancel");
GTK_WIDGET_SET_FLAGS(wgt, GTK_CAN_DEFAULT);
gtk_signal_connect(GTK_OBJECT (wgt), "clicked",
(GtkSignalFunc) load_on_cancel, &dlg_data);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->action_area), wgt,
TRUE, TRUE, 0);
gtk_widget_grab_default(wgt);
gtk_widget_show(wgt);
/* Width and Height */
wgt = gtk_table_new(3, SIZE_DIM, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(wgt), 3);
gtk_table_set_col_spacings(GTK_TABLE(wgt), 3);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->vbox), wgt, TRUE, TRUE, 0);
gtk_widget_show(wgt);
for (i = 0; i < SIZE_DIM; i++) {
char init_size[16];
GtkWidget *label = gtk_label_new(labs[i]);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(wgt), label, 0, 1, i, i+1, GTK_FILL,
GTK_FILL, 0, 0);
gtk_widget_show(label);
dlg_data.size[i] = gtk_entry_new();
gtk_widget_set_usize(dlg_data.size[i], 35, 0);
sprintf(init_size, "%d", (int) dlg_data.img_data->size[i]);
gtk_entry_set_text(GTK_ENTRY(dlg_data.size[i]), init_size);
gtk_table_attach(GTK_TABLE(wgt), dlg_data.size[i], 1, 2, i, i+1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show(dlg_data.size[i]);
}
if (check_button_label) {
dlg_data.checked = gtk_check_button_new_with_mnemonic(
check_button_label);
gtk_table_attach(GTK_TABLE(wgt), dlg_data.checked, 0, 1, i, i+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show(dlg_data.checked);
} else {
dlg_data.checked = NULL;
}
gtk_widget_show(dlg);
gtk_main();
gdk_flush();
return dlg_data.result_ok;
}
static gint
sobel_dialog ()
{
GtkWidget *dlg;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
gchar **argv;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("sobel");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), _("Sobel Edge Detection"));
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) sobel_close_callback,
NULL);
/* Action area */
button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) sobel_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (frame), vbox);
toggle = gtk_check_button_new_with_label (_("Sobel Horizontally"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) sobel_toggle_update,
&bvals.horizontal);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.horizontal);
gtk_widget_show (toggle);
toggle = gtk_check_button_new_with_label (_("Sobel Vertically"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) sobel_toggle_update,
&bvals.vertical);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.vertical);
gtk_widget_show (toggle);
toggle = gtk_check_button_new_with_label (_("Keep sign of result (one direction only)"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) sobel_toggle_update,
&bvals.keep_sign);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.vertical);
gtk_widget_show (toggle);
hbox = gtk_hbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
return bint.run;
}
void ssl_manager_create(void)
{
GtkWidget *window;
GtkWidget *hbox1;
GtkWidget *vbox1;
GtkWidget *certlist;
GtkWidget *view_btn;
GtkWidget *delete_btn;
GtkWidget *ok_btn;
gchar *titles[2];
window = gtk_window_new (GTK_WINDOW_DIALOG);
gtk_window_set_title (GTK_WINDOW(window),
_("Saved SSL Certificates"));
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);
gtk_signal_connect (GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(ssl_manager_ok_cb), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT (window);
hbox1 = gtk_hbox_new(FALSE,2);
vbox1 = gtk_vbox_new(FALSE,0);
delete_btn = gtk_button_new_with_label(_("Delete"));
gtk_signal_connect (GTK_OBJECT(delete_btn), "clicked",
GTK_SIGNAL_FUNC(ssl_manager_delete_cb), NULL);
view_btn = gtk_button_new_with_label(_("View"));
gtk_signal_connect (GTK_OBJECT(view_btn), "clicked",
GTK_SIGNAL_FUNC(ssl_manager_view_cb), NULL);
ok_btn = gtk_button_new_with_label(_("OK"));
gtk_signal_connect (GTK_OBJECT(ok_btn), "clicked",
GTK_SIGNAL_FUNC(ssl_manager_ok_cb), NULL);
gtk_widget_set_usize(ok_btn, 80, -1);
gtk_widget_set_usize(delete_btn, 80, -1);
gtk_widget_set_usize(view_btn, 80, -1);
titles[0] = _("Server");
titles[1] = _("Port");
certlist = gtk_sctree_new_with_titles(2, 3, titles);
gtk_clist_column_titles_show(GTK_CLIST(certlist));
gtk_clist_set_column_width(GTK_CLIST(certlist), 0, 220);
gtk_clist_set_selection_mode(GTK_CLIST(certlist), GTK_SELECTION_SINGLE);
gtk_widget_set_usize(certlist, 300, 200);
gtk_signal_connect (GTK_OBJECT(certlist), "open_row",
GTK_SIGNAL_FUNC(ssl_manager_view_cb), NULL);
gtk_box_pack_start(GTK_BOX(hbox1), certlist, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox1), vbox1, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), view_btn, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), delete_btn, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox1), ok_btn, FALSE, FALSE, 0);
gtk_widget_show(certlist);
gtk_widget_show(hbox1);
gtk_widget_show(vbox1);
gtk_widget_show(ok_btn);
gtk_widget_show(delete_btn);
gtk_widget_show(view_btn);
gtk_container_add(GTK_CONTAINER (window), hbox1);
manager.window = window;
manager.hbox1 = hbox1;
manager.vbox1 = vbox1;
manager.certlist = certlist;
manager.view_btn = view_btn;
manager.delete_btn = delete_btn;
manager.ok_btn = ok_btn;
gtk_widget_show(window);
}
int config_dialog(char* title, int argc, char** argv) {
GtkWidget *box1, *but_quit, *but_start;
GdkBitmap *mask;
GdkPixmap *background;
GdkColormap* colormap;
GdkColor white, black;
if (gtk_init_check(&argc, &argv) == FALSE)
return -1;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(GTK_WIDGET(window), TRUE);
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_set_usize(GTK_WIDGET(window), 120, 400);
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
ch_windowed = gtk_check_button_new_with_label("Windowed");
gtk_box_pack_start(GTK_BOX(box1), ch_windowed, FALSE, FALSE, 0);
gtk_widget_show(ch_windowed);
ch_oldskool = gtk_check_button_new_with_label("Oldskool");
gtk_box_pack_start(GTK_BOX(box1), ch_oldskool, FALSE, FALSE, 0);
gtk_widget_show(ch_oldskool);
but_quit = gtk_button_new_with_label("Quit");
gtk_box_pack_end(GTK_BOX(box1), but_quit, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(but_quit), "clicked", GTK_SIGNAL_FUNC(quit_event), NULL);
gtk_widget_show(but_quit);
but_start = gtk_button_new_with_label("Start");
gtk_box_pack_end(GTK_BOX(box1), but_start, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(but_start), "clicked", GTK_SIGNAL_FUNC(start_event), NULL);
gtk_widget_show(but_start);
gtk_widget_show(box1);
gtk_widget_realize(GTK_WIDGET(window));
gdk_window_set_decorations(GTK_WIDGET(window)->window, 0);
colormap = gdk_colormap_get_system();
gdk_color_white(colormap, &white);
gdk_color_black(colormap, &black);
background = gdk_pixmap_create_from_data(GTK_WIDGET(window)->window,
fznback2_bits, fznback2_width, fznback2_height, -1, &black, &white);
gdk_window_set_back_pixmap(GTK_WIDGET(window)->window, background, FALSE);
gdk_window_clear(GTK_WIDGET(window)->window);
gtk_widget_show(window);
gtk_main();
return result;
}
int main(int argc, char *argv[])
{
GtkWidget* window;
shareMgr_t* theShareMgr;
int nRet;
gboolean ok;
// catch the SIGTERM signal
struct sigaction on_term;
memset(&on_term, 0x00, sizeof(on_term));
on_term.sa_handler = on_sigterm;
sigaction(SIGTERM, &on_term, NULL);
DL_WARNPRINTF(PACKAGE_STRING);
parse_arguments(argc, argv);
// minimum battery charge required for background mode
if (g_background)
{
if (get_battery_charge() <= BATTERY_MINCHARGE_BACKGROUND)
{
DL_ERRORPRINTF("Insufficient battery [%d] for background PC connect -> quit", get_battery_charge());
return NO_ERROR;
}
}
/* init threads */
g_thread_init(NULL);
gdk_threads_init();
// open the RC file associated with this program (re-use the downloadMgr one)
gtk_rc_parse(DATA_DIR "/downloadMgr.rc");
DL_LOGPRINTF("rc file %s", DATA_DIR "/downloadMgr.rc");
gtk_init(&argc, &argv);
load_registry();
languagesInit();
// create/init the channel to communicate with the content lister
nRet = erIpcStartClient(ER_CONTENTLISTER_CHANNEL, &contentListerChannel);
if (nRet != 0)
{
DL_ERRORPRINTF("erIpcStartClient returned %d", nRet);
contentListerChannel = NULL;
}
// create the main, top level, window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), PACKAGE " " VERSION);
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
// gtk_widget_set_size_request(GTK_WIDGET(window), SCREEN_WIDTH, SCREEN_HEIGHT);
gtk_window_set_modal(GTK_WINDOW(window), FALSE);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_fullscreen(GTK_WINDOW(window)); // Fullscreen overlap taskbars
theShareMgr = ctrlInit(window);
if (theShareMgr)
{
// Connect the destroy event of the window with our on_destroy function
// When the window is about to be destroyed we get a notification and
// stop the main GTK loop
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(on_destroy), NULL);
// make sure that everything, window and label, are visible
if ( !g_background )
{
gtk_widget_show(window);
}
}
// Start the download thread
ok = shareThread_start((gpointer)theShareMgr);
if (!ok)
{
printf("%s %s: ", __FILE__, __FUNCTION__);
perror("Could not create thread\n");
}
// run the GTK main loop
DL_LOGPRINTF("Before gtk_main");
gdk_threads_enter();
gtk_main();
gdk_threads_leave();
nRet = theShareMgr->returnVal;
DL_LOGPRINTF("exitValue after gtk_main [%d]", nRet);
// GTK done, abort any copying that might be running
shareThread_stop();
shareThread_wait(15);
DL_WARNPRINTF("PC Share Manager quitting with return value \"%d\"", nRet);
ctrlDestroy(theShareMgr);
release_registry();
return nRet;
}
void
menu_about (GtkWidget * wid, gpointer sess)
{
GtkWidget *vbox, *label, *hbox;
GtkStyle *about_style;
GtkStyle *head_style;
char buf[512];
if (about)
{
gdk_window_show (about->window);
return;
}
head_style = gtk_style_new ();
#ifndef WIN32
gdk_font_unref (head_style->font);
head_style->font = gdk_font_load ("-*-times-bold-i-*-*-*-240-*");
if (!head_style->font)
head_style->font = gdk_font_load ("fixed");
#endif
head_style->fg[GTK_STATE_NORMAL] = colors[2];
about_style = gtk_style_new ();
gdk_font_unref (about_style->font);
about_style->font = gdk_font_load ("fixed");
about = gtk_window_new (GTK_WINDOW_DIALOG);
gtk_window_position (GTK_WINDOW (about), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (about), _("About X-Chat"));
gtk_container_set_border_width (GTK_CONTAINER (about), 6);
gtk_signal_connect (GTK_OBJECT (about), "destroy",
GTK_SIGNAL_FUNC (about_close), 0);
gtk_widget_realize (about);
vbox = gtk_vbox_new (0, 2);
gtk_container_add (GTK_CONTAINER (about), vbox);
/*gtk_widget_show (vbox);*/
label = gtk_entry_new ();
gtk_entry_set_editable (GTK_ENTRY (label), FALSE);
gtk_entry_set_text (GTK_ENTRY (label), "X-Chat " VERSION);
gtk_widget_set_style (label, head_style);
gtk_style_unref (head_style);
gtk_container_add (GTK_CONTAINER (vbox), label);
snprintf (buf, sizeof (buf),
_("(C) 1998-2001 Peter Zelezny <*****@*****.**>\n\n"
"An IRC Client for UNIX.\n\n"
"This binary was compiled on "__DATE__"\n"
"Using GTK %d.%d.%d X %d\n"
"Running on %s\n"),
gtk_major_version, gtk_minor_version, gtk_micro_version,
#ifdef USE_XLIB
VendorRelease (GDK_DISPLAY ()), get_cpu_str());
#else
666, get_cpu_str());
#endif
label = gtk_label_new (buf);
gtk_container_add (GTK_CONTAINER (vbox), label);
gtk_widget_set_style (label, about_style);
gtk_style_unref (about_style);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
wid = gtk_hseparator_new ();
gtk_container_add (GTK_CONTAINER (vbox), wid);
hbox = gtk_hbox_new (0, 2);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
wid = gtk_button_new_with_label (" Continue ");
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
GTK_WIDGET_SET_FLAGS (GTK_WIDGET (wid), GTK_CAN_DEFAULT);
gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_grab_default (wid);
gtk_signal_connect (GTK_OBJECT (wid), "clicked",
GTK_SIGNAL_FUNC (gtkutil_destroy), about);
gtk_widget_show_all (about);
}
static void exec_msg2clip_menu_cb(void)
{
/* show modal dialog */
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *confirm_area;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *notebook;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, FALSE);
gtk_window_set_default_size(GTK_WINDOW(window), 300, 100);
gtk_widget_realize(window);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
/* notebook */
notebook = gtk_notebook_new();
/* main tab */
create_config_main_page(notebook, g_opt.rcfile);
/* about, copyright tab */
sylpf_append_config_about_page(notebook,
g_opt.rcfile,
_("About"),
_(PLUGIN_NAME),
_(PLUGIN_DESC),
_(copyright));
gtk_widget_show(notebook);
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
confirm_area = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(confirm_area), 6);
ok_btn = gtk_button_new_from_stock(GTK_STOCK_OK);
GTK_WIDGET_SET_FLAGS(ok_btn, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(confirm_area), ok_btn, FALSE, FALSE, 0);
gtk_widget_show(ok_btn);
cancel_btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
GTK_WIDGET_SET_FLAGS(cancel_btn, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(confirm_area), cancel_btn, FALSE, FALSE, 0);
gtk_widget_show(cancel_btn);
gtk_widget_show(confirm_area);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_btn);
gtk_widget_show(vbox);
gtk_window_set_title(GTK_WINDOW(window), _("Msg2Clip Settings"));
g_signal_connect(G_OBJECT(ok_btn), "clicked",
G_CALLBACK(prefs_ok_cb), window);
g_signal_connect(G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(prefs_cancel_cb), window);
gtk_widget_show_all(window);
}
static void prefs_summary_column_create(void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *label_hbox;
GtkWidget *label;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *clist_hbox;
GtkWidget *scrolledwin;
GtkWidget *stock_clist;
GtkWidget *shown_clist;
GtkWidget *btn_vbox;
GtkWidget *btn_vbox1;
GtkWidget *add_btn;
GtkWidget *remove_btn;
GtkWidget *up_btn;
GtkWidget *down_btn;
GtkWidget *btn_hbox;
GtkWidget *default_btn;
GtkWidget *confirm_area;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
gchar *title[1];
debug_print("Creating summary column setting window...\n");
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_window_set_title(GTK_WINDOW(window),
_("Displayed items configuration"));
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(prefs_summary_column_delete_event),
NULL);
gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
GTK_SIGNAL_FUNC(prefs_summary_column_key_pressed),
NULL);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
label_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(label_hbox);
gtk_box_pack_start(GTK_BOX(vbox), label_hbox, FALSE, FALSE, 4);
label = gtk_label_new
(_("Select items to be displayed in the summary view. You can modify\n"
"the order by using the Up / Down buttons or by dragging the items."));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(label_hbox), label, FALSE, FALSE, 4);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
vbox1 = gtk_vbox_new(FALSE, VSPACING);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(vbox), vbox1, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox1), 2);
hbox1 = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);
clist_hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(clist_hbox);
gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_usize(scrolledwin, 180, 210);
gtk_widget_show(scrolledwin);
gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
title[0] = _("Available items");
stock_clist = gtk_clist_new_with_titles(1, title);
gtk_widget_show(stock_clist);
gtk_container_add(GTK_CONTAINER(scrolledwin), stock_clist);
gtk_clist_set_selection_mode(GTK_CLIST(stock_clist),
GTK_SELECTION_BROWSE);
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(stock_clist)->column[0].button,
GTK_CAN_FOCUS);
/* add/remove button */
btn_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(btn_vbox);
gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);
btn_vbox1 = gtk_vbox_new(FALSE, 8);
gtk_widget_show(btn_vbox1);
gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);
add_btn = gtk_button_new_with_label(_(" -> "));
gtk_widget_show(add_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), add_btn, FALSE, FALSE, 0);
remove_btn = gtk_button_new_with_label(_(" <- "));
gtk_widget_show(remove_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), remove_btn, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(add_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_add), NULL);
gtk_signal_connect(GTK_OBJECT(remove_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_remove), NULL);
clist_hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(clist_hbox);
gtk_box_pack_start(GTK_BOX(hbox1), clist_hbox, TRUE, TRUE, 0);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_usize(scrolledwin, 180, 210);
gtk_widget_show(scrolledwin);
gtk_box_pack_start(GTK_BOX(clist_hbox), scrolledwin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
title[0] = _("Displayed items");
shown_clist = gtk_clist_new_with_titles(1, title);
gtk_widget_show(shown_clist);
gtk_container_add(GTK_CONTAINER(scrolledwin), shown_clist);
gtk_clist_set_selection_mode(GTK_CLIST(shown_clist),
GTK_SELECTION_BROWSE);
gtk_clist_set_reorderable(GTK_CLIST(shown_clist), TRUE);
gtk_clist_set_use_drag_icons(GTK_CLIST(shown_clist), FALSE);
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(shown_clist)->column[0].button,
GTK_CAN_FOCUS);
/* up/down button */
btn_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(btn_vbox);
gtk_box_pack_start(GTK_BOX(hbox1), btn_vbox, FALSE, FALSE, 0);
btn_vbox1 = gtk_vbox_new(FALSE, 8);
gtk_widget_show(btn_vbox1);
gtk_box_pack_start(GTK_BOX(btn_vbox), btn_vbox1, TRUE, FALSE, 0);
up_btn = gtk_button_new_with_label(_("Up"));
gtk_widget_show(up_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), up_btn, FALSE, FALSE, 0);
down_btn = gtk_button_new_with_label(_("Down"));
gtk_widget_show(down_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox1), down_btn, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(up_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_up), NULL);
gtk_signal_connect(GTK_OBJECT(down_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_down), NULL);
btn_hbox = gtk_hbox_new(FALSE, 8);
gtk_widget_show(btn_hbox);
gtk_box_pack_end(GTK_BOX(vbox), btn_hbox, FALSE, FALSE, 0);
btn_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(btn_vbox);
gtk_box_pack_start(GTK_BOX(btn_hbox), btn_vbox, FALSE, FALSE, 0);
default_btn = gtk_button_new_with_label(_(" Use default "));
gtk_widget_show(default_btn);
gtk_box_pack_start(GTK_BOX(btn_vbox), default_btn, TRUE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(default_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_set_to_default),
NULL);
gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
&cancel_btn, _("Cancel"), NULL, NULL);
gtk_widget_show(confirm_area);
gtk_box_pack_end(GTK_BOX(btn_hbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_btn);
gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_ok), NULL);
gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked",
GTK_SIGNAL_FUNC(prefs_summary_column_cancel), NULL);
summary_col.window = window;
summary_col.stock_clist = stock_clist;
summary_col.shown_clist = shown_clist;
summary_col.add_btn = add_btn;
summary_col.remove_btn = remove_btn;
summary_col.up_btn = up_btn;
summary_col.down_btn = down_btn;
summary_col.ok_btn = ok_btn;
summary_col.cancel_btn = cancel_btn;
}
