From a556c2e84fc121dacdbb00629c68371b72c5cb7a Mon Sep 17 00:00:00 2001
From: Jacek Antonelli
Date: Mon, 29 Jun 2009 17:25:47 -0500
Subject: Updated URL for Mac OpenAL libs package.
---
linden/install.xml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/linden/install.xml b/linden/install.xml
index 224cd65..b213b94 100644
--- a/linden/install.xml
+++ b/linden/install.xml
@@ -1128,7 +1128,7 @@ anguage Infrstructure (CLI) international standard
md5sum
f30b851e089108978c8218295a405159
url
- http://thomas.shikami.mooo.com/install_pkgs/openal-darwin-20090418.tar.bz2
+ http://imprudenceviewer.org/download/libs/openal-darwin-20090418.tar.bz2
linux
+ DefaultGrid
+
+ KeepAppearance
+
+ CheckForGridUpdates
+
diff --git a/linden/indra/newview/authentication_controller.cpp b/linden/indra/newview/authentication_controller.cpp
new file mode 100644
index 0000000..a060409
--- /dev/null
+++ b/linden/indra/newview/authentication_controller.cpp
@@ -0,0 +1,80 @@
+/*
+ * AuthenticationController.cpp
+ * SecondLife
+ *
+ * Created by RMS on 7/1/08.
+ *
+ */
+
+#include "llviewerprecompiledheaders.h"
+#include "authentication_floater.h"
+#include "llviewerobject.h"
+#include "llcheckboxctrl.h"
+#include "llselectmgr.h"
+#include "authentication_controller.h"
+
+// Statics
+std::string AuthenticationController::target_grid;
+std::string AuthenticationController::username;
+std::string AuthenticationController::password;
+BOOL AuthenticationController::store_pw = FALSE;
+
+AuthenticationController::AuthenticationController(const std::string& tg, void (*cb)(void*))
+{
+ target_grid = tg;
+ callback = cb;
+}
+
+AuthenticationController::~AuthenticationController()
+{
+}
+
+// user interface callbacks: all static
+void AuthenticationController::onCommitUser(LLUICtrl* ctrl, void* userdata)
+{
+ AuthenticationFloater *floater = (AuthenticationFloater*)userdata;
+ username = floater->childGetText("User_edit");
+}
+
+void AuthenticationController::onCommitPassword(LLUICtrl* ctrl, void* userdata)
+{
+ AuthenticationFloater *floater = (AuthenticationFloater*)userdata;
+ password = floater->childGetText("Password_edit");
+}
+
+void AuthenticationController::onCommitRemember(LLUICtrl* ctrl, void* userdata)
+{
+ LLViewerObject *object = LLSelectMgr::getInstance()->getSelection()->getFirstRootObject();
+ if(!object) return;
+
+ LLCheckBoxCtrl *check = (LLCheckBoxCtrl*)ctrl;
+ store_pw = check->get();
+}
+
+void AuthenticationController::onAccept(void* userdata)
+{
+
+}
+
+void AuthenticationController::onCancel(void* userdata)
+{
+ AuthenticationFloater *floater = (AuthenticationFloater*)userdata;
+ floater->cancel();
+ floater->close();
+}
+
+void AuthenticationController::onClickRegister(void* userdata)
+{
+ llinfos << "onClickRegister" << llendl;
+}
+
+void AuthenticationController::retrieveStoredAccountData(void* userdata)
+{
+
+}
+
+// static
+std::string AuthenticationController::getTargetGrid()
+{
+ return target_grid;
+}
diff --git a/linden/indra/newview/authentication_controller.h b/linden/indra/newview/authentication_controller.h
new file mode 100644
index 0000000..db875ea
--- /dev/null
+++ b/linden/indra/newview/authentication_controller.h
@@ -0,0 +1,42 @@
+/*
+ * AuthenticationController.h
+ * SecondLife
+ *
+ * Created by RMS on 7/1/08.
+ *
+ */
+
+#ifndef PL_AuthenticationController_H
+#define PL_AuthenticationController_H
+
+#include "llfloater.h"
+
+class AuthenticationController
+{
+public:
+ AuthenticationController(const std::string& tg, void (*cb)(void*));
+ virtual ~AuthenticationController();
+
+ // line editor callbacks
+ static void onCommitUser(LLUICtrl* ctrl, void* userdata);
+ static void onCommitPassword(LLUICtrl* ctrl, void* userdata);
+ static void onCommitRemember(LLUICtrl* ctrl, void* userdata);
+ // button callbacks
+ static void onAccept(void* userdata);
+ static void onCancel(void* userdata);
+ static void onClickRegister(void* userdata);
+
+ void retrieveStoredAccountData(void* userdata);
+ static std::string getTargetGrid();
+
+private:
+ static std::string target_grid;
+ static std::string username;
+ static std::string password;
+ static BOOL store_pw;
+ void (*callback)(void*);
+};
+
+
+#endif // PL_AuthenticationController_H
+
diff --git a/linden/indra/newview/authentication_floater.cpp b/linden/indra/newview/authentication_floater.cpp
new file mode 100644
index 0000000..2fc7add
--- /dev/null
+++ b/linden/indra/newview/authentication_floater.cpp
@@ -0,0 +1,75 @@
+/*
+ * AuthenticationFloater.cpp
+ * Cross-grid authentication system view.
+ *
+ * Created by RMS on 7/1/08.
+ *
+ */
+
+
+#include "llviewerprecompiledheaders.h"
+#include "authentication_floater.h"
+#include "lluictrlfactory.h"
+
+// Statics
+AuthenticationFloater* AuthenticationFloater::sInstance = NULL;
+AuthenticationController* AuthenticationFloater::sController = NULL;
+
+AuthenticationFloater::AuthenticationFloater()
+: LLFloater("floater_authentication")
+{
+ LLUICtrlFactory::getInstance()->buildFloater(this, "floater_authentication.xml");
+
+ childSetTextArg("Intro_text", "[TARGET_GRID]", sController->getTargetGrid());
+
+ childSetCommitCallback("User_edit", controller()->onCommitUser, this);
+ childSetCommitCallback("Password_edit", controller()->onCommitPassword, this);
+ childSetCommitCallback("Remember_check", controller()->onCommitRemember, this);
+
+ childSetAction("OK", controller()->onAccept, this);
+ childSetAction("Cancel", controller()->onCancel, this);
+ childSetAction("Register", controller()->onClickRegister, this);
+
+ setDefaultBtn("OK");
+}
+
+AuthenticationFloater::~AuthenticationFloater()
+{
+ sInstance = NULL;
+ delete sController;
+ sController = NULL;
+}
+
+// static
+void AuthenticationFloater::show(void* userdata)
+{
+ std::string target_grid;
+ void (*cb)(void*) = NULL;
+
+ if (!userdata)
+ {
+ target_grid = "Authentication Test";
+ }
+
+ if (!sInstance)
+ sInstance = new AuthenticationFloater();
+ if (!sController)
+ sController = new AuthenticationController(target_grid, cb);
+
+ sInstance->open();
+}
+
+void AuthenticationFloater::accept()
+{
+ llinfos << "accept" << llendl;
+}
+
+void AuthenticationFloater::cancel()
+{
+ llinfos << "cancel" << llendl;
+}
+
+AuthenticationController* AuthenticationFloater::controller()
+{
+ return sController;
+}
diff --git a/linden/indra/newview/authentication_floater.h b/linden/indra/newview/authentication_floater.h
new file mode 100644
index 0000000..b24426b
--- /dev/null
+++ b/linden/indra/newview/authentication_floater.h
@@ -0,0 +1,35 @@
+/*
+ * AuthenticationFloater.h
+ * Cross-grid authentication system view.
+ *
+ * Created by RMS on 7/1/08.
+ *
+ */
+
+#ifndef PL_AuthenticationFloater_H
+#define PL_AuthenticationFloater_H
+
+#include "llfloater.h"
+#include "authentication_controller.h"
+
+class AuthenticationFloater : public LLFloater
+{
+public:
+ AuthenticationFloater();
+ virtual ~AuthenticationFloater();
+
+ static void show(void* userdata);
+ static void accept();
+ static void cancel();
+
+ // data accessors
+ static AuthenticationController* controller();
+
+private:
+ // static because we only need one floater
+ static AuthenticationFloater* sInstance;
+ static AuthenticationController* sController;
+};
+
+
+#endif // PL_AuthenticationFloater_H
diff --git a/linden/indra/newview/authentication_model.cpp b/linden/indra/newview/authentication_model.cpp
new file mode 100644
index 0000000..763ab4a
--- /dev/null
+++ b/linden/indra/newview/authentication_model.cpp
@@ -0,0 +1,111 @@
+/*
+ * authentication_model.cpp
+ * SecondLife
+ *
+ * Created by RMS on 7/17/08.
+ *
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "lldir.h"
+#include "llfile.h"
+#include "llsdserialize.h"
+#include "authentication_model.h"
+
+AuthenticationModel::AuthenticationModel()
+{
+ loadPersistentData();
+}
+
+AuthenticationModel::~AuthenticationModel()
+{
+ savePersistentData();
+}
+
+void AuthenticationModel::loadPersistentData()
+{
+ std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,
+ "cross_grid_authentication.xml");
+ LLSD auth_llsd;
+ llifstream file;
+ file.open(filename);
+ if(file.is_open())
+ LLSDSerialize::fromXML(mAuthLLSD, file);
+}
+
+void AuthenticationModel::savePersistentData()
+{
+ std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,
+ "cross_grid_authentication.xml");
+ llofstream ofile;
+ ofile.open(filename);
+ LLSDSerialize::toPrettyXML(mAuthLLSD, ofile);
+}
+
+void AuthenticationModel::revert()
+{
+ loadPersistentData();
+}
+
+AuthenticationModel::connection_t AuthenticationModel::subscribeToModelUpdates
+ (event_t::slot_function_type subscriber)
+{
+ return mEventUpdate.connect(subscriber);
+}
+
+void AuthenticationModel::unsubscribe(connection_t subscriber)
+{
+ subscriber.disconnect();
+}
+
+/* setters */
+void AuthenticationModel::addAccount(const std::string &grid, const std::string &accountName,
+ const std::string &accountPassword)
+{
+ mAuthLLSD[grid][accountName] = LLSD::LLSD(accountPassword);
+ mEventUpdate();
+}
+
+void AuthenticationModel::removeAccount(const std::string &grid, const std::string &accountName)
+{
+ mAuthLLSD[grid].erase(accountName);
+ mEventUpdate();
+}
+
+void AuthenticationModel::changePassword(const std::string &grid, const std::string &accountName,
+ const std::string &newPassword)
+{
+ mAuthLLSD[grid][accountName] = newPassword;
+ // no event necessary: passwords aren't displayed in any view
+}
+
+/* getters */
+
+void AuthenticationModel::getAllAccountNames(std::list &names)
+{
+ // TODO: implement this for account management
+}
+
+void AuthenticationModel::getAccountNames(const std::string &grid, std::set &names)
+{
+ if(!mAuthLLSD.has(grid))
+ return;
+
+ for(LLSD::map_const_iterator it = mAuthLLSD[grid].beginMap();
+ it != mAuthLLSD[grid].endMap(); ++it)
+ {
+ names.insert(it->first);
+ }
+}
+
+void AuthenticationModel::getPassword(const std::string &grid, const std::string &accountName,
+ std::string &password)
+{
+ password = mAuthLLSD[grid][accountName].asString();
+}
+
+void AuthenticationModel::requestUpdate()
+{
+ mEventUpdate();
+}
diff --git a/linden/indra/newview/authentication_model.h b/linden/indra/newview/authentication_model.h
new file mode 100644
index 0000000..858e936
--- /dev/null
+++ b/linden/indra/newview/authentication_model.h
@@ -0,0 +1,53 @@
+/*
+ * authentication_model.h
+ * SecondLife
+ *
+ * Created by RMS on 7/17/08.
+ *
+ */
+
+#ifndef PL_authentication_model_H
+#define PL_authentication_model_H
+
+#include
+#include
+#include
+#include
+#include
+#include "lluuid.h"
+#include "llmemory.h"
+#include "llsd.h"
+
+class AuthenticationModel : public LLSingleton
+{
+public:
+ typedef boost::signal event_t;
+ typedef boost::signals::connection connection_t;
+
+ AuthenticationModel();
+ virtual ~AuthenticationModel();
+
+ void loadPersistentData();
+ void savePersistentData();
+ void revert();
+
+ /* generic update, pull model: */
+ connection_t subscribeToModelUpdates(event_t::slot_function_type subscriber);
+ void unsubscribe(connection_t subscriber);
+
+ /* setters */
+ void addAccount(const std::string &grid, const std::string &accountName, const std::string &accountPassword);
+ void removeAccount(const std::string &grid, const std::string &accountName);
+ void changePassword(const std::string &grid, const std::string &accountName, const std::string &newPassword);
+
+ /* getters */
+ void getAllAccountNames(std::list &names);
+ void getAccountNames(const std::string &grid, std::set &names);
+ void getPassword(const std::string &grid, const std::string &accountName, std::string &password);
+ void requestUpdate();
+protected:
+ LLSD mAuthLLSD;
+private:
+ event_t mEventUpdate;
+};
+#endif // PL_authentication_model_H
diff --git a/linden/indra/newview/controllerlogin.cpp b/linden/indra/newview/controllerlogin.cpp
new file mode 100644
index 0000000..9dd61a6
--- /dev/null
+++ b/linden/indra/newview/controllerlogin.cpp
@@ -0,0 +1,142 @@
+/*
+ * controllerlogin.cpp
+ * SecondLife
+ *
+ * Created by RMS on 7/16/08.
+ *
+ */
+#include "llerror.h"
+#include "llmd5.h"
+#include
+#include "controllerlogin.h"
+
+LoginController::LoginController(LoginFloater *floater, AuthenticationModel *authModel, const std::string &grid)
+: mFloater(floater), mModel(authModel), mGrid(grid)
+{
+ // set up the user interface subview pointers
+ name_combo = mFloater->getChild("name_combo");
+ password_edit = mFloater->getChild("password_edit");
+ start_location_combo= mFloater->getChild("start_location_combo");
+ remember_check = mFloater->getChild("remember_check");
+ connect_btn = mFloater->getChild("connect_btn");
+ quit_btn = mFloater->getChild("quit_btn");
+ server_combo = mFloater->getChild("server_combo");
+
+ // callbacks
+ // TODO: account creation and version information callbacks
+ name_combo->setCommitCallback(onCommitName);
+ name_combo->setCallbackUserData(this);
+ password_edit->setCommitCallback(onCommitPassword);
+ password_edit->setCallbackUserData(mFloater);
+ connect_btn->setClickedCallback(onAccept, this);
+ quit_btn->setClickedCallback(onCancel, this);
+
+ // subscribe to the model
+ mModelConnection = mModel->subscribeToModelUpdates(boost::bind(&LoginController::update, this));
+ // request an initial update
+ mModel->requestUpdate();
+}
+
+LoginController::~LoginController()
+{
+ mModel->unsubscribe(mModelConnection);
+}
+
+void LoginController::update()
+{
+ // when we want to update, we need to make sure it's relevant to our
+ // interests and make the change as smooth as possible for the user
+ std::set newAccountNames;
+ mModel->getAccountNames(mGrid, newAccountNames);
+
+ if(mAccountNames == newAccountNames)
+ return;
+
+ name_combo->removeall();
+
+ for(std::set::iterator it = newAccountNames.begin();
+ it != newAccountNames.end(); ++it)
+ {
+ name_combo->add(*it);
+ }
+
+ name_combo->sortByName();
+ mAccountNames.swap(newAccountNames);
+}
+
+void LoginController::mungePassword(std::string &password)
+{
+ LLMD5 pass((unsigned char *)password.c_str());
+ char munged_password[MD5HEX_STR_SIZE];
+ pass.hex_digest(munged_password);
+ password = munged_password;
+}
+
+// user interface callbacks
+
+void LoginController::onCommitName(LLUICtrl *control, void *userdata)
+{
+ // look at this shit it fills in the password box if it finds a stored account
+ // and auto checks remember password
+ LoginController *controller = (LoginController *)userdata;
+ LoginFloater *floater = controller->mFloater;
+
+ std::string loginname = floater->childGetText("name_combo");
+ std::set::iterator it = controller->mAccountNames.find(loginname);
+ if(it != controller->mAccountNames.end())
+ {
+ std::string loginpassword;
+
+ controller->mModel->getPassword(controller->mGrid, loginname, loginpassword);
+ LoginFloater::setFields(loginname, loginpassword, true);
+ }
+}
+
+void LoginController::onCommitPassword(LLUICtrl *control, void *userdata)
+{
+ LoginFloater *floater = (LoginFloater *)userdata;
+ LLLineEditor *editor = (LLLineEditor *)control;
+ std::string password = editor->getText();
+
+ // when we have a new password we need to MD5 it and tell the floater
+ if(!floater->isSamePassword(password))
+ {
+ mungePassword(password);
+ floater->setPassword(password);
+ }
+}
+
+void LoginController::onAccept(void* userdata)
+{
+ // this here does the main work of telling the model we need to write
+ // account data
+ LoginController *controller = (LoginController *)userdata;
+ LoginFloater *floater = controller->mFloater;
+
+ if(!floater->childGetValue("remember_check"))
+ {
+ LoginFloater::accept();
+ return;
+ }
+
+ std::string username = floater->childGetText("name_combo");
+ std::string password = floater->getPassword();
+
+ if(controller->mAccountNames.find(username) != controller->mAccountNames.end())
+ {
+ controller->mModel->changePassword(controller->mGrid, username, password);
+ }
+
+ else
+ {
+ controller->mModel->addAccount(controller->mGrid, username, password);
+ }
+ controller->mModel->savePersistentData();
+ LoginFloater::accept();
+}
+
+void LoginController::onCancel(void* userdata)
+{
+ // if the user backs out of the dialog we tell it to clean up and such
+ LoginFloater::cancel_old();
+}
diff --git a/linden/indra/newview/controllerlogin.h b/linden/indra/newview/controllerlogin.h
new file mode 100644
index 0000000..a187558
--- /dev/null
+++ b/linden/indra/newview/controllerlogin.h
@@ -0,0 +1,55 @@
+/*
+ * controllerlogin.h
+ * SecondLife
+ *
+ * Created by RMS on 7/16/08.
+ *
+ */
+#ifndef PL_controllerlogin_H
+#define PL_controllerlogin_H
+
+#include
+#include
+#include "llcombobox.h"
+#include "lllineeditor.h"
+#include "llcheckboxctrl.h"
+#include "llbutton.h"
+#include "floaterlogin.h"
+#include "authentication_model.h"
+
+class LoginController
+{
+public:
+ LoginController(LoginFloater *floater, AuthenticationModel *authModel, const std::string &grid);
+ virtual ~LoginController();
+ virtual void update();
+protected:
+ LoginFloater *mFloater;
+ AuthenticationModel *mModel;
+ std::string mGrid;
+private:
+ AuthenticationModel::connection_t mModelConnection;
+
+ static void mungePassword(std::string &password);
+
+ // UI subview pointers
+ LLComboBox *name_combo;
+ LLLineEditor *password_edit;
+ LLComboBox *start_location_combo;
+ LLCheckBoxCtrl *remember_check;
+ LLButton *connect_btn;
+ LLButton *quit_btn;
+ LLComboBox *server_combo;
+
+ // state
+ std::set mAccountNames;
+
+ // user interface callbacks
+ // TODO: find an alternative to linden callbacks
+ static void onCommitName(LLUICtrl *control, void *userdata);
+ static void onCommitPassword(LLUICtrl *control, void *userdata);
+ static void onAccept(void* userdata);
+ static void onCancel(void* userdata);
+};
+
+#endif // PL_controllerlogin_H
diff --git a/linden/indra/newview/controllerpasswords.cpp b/linden/indra/newview/controllerpasswords.cpp
new file mode 100644
index 0000000..6e39d9a
--- /dev/null
+++ b/linden/indra/newview/controllerpasswords.cpp
@@ -0,0 +1,41 @@
+/*
+ * controllerpasswords.cpp
+ * SecondLife
+ *
+ * Created by RMS on 8/5/08.
+ *
+ */
+
+#include "authentication_model.h"
+#include "prefpanelpasswords.h"
+#include "controllerpasswords.h"
+
+PasswordsController::PasswordsController(PasswordsPrefPanel *panel)
+: mPanel(panel)
+{
+ accounts_list = mPanel->getChild("accounts_list");
+ remove_btn = mPanel->getChild("remove_btn");
+ mModel = AuthenticationModel::getInstance();
+
+ // subscribe to the model
+ mModelConnection = mModel->subscribeToModelUpdates(boost::bind(&PasswordsController::update, this));
+ // request an initial update
+ mModel->requestUpdate();
+}
+
+PasswordsController::~PasswordsController()
+{
+ mModel->unsubscribe(mModelConnection);
+ mModel = NULL;
+}
+
+void PasswordsController::update()
+{
+ std::list newAccountData;
+ mModel->getAllAccountNames(newAccountData);
+
+ if(mAccountData == newAccountData)
+ return;
+
+ accounts_list->deleteAllItems();
+}
diff --git a/linden/indra/newview/controllerpasswords.h b/linden/indra/newview/controllerpasswords.h
new file mode 100644
index 0000000..e656659
--- /dev/null
+++ b/linden/indra/newview/controllerpasswords.h
@@ -0,0 +1,37 @@
+/*
+ * controllerpasswords.h
+ * SecondLife
+ *
+ * Created by RMS on 8/5/08.
+ *
+ */
+
+#include
+#include
+#include "llscrolllistctrl.h"
+#include "llbutton.h"
+#include "authentication_model.h"
+
+#ifndef PL_controllerpasswords_H
+#define PL_controllerpasswords_H
+class PasswordsPrefPanel;
+
+class PasswordsController
+{
+public:
+ PasswordsController(PasswordsPrefPanel *panel);
+ virtual ~PasswordsController();
+ virtual void update();
+protected:
+ LLScrollListCtrl *accounts_list;
+ LLButton *remove_btn;
+private:
+ AuthenticationModel::connection_t mModelConnection;
+
+ PasswordsPrefPanel *mPanel;
+ AuthenticationModel *mModel;
+
+ std::list mAccountData;
+};
+
+#endif // PL_controllerpasswords_H
diff --git a/linden/indra/newview/floaterlogin.cpp b/linden/indra/newview/floaterlogin.cpp
new file mode 100644
index 0000000..b943c4e
--- /dev/null
+++ b/linden/indra/newview/floaterlogin.cpp
@@ -0,0 +1,834 @@
+/*
+ * floaterlogin.cpp
+ * SecondLife
+ *
+ * Created by RMS on 7/15/08.
+ *
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include
+#include "llviewercontrol.h"
+#include "llviewerbuild.h"
+#include "llcombobox.h"
+#include "llscrolllistctrl.h"
+#include "llmd5.h"
+#include "llurlsimstring.h"
+#include "lluictrlfactory.h"
+#include "controllerlogin.h"
+#include "floaterlogin.h"
+#include "hippoGridManager.h"
+#include "llviewernetwork.h"
+#include "llpanellogin.h"
+
+#define PASSWORD_FILLER "123456789!123456"
+
+LoginFloater* LoginFloater::sInstance = NULL;
+LoginController* LoginFloater::sController = NULL;
+AuthenticationModel* LoginFloater::sModel = NULL;
+bool LoginFloater::sIsInitialLogin;
+std::string LoginFloater::sGrid;
+
+LoginFloater::LoginFloater(void (*callback)(S32 option, void* user_data),
+ void *cb_data)
+: LLFloater("floater_login"), mCallback(callback), mCallbackData(cb_data)
+{
+
+ mState = NORMAL;
+ LLUICtrlFactory::getInstance()->buildFloater(this, "floater_login.xml");
+
+
+ llwarns << "LoginFloater called" << llendl;
+
+
+ // configure the floater interface for non-initial login
+ setCanMinimize(!sIsInitialLogin);
+ setCanClose(!sIsInitialLogin);
+ setCanDrag(!sIsInitialLogin);
+ childSetVisible("server_combo", sIsInitialLogin);
+
+ if(!sIsInitialLogin)
+ {
+ LLButton* quit_btn = getChild("quit_btn");
+ quit_btn->setLabel(std::string("Cancel"));
+ setTitle(std::string("Grid Manager"));
+ }
+
+ center();
+ LLLineEditor* edit = getChild("password_edit");
+ if (edit) edit->setDrawAsterixes(TRUE);
+ LLComboBox* combo = getChild("start_location_combo");
+ combo->setAllowTextEntry(TRUE, 128, FALSE);
+
+ BOOL login_last = gSavedSettings.getBOOL("LoginLastLocation");
+ std::string sim_string = LLURLSimString::sInstance.mSimString;
+ if (!sim_string.empty())
+ {
+ // Replace "" with this region name
+ combo->remove(2);
+ combo->add( sim_string );
+ combo->setTextEntry(sim_string);
+ combo->setCurrentByIndex( 2 );
+ }
+ else if (login_last)
+ {
+ combo->setCurrentByIndex( 1 );
+ }
+ else
+ {
+ combo->setCurrentByIndex( 0 );
+ }
+
+ LLTextBox* version_text = getChild("version_text");
+ std::string version = llformat("%d.%d.%d (%d)",
+ LL_VERSION_MAJOR,
+ LL_VERSION_MINOR,
+ LL_VERSION_PATCH,
+ LL_VIEWER_BUILD );
+ version_text->setText(version);
+
+ LLTextBox* channel_text = getChild("channel_text");
+ channel_text->setText(gSavedSettings.getString("VersionChannelName"));
+
+ sendChildToBack(getChildView("channel_text"));
+ sendChildToBack(getChildView("version_text"));
+ sendChildToBack(getChildView("forgot_password_text"));
+
+ setDefaultBtn("connect_btn");
+
+
+
+}
+
+
+LoginFloater::~LoginFloater()
+{
+ delete LoginFloater::sController;
+
+ LoginFloater::sModel = NULL;
+ LoginFloater::sController = NULL;
+ LoginFloater::sInstance = NULL;
+}
+
+void LoginFloater::close()
+{
+ if(sInstance)
+ {
+ delete sInstance;
+ sInstance = NULL;
+ }
+}
+
+BOOL LoginFloater::postBuild()
+{
+ requires("grid_selector");
+ requires("gridnick");
+ requires("platform");
+ requires("gridname");
+ requires("loginuri");
+ requires("loginpage");
+ requires("helperuri");
+ requires("website");
+ requires("first_name");
+ requires("last_name");
+ requires("password");
+ //requires("search");
+ requires("btn_delete");
+ requires("btn_add");
+ requires("btn_copy");
+ requires("set_default");
+ requires("btn_gridinfo");
+ requires("btn_help_render_compat");
+ if (!checkRequirements()) return false;
+ LLLineEditor* password_edit = getChild("password");
+ if (password_edit) password_edit->setDrawAsterixes(TRUE);
+
+ childSetAction("btn_delete", onClickDelete, this);
+ childSetAction("btn_add", onClickAdd, this);
+ childSetAction("btn_copy", onClickCopy, this);
+ childSetAction("btn_apply", onClickApply, this);
+ childSetAction("set_default", onClickDefault, this);
+ childSetAction("btn_cancel", onClickCancel, this);
+//KOW childSetAction("set_default", onClickDefault, this);
+//KOW childSetAction("btn_gridinfo", onClickGridInfo, this);
+//KOW childSetAction("btn_help_render_compat", onClickHelpRenderCompat, this);
+
+ childSetCommitCallback("grid_selector", onSelectGrid, this);
+//KOW childSetCommitCallback("platform", onSelectPlatform, this);
+
+ // !!!### server_choice_combo->setFocusLostCallback(onServerComboLostFocus);
+
+//KOW update();
+ return TRUE;
+}
+
+void LoginFloater::refresh_grids()
+{
+ const std::string &defaultGrid = gHippoGridManager->getDefaultGridNick();
+ LLScrollListCtrl *grids = sInstance->getChild("grid_selector");
+ S32 selectIndex = -1, i = 0;
+ grids->deleteAllItems();
+ if (defaultGrid != "") {
+ LLSD value;
+ value["id"] = defaultGrid;
+ value["columns"][0]["column"] = "grid";
+ value["columns"][0]["value"] = defaultGrid;
+ grids->addElement(value);
+ selectIndex = i++;
+ }
+
+ HippoGridManager::GridIterator it, end = gHippoGridManager->endGrid();
+ for (it = gHippoGridManager->beginGrid(); it != end; ++it) {
+ const std::string &grid = it->second->getGridNick();
+ if (grid != defaultGrid) {
+ LLSD value;
+ value["id"] = grid;
+ value["columns"][0]["column"] = "grid";
+ value["columns"][0]["value"] = grid;
+ grids->addElement(value);
+
+ if (grid == sInstance->mCurGrid) selectIndex = i;
+ i++;
+ }
+ }
+ if ((sInstance->mState == ADD_NEW) || (sInstance->mState == ADD_COPY)) {
+ grids->addElement("");
+ selectIndex = i++;
+ }
+ if (selectIndex >= 0) {
+ //grids->setCurrentByIndex(selectIndex);
+ } else {
+ //grids->setLabel(LLStringExplicit("")); // LLComboBox::removeall() does not clear the label
+ }
+
+ sInstance->childSetTextArg("default_grid", "[DEFAULT]", (defaultGrid != "")? defaultGrid: " ");
+
+ sInstance->childSetEnabled("btn_delete", (selectIndex >= 0));
+ sInstance->childSetEnabled("btn_copy", (sInstance->mState == NORMAL) && (selectIndex >= 0));
+ sInstance->childSetEnabled("set_default", (sInstance->mState == NORMAL) && (selectIndex > 0));
+ sInstance->childSetEnabled("gridnick", (sInstance->mState == ADD_NEW) || (sInstance->mState == ADD_COPY));
+
+
+ LLComboBox *platform = sInstance->getChild("platform");
+ platform->removeall();
+ for (int p=HippoGridInfo::PLATFORM_OTHER; padd(HippoGridInfo::getPlatformString(static_cast(p)));
+
+
+ if (sInstance->mState == NORMAL) {
+ HippoGridInfo *gridInfo = gHippoGridManager->getGrid(sInstance->mCurGrid);
+ if (gridInfo) {
+ sInstance->childSetText("gridnick", gridInfo->getGridNick());
+ platform->setCurrentByIndex(gridInfo->getPlatform());
+ //sInstance->childSetText("grid_name", gridInfo->getGridName());
+ sInstance->childSetText("loginuri", gridInfo->getLoginUri());
+ sInstance->childSetText("loginpage", gridInfo->getLoginPage());
+ sInstance->childSetText("helperuri", gridInfo->getHelperUri());
+ sInstance->childSetText("website", gridInfo->getWebSite());
+ sInstance->childSetText("first_name", gridInfo->getFirstName());
+ sInstance->childSetText("last_name", gridInfo->getLastName());
+ if(gridInfo->getAvatarPassword().length() == 32)
+ sInstance->childSetText("password", std::string(PASSWORD_FILLER));
+ else if(gridInfo->getPasswordUrl().empty())
+ sInstance->childSetText("password", std::string(""));
+/*
+ if (gridInfo->getPlatform() == HippoGridInfo::PLATFORM_SECONDLIFE) {
+ //childSetEnabled("search", false);
+ //childSetText("search", LLStringExplicit(""));
+ childSetEnabled("render_compat", false);
+ childSetValue("render_compat", false);
+ } else {
+ //childSetEnabled("search", true);
+ //childSetText("search", gridInfo->getSearchUrl());
+ childSetEnabled("render_compat", true);
+ childSetValue("render_compat", gridInfo->isRenderCompat());
+ }
+ */
+ } else {
+ std::string empty = "";
+ sInstance->childSetText("gridnick", empty);
+ platform->setCurrentByIndex(HippoGridInfo::PLATFORM_OTHER);
+ sInstance->childSetText("gridname", empty);
+ sInstance->childSetText("loginuri", empty);
+ sInstance->childSetText("loginpage", empty);
+ sInstance->childSetText("helperuri", empty);
+ sInstance->childSetText("website", empty);
+ sInstance->childSetText("first_name", empty);
+ sInstance->childSetText("last_name", empty);
+ sInstance->childSetText("password", empty);
+ sInstance->childSetEnabled("render_compat", true);
+ sInstance->childSetValue("render_compat", true);
+ }
+ } else if (sInstance->mState == ADD_NEW) {
+ llwarns << "ADD_NEW" << llendl;
+ std::string required = "";
+ std::string empty = "";
+ sInstance->childSetText("gridnick", required);
+ platform->setCurrentByIndex(HippoGridInfo::PLATFORM_OTHER);
+ sInstance->childSetText("gridname", empty);
+ sInstance->childSetText("loginuri", required);
+ sInstance->childSetText("loginpage", empty);
+ sInstance->childSetText("helperuri", empty);
+ sInstance->childSetText("website", empty);
+ sInstance->childSetText("first_name", empty);
+ sInstance->childSetText("last_name", empty);
+ sInstance->childSetText("password", empty);
+ //childSetEnabled("search", true);
+ //childSetText("search", empty);
+ sInstance->childSetEnabled("render_compat", true);
+ sInstance->childSetValue("render_compat", true);
+ } else if (sInstance->mState == ADD_COPY) {
+ llwarns << "ADD_COPY" << llendl;
+ sInstance->childSetText("gridnick", LLStringExplicit(""));
+ } else {
+ llwarns << "Illegal state " << sInstance->mState << '.' << llendl;
+ }
+ return;
+}
+
+void LoginFloater::update()
+{
+ mState = NORMAL;
+ mCurGrid = gHippoGridManager->getCurrentGridNick();
+ refresh_grids();
+ //KOW gHippoLimits->setLimits();
+}
+
+void LoginFloater::applyChanges()
+{
+ HippoGridInfo *gridInfo = gHippoGridManager->getGrid(mCurGrid);
+ if (gridInfo)
+ {
+ if (gridInfo->getGridNick() == childGetValue("gridnick").asString())
+ {
+ gridInfo->setPlatform(childGetValue("platform"));
+ gridInfo->setGridName(childGetValue("gridname"));
+ gridInfo->setLoginUri(childGetValue("loginuri"));
+ gridInfo->setLoginPage(childGetValue("loginpage"));
+ gridInfo->setHelperUri(childGetValue("helperuri"));
+ gridInfo->setWebSite(childGetValue("website"));
+ gridInfo->setFirstName(childGetValue("first_name"));
+ gridInfo->setLastName(childGetValue("last_name"));
+ //gridInfo->setSearchUrl(childGetValue("search"));
+ gridInfo->setRenderCompat(childGetValue("render_compat"));
+
+ if(childGetValue("password").asString().empty())
+ gridInfo->setPasswordUrl(std::string(""));
+ else if(childGetValue("password").asString() != std::string(PASSWORD_FILLER))
+ {
+ // store account authentication data
+ std::string auth_password = childGetValue("password");
+ std::string hashed_password;
+ hashPassword(auth_password, hashed_password);
+ gridInfo->setAvatarPassword(hashed_password);
+ }
+ LLPanelLogin::setFields(gridInfo->getFirstName(), gridInfo->getLastName(),
+ gridInfo->getAvatarPassword(), true);
+ }
+ else
+ {
+ llwarns << "Grid nickname mismatch, ignoring changes." << llendl;
+ }
+ }
+}
+
+
+bool LoginFloater::createNewGrid()
+{
+ // check nickname
+ std::string gridnick = childGetValue("gridnick");
+ if (gridnick == "") gridnick = "";
+ HippoGridInfo::cleanUpGridNick(gridnick);
+ childSetValue("gridnick", (gridnick != "")? gridnick: "");
+ if (gridnick == "") {
+ //KOW gViewerWindow->alertXml("GridsNoNick");
+ return false;
+ }
+ if (gHippoGridManager->getGrid(gridnick)) {
+ LLStringUtil::format_map_t args;
+ args["[NAME]"] = gridnick;
+ //KOW gViewerWindow->alertXml("GridExists", args);
+ return false;
+ }
+
+ // check login URI
+ std::string loginuri = childGetValue("loginuri");
+ if ((loginuri == "") || (loginuri == "")) {
+ LLStringUtil::format_map_t args;
+ args["[NAME]"] = gridnick;
+ //KOW gViewerWindow->alertXml("GridsNoLoginUri", args);
+ return false;
+ }
+
+ // create new grid
+ HippoGridInfo *grid = new HippoGridInfo(gridnick);
+ grid->setPlatform(childGetValue("platform"));
+ grid->setGridName(childGetValue("gridname"));
+ grid->setLoginUri(loginuri);
+ grid->setLoginPage(childGetValue("loginpage"));
+ grid->setHelperUri(childGetValue("helperuri"));
+ grid->setWebSite(childGetValue("website"));
+ grid->setFirstName(childGetValue("first_name"));
+ grid->setLastName(childGetValue("last_name"));
+ //grid->setSearchUrl(childGetValue("search"));
+ grid->setRenderCompat(childGetValue("render_compat"));
+ gHippoGridManager->addGrid(grid);
+
+ if(childGetValue("password").asString().empty())
+ grid->setAvatarPassword(std::string(""));
+ else
+ {
+ std::string hashed_password;
+ hashPassword(childGetValue("password"), hashed_password);
+ grid->setAvatarPassword(hashed_password);
+ }
+
+ mCurGrid = gridnick;
+ return true;
+}
+
+void LoginFloater::apply()
+{
+ if (mState == NORMAL) {
+ applyChanges();
+ } else if ((mState == ADD_NEW) || (mState == ADD_COPY)) {
+ if (!createNewGrid()) return;
+ } else {
+ llwarns << "Illegal state " << mState << '.' << llendl;
+ return;
+ }
+ //gHippoGridManager->setCurrentGrid(mCurGrid);
+ //gHippoGridManager->setDefaultGrid(mCurGrid);
+ //LLPanelLogin::refreshLoginPage();
+ gHippoGridManager->saveFile();
+ LLPanelLogin::addServer(LLViewerLogin::getInstance()->getGridLabel());
+}
+
+void LoginFloater::setDefault()
+{
+ if (mState == NORMAL) {
+ applyChanges();
+ } else if ((mState == ADD_NEW) || (mState == ADD_COPY)) {
+ if (!createNewGrid()) return;
+ } else {
+ llwarns << "Illegal state " << mState << '.' << llendl;
+ return;
+ }
+ gHippoGridManager->setCurrentGrid(mCurGrid);
+ gHippoGridManager->setDefaultGrid(mCurGrid);
+ llwarns << "I think me grid is " << mCurGrid << llendl;
+ //LLPanelLogin::refreshLoginPage();
+ gHippoGridManager->saveFile();
+ LLPanelLogin::addServer(LLViewerLogin::getInstance()->getGridLabel());
+}
+
+void LoginFloater::cancel()
+{
+ gHippoGridManager->discardAndReload();
+ LoginFloater::sModel->revert();
+ update();
+}
+
+void LoginFloater::onSelectGrid(LLUICtrl* ctrl, void *data)
+{
+ LoginFloater* self = (LoginFloater*)data;
+ if (self->mState == NORMAL) {
+ self->applyChanges();
+ } else if ((self->mState == ADD_NEW) || (self->mState == ADD_COPY)) {
+ if (self->createNewGrid()) {
+ self->mState = NORMAL;
+ } else {
+ //LLCtrlListInterface *grids = self->childGetListInterface("search_results");
+ //if (!grids) return;
+
+ //LLSD selected_value = grids->getSelectedValue();
+ //std::string sim_name = selected_value.asString();
+
+ LLComboBox *grids = self->getChild("grid_selector");
+ grids->setCurrentByIndex(grids->getItemCount() - 1);
+ return;
+ }
+ } else {
+ llwarns << "Illegal state " << self->mState << '.' << llendl;
+ return;
+ }
+ self->mCurGrid = ctrl->getValue().asString();
+ llwarns << "I think me grid is " << self->mCurGrid << llendl;
+
+ self->refresh_grids();
+}
+
+//static
+void LoginFloater::onClickDelete(void *data)
+{
+ llwarns << "onclickdelete" << llendl;
+ LoginFloater* self = (LoginFloater*)data;
+ if (self->mState == NORMAL)
+ gHippoGridManager->deleteGrid(self->mCurGrid);
+ self->update();
+}
+
+//static
+void LoginFloater::onClickAdd(void *data)
+{
+ llwarns << "add" << llendl;
+ LoginFloater* self = (LoginFloater*)data;
+ self->mState = ADD_NEW;
+ self->refresh_grids();
+}
+
+
+//static
+void LoginFloater::onClickCopy(void *data)
+{
+ llwarns << "copy" << llendl;
+ LoginFloater* self = (LoginFloater*)data;
+ self->mState = ADD_COPY;
+ self->refresh_grids();
+}
+
+//static
+void LoginFloater::onClickApply(void *data)
+{
+ sInstance->apply();
+}
+
+//static
+void LoginFloater::onClickDefault(void *data)
+{
+ sInstance->setDefault();
+}
+
+//static
+void LoginFloater::onClickCancel(void *data)
+{
+ sInstance->cancel();
+}
+
+void LoginFloater::setAlwaysRefresh(bool refresh)
+{
+ // wargames 2: dead code, LLPanelLogin compatibility
+ return;
+}
+
+void LoginFloater::refreshLocation( bool force_visible )
+{
+
+ llwarns << "refreshLocation called" << llendl;
+
+ if (!sInstance) return;
+
+ LLComboBox* combo = sInstance->getChild("start_location_combo");
+
+ if (LLURLSimString::parse())
+ {
+ combo->setCurrentByIndex( 3 ); // BUG? Maybe 2?
+ combo->setTextEntry(LLURLSimString::sInstance.mSimString);
+ }
+ else
+ {
+ BOOL login_last = gSavedSettings.getBOOL("LoginLastLocation");
+ combo->setCurrentByIndex( login_last ? 1 : 0 );
+ }
+
+ BOOL show_start = TRUE;
+
+ if ( ! force_visible )
+ show_start = gSavedSettings.getBOOL("ShowStartLocation");
+
+ sInstance->childSetVisible("start_location_combo", show_start);
+ sInstance->childSetVisible("start_location_text", show_start);
+ sInstance->childSetVisible("server_combo", TRUE);
+}
+
+void LoginFloater::newShow(const std::string &grid, bool initialLogin,
+ void (*callback)(S32 option, void* user_data),
+ void* callback_data)
+{
+
+ llwarns << "newShow called" << llendl;
+ if(NULL==sInstance)
+ {
+ LoginFloater::sGrid = grid;
+ LoginFloater::sIsInitialLogin = initialLogin;
+ sInstance = new LoginFloater(callback, callback_data);
+
+ llwarns << "sInstance assigned. sInstance=" << sInstance << llendl;
+ }
+
+ // floater controller requires initialized floater and model
+ if(NULL==sModel)
+ sModel = AuthenticationModel::getInstance();
+ if(NULL==sController)
+ //sController = new LoginController(sInstance, sModel, sGrid);
+
+
+
+ llwarns << "newshow called" << llendl;
+ sInstance->mCurGrid = gHippoGridManager->getCurrentGridNick();
+ refresh_grids();
+
+ // we're important
+ sInstance->setFrontmost(TRUE);
+ sInstance->setFocus(TRUE);
+
+}
+
+void LoginFloater::testShow(void *lies)
+{
+ // this is if we want to call LoginFloater from a menu option
+ // or you know whatever
+ newShow(std::string("Test"), false, testCallback, NULL);
+}
+
+void LoginFloater::testCallback(S32 option, void *user_data)
+{
+ // test callback, referenced by testShow()
+ if(LOGIN_OPTION_CONNECT == option)
+ {
+ llinfos << "this is how we connect to a METAVERSE" << llendl;
+ std::string first, last, password;
+ BOOL remember = TRUE;
+ getFields(first, last, password, remember);
+ llinfos << "first\t\tlast\t\tpassword" << llendl;
+ llinfos << first << "\t\t" << last << "\t\t" << password << llendl;
+ }
+ else if(LOGIN_OPTION_QUIT == option)
+ {
+ llinfos << "my login, she die" << llendl;
+ llinfos << ":(" << llendl;
+ close();
+ }
+}
+
+void LoginFloater::show(const LLRect &rect, BOOL show_server,
+ void (*callback)(S32 option, void* user_data),
+ void* callback_data)
+{
+ // we don't need a grid passed in because this is old-style login
+ std::string grid = "";
+ newShow(grid, TRUE, callback, callback_data);
+}
+
+void LoginFloater::setFocus(BOOL b)
+{
+ if(b != hasFocus())
+ {
+ if(b)
+ {
+ LoginFloater::giveFocus();
+ }
+ else
+ {
+ LLPanel::setFocus(b);
+ }
+ }
+}
+
+void LoginFloater::giveFocus()
+{
+ LLComboBox *combo = NULL;
+
+ if(NULL==sInstance)
+ {
+ llwarns << "giveFocus has no LoginFloater instance. sInstance=" << sInstance << llendl;
+ return;
+ }
+
+ // for our combo box approach, selecting the combo box is almost always
+ // the right thing to do on the floater receiving focus
+ combo = sInstance->getChild("name_combo");
+ combo->setFocus(TRUE);
+}
+
+void LoginFloater::getFields(std::string &firstname, std::string &lastname, std::string &password,
+ BOOL &remember)
+{
+ if (!sInstance)
+ {
+ llwarns << "Attempted getFields with no login view shown" << llendl;
+ return;
+ }
+
+ std::string loginname = sInstance->childGetText("name_combo");
+
+ LLStringUtil::replaceTabsWithSpaces(loginname, 1);
+ LLStringUtil::trim(loginname);
+ std::vector loginVec;
+ boost::split(loginVec, loginname, boost::is_any_of(" "), boost::token_compress_on);
+ if(loginVec.size() == 2)
+ {
+ firstname = loginVec[0];
+ lastname = loginVec[1];
+ }
+
+ password = sInstance->mMungedPassword;
+ remember = sInstance->childGetValue("remember_check");
+}
+
+void LoginFloater::getFields(std::string &loginname, std::string &password, BOOL &remember)
+{
+ std::string first, last, pass;
+ BOOL rem;
+ getFields(first, last, pass, rem);
+ loginname = first + " " + last;
+ password = pass;
+ remember = rem;
+}
+
+void LoginFloater::setFields(const std::string& firstname, const std::string& lastname, const std::string& password,
+ BOOL remember)
+{
+ if (!sInstance)
+ {
+ llwarns << "Attempted setFields with no login view shown" << llendl;
+ return;
+ }
+
+ std::string loginname = firstname + " " + lastname;
+ sInstance->childSetText("name_combo", loginname);
+
+ // Max "actual" password length is 16 characters.
+ // Hex digests are always 32 characters.
+ if (password.length() == 32)
+ {
+ // This is a MD5 hex digest of a password.
+ // We don't actually use the password input field,
+ // fill it with MAX_PASSWORD characters so we get a
+ // nice row of asterixes.
+ const std::string filler("123456789!123456");
+ sInstance->childSetText("password_edit", filler);
+ sInstance->mIncomingPassword = filler;
+ sInstance->mMungedPassword = password;
+ }
+ else
+ {
+ // this is a normal text password
+ sInstance->childSetText("password_edit", password);
+ sInstance->mIncomingPassword = password;
+ LLMD5 pass((unsigned char *)password.c_str());
+ char munged_password[MD5HEX_STR_SIZE];
+ pass.hex_digest(munged_password);
+ sInstance->mMungedPassword = munged_password;
+ }
+
+ sInstance->childSetValue("remember_check", remember);
+}
+
+void LoginFloater::setFields(const std::string &loginname, const std::string &password, BOOL remember)
+{
+ std::vector loginVec;
+ boost::split(loginVec, loginname, boost::is_any_of(" "), boost::token_compress_on);
+ setFields(loginVec[0], loginVec[1], password, remember);
+}
+
+BOOL LoginFloater::isGridComboDirty()
+{
+ BOOL user_picked = FALSE;
+ if (!sInstance)
+ {
+ llwarns << "Attempted getServer with no login view shown" << llendl;
+ }
+ else
+ {
+ LLComboBox* combo = sInstance->getChild("server_combo");
+ user_picked = combo->isDirty();
+ }
+ return user_picked;
+}
+
+void LoginFloater::getLocation(std::string &location)
+{
+ if (!sInstance)
+ {
+ llwarns << "Attempted getLocation with no login view shown" << llendl;
+ return;
+ }
+
+ LLComboBox* combo = sInstance->getChild("start_location_combo");
+ location = combo->getValue().asString();
+}
+
+std::string& LoginFloater::getPassword()
+{
+ return mMungedPassword;
+}
+
+void LoginFloater::setPassword(std::string &password)
+{
+ mMungedPassword = password;
+}
+
+bool LoginFloater::isSamePassword(std::string &password)
+{
+ return mMungedPassword == password;
+}
+
+void LoginFloater::addServer(const std::string& server, S32 domain_name)
+{
+ if (!sInstance)
+ {
+ llwarns << "Attempted addServer with no login view shown" << llendl;
+ return;
+ }
+
+ LLComboBox* combo = sInstance->getChild("server_combo");
+ combo->add(server, LLSD(domain_name) );
+ combo->setCurrentByIndex(0);
+}
+
+void LoginFloater::accept()
+{
+ if(NULL==sInstance || NULL==sInstance->mCallback)
+ return;
+
+ sInstance->setFocus(FALSE);
+
+ std::string name_combo = sInstance->childGetText("name_combo");
+ if(!name_combo.empty())
+ {
+ sInstance->mCallback(LOGIN_OPTION_CONNECT, sInstance->mCallbackData);
+ }
+ else
+ {
+ // TODO: new account call goes here
+ return;
+ }
+}
+
+void LoginFloater::cancel_old()
+{
+ if(NULL==sInstance)
+ return;
+
+ if(sInstance->sIsInitialLogin)
+ {
+ // send a callback that indicates we're quitting or closing
+ if(sInstance->mCallback)
+ sInstance->mCallback(LOGIN_OPTION_QUIT, sInstance->mCallbackData);
+ return;
+ }
+
+ sInstance->close();
+}
+
+void LoginFloater::hashPassword(const std::string& password, std::string& hashedPassword)
+{
+ // Max "actual" password length is 16 characters.
+ // Hex digests are always 32 characters.
+ if (password.length() == 32)
+ {
+ hashedPassword = password;
+ }
+ else
+ {
+ // this is a normal text password
+ LLMD5 pass((unsigned char *)password.c_str());
+ char munged_password[MD5HEX_STR_SIZE];
+ pass.hex_digest(munged_password);
+ hashedPassword = munged_password;
+ }
+
+}
+
diff --git a/linden/indra/newview/floaterlogin.h b/linden/indra/newview/floaterlogin.h
new file mode 100644
index 0000000..1800897
--- /dev/null
+++ b/linden/indra/newview/floaterlogin.h
@@ -0,0 +1,98 @@
+/*
+ * floaterlogin.h
+ * SecondLife
+ *
+ * Created by RMS on 7/15/08.
+ *
+ */
+#ifndef PL_floaterlogin_H
+#define PL_floaterlogin_H
+
+#define LOGIN_OPTION_CONNECT 0
+#define LOGIN_OPTION_QUIT 1
+
+#include "llfloater.h"
+
+class LoginController;
+class AuthenticationModel;
+
+class LoginFloater : public LLFloater
+{
+public:
+ LoginFloater(void (*callback)(S32 option, void *user_data),
+ void *callback_data);
+ virtual ~LoginFloater();
+
+ virtual BOOL postBuild();
+
+ static void refresh_grids();
+ void apply();
+ void setDefault();
+ void cancel();
+
+ // new-style login methods
+ static void newShow(const std::string &grid, bool initialLogin,
+ void (*callback)(S32 option, void *user_data),
+ void *callback_data);
+ static void testShow(void *lies);
+ static void testCallback(S32 option, void *user_data);
+ virtual std::string& getPassword();
+ virtual void setPassword(std::string &password);
+ virtual bool isSamePassword(std::string &password);
+ static void getFields(std::string &loginname, std::string &password,
+ BOOL &remember);
+ static void setFields(const std::string &loginname, const std::string &password,
+ BOOL remember);
+
+ // LLLoginPanel compatibility
+ //TODO: Make this not suck
+ static void show(const LLRect &rect, BOOL show_server,
+ void (*callback)(S32 option, void *user_data),
+ void *callback_data);
+ static void close();
+ static void setAlwaysRefresh(bool refresh);
+ static void refreshLocation(bool force_visible);
+ virtual void setFocus(BOOL b);
+ static void giveFocus();
+ static void getFields(std::string& firstname, std::string& lastname,
+ std::string& password, BOOL& remember);
+ static void setFields(const std::string& firstname, const std::string &lastname,
+ const std::string& password, BOOL remember);
+ static void getLocation(std::string &location);
+ static BOOL isGridComboDirty();
+ static void addServer(const std::string& server, S32 domain_name);
+ static void accept();
+ static void cancel_old();
+ static void hashPassword(const std::string& password, std::string& hashedPassword);
+protected:
+ static bool sIsInitialLogin;
+ static std::string sGrid;
+private:
+ enum State { NORMAL, ADD_NEW, ADD_COPY };
+ State mState;
+ std::string mCurGrid;
+
+ std::string mIncomingPassword;
+ std::string mMungedPassword;
+
+ void applyChanges();
+ bool createNewGrid();
+ void update();
+
+ static void onSelectGrid(LLUICtrl *ctrl, void *data);
+ static void onClickDelete(void *data);
+ static void onClickAdd(void *data);
+ static void onClickCopy(void *data);
+ static void onClickApply(void *data);
+ static void onClickDefault(void *data);
+ static void onClickCancel(void *data);
+
+ static LoginFloater *sInstance;
+ static LoginController *sController;
+ static AuthenticationModel *sModel;
+
+ void (*mCallback)(S32 option, void *userdata);
+ void *mCallbackData;
+};
+
+#endif // PL_floaterlogin_H
diff --git a/linden/indra/newview/hippoGridManager.cpp b/linden/indra/newview/hippoGridManager.cpp
new file mode 100644
index 0000000..8415adb
--- /dev/null
+++ b/linden/indra/newview/hippoGridManager.cpp
@@ -0,0 +1,597 @@
+
+
+#include "hippoGridManager.h"
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include "llviewercontrol.h"
+#include "llweb.h"
+
+#include "hippoRestRequest.h"
+
+
+// ********************************************************************
+// Global Variables
+
+HippoGridManager *gHippoGridManager = 0;
+
+HippoGridInfo HippoGridInfo::FALLBACK_GRIDINFO("");
+
+
+
+// ********************************************************************
+// ********************************************************************
+// HippoGridInfo
+// ********************************************************************
+// ********************************************************************
+
+
+// ********************************************************************
+// Initialize
+
+HippoGridInfo::HippoGridInfo(const std::string &gridNick) :
+ mPlatform(PLATFORM_OTHER),
+ mGridNick(gridNick),
+ mRenderCompat(true),
+ mCurrencySymbol("OS$"),
+ mRealCurrencySymbol("US$"),
+ mDirectoryFee(30)
+{
+ cleanUpGridNick(mGridNick);
+}
+
+
+void HippoGridInfo::setPlatform(Platform platform)
+{
+ mPlatform = platform;
+ mCurrencySymbol = (mPlatform == PLATFORM_SECONDLIFE)? "L$": "OS$";
+}
+
+
+void HippoGridInfo::setPlatform(const std::string &platform)
+{
+ std::string tmp = platform;
+ for (unsigned i=0; imXmlState = XML_GRIDNICK;
+ else if (strcasecmp(name, "gridname") == 0)
+ self->mXmlState = XML_GRIDNAME;
+ else if (strcasecmp(name, "platform") == 0)
+ self->mXmlState = XML_PLATFORM;
+ else if ((strcasecmp(name, "login") == 0) || (strcasecmp(name, "loginuri") == 0))
+ self->mXmlState = XML_LOGINURI;
+ else if ((strcasecmp(name, "welcome") == 0) || (strcasecmp(name, "loginpage") == 0))
+ self->mXmlState = XML_LOGINPAGE;
+ else if ((strcasecmp(name, "economy") == 0) || (strcasecmp(name, "helperuri") == 0))
+ self->mXmlState = XML_HELPERURI;
+ else if ((strcasecmp(name, "about") == 0) || (strcasecmp(name, "website") == 0))
+ self->mXmlState = XML_WEBSITE;
+ else if ((strcasecmp(name, "help") == 0) || (strcasecmp(name, "support") == 0))
+ self->mXmlState = XML_SUPPORT;
+ else if ((strcasecmp(name, "register") == 0) || (strcasecmp(name, "account") == 0))
+ self->mXmlState = XML_REGISTER;
+ else if (strcasecmp(name, "password") == 0)
+ self->mXmlState = XML_PASSWORD;
+ //else if (strcasecmp(name, "search") == 0)
+ //self->mXmlState = XML_SEARCH;
+}
+
+//static
+void HippoGridInfo::onXmlElementEnd(void *userData, const XML_Char *name)
+{
+ HippoGridInfo *self = (HippoGridInfo*)userData;
+ self->mXmlState = XML_VOID;
+}
+
+//static
+void HippoGridInfo::onXmlCharacterData(void *userData, const XML_Char *s, int len)
+{
+ HippoGridInfo *self = (HippoGridInfo*)userData;
+ switch (self->mXmlState) {
+
+ case XML_GRIDNICK:
+ if (self->mGridNick == "") self->mGridNick.assign(s, len);
+ cleanUpGridNick(self->mGridNick);
+ break;
+
+ case XML_PLATFORM: {
+ std::string platform(s, len);
+ self->setPlatform(platform);
+ break;
+ }
+
+ case XML_LOGINURI:
+ self->mLoginUri.assign(s, len);
+ cleanUpUri(self->mLoginUri);
+ break;
+
+ case XML_HELPERURI:
+ self->mHelperUri.assign(s, len);
+ cleanUpUri(self->mHelperUri);
+ break;
+
+ case XML_SEARCH:
+ //self->mSearchUrl.assign(s, len);
+ //cleanUpQueryUrl(mSearchUrl);
+ break;
+
+ case XML_GRIDNAME: self->mGridName.assign(s, len); break;
+ case XML_LOGINPAGE: self->mLoginPage.assign(s, len); break;
+ case XML_WEBSITE: self->mWebSite.assign(s, len); break;
+ case XML_SUPPORT: self->mSupportUrl.assign(s, len); break;
+ case XML_REGISTER: self->mRegisterUrl.assign(s, len); break;
+ case XML_PASSWORD: self->mPasswordUrl.assign(s, len); break;
+
+ case XML_VOID: break;
+ }
+}
+
+
+bool HippoGridInfo::retrieveGridInfo()
+{
+ if (mLoginUri == "") return false;
+
+ std::string reply;
+ int result = HippoRestRequest::getBlocking(mLoginUri + "get_grid_info", &reply);
+ if (result != 200) return false;
+
+ llinfos << "Received: " << reply << llendl;
+
+ bool success = true;
+ XML_Parser parser = XML_ParserCreate(0);
+ XML_SetUserData(parser, this);
+ XML_SetElementHandler(parser, onXmlElementStart, onXmlElementEnd);
+ XML_SetCharacterDataHandler(parser, onXmlCharacterData);
+ mXmlState = XML_VOID;
+ if (!XML_Parse(parser, reply.data(), reply.size(), TRUE)) {
+ llwarns << "XML Parse Error: " << XML_ErrorString(XML_GetErrorCode(parser)) << llendl;
+ success = false;
+ }
+ XML_ParserFree(parser);
+
+ return success;
+}
+
+
+std::string HippoGridInfo::getUploadFee() const
+{
+ std::string fee;
+ formatFee(fee, LLGlobalEconomy::Singleton::getInstance()->getPriceUpload(), true);
+ return fee;
+}
+
+std::string HippoGridInfo::getGroupCreationFee() const
+{
+ std::string fee;
+ formatFee(fee, LLGlobalEconomy::Singleton::getInstance()->getPriceGroupCreate(), false);
+ return fee;
+}
+
+std::string HippoGridInfo::getDirectoryFee() const
+{
+ std::string fee;
+ formatFee(fee, mDirectoryFee, true);
+ if (fee != "free") fee += "/week";
+ return fee;
+}
+
+void HippoGridInfo::formatFee(std::string &fee, int cost, bool showFree) const
+{
+ if (showFree && (cost == 0)) {
+ fee = "free";
+ } else {
+ fee = llformat("%s%d", getCurrencySymbol().c_str(), cost);
+ }
+}
+
+
+// ********************************************************************
+// Static Helpers
+
+// static
+const char *HippoGridInfo::getPlatformString(Platform platform)
+{
+ static const char *platformStrings[PLATFORM_LAST] = {
+ "Other", "OpenSim", "SecondLife"
+ };
+
+ if ((platform < PLATFORM_OTHER) || (platform >= PLATFORM_LAST))
+ platform = PLATFORM_OTHER;
+ return platformStrings[platform];
+}
+
+
+// static
+void HippoGridInfo::cleanUpGridNick(std::string &gridnick)
+{
+ std::string tmp;
+ int size = gridnick.size();
+ for (int i=0; i::iterator it, end = mGridInfo.end();
+ for (it=mGridInfo.begin(); it != end; ++it) {
+ delete it->second;
+ }
+ mGridInfo.clear();
+}
+
+
+void HippoGridManager::init()
+{
+ HippoGridInfo::initFallback();
+ loadFromFile();
+
+ // !!!### gSavedSettings.getControl("CmdLineLoginURI");
+ // !!!### gSavedSettings.getString("CmdLineLoginPage");
+ // !!!### gSavedSettings.getString("CmdLineHelperURI");
+ // !!!### LLString::compareInsensitive(gGridInfo[grid_index].mLabel, grid_name.c_str()))
+}
+
+
+void HippoGridManager::discardAndReload()
+{
+ cleanup();
+ loadFromFile();
+}
+
+
+// ********************************************************************
+// Public Access
+
+HippoGridInfo *HippoGridManager::getGrid(const std::string &grid) const
+{
+ std::map::const_iterator it;
+ it = mGridInfo.find(grid);
+ if (it != mGridInfo.end()) {
+ return it->second;
+ } else {
+ return 0;
+ }
+}
+
+
+HippoGridInfo *HippoGridManager::getCurrentGrid() const
+{
+ HippoGridInfo *grid = getGrid(mCurrentGrid);
+ if (grid) {
+ return grid;
+ } else {
+ return &HippoGridInfo::FALLBACK_GRIDINFO;
+ }
+}
+
+
+void HippoGridManager::addGrid(HippoGridInfo *grid)
+{
+ if (!grid) return;
+ const std::string &nick = grid->getGridNick();
+ if (nick == "") {
+ llwarns << "Ignoring to try adding grid with empty nick." << llendl;
+ delete grid;
+ return;
+ }
+ if (mGridInfo.find(nick) != mGridInfo.end()) {
+ llwarns << "Ignoring to try adding existing grid " << nick << '.' << llendl;
+ delete grid;
+ return;
+ }
+ mGridInfo[nick] = grid;
+}
+
+
+void HippoGridManager::deleteGrid(const std::string &grid)
+{
+ GridIterator it = mGridInfo.find(grid);
+ if (it == mGridInfo.end()) {
+ llwarns << "Trying to delete non-existing grid " << grid << '.' << llendl;
+ return;
+ }
+ mGridInfo.erase(it);
+ llinfos << "Number of grids now: " << mGridInfo.size() << llendl;
+ if (mGridInfo.empty()) llinfos << "Grid info map is empty." << llendl;
+ if (grid == mDefaultGrid)
+ setDefaultGrid(""); // sets first grid, if map not empty
+ if (grid == mCurrentGrid)
+ mCurrentGrid = mDefaultGrid;
+}
+
+
+void HippoGridManager::setDefaultGrid(const std::string &grid)
+{
+ GridIterator it = mGridInfo.find(grid);
+ if (it != mGridInfo.end()) {
+ mDefaultGrid = grid;
+ } else if (mGridInfo.find("secondlife") != mGridInfo.end()) {
+ mDefaultGrid = "secondlife";
+ } else if (!mGridInfo.empty()) {
+ mDefaultGrid = mGridInfo.begin()->first;
+ } else {
+ mDefaultGrid = "";
+ }
+}
+
+
+void HippoGridManager::setCurrentGrid(const std::string &grid)
+{
+ GridIterator it = mGridInfo.find(grid);
+ if (it != mGridInfo.end()) {
+ mCurrentGrid = grid;
+ } else if (!mGridInfo.empty()) {
+ llwarns << "Unknown grid '" << grid << "'. Setting to default grid." << llendl;
+ mCurrentGrid = mDefaultGrid;
+ }
+}
+
+
+// ********************************************************************
+// Persistent Store
+
+void HippoGridManager::loadFromFile()
+{
+ mDefaultGridsVersion = 0;
+ // load user grid info
+ parseFile(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "grid_info.xml"), false);
+ // merge default grid info, if newer. Force load, if list of grids is empty.
+ parseFile(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "default_grids.xml"), !mGridInfo.empty());
+ // merge grid info from web site, if newer. Force load, if list of grids is empty.
+ if (gSavedSettings.getBOOL("CheckForGridUpdates"))
+ parseUrl("http://opensim-viewer.sourceforge.net/db/grids.php", !mGridInfo.empty());
+
+ setDefaultGrid(gSavedSettings.getString("DefaultGrid"));
+ setCurrentGrid(gSavedSettings.getString("CmdLineGridChoice"));
+}
+
+
+void HippoGridManager::parseUrl(const char *url, bool mergeIfNewer)
+{
+ llinfos << "Loading grid info from '" << url << "'." << llendl;
+
+ // query update server
+ std::string escaped_url = LLWeb::escapeURL(url);
+ LLSD response = LLHTTPClient::blockingGet(url);
+
+ // check response, return on error
+ S32 status = response["status"].asInteger();
+ if ((status != 200) || !response["body"].isArray()) {
+ llinfos << "GridInfo Update failed (" << status << "): "
+ << (response["body"].isString()? response["body"].asString(): "")
+ << llendl;
+ return;
+ }
+
+ LLSD gridInfo = response["body"];
+ parseData(gridInfo, mergeIfNewer);
+}
+
+void HippoGridManager::parseFile(const std::string &fileName, bool mergeIfNewer)
+{
+ llifstream infile;
+ infile.open(fileName.c_str());
+ if(!infile.is_open()) {
+ llwarns << "Cannot find grid info file " << fileName << " to load." << llendl;
+ return;
+ }
+
+ LLSD gridInfo;
+ if (LLSDSerialize::fromXML(gridInfo, infile) <= 0) {
+ llwarns << "Unable to parse grid info file " << fileName << '.' << llendl;
+ return;
+ }
+
+ llinfos << "Loading grid info file " << fileName << '.' << llendl;
+ parseData(gridInfo, mergeIfNewer);
+}
+
+
+void HippoGridManager::parseData(LLSD &gridInfo, bool mergeIfNewer)
+{
+ if (mergeIfNewer) {
+ LLSD::array_const_iterator it, end = gridInfo.endArray();
+ for (it = gridInfo.beginArray(); it != end; ++it) {
+ LLSD gridMap = *it;
+ if (gridMap.has("default_grids_version")) {
+ int version = gridMap["default_grids_version"];
+ if (version <= mDefaultGridsVersion) return;
+ else break;
+ }
+ }
+ if (it == end) {
+ llwarns << "Grid data has no version number." << llendl;
+ return;
+ }
+ }
+
+ llinfos << "Loading grid data." << llendl;
+
+ LLSD::array_const_iterator it, end = gridInfo.endArray();
+ for (it = gridInfo.beginArray(); it != end; ++it) {
+ LLSD gridMap = *it;
+ if (gridMap.has("default_grids_version")) {
+ mDefaultGridsVersion = gridMap["default_grids_version"];
+ } else if (gridMap.has("gridnick") && gridMap.has("loginuri")) {
+ std::string gridnick = gridMap["gridnick"];
+ HippoGridInfo *grid;
+ GridIterator it = mGridInfo.find(gridnick);
+ bool newGrid = (it == mGridInfo.end());
+ if (newGrid) {
+ // create new grid info
+ grid = new HippoGridInfo(gridnick);
+ } else {
+ // update existing grid info
+ grid = it->second;
+ }
+ grid->setLoginUri(gridMap["loginuri"]);
+ if (gridMap.has("platform")) grid->setPlatform(gridMap["platform"]);
+ if (gridMap.has("gridname")) grid->setGridName(gridMap["gridname"]);
+ if (gridMap.has("loginpage")) grid->setLoginPage(gridMap["loginpage"]);
+ if (gridMap.has("helperuri")) grid->setHelperUri(gridMap["helperuri"]);
+ if (gridMap.has("website")) grid->setWebSite(gridMap["website"]);
+ if (gridMap.has("support")) grid->setSupportUrl(gridMap["support"]);
+ if (gridMap.has("register")) grid->setRegisterUrl(gridMap["register"]);
+ if (gridMap.has("password")) grid->setPasswordUrl(gridMap["password"]);
+ //if (gridMap.has("search")) grid->setSearchUrl(gridMap["search"]);
+ if (gridMap.has("render_compat")) grid->setRenderCompat(gridMap["render_compat"]);
+ if (gridMap.has("firstname")) grid->setFirstName(gridMap["firstname"]);
+ if (gridMap.has("lastname")) grid->setLastName(gridMap["lastname"]);
+ if (gridMap.has("avatarpassword")) grid->setAvatarPassword(gridMap["avatarpassword"]);
+ if (newGrid) addGrid(grid);
+ }
+ }
+}
+
+
+void HippoGridManager::saveFile()
+{
+ // save default grid to client settings
+ gSavedSettings.setString("DefaultGrid", mDefaultGrid);
+
+ // build LLSD
+ LLSD gridInfo;
+ gridInfo[0]["default_grids_version"] = mDefaultGridsVersion;
+
+ // add grids
+ S32 i = 1;
+ GridIterator it, end = mGridInfo.end();
+ for (it = mGridInfo.begin(); it != end; ++it, i++) {
+ HippoGridInfo *grid = it->second;
+ gridInfo[i]["gridnick"] = grid->getGridNick();
+ gridInfo[i]["platform"] = HippoGridInfo::getPlatformString(grid->getPlatform());
+ gridInfo[i]["gridname"] = grid->getGridName();
+ gridInfo[i]["loginuri"] = grid->getLoginUri();
+ gridInfo[i]["loginpage"] = grid->getLoginPage();
+ gridInfo[i]["helperuri"] = grid->getHelperUri();
+ gridInfo[i]["website"] = grid->getWebSite();
+ gridInfo[i]["support"] = grid->getSupportUrl();
+ gridInfo[i]["register"] = grid->getRegisterUrl();
+ gridInfo[i]["firstname"] = grid->getFirstName();
+ gridInfo[i]["lastname"] = grid->getLastName();
+ gridInfo[i]["avatarpassword"] = grid->getAvatarPassword();
+
+ //gridInfo[i]["search"] = grid->getSearchUrl();
+ gridInfo[i]["render_compat"] = grid->isRenderCompat();
+ }
+
+ // write client grid info file
+ std::string fileName = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "grid_info.xml");
+ llofstream file;
+ file.open(fileName.c_str());
+ if (file.is_open()) {
+ LLSDSerialize::toPrettyXML(gridInfo, file);
+ file.close();
+ llinfos << "Saved grids to " << fileName << llendl;
+ } else {
+ llerrs << "Unable to open grid info file: " << fileName << llendl;
+ }
+}
diff --git a/linden/indra/newview/hippoGridManager.h b/linden/indra/newview/hippoGridManager.h
new file mode 100644
index 0000000..933a944
--- /dev/null
+++ b/linden/indra/newview/hippoGridManager.h
@@ -0,0 +1,171 @@
+#ifndef __HIPPO_GRID_MANAGER_H__
+#define __HIPPO_GRID_MANAGER_H__
+
+
+#include