UmPasswordDialog *
um_password_dialog_new (void)
{
GtkBuilder *builder;
GError *error;
const gchar *filename;
UmPasswordDialog *um;
GtkWidget *widget;
const char *old_label;
char *label;
gint len;
builder = gtk_builder_new ();
error = NULL;
filename = UIDIR "/password-dialog.ui";
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
filename = "data/password-dialog.ui";
if (!gtk_builder_add_from_file (builder, filename, &error)) {
g_error ("%s", error->message);
g_error_free (error);
return NULL;
}
um = g_new0 (UmPasswordDialog, 1);
um->action_label = (GtkWidget *) gtk_builder_get_object (builder, "action-label");
widget = (GtkWidget *) gtk_builder_get_object (builder, "action-combo");
g_signal_connect (widget, "changed",
G_CALLBACK (action_changed), um);
um->action_combo = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "dialog");
g_signal_connect (widget, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
um->dialog = widget;
um->user_icon = (GtkWidget *) gtk_builder_get_object (builder, "user-icon");
um->user_name = (GtkWidget *) gtk_builder_get_object (builder, "user-name");
widget = (GtkWidget *) gtk_builder_get_object (builder, "cancel-button");
g_signal_connect (widget, "clicked",
G_CALLBACK (cancel_password_dialog), um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "ok-button");
g_signal_connect (widget, "clicked",
G_CALLBACK (accept_password_dialog), um);
gtk_widget_grab_default (widget);
um->ok_button = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "password-normal-strength-hints-label");
old_label = gtk_label_get_label (GTK_LABEL (widget));
if (!g_strcmp0(g_getenv("XDG_CURRENT_DESKTOP"), "Unity"))
label = g_strdup_printf ("<a href=\"%s\">%s</a>",
"help:ubuntu-help/user-goodpassword",
old_label);
else
label = g_strdup_printf ("<a href=\"%s\">%s</a>",
"help:gnome-help/user-goodpassword",
old_label);
gtk_label_set_markup (GTK_LABEL (widget), label);
g_free (label);
widget = (GtkWidget *) gtk_builder_get_object (builder, "show-password-checkbutton");
g_signal_connect (widget, "toggled",
G_CALLBACK (show_password_toggled), um);
um->show_password_button = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "password-entry");
g_signal_connect (widget, "notify::text",
G_CALLBACK (password_entry_changed), um);
g_signal_connect_after (widget, "focus-out-event",
G_CALLBACK (password_entry_focus_out), um);
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
g_signal_connect (widget, "icon-press",
G_CALLBACK (activate_icon), um);
g_signal_connect (widget, "populate-popup",
G_CALLBACK (populate_menu), um);
um->password_entry = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "old-password-entry");
g_signal_connect_after (widget, "focus-out-event",
G_CALLBACK (old_password_entry_focus_out), um);
g_signal_connect (widget, "notify::text",
G_CALLBACK (old_password_entry_changed), um);
g_signal_connect (widget, "activate",
G_CALLBACK (old_password_entry_activate), um);
um->old_password_entry = widget;
um->old_password_label = (GtkWidget *) gtk_builder_get_object (builder, "old-password-label");
widget = (GtkWidget *) gtk_builder_get_object (builder, "verify-entry");
g_signal_connect (widget, "notify::text",
G_CALLBACK (verify_entry_changed), um);
g_signal_connect_after (widget, "focus-out-event",
G_CALLBACK (verify_entry_focus_out), um);
um->verify_entry = widget;
len = 0;
len = MAX (len, strlen (C_("Password strength", "Too short")));
len = MAX (len, strlen (C_("Password strength", "Weak")));
len = MAX (len, strlen (C_("Password strength", "Fair")));
len = MAX (len, strlen (C_("Password strength", "Good")));
len = MAX (len, strlen (C_("Password strength", "Strong")));
len += 2;
widget = (GtkWidget *) gtk_builder_get_object (builder, "strength-indicator-label");
gtk_label_set_width_chars (GTK_LABEL (widget), len);
um->normal_hint_entry = (GtkWidget *) gtk_builder_get_object (builder, "normal-hint-entry");
/* Label size hack.
* This only sort-of works because the dialog is non-resizable.
*/
widget = (GtkWidget *)gtk_builder_get_object (builder, "password-normal-hint-description-label");
g_signal_connect (um->normal_hint_entry, "size-allocate",
G_CALLBACK (entry_size_changed), widget);
um->normal_hint_label = widget;
if (!is_gdm_running ()) {
widget = (GtkWidget *) gtk_builder_get_object (builder, "password-normal-hint-label");
gtk_widget_hide (widget);
gtk_widget_hide (um->normal_hint_entry);
gtk_widget_hide (um->normal_hint_label);
}
um->strength_indicator = (GtkWidget *) gtk_builder_get_object (builder, "strength-indicator");
um->strength_indicator_label = (GtkWidget *) gtk_builder_get_object (builder, "strength-indicator-label");
g_object_unref (builder);
return um;
}
/* create and display the dialog box */
void
makeWidget(PluginInstance *This)
{
GtkWidget *dialogWindow;
GtkWidget *dialogMessage;
GtkWidget *okButton;
GtkWidget *cancelButton;
char message[1024];
MimeTypeElement *ele;
if (!This) return;
/* need to check whether we already pop up a dialog box for previous
minetype in the same web page. It's require otherwise there will
be 2 dialog boxes pop if there are 2 plugin in the same web page
*/
if ((ele = isExist(&head, This->type)))
{
if (ele->pinst && ele->pinst->dialogBox)
{
GtkWidget *top_window = gtk_widget_get_toplevel(ele->pinst->dialogBox);
if (top_window && GTK_WIDGET_VISIBLE(top_window))
{ /* this will raise the toplevel window */
gdk_window_show(top_window->window);
}
}
return;
}
dialogWindow = gtk_dialog_new();
This->dialogBox = dialogWindow;
This->exists = TRUE;
This->dialogBox = dialogWindow;
addToList(&head, This);
gtk_window_set_title(GTK_WINDOW(dialogWindow), PLUGIN_NAME);
gtk_window_set_position(GTK_WINDOW(dialogWindow), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(dialogWindow), FALSE);
gtk_window_set_wmclass(GTK_WINDOW(dialogWindow), "Mozilla", "DefaultPlugin");
gtk_container_set_border_width(GTK_CONTAINER(dialogWindow), 20);
gtk_window_set_resizable(GTK_WINDOW(dialogWindow), FALSE);
PR_snprintf(message, sizeof(message) - 1, MESSAGE, This->type);
dialogMessage = AddWidget(gtk_label_new (message),
GTK_DIALOG(dialogWindow)->vbox);
okButton= AddWidget(gtk_button_new_with_label (OK_BUTTON),
GTK_DIALOG(dialogWindow)->action_area);
g_object_set_data(GTK_OBJECT(okButton), DIALOGID, dialogWindow);
GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT);
gtk_widget_grab_default(okButton);
cancelButton= AddWidget(gtk_button_new_with_label (CANCEL_BUTTON),
GTK_DIALOG(dialogWindow)->action_area);
g_signal_connect (GTK_OBJECT(okButton), "clicked",
G_CALLBACK(DialogOKClicked), This);
g_signal_connect (GTK_OBJECT(cancelButton), "clicked",
G_CALLBACK(DialogCancelClicked), This);
g_signal_connect(GTK_OBJECT(dialogWindow), "key_press_event",
G_CALLBACK(DialogEscapePressed), NULL);
/* hookup to when the dialog is destroyed */
g_signal_connect(GTK_OBJECT(dialogWindow), "destroy",
G_CALLBACK(onDestroyWidget), This);
gtk_widget_show_all(dialogWindow);
}
int
main (int argc, char *argv[])
{
GtkWidget *box;
GtkWidget *menubar;
GtkWidget *menuitem;
GtkWidget *menu;
GtkWidget *button;
GtkAccelGroup *accel_group;
gtk_init (&argc, &argv);
manager = gtk_recent_manager_get_default ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), -1, -1);
gtk_window_set_title (GTK_WINDOW (window), "Recent Chooser Menu Test");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show (box);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_file_menu (accel_group);
menuitem = gtk_menu_item_new_with_mnemonic ("_File");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menu = create_recent_chooser_menu (4);
menuitem = gtk_menu_item_new_with_mnemonic ("_Recently Used");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
label = gtk_label_new ("No recent item selected");
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_end (GTK_BOX (box), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
/**
* Create main dialog decorations (excluding notebook pages).
*/
static void export_html_dialog_create( void ) {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *vnbox;
GtkWidget *notebook;
GtkWidget *hbbox;
GtkWidget *btnPrev;
GtkWidget *btnNext;
GtkWidget *btnCancel;
GtkWidget *hsbox;
GtkWidget *statusbar;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_widget_set_usize(window, EXPORTHTML_WIDTH, EXPORTHTML_HEIGHT );
gtk_container_set_border_width( GTK_CONTAINER(window), 0 );
gtk_window_set_title( GTK_WINDOW(window),
_("Export Address Book to HTML File") );
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(export_html_delete_event),
NULL );
gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
GTK_SIGNAL_FUNC(export_html_key_pressed),
NULL );
vbox = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
vnbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4);
gtk_widget_show(vnbox);
gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0);
/* Notebook */
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), FALSE ); /* Hide */
/* gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), TRUE ); */
gtk_widget_show(notebook);
gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);
/* Status line */
hsbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
/* Button panel */
gtkut_button_set_create(&hbbox, &btnPrev, _( "Prev" ),
&btnNext, _( "Next" ),
&btnCancel, _( "Cancel" ) );
gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbbox), 2);
gtk_widget_grab_default(btnNext);
/* Button handlers */
gtk_signal_connect(GTK_OBJECT(btnPrev), "clicked",
GTK_SIGNAL_FUNC(export_html_prev), NULL);
gtk_signal_connect(GTK_OBJECT(btnNext), "clicked",
GTK_SIGNAL_FUNC(export_html_next), NULL);
gtk_signal_connect(GTK_OBJECT(btnCancel), "clicked",
GTK_SIGNAL_FUNC(export_html_cancel), NULL);
gtk_widget_show_all(vbox);
exphtml_dlg.window = window;
exphtml_dlg.notebook = notebook;
exphtml_dlg.btnPrev = btnPrev;
exphtml_dlg.btnNext = btnNext;
exphtml_dlg.btnCancel = btnCancel;
exphtml_dlg.statusbar = statusbar;
exphtml_dlg.status_cid = gtk_statusbar_get_context_id(
GTK_STATUSBAR(statusbar), "Export HTML Dialog" );
}
MergeDialog::MergeDialog(const ustring & text)
{
event_textbuffer = 0;
extern Settings *settings;
mergedialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(mergedialog), _("Merge"));
gtk_window_set_position(GTK_WINDOW(mergedialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal(GTK_WINDOW(mergedialog), TRUE);
gtk_window_set_default_size(GTK_WINDOW(mergedialog), (int)(settings->genconfig.screen_width_get() * 0.8), (int)(settings->genconfig.screen_height_get() * 0.9));
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (mergedialog));
gtk_widget_show(dialog_vbox1);
label = gtk_label_new(_("The merge operation needs manual intervention. Each place that needs intervention shows two buttons with the two alternatives. Please press the buttons with the correct text."));
gtk_label_set_line_wrap(GTK_LABEL(label), true);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), label, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_IN);
textview = gtk_text_view_new();
gtk_widget_show(textview);
gtk_container_add(GTK_CONTAINER(scrolledwindow), textview);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(mergedialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(mergedialog, NULL, NULL, NULL);
cancelbutton = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(mergedialog), cancelbutton, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton), true);
okbutton = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(mergedialog), okbutton, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton), true);
gtk_widget_set_sensitive(okbutton, false);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
g_signal_connect_after((gpointer) textbuffer, "changed", G_CALLBACK(on_textbuffer_changed), gpointer(this));
gtk_widget_grab_focus(textview);
gtk_widget_grab_default(okbutton);
load_text(text);
}
UmPasswordDialog *
um_password_dialog_new (void)
{
GtkBuilder *builder;
GError *error;
UmPasswordDialog *um;
GtkWidget *widget;
const char *old_label;
char *label;
gint len;
builder = gtk_builder_new ();
error = NULL;
if (!gtk_builder_add_from_resource (builder,
"/org/gnome/control-center/user-accounts/password-dialog.ui",
&error)) {
g_error ("%s", error->message);
g_error_free (error);
return NULL;
}
um = g_new0 (UmPasswordDialog, 1);
um->action_label = (GtkWidget *) gtk_builder_get_object (builder, "action-label");
widget = (GtkWidget *) gtk_builder_get_object (builder, "action-combo");
g_signal_connect (widget, "changed",
G_CALLBACK (action_changed), um);
um->action_combo = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "dialog");
g_signal_connect (widget, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
um->dialog = widget;
um->user_icon = (GtkWidget *) gtk_builder_get_object (builder, "user-icon");
um->user_name = (GtkWidget *) gtk_builder_get_object (builder, "user-name");
widget = (GtkWidget *) gtk_builder_get_object (builder, "cancel-button");
g_signal_connect (widget, "clicked",
G_CALLBACK (cancel_password_dialog), um);
widget = (GtkWidget *) gtk_builder_get_object (builder, "ok-button");
g_signal_connect (widget, "clicked",
G_CALLBACK (accept_password_dialog), um);
gtk_widget_grab_default (widget);
um->ok_button = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "password-normal-strength-hints-label");
old_label = gtk_label_get_label (GTK_LABEL (widget));
label = g_strdup_printf ("<a href=\"%s\">%s</a>",
"help:gnome-help/user-goodpassword",
old_label);
gtk_label_set_markup (GTK_LABEL (widget), label);
g_free (label);
widget = (GtkWidget *) gtk_builder_get_object (builder, "show-password-checkbutton");
g_signal_connect (widget, "toggled",
G_CALLBACK (show_password_toggled), um);
um->show_password_button = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "password-entry");
g_signal_connect (widget, "notify::text",
G_CALLBACK (password_entry_changed), um);
g_signal_connect_after (widget, "focus-out-event",
G_CALLBACK (password_entry_focus_out), um);
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
g_signal_connect (widget, "icon-press",
G_CALLBACK (activate_icon), um);
g_signal_connect (widget, "populate-popup",
G_CALLBACK (populate_menu), um);
um->password_entry = widget;
widget = (GtkWidget *) gtk_builder_get_object (builder, "old-password-entry");
g_signal_connect_after (widget, "focus-out-event",
G_CALLBACK (old_password_entry_focus_out), um);
g_signal_connect (widget, "notify::text",
G_CALLBACK (old_password_entry_changed), um);
g_signal_connect (widget, "activate",
G_CALLBACK (old_password_entry_activate), um);
um->old_password_entry = widget;
um->old_password_label = (GtkWidget *) gtk_builder_get_object (builder, "old-password-label");
widget = (GtkWidget *) gtk_builder_get_object (builder, "verify-entry");
g_signal_connect (widget, "notify::text",
G_CALLBACK (verify_entry_changed), um);
g_signal_connect_after (widget, "focus-out-event",
G_CALLBACK (verify_entry_focus_out), um);
um->verify_entry = widget;
len = 0;
len = MAX (len, strlen (C_("Password strength", "Too short")));
len = MAX (len, strlen (C_("Password strength", "Weak")));
len = MAX (len, strlen (C_("Password strength", "Fair")));
len = MAX (len, strlen (C_("Password strength", "Good")));
len = MAX (len, strlen (C_("Password strength", "Strong")));
len += 2;
widget = (GtkWidget *) gtk_builder_get_object (builder, "strength-indicator-label");
gtk_label_set_width_chars (GTK_LABEL (widget), len);
um->strength_indicator = (GtkWidget *) gtk_builder_get_object (builder, "strength-indicator");
um->strength_indicator_label = (GtkWidget *) gtk_builder_get_object (builder, "strength-indicator-label");
g_object_unref (builder);
return um;
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *vbox, *hbox;
GtkWidget *entry;
GtkWidget *button;
GtkWidget *check;
gint position;
GTimer *tim = g_timer_new();
gtk_init (&argc, &argv);
g_timer_start(tim);
/* create a new window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request( GTK_WIDGET (window), 200, 100);
gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
g_signal_connect(G_OBJECT (window), "delete_event",
G_CALLBACK(exit), NULL);
#if GTK_CHECK_VERSION(3, 2, 0)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#else
vbox = gtk_vbox_new (FALSE, 0);
#endif
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY(entry), 50);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(enter_callback),
entry);
gtk_entry_set_text (GTK_ENTRY (entry), "hello");
gtk_editable_insert_text (GTK_EDITABLE (entry), " world", -1, &position);
gtk_editable_select_region (GTK_EDITABLE (entry),
0, gtk_entry_get_text_length(GTK_ENTRY(entry)));
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
#if GTK_CHECK_VERSION(3, 2, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new (FALSE, 0);
#endif
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_widget_show (hbox);
check = gtk_check_button_new_with_label("Editable");
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(check), "toggled",
G_CALLBACK(entry_toggle_editable), entry);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Visible");
gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT(check), "toggled",
G_CALLBACK(entry_toggle_visibility), entry);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK(exit),
G_OBJECT (window));
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_widget_set_can_default (button, TRUE);
#else
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
#endif
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show(window);
g_print("elapsed time: %f\n",g_timer_elapsed(tim,NULL));
g_timer_destroy(tim);
gtk_main();
return(0);
}
int DoMessageBox( const char* lpText, const char* lpCaption, guint32 uType ){
GtkWidget *window, *w, *vbox, *hbox;
int mode = ( uType & MB_TYPEMASK ), ret, loop = 1;
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_signal_connect( GTK_OBJECT( window ), "delete_event",
GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
gtk_signal_connect( GTK_OBJECT( window ), "destroy",
GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
gtk_window_set_title( GTK_WINDOW( window ), lpCaption );
gtk_container_border_width( GTK_CONTAINER( window ), 10 );
g_object_set_data( G_OBJECT( window ), "loop", &loop );
g_object_set_data( G_OBJECT( window ), "ret", &ret );
gtk_widget_realize( window );
vbox = gtk_vbox_new( FALSE, 10 );
gtk_container_add( GTK_CONTAINER( window ), vbox );
gtk_widget_show( vbox );
w = gtk_label_new( lpText );
gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 2 );
gtk_label_set_justify( GTK_LABEL( w ), GTK_JUSTIFY_LEFT );
gtk_widget_show( w );
w = gtk_hseparator_new();
gtk_box_pack_start( GTK_BOX( vbox ), w, FALSE, FALSE, 2 );
gtk_widget_show( w );
hbox = gtk_hbox_new( FALSE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 2 );
gtk_widget_show( hbox );
if ( mode == MB_OK ) {
w = gtk_button_new_with_label( "Ok" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
gtk_widget_grab_default( w );
gtk_widget_show( w );
ret = IDOK;
}
else if ( mode == MB_OKCANCEL ) {
w = gtk_button_new_with_label( "Ok" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
gtk_widget_grab_default( w );
gtk_widget_show( w );
w = gtk_button_new_with_label( "Cancel" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDCANCEL ) );
gtk_widget_show( w );
ret = IDCANCEL;
}
else if ( mode == MB_YESNOCANCEL ) {
w = gtk_button_new_with_label( "Yes" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDYES ) );
GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
gtk_widget_grab_default( w );
gtk_widget_show( w );
w = gtk_button_new_with_label( "No" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDNO ) );
gtk_widget_show( w );
w = gtk_button_new_with_label( "Cancel" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDCANCEL ) );
gtk_widget_show( w );
ret = IDCANCEL;
}
else /* if (mode == MB_YESNO) */
{
w = gtk_button_new_with_label( "Yes" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDYES ) );
GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
gtk_widget_grab_default( w );
gtk_widget_show( w );
w = gtk_button_new_with_label( "No" );
gtk_box_pack_start( GTK_BOX( hbox ), w, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( w ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDNO ) );
gtk_widget_show( w );
ret = IDNO;
}
gtk_widget_show( window );
gtk_grab_add( window );
while ( loop )
gtk_main_iteration();
gtk_grab_remove( window );
gtk_widget_destroy( window );
return ret;
}
static GtkWidget *
build_heur_dissectors_treeview(void)
{
GtkWidget *bbox, *proto_list, *label, *proto_sw, *proto_vb, *button,
*ok_bt, *save_bt, *cancel_bt;
static const gchar *titles[] = { "Status", "Heuristic Protocol", "Description" };
GtkListStore *proto_store;
GtkCellRenderer *proto_rend;
GtkTreeViewColumn *proto_col;
/* Protocol list */
proto_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
gtk_widget_show(proto_vb);
proto_sw = scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(proto_sw),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(proto_vb), proto_sw, TRUE, TRUE, 0);
gtk_widget_show(proto_sw);
proto_store = gtk_list_store_new(4, G_TYPE_BOOLEAN, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER);
show_heur_selection(proto_store);
/* default sort on "abbrev" column */
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(proto_store), 1,
GTK_SORT_ASCENDING);
proto_list = tree_view_new(GTK_TREE_MODEL(proto_store));
gtk_container_add(GTK_CONTAINER(proto_sw), proto_list);
proto_rend = gtk_cell_renderer_toggle_new();
g_signal_connect(proto_rend, "toggled", G_CALLBACK(status_toggled), proto_store);
proto_col = gtk_tree_view_column_new_with_attributes(titles[0], proto_rend, "active", 0, NULL);
gtk_tree_view_column_set_sort_column_id(proto_col, 0);
g_signal_connect(proto_col, "clicked", G_CALLBACK(proto_col_clicked_cb), proto_list);
gtk_tree_view_append_column(GTK_TREE_VIEW(proto_list), proto_col);
proto_rend = gtk_cell_renderer_text_new();
proto_col = gtk_tree_view_column_new_with_attributes(titles[1], proto_rend, "text", 1, NULL);
gtk_tree_view_column_set_sort_column_id(proto_col, 1);
g_signal_connect(proto_col, "clicked", G_CALLBACK(proto_col_clicked_cb), proto_list);
gtk_tree_view_append_column(GTK_TREE_VIEW(proto_list), proto_col);
proto_rend = gtk_cell_renderer_text_new();
proto_col = gtk_tree_view_column_new_with_attributes(titles[2], proto_rend, "text", 2, NULL);
gtk_tree_view_column_set_sort_column_id(proto_col, 2);
g_signal_connect(proto_col, "clicked", G_CALLBACK(proto_col_clicked_cb), proto_list);
gtk_tree_view_append_column(GTK_TREE_VIEW(proto_list), proto_col);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(proto_list), 1); /* col 1 in the *model* */
g_object_unref(G_OBJECT(proto_store));
gtk_widget_show(proto_list);
label = gtk_label_new("Disabling a heuristic dissector prevents higher "
"layer protocols from being displayed");
gtk_misc_set_alignment(GTK_MISC(label), 0.5f, 0.5f);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(proto_vb), label, FALSE, FALSE, 5);
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(proto_vb), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
/* Enable All */
button = gtk_button_new_with_label("Enable All");
g_signal_connect(button, "clicked", G_CALLBACK(enable_all_cb), proto_list);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* Disable All */
button = gtk_button_new_with_label("Disable All");
g_signal_connect(button, "clicked", G_CALLBACK(disable_all_cb), proto_list);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* Invert */
button = gtk_button_new_with_label("Invert");
g_signal_connect(button, "clicked", G_CALLBACK(toggle_all_cb), proto_list);
gtk_box_pack_start(GTK_BOX(bbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* Button row */
bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_APPLY, GTK_STOCK_SAVE, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
gtk_box_pack_start(GTK_BOX(proto_vb), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
/*g_signal_connect(ok_bt, "clicked", G_CALLBACK(proto_ok_cb), proto_w);*/
gtk_widget_grab_default(ok_bt);
/*apply_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_APPLY);*/
/* g_signal_connect(apply_bt, "clicked", G_CALLBACK(proto_apply_cb), proto_w);*/
save_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE);
/* g_signal_connect(save_bt, "clicked", G_CALLBACK(proto_save_cb), proto_w);*/
cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
window_set_cancel_button(proto_w, cancel_bt, proto_cancel_cb);
/*help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);*/
/*g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_ENABLED_PROTOCOLS_DIALOG);*/
/*g_signal_connect(proto_w, "delete_event", G_CALLBACK(proto_delete_event_cb), NULL);*/
g_signal_connect(proto_w, "destroy", G_CALLBACK(heur_proto_destroy_cb), NULL);
gtk_widget_show(proto_w);
gtk_widget_grab_focus(proto_list); /* XXX: force focus to the tree_view. This hack req'd so "type-ahead find"
* will be effective after the window is displayed. The issue is
* that any call to gtk_tree_view_column_set_sort_column_id above
* apparently sets the focus to the column header button and thus
* type-ahead find is, in effect, disabled on the column.
* Also required: a grab_focus whenever the column header is
* clicked to change the column sort order since the click
* also changes the focus to the column header button.
* Is there a better way to do this ?
*/
/* hide the Save button if the user uses implicit save */
if(!prefs.gui_use_pref_save) {
gtk_widget_hide(save_bt);
}
return proto_vb;
}
void show_new_game(GtkMenuItem *menuitem,
gpointer user_data)
{
GtkWidget *label;
GtkWidget *frame;
GtkWidget *vbox,*hbox;
GtkWidget *table;
GtkWidget *button;
GtkWidget *button1;
GtkWidget *button2;
GtkAdjustment *adj;
new_game_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect ((gpointer) new_game_window, "destroy",
G_CALLBACK (show_new_game_close),
GINT_TO_POINTER(FALSE));
gtk_window_set_title(GTK_WINDOW(new_game_window),"Level settings");
gtk_window_set_position(GTK_WINDOW(new_game_window),GTK_WIN_POS_CENTER);
gtk_container_border_width(GTK_CONTAINER(new_game_window),3);
vbox = gtk_vbox_new(FALSE,2);
gtk_container_add(GTK_CONTAINER(new_game_window),vbox);
frame = gtk_frame_new(NULL);
gtk_box_pack_start(GTK_BOX(vbox),frame,TRUE,TRUE,TRUE);
table = gtk_table_new(3,2,TRUE);
gtk_container_add(GTK_CONTAINER(frame),table);
label = gtk_label_new("Start level:");
adj = (GtkAdjustment *)gtk_adjustment_new(options.level,0,
NUM_LEVELS-1,1,1,0);
spin_level = gtk_spin_button_new(adj,0,0);
gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,0,1);
gtk_table_attach_defaults(GTK_TABLE(table),spin_level,1,2,0,1);
label = gtk_label_new("Noise level:");
adj = (GtkAdjustment *)gtk_adjustment_new(options.noise_l,0,MAX_X-1,1,1,0);
spin_noise_level = gtk_spin_button_new(adj,0,0);
gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,1,2);
gtk_table_attach_defaults(GTK_TABLE(table),spin_noise_level,1,2,1,2);
label = gtk_label_new("Noise height:");
adj = (GtkAdjustment *)gtk_adjustment_new(options.noise_h,0,MAX_Y-4,1,1,0);
spin_noise_height = gtk_spin_button_new(adj,0,0);
gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,2,3);
gtk_table_attach_defaults(GTK_TABLE(table),spin_noise_height,1,2,2,3);
hbox = gtk_hbox_new(TRUE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,0);
button = gtk_button_new_with_label("Play");
g_signal_connect ((gpointer) button, "clicked",
G_CALLBACK (game_new_wrapper),
NULL);
gtk_box_pack_start(GTK_BOX(hbox),button,FALSE,TRUE,0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
button1 = gtk_button_new_with_label("Accept");
g_signal_connect ((gpointer) button1, "clicked",
G_CALLBACK (game_new_accept),
NULL);
gtk_box_pack_start(GTK_BOX(hbox),button1,FALSE,TRUE,0);
GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
button2 = gtk_button_new_with_label("Close");
g_signal_connect ((gpointer) button2, "clicked",
G_CALLBACK (show_new_game_close),
GINT_TO_POINTER(TRUE));
gtk_box_pack_start(GTK_BOX(hbox),button2,FALSE,TRUE,0);
GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
gtk_widget_set_usize(new_game_window,220,130);
gtk_widget_show_all(new_game_window);
gtk_widget_set_sensitive(menu_game_start,FALSE);
gtk_widget_set_sensitive(menu_game_quick,FALSE);
}
int main(int argc,char *argv[])
{
char dmmy[20];
GtkWidget *main_window;
GtkWidget *v_box;
GtkWidget *h_box;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *right_side;
GtkWidget *game_border;
GtkWidget *next_block_border;
GdkBitmap *mask;
GtkWidget *menu_bar;
GtkWidget *menu_game;
GtkWidget *menu_game_menu;
GtkWidget *separatormenuitem1;
GtkWidget *separator1;
GtkWidget *menu_settings;
GtkWidget *menu_settings_menu;
GtkWidget *menu_help;
GtkWidget *menu_help_menu;
GtkWidget *help1;
GtkWidget *high_scores1;
GtkWidget *separator2;
GtkWidget *about1;
GtkAccelGroup* accel_group;
//init game values
game_play=FALSE;
get_opt_file(options_f,100);
read_options();
game_over = TRUE;
game_pause = FALSE;
current_x = current_y = 0;
current_block = current_frame = 0;
current_score = current_lines = 0;
current_level = options.level;
next_block = next_frame = 0;
// seed random generator
srandom(time(NULL));
//options.shw_nxt = TRUE;
gtk_set_locale();
gtk_init(&argc,&argv);
accel_group = gtk_accel_group_new();
// window
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy(GTK_WINDOW(main_window),FALSE,FALSE,TRUE);
gtk_window_set_title(GTK_WINDOW(main_window),"GTK Tetris");
g_signal_connect ((gpointer) main_window, "key_press_event",
G_CALLBACK (keyboard_event_handler),
NULL);
// vertical box
v_box = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(main_window),v_box);
gtk_widget_show(v_box);
// menu stuff
menu_bar = gtk_menu_bar_new();
gtk_widget_show(menu_bar);
gtk_box_pack_start(GTK_BOX(v_box),menu_bar,FALSE,FALSE,0);
//Game sub-menu
menu_game=gtk_menu_item_new_with_mnemonic ("_Game");
gtk_widget_show(menu_game);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_game);
menu_game_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_game), menu_game_menu);
menu_game_quick = gtk_menu_item_new_with_mnemonic ("Start Game");
gtk_widget_show (menu_game_quick);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quick);
g_signal_connect ((gpointer) menu_game_quick, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_quick, "activate", accel_group,
GDK_G, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_game_stop = gtk_menu_item_new_with_mnemonic ("Stop Game");
gtk_widget_show (menu_game_stop);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_stop);
g_signal_connect ((gpointer) menu_game_stop, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_stop, "activate", accel_group,
GDK_O, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_set_sensitive(menu_game_stop,FALSE);
menu_game_pause = gtk_check_menu_item_new_with_mnemonic ("Pause");
gtk_widget_show (menu_game_pause);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_pause);
g_signal_connect ((gpointer) menu_game_pause, "activate",
G_CALLBACK (game_set_pause),
NULL);
gtk_widget_add_accelerator (menu_game_pause, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separatormenuitem1 = gtk_menu_item_new ();
gtk_widget_show (separatormenuitem1);
gtk_container_add (GTK_CONTAINER (menu_game_menu), separatormenuitem1);
gtk_widget_set_sensitive (separatormenuitem1, FALSE);
menu_game_quit = gtk_menu_item_new_with_mnemonic ("Quit");
gtk_widget_show (menu_game_quit);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quit);
g_signal_connect ((gpointer) menu_game_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_widget_add_accelerator(menu_game_quit,"activate", accel_group,
GDK_X, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
//Settings sub-menu
menu_settings = gtk_menu_item_new_with_mnemonic ("_Settings");
gtk_widget_show (menu_settings);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_settings);
menu_settings_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_settings),
menu_settings_menu);
menu_game_start = gtk_menu_item_new_with_mnemonic ("Level Settings");
gtk_widget_show (menu_game_start);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_game_start);
g_signal_connect ((gpointer) menu_game_start, "activate",
G_CALLBACK (show_new_game),
NULL);
menu_game_show_next_block = gtk_check_menu_item_new_with_mnemonic ("Show next block");
gtk_widget_show (menu_game_show_next_block);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_game_show_next_block);
if (options.shw_nxt)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_game_show_next_block),
TRUE);
g_signal_connect ((gpointer) menu_game_show_next_block, "activate",
G_CALLBACK (game_show_next_block),
NULL);
gtk_widget_add_accelerator (menu_game_show_next_block, "activate",
accel_group,
GDK_N, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separator1 = gtk_menu_item_new ();
gtk_widget_show (separator1);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), separator1);
gtk_widget_set_sensitive (separator1, FALSE);
menu_save_options = gtk_menu_item_new_with_mnemonic ("Save Settings");
gtk_widget_show (menu_save_options);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_save_options);
g_signal_connect ((gpointer) menu_save_options, "activate",
G_CALLBACK (save_options),
NULL);
//Help sub-menu
menu_help=gtk_menu_item_new_with_mnemonic ("_Help");
gtk_widget_show (menu_help);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_help);
gtk_menu_item_set_right_justified (GTK_MENU_ITEM(menu_help),TRUE);
menu_help_menu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_help),
menu_help_menu);
help1 = gtk_menu_item_new_with_mnemonic ("Help");
gtk_widget_show (help1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), help1);
g_signal_connect ((gpointer) help1, "activate",
G_CALLBACK (show_help),
NULL);
gtk_widget_add_accelerator (help1, "activate",
accel_group,
GDK_F1, (GdkModifierType) 0,
GTK_ACCEL_VISIBLE);
high_scores1 = gtk_menu_item_new_with_mnemonic ("High-scores");
gtk_widget_show (high_scores1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), high_scores1);
g_signal_connect ((gpointer) high_scores1, "activate",
G_CALLBACK (show_highscore_wrapper),
NULL);
separator2 = gtk_menu_item_new ();
gtk_widget_show (separator2);
gtk_container_add (GTK_CONTAINER (menu_help_menu), separator2);
gtk_widget_set_sensitive (separator2, FALSE);
about1 = gtk_menu_item_new_with_mnemonic ("About");
gtk_widget_show (about1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), about1);
g_signal_connect ((gpointer) about1, "activate",
G_CALLBACK (show_about),
NULL);
// horizontal box
h_box = gtk_hbox_new(FALSE,1);
gtk_widget_show(h_box);
gtk_box_pack_start(GTK_BOX(v_box),h_box,FALSE,FALSE,0);
// game_border
game_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(game_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(h_box),game_border,FALSE,FALSE,1);
gtk_widget_show(game_border);
// game_area
game_area = gtk_drawing_area_new();
gtk_widget_show(game_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(game_area),
MAX_X*BLOCK_WIDTH,MAX_Y*BLOCK_HEIGHT);
g_signal_connect ((gpointer) game_area, "expose_event",
G_CALLBACK (game_area_expose_event),
NULL);
gtk_widget_set_events(game_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(game_border),game_area);
// right_side
right_side = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(h_box),right_side,FALSE,FALSE,0);
gtk_widget_show(right_side);
// next_block_border
next_block_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(next_block_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(right_side),next_block_border,FALSE,FALSE,0);
gtk_widget_show(next_block_border);
// next_block_area
next_block_area = gtk_drawing_area_new();
gtk_widget_show(next_block_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(next_block_area),
4*BLOCK_WIDTH,4*BLOCK_HEIGHT);
g_signal_connect ((gpointer) next_block_area, "expose_event",
G_CALLBACK (next_block_area_expose_event),
NULL);
gtk_widget_set_events(next_block_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(next_block_border),next_block_area);
// the score,level and lines labels
score_label1 = gtk_label_new("Score:");
gtk_label_set_justify(GTK_LABEL(score_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label1);
gtk_box_pack_start(GTK_BOX(right_side),score_label1,FALSE,FALSE,3);
score_label2 = gtk_label_new("0");
set_gtk_color_style(score_label2,0xffff,0,0);
gtk_label_set_justify(GTK_LABEL(score_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label2);
gtk_box_pack_start(GTK_BOX(right_side),score_label2,FALSE,FALSE,3);
level_label1 = gtk_label_new("Level:");
gtk_label_set_justify(GTK_LABEL(level_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label1);
gtk_box_pack_start(GTK_BOX(right_side),level_label1,FALSE,FALSE,3);
sprintf(dmmy,"%d",current_level);
level_label2 = gtk_label_new(dmmy);
set_gtk_color_style(level_label2,0,0,0xffff);
gtk_label_set_justify(GTK_LABEL(level_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label2);
gtk_box_pack_start(GTK_BOX(right_side),level_label2,FALSE,FALSE,3);
lines_label1 = gtk_label_new("Lines:");
gtk_label_set_justify(GTK_LABEL(lines_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label1);
gtk_box_pack_start(GTK_BOX(right_side),lines_label1,FALSE,FALSE,3);
lines_label2 = gtk_label_new("0");
gtk_label_set_justify(GTK_LABEL(lines_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label2);
gtk_box_pack_start(GTK_BOX(right_side),lines_label2,FALSE,FALSE,3);
//the game buttons
//Start_stop
Start_stop_button = gtk_button_new();
gtk_widget_show(Start_stop_button);
g_signal_connect ((gpointer) Start_stop_button, "clicked",
G_CALLBACK (game_start_stop),
NULL);
Start_stop_button_label= gtk_label_new(start_stop_str[0]);
box2 = label_box(right_side, Start_stop_button_label,
start_stop_str[0] );
gtk_widget_show(box2);
gtk_container_add (GTK_CONTAINER (Start_stop_button), box2);
gtk_box_pack_start(GTK_BOX(right_side),Start_stop_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Start_stop_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(Start_stop_button);
//Pause
Pause_button = gtk_button_new();
gtk_widget_show(Pause_button);
g_signal_connect ((gpointer) Pause_button, "clicked",
G_CALLBACK (game_set_pause_b),
NULL);
Pause_button_label = gtk_label_new(pause_str[0]);
box1 = label_box(right_side, Pause_button_label, pause_str[0] );
gtk_widget_show(box1);
gtk_container_add (GTK_CONTAINER (Pause_button), box1);
gtk_box_pack_start(GTK_BOX(right_side),Pause_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Pause_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(Pause_button,FALSE);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
gtk_widget_show(main_window);
// Block images...
blocks_pixmap = gdk_pixmap_create_from_xpm_d(game_area->window,
&mask,
NULL,
(gchar **)blocks_xpm);
gtk_main ();
return 0;
}
void show_help(GtkMenuItem *menuitem,
gpointer user_data)
{
GtkWidget *Help_close_button;
GtkWidget *help_label;
GtkWidget *help_border;
GtkWidget *hbox;
GtkWidget *vbox;
help_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(help_window),"Help");
gtk_window_set_policy(GTK_WINDOW(help_window),FALSE,FALSE,TRUE);
gtk_window_set_position(GTK_WINDOW(help_window),GTK_WIN_POS_CENTER);
gtk_container_border_width(GTK_CONTAINER(help_window),1);
help_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(help_border),GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(help_window),help_border);
vbox = gtk_vbox_new(FALSE,3);
gtk_container_add(GTK_CONTAINER(help_border),vbox);
hbox = gtk_hbox_new(FALSE,30);
gtk_container_add(GTK_CONTAINER(vbox),hbox);
help_label = gtk_label_new( "\nKeys:\n"
"Right and \"d\"\n"
"Left and \"a\"\n"
"\"s\"\n"
"Up and \"w\"\n"
"\"x\"\n"
"Space ans Down\n\n"
"Score: score*level\n"
"Single\n"
"Double\n"
"Triple\n"
"TETRIS\n\n"
"Drop bonus: rows*level\n");
gtk_misc_set_alignment(GTK_MISC(help_label),0,0);
gtk_label_set_justify(GTK_LABEL(help_label),GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(hbox),help_label,TRUE,TRUE,TRUE);
help_label = gtk_label_new( "\n\n"
"move right\n"
"move left\n"
"move down\n"
"rotate ccw\n"
"rotate cw\n"
"drop block\n\n\n"
"40\n100\n"
"300\n1200\n");
gtk_misc_set_alignment(GTK_MISC(help_label),0,0);
gtk_label_set_justify(GTK_LABEL(help_label),GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(hbox),help_label,TRUE,TRUE,TRUE);
Help_close_button = gtk_button_new_with_label("Close");
g_signal_connect ((gpointer) Help_close_button, "clicked",
G_CALLBACK (help_close),
NULL);
gtk_box_pack_start(GTK_BOX(vbox),Help_close_button,FALSE,TRUE,0);
GTK_WIDGET_SET_FLAGS(Help_close_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(Help_close_button);
gtk_widget_show_all(help_window);
}
static void addressbook_edit_jpilot_create( gboolean *cancelled ) {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
GtkWidget *name_entry;
GtkWidget *file_entry;
GtkWidget *vbox_custom;
GtkWidget *frame_custom;
GtkWidget *custom_check[JPILOT_NUM_CUSTOM_LABEL];
GtkWidget *custom_label[JPILOT_NUM_CUSTOM_LABEL];
GtkWidget *hlbox;
GtkWidget *hbbox;
GtkWidget *hsep;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *check_btn;
GtkWidget *file_btn;
GtkWidget *hsbox;
GtkWidget *statusbar;
gint top, i;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, 450, -1);
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
gtk_window_set_title(GTK_WINDOW(window), _("Edit JPilot Entry"));
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(edit_jpilot_delete_event),
cancelled);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(edit_jpilot_key_pressed),
cancelled);
vbox = gtk_vbox_new(FALSE, 8);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_container_set_border_width( GTK_CONTAINER(vbox), 0 );
table = gtk_table_new(2 + JPILOT_NUM_CUSTOM_LABEL, 3, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_container_set_border_width( GTK_CONTAINER(table), 8 );
gtk_table_set_row_spacings(GTK_TABLE(table), 8);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
/* First row */
top = 0;
label = gtk_label_new(_("Name"));
gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
name_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), name_entry, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
check_btn = gtk_button_new_with_label( _(" Check File "));
gtk_table_attach(GTK_TABLE(table), check_btn, 2, 3, top, (top + 1), GTK_FILL, 0, 3, 0);
/* Second row */
top = 1;
label = gtk_label_new(_("File"));
gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
file_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), file_entry, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
file_btn = gtk_button_new_with_label( _(" ... "));
gtk_table_attach(GTK_TABLE(table), file_btn, 2, 3, top, (top + 1), GTK_FILL, 0, 3, 0);
/* Third row */
top = 2;
frame_custom = gtk_frame_new(_("Additional e-Mail address item(s)"));
gtk_table_attach(GTK_TABLE(table), frame_custom, 1, 2, top, (top + JPILOT_NUM_CUSTOM_LABEL), GTK_FILL, 0, 0, 0);
/* Now do custom labels. */
vbox_custom = gtk_vbox_new (FALSE, 8);
for( i = 0; i < JPILOT_NUM_CUSTOM_LABEL; i++ ) {
hlbox = gtk_hbox_new( FALSE, 0 );
custom_check[i] = gtk_check_button_new();
custom_label[i] = gtk_label_new( "" );
gtk_box_pack_start( GTK_BOX(hlbox), custom_check[i], FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX(hlbox), custom_label[i], TRUE, TRUE, 0 );
gtk_box_pack_start( GTK_BOX(vbox_custom), hlbox, TRUE, TRUE, 0 );
gtk_misc_set_alignment(GTK_MISC(custom_label[i]), 0, 0.5);
top++;
}
gtk_container_add (GTK_CONTAINER (frame_custom), vbox_custom);
gtk_container_set_border_width( GTK_CONTAINER(vbox_custom), 8 );
/* Status line */
hsbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, 0);
statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, 0);
/* Button panel */
gtkut_stock_button_set_create(&hbbox, &ok_btn, GTK_STOCK_OK,
&cancel_btn, GTK_STOCK_CANCEL,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
gtk_container_set_border_width( GTK_CONTAINER(hbbox), 0 );
gtk_widget_grab_default(ok_btn);
hsep = gtk_hseparator_new();
gtk_box_pack_end(GTK_BOX(vbox), hsep, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(ok_btn), "clicked",
G_CALLBACK(edit_jpilot_ok), cancelled);
g_signal_connect(G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(edit_jpilot_cancel), cancelled);
g_signal_connect(G_OBJECT(file_btn), "clicked",
G_CALLBACK(edit_jpilot_file_select), NULL);
g_signal_connect(G_OBJECT(check_btn), "clicked",
G_CALLBACK(edit_jpilot_file_check), NULL);
gtk_widget_show_all(vbox);
jpilotedit.window = window;
jpilotedit.name_entry = name_entry;
jpilotedit.file_entry = file_entry;
jpilotedit.hbbox = hbbox;
jpilotedit.ok_btn = ok_btn;
jpilotedit.cancel_btn = cancel_btn;
jpilotedit.statusbar = statusbar;
jpilotedit.status_cid = gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "Edit JPilot Dialog" );
for( i = 0; i < JPILOT_NUM_CUSTOM_LABEL; i++ ) {
jpilotedit.custom_check[i] = custom_check[i];
jpilotedit.custom_label[i] = custom_label[i];
}
}
static gchar*
passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad)
{
gchar *the_passphrase = NULL;
GtkWidget *vbox;
GtkWidget *confirm_box;
GtkWidget *window;
GtkWidget *pass_entry;
GtkWidget *ok_button;
GtkWidget *cancel_button;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("Passphrase"));
gtk_widget_set_size_request(window, 450, -1);
gtk_window_set_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);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(passphrase_deleted), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(passphrase_key_pressed), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
manage_window_set_transient(GTK_WINDOW(window));
vbox = gtk_vbox_new(FALSE, 8);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
if (uid_hint || pass_hint) {
GtkWidget *label;
label = create_description (uid_hint, pass_hint, prev_bad);
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
}
pass_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), pass_entry, FALSE, FALSE, 0);
gtk_entry_set_visibility(GTK_ENTRY(pass_entry), FALSE);
gtk_widget_grab_focus(pass_entry);
gtkut_stock_button_set_create(&confirm_box, &ok_button, GTK_STOCK_OK,
&cancel_button, GTK_STOCK_CANCEL,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), confirm_box, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(pass_entry), "activate",
G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(passphrase_cancel_cb), NULL);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
if (grab_all)
gtk_window_set_policy (GTK_WINDOW(window), FALSE, FALSE, TRUE);
gtk_widget_show_all(window);
if (grab_all) {
/* make sure that window is viewable
* FIXME: this is still not enough */
gtk_widget_show_now(window);
gdk_flush();
#ifdef GDK_WINDOWING_X11
gdk_x11_display_grab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
if (gdk_pointer_grab(window->window, TRUE, 0,
window->window, NULL, GDK_CURRENT_TIME)) {
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
g_warning("OOPS: Could not grab mouse\n");
gtk_widget_destroy(window);
return NULL;
}
if (gdk_keyboard_grab(window->window, FALSE, GDK_CURRENT_TIME)) {
gdk_display_pointer_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
g_warning("OOPS: Could not grab keyboard\n");
gtk_widget_destroy(window);
return NULL;
}
}
gtk_main();
if (grab_all) {
gdk_display_keyboard_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
gdk_flush();
}
manage_window_focus_out(window, NULL, NULL);
if (pass_ack) {
const gchar *entry_text;
entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry));
the_passphrase = g_locale_from_utf8(entry_text, -1, NULL, NULL, NULL);
if (!the_passphrase)
the_passphrase = g_strdup(entry_text);
}
gtk_widget_destroy(window);
return the_passphrase;
}
static void config_window_create(void)
{
GtkWidget *win_vbox;
GtkWidget *hbox;
GtkWidget *notebook;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *group;
GtkWidget *subgroup;
GtkWidget *button;
GtkWidget *tabcomp;
GtkWidget *ct_button;
GtkWidget *table;
GtkWidget *spin;
GtkWidget *scrolled;
GtkWidget *viewport;
GtkWidget *filter_view;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gint i;
configwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(configwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT (configwindow), "delete_event",
G_CALLBACK(config_window_delete), NULL);
gtk_window_set_resizable(GTK_WINDOW(configwindow), FALSE);
gtk_window_set_title(GTK_WINDOW(configwindow), _("GQview Preferences"));
gtk_window_set_wmclass(GTK_WINDOW(configwindow), "config", "GQview");
gtk_container_set_border_width(GTK_CONTAINER(configwindow), PREF_PAD_BORDER);
window_set_icon(configwindow, PIXBUF_INLINE_ICON_CONFIG, NULL);
win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(configwindow), win_vbox);
gtk_widget_show(win_vbox);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = pref_button_new(NULL, GTK_STOCK_OK, NULL, FALSE,
G_CALLBACK(config_window_ok_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
gtk_widget_show(button);
ct_button = button;
button = pref_button_new(NULL, GTK_STOCK_APPLY, NULL, FALSE,
G_CALLBACK(config_window_apply_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_CANCEL, NULL, FALSE,
G_CALLBACK(config_window_close_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
if (!generic_dialog_get_alternative_button_order(configwindow))
{
gtk_box_reorder_child(GTK_BOX(hbox), ct_button, -1);
}
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK(notebook), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(win_vbox), notebook, TRUE, TRUE, 0);
/* general options tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("General"));
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("Startup"), GTK_ORIENTATION_VERTICAL);
button = pref_checkbox_new_int(group, _("Change to folder:"),
startup_path_enable, &startup_path_enable_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(button, hbox);
tabcomp = tab_completion_new(&startup_path_entry, startup_path, NULL, NULL);
tab_completion_add_select_button(startup_path_entry, NULL, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
button = pref_button_new(hbox, NULL, _("Use current"), FALSE,
G_CALLBACK(startup_path_set_current), NULL);
group = pref_group_new(vbox, FALSE, _("Thumbnails"), GTK_ORIENTATION_VERTICAL);
table = pref_table_new(group, 2, 2, FALSE, FALSE);
add_thumb_size_menu(table, 0, 0, _("Size:"));
add_quality_menu(table, 0, 1, _("Quality:"), thumbnail_quality, &thumbnail_quality_c);
ct_button = pref_checkbox_new_int(group, _("Cache thumbnails"),
enable_thumb_caching, &enable_thumb_caching_c);
subgroup = pref_box_new(group, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_link_sensitivity(ct_button, subgroup);
button = pref_checkbox_new_int(subgroup, _("Use shared thumbnail cache"),
thumbnail_spec_standard, &thumbnail_spec_standard_c);
subgroup = pref_box_new(subgroup, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_link_sensitivity_swap(button, subgroup);
pref_checkbox_new_int(subgroup, _("Cache thumbnails into .thumbnails"),
enable_thumb_dirs, &enable_thumb_dirs_c);
#if 0
pref_checkbox_new_int(subgroup, _("Use xvpics thumbnails when found (read only)"),
use_xvpics_thumbnails, &use_xvpics_thumbnails_c);
#endif
pref_checkbox_new_int(group, _("Faster jpeg thumbnailing (may reduce quality)"),
thumbnail_fast, &thumbnail_fast_c);
group = pref_group_new(vbox, FALSE, _("Slide show"), GTK_ORIENTATION_VERTICAL);
slideshow_delay_c = slideshow_delay;
spin = pref_spin_new(group, _("Delay between image change:"), _("seconds"),
SLIDESHOW_MIN_SECONDS, SLIDESHOW_MAX_SECONDS, 1.0, 1,
slideshow_delay ? (double)slideshow_delay / SLIDESHOW_SUBSECOND_PRECISION : 10.0,
G_CALLBACK(slideshow_delay_cb), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
pref_checkbox_new_int(group, _("Random"), slideshow_random, &slideshow_random_c);
pref_checkbox_new_int(group, _("Repeat"), slideshow_repeat, &slideshow_repeat_c);
/* image tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Image"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("Zoom"), GTK_ORIENTATION_VERTICAL);
#if 0
add_dither_menu(dither_quality, &dither_quality_c, _("Dithering method:"), group);
#endif
table = pref_table_new(group, 2, 1, FALSE, FALSE);
add_quality_menu(table, 0, 0, _("Quality:"), zoom_quality, &zoom_quality_c);
pref_checkbox_new_int(group, _("Two pass zooming"),
two_pass_zoom, &two_pass_zoom_c);
pref_checkbox_new_int(group, _("Allow enlargement of image for zoom to fit"),
zoom_to_fit_expands, &zoom_to_fit_expands_c);
zoom_increment_c = zoom_increment;
spin = pref_spin_new(group, _("Zoom increment:"), NULL,
0.1, 4.0, 1.0, 1, (double)zoom_increment / 10.0,
G_CALLBACK(zoom_increment_cb), NULL);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(spin), GTK_UPDATE_ALWAYS);
group = pref_group_new(vbox, FALSE, _("When new image is selected:"), GTK_ORIENTATION_VERTICAL);
zoom_mode_c = zoom_mode;
button = pref_radiobutton_new(group, NULL, _("Zoom to original size"),
(zoom_mode == ZOOM_RESET_ORIGINAL),
G_CALLBACK(zoom_mode_original_cb), NULL);
button = pref_radiobutton_new(group, button, _("Fit image to window"),
(zoom_mode == ZOOM_RESET_FIT_WINDOW),
G_CALLBACK(zoom_mode_fit_cb), NULL);
button = pref_radiobutton_new(group, button, _("Leave Zoom at previous setting"),
(zoom_mode == ZOOM_RESET_NONE),
G_CALLBACK(zoom_mode_none_cb), NULL);
group = pref_group_new(vbox, FALSE, _("Appearance"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Black background"),
black_window_background, &black_window_background_c);
group = pref_group_new(vbox, FALSE, _("Convenience"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Refresh on file change"),
update_on_time_change, &update_on_time_change_c);
pref_checkbox_new_int(group, _("Preload next image"),
enable_read_ahead, &enable_read_ahead_c);
pref_checkbox_new_int(group, _("Auto rotate image using Exif information"),
exif_rotate_enable, &exif_rotate_enable_c);
/* window tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Windows"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
group = pref_group_new(vbox, FALSE, _("State"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Remember window positions"),
save_window_positions, &save_window_positions_c);
pref_checkbox_new_int(group, _("Remember tool state (float/hidden)"),
restore_tool, &restore_tool_c);
group = pref_group_new(vbox, FALSE, _("Size"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Fit window to image when tools are hidden/floating"),
fit_window, &fit_window_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
ct_button = pref_checkbox_new_int(hbox, _("Limit size when auto-sizing window (%):"),
limit_window_size, &limit_window_size_c);
spin = pref_spin_new_int(hbox, NULL, NULL,
10, 150, 1,
max_window_size, &max_window_size_c);
pref_checkbox_link_sensitivity(ct_button, spin);
group = pref_group_new(vbox, FALSE, _("Layout"), GTK_ORIENTATION_VERTICAL);
layout_widget = layout_config_new();
layout_config_set(layout_widget, layout_style, layout_order);
gtk_box_pack_start(GTK_BOX(group), layout_widget, FALSE, FALSE, 0);
gtk_widget_show(layout_widget);
/* filtering tab */
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER (vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Filtering"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
group = pref_box_new(vbox, FALSE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
pref_checkbox_new_int(group, _("Show entries that begin with a dot"),
show_dot_files, &show_dot_files_c);
pref_checkbox_new_int(group, _("Case sensitive sort"),
file_sort_case_sensitive, &file_sort_case_sensitive_c);
ct_button = pref_checkbox_new_int(group, _("Disable File Filtering"),
file_filter_disable, &file_filter_disable_c);
group = pref_group_new(vbox, TRUE, _("File types"), GTK_ORIENTATION_VERTICAL);
frame = pref_group_parent(group);
g_signal_connect(G_OBJECT(ct_button), "toggled",
G_CALLBACK(filter_disable_cb), frame);
gtk_widget_set_sensitive(frame, !file_filter_disable);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(group), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
filter_store = gtk_list_store_new(1, G_TYPE_POINTER);
filter_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(filter_store));
g_object_unref(filter_store);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(filter_view));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(filter_view), FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Filter"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(filter_store_enable_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_ENABLE), NULL);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_ext_edit_cb), filter_store);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_EXTENSION), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Description"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(filter_store_desc_edit_cb), filter_store);
g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, filter_set_func,
GINT_TO_POINTER(FE_DESCRIPTION), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(filter_view), column);
filter_store_populate();
gtk_container_add(GTK_CONTAINER(scrolled), filter_view);
gtk_widget_show(filter_view);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
G_CALLBACK(filter_default_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_REMOVE, NULL, FALSE,
G_CALLBACK(filter_remove_cb), filter_view);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_ADD, NULL, FALSE,
G_CALLBACK(filter_add_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* editor entry tab */
vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
gtk_container_set_border_width(GTK_CONTAINER(vbox), PREF_PAD_BORDER);
gtk_widget_show(vbox);
label = gtk_label_new(_("Editors"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, label);
table = pref_table_new(vbox, 3, 9, FALSE, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
label = pref_table_label(table, 0, 0, _("#"), 1.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 2, 0, _("Command Line"), 0.0);
pref_label_bold(label, TRUE, FALSE);
for (i = 0; i < GQVIEW_EDITOR_SLOTS; i++)
{
gchar *buf;
buf = g_strdup_printf("%d", i+1);
pref_table_label(table, 0, i+1, buf, 1.0);
g_free(buf);
editor_name_entry[i] = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(editor_name_entry[i]), EDITOR_NAME_MAX_LENGTH);
gtk_widget_set_size_request(editor_name_entry[i],80,-1);
if (editor_name[i]) gtk_entry_set_text(GTK_ENTRY(editor_name_entry[i]),editor_name[i]);
gtk_table_attach(GTK_TABLE (table),editor_name_entry[i],1,2,i+1,i+2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(editor_name_entry[i]);
editor_command_entry[i] = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(editor_command_entry[i]), EDITOR_COMMAND_MAX_LENGTH);
gtk_widget_set_size_request(editor_command_entry[i],160,-1);
tab_completion_add_to_entry(editor_command_entry[i], NULL, NULL);
if (editor_command[i]) gtk_entry_set_text(GTK_ENTRY(editor_command_entry[i]), editor_command[i]);
gtk_table_attach(GTK_TABLE (table),editor_command_entry[i],2,3,i+1,i+2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(editor_command_entry[i]);
}
hbox = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
button = pref_button_new(NULL, NULL, _("Defaults"), FALSE,
G_CALLBACK(editor_default_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_HELP, NULL, FALSE,
G_CALLBACK(editor_help_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* advanced entry tab */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(scrolled), PREF_PAD_BORDER);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
label = gtk_label_new(_("Advanced"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled, label);
gtk_widget_show(scrolled);
viewport = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(scrolled), viewport);
gtk_widget_show(viewport);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(viewport), vbox);
gtk_widget_show(vbox);
group = pref_group_new(vbox, FALSE, _("Full screen"), GTK_ORIENTATION_VERTICAL);
fullscreen_screen_c = fullscreen_screen;
fullscreen_above_c = fullscreen_above;
hbox = fullscreen_prefs_selection_new(_("Location:"), &fullscreen_screen_c, &fullscreen_above_c);
gtk_box_pack_start(GTK_BOX(group), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
pref_checkbox_new_int(group, _("Smooth image flip"),
fullscreen_clean_flip, &fullscreen_clean_flip_c);
pref_checkbox_new_int(group, _("Disable screen saver"),
fullscreen_disable_saver, &fullscreen_disable_saver_c);
group = pref_group_new(vbox, FALSE, _("Delete"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Confirm file delete"),
confirm_delete, &confirm_delete_c);
pref_checkbox_new_int(group, _("Enable Delete key"),
enable_delete_key, &enable_delete_key_c);
ct_button = pref_checkbox_new_int(group, _("Safe delete"),
safe_delete_enable, &safe_delete_enable_c);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_checkbox_link_sensitivity(ct_button, hbox);
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
tabcomp = tab_completion_new(&safe_delete_path_entry, safe_delete_path, NULL, NULL);
tab_completion_add_select_button(safe_delete_path_entry, NULL, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), tabcomp, TRUE, TRUE, 0);
gtk_widget_show(tabcomp);
hbox = pref_box_new(group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_BUTTON_GAP);
pref_checkbox_link_sensitivity(ct_button, hbox);
pref_spacer(hbox, PREF_PAD_INDENT - PREF_PAD_GAP);
pref_spin_new_int(hbox, _("Maximum size:"), _("MB"),
1, 500, 1, safe_delete_size, &safe_delete_size_c);
button = pref_button_new(NULL, NULL, _("View"), FALSE,
G_CALLBACK(safe_delete_view_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_CLEAR, NULL, FALSE,
G_CALLBACK(safe_delete_clear_cb), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
group = pref_group_new(vbox, FALSE, _("Behavior"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Rectangular selection in icon view"),
collection_rectangular_selection, &collection_rectangular_selection_c);
pref_checkbox_new_int(group, _("Descend folders in tree view"),
tree_descend_subdirs, &tree_descend_subdirs_c);
pref_checkbox_new_int(group, _("In place renaming"),
enable_in_place_rename, &enable_in_place_rename_c);
group = pref_group_new(vbox, FALSE, _("Navigation"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Progressive keyboard scrolling"),
progressive_key_scrolling, &progressive_key_scrolling_c);
pref_checkbox_new_int(group, _("Mouse wheel scrolls image"),
mousewheel_scrolls, &mousewheel_scrolls_c);
group = pref_group_new(vbox, FALSE, _("Miscellaneous"), GTK_ORIENTATION_VERTICAL);
pref_checkbox_new_int(group, _("Store keywords and comments local to source images"),
enable_metadata_dirs, &enable_metadata_dirs_c);
pref_spin_new_int(group, _("Custom similarity threshold:"), NULL,
0, 100, 1, dupe_custom_threshold, &dupe_custom_threshold_c);
pref_spin_new_int(group, _("Offscreen cache size (Mb per image):"), NULL,
0, 128, 1, tile_cache_max, &tile_cache_max_c);
group = pref_group_new(vbox, FALSE, _("Color profiles"), GTK_ORIENTATION_VERTICAL);
#ifndef HAVE_LCMS
gtk_widget_set_sensitive(pref_group_parent(group), FALSE);
#endif
table = pref_table_new(group, 3, COLOR_PROFILE_INPUTS + 2, FALSE, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), PREF_PAD_GAP);
label = pref_table_label(table, 0, 0, _("Type"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 1, 0, _("Menu name"), 0.0);
pref_label_bold(label, TRUE, FALSE);
label = pref_table_label(table, 2, 0, _("File"), 0.0);
pref_label_bold(label, TRUE, FALSE);
for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
{
GtkWidget *entry;
gchar *buf;
buf = g_strdup_printf("Input %d:", i + 1);
pref_table_label(table, 0, i + 1, buf, 1.0);
g_free(buf);
entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), EDITOR_NAME_MAX_LENGTH);
gtk_widget_set_size_request(editor_name_entry[i], 30, -1);
if (color_profile_input_name[i]) gtk_entry_set_text(GTK_ENTRY(entry), color_profile_input_name[i]);
gtk_table_attach(GTK_TABLE(table), entry, 1, 2, i + 1, i + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(entry);
color_profile_input_name_entry[i] = entry;
tabcomp = tab_completion_new(&entry, color_profile_input_file[i], NULL, NULL);
tab_completion_add_select_button(entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(entry, 160, -1);
gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3, i + 1, i + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(tabcomp);
color_profile_input_file_entry[i] = entry;
}
pref_table_label(table, 0, COLOR_PROFILE_INPUTS + 1, _("Screen:"), 1.0);
tabcomp = tab_completion_new(&color_profile_screen_file_entry,
color_profile_screen_file, NULL, NULL);
tab_completion_add_select_button(color_profile_screen_file_entry, _("Select color profile"), FALSE);
gtk_widget_set_size_request(color_profile_screen_file_entry, 160, -1);
gtk_table_attach(GTK_TABLE(table), tabcomp, 2, 3,
COLOR_PROFILE_INPUTS + 1, COLOR_PROFILE_INPUTS + 2,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_widget_show(tabcomp);
gtk_widget_show(notebook);
gtk_widget_show(configwindow);
}
GtkWidget*
create_dialog1 (const char *msg)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *hbox1;
GtkWidget *image1;
GtkWidget *label1;
GtkWidget *dialog_action_area1;
GtkWidget *button2;
GtkWidget *alignment1;
GtkWidget *hbox2;
GtkWidget *image2;
GtkWidget *label2;
GtkWidget *button1;
GtkWidget *alignment2;
GtkWidget *hbox3;
GtkWidget *image3;
GtkWidget *label3;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("Filesystem full / quota exceeded"));
gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog1), FALSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
hbox1 = gtk_hbox_new (FALSE, 12);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 12);
image1 = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG);
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, TRUE, 0);
label1 = gtk_label_new (msg);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, TRUE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
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);
button2 = gtk_button_new ();
gtk_widget_show (button2);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), button2, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (button2), alignment1);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox2);
gtk_container_add (GTK_CONTAINER (alignment1), hbox2);
image2 = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image2);
gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0);
label2 = gtk_label_new_with_mnemonic (_("Ignore"));
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (hbox2), label2, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
button1 = gtk_button_new ();
gtk_widget_show (button1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), button1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (button1), alignment2);
hbox3 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox3);
gtk_container_add (GTK_CONTAINER (alignment2), hbox3);
image3 = gtk_image_new_from_stock ("gtk-redo", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image3);
gtk_box_pack_start (GTK_BOX (hbox3), image3, FALSE, FALSE, 0);
label3 = gtk_label_new_with_mnemonic (_("Retry"));
gtk_widget_show (label3);
gtk_box_pack_start (GTK_BOX (hbox3), label3, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
/* 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, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, image1, "image1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, button2, "button2");
GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (dialog1, image2, "image2");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, button1, "button1");
GLADE_HOOKUP_OBJECT (dialog1, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (dialog1, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (dialog1, image3, "image3");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
gtk_widget_grab_focus (button1);
gtk_widget_grab_default (button1);
return dialog1;
}
/**
* gpk_log_startup_cb:
**/
static void
gpk_log_startup_cb (GtkApplication *application, gpointer user_data)
{
gboolean ret;
GError *error = NULL;
GSettings *settings;
GtkEntryCompletion *completion;
GtkTreeSelection *selection;
GtkWidget *widget;
GtkWindow *window;
guint retval;
client = pk_client_new ();
g_object_set (client,
"background", FALSE,
NULL);
/* get UI */
builder = gtk_builder_new ();
retval = gtk_builder_add_from_file (builder, GPK_DATA "/pi-gpk-log.ui", &error);
if (retval == 0) {
g_warning ("failed to load ui: %s", error->message);
g_error_free (error);
goto out;
}
window = GTK_WINDOW (gtk_builder_get_object (builder, "dialog_simple"));
gtk_window_set_icon_name (window, GPK_ICON_SOFTWARE_LOG);
gtk_window_set_application (window, application);
/* set a size, as the screen allows */
gpk_window_set_size_request (window, 1200, 1200);
/* if command line arguments are set, then setup UI */
if (filter != NULL) {
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
gtk_entry_set_text (GTK_ENTRY(widget), filter);
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_close"));
g_signal_connect (widget, "clicked",
G_CALLBACK (gpk_log_button_close_cb), application);
gtk_widget_grab_default (widget);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_refresh"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_refresh_cb), NULL);
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_filter"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* hit enter in the search box for filter */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
g_signal_connect (widget, "activate", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* autocompletion can be turned off as it's slow */
settings = g_settings_new (GPK_SETTINGS_SCHEMA);
ret = g_settings_get_boolean (settings, GPK_SETTINGS_AUTOCOMPLETE);
if (ret) {
/* create the completion object */
completion = gpk_package_entry_completion_new ();
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
gtk_entry_set_completion (GTK_ENTRY (widget), completion);
g_object_unref (completion);
} else {
/* use search as you type */
g_signal_connect (widget, "key-release-event", G_CALLBACK (gpk_log_entry_filter_cb), NULL);
}
g_object_unref (settings);
/* create list stores */
list_store = gtk_list_store_new (GPK_LOG_COLUMN_LAST, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
/* create transaction_id tree view */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "treeview_simple"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget),
GTK_TREE_MODEL (list_store));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
g_signal_connect (selection, "changed",
G_CALLBACK (gpk_log_treeview_clicked_cb), NULL);
/* add columns to the tree view */
pk_treeview_add_general_columns (GTK_TREE_VIEW (widget));
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store),
GPK_LOG_COLUMN_TIMESPEC, GTK_SORT_DESCENDING);
/* show */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple"));
gtk_widget_show (widget);
/* set the parent window if it is specified */
if (xid != 0) {
g_debug ("Setting xid %i", xid);
gpk_window_set_parent_xid (GTK_WINDOW (widget), xid);
}
/* get the update list */
gpk_log_refresh ();
out:
g_object_unref (list_store);
g_object_unref (client);
g_free (transaction_id);
g_free (filter);
if (transactions != NULL)
g_ptr_array_unref (transactions);
}
int main (int argc, char *argv[])
{
static GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *table;
GtkWidget *button;
char buffer[32];
int i, j;
gtk_init (&argc, &argv);
/* スクロールウィンドウをパックするためのダイアログを
* 新規に作成する。*/
window = gtk_dialog_new ();
gtk_signal_connect (GTK_OBJECT (window), "destroy",
(GtkSignalFunc) destroy, NULL);
gtk_window_set_title (GTK_WINDOW (window), "GtkScrolledWindow example");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_widget_set_usize(window, 300, 300);
/* 新しくスクロールドウィンドウを作成 */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
/* ポリシーは GTK_POLICY AUTOMATIC か GTK_POLICY_ALWAYS のどちらかである。
* GTK_POLICY_AUTOMATIC は自動的にスクロールバーが必要か判断するのに対し、
* GTK_POLICY_ALWAYS は常にスクロールバーを表示する。
* 最初に設定しているのが水平方向で、次が垂直方向である。*/
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
/* ダイアログウィンドウは内部に vbox を持っている */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window,
TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
/* 10 x 10 の 正方形の表を作成 */
table = gtk_table_new (10, 10, FALSE);
/* x 方向と y 方向のスペーシングを 10 に設定 */
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 10);
/* テーブルをスクロールドウィンドウにパック */
gtk_scrolled_window_add_with_viewport (
GTK_SCROLLED_WINDOW (scrolled_window), table);
gtk_widget_show (table);
/* これはスクロールドウィンドウのデモ用に、トグルボタンのテーブル
* を作成しているだけ。*/
for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++) {
sprintf (buffer, "button (%d,%d)\n", i, j);
button = gtk_toggle_button_new_with_label (buffer);
gtk_table_attach_defaults (GTK_TABLE (table), button,
i, i+1, j, j+1);
gtk_widget_show (button);
}
/* "close" ボタンをダイアログの下に追加 */
button = gtk_button_new_with_label ("close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (window));
/* このボタンをデフォルトに指定 */
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
/* この操作でこのボタンをデフォルトのボタンにする。"Enter" キーを
押すだけでボタンが押される。 */
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main();
return(0);
}
int I_PickIWad_Gtk (WadStuff *wads, int numwads, bool showwin, int defaultiwad)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *bbox;
GtkWidget *widget;
GtkWidget *tree;
GtkWidget *check;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkTreeIter iter, defiter;
int close_style = 0;
int i;
char caption[100];
// Create the dialog window.
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
mysnprintf(caption, countof(caption), GAMESIG " %s: Select an IWAD to use", GetVersionString());
gtk_window_set_title (GTK_WINDOW(window), caption);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width (GTK_CONTAINER(window), 10);
g_signal_connect (window, "delete_event", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect (window, "key_press_event", G_CALLBACK(CheckEscape), NULL);
// Create the vbox container.
vbox = gtk_vbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER(window), vbox);
// Create the top label.
widget = gtk_label_new ("ZDoom found more than one IWAD\nSelect from the list below to determine which one to use:");
gtk_box_pack_start (GTK_BOX(vbox), widget, false, false, 0);
gtk_misc_set_alignment (GTK_MISC(widget), 0, 0);
// Create a list store with all the found IWADs.
store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
for (i = 0; i < numwads; ++i)
{
const char *filepart = strrchr (wads[i].Path, '/');
if (filepart == NULL)
filepart = wads[i].Path;
else
filepart++;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, filepart,
1, wads[i].Name.GetChars(),
2, i,
-1);
if (i == defaultiwad)
{
defiter = iter;
}
}
// Create the tree view control to show the list.
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("IWAD", renderer, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Game", renderer, "text", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(tree), true, true, 0);
g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(DoubleClickChecker), &close_style);
g_signal_connect(G_OBJECT(tree), "key_press_event", G_CALLBACK(AllowDefault), window);
// Select the default IWAD.
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_select_iter (selection, &defiter);
// Create the hbox for the bottom row.
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX(vbox), hbox, false, false, 0);
// Create the "Don't ask" checkbox.
check = gtk_check_button_new_with_label ("Don't ask me this again");
gtk_box_pack_start (GTK_BOX(hbox), check, false, false, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), !showwin);
// Create the OK/Cancel button box.
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX(bbox), 10);
gtk_box_pack_end (GTK_BOX(hbox), bbox, false, false, 0);
// Create the OK button.
widget = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0);
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
gtk_widget_grab_default (widget);
g_signal_connect (widget, "clicked", G_CALLBACK(ClickedOK), &close_style);
g_signal_connect (widget, "activate", G_CALLBACK(ClickedOK), &close_style);
// Create the cancel button.
widget = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0);
g_signal_connect (widget, "clicked", G_CALLBACK(gtk_main_quit), &window);
// Finally we can show everything.
gtk_widget_show_all (window);
gtk_main ();
if (close_style == 1)
{
GtkTreeModel *model;
GValue value = { 0, { {0} } };
// Find out which IWAD was selected.
gtk_tree_selection_get_selected (selection, &model, &iter);
gtk_tree_model_get_value (GTK_TREE_MODEL(model), &iter, 2, &value);
i = g_value_get_int (&value);
g_value_unset (&value);
// Set state of queryiwad based on the checkbox.
queryiwad = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check));
}
else
{
i = -1;
}
if (GTK_IS_WINDOW(window))
{
gtk_widget_destroy (window);
// If we don't do this, then the X window might not actually disappear.
while (g_main_context_iteration (NULL, FALSE)) {}
}
return i;
}
static void
ifopts_edit_cb(GtkWidget *w, gpointer data _U_)
{
GtkWidget *ifopts_edit_dlg, *cur_scr_win, *main_hb, *main_tb,
*cur_opts_fr, *ed_opts_fr, *main_vb,
*if_descr_lb,
*if_hide_lb,
*bbox, *ok_bt, *cancel_bt, *help_bt;
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeView *list_view;
GtkTreeSelection *selection;
int row = 0;
GtkWidget *caller = gtk_widget_get_toplevel(w);
/* Has an edit dialog box already been opened for that top-level
widget? */
ifopts_edit_dlg = g_object_get_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY);
if (ifopts_edit_dlg != NULL) {
/* Yes. Just re-activate that dialog box. */
reactivate_window(ifopts_edit_dlg);
return;
}
/* create a new dialog */
ifopts_edit_dlg = dlg_conf_window_new("Wireshark: Preferences: Interface Options");
gtk_window_set_default_size(GTK_WINDOW(ifopts_edit_dlg), 1000, 440);
main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
gtk_container_add(GTK_CONTAINER(ifopts_edit_dlg), main_vb);
gtk_widget_show(main_vb);
/* create current options frame */
cur_opts_fr = gtk_frame_new("Interfaces");
gtk_box_pack_start(GTK_BOX(main_vb), cur_opts_fr, TRUE, TRUE, 0);
gtk_widget_show(cur_opts_fr);
/* create a scrolled window to pack the current options TreeView widget into */
cur_scr_win = scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(cur_scr_win), 3);
gtk_container_add(GTK_CONTAINER(cur_opts_fr), cur_scr_win);
gtk_widget_show(cur_scr_win);
/*
* Create current options TreeView.
*/
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX */
G_TYPE_STRING, /* Device */
G_TYPE_STRING, /* Description */
#ifdef HAVE_PCAP_CREATE
G_TYPE_BOOLEAN, /* Monitor mode */
#endif
G_TYPE_STRING, /* Default link-layer */
G_TYPE_STRING, /* Comment */
G_TYPE_BOOLEAN, /* Hide? */
G_TYPE_INT); /* Dlt */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Device", renderer,
"text", DEVICE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
#ifdef _WIN32
gtk_tree_view_column_set_min_width(column, 230);
#else
gtk_tree_view_column_set_min_width(column, 70);
#endif
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Description", renderer,
"text", DESC_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 260);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#ifdef HAVE_PCAP_CREATE
/*
* XXX - for some reason, this doesn't show up.
*/
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Default to monitor mode", renderer,
"active", DEF_MONITOR_MODE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#endif
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Default link-layer", renderer,
"text", DEF_LINK_LAYER_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 230);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Comment", renderer,
"text", COMMENT_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ("Hide?", renderer,
"active", HIDE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#if 0
/* Don't show the DLT column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("DLT", renderer,
"text", DLT_COLUMN,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 40);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
#endif
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(list_view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
cur_list = list;
gtk_container_add(GTK_CONTAINER(cur_scr_win), cur_list);
if_selection = selection;
g_signal_connect (G_OBJECT (selection), "changed", /* select_row */
G_CALLBACK (ifopts_edit_ifsel_cb),
NULL);
gtk_widget_show(cur_list);
/* add interface names to cell */
ifopts_if_liststore_add();
/* create edit options frame */
ed_opts_fr = gtk_frame_new("Properties");
gtk_box_pack_start(GTK_BOX(main_vb), ed_opts_fr, FALSE, FALSE, 0);
gtk_widget_show(ed_opts_fr);
main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(main_hb), 3);
gtk_container_add(GTK_CONTAINER(ed_opts_fr), main_hb);
gtk_widget_show(main_hb);
/* table to hold description text entry and hide button */
main_tb = gtk_table_new(IFOPTS_TABLE_ROWS, 4, FALSE);
gtk_box_pack_start(GTK_BOX(main_hb), main_tb, TRUE, FALSE, 10);
gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10);
gtk_table_set_col_spacings(GTK_TABLE(main_tb), 10);
gtk_widget_show(main_tb);
if_dev_lb = gtk_label_new("Device:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 1.0f, 0.5f);
gtk_widget_show(if_dev_lb);
if_dev_lb = gtk_label_new("");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 1, 2, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 0.0f, 0.5f);
gtk_widget_show(if_dev_lb);
row++;
if_name_lb = gtk_label_new("Description:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_name_lb), 1.0f, 0.5f);
gtk_widget_show(if_name_lb);
if_name_lb = gtk_label_new("");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 1, 2, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_name_lb), 0.0f, 0.5f);
gtk_widget_show(if_name_lb);
row++;
#ifdef HAVE_PCAP_CREATE
/* create "monitor mode" label and button */
if_monitor_lb = gtk_label_new("Monitor mode:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_monitor_lb), 1.0f, 0.5f);
gtk_widget_show(if_monitor_lb);
if_monitor_cb = gtk_check_button_new();
g_signal_connect(if_monitor_cb, "toggled", G_CALLBACK(ifopts_edit_monitor_changed_cb),
cur_list);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_monitor_cb, 1, 2, row, row+1);
gtk_widget_show(if_monitor_cb);
row++;
#endif
if_linktype_lb = gtk_label_new("Default link-layer header type:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_linktype_lb), 1.0f, 0.5f);
gtk_widget_show(if_linktype_lb);
if_linktype_cb = gtk_combo_box_text_new();
num_linktypes = 0;
interfaces_info_nochange = FALSE;
g_signal_connect(if_linktype_cb, "changed", G_CALLBACK(ifopts_edit_linktype_changed_cb),
cur_list);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_linktype_cb, 1, 2, row, row+1);
gtk_widget_show(if_linktype_cb);
row++;
/* create interface description label and text entry */
if_descr_lb = gtk_label_new("Comment:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_descr_lb), 1.0f, 0.5f);
gtk_widget_show(if_descr_lb);
if_descr_te = gtk_entry_new();
g_signal_connect(if_descr_te, "changed", G_CALLBACK(ifopts_edit_descr_changed_cb),
cur_list);
gtk_entry_set_max_length(GTK_ENTRY(if_descr_te), IFOPTS_MAX_DESCR_LEN);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_te, 1, 2, row, row+1);
gtk_widget_show(if_descr_te);
row++;
/* create "hide interface" label and button */
if_hide_lb = gtk_label_new("Hide interface?:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_hide_lb), 1.0f, 0.5f);
gtk_widget_show(if_hide_lb);
if_hide_cb = gtk_check_button_new();
g_signal_connect(if_hide_cb, "toggled", G_CALLBACK(ifopts_edit_hide_changed_cb),
cur_list);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_cb, 1, 2, row, row+1);
gtk_widget_show(if_hide_cb);
if_default_if_lb = gtk_label_new("(Default interface cannot be hidden)");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_default_if_lb, 1, 3, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_default_if_lb), 0.15f, 0.5f);
row++;
/* button row: OK and Cancel buttons */
bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
gtk_widget_set_tooltip_text(ok_bt, "Save changes and exit dialog");
g_signal_connect(ok_bt, "clicked", G_CALLBACK(ifopts_edit_ok_cb), ifopts_edit_dlg);
cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
gtk_widget_set_tooltip_text(cancel_bt, "Cancel and exit dialog");
window_set_cancel_button(ifopts_edit_dlg, cancel_bt, window_cancel_button_cb);
help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb),
(gpointer)HELP_CAPTURE_INTERFACE_OPTIONS_DIALOG);
gtk_widget_set_tooltip_text (help_bt, "Show topic specific help");
gtk_widget_grab_default(ok_bt);
g_signal_connect(ifopts_edit_dlg, "delete_event", G_CALLBACK(window_delete_event_cb),
NULL);
/* Call a handler when we're destroyed, so we can inform
our caller, if any, that we've been destroyed. */
g_signal_connect(ifopts_edit_dlg, "destroy", G_CALLBACK(ifopts_edit_destroy_cb), NULL);
/* Set the key for the new dialog to point to our caller. */
g_object_set_data(G_OBJECT(ifopts_edit_dlg), IFOPTS_CALLER_PTR_KEY, caller);
/* Set the key for the caller to point to us */
g_object_set_data(G_OBJECT(caller), IFOPTS_DIALOG_PTR_KEY, ifopts_edit_dlg);
gtk_widget_show(ifopts_edit_dlg); /* triggers ifopts_edit_ifsel_cb() with the */
/* "interfaces" TreeView first row selected */
window_present(ifopts_edit_dlg);
}
static void prefs_custom_header_create(void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *confirm_area;
GtkWidget *vbox1;
GtkWidget *table1;
GtkWidget *hdr_label;
GtkWidget *hdr_combo;
GtkWidget *val_label;
GtkWidget *val_entry;
GtkWidget *val_btn;
GtkWidget *reg_hbox;
GtkWidget *btn_hbox;
GtkWidget *arrow;
GtkWidget *add_btn;
GtkWidget *del_btn;
GtkWidget *preview;
GtkWidget *ch_hbox;
GtkWidget *ch_scrolledwin;
GtkWidget *list_view;
GtkWidget *btn_vbox;
GtkWidget *up_btn;
GtkWidget *down_btn;
debug_print("Creating custom header setting window...\n");
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_customheader");
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW (window), TRUE);
vbox = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL,
&ok_btn, GTK_STOCK_OK,
NULL, NULL);
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), _("Custom header configuration"));
MANAGE_WINDOW_SIGNALS_CONNECT (window);
g_signal_connect (G_OBJECT(window), "delete_event",
G_CALLBACK(prefs_custom_header_deleted),
NULL);
g_signal_connect (G_OBJECT(window), "key_press_event",
G_CALLBACK(prefs_custom_header_key_pressed),
NULL);
g_signal_connect (G_OBJECT(ok_btn), "clicked",
G_CALLBACK(prefs_custom_header_ok), NULL);
g_signal_connect (G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(prefs_custom_header_cancel), NULL);
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);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox1), table1,
FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 8);
gtk_table_set_col_spacings (GTK_TABLE (table1), 8);
hdr_label = gtk_label_new (_("Header"));
gtk_widget_show (hdr_label);
gtk_table_attach (GTK_TABLE (table1), hdr_label, 0, 1, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
0, 0, 0);
gtk_misc_set_alignment (GTK_MISC (hdr_label), 0, 0.5);
hdr_combo = combobox_text_new(TRUE, "User-Agent", "Face", "X-Face",
"X-Operating-System", NULL);
gtk_table_attach (GTK_TABLE (table1), hdr_combo, 0, 1, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
0, 0, 0);
gtk_widget_set_size_request (hdr_combo, 150, -1);
val_label = gtk_label_new (_("Value"));
gtk_widget_show (val_label);
gtk_table_attach (GTK_TABLE (table1), val_label, 1, 2, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
0, 0, 0);
gtk_misc_set_alignment (GTK_MISC (val_label), 0, 0.5);
val_entry = gtk_entry_new ();
gtk_widget_show (val_entry);
gtk_table_attach (GTK_TABLE (table1), val_entry, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
0, 0, 0);
gtk_widget_set_size_request (val_entry, 200, -1);
val_btn = gtkut_get_browse_file_btn(_("Bro_wse"));
gtk_widget_show (val_btn);
gtk_table_attach (GTK_TABLE (table1), val_btn, 2, 3, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
0, 0, 0);
g_signal_connect (G_OBJECT (val_btn), "clicked",
G_CALLBACK (prefs_custom_header_val_from_file_cb),
NULL);
/* add / delete */
reg_hbox = gtk_hbox_new (FALSE, 4);
gtk_widget_show (reg_hbox);
gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0);
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
gtk_widget_show (arrow);
gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0);
gtk_widget_set_size_request (arrow, -1, 16);
btn_hbox = gtk_hbox_new (TRUE, 4);
gtk_widget_show (btn_hbox);
gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0);
add_btn = gtk_button_new_from_stock (GTK_STOCK_ADD);
gtk_widget_show (add_btn);
gtk_box_pack_start (GTK_BOX (btn_hbox), add_btn, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (add_btn), "clicked",
G_CALLBACK (prefs_custom_header_add_cb),
NULL);
del_btn = gtk_button_new_from_stock (GTK_STOCK_DELETE);
gtk_widget_show (del_btn);
gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (del_btn), "clicked",
G_CALLBACK (prefs_custom_header_delete_cb),
NULL);
ch_hbox = gtk_hbox_new (FALSE, 8);
gtk_widget_show (ch_hbox);
gtk_box_pack_start (GTK_BOX (vbox1), ch_hbox, TRUE, TRUE, 0);
ch_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (ch_scrolledwin, -1, 200);
gtk_widget_show (ch_scrolledwin);
gtk_box_pack_start (GTK_BOX (ch_hbox), ch_scrolledwin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ch_scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
list_view = prefs_custom_header_list_view_create();
gtk_widget_show (list_view);
gtk_container_add (GTK_CONTAINER (ch_scrolledwin), list_view);
btn_vbox = gtk_vbox_new (FALSE, 8);
gtk_widget_show (btn_vbox);
gtk_box_pack_start (GTK_BOX (ch_hbox), btn_vbox, FALSE, FALSE, 0);
up_btn = gtk_button_new_from_stock (GTK_STOCK_GO_UP);
gtk_widget_show (up_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (up_btn), "clicked",
G_CALLBACK (prefs_custom_header_up), NULL);
down_btn = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN);
gtk_widget_show (down_btn);
gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (down_btn), "clicked",
G_CALLBACK (prefs_custom_header_down), NULL);
preview = gtk_image_new ();
gtk_widget_show (preview);
gtk_box_pack_start (GTK_BOX (btn_vbox), preview, FALSE, FALSE, 0);
gtk_widget_show_all(window);
customhdr.window = window;
customhdr.ok_btn = ok_btn;
customhdr.cancel_btn = cancel_btn;
customhdr.preview = preview;
customhdr.hdr_combo = hdr_combo;
customhdr.hdr_entry = gtk_bin_get_child(GTK_BIN((hdr_combo)));
customhdr.val_entry = val_entry;
customhdr.list_view = list_view;
}
void master_passphrase_change_dialog()
{
static PangoFontDescription *font_desc;
GtkWidget *dialog;
GtkWidget *vbox, *hbox;
GtkWidget *icon, *table, *label;
GtkWidget *msg_title;
GtkWidget *entry_old, *entry_new1, *entry_new2;
GtkWidget *confirm_area;
GtkWidget *ok_button, *cancel_button;
struct _ctx *ctx;
dialog = gtk_dialog_new();
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_window_set_default_size(GTK_WINDOW(dialog), 375, 100);
gtk_window_set_title(GTK_WINDOW(dialog), "");
MANAGE_WINDOW_SIGNALS_CONNECT(dialog);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_set_spacing(GTK_BOX(vbox), 14);
hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0);
gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
msg_title = gtk_label_new(_("Changing master passphrase"));
gtk_misc_set_alignment(GTK_MISC(msg_title), 0, 0.5);
gtk_label_set_justify(GTK_LABEL(msg_title), GTK_JUSTIFY_LEFT);
gtk_label_set_use_markup (GTK_LABEL (msg_title), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), msg_title, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(msg_title), TRUE);
if (!font_desc) {
gint size;
size = pango_font_description_get_size
(gtk_widget_get_style(msg_title)->font_desc);
font_desc = pango_font_description_new();
pango_font_description_set_weight
(font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size
(font_desc, size * PANGO_SCALE_LARGE);
}
if (font_desc)
gtk_widget_modify_font(msg_title, font_desc);
label = gtk_label_new(
_("If a master passphrase is currently active, it\n"
"needs to be entered.")
);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
table = gtk_table_new(4, 2, FALSE);
/* Old passphrase */
label = gtk_label_new(_("Old passphrase:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
entry_old = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry_old), FALSE);
gtk_table_attach(GTK_TABLE(table), entry_old, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
/* Separator */
gtk_table_attach(GTK_TABLE(table),
gtk_hseparator_new(), 0, 2, 1, 2,
GTK_FILL | GTK_EXPAND, 0, 0, 5);
/* New passphrase */
label = gtk_label_new(_("New passphrase:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
entry_new1 = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry_new1), FALSE);
gtk_table_attach(GTK_TABLE(table), entry_new1, 1, 2, 2, 3,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
/* New passphrase again */
label = gtk_label_new(_("Confirm passphrase:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
entry_new2 = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry_new2), FALSE);
gtk_table_attach(GTK_TABLE(table), entry_new2, 1, 2, 3, 4,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
/* Dialog buttons */
gtkut_stock_button_set_create(&confirm_area,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dialog))),
confirm_area, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
gtk_widget_grab_default(ok_button);
/* If no master passphrase is set, disable the "old passphrase" entry */
if (!master_passphrase_is_set())
gtk_widget_set_sensitive(entry_old, FALSE);
g_signal_connect(G_OBJECT(entry_old), "activate",
G_CALLBACK(entry_activated), entry_new1);
g_signal_connect(G_OBJECT(entry_new1), "activate",
G_CALLBACK(entry_activated), entry_new2);
gtk_entry_set_activates_default(GTK_ENTRY(entry_new2), TRUE);
ctx = g_new(struct _ctx, 1);
ctx->done = FALSE;
ctx->dialog = dialog;
ctx->entry_old = entry_old;
ctx->entry_new1 = entry_new1;
ctx->entry_new2 = entry_new2;
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(ok_button_clicked), ctx);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(cancel_button_clicked), ctx);
g_signal_connect(G_OBJECT(dialog), "destroy",
G_CALLBACK(dialog_destroy), ctx);
gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_window_present(GTK_WINDOW(dialog));
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
manage_window_set_transient(GTK_WINDOW(dialog));
while (!ctx->done)
gtk_main_iteration();
if (ctx->dialog != NULL)
gtk_widget_destroy(ctx->dialog);
GTK_EVENTS_FLUSH();
g_free(ctx);
}
void init_gui_playlist(void) {
GtkWidget *li;
GtkWidget *scroller;
GtkWidget *box;
GtkWidget *table1;
GtkWidget *reload_button;
GtkWidget * enqueue_button;
selected_row = -1;
dir_browser = NULL;
list_dialog = NULL;
files = NULL;
/* Create and setup main window */
library_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//gtk_window_set_decorated(library_window, FALSE);
// gtk_widget_set_app_paintable(library_window, TRUE);
// gtk_window_set_policy( GTK_WINDOW(library_window), FALSE, FALSE, TRUE);
/* Put the window into the xmms class, and hide it from the window list*/
gtk_window_set_wmclass( GTK_WINDOW(library_window), "XMMS_MediaLibrary",
"xmms");
gtk_window_set_transient_for( GTK_WINDOW(library_window),
GTK_WINDOW(mainwin) );
// hint_set_skip_winlist( library_window );
gtk_window_set_default_size(GTK_WINDOW(library_window), 350, 350);
gtk_window_set_title(GTK_WINDOW(library_window), "Media Library");
/* gtk_widget_set_events( library_window, GDK_FOCUS_CHANGE_MASK |
GDK_BUTTON_MOTION_MASK | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK );
*/
// gtk_widget_realize( library_window );
// gtk_widget_set_usize( library_window, 300, 200 );
/* background = gdk_pixmap_new( NULL, 300, 200, gdk_rgb_get_visual()->depth );
pl_gc = gdk_gc_new( library_window->window );
printf("init\n");
printf("%i\n", get_skin_color(SKIN_PLEDIT_NORMALBG));
gdk_gc_set_foreground(pl_gc, get_skin_color(SKIN_PLEDIT_NORMALBG) );
gdk_draw_rectangle( background, pl_gc, TRUE, 0, 0, 300, 200 );
gdk_window_set_back_pixmap( library_window->window, background, 0);*/
/* Remove the WMs decorations */
// gdk_window_set_decorations( library_window->window, 0);
/* Setup list*/
file_list = gtk_clist_new(1);
g_signal_connect(GTK_OBJECT(file_list), "select-row",
GTK_SIGNAL_FUNC(file_list_select), NULL);
g_signal_connect(GTK_OBJECT(file_list), "unselect-row",
GTK_SIGNAL_FUNC(file_list_unselect), NULL);
g_signal_connect(GTK_OBJECT(file_list), "button-press-event",
G_CALLBACK(file_list_pressed), NULL);
g_signal_connect(GTK_OBJECT(file_list), "key-press-event",
GTK_SIGNAL_FUNC(file_list_key_press), NULL);
gtk_clist_set_column_title(GTK_CLIST(file_list), 0, "Title");
gtk_clist_column_titles_passive(GTK_CLIST(file_list));
gtk_clist_column_titles_show(GTK_CLIST(file_list));
gtk_clist_set_selection_mode(GTK_CLIST(file_list), GTK_SELECTION_EXTENDED);
gtk_widget_grab_default( GTK_OBJECT(file_list) );
/* Setup the search field */
search_field = gtk_entry_new();
g_signal_connect(GTK_OBJECT(search_field), "changed",
GTK_SIGNAL_FUNC(search_modify), NULL);
g_signal_connect(GTK_OBJECT(search_field), "key-press-event",
G_CALLBACK(search_field_keypress), NULL);
/* gtk_signal_connect(GTK_OBJECT(search_field), "focus-in-event",
GTK_SIGNAL_FUNC(search_field_focus_in), NULL);*/
/* Setup the search button
search_button = gtk_button_new_with_label("Search"); */
/* Setup the reload button*/
reload_button = gtk_button_new_with_label("Reload");
g_signal_connect( GTK_OBJECT(reload_button), "clicked",
GTK_SIGNAL_FUNC(reload_button_clicked), NULL);
/* Setup the play and enqueue-buttons */
play_button = gtk_button_new_with_label("Play");
play_button_handler_id = g_signal_connect(GTK_OBJECT(play_button), "clicked",
GTK_SIGNAL_FUNC(play_button_clicked), NULL);
enqueue_button = gtk_button_new_with_label("Add");
g_signal_connect(GTK_OBJECT(enqueue_button), "clicked",
GTK_SIGNAL_FUNC(enqueue_button_clicked), NULL);
/* Set the scroller up*/
scroller = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroller),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(scroller), file_list);
/* Setup the labels
label1 = gtk_label_new("Total songs:");
label2 = gtk_label_new("Songs showing:");
gtk_label_set_justify(GTK_LABEL(label1), GTK_JUSTIFY_RIGHT);
gtk_label_set_justify(GTK_LABEL(label2), GTK_JUSTIFY_RIGHT);
total_count_label = gtk_label_new("-");
showing_count_label = gtk_label_new("-");
gtk_label_set_justify(GTK_LABEL(total_count_label), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(showing_count_label), GTK_JUSTIFY_LEFT);*/
/* Setup layout widgets*/
layout_box = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(library_window), layout_box);
gtk_widget_show(layout_box);
table = gtk_table_new(3,2, TRUE);
gtk_box_pack_start(GTK_BOX(layout_box), table, FALSE, FALSE, 0);
gtk_box_pack_start_defaults(GTK_BOX(layout_box), scroller);
box = gtk_hbox_new(FALSE, 1);
//gtk_box_pack_start(GTK_BOX(box), search_field, TRUE, TRUE, 0);
/* The top 'bar'*/
table1 = gtk_table_new(1, 4, FALSE);
gtk_table_attach_defaults(GTK_TABLE(table1), search_field, 0,1,0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), play_button, 1,2,0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), enqueue_button, 2,3,0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), reload_button, 3,4,0,1);
/* gtk_table_attach_defaults(GTK_TABLE(table1), reload_button, 2, 3, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table1), add_random_button, 2, 3, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table1), label1, 0,1, 0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), label2, 0,1, 1,2);
gtk_table_attach_defaults(GTK_TABLE(table1), total_count_label, 1,2, 0,1);
gtk_table_attach_defaults(GTK_TABLE(table1), showing_count_label, 1,2, 1,2);*/
/* Add widgets to the table */
gtk_table_attach_defaults(GTK_TABLE(table), table1, 0, 2, 0, 2);
//gtk_table_attach_defaults(GTK_TABLE(table), box, 0, 2, 1, 3);
/* Show all the widgets*/
gtk_widget_show(reload_button);
gtk_widget_show(play_button);
gtk_widget_show(enqueue_button);
//gtk_widget_show(box);
gtk_widget_show(search_field);
gtk_widget_show(scroller);
gtk_widget_show(table1);
gtk_widget_show(table);
gtk_widget_show(file_list);
/* And finally, show the window itself*/
gtk_widget_show(library_window);
// dock_add_window(dock_window_list, library_window);
}
static void create_range_controls( void )
{
GtkWidget *window;
GtkWidget *box1, *box2, *box3;
GtkWidget *button;
GtkWidget *scrollbar;
GtkWidget *separator;
GtkWidget *opt, *menu, *item;
GtkWidget *label;
GtkWidget *scale;
GtkObject *adj1, *adj2;
/* Standard window-creating stuff */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* value, lower, upper, step_increment, page_increment, page_size */
/* Note that the page_size value only makes a difference for
* scrollbar widgets, and the highest value you'll get is actually
* (upper - page_size). */
adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));
scale_set_default_values (GTK_SCALE (vscale));
gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);
gtk_widget_show (vscale);
box3 = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);
gtk_widget_show (box3);
/* Reuse the same adjustment */
hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
gtk_widget_set_size_request (GTK_WIDGET (hscale), 200, -1);
scale_set_default_values (GTK_SCALE (hscale));
gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale);
/* Reuse the same adjustment again */
scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));
/* Notice how this causes the scales to always be updated
* continuously when the scrollbar is moved */
gtk_range_set_update_policy (GTK_RANGE (scrollbar),
GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* A checkbutton to control whether the value is displayed or not */
button = gtk_check_button_new_with_label("Display value on scale widgets");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (button, "toggled",
G_CALLBACK (cb_draw_value), NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An option menu to change the position of the value */
label = gtk_label_new ("Scale Value Position:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new ();
menu = gtk_menu_new ();
item = make_menu_item ("Top",
G_CALLBACK (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_TOP));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = make_menu_item ("Bottom", G_CALLBACK (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_BOTTOM));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = make_menu_item ("Left", G_CALLBACK (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_LEFT));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = make_menu_item ("Right", G_CALLBACK (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_RIGHT));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* Yet another option menu, this time for the update policy of the
* scale widgets */
label = gtk_label_new ("Scale Update Policy:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new ();
menu = gtk_menu_new ();
item = make_menu_item ("Continuous",
G_CALLBACK (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = make_menu_item ("Discontinuous",
G_CALLBACK (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = make_menu_item ("Delayed",
G_CALLBACK (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DELAYED));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An HScale widget for adjusting the number of digits on the
* sample scales. */
label = gtk_label_new ("Scale Digits:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
g_signal_connect (adj2, "value_changed",
G_CALLBACK (cb_digits_scale), NULL);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* And, one last HScale widget for adjusting the page size of the
* scrollbar. */
label = gtk_label_new ("Scrollbar Page Size:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
g_signal_connect (adj2, "value-changed",
G_CALLBACK (cb_page_size), (gpointer) adj1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("Quit");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
}
void edit_properties(GtkWidget *widget, gpointer data)
{
GtkWidget *props_window;
GtkWidget *main_box;
GtkWidget *settings_box;
GtkWidget *wide_box;
GtkWidget *general_frame;
GtkWidget *general_box;
GtkWidget *syntax_frame;
GtkWidget *syntax_box;
GtkWidget *bracket_frame;
GtkWidget *bracket_box;
GtkWidget *tabs_frame;
GtkWidget *tabs_box;
GtkWidget *compile_frame;
GtkWidget *compile_box;
GtkWidget *util_box;
GtkWidget *util_label;
GtkWidget *buttons_box;
GtkWidget *ok_button;
GtkWidget *defaults_button;
GtkWidget *undo_button;
GtkWidget *close_button;
FileProps *file_props;
gchar *chars = NULL;
GtkWidget *hsep;
if(cur_file->props_dialog && GTK_IS_WINDOW(cur_file->props_dialog))
{
gdk_window_raise(cur_file->props_dialog->window);
return;
}
file_props = g_new(FileProps, 1);
file_props->defaults = cur_file->tables ? &cur_file->tables->props : NULL;
file_props->current = &cur_file->props;
file_props->backups = g_new(GdsFileProperties, 1);
copy_properties(file_props->backups, file_props->current);
props_window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_container_set_border_width(GTK_CONTAINER(props_window), 5);
chars = g_strconcat(_("GdsFileProperties Editor - "), cur_file->filename, NULL);
gtk_window_set_title(GTK_WINDOW(props_window), chars);
g_free(chars);
cur_file->props_dialog = props_window;
main_box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(props_window), main_box);
gtk_widget_show(main_box);
settings_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(settings_box), 0);
gtk_box_pack_start(GTK_BOX(main_box), settings_box, FALSE, FALSE, 0);
gtk_widget_show(settings_box);
/* File Settings */
general_frame = gtk_frame_new(_("File Specific Settings"));
gtk_box_pack_start(GTK_BOX(settings_box), general_frame, FALSE, FALSE, 0);
gtk_widget_show(general_frame);
wide_box = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(wide_box), 5);
gtk_container_add(GTK_CONTAINER(general_frame), wide_box);
gtk_widget_show(wide_box);
general_box = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(wide_box), general_box, TRUE, TRUE, 0);
gtk_widget_show(general_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(general_box), util_box, TRUE, TRUE, 5);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_widget_show(util_box);
file_props->over_ride = make_button(_("Override defaults ?"), util_box, &file_props->current->over_ride);
util_box = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(general_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Directory:"));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->dir = gnome_direntry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->dir, TRUE, TRUE, 0);
gtk_widget_show(file_props->dir);
bracket_frame = gtk_frame_new(_("Bracket Highlighting"));
gtk_box_pack_start(GTK_BOX(general_box), bracket_frame, FALSE, FALSE, 0);
gtk_widget_show(bracket_frame);
bracket_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(bracket_box), 5);
gtk_container_add(GTK_CONTAINER(bracket_frame), bracket_box);
gtk_widget_show(bracket_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(bracket_box), util_box, FALSE, TRUE, 0);
gtk_widget_show(util_box);
file_props->bracketmatch = make_button(_("Enable bracket highlighting ?"), util_box, &file_props->current->bracketmatch);
syntax_frame = gtk_frame_new(_("Syntax Highlighting"));
gtk_box_pack_start(GTK_BOX(general_box), syntax_frame, FALSE, FALSE, 0);
gtk_widget_show(syntax_frame);
syntax_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(syntax_box), 5);
gtk_container_add(GTK_CONTAINER(syntax_frame), syntax_box);
gtk_widget_show(syntax_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(syntax_box), util_box, FALSE, TRUE, 0);
gtk_widget_show(util_box);
file_props->syntax = make_button(_("Enable syntax highlighting ?"), util_box, &file_props->current->syntax);
tabs_frame = gtk_frame_new(_("Indentation"));
gtk_box_pack_start(GTK_BOX(general_box), tabs_frame, TRUE, TRUE, 0);
gtk_widget_show(tabs_frame);
tabs_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(tabs_box), 5);
gtk_container_add(GTK_CONTAINER(tabs_frame), tabs_box);
gtk_widget_show(tabs_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_box_pack_start(GTK_BOX(tabs_box), util_box, TRUE, TRUE, 0);
gtk_widget_show(util_box);
file_props->auto_indent = make_button(_("Auto Indent ?"), util_box, &file_props->current->auto_indent);
util_box = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_box_pack_start(GTK_BOX(tabs_box), util_box, TRUE, TRUE, 0);
gtk_widget_show(util_box);
file_props->use_spaces = make_button(_("Use spaces instead of tabs ?"), util_box, &file_props->current->use_spaces);
util_box = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(util_box), 5);
gtk_box_pack_start(GTK_BOX(tabs_box), util_box, TRUE, TRUE, 0);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Tab stop:"));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->spaces_spin = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, 1, 8, 1, 2, 0)), 1, 0);
gtk_box_pack_start(GTK_BOX(util_box), file_props->spaces_spin, TRUE, TRUE, 0);
gtk_widget_show(file_props->spaces_spin);
compile_frame = gtk_frame_new(_("Build Information"));
gtk_box_pack_start(GTK_BOX(wide_box), compile_frame, TRUE, TRUE, 0);
gtk_widget_show(compile_frame);
compile_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(compile_box), 5);
gtk_container_add(GTK_CONTAINER(compile_frame), compile_box);
gtk_widget_show(compile_box);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(compile_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Compiler: "));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->compiler = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->compiler, TRUE, TRUE, 0);
gtk_widget_show(file_props->compiler);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(compile_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Debugger: "));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->debugger = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->debugger, TRUE, TRUE, 0);
gtk_widget_show(file_props->debugger);
util_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(compile_box), util_box, TRUE, TRUE, 5);
gtk_widget_show(util_box);
util_label = gtk_label_new(_("Execution: "));
gtk_box_pack_start(GTK_BOX(util_box), util_label, FALSE, FALSE, 0);
gtk_widget_show(util_label);
file_props->execution = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(util_box), file_props->execution, TRUE, TRUE, 0);
gtk_widget_show(file_props->execution);
hsep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(main_box), hsep, FALSE, TRUE, 10);
gtk_widget_show(hsep);
buttons_box = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(main_box), buttons_box, FALSE, TRUE, 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(buttons_box), gnome_preferences_get_button_layout());
gtk_button_box_set_spacing(GTK_BUTTON_BOX(buttons_box), GNOME_PAD);
gtk_widget_show(buttons_box);
ok_button = gnome_stock_button(GNOME_STOCK_BUTTON_OK);
gtk_box_pack_start(GTK_BOX(buttons_box), ok_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(save_properties), file_props);
gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(set_properties), cur_file);
gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(kill_widget), GTK_OBJECT(props_window));
GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
gtk_widget_show(ok_button);
defaults_button = gnome_stock_or_ordinary_button(_("Defaults"));
gtk_box_pack_start(GTK_BOX(buttons_box), defaults_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(defaults_button), "clicked", GTK_SIGNAL_FUNC(get_default_props), file_props);
GTK_WIDGET_SET_FLAGS(defaults_button, GTK_CAN_DEFAULT);
gtk_widget_show(defaults_button);
undo_button = gnome_stock_or_ordinary_button(_("Undo"));
gtk_box_pack_start(GTK_BOX(buttons_box), undo_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(undo_button), "clicked", GTK_SIGNAL_FUNC(get_backup_props), file_props);
GTK_WIDGET_SET_FLAGS(undo_button, GTK_CAN_DEFAULT);
gtk_widget_show(undo_button);
close_button = gnome_stock_button(GNOME_STOCK_BUTTON_CLOSE);
gtk_box_pack_end(GTK_BOX(buttons_box), close_button, FALSE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(close_button), "clicked", GTK_SIGNAL_FUNC(kill_widget), GTK_OBJECT(props_window));
gtk_signal_connect(GTK_OBJECT(close_button), "clicked", GTK_SIGNAL_FUNC(redo_backup_props), file_props);
GTK_WIDGET_SET_FLAGS(close_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(close_button);
gtk_widget_show(close_button);
gtk_signal_connect(GTK_OBJECT(props_window), "destroy", GTK_SIGNAL_FUNC(kill_widget_ptr), &cur_file->props_dialog);
gtk_signal_connect(GTK_OBJECT(props_window), "destroy", GTK_SIGNAL_FUNC(free_properties), file_props->backups);
gtk_signal_connect(GTK_OBJECT(props_window), "destroy", GTK_SIGNAL_FUNC(kill_data), file_props);
put_properties(file_props, file_props->current);
gtk_widget_show(props_window);
}
static VALUE
rg_grab_default(VALUE self)
{
gtk_widget_grab_default(_SELF(self));
return self;
}
static void imp_pine_create( gboolean *cancelled ) {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
GtkWidget *file_entry;
GtkWidget *name_entry;
GtkWidget *hbbox;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *file_btn;
GtkWidget *statusbar;
GtkWidget *hsbox;
gint top;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "importpine");
gtk_widget_set_size_request(window, 450, -1);
gtk_container_set_border_width( GTK_CONTAINER(window), 0 );
gtk_window_set_title( GTK_WINDOW(window), _("Import Pine file into Address Book") );
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(imp_pine_delete_event), cancelled);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(imp_pine_key_pressed), cancelled);
vbox = gtk_vbox_new(FALSE, 8);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_container_set_border_width( GTK_CONTAINER(vbox), 0 );
table = gtk_table_new(2, 3, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_container_set_border_width( GTK_CONTAINER(table), 8 );
gtk_table_set_row_spacings(GTK_TABLE(table), 8);
gtk_table_set_col_spacings(GTK_TABLE(table), 8 );
/* First row */
top = 0;
label = gtk_label_new(_("Name"));
gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
name_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), name_entry, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
/* Second row */
top = 1;
label = gtk_label_new(_("File"));
gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
file_entry = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), file_entry, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);
file_btn = gtkut_get_browse_file_btn(_("_Browse"));
gtk_table_attach(GTK_TABLE(table), file_btn, 2, 3, top, (top + 1), GTK_FILL, 0, 3, 0);
/* Status line */
hsbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
/* Button panel */
gtkut_stock_button_set_create(&hbbox, &cancel_btn, GTK_STOCK_CANCEL,
&ok_btn, GTK_STOCK_OK,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
gtk_container_set_border_width( GTK_CONTAINER(hbbox), 5);
gtk_widget_grab_default(ok_btn);
g_signal_connect(G_OBJECT(ok_btn), "clicked",
G_CALLBACK(imp_pine_ok), cancelled);
g_signal_connect(G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(imp_pine_cancel), cancelled);
g_signal_connect(G_OBJECT(file_btn), "clicked",
G_CALLBACK(imp_pine_file_select), NULL);
gtk_widget_show_all(vbox);
imppine_dlg.window = window;
imppine_dlg.file_entry = file_entry;
imppine_dlg.name_entry = name_entry;
imppine_dlg.ok_btn = ok_btn;
imppine_dlg.cancel_btn = cancel_btn;
imppine_dlg.statusbar = statusbar;
imppine_dlg.status_cid = gtk_statusbar_get_context_id(
GTK_STATUSBAR(statusbar), "Import Pine Dialog" );
}
void show_about_window(void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
GdkPixbuf *pixbuf;
gchar *buf;
if (about)
{
gtk_window_present(GTK_WINDOW(about));
return;
}
about = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(about), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_wmclass(GTK_WINDOW(about), "about", "GQview");
g_signal_connect(G_OBJECT(about), "delete_event",
G_CALLBACK(about_delete_cb), NULL);
gtk_window_set_title(GTK_WINDOW(about), _("About - GQview"));
gtk_container_set_border_width(GTK_CONTAINER(about), PREF_PAD_BORDER);
vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(about), vbox);
gtk_widget_show(vbox);
pixbuf = pixbuf_inline(PIXBUF_INLINE_LOGO);
button = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref(pixbuf);
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 0);
gtk_widget_show(button);
buf = g_strdup_printf(_("GQview %s\n\nCopyright (c) %s John Ellis\nwebsite: %s\nemail: %s\n\nReleased under the GNU General Public License"),
VERSION,
"2006",
"gqview.sourceforge.net",
"*****@*****.**");
label = gtk_label_new(buf);
g_free(buf);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = pref_button_new(NULL, NULL, _("Credits..."), FALSE,
G_CALLBACK(about_credits_cb), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
G_CALLBACK(about_window_close), NULL);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
gtk_widget_show(button);
window_set_icon(about, NULL, NULL);
gtk_widget_show(about);
}
GtkWidget *create_dialog2 (int mmin, int mmax)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *label1;
GtkObject *spinbutton1_adj;
GtkWidget *spinbutton1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
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);
label1 = gtk_label_new (_("label1"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
spinbutton1_adj = gtk_adjustment_new (1, mmin, mmax, 1, 10, 10);
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0);
gtk_widget_show (spinbutton1);
gtk_box_pack_start (GTK_BOX (vbox1), spinbutton1, FALSE, FALSE, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton1), TRUE);
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);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
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, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
gtk_widget_grab_focus (okbutton1);
gtk_widget_grab_default (okbutton1);
return dialog1;
}
/**
* Create main dialog decorations (excluding notebook pages).
*/
static void export_ldif_dialog_create( void ) {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *vnbox;
GtkWidget *notebook;
GtkWidget *hbbox;
GtkWidget *btnPrev;
GtkWidget *btnNext;
GtkWidget *btnCancel;
GtkWidget *hsbox;
GtkWidget *statusbar;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "expldifdlg");
gtk_widget_set_size_request(window, EXPORTLDIF_WIDTH, EXPORTLDIF_HEIGHT );
gtk_container_set_border_width( GTK_CONTAINER(window), 0 );
gtk_window_set_title( GTK_WINDOW(window),
_("Export Address Book to LDIF File") );
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(export_ldif_delete_event),
NULL );
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(export_ldif_key_pressed),
NULL );
vbox = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
vnbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vnbox), 4);
gtk_widget_show(vnbox);
gtk_box_pack_start(GTK_BOX(vbox), vnbox, TRUE, TRUE, 0);
/* Notebook */
notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), FALSE ); /* Hide */
/* gtk_notebook_set_show_tabs( GTK_NOTEBOOK(notebook), TRUE ); */
gtk_widget_show(notebook);
gtk_box_pack_start(GTK_BOX(vnbox), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);
/* Status line */
hsbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
/* Button panel */
gtkut_stock_button_set_create(&hbbox, &btnPrev, GTK_STOCK_GO_BACK,
&btnNext, GTK_STOCK_GO_FORWARD,
&btnCancel, GTK_STOCK_CANCEL);
gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbbox), 2);
gtk_widget_grab_default(btnNext);
/* Button handlers */
g_signal_connect(G_OBJECT(btnPrev), "clicked",
G_CALLBACK(export_ldif_prev), NULL);
g_signal_connect(G_OBJECT(btnNext), "clicked",
G_CALLBACK(export_ldif_next), NULL);
g_signal_connect(G_OBJECT(btnCancel), "clicked",
G_CALLBACK(export_ldif_cancel), NULL);
gtk_widget_show_all(vbox);
expldif_dlg.window = window;
expldif_dlg.notebook = notebook;
expldif_dlg.btnPrev = btnPrev;
expldif_dlg.btnNext = btnNext;
expldif_dlg.btnCancel = btnCancel;
expldif_dlg.statusbar = statusbar;
expldif_dlg.status_cid = gtk_statusbar_get_context_id(
GTK_STATUSBAR(statusbar), "Export LDIF Dialog" );
}