static void
file_save_as (CeditTab *tab,
CeditWindow *window)
{
GtkWidget *save_dialog;
GtkWindowGroup *wg;
CeditDocument *doc;
GFile *file;
gboolean uri_set = FALSE;
const CeditEncoding *encoding;
CeditDocumentNewlineType newline_type;
g_return_if_fail (CEDIT_IS_TAB (tab));
g_return_if_fail (CEDIT_IS_WINDOW (window));
cedit_debug (DEBUG_COMMANDS);
save_dialog = cedit_file_chooser_dialog_new (_("Save As\342\200\246"),
GTK_WINDOW (window),
GTK_FILE_CHOOSER_ACTION_SAVE,
NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (save_dialog),
TRUE);
g_signal_connect (save_dialog,
"confirm-overwrite",
G_CALLBACK (confirm_overwrite_callback),
NULL);
wg = cedit_window_get_group (window);
gtk_window_group_add_window (wg,
GTK_WINDOW (save_dialog));
/* Save As dialog is modal to its main window */
gtk_window_set_modal (GTK_WINDOW (save_dialog), TRUE);
/* Set the suggested file name */
doc = cedit_tab_get_document (tab);
file = cedit_document_get_location (doc);
if (file != NULL)
{
uri_set = gtk_file_chooser_set_file (GTK_FILE_CHOOSER (save_dialog),
file,
NULL);
g_object_unref (file);
}
if (!uri_set)
{
GFile *default_path;
gchar *docname;
default_path = _cedit_window_get_default_location (window);
docname = cedit_document_get_short_name_for_display (doc);
if (default_path != NULL)
{
gchar *uri;
uri = g_file_get_uri (default_path);
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (save_dialog),
uri);
g_free (uri);
g_object_unref (default_path);
}
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog),
docname);
g_free (docname);
}
/* Set suggested encoding */
encoding = cedit_document_get_encoding (doc);
g_return_if_fail (encoding != NULL);
newline_type = cedit_document_get_newline_type (doc);
cedit_file_chooser_dialog_set_encoding (CEDIT_FILE_CHOOSER_DIALOG (save_dialog),
encoding);
cedit_file_chooser_dialog_set_newline_type (CEDIT_FILE_CHOOSER_DIALOG (save_dialog),
newline_type);
g_object_set_data (G_OBJECT (save_dialog),
CEDIT_TAB_TO_SAVE_AS,
tab);
g_signal_connect (save_dialog,
"response",
G_CALLBACK (save_dialog_response_cb),
window);
gtk_widget_show (save_dialog);
}
void
e_composer_private_constructed (EMsgComposer *composer)
{
EMsgComposerPrivate *priv = composer->priv;
EFocusTracker *focus_tracker;
EComposerHeader *header;
EShell *shell;
EClientCache *client_cache;
EHTMLEditor *editor;
EHTMLEditorView *view;
GtkUIManager *ui_manager;
GtkAction *action;
GtkWidget *container;
GtkWidget *widget;
GtkWidget *send_widget;
GtkWindow *window;
GSettings *settings;
const gchar *path;
gchar *filename, *gallery_path;
gint ii;
GError *error = NULL;
editor = e_msg_composer_get_editor (composer);
ui_manager = e_html_editor_get_ui_manager (editor);
view = e_html_editor_get_view (editor);
settings = e_util_ref_settings ("org.gnome.evolution.mail");
shell = e_msg_composer_get_shell (composer);
client_cache = e_shell_get_client_cache (shell);
/* Each composer window gets its own window group. */
window = GTK_WINDOW (composer);
priv->window_group = gtk_window_group_new ();
gtk_window_group_add_window (priv->window_group, window);
priv->async_actions = gtk_action_group_new ("async");
priv->charset_actions = gtk_action_group_new ("charset");
priv->composer_actions = gtk_action_group_new ("composer");
priv->extra_hdr_names = g_ptr_array_new ();
priv->extra_hdr_values = g_ptr_array_new ();
priv->charset = e_composer_get_default_charset ();
priv->is_from_new_message = FALSE;
priv->set_signature_from_message = FALSE;
priv->disable_signature = FALSE;
priv->busy = FALSE;
priv->saved_editable = FALSE;
priv->drop_occured = FALSE;
priv->dnd_is_uri = FALSE;
priv->check_if_signature_is_changed = FALSE;
priv->ignore_next_signature_change = FALSE;
priv->dnd_history_saved = FALSE;
priv->focused_entry = NULL;
e_composer_actions_init (composer);
filename = e_composer_find_data_file ("evolution-composer.ui");
gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error);
g_free (filename);
/* We set the send button as important to have a label */
path = "/main-toolbar/pre-main-toolbar/send";
send_widget = gtk_ui_manager_get_widget (ui_manager, path);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (send_widget), TRUE);
composer_setup_charset_menu (composer);
if (error != NULL) {
/* Henceforth, bad things start happening. */
g_critical ("%s", error->message);
g_clear_error (&error);
}
/* Configure an EFocusTracker to manage selection actions. */
focus_tracker = e_focus_tracker_new (GTK_WINDOW (composer));
action = e_html_editor_get_action (editor, "cut");
e_focus_tracker_set_cut_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "copy");
e_focus_tracker_set_copy_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "paste");
e_focus_tracker_set_paste_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "select-all");
e_focus_tracker_set_select_all_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "undo");
e_focus_tracker_set_undo_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "redo");
e_focus_tracker_set_redo_action (focus_tracker, action);
priv->focus_tracker = focus_tracker;
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (composer), widget);
gtk_widget_show (widget);
container = widget;
/* Construct the main menu and toolbar. */
widget = e_html_editor_get_managed_widget (editor, "/main-menu");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = e_html_editor_get_managed_widget (editor, "/main-toolbar");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the header table. */
widget = e_composer_header_table_new (client_cache);
gtk_container_set_border_width (GTK_CONTAINER (widget), 6);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
priv->header_table = g_object_ref (widget);
gtk_widget_show (widget);
header = e_composer_header_table_get_header (
E_COMPOSER_HEADER_TABLE (widget),
E_COMPOSER_HEADER_SUBJECT);
e_binding_bind_property (
view, "spell-checker",
header->input_widget, "spell-checker",
G_BINDING_SYNC_CREATE);
/* Construct the editing toolbars. We'll have to reparent
* the embedded EHTMLEditorView a little further down. */
widget = GTK_WIDGET (editor);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the attachment paned. */
widget = e_attachment_paned_new ();
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
priv->attachment_paned = g_object_ref_sink (widget);
gtk_widget_show (widget);
e_binding_bind_property (
view, "editable",
widget, "sensitive",
G_BINDING_SYNC_CREATE);
container = e_attachment_paned_get_content_area (
E_ATTACHMENT_PANED (priv->attachment_paned));
widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (widget, -1, GALLERY_INITIAL_HEIGHT);
gtk_paned_pack1 (GTK_PANED (container), widget, FALSE, FALSE);
priv->gallery_scrolled_window = g_object_ref (widget);
gtk_widget_show (widget);
/* Reparent the scrolled window containing the web view
* widget into the content area of the top attachment pane. */
widget = GTK_WIDGET (view);
widget = gtk_widget_get_parent (widget);
gtk_widget_reparent (widget, container);
/* Construct the picture gallery. */
container = priv->gallery_scrolled_window;
/* FIXME This should be an EMsgComposer property. */
gallery_path = g_settings_get_string (
settings, "composer-gallery-path");
widget = e_picture_gallery_new (gallery_path);
gtk_container_add (GTK_CONTAINER (container), widget);
priv->gallery_icon_view = g_object_ref_sink (widget);
g_free (gallery_path);
e_signal_connect_notify_swapped (
view, "notify::mode",
G_CALLBACK (composer_update_gallery_visibility), composer);
g_signal_connect_swapped (
ACTION (PICTURE_GALLERY), "toggled",
G_CALLBACK (composer_update_gallery_visibility), composer);
/* Initial sync */
composer_update_gallery_visibility (composer);
/* Bind headers to their corresponding actions. */
for (ii = 0; ii < E_COMPOSER_NUM_HEADERS; ii++) {
EComposerHeaderTable *table;
EComposerHeader *header;
GtkAction *action;
table = E_COMPOSER_HEADER_TABLE (priv->header_table);
header = e_composer_header_table_get_header (table, ii);
switch (ii) {
case E_COMPOSER_HEADER_FROM:
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_name_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_address_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
action = ACTION (VIEW_FROM_OVERRIDE);
e_binding_bind_property (
header, "override-visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
continue;
case E_COMPOSER_HEADER_BCC:
action = ACTION (VIEW_BCC);
break;
case E_COMPOSER_HEADER_CC:
action = ACTION (VIEW_CC);
break;
case E_COMPOSER_HEADER_REPLY_TO:
action = ACTION (VIEW_REPLY_TO);
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
break;
case E_COMPOSER_HEADER_SUBJECT:
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
continue;
default:
continue;
}
e_binding_bind_property (
header, "sensitive",
action, "sensitive",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
header, "visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
}
/* Disable actions that start asynchronous activities while an
* asynchronous activity is in progress. We enforce this with
* a simple inverted binding to EMsgComposer's "busy" property. */
e_binding_bind_property (
composer, "busy",
priv->async_actions, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
e_binding_bind_property (
composer, "busy",
priv->header_table, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
g_object_unref (settings);
}
static void
dma_data_view_goto_activate (GtkWidget *menu_item,
DmaDataView *view)
{
GtkWidget *toplevel;
GtkWidget *frame;
GtkWidget *vbox;
GtkWindowGroup *toplevel_group;
GtkWindowGroup *goto_window_group;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (view));
toplevel_group = gtk_window_get_group (GTK_WINDOW (toplevel));
goto_window_group = gtk_window_get_group (GTK_WINDOW (view->goto_window));
if (view->goto_window != NULL)
{
if (toplevel_group)
gtk_window_group_add_window (toplevel_group,
GTK_WINDOW (view->goto_window));
else if (goto_window_group)
gtk_window_group_remove_window (goto_window_group,
GTK_WINDOW (view->goto_window));
}
else
{
view->goto_window = gtk_window_new (GTK_WINDOW_POPUP);
if (toplevel_group)
gtk_window_group_add_window (toplevel_group,
GTK_WINDOW (view->goto_window));
gtk_window_set_modal (GTK_WINDOW (view->goto_window), TRUE);
g_signal_connect (view->goto_window, "delete_event",
G_CALLBACK (dma_data_view_goto_delete_event),
view);
g_signal_connect (view->goto_window, "key_press_event",
G_CALLBACK (dma_data_view_goto_key_press_event),
view);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_widget_show (frame);
gtk_container_add (GTK_CONTAINER (view->goto_window), frame);
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
/* add entry */
view->goto_entry = gtk_entry_new ();
gtk_entry_set_icon_from_stock (GTK_ENTRY (view->goto_entry),
GTK_ENTRY_ICON_PRIMARY,
GTK_STOCK_JUMP_TO);
gtk_widget_show (view->goto_entry);
gtk_container_add (GTK_CONTAINER (vbox),
view->goto_entry);
gtk_widget_realize (view->goto_entry);
}
dma_data_view_goto_position_func (view);
gtk_entry_set_text (GTK_ENTRY (view->goto_entry), "0x");
gtk_widget_show (view->goto_window);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view->address), FALSE);
gtk_widget_grab_focus (view->goto_entry);
send_focus_change (view->goto_entry, TRUE);
gtk_editable_set_position (GTK_EDITABLE (view->goto_entry), -1);
}
static void
add_or_remove (GeditEncodingsComboBox *menu,
GtkTreeModel *model)
{
GtkTreeIter iter;
gboolean add_item = FALSE;
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (menu), &iter))
{
gtk_tree_model_get (model, &iter,
ADD_COLUMN, &add_item,
-1);
}
if (!add_item)
{
menu->priv->activated_item = gtk_combo_box_get_active (GTK_COMBO_BOX (menu));
}
else
{
GtkWidget *dialog;
GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu));
if (!gtk_widget_is_toplevel (toplevel))
toplevel = NULL;
g_signal_handler_block (menu, menu->priv->changed_id);
gtk_combo_box_set_active (GTK_COMBO_BOX (menu),
menu->priv->activated_item);
g_signal_handler_unblock (menu, menu->priv->changed_id);
dialog = gedit_encodings_dialog_new();
if (toplevel != NULL)
{
GtkWindowGroup *wg;
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (toplevel));
if (gtk_window_has_group (GTK_WINDOW (toplevel)))
{
wg = gtk_window_get_group (GTK_WINDOW (toplevel));
}
else
{
wg = gtk_window_group_new ();
gtk_window_group_add_window (wg,
GTK_WINDOW (toplevel));
}
gtk_window_group_add_window (wg,
GTK_WINDOW (dialog));
}
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_signal_connect (dialog,
"response",
G_CALLBACK (dialog_response_cb),
menu);
gtk_widget_show (dialog);
}
}
static void
create_window (void)
{
GtkWidget *bar;
GtkWidget *table;
GtkWidget *contents;
GtkUIManager *ui;
GtkWidget *sw;
GtkActionGroup *actions;
GError *error;
GtkWindowGroup *group;
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
group = gtk_window_group_new ();
gtk_window_group_add_window (group, GTK_WINDOW (main_window));
g_object_unref (group);
gtk_window_set_default_size (GTK_WINDOW (main_window),
400, 600);
g_signal_connect (main_window, "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
actions = gtk_action_group_new ("Actions");
gtk_action_group_add_actions (actions, entries, n_entries, NULL);
ui = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui, actions, 0);
gtk_window_add_accel_group (GTK_WINDOW (main_window),
gtk_ui_manager_get_accel_group (ui));
gtk_container_set_border_width (GTK_CONTAINER (main_window), 0);
error = NULL;
if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error))
{
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
table = gtk_table_new (1, 3, FALSE);
gtk_container_add (GTK_CONTAINER (main_window), table);
bar = gtk_ui_manager_get_widget (ui, "/MenuBar");
gtk_widget_show (bar);
gtk_table_attach (GTK_TABLE (table),
bar,
/* X direction */ /* Y direction */
0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
/* Create document */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_table_attach (GTK_TABLE (table),
sw,
/* X direction */ /* Y direction */
0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL,
0, 0);
contents = gtk_text_view_new ();
gtk_widget_grab_focus (contents);
gtk_container_add (GTK_CONTAINER (sw),
contents);
/* Create statusbar */
statusbar = gtk_statusbar_new ();
gtk_table_attach (GTK_TABLE (table),
statusbar,
/* X direction */ /* Y direction */
0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
/* Show text widget info in the statusbar */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents));
g_signal_connect_object (buffer,
"changed",
G_CALLBACK (buffer_changed_callback),
NULL,
0);
g_signal_connect_object (buffer,
"mark_set", /* cursor moved */
G_CALLBACK (mark_set_callback),
NULL,
0);
g_signal_connect_object (main_window,
"window_state_event",
G_CALLBACK (update_resize_grip),
statusbar,
0);
update_ui ();
gtk_widget_show_all (main_window);
}
nsresult
EmbedPrompter::Create(PromptType aType, GtkWindow* aParentWindow)
{
mWindow = gtk_dialog_new_with_buttons(mTitle.get(), aParentWindow,
(GtkDialogFlags)0,
NULL);
// only add the dialog to the window group if the parent already has a window group,
// so as not to break app's expectations about modal dialogs.
if (aParentWindow && aParentWindow->group) {
gtk_window_group_add_window (aParentWindow->group, GTK_WINDOW (mWindow));
}
// gtk will resize this for us as necessary
gtk_window_set_default_size(GTK_WINDOW(mWindow), 100, 50);
// this HBox will contain the icon, and a vbox which contains the
// dialog text and other widgets.
GtkWidget* dialogHBox = gtk_hbox_new(FALSE, 12);
// Set up dialog properties according to the GNOME HIG
// (http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows)
gtk_container_set_border_width(GTK_CONTAINER(mWindow), 6);
gtk_dialog_set_has_separator(GTK_DIALOG(mWindow), FALSE);
gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(mWindow)->vbox), 12);
gtk_container_set_border_width(GTK_CONTAINER(dialogHBox), 6);
// This is the VBox which will contain the label and other controls.
GtkWidget* contentsVBox = gtk_vbox_new(FALSE, 12);
// get the stock icon for this dialog and put it in the box
const gchar* iconDesc = DialogTable[aType].icon;
GtkWidget* icon = gtk_image_new_from_stock(iconDesc, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0);
gtk_box_pack_start(GTK_BOX(dialogHBox), icon, FALSE, FALSE, 0);
// now pack the label into the vbox
GtkWidget* label = gtk_label_new(mMessageText.get());
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_box_pack_start(GTK_BOX(contentsVBox), label, FALSE, FALSE, 0);
int widgetFlags = DialogTable[aType].flags;
if (widgetFlags & (INCLUDE_USERNAME | INCLUDE_PASSWORD)) {
// If we're creating a username and/or password field, make an hbox
// which will contain two vboxes, one for the labels and one for the
// text fields. This will let us line up the textfields.
GtkWidget* userPassHBox = gtk_hbox_new(FALSE, 12);
GtkWidget* userPassLabels = gtk_vbox_new(TRUE, 6);
GtkWidget* userPassFields = gtk_vbox_new(TRUE, 6);
if (widgetFlags & INCLUDE_USERNAME) {
GtkWidget* userLabel = gtk_label_new("User Name:");
gtk_box_pack_start(GTK_BOX(userPassLabels), userLabel, FALSE,
FALSE, 0);
mUserField = gtk_entry_new();
if (!mUser.IsEmpty())
gtk_entry_set_text(GTK_ENTRY(mUserField), mUser.get());
gtk_entry_set_activates_default(GTK_ENTRY(mUserField), TRUE);
gtk_box_pack_start(GTK_BOX(userPassFields), mUserField, FALSE,
FALSE, 0);
}
if (widgetFlags & INCLUDE_PASSWORD) {
GtkWidget* passLabel = gtk_label_new("Password:");
gtk_box_pack_start(GTK_BOX(userPassLabels), passLabel, FALSE,
FALSE, 0);
mPassField = gtk_entry_new();
if (!mPass.IsEmpty())
gtk_entry_set_text(GTK_ENTRY(mPassField), mPass.get());
gtk_entry_set_visibility(GTK_ENTRY(mPassField), FALSE);
gtk_entry_set_activates_default(GTK_ENTRY(mPassField), TRUE);
gtk_box_pack_start(GTK_BOX(userPassFields), mPassField, FALSE,
FALSE, 0);
}
gtk_box_pack_start(GTK_BOX(userPassHBox), userPassLabels, FALSE,
FALSE, 0);
gtk_box_pack_start(GTK_BOX(userPassHBox), userPassFields, FALSE,
FALSE, 0);
gtk_box_pack_start(GTK_BOX(contentsVBox), userPassHBox, FALSE, FALSE, 0);
}
if (aType == TYPE_PROMPT) {
mTextField = gtk_entry_new();
if (!mTextValue.IsEmpty())
gtk_entry_set_text(GTK_ENTRY(mTextField), mTextValue.get());
gtk_entry_set_activates_default(GTK_ENTRY(mTextField), TRUE);
gtk_box_pack_start(GTK_BOX(contentsVBox), mTextField, FALSE, FALSE, 0);
}
// Add a checkbox
if ((widgetFlags & INCLUDE_CHECKBOX) && !mCheckMessage.IsEmpty()) {
mCheckBox = gtk_check_button_new_with_label(mCheckMessage.get());
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mCheckBox),
mCheckValue);
gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mCheckBox))),
TRUE);
gtk_box_pack_start(GTK_BOX(contentsVBox), mCheckBox, FALSE, FALSE, 0);
}
// Add a dropdown menu
if (aType == TYPE_SELECT) {
// Build up a GtkMenu containing the items
GtkWidget* menu = gtk_menu_new();
for (PRUint32 i = 0; i < mItemCount; ++i) {
GtkWidget* item = gtk_menu_item_new_with_label(mItemList[i].get());
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
}
// Now create an OptionMenu and set this as the menu
mOptionMenu = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(mOptionMenu), menu);
gtk_box_pack_start(GTK_BOX(contentsVBox), mOptionMenu, FALSE, FALSE, 0);
}
if (aType == TYPE_UNIVERSAL) {
// Create buttons based on the flags passed in.
for (int i = EMBED_MAX_BUTTONS; i >= 0; --i) {
if (!mButtonLabels[i].IsEmpty())
gtk_dialog_add_button(GTK_DIALOG(mWindow),
mButtonLabels[i].get(), i);
}
gtk_dialog_set_default_response(GTK_DIALOG(mWindow), 0);
} else {
// Create standard ok and cancel buttons
if (widgetFlags & INCLUDE_CANCEL)
gtk_dialog_add_button(GTK_DIALOG(mWindow), GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
GtkWidget* okButton = gtk_dialog_add_button(GTK_DIALOG(mWindow),
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT);
gtk_widget_grab_default(okButton);
}
// Pack the contentsVBox into the dialogHBox and the dialog.
gtk_box_pack_start(GTK_BOX(dialogHBox), contentsVBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(mWindow)->vbox), dialogHBox, FALSE,
FALSE, 0);
return NS_OK;
}
void
GtkNSSSecurityWarningDialogs::DoDialog (nsIInterfaceRequestor *aContext,
const char *aPrefName,
GtkMessageType aType,
GtkButtonsType aButtons,
int aDefaultResponse,
const char *aPrimary,
const char *aSecondary,
const char *aButtonText,
PRBool *_retval)
{
if (_retval) *_retval = PR_FALSE;
nsresult rv;
PRBool show = PR_TRUE;
nsCOMPtr<nsIPrefBranch> prefBranch
(do_GetService (NS_PREFSERVICE_CONTRACTID));
if (prefBranch && aPrefName)
{
rv = prefBranch->GetBoolPref (aPrefName, &show);
if (NS_FAILED(rv)) show = PR_TRUE;
}
char *showOncePref = NULL;
PRBool showOnce = PR_FALSE;
if (!show && prefBranch && aPrefName)
{
showOncePref = g_strconcat (aPrefName, ".show_once", NULL);
rv = prefBranch->GetBoolPref (showOncePref, &showOnce);
if (NS_FAILED (rv)) showOnce = PR_FALSE;
}
if (!show && !showOnce)
{
g_free (showOncePref);
if (_retval) *_retval = PR_TRUE;
return;
}
AutoJSContextStack stack;
rv = stack.Init ();
if (NS_FAILED (rv)) return;
/* Didn't you know it, mozilla SUCKS!
* the "aContext" interface requestor is made from a nsIDOMWindow,
* but can only give out a nsIPrompt, from where there's no way to get
* the nsIDOMWindow back!
*
* However GaleonUtils::FindGtkParent falls back to the current active
* window so this vageuly works for us at the moment
*
* https://bugzilla.mozilla.org/show_bug.cgi?id=277587
*/
nsCOMPtr<nsIDOMWindow> domWin (do_GetInterface (aContext));
GtkWidget *parent = GaleonUtils::FindGtkParent (domWin);
GtkDialogFlags flags = parent ? (GtkDialogFlags)0 : GTK_DIALOG_MODAL;
#if GTK_CHECK_VERSION(2,6,0)
GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW (parent), flags,
aType, aButtons, "%s", aPrimary);
if (aSecondary)
{
gtk_message_dialog_format_secondary_markup
(GTK_MESSAGE_DIALOG (dialog), "%s", aSecondary);
}
#else
GtkWidget *dialog = hig_alert_new (GTK_WINDOW (parent), flags,
aType == GTK_MESSAGE_INFO ?
HIG_ALERT_INFORMATION : HIG_ALERT_CONFIRMATION,
aPrimary, aSecondary, NULL);
if (aButtons == GTK_BUTTONS_OK)
{
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK,
GTK_RESPONSE_OK);
}
else if (aButtons == GTK_BUTTONS_CANCEL)
{
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
}
else
{
g_assert_not_reached();
}
#endif
if (parent && GTK_WINDOW (parent)->group)
{
gtk_window_group_add_window (GTK_WINDOW (parent)->group,
GTK_WINDOW (dialog));
}
if (aButtonText)
{
gtk_dialog_add_button (GTK_DIALOG (dialog), aButtonText,
GTK_RESPONSE_ACCEPT);
}
gtk_dialog_set_default_response (GTK_DIALOG (dialog), aDefaultResponse);
int response = gtk_dialog_run (GTK_DIALOG (dialog));
if (_retval) *_retval = response == GTK_RESPONSE_ACCEPT;
if (prefBranch && showOncePref && showOnce)
{
prefBranch->SetBoolPref (showOncePref, PR_FALSE);
}
gtk_widget_destroy (dialog);
g_free (showOncePref);
}
bool wxPopupWindow::Create( wxWindow *parent, int style )
{
if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
!CreateBase( parent, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("popup") ))
{
wxFAIL_MSG( wxT("wxPopupWindow creation failed") );
return false;
}
// Unlike windows, top level windows are created hidden by default.
m_isShown = false;
// All dialogs should really have this style
m_windowStyle |= wxTAB_TRAVERSAL;
m_widget = gtk_window_new( GTK_WINDOW_POPUP );
g_object_ref( m_widget );
gtk_widget_set_name( m_widget, "wxPopupWindow" );
// wxPopupWindow is used for different windows as well
// gtk_window_set_type_hint( GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_COMBO );
// Popup windows can be created without parent, so handle this correctly.
if (parent)
{
GtkWidget *toplevel = gtk_widget_get_toplevel( parent->m_widget );
if (GTK_IS_WINDOW (toplevel))
{
#if GTK_CHECK_VERSION(2,10,0)
#ifndef __WXGTK3__
if (!gtk_check_version(2,10,0))
#endif
{
gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)), GTK_WINDOW (m_widget));
}
#endif
gtk_window_set_transient_for (GTK_WINDOW (m_widget), GTK_WINDOW (toplevel));
}
gtk_window_set_screen (GTK_WINDOW (m_widget), gtk_widget_get_screen (GTK_WIDGET (parent->m_widget)));
}
gtk_window_set_resizable (GTK_WINDOW (m_widget), FALSE);
g_signal_connect (m_widget, "delete_event",
G_CALLBACK (gtk_dialog_delete_callback), this);
m_wxwindow = wxPizza::New();
gtk_widget_show( m_wxwindow );
gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
if (m_parent) m_parent->AddChild( this );
PostCreation();
m_time = gtk_get_current_event_time();
g_signal_connect (m_widget, "button_press_event",
G_CALLBACK (gtk_popup_button_press), this);
return true;
}
static void
moo_position_window_real (GtkWidget *window,
GtkWidget *parent,
gboolean at_mouse,
gboolean at_coords,
int x,
int y)
{
GtkWidget *toplevel = NULL;
g_return_if_fail (GTK_IS_WINDOW (window));
if (parent)
toplevel = gtk_widget_get_toplevel (parent);
if (toplevel && !GTK_IS_WINDOW (toplevel))
toplevel = NULL;
if (toplevel)
{
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (toplevel));
#ifdef __WIN32__
g_signal_handlers_disconnect_by_func (window, (gpointer) on_hide, NULL);
g_signal_connect (window, "unmap", G_CALLBACK (on_hide), NULL);
#endif
}
if (toplevel && GTK_WINDOW(toplevel)->group)
gtk_window_group_add_window (GTK_WINDOW(toplevel)->group, GTK_WINDOW (window));
if (!at_mouse && !at_coords && parent && GTK_WIDGET_REALIZED (parent))
{
if (GTK_IS_WINDOW (parent))
{
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ON_PARENT);
}
else
{
GdkWindow *parent_window = gtk_widget_get_parent_window (parent);
gdk_window_get_origin (parent_window, &x, &y);
x += parent->allocation.x;
y += parent->allocation.y;
x += parent->allocation.width / 2;
y += parent->allocation.height / 2;
at_coords = TRUE;
}
}
if (at_mouse)
{
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
}
else if (at_coords)
{
GdkPoint *coord = g_new (GdkPoint, 1);
coord->x = x;
coord->y = y;
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_NONE);
g_object_set_data_full (G_OBJECT (window), "moo-coords", coord, g_free);
if (!GTK_WIDGET_REALIZED (window))
{
g_signal_handlers_disconnect_by_func (window, (gpointer) position_window, NULL);
g_signal_connect (window, "realize",
G_CALLBACK (position_window),
NULL);
}
else
{
position_window (GTK_WINDOW (window));
}
}
}
NS_IMETHODIMP
nsFilePicker::Show(PRInt16 *aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
nsXPIDLCString title;
title.Adopt(ToNewUTF8String(mTitle));
GtkWindow *parent_widget = get_gtk_window_for_nsiwidget(mParentWidget);
GtkFileChooserAction action = GetGtkFileChooserAction(mMode);
const gchar *accept_button = (action == GTK_FILE_CHOOSER_ACTION_SAVE)
? GTK_STOCK_SAVE : GTK_STOCK_OPEN;
#if (MOZ_PLATFORM_MAEMO == 5)
GtkWidget *file_chooser =
hildon_file_chooser_dialog_new_with_properties(parent_widget,
"action", action,
"open-button-text", accept_button,
NULL);
gtk_window_set_title(GTK_WINDOW(file_chooser), title);
#else
GtkWidget *file_chooser =
gtk_file_chooser_dialog_new(title, parent_widget, action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
accept_button, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_alternative_button_order(GTK_DIALOG(file_chooser),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
if (mAllowURLs) {
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser), FALSE);
}
#endif
if (action == GTK_FILE_CHOOSER_ACTION_OPEN || action == GTK_FILE_CHOOSER_ACTION_SAVE) {
GtkWidget *img_preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(file_chooser), img_preview);
g_signal_connect(file_chooser, "update-preview", G_CALLBACK(UpdateFilePreviewWidget), img_preview);
}
if (parent_widget && parent_widget->group) {
gtk_window_group_add_window(parent_widget->group, GTK_WINDOW(file_chooser));
}
NS_ConvertUTF16toUTF8 defaultName(mDefault);
switch (mMode) {
case nsIFilePicker::modeOpenMultiple:
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), TRUE);
break;
case nsIFilePicker::modeSave:
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser),
defaultName.get());
break;
}
nsCOMPtr<nsIFile> defaultPath;
if (mDisplayDirectory) {
mDisplayDirectory->Clone(getter_AddRefs(defaultPath));
} else if (mPrevDisplayDirectory) {
mPrevDisplayDirectory->Clone(getter_AddRefs(defaultPath));
}
if (defaultPath) {
if (!defaultName.IsEmpty() && mMode != nsIFilePicker::modeSave) {
// Try to select the intended file. Even if it doesn't exist, GTK still switches
// directories.
defaultPath->AppendNative(defaultName);
nsCAutoString path;
defaultPath->GetNativePath(path);
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_chooser), path.get());
} else {
nsCAutoString directory;
defaultPath->GetNativePath(directory);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser),
directory.get());
}
}
gtk_dialog_set_default_response(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT);
PRInt32 count = mFilters.Length();
for (PRInt32 i = 0; i < count; ++i) {
// This is fun... the GTK file picker does not accept a list of filters
// so we need to split out each string, and add it manually.
char **patterns = g_strsplit(mFilters[i].get(), ";", -1);
if (!patterns) {
return NS_ERROR_OUT_OF_MEMORY;
}
GtkFileFilter *filter = gtk_file_filter_new();
for (int j = 0; patterns[j] != NULL; ++j) {
nsCAutoString caseInsensitiveFilter = MakeCaseInsensitiveShellGlob(g_strstrip(patterns[j]));
gtk_file_filter_add_pattern(filter, caseInsensitiveFilter.get());
}
g_strfreev(patterns);
if (!mFilterNames[i].IsEmpty()) {
// If we have a name for our filter, let's use that.
const char *filter_name = mFilterNames[i].get();
gtk_file_filter_set_name(filter, filter_name);
} else {
// If we don't have a name, let's just use the filter pattern.
const char *filter_pattern = mFilters[i].get();
gtk_file_filter_set_name(filter, filter_pattern);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
// Set the initially selected filter
if (mSelectedType == i) {
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser), filter);
}
}
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), PR_TRUE);
gint response = RunDialog(GTK_DIALOG(file_chooser));
switch (response) {
case GTK_RESPONSE_OK:
case GTK_RESPONSE_ACCEPT:
ReadValuesFromFileChooser(file_chooser);
*aReturn = nsIFilePicker::returnOK;
if (mMode == nsIFilePicker::modeSave) {
nsCOMPtr<nsILocalFile> file;
GetFile(getter_AddRefs(file));
if (file) {
PRBool exists = PR_FALSE;
file->Exists(&exists);
if (exists)
*aReturn = nsIFilePicker::returnReplace;
}
}
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_CLOSE:
case GTK_RESPONSE_DELETE_EVENT:
*aReturn = nsIFilePicker::returnCancel;
break;
default:
NS_WARNING("Unexpected response");
*aReturn = nsIFilePicker::returnCancel;
break;
}
gtk_widget_destroy(file_chooser);
return NS_OK;
}
NS_IMETHODIMP
nsFilePicker::Show(PRInt16 *aReturn)
{
NS_ENSURE_ARG_POINTER(aReturn);
nsXPIDLCString title;
title.Adopt(ToNewUTF8String(mTitle));
GtkWindow *parent_widget = get_gtk_window_for_nsiwidget(mParentWidget);
GtkFileChooserAction action = GetGtkFileChooserAction(mMode);
const gchar *accept_button = (mMode == GTK_FILE_CHOOSER_ACTION_SAVE)
? GTK_STOCK_SAVE : GTK_STOCK_OPEN;
GtkWidget *file_chooser =
_gtk_file_chooser_dialog_new(title, parent_widget, action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
accept_button, GTK_RESPONSE_ACCEPT,
NULL);
if (parent_widget && parent_widget->group) {
gtk_window_group_add_window(parent_widget->group, GTK_WINDOW(file_chooser));
}
if (mMode == nsIFilePicker::modeOpenMultiple) {
_gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(file_chooser), TRUE);
} else if (mMode == nsIFilePicker::modeSave) {
char *default_filename = ToNewUTF8String(mDefault);
_gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser),
NS_STATIC_CAST(const gchar*, default_filename));
nsMemory::Free(default_filename);
}
gtk_dialog_set_default_response(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT);
nsCAutoString directory;
if (mDisplayDirectory) {
mDisplayDirectory->GetNativePath(directory);
} else if (mPrevDisplayDirectory) {
mPrevDisplayDirectory->GetNativePath(directory);
}
if (!directory.IsEmpty()) {
_gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser),
directory.get());
}
PRInt32 count = mFilters.Count();
for (PRInt32 i = 0; i < count; ++i) {
// This is fun... the GTK file picker does not accept a list of filters
// so we need to split out each string, and add it manually.
char **patterns = g_strsplit(mFilters[i]->get(), ";", -1);
if (!patterns) {
return NS_ERROR_OUT_OF_MEMORY;
}
GtkFileFilter *filter = _gtk_file_filter_new ();
for (int j = 0; patterns[j] != NULL; ++j) {
_gtk_file_filter_add_pattern (filter, g_strstrip (patterns[j]));
}
g_strfreev(patterns);
if (!mFilterNames[i]->IsEmpty()) {
// If we have a name for our filter, let's use that.
const char *filter_name = mFilterNames[i]->get();
_gtk_file_filter_set_name (filter, filter_name);
} else {
// If we don't have a name, let's just use the filter pattern.
const char *filter_pattern = mFilters[i]->get();
_gtk_file_filter_set_name (filter, filter_pattern);
}
_gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), filter);
// Set the initially selected filter
if (mSelectedType == i) {
_gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(file_chooser), filter);
}
}
PRBool checkForOverwrite = PR_TRUE;
if (_gtk_file_chooser_set_do_overwrite_confirmation) {
checkForOverwrite = PR_FALSE;
// Only available in GTK 2.8
_gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), PR_TRUE);
}
gint response = gtk_dialog_run (GTK_DIALOG (file_chooser));
switch (response) {
case GTK_RESPONSE_ACCEPT:
ReadValuesFromFileChooser(file_chooser);
*aReturn = nsIFilePicker::returnOK;
if (mMode == nsIFilePicker::modeSave) {
nsCOMPtr<nsILocalFile> file;
GetFile(getter_AddRefs(file));
if (file) {
PRBool exists = PR_FALSE;
file->Exists(&exists);
if (exists) {
PRBool overwrite = !checkForOverwrite ||
confirm_overwrite_file (file_chooser, file);
if (overwrite) {
*aReturn = nsIFilePicker::returnReplace;
} else {
*aReturn = nsIFilePicker::returnCancel;
}
}
}
}
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_CLOSE:
case GTK_RESPONSE_DELETE_EVENT:
*aReturn = nsIFilePicker::returnCancel;
break;
default:
NS_WARNING("Unexpected response");
*aReturn = nsIFilePicker::returnCancel;
break;
}
gtk_widget_destroy(file_chooser);
return NS_OK;
}
static void
gnc_date_edit_popup (GNCDateEdit *gde)
{
GtkWidget *toplevel;
struct tm mtm;
gboolean date_was_valid;
GdkDevice *device, *keyboard, *pointer;
g_return_if_fail (GNC_IS_DATE_EDIT (gde));
ENTER("gde %p", gde);
device = gtk_get_current_event_device ();
/* This code is pretty much just copied from gtk_date_edit_get_date */
date_was_valid = qof_scan_date (gtk_entry_get_text (GTK_ENTRY (gde->date_entry)),
&mtm.tm_mday, &mtm.tm_mon, &mtm.tm_year);
if (!date_was_valid)
{
/* No valid date. Hacky workaround: Instead of crashing we randomly choose today's date. */
gnc_tm_get_today_start(&mtm);
}
mtm.tm_mon--;
/* Hope the user does not actually mean years early in the A.D. days...
* This date widget will obviously not work for a history program :-)
*/
if (mtm.tm_year >= 1900)
mtm.tm_year -= 1900;
gnc_tm_set_day_start(&mtm);
/* Set the calendar. */
gtk_calendar_select_day (GTK_CALENDAR (gde->calendar), 1);
gtk_calendar_select_month (GTK_CALENDAR (gde->calendar), mtm.tm_mon,
1900 + mtm.tm_year);
gtk_calendar_select_day (GTK_CALENDAR (gde->calendar), mtm.tm_mday);
/* Make sure we'll get notified of clicks outside the popup
* window so we can properly pop down if that happens. */
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (gde));
if (GTK_IS_WINDOW (toplevel))
{
gtk_window_group_add_window (
gtk_window_get_group (GTK_WINDOW (toplevel)),
GTK_WINDOW (gde->cal_popup));
gtk_window_set_transient_for (GTK_WINDOW (gde->cal_popup),
GTK_WINDOW (toplevel));
}
position_popup (gde);
gtk_widget_show (gde->cal_popup);
gtk_widget_grab_focus (gde->cal_popup);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gde->date_button),
TRUE);
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
keyboard = device;
pointer = gdk_device_get_associated_device (device);
}
else
{
pointer = device;
keyboard = gdk_device_get_associated_device (device);
}
if (!gtk_widget_has_focus (gde->calendar))
gtk_widget_grab_focus (gde->calendar);
if (!popup_grab_on_window (gtk_widget_get_window ((GTK_WIDGET(gde->cal_popup))),
keyboard, pointer, GDK_CURRENT_TIME))
{
gtk_widget_hide (gde->cal_popup);
LEAVE("Failed to grab window");
return;
}
gtk_grab_add (gde->cal_popup);
LEAVE(" ");
}
static gboolean
cg_combo_flags_popup_idle (gpointer data)
{
CgComboFlags *combo;
CgComboFlagsPrivate *priv;
GtkTreeSelection* selection;
GtkWidget *toplevel;
GtkWidget *scrolled;
GdkWindow *window;
GdkDeviceManager* device_manager;
gint height, width, x, y;
combo = CG_COMBO_FLAGS (data);
priv = CG_COMBO_FLAGS_PRIVATE (combo);
g_assert (priv->window == NULL);
priv->window = gtk_window_new (GTK_WINDOW_POPUP);
g_object_ref (G_OBJECT (priv->window));
gtk_window_set_resizable (GTK_WINDOW (priv->window), FALSE);
g_signal_connect (G_OBJECT (priv->window), "key_press_event",
G_CALLBACK (cg_combo_flags_window_key_press_cb),
combo);
g_signal_connect (G_OBJECT (priv->window), "button_press_event",
G_CALLBACK (cg_combo_flags_window_button_press_cb),
combo);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (priv->window), scrolled);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_widget_show (scrolled);
priv->treeview = gtk_tree_view_new_with_model (priv->model);
gtk_widget_show (priv->treeview);
gtk_container_add (GTK_CONTAINER (scrolled), priv->treeview);
g_signal_connect (G_OBJECT (priv->treeview), "key_press_event",
G_CALLBACK (cg_combo_flags_treeview_key_press_cb),
combo);
g_signal_connect (G_OBJECT (priv->treeview), "button_press_event",
G_CALLBACK (cg_combo_flags_treeview_button_press_cb),
combo);
priv->column = gtk_tree_view_column_new ();
g_object_ref (G_OBJECT (priv->column));
cg_combo_flags_sync_cells (combo, GTK_CELL_LAYOUT (priv->column));
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), priv->column);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), FALSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->treeview), TRUE);
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo));
if (GTK_IS_WINDOW (toplevel))
{
gtk_window_group_add_window (gtk_window_get_group (
GTK_WINDOW (toplevel)),
GTK_WINDOW (priv->window));
gtk_window_set_transient_for (GTK_WINDOW (priv->window),
GTK_WINDOW (toplevel));
}
gtk_window_set_screen (GTK_WINDOW (priv->window),
gtk_widget_get_screen (GTK_WIDGET (combo)));
cg_combo_flags_get_position (combo, &x, &y, &width, &height);
gtk_widget_set_size_request (priv->window, width, height);
gtk_window_move (GTK_WINDOW(priv->window), x, y);
gtk_widget_show (priv->window);
gtk_widget_grab_focus (priv->window);
if (!gtk_widget_has_focus (priv->treeview))
gtk_widget_grab_focus (priv->treeview);
window = gtk_widget_get_window (priv->window);
device_manager = gdk_display_get_device_manager (gdk_window_get_display (window));
priv->pointer_device = gdk_device_manager_get_client_pointer (device_manager);
priv->keyboard_device = gdk_device_get_associated_device (priv->pointer_device);
gtk_grab_add (priv->window);
gdk_device_grab (priv->pointer_device, window, GDK_OWNERSHIP_NONE, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
NULL, GDK_CURRENT_TIME);
gdk_device_grab (priv->keyboard_device, window, GDK_OWNERSHIP_NONE, TRUE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, GDK_CURRENT_TIME);
return FALSE;
}
