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" ); }