mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
409 lines
13 KiB
C++
409 lines
13 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* vim:expandtab:shiftwidth=4:tabstop=4: */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 2003
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Brian Ryner <bryner@brianryner.com>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#include "EmbedPrompter.h"
|
|
|
|
enum {
|
|
INCLUDE_USERNAME = 1 << 0,
|
|
INCLUDE_PASSWORD = 1 << 1,
|
|
INCLUDE_CHECKBOX = 1 << 2,
|
|
INCLUDE_CANCEL = 1 << 3
|
|
};
|
|
|
|
struct DialogDescription {
|
|
int flags;
|
|
gchar* icon;
|
|
};
|
|
|
|
// This table contains the optional widgets and icons associated with
|
|
// each type of dialog.
|
|
|
|
static const DialogDescription DialogTable[] = {
|
|
{ 0, GTK_STOCK_DIALOG_WARNING }, // ALERT
|
|
{ INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_WARNING }, // ALERT_CHECK
|
|
{ INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // CONFIRM
|
|
{ INCLUDE_CHECKBOX |
|
|
INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // CONFIRM_CHECK
|
|
{ INCLUDE_CANCEL |
|
|
INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT
|
|
{ INCLUDE_CANCEL |
|
|
INCLUDE_USERNAME |
|
|
INCLUDE_PASSWORD |
|
|
INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT_USER_PASS
|
|
{ INCLUDE_CANCEL |
|
|
INCLUDE_PASSWORD |
|
|
INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION }, // PROMPT_PASS
|
|
{ INCLUDE_CANCEL, GTK_STOCK_DIALOG_QUESTION }, // SELECT
|
|
{ INCLUDE_CANCEL |
|
|
INCLUDE_CHECKBOX, GTK_STOCK_DIALOG_QUESTION } // UNIVERSAL
|
|
};
|
|
|
|
EmbedPrompter::EmbedPrompter(void)
|
|
: mCheckValue(PR_FALSE),
|
|
mItemList(nsnull),
|
|
mItemCount(0),
|
|
mButtonPressed(0),
|
|
mConfirmResult(PR_FALSE),
|
|
mSelectedItem(0),
|
|
mWindow(NULL),
|
|
mUserField(NULL),
|
|
mPassField(NULL),
|
|
mTextField(NULL),
|
|
mOptionMenu(NULL),
|
|
mCheckBox(NULL)
|
|
{
|
|
}
|
|
|
|
EmbedPrompter::~EmbedPrompter(void)
|
|
{
|
|
if (mItemList)
|
|
delete[] mItemList;
|
|
}
|
|
|
|
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
|
|
EmbedPrompter::SetTitle(const PRUnichar *aTitle)
|
|
{
|
|
mTitle.Assign(NS_ConvertUTF16toUTF8(aTitle));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetTextValue(const PRUnichar *aTextValue)
|
|
{
|
|
mTextValue.Assign(NS_ConvertUTF16toUTF8(aTextValue));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetCheckMessage(const PRUnichar *aMessage)
|
|
{
|
|
mCheckMessage.Assign(NS_ConvertUTF16toUTF8(aMessage));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetMessageText(const PRUnichar *aMessageText)
|
|
{
|
|
mMessageText.Assign(NS_ConvertUTF16toUTF8(aMessageText));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetUser(const PRUnichar *aUser)
|
|
{
|
|
mUser.Assign(NS_ConvertUTF16toUTF8(aUser));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetPassword(const PRUnichar *aPass)
|
|
{
|
|
mPass.Assign(NS_ConvertUTF16toUTF8(aPass));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetCheckValue(const PRBool aValue)
|
|
{
|
|
mCheckValue = aValue;
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetItems(const PRUnichar** aItemArray, PRUint32 aCount)
|
|
{
|
|
if (mItemList)
|
|
delete[] mItemList;
|
|
|
|
mItemCount = aCount;
|
|
mItemList = new nsCString[aCount];
|
|
for (PRUint32 i = 0; i < aCount; ++i)
|
|
mItemList[i].Assign(NS_ConvertUTF16toUTF8(aItemArray[i]));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SetButtons(const PRUnichar* aButton0Label,
|
|
const PRUnichar* aButton1Label,
|
|
const PRUnichar* aButton2Label)
|
|
{
|
|
mButtonLabels[0].Assign(NS_ConvertUTF16toUTF8(aButton0Label));
|
|
mButtonLabels[1].Assign(NS_ConvertUTF16toUTF8(aButton1Label));
|
|
mButtonLabels[2].Assign(NS_ConvertUTF16toUTF8(aButton2Label));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::GetCheckValue(PRBool *aValue)
|
|
{
|
|
*aValue = mCheckValue;
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::GetConfirmValue(PRBool *aConfirmValue)
|
|
{
|
|
*aConfirmValue = mConfirmResult;
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::GetTextValue(PRUnichar **aTextValue)
|
|
{
|
|
*aTextValue = ToNewUnicode(NS_ConvertUTF8toUTF16(mTextValue));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::GetUser(PRUnichar **aUser)
|
|
{
|
|
*aUser = ToNewUnicode(NS_ConvertUTF8toUTF16(mUser));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::GetPassword(PRUnichar **aPass)
|
|
{
|
|
*aPass = ToNewUnicode(NS_ConvertUTF8toUTF16(mPass));
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::GetSelectedItem(PRInt32 *aIndex)
|
|
{
|
|
*aIndex = mSelectedItem;
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::GetButtonPressed(PRInt32 *aButton)
|
|
{
|
|
*aButton = mButtonPressed;
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::Run(void)
|
|
{
|
|
gtk_widget_show_all(mWindow);
|
|
gint response = gtk_dialog_run(GTK_DIALOG(mWindow));
|
|
switch (response) {
|
|
case GTK_RESPONSE_NONE:
|
|
case GTK_RESPONSE_CANCEL:
|
|
case GTK_RESPONSE_DELETE_EVENT:
|
|
mConfirmResult = PR_FALSE;
|
|
break;
|
|
case GTK_RESPONSE_ACCEPT:
|
|
mConfirmResult = PR_TRUE;
|
|
SaveDialogValues();
|
|
break;
|
|
default:
|
|
mButtonPressed = response;
|
|
SaveDialogValues();
|
|
}
|
|
|
|
gtk_widget_destroy(mWindow);
|
|
}
|
|
|
|
void
|
|
EmbedPrompter::SaveDialogValues()
|
|
{
|
|
if (mUserField)
|
|
mUser.Assign(gtk_entry_get_text(GTK_ENTRY(mUserField)));
|
|
|
|
if (mPassField)
|
|
mPass.Assign(gtk_entry_get_text(GTK_ENTRY(mPassField)));
|
|
|
|
if (mCheckBox)
|
|
mCheckValue = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mCheckBox));
|
|
|
|
if (mTextField)
|
|
mTextValue.Assign(gtk_entry_get_text(GTK_ENTRY(mTextField)));
|
|
|
|
if (mOptionMenu)
|
|
mSelectedItem = gtk_option_menu_get_history(GTK_OPTION_MENU(mOptionMenu));
|
|
}
|