teamnwah/openmw-tes3coop
2
0
Fork 1
forked from mirror/openmw-tes3mp
Code Issues Pull requests 1 Releases Wiki Activity

Merge remote-tracking branch 'zini/next' into nifogre

Browse source
This commit is contained in:
Chris Robinson 2013-04-18 15:14:28 -07:00
commit 434f3ac8c8
28 changed files with 8661 additions and 8526 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -15,7 +15,7 @@ include (OpenMWMacros)
# Version
set (OPENMW_VERSION_MAJOR 0)
set (OPENMW_VERSION_MINOR 22)
set (OPENMW_VERSION_MINOR 23)
set (OPENMW_VERSION_RELEASE 0)
set (OPENMW_VERSION "${OPENMW_VERSION_MAJOR}.${OPENMW_VERSION_MINOR}.${OPENMW_VERSION_RELEASE}")

78
apps/openmw/mwgui/birth.cpp
View file

@ -9,22 +9,22 @@
#include "widgets.hpp"
using namespace MWGui;
using namespace Widgets;
namespace
{
bool sortBirthSigns(const std::pair<std::string, const ESM::BirthSign*>& left, const std::pair<std::string, const ESM::BirthSign*>& right)
{
bool sortBirthSigns(const std::pair<std::string, const ESM::BirthSign*>& left, const std::pair<std::string, const ESM::BirthSign*>& right)
{
return left.second->mName.compare (right.second->mName) < 0;
}
}
}
BirthDialog::BirthDialog()
: WindowModal("openmw_chargen_birth.layout")
namespace MWGui
{
BirthDialog::BirthDialog()
: WindowModal("openmw_chargen_birth.layout")
{
// Centre dialog
center();
@ -49,10 +49,10 @@ BirthDialog::BirthDialog()
updateBirths();
updateSpells();
}
}
void BirthDialog::setNextButtonShow(bool shown)
{
void BirthDialog::setNextButtonShow(bool shown)
{
MyGUI::Button* okButton;
getWidget(okButton, "OKButton");
@ -60,18 +60,18 @@ void BirthDialog::setNextButtonShow(bool shown)
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sNext", ""));
else
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sOK", ""));
}
}
void BirthDialog::open()
{
void BirthDialog::open()
{
WindowModal::open();
updateBirths();
updateSpells();
}
}
void BirthDialog::setBirthId(const std::string &birthId)
{
void BirthDialog::setBirthId(const std::string &birthId)
{
mCurrentBirthId = birthId;
mBirthList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = mBirthList->getItemCount();
@ -87,24 +87,24 @@ void BirthDialog::setBirthId(const std::string &birthId)
}
updateSpells();
}
}
// widget controls
// widget controls
void BirthDialog::onOkClicked(MyGUI::Widget* _sender)
{
void BirthDialog::onOkClicked(MyGUI::Widget* _sender)
{
if(mBirthList->getIndexSelected() == MyGUI::ITEM_NONE)
return;
eventDone(this);
}
}
void BirthDialog::onBackClicked(MyGUI::Widget* _sender)
{
void BirthDialog::onBackClicked(MyGUI::Widget* _sender)
{
eventBack();
}
}
void BirthDialog::onSelectBirth(MyGUI::ListBox* _sender, size_t _index)
{
void BirthDialog::onSelectBirth(MyGUI::ListBox* _sender, size_t _index)
{
if (_index == MyGUI::ITEM_NONE)
return;
@ -117,12 +117,12 @@ void BirthDialog::onSelectBirth(MyGUI::ListBox* _sender, size_t _index)
mCurrentBirthId = *birthId;
updateSpells();
}
}
// update widget content
// update widget content
void BirthDialog::updateBirths()
{
void BirthDialog::updateBirths()
{
mBirthList->removeAllItems();
const MWWorld::Store<ESM::BirthSign> &signs =
@ -153,10 +153,10 @@ void BirthDialog::updateBirths()
mBirthList->setIndexSelected(index);
}
}
}
}
void BirthDialog::updateSpells()
{
void BirthDialog::updateSpells()
{
for (std::vector<MyGUI::Widget*>::iterator it = mSpellItems.begin(); it != mSpellItems.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
@ -166,7 +166,7 @@ void BirthDialog::updateSpells()
if (mCurrentBirthId.empty())
return;
MWSpellPtr spellWidget;
Widgets::MWSpellPtr spellWidget;
const int lineHeight = 18;
MyGUI::IntCoord coord(0, 0, mSpellArea->getWidth(), 18);
@ -177,7 +177,7 @@ void BirthDialog::updateSpells()
store.get<ESM::BirthSign>().find(mCurrentBirthId);
std::string texturePath = std::string("textures\\") + birth->mTexture;
fixTexturePath(texturePath);
Widgets::fixTexturePath(texturePath);
mBirthImage->setImageTexture(texturePath);
std::vector<std::string> abilities, powers, spells;
@ -227,7 +227,7 @@ void BirthDialog::updateSpells()
for (std::vector<std::string>::const_iterator it = categories[category].spells.begin(); it != end; ++it)
{
const std::string &spellId = *it;
spellWidget = mSpellArea->createWidget<MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("Spell") + boost::lexical_cast<std::string>(i));
spellWidget = mSpellArea->createWidget<Widgets::MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("Spell") + boost::lexical_cast<std::string>(i));
spellWidget->setSpellId(spellId);
mSpellItems.push_back(spellWidget);
@ -235,11 +235,13 @@ void BirthDialog::updateSpells()
MyGUI::IntCoord spellCoord = coord;
spellCoord.height = 24; // TODO: This should be fetched from the skin somehow, or perhaps a widget in the layout as a template?
spellWidget->createEffectWidgets(mSpellItems, mSpellArea, spellCoord, (category == 0) ? MWEffectList::EF_Constant : 0);
spellWidget->createEffectWidgets(mSpellItems, mSpellArea, spellCoord, (category == 0) ? Widgets::MWEffectList::EF_Constant : 0);
coord.top = spellCoord.top;
++i;
}
}
}
}
}

63
apps/openmw/mwgui/bookwindow.cpp
View file

@ -12,13 +12,14 @@
#include "formatting.hpp"
using namespace MWGui;
namespace MWGui
{
BookWindow::BookWindow ()
BookWindow::BookWindow ()
: WindowBase("openmw_book.layout")
, mTakeButtonShow(true)
, mTakeButtonAllowed(true)
{
{
getWidget(mCloseButton, "CloseButton");
mCloseButton->eventMouseButtonClick += MyGUI::newDelegate(this, &BookWindow::onCloseButtonClicked);
@ -38,20 +39,20 @@ BookWindow::BookWindow ()
getWidget(mRightPage, "RightPage");
center();
}
}
void BookWindow::clearPages()
{
void BookWindow::clearPages()
{
for (std::vector<MyGUI::Widget*>::iterator it=mPages.begin();
it!=mPages.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
mPages.clear();
}
}
void BookWindow::open (MWWorld::Ptr book)
{
void BookWindow::open (MWWorld::Ptr book)
{
mBook = book;
clearPages();
@ -83,40 +84,40 @@ void BookWindow::open (MWWorld::Ptr book)
updatePages();
setTakeButtonShow(true);
}
}
void BookWindow::setTakeButtonShow(bool show)
{
void BookWindow::setTakeButtonShow(bool show)
{
mTakeButtonShow = show;
mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
}
}
void BookWindow::setInventoryAllowed(bool allowed)
{
void BookWindow::setInventoryAllowed(bool allowed)
{
mTakeButtonAllowed = allowed;
mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
}
}
void BookWindow::onCloseButtonClicked (MyGUI::Widget* sender)
{
void BookWindow::onCloseButtonClicked (MyGUI::Widget* sender)
{
// no 3d sounds because the object could be in a container.
MWBase::Environment::get().getSoundManager()->playSound ("book close", 1.0, 1.0);
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Book);
}
}
void BookWindow::onTakeButtonClicked (MyGUI::Widget* sender)
{
void BookWindow::onTakeButtonClicked (MyGUI::Widget* sender)
{
MWBase::Environment::get().getSoundManager()->playSound ("Item Book Up", 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
MWWorld::ActionTake take(mBook);
take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Book);
}
}
void BookWindow::onNextPageButtonClicked (MyGUI::Widget* sender)
{
void BookWindow::onNextPageButtonClicked (MyGUI::Widget* sender)
{
if ((mCurrentPage+1)*2 < mPages.size())
{
MWBase::Environment::get().getSoundManager()->playSound ("book page2", 1.0, 1.0);
@ -125,10 +126,10 @@ void BookWindow::onNextPageButtonClicked (MyGUI::Widget* sender)
updatePages();
}
}
}
void BookWindow::onPrevPageButtonClicked (MyGUI::Widget* sender)
{
void BookWindow::onPrevPageButtonClicked (MyGUI::Widget* sender)
{
if (mCurrentPage > 0)
{
MWBase::Environment::get().getSoundManager()->playSound ("book page", 1.0, 1.0);
@ -137,10 +138,10 @@ void BookWindow::onPrevPageButtonClicked (MyGUI::Widget* sender)
updatePages();
}
}
}
void BookWindow::updatePages()
{
void BookWindow::updatePages()
{
mLeftPageNumber->setCaption( boost::lexical_cast<std::string>(mCurrentPage*2 + 1) );
mRightPageNumber->setCaption( boost::lexical_cast<std::string>(mCurrentPage*2 + 2) );
@ -156,4 +157,6 @@ void BookWindow::updatePages()
}
++i;
}
}
}

165
apps/openmw/mwgui/charactercreation.cpp
View file

@ -43,9 +43,10 @@ namespace
};
}
using namespace MWGui;
namespace MWGui
{
CharacterCreation::CharacterCreation()
CharacterCreation::CharacterCreation()
: mNameDialog(0)
, mRaceDialog(0)
, mClassChoiceDialog(0)
@ -56,12 +57,12 @@ CharacterCreation::CharacterCreation()
, mBirthSignDialog(0)
, mReviewDialog(0)
, mGenerateClassStep(0)
{
{
mCreationStage = CSE_NotStarted;
}
}
void CharacterCreation::setValue (const std::string& id, const MWMechanics::Stat<int>& value)
{
void CharacterCreation::setValue (const std::string& id, const MWMechanics::Stat<int>& value)
{
if (mReviewDialog)
{
static const char *ids[] =
@ -77,10 +78,10 @@ void CharacterCreation::setValue (const std::string& id, const MWMechanics::Stat
mReviewDialog->setAttribute(ESM::Attribute::AttributeID(i), value);
}
}
}
}
void CharacterCreation::setValue (const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
void CharacterCreation::setValue (const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
if (mReviewDialog)
{
if (id == "HBar")
@ -96,22 +97,22 @@ void CharacterCreation::setValue (const std::string& id, const MWMechanics::Dyna
mReviewDialog->setFatigue (value);
}
}
}
}
void CharacterCreation::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechanics::Stat<float>& value)
{
void CharacterCreation::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechanics::Stat<float>& value)
{
if (mReviewDialog)
mReviewDialog->setSkillValue(parSkill, value);
}
}
void CharacterCreation::configureSkills (const SkillList& major, const SkillList& minor)
{
void CharacterCreation::configureSkills (const SkillList& major, const SkillList& minor)
{
if (mReviewDialog)
mReviewDialog->configureSkills(major, minor);
}
}
void CharacterCreation::spawnDialog(const char id)
{
void CharacterCreation::spawnDialog(const char id)
{
switch (id)
{
case GM_Name:
@ -235,41 +236,41 @@ void CharacterCreation::spawnDialog(const char id)
mCreationStage = CSE_BirthSignChosen;
break;
}
}
}
void CharacterCreation::setPlayerHealth (const MWMechanics::DynamicStat<float>& value)
{
void CharacterCreation::setPlayerHealth (const MWMechanics::DynamicStat<float>& value)
{
mPlayerHealth = value;
}
}
void CharacterCreation::setPlayerMagicka (const MWMechanics::DynamicStat<float>& value)
{
void CharacterCreation::setPlayerMagicka (const MWMechanics::DynamicStat<float>& value)
{
mPlayerMagicka = value;
}
}
void CharacterCreation::setPlayerFatigue (const MWMechanics::DynamicStat<float>& value)
{
void CharacterCreation::setPlayerFatigue (const MWMechanics::DynamicStat<float>& value)
{
mPlayerFatigue = value;
}
}
void CharacterCreation::onReviewDialogDone(WindowBase* parWindow)
{
void CharacterCreation::onReviewDialogDone(WindowBase* parWindow)
{
MWBase::Environment::get().getWindowManager()->removeDialog(mReviewDialog);
mReviewDialog = 0;
MWBase::Environment::get().getWindowManager()->popGuiMode();
}
}
void CharacterCreation::onReviewDialogBack()
{
void CharacterCreation::onReviewDialogBack()
{
MWBase::Environment::get().getWindowManager()->removeDialog(mReviewDialog);
mReviewDialog = 0;
MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Birth);
}
}
void CharacterCreation::onReviewActivateDialog(int parDialog)
{
void CharacterCreation::onReviewActivateDialog(int parDialog)
{
MWBase::Environment::get().getWindowManager()->removeDialog(mReviewDialog);
mReviewDialog = 0;
mCreationStage = CSE_ReviewNext;
@ -290,10 +291,10 @@ void CharacterCreation::onReviewActivateDialog(int parDialog)
case ReviewDialog::BIRTHSIGN_DIALOG:
MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Birth);
};
}
}
void CharacterCreation::onPickClassDialogDone(WindowBase* parWindow)
{
void CharacterCreation::onPickClassDialogDone(WindowBase* parWindow)
{
if (mPickClassDialog)
{
const std::string &classId = mPickClassDialog->getClassId();
@ -327,10 +328,10 @@ void CharacterCreation::onPickClassDialogDone(WindowBase* parWindow)
mCreationStage = CSE_ClassChosen;
MWBase::Environment::get().getWindowManager()->popGuiMode();
}
}
}
void CharacterCreation::onPickClassDialogBack()
{
void CharacterCreation::onPickClassDialogBack()
{
if (mPickClassDialog)
{
const std::string classId = mPickClassDialog->getClassId();
@ -342,10 +343,10 @@ void CharacterCreation::onPickClassDialogBack()
MWBase::Environment::get().getWindowManager()->popGuiMode();
MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Class);
}
}
void CharacterCreation::onClassChoice(int _index)
{
void CharacterCreation::onClassChoice(int _index)
{
MWBase::Environment::get().getWindowManager()->removeDialog(mClassChoiceDialog);
mClassChoiceDialog = 0;
@ -367,10 +368,10 @@ void CharacterCreation::onClassChoice(int _index)
break;
};
}
}
void CharacterCreation::onNameDialogDone(WindowBase* parWindow)
{
void CharacterCreation::onNameDialogDone(WindowBase* parWindow)
{
if (mNameDialog)
{
mPlayerName = mNameDialog->getTextInput();
@ -395,10 +396,10 @@ void CharacterCreation::onNameDialogDone(WindowBase* parWindow)
mCreationStage = CSE_NameChosen;
MWBase::Environment::get().getWindowManager()->popGuiMode();
}
}
}
void CharacterCreation::onRaceDialogBack()
{
void CharacterCreation::onRaceDialogBack()
{
if (mRaceDialog)
{
const ESM::NPC &data = mRaceDialog->getResult();
@ -417,10 +418,10 @@ void CharacterCreation::onRaceDialogBack()
MWBase::Environment::get().getWindowManager()->popGuiMode();
MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Name);
}
}
void CharacterCreation::onRaceDialogDone(WindowBase* parWindow)
{
void CharacterCreation::onRaceDialogDone(WindowBase* parWindow)
{
if (mRaceDialog)
{
const ESM::NPC &data = mRaceDialog->getResult();
@ -454,10 +455,10 @@ void CharacterCreation::onRaceDialogDone(WindowBase* parWindow)
mCreationStage = CSE_RaceChosen;
MWBase::Environment::get().getWindowManager()->popGuiMode();
}
}
}
void CharacterCreation::onBirthSignDialogDone(WindowBase* parWindow)
{
void CharacterCreation::onBirthSignDialogDone(WindowBase* parWindow)
{
if (mBirthSignDialog)
{
mPlayerBirthSignId = mBirthSignDialog->getBirthId();
@ -477,10 +478,10 @@ void CharacterCreation::onBirthSignDialogDone(WindowBase* parWindow)
mCreationStage = CSE_BirthSignChosen;
MWBase::Environment::get().getWindowManager()->popGuiMode();
}
}
}
void CharacterCreation::onBirthSignDialogBack()
{
void CharacterCreation::onBirthSignDialogBack()
{
if (mBirthSignDialog)
{
MWBase::Environment::get().getMechanicsManager()->setPlayerBirthsign(mBirthSignDialog->getBirthId());
@ -490,10 +491,10 @@ void CharacterCreation::onBirthSignDialogBack()
MWBase::Environment::get().getWindowManager()->popGuiMode();
MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Class);
}
}
void CharacterCreation::onCreateClassDialogDone(WindowBase* parWindow)
{
void CharacterCreation::onCreateClassDialogDone(WindowBase* parWindow)
{
if (mCreateClassDialog)
{
ESM::Class klass;
@ -540,19 +541,19 @@ void CharacterCreation::onCreateClassDialogDone(WindowBase* parWindow)
mCreationStage = CSE_ClassChosen;
MWBase::Environment::get().getWindowManager()->popGuiMode();
}
}
}
void CharacterCreation::onCreateClassDialogBack()
{
void CharacterCreation::onCreateClassDialogBack()
{
MWBase::Environment::get().getWindowManager()->removeDialog(mCreateClassDialog);
mCreateClassDialog = 0;
MWBase::Environment::get().getWindowManager()->popGuiMode();
MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Class);
}
}
void CharacterCreation::onClassQuestionChosen(int _index)
{
void CharacterCreation::onClassQuestionChosen(int _index)
{
MWBase::Environment::get().getSoundManager()->stopSay();
MWBase::Environment::get().getWindowManager()->removeDialog(mGenerateClassQuestionDialog);
@ -574,10 +575,10 @@ void CharacterCreation::onClassQuestionChosen(int _index)
++mGenerateClassSpecializations[2];
++mGenerateClassStep;
showClassQuestionDialog();
}
}
void CharacterCreation::showClassQuestionDialog()
{
void CharacterCreation::showClassQuestionDialog()
{
if (mGenerateClassStep == 10)
{
static boost::array<ClassPoint, 23> classes = { {
@ -667,10 +668,10 @@ void CharacterCreation::showClassQuestionDialog()
mGenerateClassQuestionDialog->setVisible(true);
MWBase::Environment::get().getSoundManager()->say(sGenerateClassSteps(mGenerateClassStep).mSound);
}
}
void CharacterCreation::onGenerateClassBack()
{
void CharacterCreation::onGenerateClassBack()
{
MWBase::Environment::get().getWindowManager()->removeDialog(mGenerateClassResultDialog);
mGenerateClassResultDialog = 0;
@ -678,10 +679,10 @@ void CharacterCreation::onGenerateClassBack()
MWBase::Environment::get().getWindowManager()->popGuiMode();
MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Class);
}
}
void CharacterCreation::onGenerateClassDone(WindowBase* parWindow)
{
void CharacterCreation::onGenerateClassDone(WindowBase* parWindow)
{
MWBase::Environment::get().getWindowManager()->removeDialog(mGenerateClassResultDialog);
mGenerateClassResultDialog = 0;
@ -708,10 +709,10 @@ void CharacterCreation::onGenerateClassDone(WindowBase* parWindow)
mCreationStage = CSE_ClassChosen;
MWBase::Environment::get().getWindowManager()->popGuiMode();
}
}
}
CharacterCreation::~CharacterCreation()
{
CharacterCreation::~CharacterCreation()
{
delete mNameDialog;
delete mRaceDialog;
delete mClassChoiceDialog;
@ -721,4 +722,6 @@ CharacterCreation::~CharacterCreation()
delete mCreateClassDialog;
delete mBirthSignDialog;
delete mReviewDialog;
}
}

407
apps/openmw/mwgui/class.cpp
View file

@ -11,13 +11,14 @@
#undef min
#undef max
using namespace MWGui;
/* GenerateClassResultDialog */
GenerateClassResultDialog::GenerateClassResultDialog()
: WindowModal("openmw_chargen_generate_class_result.layout")
namespace MWGui
{
/* GenerateClassResultDialog */
GenerateClassResultDialog::GenerateClassResultDialog()
: WindowModal("openmw_chargen_generate_class_result.layout")
{
// Centre dialog
center();
@ -34,37 +35,37 @@ GenerateClassResultDialog::GenerateClassResultDialog()
getWidget(okButton, "OKButton");
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sOK", ""));
okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &GenerateClassResultDialog::onOkClicked);
}
}
std::string GenerateClassResultDialog::getClassId() const
{
std::string GenerateClassResultDialog::getClassId() const
{
return mClassName->getCaption();
}
}
void GenerateClassResultDialog::setClassId(const std::string &classId)
{
void GenerateClassResultDialog::setClassId(const std::string &classId)
{
mCurrentClassId = classId;
mClassImage->setImageTexture(std::string("textures\\levelup\\") + mCurrentClassId + ".dds");
mClassName->setCaption(MWBase::Environment::get().getWorld()->getStore().get<ESM::Class>().find(mCurrentClassId)->mName);
}
}
// widget controls
// widget controls
void GenerateClassResultDialog::onOkClicked(MyGUI::Widget* _sender)
{
void GenerateClassResultDialog::onOkClicked(MyGUI::Widget* _sender)
{
eventDone(this);
}
}
void GenerateClassResultDialog::onBackClicked(MyGUI::Widget* _sender)
{
void GenerateClassResultDialog::onBackClicked(MyGUI::Widget* _sender)
{
eventBack();
}
}
/* PickClassDialog */
/* PickClassDialog */
PickClassDialog::PickClassDialog()
PickClassDialog::PickClassDialog()
: WindowModal("openmw_chargen_class.layout")
{
{
// Centre dialog
center();
@ -98,10 +99,10 @@ PickClassDialog::PickClassDialog()
updateClasses();
updateStats();
}
}
void PickClassDialog::setNextButtonShow(bool shown)
{
void PickClassDialog::setNextButtonShow(bool shown)
{
MyGUI::Button* okButton;
getWidget(okButton, "OKButton");
@ -109,18 +110,18 @@ void PickClassDialog::setNextButtonShow(bool shown)
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sNext", ""));
else
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sOK", ""));
}
}
void PickClassDialog::open()
{
void PickClassDialog::open()
{
WindowModal::open ();
updateClasses();
updateStats();
}
}
void PickClassDialog::setClassId(const std::string &classId)
{
void PickClassDialog::setClassId(const std::string &classId)
{
mCurrentClassId = classId;
mClassList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = mClassList->getItemCount();
@ -136,24 +137,24 @@ void PickClassDialog::setClassId(const std::string &classId)
}
updateStats();
}
}
// widget controls
// widget controls
void PickClassDialog::onOkClicked(MyGUI::Widget* _sender)
{
void PickClassDialog::onOkClicked(MyGUI::Widget* _sender)
{
if(mClassList->getIndexSelected() == MyGUI::ITEM_NONE)
return;
eventDone(this);
}
}
void PickClassDialog::onBackClicked(MyGUI::Widget* _sender)
{
void PickClassDialog::onBackClicked(MyGUI::Widget* _sender)
{
eventBack();
}
}
void PickClassDialog::onSelectClass(MyGUI::ListBox* _sender, size_t _index)
{
void PickClassDialog::onSelectClass(MyGUI::ListBox* _sender, size_t _index)
{
if (_index == MyGUI::ITEM_NONE)
return;
@ -166,12 +167,12 @@ void PickClassDialog::onSelectClass(MyGUI::ListBox* _sender, size_t _index)
mCurrentClassId = *classId;
updateStats();
}
}
// update widget content
// update widget content
void PickClassDialog::updateClasses()
{
void PickClassDialog::updateClasses()
{
mClassList->removeAllItems();
const MWWorld::ESMStore &store = MWBase::Environment::get().getWorld()->getStore();
@ -197,10 +198,10 @@ void PickClassDialog::updateClasses()
}
++index;
}
}
}
void PickClassDialog::updateStats()
{
void PickClassDialog::updateStats()
{
if (mCurrentClassId.empty())
return;
const MWWorld::ESMStore &store = MWBase::Environment::get().getWorld()->getStore();
@ -233,22 +234,22 @@ void PickClassDialog::updateStats()
}
mClassImage->setImageTexture(std::string("textures\\levelup\\") + mCurrentClassId + ".dds");
}
}
/* InfoBoxDialog */
/* InfoBoxDialog */
void InfoBoxDialog::fitToText(MyGUI::TextBox* widget)
{
void InfoBoxDialog::fitToText(MyGUI::TextBox* widget)
{
MyGUI::IntCoord inner = widget->getTextRegion();
MyGUI::IntCoord outer = widget->getCoord();
MyGUI::IntSize size = widget->getTextSize();
size.width += outer.width - inner.width;
size.height += outer.height - inner.height;
widget->setSize(size);
}
}
void InfoBoxDialog::layoutVertically(MyGUI::Widget* widget, int margin)
{
void InfoBoxDialog::layoutVertically(MyGUI::Widget* widget, int margin)
{
size_t count = widget->getChildCount();
int pos = 0;
pos += margin;
@ -265,34 +266,34 @@ void InfoBoxDialog::layoutVertically(MyGUI::Widget* widget, int margin)
}
width += margin*2;
widget->setSize(width, pos);
}
}
InfoBoxDialog::InfoBoxDialog()
InfoBoxDialog::InfoBoxDialog()
: WindowModal("openmw_infobox.layout")
, mCurrentButton(-1)
{
{
getWidget(mTextBox, "TextBox");
getWidget(mText, "Text");
mText->getSubWidgetText()->setWordWrap(true);
getWidget(mButtonBar, "ButtonBar");
center();
}
}
void InfoBoxDialog::setText(const std::string &str)
{
void InfoBoxDialog::setText(const std::string &str)
{
mText->setCaption(str);
mTextBox->setVisible(!str.empty());
fitToText(mText);
}
}
std::string InfoBoxDialog::getText() const
{
std::string InfoBoxDialog::getText() const
{
return mText->getCaption();
}
}
void InfoBoxDialog::setButtons(ButtonList &buttons)
{
void InfoBoxDialog::setButtons(ButtonList &buttons)
{
for (std::vector<MyGUI::Button*>::iterator it = this->mButtons.begin(); it != this->mButtons.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
@ -315,10 +316,10 @@ void InfoBoxDialog::setButtons(ButtonList &buttons)
coord.top += button->getHeight();
this->mButtons.push_back(button);
}
}
}
void InfoBoxDialog::open()
{
void InfoBoxDialog::open()
{
WindowModal::open();
// Fix layout
layoutVertically(mTextBox, 4);
@ -326,15 +327,15 @@ void InfoBoxDialog::open()
layoutVertically(mMainWidget, 4 + 6);
center();
}
}
int InfoBoxDialog::getChosenButton() const
{
int InfoBoxDialog::getChosenButton() const
{
return mCurrentButton;
}
}
void InfoBoxDialog::onButtonClicked(MyGUI::Widget* _sender)
{
void InfoBoxDialog::onButtonClicked(MyGUI::Widget* _sender)
{
std::vector<MyGUI::Button*>::const_iterator end = mButtons.end();
int i = 0;
for (std::vector<MyGUI::Button*>::const_iterator it = mButtons.begin(); it != end; ++it)
@ -347,13 +348,13 @@ void InfoBoxDialog::onButtonClicked(MyGUI::Widget* _sender)
}
++i;
}
}
}
/* ClassChoiceDialog */
/* ClassChoiceDialog */
ClassChoiceDialog::ClassChoiceDialog()
ClassChoiceDialog::ClassChoiceDialog()
: InfoBoxDialog()
{
{
setText("");
ButtonList buttons;
buttons.push_back(MWBase::Environment::get().getWindowManager()->getGameSettingString("sClassChoiceMenu1", ""));
@ -361,17 +362,17 @@ ClassChoiceDialog::ClassChoiceDialog()
buttons.push_back(MWBase::Environment::get().getWindowManager()->getGameSettingString("sClassChoiceMenu3", ""));
buttons.push_back(MWBase::Environment::get().getWindowManager()->getGameSettingString("sBack", ""));
setButtons(buttons);
}
}
/* CreateClassDialog */
/* CreateClassDialog */
CreateClassDialog::CreateClassDialog()
CreateClassDialog::CreateClassDialog()
: WindowModal("openmw_chargen_create_class.layout")
, mSpecDialog(NULL)
, mAttribDialog(NULL)
, mSkillDialog(NULL)
, mDescDialog(NULL)
{
{
// Centre dialog
center();
@ -439,18 +440,18 @@ CreateClassDialog::CreateClassDialog()
setSpecialization(0);
update();
}
}
CreateClassDialog::~CreateClassDialog()
{
CreateClassDialog::~CreateClassDialog()
{
delete mSpecDialog;
delete mAttribDialog;
delete mSkillDialog;
delete mDescDialog;
}
}
void CreateClassDialog::update()
{
void CreateClassDialog::update()
{
for (int i = 0; i < 5; ++i)
{
ToolTips::createSkillToolTip(mMajorSkill[i], mMajorSkill[i]->getSkillId());
@ -459,53 +460,53 @@ void CreateClassDialog::update()
ToolTips::createAttributeToolTip(mFavoriteAttribute0, mFavoriteAttribute0->getAttributeId());
ToolTips::createAttributeToolTip(mFavoriteAttribute1, mFavoriteAttribute1->getAttributeId());
}
}
std::string CreateClassDialog::getName() const
{
std::string CreateClassDialog::getName() const
{
return mEditName->getOnlyText();
}
}
std::string CreateClassDialog::getDescription() const
{
std::string CreateClassDialog::getDescription() const
{
return mDescription;
}
}
ESM::Class::Specialization CreateClassDialog::getSpecializationId() const
{
ESM::Class::Specialization CreateClassDialog::getSpecializationId() const
{
return mSpecializationId;
}
}
std::vector<int> CreateClassDialog::getFavoriteAttributes() const
{
std::vector<int> CreateClassDialog::getFavoriteAttributes() const
{
std::vector<int> v;
v.push_back(mFavoriteAttribute0->getAttributeId());
v.push_back(mFavoriteAttribute1->getAttributeId());
return v;
}
}
std::vector<ESM::Skill::SkillEnum> CreateClassDialog::getMajorSkills() const
{
std::vector<ESM::Skill::SkillEnum> CreateClassDialog::getMajorSkills() const
{
std::vector<ESM::Skill::SkillEnum> v;
for(int i = 0; i < 5; i++)
{
v.push_back(mMajorSkill[i]->getSkillId());
}
return v;
}
}
std::vector<ESM::Skill::SkillEnum> CreateClassDialog::getMinorSkills() const
{
std::vector<ESM::Skill::SkillEnum> CreateClassDialog::getMinorSkills() const
{
std::vector<ESM::Skill::SkillEnum> v;
for(int i=0; i < 5; i++)
{
v.push_back(mMinorSkill[i]->getSkillId());
}
return v;
}
}
void CreateClassDialog::setNextButtonShow(bool shown)
{
void CreateClassDialog::setNextButtonShow(bool shown)
{
MyGUI::Button* okButton;
getWidget(okButton, "OKButton");
@ -513,12 +514,12 @@ void CreateClassDialog::setNextButtonShow(bool shown)
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sNext", ""));
else
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sOK", ""));
}
}
// widget controls
// widget controls
void CreateClassDialog::onDialogCancel()
{
void CreateClassDialog::onDialogCancel()
{
MWBase::Environment::get().getWindowManager()->removeDialog(mSpecDialog);
mSpecDialog = 0;
@ -530,28 +531,28 @@ void CreateClassDialog::onDialogCancel()
MWBase::Environment::get().getWindowManager()->removeDialog(mDescDialog);
mDescDialog = 0;
}
}
void CreateClassDialog::onSpecializationClicked(MyGUI::Widget* _sender)
{
void CreateClassDialog::onSpecializationClicked(MyGUI::Widget* _sender)
{
delete mSpecDialog;
mSpecDialog = new SelectSpecializationDialog();
mSpecDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
mSpecDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationSelected);
mSpecDialog->setVisible(true);
}
}
void CreateClassDialog::onSpecializationSelected()
{
void CreateClassDialog::onSpecializationSelected()
{
mSpecializationId = mSpecDialog->getSpecializationId();
setSpecialization(mSpecializationId);
MWBase::Environment::get().getWindowManager()->removeDialog(mSpecDialog);
mSpecDialog = 0;
}
}
void CreateClassDialog::setSpecialization(int id)
{
void CreateClassDialog::setSpecialization(int id)
{
mSpecializationId = (ESM::Class::Specialization) id;
static const char *specIds[3] = {
"sSpecializationCombat",
@ -561,20 +562,20 @@ void CreateClassDialog::setSpecialization(int id)
std::string specName = MWBase::Environment::get().getWindowManager()->getGameSettingString(specIds[mSpecializationId], specIds[mSpecializationId]);
mSpecializationName->setCaption(specName);
ToolTips::createSpecializationToolTip(mSpecializationName, specName, mSpecializationId);
}
}
void CreateClassDialog::onAttributeClicked(Widgets::MWAttributePtr _sender)
{
void CreateClassDialog::onAttributeClicked(Widgets::MWAttributePtr _sender)
{
delete mAttribDialog;
mAttribDialog = new SelectAttributeDialog();
mAffectedAttribute = _sender;
mAttribDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
mAttribDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeSelected);
mAttribDialog->setVisible(true);
}
}
void CreateClassDialog::onAttributeSelected()
{
void CreateClassDialog::onAttributeSelected()
{
ESM::Attribute::AttributeID id = mAttribDialog->getAttributeId();
if (mAffectedAttribute == mFavoriteAttribute0)
{
@ -591,20 +592,20 @@ void CreateClassDialog::onAttributeSelected()
mAttribDialog = 0;
update();
}
}
void CreateClassDialog::onSkillClicked(Widgets::MWSkillPtr _sender)
{
void CreateClassDialog::onSkillClicked(Widgets::MWSkillPtr _sender)
{
delete mSkillDialog;
mSkillDialog = new SelectSkillDialog();
mAffectedSkill = _sender;
mSkillDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
mSkillDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSkillSelected);
mSkillDialog->setVisible(true);
}
}
void CreateClassDialog::onSkillSelected()
{
void CreateClassDialog::onSkillSelected()
{
ESM::Skill::SkillEnum id = mSkillDialog->getSkillId();
// Avoid duplicate skills by swapping any skill field that matches the selected one
@ -624,40 +625,40 @@ void CreateClassDialog::onSkillSelected()
MWBase::Environment::get().getWindowManager()->removeDialog(mSkillDialog);
mSkillDialog = 0;
update();
}
}
void CreateClassDialog::onDescriptionClicked(MyGUI::Widget* _sender)
{
void CreateClassDialog::onDescriptionClicked(MyGUI::Widget* _sender)
{
mDescDialog = new DescriptionDialog();
mDescDialog->setTextInput(mDescription);
mDescDialog->eventDone += MyGUI::newDelegate(this, &CreateClassDialog::onDescriptionEntered);
mDescDialog->setVisible(true);
}
}
void CreateClassDialog::onDescriptionEntered(WindowBase* parWindow)
{
void CreateClassDialog::onDescriptionEntered(WindowBase* parWindow)
{
mDescription = mDescDialog->getTextInput();
MWBase::Environment::get().getWindowManager()->removeDialog(mDescDialog);
mDescDialog = 0;
}
}
void CreateClassDialog::onOkClicked(MyGUI::Widget* _sender)
{
void CreateClassDialog::onOkClicked(MyGUI::Widget* _sender)
{
if(getName().size() <= 0)
return;
eventDone(this);
}
}
void CreateClassDialog::onBackClicked(MyGUI::Widget* _sender)
{
void CreateClassDialog::onBackClicked(MyGUI::Widget* _sender)
{
eventBack();
}
}
/* SelectSpecializationDialog */
/* SelectSpecializationDialog */
SelectSpecializationDialog::SelectSpecializationDialog()
SelectSpecializationDialog::SelectSpecializationDialog()
: WindowModal("openmw_chargen_select_specialization.layout")
{
{
// Centre dialog
center();
@ -686,16 +687,16 @@ SelectSpecializationDialog::SelectSpecializationDialog()
getWidget(cancelButton, "CancelButton");
cancelButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sCancel", ""));
cancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onCancelClicked);
}
}
SelectSpecializationDialog::~SelectSpecializationDialog()
{
}
SelectSpecializationDialog::~SelectSpecializationDialog()
{
}
// widget controls
// widget controls
void SelectSpecializationDialog::onSpecializationClicked(MyGUI::Widget* _sender)
{
void SelectSpecializationDialog::onSpecializationClicked(MyGUI::Widget* _sender)
{
if (_sender == mSpecialization0)
mSpecializationId = ESM::Class::Combat;
else if (_sender == mSpecialization1)
@ -706,18 +707,18 @@ void SelectSpecializationDialog::onSpecializationClicked(MyGUI::Widget* _sender)
return;
eventItemSelected();
}
}
void SelectSpecializationDialog::onCancelClicked(MyGUI::Widget* _sender)
{
void SelectSpecializationDialog::onCancelClicked(MyGUI::Widget* _sender)
{
eventCancel();
}
}
/* SelectAttributeDialog */
/* SelectAttributeDialog */
SelectAttributeDialog::SelectAttributeDialog()
SelectAttributeDialog::SelectAttributeDialog()
: WindowModal("openmw_chargen_select_attribute.layout")
{
{
// Centre dialog
center();
@ -738,32 +739,32 @@ SelectAttributeDialog::SelectAttributeDialog()
getWidget(cancelButton, "CancelButton");
cancelButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sCancel", ""));
cancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectAttributeDialog::onCancelClicked);
}
}
SelectAttributeDialog::~SelectAttributeDialog()
{
}
SelectAttributeDialog::~SelectAttributeDialog()
{
}
// widget controls
// widget controls
void SelectAttributeDialog::onAttributeClicked(Widgets::MWAttributePtr _sender)
{
void SelectAttributeDialog::onAttributeClicked(Widgets::MWAttributePtr _sender)
{
// TODO: Change MWAttribute to set and get AttributeID enum instead of int
mAttributeId = static_cast<ESM::Attribute::AttributeID>(_sender->getAttributeId());
eventItemSelected();
}
}
void SelectAttributeDialog::onCancelClicked(MyGUI::Widget* _sender)
{
void SelectAttributeDialog::onCancelClicked(MyGUI::Widget* _sender)
{
eventCancel();
}
}
/* SelectSkillDialog */
/* SelectSkillDialog */
SelectSkillDialog::SelectSkillDialog()
SelectSkillDialog::SelectSkillDialog()
: WindowModal("openmw_chargen_select_skill.layout")
{
{
// Centre dialog
center();
@ -830,30 +831,30 @@ SelectSkillDialog::SelectSkillDialog()
getWidget(cancelButton, "CancelButton");
cancelButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sCancel", ""));
cancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSkillDialog::onCancelClicked);
}
}
SelectSkillDialog::~SelectSkillDialog()
{
}
SelectSkillDialog::~SelectSkillDialog()
{
}
// widget controls
// widget controls
void SelectSkillDialog::onSkillClicked(Widgets::MWSkillPtr _sender)
{
void SelectSkillDialog::onSkillClicked(Widgets::MWSkillPtr _sender)
{
mSkillId = _sender->getSkillId();
eventItemSelected();
}
}
void SelectSkillDialog::onCancelClicked(MyGUI::Widget* _sender)
{
void SelectSkillDialog::onCancelClicked(MyGUI::Widget* _sender)
{
eventCancel();
}
}
/* DescriptionDialog */
/* DescriptionDialog */
DescriptionDialog::DescriptionDialog()
DescriptionDialog::DescriptionDialog()
: WindowModal("openmw_chargen_class_description.layout")
{
{
// Centre dialog
center();
@ -866,15 +867,17 @@ DescriptionDialog::DescriptionDialog()
// Make sure the edit box has focus
MyGUI::InputManager::getInstance().setKeyFocusWidget(mTextEdit);
}
}
DescriptionDialog::~DescriptionDialog()
{
}
DescriptionDialog::~DescriptionDialog()
{
}
// widget controls
// widget controls
void DescriptionDialog::onOkClicked(MyGUI::Widget* _sender)
{
void DescriptionDialog::onOkClicked(MyGUI::Widget* _sender)
{
eventDone(this);
}
}

31
apps/openmw/mwgui/console.cpp
View file

@ -278,16 +278,15 @@ namespace MWGui
std::string Console::complete( std::string input, std::vector<std::string> &matches )
{
using namespace std;
string output=input;
string tmp=input;
std::string output = input;
std::string tmp = input;
bool has_front_quote = false;
/* Does the input string contain things that don't have to be completed? If yes erase them. */
/* Are there quotation marks? */
if( tmp.find('"') != string::npos ) {
if( tmp.find('"') != std::string::npos ) {
int numquotes=0;
for(string::iterator it=tmp.begin(); it < tmp.end(); ++it) {
for(std::string::iterator it=tmp.begin(); it < tmp.end(); ++it) {
if( *it == '"' )
numquotes++;
}
@ -299,7 +298,7 @@ namespace MWGui
}
else {
size_t pos;
if( ( ((pos = tmp.rfind(' ')) != string::npos ) ) && ( pos > tmp.rfind('"') ) ) {
if( ( ((pos = tmp.rfind(' ')) != std::string::npos ) ) && ( pos > tmp.rfind('"') ) ) {
tmp.erase( 0, tmp.rfind(' ')+1);
}
else {
@ -311,7 +310,7 @@ namespace MWGui
/* No quotation marks. Are there spaces?*/
else {
size_t rpos;
if( (rpos=tmp.rfind(' ')) != string::npos ) {
if( (rpos=tmp.rfind(' ')) != std::string::npos ) {
if( rpos == 0 ) {
tmp.clear();
}
@ -330,7 +329,7 @@ namespace MWGui
}
/* Iterate through the vector. */
for(vector<string>::iterator it=mNames.begin(); it < mNames.end();++it) {
for(std::vector<std::string>::iterator it=mNames.begin(); it < mNames.end();++it) {
bool string_different=false;
/* Is the string shorter than the input string? If yes skip it. */
@ -338,7 +337,7 @@ namespace MWGui
continue;
/* Is the beginning of the string different from the input string? If yes skip it. */
for( string::iterator iter=tmp.begin(), iter2=(*it).begin(); iter < tmp.end();iter++, iter2++) {
for( std::string::iterator iter=tmp.begin(), iter2=(*it).begin(); iter < tmp.end();iter++, iter2++) {
if( tolower(*iter) != tolower(*iter2) ) {
string_different=true;
break;
@ -361,24 +360,24 @@ namespace MWGui
/* Only one match. We're done. */
if( matches.size() == 1 ) {
/* Adding quotation marks when the input string started with a quotation mark or has spaces in it*/
if( ( matches.front().find(' ') != string::npos ) ) {
if( ( matches.front().find(' ') != std::string::npos ) ) {
if( !has_front_quote )
output.append(string("\""));
return output.append(matches.front() + string("\" "));
output.append(std::string("\""));
return output.append(matches.front() + std::string("\" "));
}
else if( has_front_quote ) {
return output.append(matches.front() + string("\" "));
return output.append(matches.front() + std::string("\" "));
}
else {
return output.append(matches.front() + string(" "));
return output.append(matches.front() + std::string(" "));
}
}
/* Check if all matching strings match further than input. If yes complete to this match. */
int i = tmp.length();
for(string::iterator iter=matches.front().begin()+tmp.length(); iter < matches.front().end(); iter++, i++) {
for(vector<string>::iterator it=matches.begin(); it < matches.end();++it) {
for(std::string::iterator iter=matches.front().begin()+tmp.length(); iter < matches.front().end(); iter++, i++) {
for(std::vector<std::string>::iterator it=matches.begin(); it < matches.end();++it) {
if( tolower((*it)[i]) != tolower(*iter) ) {
/* Append the longest match to the end of the output string*/
output.append(matches.front().substr( 0, i));

170
apps/openmw/mwgui/container.cpp
View file

@ -14,10 +14,6 @@
#include "tradewindow.hpp"
#include "inventorywindow.hpp"
using namespace MWGui;
using namespace Widgets;
namespace
{
bool compareType(std::string type1, std::string type2)
@ -68,30 +64,32 @@ namespace
}
}
namespace MWGui
{
ContainerBase::ContainerBase(DragAndDrop* dragAndDrop)
ContainerBase::ContainerBase(DragAndDrop* dragAndDrop)
: mDragAndDrop(dragAndDrop)
, mFilter(ContainerBase::Filter_All)
, mDisplayEquippedItems(true)
, mHighlightEquippedItems(true)
{
}
{
}
void ContainerBase::setWidgets(MyGUI::Widget* containerWidget, MyGUI::ScrollView* itemView)
{
void ContainerBase::setWidgets(MyGUI::Widget* containerWidget, MyGUI::ScrollView* itemView)
{
mContainerWidget = containerWidget;
mItemView = itemView;
mContainerWidget->eventMouseButtonClick += MyGUI::newDelegate(this, &ContainerBase::onContainerClicked);
mContainerWidget->eventMouseWheel += MyGUI::newDelegate(this, &ContainerWindow::onMouseWheel);
}
}
ContainerBase::~ContainerBase()
{
}
ContainerBase::~ContainerBase()
{
}
void ContainerBase::onSelectedItem(MyGUI::Widget* _sender)
{
void ContainerBase::onSelectedItem(MyGUI::Widget* _sender)
{
mSelectedItem = _sender;
if (mDragAndDrop && !isTrading())
@ -182,10 +180,10 @@ void ContainerBase::onSelectedItem(MyGUI::Widget* _sender)
{
onSelectedItemImpl(*_sender->getUserData<MWWorld::Ptr>());
}
}
}
void ContainerBase::sellAlreadyBoughtItem(MyGUI::Widget* _sender, int count)
{
void ContainerBase::sellAlreadyBoughtItem(MyGUI::Widget* _sender, int count)
{
MWWorld::Ptr object = *mSelectedItem->getUserData<MWWorld::Ptr>();
if (isInventory())
@ -205,10 +203,10 @@ void ContainerBase::sellAlreadyBoughtItem(MyGUI::Widget* _sender, int count)
MWBase::Environment::get().getSoundManager()->playSound (sound, 1.0, 1.0);
drawItems();
}
}
void ContainerBase::sellItem(MyGUI::Widget* _sender, int count)
{
void ContainerBase::sellItem(MyGUI::Widget* _sender, int count)
{
MWWorld::Ptr object = *mSelectedItem->getUserData<MWWorld::Ptr>();
if (isInventory())
@ -228,10 +226,10 @@ void ContainerBase::sellItem(MyGUI::Widget* _sender, int count)
MWBase::Environment::get().getSoundManager()->playSound (sound, 1.0, 1.0);
drawItems();
}
}
void ContainerBase::startDragItem(MyGUI::Widget* _sender, int count)
{
void ContainerBase::startDragItem(MyGUI::Widget* _sender, int count)
{
mDragAndDrop->mIsOnDragAndDrop = true;
mSelectedItem->detachFromWidget();
mSelectedItem->attachToWidget(mDragAndDrop->mDragAndDropWidget);
@ -254,10 +252,10 @@ void ContainerBase::startDragItem(MyGUI::Widget* _sender, int count)
drawItems();
MWBase::Environment::get().getWindowManager()->setDragDrop(true);
}
}
void ContainerBase::onContainerClicked(MyGUI::Widget* _sender)
{
void ContainerBase::onContainerClicked(MyGUI::Widget* _sender)
{
if (mDragAndDrop == NULL) return;
if(mDragAndDrop->mIsOnDragAndDrop) //drop item here
@ -331,29 +329,29 @@ void ContainerBase::onContainerClicked(MyGUI::Widget* _sender)
std::string sound = MWWorld::Class::get(object).getDownSoundId(object);
MWBase::Environment::get().getSoundManager()->playSound (sound, 1.0, 1.0);
}
}
}
void ContainerBase::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
void ContainerBase::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
if (mItemView->getViewOffset().left + _rel*0.3 > 0)
mItemView->setViewOffset(MyGUI::IntPoint(0, 0));
else
mItemView->setViewOffset(MyGUI::IntPoint(mItemView->getViewOffset().left + _rel*0.3, 0));
}
}
void ContainerBase::setFilter(int filter)
{
void ContainerBase::setFilter(int filter)
{
mFilter = filter;
drawItems();
}
}
void ContainerBase::openContainer(MWWorld::Ptr container)
{
void ContainerBase::openContainer(MWWorld::Ptr container)
{
mPtr = container;
}
}
void ContainerBase::drawItems()
{
void ContainerBase::drawItems()
{
while (mContainerWidget->getChildCount())
{
MyGUI::Gui::getInstance().destroyWidget(mContainerWidget->getChildAt(0));
@ -558,28 +556,28 @@ void ContainerBase::drawItems()
mContainerWidget->setSize(size);
notifyContentChanged();
}
}
std::string ContainerBase::getCountString(const int count)
{
std::string ContainerBase::getCountString(const int count)
{
if (count == 1)
return "";
if (count > 9999)
return boost::lexical_cast<std::string>(int(count/1000.f)) + "k";
else
return boost::lexical_cast<std::string>(count);
}
}
void ContainerBase::addBarteredItem(MWWorld::Ptr item, int count)
{
void ContainerBase::addBarteredItem(MWWorld::Ptr item, int count)
{
int origCount = item.getRefData().getCount();
item.getRefData().setCount(count);
MWWorld::ContainerStoreIterator it = mBoughtItems.add(item);
item.getRefData().setCount(origCount - count);
}
}
void ContainerBase::addItem(MWWorld::Ptr item, int count)
{
void ContainerBase::addItem(MWWorld::Ptr item, int count)
{
MWWorld::ContainerStore& containerStore = MWWorld::Class::get(mPtr).getContainerStore(mPtr);
int origCount = item.getRefData().getCount();
@ -588,28 +586,28 @@ void ContainerBase::addItem(MWWorld::Ptr item, int count)
MWWorld::ContainerStoreIterator it = containerStore.add(item);
item.getRefData().setCount(origCount - count);
}
}
void ContainerBase::transferBoughtItems()
{
void ContainerBase::transferBoughtItems()
{
MWWorld::ContainerStore& containerStore = MWWorld::Class::get(mPtr).getContainerStore(mPtr);
for (MWWorld::ContainerStoreIterator it(mBoughtItems.begin()); it != mBoughtItems.end(); ++it)
{
containerStore.add(*it);
}
}
}
void ContainerBase::returnBoughtItems(MWWorld::ContainerStore& store)
{
void ContainerBase::returnBoughtItems(MWWorld::ContainerStore& store)
{
for (MWWorld::ContainerStoreIterator it(mBoughtItems.begin()); it != mBoughtItems.end(); ++it)
{
store.add(*it);
}
}
}
std::vector<MWWorld::Ptr> ContainerBase::getEquippedItems()
{
std::vector<MWWorld::Ptr> ContainerBase::getEquippedItems()
{
if (mPtr.getTypeName() != typeid(ESM::NPC).name())
return std::vector<MWWorld::Ptr>();
@ -627,20 +625,20 @@ std::vector<MWWorld::Ptr> ContainerBase::getEquippedItems()
}
return items;
}
}
MWWorld::ContainerStore& ContainerBase::getContainerStore()
{
MWWorld::ContainerStore& ContainerBase::getContainerStore()
{
MWWorld::ContainerStore& store = MWWorld::Class::get(mPtr).getContainerStore(mPtr);
return store;
}
}
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
ContainerWindow::ContainerWindow(DragAndDrop* dragAndDrop)
ContainerWindow::ContainerWindow(DragAndDrop* dragAndDrop)
: ContainerBase(dragAndDrop)
, WindowBase("openmw_container_window.layout")
{
{
getWidget(mDisposeCorpseButton, "DisposeCorpseButton");
getWidget(mTakeButton, "TakeButton");
getWidget(mCloseButton, "CloseButton");
@ -658,19 +656,19 @@ ContainerWindow::ContainerWindow(DragAndDrop* dragAndDrop)
static_cast<MyGUI::Window*>(mMainWidget)->eventWindowChangeCoord += MyGUI::newDelegate(this, &ContainerWindow::onWindowResize);
setCoord(200,0,600,300);
}
}
ContainerWindow::~ContainerWindow()
{
}
ContainerWindow::~ContainerWindow()
{
}
void ContainerWindow::onWindowResize(MyGUI::Window* window)
{
void ContainerWindow::onWindowResize(MyGUI::Window* window)
{
drawItems();
}
}
void ContainerWindow::open(MWWorld::Ptr container, bool loot)
{
void ContainerWindow::open(MWWorld::Ptr container, bool loot)
{
mDisplayEquippedItems = true;
mHighlightEquippedItems = false;
if (container.getTypeName() == typeid(ESM::NPC).name() && !loot)
@ -684,18 +682,18 @@ void ContainerWindow::open(MWWorld::Ptr container, bool loot)
openContainer(container);
setTitle(MWWorld::Class::get(container).getName(container));
drawItems();
}
}
void ContainerWindow::onCloseButtonClicked(MyGUI::Widget* _sender)
{
void ContainerWindow::onCloseButtonClicked(MyGUI::Widget* _sender)
{
if(mDragAndDrop == NULL || !mDragAndDrop->mIsOnDragAndDrop)
{
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Container);
}
}
}
void ContainerWindow::onTakeAllButtonClicked(MyGUI::Widget* _sender)
{
void ContainerWindow::onTakeAllButtonClicked(MyGUI::Widget* _sender)
{
if(mDragAndDrop == NULL || !mDragAndDrop->mIsOnDragAndDrop)
{
// transfer everything into the player's inventory
@ -729,10 +727,10 @@ void ContainerWindow::onTakeAllButtonClicked(MyGUI::Widget* _sender)
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Container);
}
}
}
void ContainerWindow::onDisposeCorpseButtonClicked(MyGUI::Widget *sender)
{
void ContainerWindow::onDisposeCorpseButtonClicked(MyGUI::Widget *sender)
{
if(mDragAndDrop == NULL || !mDragAndDrop->mIsOnDragAndDrop)
{
onTakeAllButtonClicked(mTakeButton);
@ -745,9 +743,11 @@ void ContainerWindow::onDisposeCorpseButtonClicked(MyGUI::Widget *sender)
mPtr = MWWorld::Ptr();
}
}
}
void ContainerWindow::onReferenceUnavailable()
{
void ContainerWindow::onReferenceUnavailable()
{
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Container);
}
}

168
apps/openmw/mwgui/dialogue.cpp
View file

@ -19,38 +19,37 @@
#include "inventorywindow.hpp"
#include "travelwindow.hpp"
using namespace MWGui;
using namespace Widgets;
/**
*Copied from the internet.
*/
namespace {
std::string lower_string(const std::string& str)
namespace
{
std::string lower_string(const std::string& str)
{
std::string lowerCase = Misc::StringUtils::lowerCase (str);
return lowerCase;
}
}
std::string::size_type find_str_ci(const std::string& str, const std::string& substr,size_t pos)
{
std::string::size_type find_str_ci(const std::string& str, const std::string& substr,size_t pos)
{
return lower_string(str).find(lower_string(substr),pos);
}
}
bool sortByLength (const std::string& left, const std::string& right)
{
bool sortByLength (const std::string& left, const std::string& right)
{
return left.size() > right.size();
}
}
}
PersuasionDialog::PersuasionDialog()
: WindowModal("openmw_persuasion_dialog.layout")
namespace MWGui
{
PersuasionDialog::PersuasionDialog()
: WindowModal("openmw_persuasion_dialog.layout")
{
getWidget(mCancelButton, "CancelButton");
getWidget(mAdmireButton, "AdmireButton");
getWidget(mIntimidateButton, "IntimidateButton");
@ -67,15 +66,15 @@ PersuasionDialog::PersuasionDialog()
mBribe10Button->eventMouseButtonClick += MyGUI::newDelegate(this, &PersuasionDialog::onPersuade);
mBribe100Button->eventMouseButtonClick += MyGUI::newDelegate(this, &PersuasionDialog::onPersuade);
mBribe1000Button->eventMouseButtonClick += MyGUI::newDelegate(this, &PersuasionDialog::onPersuade);
}
}
void PersuasionDialog::onCancel(MyGUI::Widget *sender)
{
void PersuasionDialog::onCancel(MyGUI::Widget *sender)
{
setVisible(false);
}
}
void PersuasionDialog::onPersuade(MyGUI::Widget *sender)
{
void PersuasionDialog::onPersuade(MyGUI::Widget *sender)
{
MWBase::MechanicsManager::PersuasionType type;
if (sender == mAdmireButton) type = MWBase::MechanicsManager::PT_Admire;
else if (sender == mIntimidateButton) type = MWBase::MechanicsManager::PT_Intimidate;
@ -99,10 +98,10 @@ void PersuasionDialog::onPersuade(MyGUI::Widget *sender)
MWBase::Environment::get().getDialogueManager()->persuade(type);
setVisible(false);
}
}
void PersuasionDialog::open()
{
void PersuasionDialog::open()
{
WindowModal::open();
center();
@ -113,16 +112,16 @@ void PersuasionDialog::open()
mBribe1000Button->setEnabled (playerGold >= 1000);
mGoldLabel->setCaptionWithReplacing("#{sGold}: " + boost::lexical_cast<std::string>(playerGold));
}
}
// --------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------
DialogueWindow::DialogueWindow()
DialogueWindow::DialogueWindow()
: WindowBase("openmw_dialogue_window.layout")
, mPersuasionDialog()
, mEnabled(false)
, mServices(0)
{
{
// Centre dialog
center();
@ -152,10 +151,10 @@ DialogueWindow::DialogueWindow()
getWidget(mDispositionText,"DispositionText");
static_cast<MyGUI::Window*>(mMainWidget)->eventWindowChangeCoord += MyGUI::newDelegate(this, &DialogueWindow::onWindowResize);
}
}
void DialogueWindow::onHistoryClicked(MyGUI::Widget* _sender)
{
void DialogueWindow::onHistoryClicked(MyGUI::Widget* _sender)
{
MyGUI::ISubWidgetText* t = mHistory->getClient()->getSubWidgetText();
if(t == NULL)
return;
@ -199,28 +198,28 @@ void DialogueWindow::onHistoryClicked(MyGUI::Widget* _sender)
if(color == "#572D21")
MWBase::Environment::get().getDialogueManager()->questionAnswered(lower_string(key));
}
}
}
void DialogueWindow::onWindowResize(MyGUI::Window* _sender)
{
void DialogueWindow::onWindowResize(MyGUI::Window* _sender)
{
mTopicsList->adjustSize();
}
}
void DialogueWindow::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
void DialogueWindow::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
if (mHistory->getVScrollPosition() - _rel*0.3 < 0)
mHistory->setVScrollPosition(0);
else
mHistory->setVScrollPosition(mHistory->getVScrollPosition() - _rel*0.3);
}
}
void DialogueWindow::onByeClicked(MyGUI::Widget* _sender)
{
void DialogueWindow::onByeClicked(MyGUI::Widget* _sender)
{
MWBase::Environment::get().getDialogueManager()->goodbyeSelected();
}
}
void DialogueWindow::onSelectTopic(const std::string& topic, int id)
{
void DialogueWindow::onSelectTopic(const std::string& topic, int id)
{
if (!mEnabled || MWBase::Environment::get().getDialogueManager()->isInChoice())
return;
@ -286,10 +285,10 @@ void DialogueWindow::onSelectTopic(const std::string& topic, int id)
}
}
}
}
}
void DialogueWindow::startDialogue(MWWorld::Ptr actor, std::string npcName)
{
void DialogueWindow::startDialogue(MWWorld::Ptr actor, std::string npcName)
{
mEnabled = true;
mPtr = actor;
mTopicsList->setEnabled(true);
@ -299,10 +298,10 @@ void DialogueWindow::startDialogue(MWWorld::Ptr actor, std::string npcName)
mHyperLinks.clear();
mHistory->setCaption("");
updateOptions();
}
}
void DialogueWindow::setKeywords(std::list<std::string> keyWords)
{
void DialogueWindow::setKeywords(std::list<std::string> keyWords)
{
mTopicsList->clear();
bool isCompanion = !MWWorld::Class::get(mPtr).getScript(mPtr).empty()
@ -349,19 +348,19 @@ void DialogueWindow::setKeywords(std::list<std::string> keyWords)
mTopicsList->addItem(*it);
}
mTopicsList->adjustSize();
}
}
void DialogueWindow::removeKeyword(std::string keyWord)
{
void DialogueWindow::removeKeyword(std::string keyWord)
{
if(mTopicsList->hasItem(keyWord))
{
mTopicsList->removeItem(keyWord);
}
mTopicsList->adjustSize();
}
}
void addColorInString(std::string& str, const std::string& keyword,std::string color1, std::string color2)
{
void addColorInString(std::string& str, const std::string& keyword,std::string color1, std::string color2)
{
size_t pos = 0;
while((pos = find_str_ci(str,keyword, pos)) != std::string::npos)
{
@ -387,10 +386,10 @@ void addColorInString(std::string& str, const std::string& keyword,std::string c
str.insert(pos,color2);
pos+= color2.length();
}
}
}
std::string DialogueWindow::parseText(const std::string& text)
{
std::string DialogueWindow::parseText(const std::string& text)
{
bool separatorReached = false; // only parse topics that are below the separator (this prevents actions like "Barter" that are not topics from getting blue-colored)
std::vector<std::string> topics;
@ -464,20 +463,20 @@ std::string DialogueWindow::parseText(const std::string& text)
}
return result;
}
}
void DialogueWindow::addText(std::string text)
{
void DialogueWindow::addText(std::string text)
{
mHistory->addDialogText("#B29154"+parseText(text)+"#B29154");
}
}
void DialogueWindow::addMessageBox(const std::string& text)
{
void DialogueWindow::addMessageBox(const std::string& text)
{
mHistory->addDialogText("\n#FFFFFF"+text+"#B29154");
}
}
void DialogueWindow::addTitle(std::string text)
{
void DialogueWindow::addTitle(std::string text)
{
// This is called from the dialogue manager, so text is
// case-smashed - thus we have to retrieve the correct case
// of the text through the topic list.
@ -489,15 +488,15 @@ void DialogueWindow::addTitle(std::string text)
}
mHistory->addDialogHeading(text);
}
}
void DialogueWindow::askQuestion(std::string question)
{
void DialogueWindow::askQuestion(std::string question)
{
mHistory->addDialogText("#572D21"+question+"#B29154"+" ");
}
}
void DialogueWindow::updateOptions()
{
void DialogueWindow::updateOptions()
{
//Clear the list of topics
mTopicsList->clear();
mHyperLinks.clear();
@ -510,22 +509,22 @@ void DialogueWindow::updateOptions()
mDispositionText->eraseText(0, mDispositionText->getTextLength());
mDispositionText->addText("#B29154"+boost::lexical_cast<std::string>(MWBase::Environment::get().getMechanicsManager()->getDerivedDisposition(mPtr))+std::string("/100")+"#B29154");
}
}
}
void DialogueWindow::goodbye()
{
void DialogueWindow::goodbye()
{
mHistory->addDialogText("\n#572D21" + MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>().find("sGoodbye")->getString());
mTopicsList->setEnabled(false);
mEnabled = false;
}
}
void DialogueWindow::onReferenceUnavailable()
{
void DialogueWindow::onReferenceUnavailable()
{
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Dialogue);
}
}
void DialogueWindow::onFrame()
{
void DialogueWindow::onFrame()
{
if(mMainWidget->getVisible() && mEnabled && mPtr.getTypeName() == typeid(ESM::NPC).name())
{
int disp = std::max(0, std::min(100,
@ -536,4 +535,5 @@ void DialogueWindow::onFrame()
mDispositionText->eraseText(0, mDispositionText->getTextLength());
mDispositionText->addText("#B29154"+boost::lexical_cast<std::string>(disp)+std::string("/100")+"#B29154");
}
}
}

28
apps/openmw/mwgui/dialoguehistory.cpp
View file

@ -12,11 +12,11 @@
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
using namespace MWGui;
using namespace Widgets;
MyGUI::UString DialogueHistory::getColorAtPos(size_t _pos)
namespace MWGui
{
MyGUI::UString DialogueHistory::getColorAtPos(size_t _pos)
{
MyGUI::UString colour = MyGUI::TextIterator::convertTagColour(getTextColour());
MyGUI::TextIterator iterator(getCaption());
while(iterator.moveNext())
@ -29,10 +29,10 @@ MyGUI::UString DialogueHistory::getColorAtPos(size_t _pos)
break;
}
return colour;
}
}
MyGUI::UString DialogueHistory::getColorTextAt(size_t _pos)
{
MyGUI::UString DialogueHistory::getColorTextAt(size_t _pos)
{
bool breakOnNext = false;
MyGUI::UString colour = MyGUI::TextIterator::convertTagColour(getTextColour());
MyGUI::UString colour2 = colour;
@ -59,18 +59,20 @@ MyGUI::UString DialogueHistory::getColorTextAt(size_t _pos)
}
}
return "";
}
}
void DialogueHistory::addDialogHeading(const MyGUI::UString& parText)
{
void DialogueHistory::addDialogHeading(const MyGUI::UString& parText)
{
MyGUI::UString head("\n#D8C09A");
head.append(parText);
head.append("#B29154\n");
addText(head);
}
}
void DialogueHistory::addDialogText(const MyGUI::UString& parText)
{
void DialogueHistory::addDialogText(const MyGUI::UString& parText)
{
addText(parText);
addText("\n");
}
}

55
apps/openmw/mwgui/formatting.cpp
View file

@ -9,8 +9,6 @@
#include <boost/lexical_cast.hpp>
#include <OgreUTFString.h>
using namespace MWGui;
namespace
{
int convertFromHex(std::string hex)
@ -78,8 +76,11 @@ namespace
}
}
std::vector<std::string> BookTextParser::split(std::string utf8Text, const int width, const int height)
namespace MWGui
{
std::vector<std::string> BookTextParser::split(std::string utf8Text, const int width, const int height)
{
using Ogre::UTFString;
std::vector<std::string> result;
@ -177,23 +178,23 @@ std::vector<std::string> BookTextParser::split(std::string utf8Text, const int w
}
return result;
}
}
float BookTextParser::widthForCharGlyph(unsigned unicodeChar) const
{
float BookTextParser::widthForCharGlyph(unsigned unicodeChar) const
{
std::string fontName(mTextStyle.mFont == "Default" ? "EB Garamond" : mTextStyle.mFont);
return MyGUI::FontManager::getInstance().getByName(fontName)
->getGlyphInfo(unicodeChar)->width;
}
}
float BookTextParser::currentFontHeight() const
{
float BookTextParser::currentFontHeight() const
{
std::string fontName(mTextStyle.mFont == "Default" ? "EB Garamond" : mTextStyle.mFont);
return MyGUI::FontManager::getInstance().getByName(fontName)->getDefaultHeight();
}
}
MyGUI::IntSize BookTextParser::parse(std::string text, MyGUI::Widget* parent, const int width)
{
MyGUI::IntSize BookTextParser::parse(std::string text, MyGUI::Widget* parent, const int width)
{
MWScript::InterpreterContext interpreterContext(NULL, MWWorld::Ptr()); // empty arguments, because there is no locals or actor
text = Interpreter::fixDefinesBook(text, interpreterContext);
@ -212,8 +213,8 @@ MyGUI::IntSize BookTextParser::parse(std::string text, MyGUI::Widget* parent, co
boost::algorithm::replace_all(text, "<P>", "\n\n");
// remove leading newlines
// while (text[0] == '\n')
// text.erase(0);
// while (text[0] == '\n')
// text.erase(0);
// remove trailing "
if (text[text.size()-1] == '\"')
@ -221,10 +222,10 @@ MyGUI::IntSize BookTextParser::parse(std::string text, MyGUI::Widget* parent, co
parseSubText(text);
return MyGUI::IntSize(mWidth, mHeight);
}
}
void BookTextParser::parseImage(std::string tag, bool createWidget)
{
void BookTextParser::parseImage(std::string tag, bool createWidget)
{
int src_start = tag.find("SRC=")+5;
std::string image = tag.substr(src_start, tag.find('"', src_start)-src_start);
@ -253,10 +254,10 @@ void BookTextParser::parseImage(std::string tag, bool createWidget)
mWidth = std::max(mWidth, width);
mHeight += height;
}
}
void BookTextParser::parseDiv(std::string tag)
{
void BookTextParser::parseDiv(std::string tag)
{
if (tag.find("ALIGN=") == std::string::npos)
return;
@ -266,10 +267,10 @@ void BookTextParser::parseDiv(std::string tag)
mTextStyle.mTextAlign = MyGUI::Align::HCenter;
else if (align == "LEFT")
mTextStyle.mTextAlign = MyGUI::Align::Left;
}
}
void BookTextParser::parseFont(std::string tag)
{
void BookTextParser::parseFont(std::string tag)
{
if (tag.find("COLOR=") != std::string::npos)
{
int color_start = tag.find("COLOR=")+7;
@ -292,10 +293,10 @@ void BookTextParser::parseFont(std::string tag)
{
/// \todo
}
}
}
void BookTextParser::parseSubText(std::string text)
{
void BookTextParser::parseSubText(std::string text)
{
if (text[0] == '<')
{
const size_t tagStart = 1;
@ -361,4 +362,6 @@ void BookTextParser::parseSubText(std::string text)
{
parseSubText(text.substr(tagStart, text.size()));
}
}
}

183
apps/openmw/mwgui/hud.cpp
View file

@ -12,9 +12,10 @@
#include "console.hpp"
#include "spellicons.hpp"
using namespace MWGui;
namespace MWGui
{
HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
: Layout("openmw_hud.layout")
, mHealth(NULL)
, mMagicka(NULL)
@ -43,7 +44,7 @@ HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
, mWeaponVisible(true)
, mSpellVisible(true)
, mWorldMouseOver(false)
{
{
setCoord(0,0, width, height);
// Energy bars
@ -103,15 +104,15 @@ HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
mMainWidget->eventMouseLostFocus += MyGUI::newDelegate(this, &HUD::onWorldMouseLostFocus);
mSpellIcons = new SpellIcons();
}
}
HUD::~HUD()
{
HUD::~HUD()
{
delete mSpellIcons;
}
}
void HUD::setFpsLevel(int level)
{
void HUD::setFpsLevel(int level)
{
mFpsCounter = 0;
MyGUI::Widget* fps;
@ -132,26 +133,26 @@ void HUD::setFpsLevel(int level)
mFpsBox->setVisible(true);
getWidget(mFpsCounter, "FPSCounter");
}
}
}
void HUD::setFPS(float fps)
{
void HUD::setFPS(float fps)
{
if (mFpsCounter)
mFpsCounter->setCaption(boost::lexical_cast<std::string>((int)fps));
}
}
void HUD::setTriangleCount(unsigned int count)
{
void HUD::setTriangleCount(unsigned int count)
{
mTriangleCounter->setCaption(boost::lexical_cast<std::string>(count));
}
}
void HUD::setBatchCount(unsigned int count)
{
void HUD::setBatchCount(unsigned int count)
{
mBatchCounter->setCaption(boost::lexical_cast<std::string>(count));
}
}
void HUD::setValue(const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
void HUD::setValue(const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
static const char *ids[] =
{
"HBar", "MBar", "FBar", 0
@ -184,10 +185,10 @@ void HUD::setValue(const std::string& id, const MWMechanics::DynamicStat<float>&
break;
}
}
}
}
void HUD::onWorldClicked(MyGUI::Widget* _sender)
{
void HUD::onWorldClicked(MyGUI::Widget* _sender)
{
if (!MWBase::Environment::get().getWindowManager ()->isGuiMode ())
return;
@ -244,10 +245,10 @@ void HUD::onWorldClicked(MyGUI::Widget* _sender)
MWBase::Environment::get().getWindowManager()->getInventoryWindow()->pickUpObject(object);
}
}
}
}
void HUD::onWorldMouseOver(MyGUI::Widget* _sender, int x, int y)
{
void HUD::onWorldMouseOver(MyGUI::Widget* _sender, int x, int y)
{
if (mDragAndDrop->mIsOnDragAndDrop)
{
mWorldMouseOver = false;
@ -273,36 +274,36 @@ void HUD::onWorldMouseOver(MyGUI::Widget* _sender, int x, int y)
MWBase::Environment::get().getWindowManager()->changePointer("arrow");
mWorldMouseOver = true;
}
}
}
void HUD::onWorldMouseLostFocus(MyGUI::Widget* _sender, MyGUI::Widget* _new)
{
void HUD::onWorldMouseLostFocus(MyGUI::Widget* _sender, MyGUI::Widget* _new)
{
MWBase::Environment::get().getWindowManager()->changePointer("arrow");
mWorldMouseOver = false;
}
}
void HUD::onHMSClicked(MyGUI::Widget* _sender)
{
void HUD::onHMSClicked(MyGUI::Widget* _sender)
{
MWBase::Environment::get().getWindowManager()->toggleVisible(GW_Stats);
}
}
void HUD::onMapClicked(MyGUI::Widget* _sender)
{
void HUD::onMapClicked(MyGUI::Widget* _sender)
{
MWBase::Environment::get().getWindowManager()->toggleVisible(GW_Map);
}
}
void HUD::onWeaponClicked(MyGUI::Widget* _sender)
{
void HUD::onWeaponClicked(MyGUI::Widget* _sender)
{
MWBase::Environment::get().getWindowManager()->toggleVisible(GW_Inventory);
}
}
void HUD::onMagicClicked(MyGUI::Widget* _sender)
{
void HUD::onMagicClicked(MyGUI::Widget* _sender)
{
MWBase::Environment::get().getWindowManager()->toggleVisible(GW_Magic);
}
}
void HUD::setCellName(const std::string& cellName)
{
void HUD::setCellName(const std::string& cellName)
{
if (mCellName != cellName)
{
mCellNameTimer = 5.0f;
@ -311,25 +312,25 @@ void HUD::setCellName(const std::string& cellName)
mCellNameBox->setCaptionWithReplacing("#{sCell=" + mCellName + "}");
mCellNameBox->setVisible(mMapVisible);
}
}
}
void HUD::onFrame(float dt)
{
void HUD::onFrame(float dt)
{
mCellNameTimer -= dt;
mWeaponSpellTimer -= dt;
if (mCellNameTimer < 0)
mCellNameBox->setVisible(false);
if (mWeaponSpellTimer < 0)
mWeaponSpellBox->setVisible(false);
}
}
void HUD::onResChange(int width, int height)
{
void HUD::onResChange(int width, int height)
{
setCoord(0, 0, width, height);
}
}
void HUD::setSelectedSpell(const std::string& spellId, int successChancePercent)
{
void HUD::setSelectedSpell(const std::string& spellId, int successChancePercent)
{
const ESM::Spell* spell =
MWBase::Environment::get().getWorld()->getStore().get<ESM::Spell>().find(spellId);
@ -361,10 +362,10 @@ void HUD::setSelectedSpell(const std::string& spellId, int successChancePercent)
icon = std::string("icons\\") + icon;
Widgets::fixTexturePath(icon);
mSpellImage->setImageTexture(icon);
}
}
void HUD::setSelectedEnchantItem(const MWWorld::Ptr& item, int chargePercent)
{
void HUD::setSelectedEnchantItem(const MWWorld::Ptr& item, int chargePercent)
{
std::string itemName = MWWorld::Class::get(item).getName(item);
if (itemName != mSpellName && mSpellVisible)
{
@ -392,10 +393,10 @@ void HUD::setSelectedEnchantItem(const MWWorld::Ptr& item, int chargePercent)
Widgets::fixTexturePath(path);
itemBox->setImageTexture(path);
itemBox->setNeedMouseFocus(false);
}
}
void HUD::setSelectedWeapon(const MWWorld::Ptr& item, int durabilityPercent)
{
void HUD::setSelectedWeapon(const MWWorld::Ptr& item, int durabilityPercent)
{
std::string itemName = MWWorld::Class::get(item).getName(item);
if (itemName != mWeaponName && mWeaponVisible)
{
@ -428,10 +429,10 @@ void HUD::setSelectedWeapon(const MWWorld::Ptr& item, int durabilityPercent)
}
else
mWeapImage->setImageTexture(path);
}
}
void HUD::unsetSelectedSpell()
{
void HUD::unsetSelectedSpell()
{
std::string spellName = "#{sNone}";
if (spellName != mSpellName && mSpellVisible)
{
@ -447,10 +448,10 @@ void HUD::unsetSelectedSpell()
mSpellStatus->setProgressPosition(0);
mSpellImage->setImageTexture("");
mSpellBox->clearUserStrings();
}
}
void HUD::unsetSelectedWeapon()
{
void HUD::unsetSelectedWeapon()
{
std::string itemName = "#{sSkillHandtohand}";
if (itemName != mWeaponName && mWeaponVisible)
{
@ -466,47 +467,47 @@ void HUD::unsetSelectedWeapon()
mWeapStatus->setProgressPosition(0);
mWeapImage->setImageTexture("icons\\k\\stealth_handtohand.dds");
mWeapBox->clearUserStrings();
}
}
void HUD::setCrosshairVisible(bool visible)
{
void HUD::setCrosshairVisible(bool visible)
{
mCrosshair->setVisible (visible);
}
}
void HUD::setHmsVisible(bool visible)
{
void HUD::setHmsVisible(bool visible)
{
mHealth->setVisible(visible);
mMagicka->setVisible(visible);
mStamina->setVisible(visible);
updatePositions();
}
}
void HUD::setWeapVisible(bool visible)
{
void HUD::setWeapVisible(bool visible)
{
mWeapBox->setVisible(visible);
updatePositions();
}
}
void HUD::setSpellVisible(bool visible)
{
void HUD::setSpellVisible(bool visible)
{
mSpellBox->setVisible(visible);
updatePositions();
}
}
void HUD::setEffectVisible(bool visible)
{
void HUD::setEffectVisible(bool visible)
{
mEffectBox->setVisible (visible);
updatePositions();
}
}
void HUD::setMinimapVisible(bool visible)
{
void HUD::setMinimapVisible(bool visible)
{
mMinimapBox->setVisible (visible);
updatePositions();
}
}
void HUD::updatePositions()
{
void HUD::updatePositions()
{
int weapDx = 0, spellDx = 0;
if (!mHealth->getVisible())
spellDx = weapDx = mWeapBoxBaseLeft - mHealthManaStaminaBaseLeft;
@ -531,9 +532,11 @@ void HUD::updatePositions()
mMapVisible = mMinimapBox->getVisible ();
mEffectBox->setPosition((viewSize.width - mEffectBoxBaseRight) - mEffectBox->getWidth() + effectsDx, mEffectBox->getTop());
}
}
void HUD::update()
{
void HUD::update()
{
mSpellIcons->updateWidgets(mEffectBox, true);
}
}

110
apps/openmw/mwgui/list.cpp
View file

@ -5,18 +5,21 @@
#include <MyGUI_ImageBox.h>
#include <MyGUI_ScrollBar.h>
using namespace MWGui;
using namespace MWGui::Widgets;
namespace MWGui
{
MWList::MWList() :
namespace Widgets
{
MWList::MWList() :
mClient(0)
, mScrollView(0)
, mItemHeight(0)
{
}
{
}
void MWList::initialiseOverride()
{
void MWList::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mClient, "Client");
@ -26,25 +29,25 @@ void MWList::initialiseOverride()
mScrollView = mClient->createWidgetReal<MWGui::Widgets::MWScrollView>(
"MW_ScrollView", MyGUI::FloatCoord(0.0, 0.0, 1.0, 1.0),
MyGUI::Align::Top | MyGUI::Align::Left | MyGUI::Align::Stretch, getName() + "_ScrollView");
}
}
void MWList::addItem(const std::string& name)
{
void MWList::addItem(const std::string& name)
{
mItems.push_back(name);
}
}
void MWList::addSeparator()
{
void MWList::addSeparator()
{
mItems.push_back("");
}
}
void MWList::adjustSize()
{
void MWList::adjustSize()
{
redraw();
}
}
void MWList::redraw(bool scrollbarShown)
{
void MWList::redraw(bool scrollbarShown)
{
const int _scrollBarWidth = 24; // fetch this from skin?
const int scrollBarWidth = scrollbarShown ? _scrollBarWidth : 0;
const int spacing = 3;
@ -97,67 +100,70 @@ void MWList::redraw(bool scrollbarShown)
if(scrollbarPosition > scrollbarRange)
scrollbarPosition = scrollbarRange;
mScrollView->setScrollPosition(scrollbarPosition);
}
}
bool MWList::hasItem(const std::string& name)
{
bool MWList::hasItem(const std::string& name)
{
return (std::find(mItems.begin(), mItems.end(), name) != mItems.end());
}
}
unsigned int MWList::getItemCount()
{
unsigned int MWList::getItemCount()
{
return mItems.size();
}
}
std::string MWList::getItemNameAt(unsigned int at)
{
std::string MWList::getItemNameAt(unsigned int at)
{
assert(at < mItems.size() && "List item out of bounds");
return mItems[at];
}
}
void MWList::removeItem(const std::string& name)
{
void MWList::removeItem(const std::string& name)
{
assert( std::find(mItems.begin(), mItems.end(), name) != mItems.end() );
mItems.erase( std::find(mItems.begin(), mItems.end(), name) );
}
}
void MWList::clear()
{
void MWList::clear()
{
mItems.clear();
}
}
void MWList::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
void MWList::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
//NB view offset is negative
if (mScrollView->getViewOffset().top + _rel*0.3 > 0)
mScrollView->setViewOffset(MyGUI::IntPoint(0, 0));
else
mScrollView->setViewOffset(MyGUI::IntPoint(0, mScrollView->getViewOffset().top + _rel*0.3));
}
}
void MWList::onItemSelected(MyGUI::Widget* _sender)
{
void MWList::onItemSelected(MyGUI::Widget* _sender)
{
std::string name = static_cast<MyGUI::Button*>(_sender)->getCaption();
int id = *_sender->getUserData<int>();
eventItemSelected(name, id);
eventWidgetSelected(_sender);
}
}
MyGUI::Widget* MWList::getItemWidget(const std::string& name)
{
MyGUI::Widget* MWList::getItemWidget(const std::string& name)
{
return mScrollView->findWidget (getName() + "_item_" + name);
}
}
size_t MWScrollView::getScrollPosition()
{
size_t MWScrollView::getScrollPosition()
{
return getVScroll()->getScrollPosition();
}
}
void MWScrollView::setScrollPosition(size_t position)
{
void MWScrollView::setScrollPosition(size_t position)
{
getVScroll()->setScrollPosition(position);
}
size_t MWScrollView::getScrollRange()
{
}
size_t MWScrollView::getScrollRange()
{
return getVScroll()->getScrollRange();
}
}
}

143
apps/openmw/mwgui/mapwindow.cpp
View file

@ -13,9 +13,10 @@
#include "widgets.hpp"
using namespace MWGui;
namespace MWGui
{
LocalMapBase::LocalMapBase()
LocalMapBase::LocalMapBase()
: mCurX(0)
, mCurY(0)
, mInterior(false)
@ -30,11 +31,11 @@ LocalMapBase::LocalMapBase()
, mLastDirectionX(0.0f)
, mLastDirectionY(0.0f)
, mCompass(NULL)
{
}
{
}
void LocalMapBase::init(MyGUI::ScrollView* widget, MyGUI::ImageBox* compass, OEngine::GUI::Layout* layout, bool mapDragAndDrop)
{
void LocalMapBase::init(MyGUI::ScrollView* widget, MyGUI::ImageBox* compass, OEngine::GUI::Layout* layout, bool mapDragAndDrop)
{
mLocalMap = widget;
mLayout = layout;
mMapDragAndDrop = mapDragAndDrop;
@ -64,22 +65,22 @@ void LocalMapBase::init(MyGUI::ScrollView* widget, MyGUI::ImageBox* compass, OEn
mFogWidgets.push_back(fog);
}
}
}
}
void LocalMapBase::setCellPrefix(const std::string& prefix)
{
void LocalMapBase::setCellPrefix(const std::string& prefix)
{
mPrefix = prefix;
mChanged = true;
}
}
void LocalMapBase::toggleFogOfWar()
{
void LocalMapBase::toggleFogOfWar()
{
mFogOfWar = !mFogOfWar;
applyFogOfWar();
}
}
void LocalMapBase::applyFogOfWar()
{
void LocalMapBase::applyFogOfWar()
{
for (int mx=0; mx<3; ++mx)
{
for (int my=0; my<3; ++my)
@ -97,20 +98,20 @@ void LocalMapBase::applyFogOfWar()
}
}
notifyMapChanged ();
}
}
void LocalMapBase::onMarkerFocused (MyGUI::Widget* w1, MyGUI::Widget* w2)
{
void LocalMapBase::onMarkerFocused (MyGUI::Widget* w1, MyGUI::Widget* w2)
{
applyFogOfWar ();
}
}
void LocalMapBase::onMarkerUnfocused (MyGUI::Widget* w1, MyGUI::Widget* w2)
{
void LocalMapBase::onMarkerUnfocused (MyGUI::Widget* w1, MyGUI::Widget* w2)
{
applyFogOfWar ();
}
}
void LocalMapBase::setActiveCell(const int x, const int y, bool interior)
{
void LocalMapBase::setActiveCell(const int x, const int y, bool interior)
{
if (x==mCurX && y==mCurY && mInterior==interior && !mChanged) return; // don't do anything if we're still in the same cell
// clear all previous markers
@ -218,11 +219,11 @@ void LocalMapBase::setActiveCell(const int x, const int y, bool interior)
std::string tex = "textures\\compass.dds";
mCompass->setImageTexture("");
mCompass->setImageTexture(tex);
}
}
void LocalMapBase::setPlayerPos(const float x, const float y)
{
void LocalMapBase::setPlayerPos(const float x, const float y)
{
if (x == mLastPositionX && y == mLastPositionY)
return;
@ -237,10 +238,10 @@ void LocalMapBase::setPlayerPos(const float x, const float y)
mCompass->setPosition(MyGUI::IntPoint(512+x*512-16, 512+y*512-16));
mLastPositionX = x;
mLastPositionY = y;
}
}
void LocalMapBase::setPlayerDir(const float x, const float y)
{
void LocalMapBase::setPlayerDir(const float x, const float y)
{
if (x == mLastDirectionX && y == mLastDirectionY)
return;
@ -254,14 +255,14 @@ void LocalMapBase::setPlayerDir(const float x, const float y)
mLastDirectionX = x;
mLastDirectionY = y;
}
}
// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
MapWindow::MapWindow(const std::string& cacheDir)
MapWindow::MapWindow(const std::string& cacheDir)
: MWGui::WindowPinnableBase("openmw_map_window.layout")
, mGlobal(false)
{
{
setCoord(500,0,320,300);
mGlobalMapRender = new MWRender::GlobalMap(cacheDir);
@ -291,20 +292,20 @@ MapWindow::MapWindow(const std::string& cacheDir)
mEventBoxLocal->eventMouseButtonPressed += MyGUI::newDelegate(this, &MapWindow::onDragStart);
LocalMapBase::init(mLocalMap, mPlayerArrowLocal, this);
}
}
MapWindow::~MapWindow()
{
MapWindow::~MapWindow()
{
delete mGlobalMapRender;
}
}
void MapWindow::setCellName(const std::string& cellName)
{
void MapWindow::setCellName(const std::string& cellName)
{
setTitle("#{sCell=" + cellName + "}");
}
}
void MapWindow::addVisitedLocation(const std::string& name, int x, int y)
{
void MapWindow::addVisitedLocation(const std::string& name, int x, int y)
{
float worldX, worldY;
mGlobalMapRender->cellTopLeftCornerToImageSpace (x, y, worldX, worldY);
@ -329,21 +330,21 @@ void MapWindow::addVisitedLocation(const std::string& name, int x, int y)
markerWidget->setUserString("ToolTipType", "Layout");
markerWidget->setUserString("ToolTipLayout", "TextToolTipOneLine");
markerWidget->setUserString("Caption_TextOneLine", name);
}
}
void MapWindow::cellExplored(int x, int y)
{
void MapWindow::cellExplored(int x, int y)
{
mGlobalMapRender->exploreCell(x,y);
}
}
void MapWindow::onDragStart(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id)
{
void MapWindow::onDragStart(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id)
{
if (_id!=MyGUI::MouseButton::Left) return;
mLastDragPos = MyGUI::IntPoint(_left, _top);
}
}
void MapWindow::onMouseDrag(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id)
{
void MapWindow::onMouseDrag(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id)
{
if (_id!=MyGUI::MouseButton::Left) return;
MyGUI::IntPoint diff = MyGUI::IntPoint(_left, _top) - mLastDragPos;
@ -355,10 +356,10 @@ void MapWindow::onMouseDrag(MyGUI::Widget* _sender, int _left, int _top, MyGUI::
mLastDragPos = MyGUI::IntPoint(_left, _top);
}
}
void MapWindow::onWorldButtonClicked(MyGUI::Widget* _sender)
{
void MapWindow::onWorldButtonClicked(MyGUI::Widget* _sender)
{
mGlobal = !mGlobal;
mGlobalMap->setVisible(mGlobal);
mLocalMap->setVisible(!mGlobal);
@ -368,15 +369,15 @@ void MapWindow::onWorldButtonClicked(MyGUI::Widget* _sender)
if (mGlobal)
globalMapUpdatePlayer ();
}
}
void MapWindow::onPinToggled()
{
void MapWindow::onPinToggled()
{
MWBase::Environment::get().getWindowManager()->setMinimapVisibility(!mPinned);
}
}
void MapWindow::open()
{
void MapWindow::open()
{
mGlobalMap->setCanvasSize (mGlobalMapRender->getWidth(), mGlobalMapRender->getHeight());
mGlobalMapImage->setSize(mGlobalMapRender->getWidth(), mGlobalMapRender->getHeight());
@ -389,10 +390,10 @@ void MapWindow::open()
globalMapUpdatePlayer();
mPlayerArrowGlobal->setImageTexture ("textures\\compass.dds");
}
}
void MapWindow::globalMapUpdatePlayer ()
{
void MapWindow::globalMapUpdatePlayer ()
{
Ogre::Vector3 pos = MWBase::Environment::get().getWorld ()->getPlayer ().getPlayer().getRefData ().getBaseNode ()->_getDerivedPosition ();
Ogre::Quaternion orient = MWBase::Environment::get().getWorld ()->getPlayer ().getPlayer().getRefData ().getBaseNode ()->_getDerivedOrientation ();
Ogre::Vector2 dir (orient.yAxis ().x, orient.yAxis().y);
@ -420,15 +421,15 @@ void MapWindow::globalMapUpdatePlayer ()
MyGUI::IntPoint viewoffs(0.5*viewsize.width - worldX, 0.5*viewsize.height - worldY);
mGlobalMap->setViewOffset(viewoffs);
}
}
}
void MapWindow::notifyPlayerUpdate ()
{
void MapWindow::notifyPlayerUpdate ()
{
globalMapUpdatePlayer ();
}
}
void MapWindow::notifyMapChanged ()
{
void MapWindow::notifyMapChanged ()
{
// workaround to prevent the map from drawing on top of the button
MyGUI::IntCoord oldCoord = mButton->getCoord ();
MyGUI::Gui::getInstance().destroyWidget (mButton);
@ -439,4 +440,6 @@ void MapWindow::notifyMapChanged ()
mButton->eventMouseButtonClick += MyGUI::newDelegate(this, &MapWindow::onWorldButtonClicked);
mButton->setCaptionWithReplacing( mGlobal ? "#{sLocal}" :
"#{sWorld}");
}
}

111
apps/openmw/mwgui/messagebox.cpp
View file

@ -5,17 +5,18 @@
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/inputmanager.hpp"
using namespace MWGui;
MessageBoxManager::MessageBoxManager ()
namespace MWGui
{
MessageBoxManager::MessageBoxManager ()
{
// defines
mMessageBoxSpeed = 0.1;
mInterMessageBoxe = NULL;
}
}
void MessageBoxManager::onFrame (float frameDuration)
{
void MessageBoxManager::onFrame (float frameDuration)
{
std::vector<MessageBoxManagerTimer>::iterator it;
for(it = mTimers.begin(); it != mTimers.end();)
{
@ -65,10 +66,10 @@ void MessageBoxManager::onFrame (float frameDuration)
MWBase::Environment::get().getInputManager()->changeInputMode(
MWBase::Environment::get().getWindowManager()->isGuiMode());
}
}
}
void MessageBoxManager::createMessageBox (const std::string& message)
{
void MessageBoxManager::createMessageBox (const std::string& message)
{
MessageBox *box = new MessageBox(*this, message);
removeMessageBox(message.length()*mMessageBoxSpeed, box);
@ -87,10 +88,10 @@ void MessageBoxManager::createMessageBox (const std::string& message)
(*it)->update(height);
height += (*it)->getHeight();
}
}
}
bool MessageBoxManager::createInteractiveMessageBox (const std::string& message, const std::vector<std::string>& buttons)
{
bool MessageBoxManager::createInteractiveMessageBox (const std::string& message, const std::vector<std::string>& buttons)
{
if(mInterMessageBoxe != NULL) {
throw std::runtime_error("There is a message box already");
}
@ -98,25 +99,25 @@ bool MessageBoxManager::createInteractiveMessageBox (const std::string& message,
mInterMessageBoxe = new InteractiveMessageBox(*this, message, buttons);
return true;
}
}
bool MessageBoxManager::isInteractiveMessageBox ()
{
bool MessageBoxManager::isInteractiveMessageBox ()
{
return mInterMessageBoxe != NULL;
}
}
void MessageBoxManager::removeMessageBox (float time, MessageBox *msgbox)
{
void MessageBoxManager::removeMessageBox (float time, MessageBox *msgbox)
{
MessageBoxManagerTimer timer;
timer.current = 0;
timer.max = time;
timer.messageBox = msgbox;
mTimers.insert(mTimers.end(), timer);
}
}
bool MessageBoxManager::removeMessageBox (MessageBox *msgbox)
{
bool MessageBoxManager::removeMessageBox (MessageBox *msgbox)
{
std::vector<MessageBox*>::iterator it;
for(it = mMessageBoxes.begin(); it != mMessageBoxes.end(); ++it)
{
@ -128,36 +129,36 @@ bool MessageBoxManager::removeMessageBox (MessageBox *msgbox)
}
}
return false;
}
}
void MessageBoxManager::setMessageBoxSpeed (int speed)
{
void MessageBoxManager::setMessageBoxSpeed (int speed)
{
mMessageBoxSpeed = speed;
}
}
void MessageBoxManager::enterPressed ()
{
void MessageBoxManager::enterPressed ()
{
if(mInterMessageBoxe != NULL)
mInterMessageBoxe->enterPressed();
}
}
int MessageBoxManager::readPressedButton ()
{
int MessageBoxManager::readPressedButton ()
{
if(mInterMessageBoxe != NULL)
{
return mInterMessageBoxe->readPressedButton();
}
return -1;
}
}
MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message)
MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message)
: Layout("openmw_messagebox.layout")
, mMessageBoxManager(parMessageBoxManager)
, mMessage(message)
{
{
// defines
mFixedWidth = 300;
mBottomPadding = 20;
@ -186,10 +187,10 @@ MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::strin
mMainWidget->setSize(size);
size.width -= 15; // this is to center the text (see messagebox.layout, Widget type="Edit" position="-2 -3 0 0")
mMessageWidget->setSize(size);
}
}
void MessageBox::update (int height)
{
void MessageBox::update (int height)
{
MyGUI::IntSize gameWindowSize = MyGUI::RenderManager::getInstance().getViewSize();
MyGUI::IntCoord coord;
coord.left = (gameWindowSize.width - mFixedWidth)/2;
@ -202,20 +203,20 @@ void MessageBox::update (int height)
mMainWidget->setCoord(coord);
mMainWidget->setSize(size);
mMainWidget->setVisible(true);
}
}
int MessageBox::getHeight ()
{
int MessageBox::getHeight ()
{
return mHeight+mNextBoxPadding; // 20 is the padding between this and the next MessageBox
}
}
InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message, const std::vector<std::string>& buttons)
InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message, const std::vector<std::string>& buttons)
: WindowModal("openmw_interactive_messagebox.layout")
, mMessageBoxManager(parMessageBoxManager)
, mButtonPressed(-1)
{
{
WindowModal::open();
int fixedWidth = 500;
@ -366,10 +367,10 @@ InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxMan
}
}
}
}
void InteractiveMessageBox::enterPressed()
{
void InteractiveMessageBox::enterPressed()
{
std::string ok = Misc::StringUtils::lowerCase(MyGUI::LanguageManager::getInstance().replaceTags("#{sOK}"));
std::vector<MyGUI::Button*>::const_iterator button;
@ -383,15 +384,15 @@ void InteractiveMessageBox::enterPressed()
}
}
}
}
void InteractiveMessageBox::mousePressed (MyGUI::Widget* pressed)
{
void InteractiveMessageBox::mousePressed (MyGUI::Widget* pressed)
{
buttonActivated (pressed);
}
}
void InteractiveMessageBox::buttonActivated (MyGUI::Widget* pressed)
{
void InteractiveMessageBox::buttonActivated (MyGUI::Widget* pressed)
{
mMarkedToDelete = true;
int index = 0;
std::vector<MyGUI::Button*>::const_iterator button;
@ -405,11 +406,13 @@ void InteractiveMessageBox::buttonActivated (MyGUI::Widget* pressed)
}
index++;
}
}
}
int InteractiveMessageBox::readPressedButton ()
{
int InteractiveMessageBox::readPressedButton ()
{
int pressed = mButtonPressed;
mButtonPressed = -1;
return pressed;
}
}

151
apps/openmw/mwgui/race.cpp
View file

@ -10,29 +10,29 @@
#include "tooltips.hpp"
using namespace MWGui;
using namespace Widgets;
namespace
{
int wrap(int index, int max)
{
int wrap(int index, int max)
{
if (index < 0)
return max - 1;
else if (index >= max)
return 0;
else
return index;
}
}
}
RaceDialog::RaceDialog()
namespace MWGui
{
RaceDialog::RaceDialog()
: WindowModal("openmw_chargen_race.layout")
, mGenderIndex(0)
, mFaceIndex(0)
, mHairIndex(0)
, mCurrentAngle(0)
{
{
// Centre dialog
center();
@ -90,10 +90,10 @@ RaceDialog::RaceDialog()
updateRaces();
updateSkills();
updateSpellPowers();
}
}
void RaceDialog::setNextButtonShow(bool shown)
{
void RaceDialog::setNextButtonShow(bool shown)
{
MyGUI::Button* okButton;
getWidget(okButton, "OKButton");
@ -101,10 +101,10 @@ void RaceDialog::setNextButtonShow(bool shown)
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sNext", ""));
else
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sOK", ""));
}
}
void RaceDialog::open()
{
void RaceDialog::open()
{
WindowModal::open();
updateRaces();
@ -126,11 +126,11 @@ void RaceDialog::open()
mHairIndex = boost::lexical_cast<int>(index) - 1;
mPreviewImage->setImageTexture ("CharacterHeadPreview");
}
}
void RaceDialog::setRaceId(const std::string &raceId)
{
void RaceDialog::setRaceId(const std::string &raceId)
{
mCurrentRaceId = raceId;
mRaceList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = mRaceList->getItemCount();
@ -147,78 +147,78 @@ void RaceDialog::setRaceId(const std::string &raceId)
updateSkills();
updateSpellPowers();
}
}
void RaceDialog::close()
{
void RaceDialog::close()
{
delete mPreview;
mPreview = 0;
}
}
// widget controls
// widget controls
void RaceDialog::onOkClicked(MyGUI::Widget* _sender)
{
void RaceDialog::onOkClicked(MyGUI::Widget* _sender)
{
if(mRaceList->getIndexSelected() == MyGUI::ITEM_NONE)
return;
eventDone(this);
}
}
void RaceDialog::onBackClicked(MyGUI::Widget* _sender)
{
void RaceDialog::onBackClicked(MyGUI::Widget* _sender)
{
eventBack();
}
}
void RaceDialog::onHeadRotate(MyGUI::ScrollBar*, size_t _position)
{
void RaceDialog::onHeadRotate(MyGUI::ScrollBar*, size_t _position)
{
float angle = (float(_position) / 49.f - 0.5) * 3.14 * 2;
float diff = angle - mCurrentAngle;
mPreview->update (diff);
mCurrentAngle += diff;
}
}
void RaceDialog::onSelectPreviousGender(MyGUI::Widget*)
{
void RaceDialog::onSelectPreviousGender(MyGUI::Widget*)
{
mGenderIndex = wrap(mGenderIndex - 1, 2);
recountParts();
updatePreview();
}
}
void RaceDialog::onSelectNextGender(MyGUI::Widget*)
{
void RaceDialog::onSelectNextGender(MyGUI::Widget*)
{
mGenderIndex = wrap(mGenderIndex + 1, 2);
recountParts();
updatePreview();
}
}
void RaceDialog::onSelectPreviousFace(MyGUI::Widget*)
{
void RaceDialog::onSelectPreviousFace(MyGUI::Widget*)
{
mFaceIndex = wrap(mFaceIndex - 1, mAvailableHeads.size());
updatePreview();
}
}
void RaceDialog::onSelectNextFace(MyGUI::Widget*)
{
void RaceDialog::onSelectNextFace(MyGUI::Widget*)
{
mFaceIndex = wrap(mFaceIndex + 1, mAvailableHeads.size());
updatePreview();
}
}
void RaceDialog::onSelectPreviousHair(MyGUI::Widget*)
{
void RaceDialog::onSelectPreviousHair(MyGUI::Widget*)
{
mHairIndex = wrap(mHairIndex - 1, mAvailableHairs.size());
updatePreview();
}
}
void RaceDialog::onSelectNextHair(MyGUI::Widget*)
{
void RaceDialog::onSelectNextHair(MyGUI::Widget*)
{
mHairIndex = wrap(mHairIndex + 1, mAvailableHairs.size());
updatePreview();
}
}
void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
{
void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
{
if (_index == MyGUI::ITEM_NONE)
return;
@ -235,10 +235,10 @@ void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
updatePreview();
updateSkills();
updateSpellPowers();
}
}
void RaceDialog::getBodyParts (int part, std::vector<std::string>& out)
{
void RaceDialog::getBodyParts (int part, std::vector<std::string>& out)
{
out.clear();
const MWWorld::Store<ESM::BodyPart> &store =
MWBase::Environment::get().getWorld()->getStore().get<ESM::BodyPart>();
@ -263,21 +263,21 @@ void RaceDialog::getBodyParts (int part, std::vector<std::string>& out)
if (Misc::StringUtils::ciEqual(bodypart.mRace, mCurrentRaceId))
out.push_back(bodypart.mId);
}
}
}
void RaceDialog::recountParts()
{
void RaceDialog::recountParts()
{
getBodyParts(ESM::BodyPart::MP_Hair, mAvailableHairs);
getBodyParts(ESM::BodyPart::MP_Head, mAvailableHeads);
mFaceIndex = 0;
mHairIndex = 0;
}
}
// update widget content
// update widget content
void RaceDialog::updatePreview()
{
void RaceDialog::updatePreview()
{
ESM::NPC record = mPreview->getPrototype();
record.mRace = mCurrentRaceId;
record.setIsMale(mGenderIndex == 0);
@ -286,10 +286,10 @@ void RaceDialog::updatePreview()
record.mHair = mAvailableHairs[mHairIndex];
mPreview->setPrototype(record);
}
}
void RaceDialog::updateRaces()
{
void RaceDialog::updateRaces()
{
mRaceList->removeAllItems();
const MWWorld::Store<ESM::Race> &races =
@ -309,10 +309,10 @@ void RaceDialog::updateRaces()
mRaceList->setIndexSelected(index);
++index;
}
}
}
void RaceDialog::updateSkills()
{
void RaceDialog::updateSkills()
{
for (std::vector<MyGUI::Widget*>::iterator it = mSkillItems.begin(); it != mSkillItems.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
@ -322,7 +322,7 @@ void RaceDialog::updateSkills()
if (mCurrentRaceId.empty())
return;
MWSkillPtr skillWidget;
Widgets::MWSkillPtr skillWidget;
const int lineHeight = 18;
MyGUI::IntCoord coord1(0, 0, mSkillList->getWidth(), 18);
@ -335,10 +335,10 @@ void RaceDialog::updateSkills()
if (skillId < 0 || skillId > ESM::Skill::Length) // Skip unknown skill indexes
continue;
skillWidget = mSkillList->createWidget<MWSkill>("MW_StatNameValue", coord1, MyGUI::Align::Default,
skillWidget = mSkillList->createWidget<Widgets::MWSkill>("MW_StatNameValue", coord1, MyGUI::Align::Default,
std::string("Skill") + boost::lexical_cast<std::string>(i));
skillWidget->setSkillNumber(skillId);
skillWidget->setSkillValue(MWSkill::SkillValue(race->mData.mBonus[i].mBonus));
skillWidget->setSkillValue(Widgets::MWSkill::SkillValue(race->mData.mBonus[i].mBonus));
ToolTips::createSkillToolTip(skillWidget, skillId);
@ -346,10 +346,10 @@ void RaceDialog::updateSkills()
coord1.top += lineHeight;
}
}
}
void RaceDialog::updateSpellPowers()
{
void RaceDialog::updateSpellPowers()
{
for (std::vector<MyGUI::Widget*>::iterator it = mSpellPowerItems.begin(); it != mSpellPowerItems.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
@ -359,7 +359,7 @@ void RaceDialog::updateSpellPowers()
if (mCurrentRaceId.empty())
return;
MWSpellPtr spellPowerWidget;
Widgets::MWSpellPtr spellPowerWidget;
const int lineHeight = 18;
MyGUI::IntCoord coord(0, 0, mSpellPowerList->getWidth(), 18);
@ -371,7 +371,7 @@ void RaceDialog::updateSpellPowers()
for (int i = 0; it != end; ++it)
{
const std::string &spellpower = *it;
spellPowerWidget = mSpellPowerList->createWidget<MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("SpellPower") + boost::lexical_cast<std::string>(i));
spellPowerWidget = mSpellPowerList->createWidget<Widgets::MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("SpellPower") + boost::lexical_cast<std::string>(i));
spellPowerWidget->setSpellId(spellpower);
spellPowerWidget->setUserString("ToolTipType", "Spell");
spellPowerWidget->setUserString("Spell", spellpower);
@ -381,4 +381,5 @@ void RaceDialog::updateSpellPowers()
coord.top += lineHeight;
++i;
}
}
}

164
apps/openmw/mwgui/review.cpp
View file

@ -11,15 +11,15 @@
#undef min
#undef max
using namespace MWGui;
using namespace Widgets;
namespace MWGui
{
const int ReviewDialog::sLineHeight = 18;
const int ReviewDialog::sLineHeight = 18;
ReviewDialog::ReviewDialog()
ReviewDialog::ReviewDialog()
: WindowModal("openmw_chargen_review.layout")
, mLastPos(0)
{
{
// Centre dialog
center();
@ -60,13 +60,13 @@ ReviewDialog::ReviewDialog()
// Setup attributes
MWAttributePtr attribute;
Widgets::MWAttributePtr attribute;
for (int idx = 0; idx < ESM::Attribute::Length; ++idx)
{
getWidget(attribute, std::string("Attribute") + boost::lexical_cast<std::string>(idx));
mAttributeWidgets.insert(std::make_pair(static_cast<int>(ESM::Attribute::sAttributeIds[idx]), attribute));
attribute->setAttributeId(ESM::Attribute::sAttributeIds[idx]);
attribute->setAttributeValue(MWAttribute::AttributeValue(0, 0));
attribute->setAttributeValue(Widgets::MWAttribute::AttributeValue(0, 0));
}
// Setup skills
@ -86,21 +86,21 @@ ReviewDialog::ReviewDialog()
MyGUI::Button* okButton;
getWidget(okButton, "OKButton");
okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onOkClicked);
}
}
void ReviewDialog::open()
{
void ReviewDialog::open()
{
WindowModal::open();
updateSkillArea();
}
}
void ReviewDialog::setPlayerName(const std::string &name)
{
void ReviewDialog::setPlayerName(const std::string &name)
{
mNameWidget->setCaption(name);
}
}
void ReviewDialog::setRace(const std::string &raceId)
{
void ReviewDialog::setRace(const std::string &raceId)
{
mRaceId = raceId;
const ESM::Race *race =
@ -110,17 +110,17 @@ void ReviewDialog::setRace(const std::string &raceId)
ToolTips::createRaceToolTip(mRaceWidget, race);
mRaceWidget->setCaption(race->mName);
}
}
}
void ReviewDialog::setClass(const ESM::Class& class_)
{
void ReviewDialog::setClass(const ESM::Class& class_)
{
mKlass = class_;
mClassWidget->setCaption(mKlass.mName);
ToolTips::createClassToolTip(mClassWidget, mKlass);
}
}
void ReviewDialog::setBirthSign(const std::string& signId)
{
void ReviewDialog::setBirthSign(const std::string& signId)
{
mBirthSignId = signId;
const ESM::BirthSign *sign =
@ -130,40 +130,40 @@ void ReviewDialog::setBirthSign(const std::string& signId)
mBirthSignWidget->setCaption(sign->mName);
ToolTips::createBirthsignToolTip(mBirthSignWidget, mBirthSignId);
}
}
}
void ReviewDialog::setHealth(const MWMechanics::DynamicStat<float>& value)
{
void ReviewDialog::setHealth(const MWMechanics::DynamicStat<float>& value)
{
mHealth->setValue(value.getCurrent(), value.getModified());
std::string valStr = boost::lexical_cast<std::string>(value.getCurrent()) + "/" + boost::lexical_cast<std::string>(value.getModified());
mHealth->setUserString("Caption_HealthDescription", "#{sHealthDesc}\n" + valStr);
}
}
void ReviewDialog::setMagicka(const MWMechanics::DynamicStat<float>& value)
{
void ReviewDialog::setMagicka(const MWMechanics::DynamicStat<float>& value)
{
mMagicka->setValue(value.getCurrent(), value.getModified());
std::string valStr = boost::lexical_cast<std::string>(value.getCurrent()) + "/" + boost::lexical_cast<std::string>(value.getModified());
mMagicka->setUserString("Caption_HealthDescription", "#{sIntDesc}\n" + valStr);
}
}
void ReviewDialog::setFatigue(const MWMechanics::DynamicStat<float>& value)
{
void ReviewDialog::setFatigue(const MWMechanics::DynamicStat<float>& value)
{
mFatigue->setValue(value.getCurrent(), value.getModified());
std::string valStr = boost::lexical_cast<std::string>(value.getCurrent()) + "/" + boost::lexical_cast<std::string>(value.getModified());
mFatigue->setUserString("Caption_HealthDescription", "#{sFatDesc}\n" + valStr);
}
}
void ReviewDialog::setAttribute(ESM::Attribute::AttributeID attributeId, const MWMechanics::Stat<int>& value)
{
std::map<int, MWAttributePtr>::iterator attr = mAttributeWidgets.find(static_cast<int>(attributeId));
void ReviewDialog::setAttribute(ESM::Attribute::AttributeID attributeId, const MWMechanics::Stat<int>& value)
{
std::map<int, Widgets::MWAttributePtr>::iterator attr = mAttributeWidgets.find(static_cast<int>(attributeId));
if (attr == mAttributeWidgets.end())
return;
attr->second->setAttributeValue(value);
}
}
void ReviewDialog::setSkillValue(ESM::Skill::SkillEnum skillId, const MWMechanics::Stat<float>& value)
{
void ReviewDialog::setSkillValue(ESM::Skill::SkillEnum skillId, const MWMechanics::Stat<float>& value)
{
mSkillValues[skillId] = value;
MyGUI::TextBox* widget = mSkillWidgetMap[skillId];
if (widget)
@ -180,10 +180,10 @@ void ReviewDialog::setSkillValue(ESM::Skill::SkillEnum skillId, const MWMechanic
widget->_setWidgetState(state);
}
}
}
void ReviewDialog::configureSkills(const std::vector<int>& major, const std::vector<int>& minor)
{
void ReviewDialog::configureSkills(const std::vector<int>& major, const std::vector<int>& minor)
{
mMajorSkills = major;
mMinorSkills = minor;
@ -201,10 +201,10 @@ void ReviewDialog::configureSkills(const std::vector<int>& major, const std::vec
}
updateSkillArea();
}
}
void ReviewDialog::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
void ReviewDialog::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::ImageBox* separator = mSkillView->createWidget<MyGUI::ImageBox>("MW_HLine", MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18), MyGUI::Align::Default);
separator->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
@ -212,10 +212,10 @@ void ReviewDialog::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2
coord1.top += separator->getHeight();
coord2.top += separator->getHeight();
}
}
void ReviewDialog::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
void ReviewDialog::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* groupWidget = mSkillView->createWidget<MyGUI::TextBox>("SandBrightText", MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height), MyGUI::Align::Default);
groupWidget->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
groupWidget->setCaption(label);
@ -223,10 +223,10 @@ void ReviewDialog::addGroup(const std::string &label, MyGUI::IntCoord &coord1, M
coord1.top += sLineHeight;
coord2.top += sLineHeight;
}
}
MyGUI::TextBox* ReviewDialog::addValueItem(const std::string& text, const std::string &value, const std::string& state, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* ReviewDialog::addValueItem(const std::string& text, const std::string &value, const std::string& state, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* skillNameWidget;
MyGUI::TextBox* skillValueWidget;
@ -246,10 +246,10 @@ MyGUI::TextBox* ReviewDialog::addValueItem(const std::string& text, const std::s
coord2.top += sLineHeight;
return skillValueWidget;
}
}
void ReviewDialog::addItem(const std::string& text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
void ReviewDialog::addItem(const std::string& text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* skillNameWidget;
skillNameWidget = mSkillView->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
@ -260,10 +260,10 @@ void ReviewDialog::addItem(const std::string& text, MyGUI::IntCoord &coord1, MyG
coord1.top += sLineHeight;
coord2.top += sLineHeight;
}
}
void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
// Add a line separator if there are items above
if (!mSkillWidgets.empty())
{
@ -298,10 +298,10 @@ void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId
mSkillWidgetMap[skillId] = widget;
}
}
}
void ReviewDialog::updateSkillArea()
{
void ReviewDialog::updateSkillArea()
{
for (std::vector<MyGUI::Widget*>::iterator it = mSkillWidgets.begin(); it != mSkillWidgets.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
@ -324,44 +324,46 @@ void ReviewDialog::updateSkillArea()
mClientHeight = coord1.top;
mSkillView->setCanvasSize (mSkillView->getWidth(), std::max(mSkillView->getHeight(), mClientHeight));
}
}
// widget controls
// widget controls
void ReviewDialog::onOkClicked(MyGUI::Widget* _sender)
{
void ReviewDialog::onOkClicked(MyGUI::Widget* _sender)
{
eventDone(this);
}
}
void ReviewDialog::onBackClicked(MyGUI::Widget* _sender)
{
void ReviewDialog::onBackClicked(MyGUI::Widget* _sender)
{
eventBack();
}
}
void ReviewDialog::onNameClicked(MyGUI::Widget* _sender)
{
void ReviewDialog::onNameClicked(MyGUI::Widget* _sender)
{
eventActivateDialog(NAME_DIALOG);
}
}
void ReviewDialog::onRaceClicked(MyGUI::Widget* _sender)
{
void ReviewDialog::onRaceClicked(MyGUI::Widget* _sender)
{
eventActivateDialog(RACE_DIALOG);
}
}
void ReviewDialog::onClassClicked(MyGUI::Widget* _sender)
{
void ReviewDialog::onClassClicked(MyGUI::Widget* _sender)
{
eventActivateDialog(CLASS_DIALOG);
}
}
void ReviewDialog::onBirthSignClicked(MyGUI::Widget* _sender)
{
void ReviewDialog::onBirthSignClicked(MyGUI::Widget* _sender)
{
eventActivateDialog(BIRTHSIGN_DIALOG);
}
}
void ReviewDialog::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
void ReviewDialog::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
if (mSkillView->getViewOffset().top + _rel*0.3 > 0)
mSkillView->setViewOffset(MyGUI::IntPoint(0, 0));
else
mSkillView->setViewOffset(MyGUI::IntPoint(0, mSkillView->getViewOffset().top + _rel*0.3));
}
}

38
apps/openmw/mwgui/scrollwindow.cpp
View file

@ -10,13 +10,14 @@
#include "formatting.hpp"
using namespace MWGui;
namespace MWGui
{
ScrollWindow::ScrollWindow ()
ScrollWindow::ScrollWindow ()
: WindowBase("openmw_scroll.layout")
, mTakeButtonShow(true)
, mTakeButtonAllowed(true)
{
{
getWidget(mTextView, "TextView");
getWidget(mCloseButton, "CloseButton");
@ -26,10 +27,10 @@ ScrollWindow::ScrollWindow ()
mTakeButton->eventMouseButtonClick += MyGUI::newDelegate(this, &ScrollWindow::onTakeButtonClicked);
center();
}
}
void ScrollWindow::open (MWWorld::Ptr scroll)
{
void ScrollWindow::open (MWWorld::Ptr scroll)
{
// no 3d sounds because the object could be in a container.
MWBase::Environment::get().getSoundManager()->playSound ("scroll", 1.0, 1.0);
@ -48,33 +49,34 @@ void ScrollWindow::open (MWWorld::Ptr scroll)
mTextView->setViewOffset(MyGUI::IntPoint(0,0));
setTakeButtonShow(true);
}
}
void ScrollWindow::setTakeButtonShow(bool show)
{
void ScrollWindow::setTakeButtonShow(bool show)
{
mTakeButtonShow = show;
mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
}
}
void ScrollWindow::setInventoryAllowed(bool allowed)
{
void ScrollWindow::setInventoryAllowed(bool allowed)
{
mTakeButtonAllowed = allowed;
mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
}
}
void ScrollWindow::onCloseButtonClicked (MyGUI::Widget* _sender)
{
void ScrollWindow::onCloseButtonClicked (MyGUI::Widget* _sender)
{
MWBase::Environment::get().getSoundManager()->playSound ("scroll", 1.0, 1.0);
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Scroll);
}
}
void ScrollWindow::onTakeButtonClicked (MyGUI::Widget* _sender)
{
void ScrollWindow::onTakeButtonClicked (MyGUI::Widget* _sender)
{
MWBase::Environment::get().getSoundManager()->playSound ("Item Book Up", 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
MWWorld::ActionTake take(mScroll);
take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Scroll);
}
}

137
apps/openmw/mwgui/statswindow.cpp
View file

@ -13,10 +13,12 @@
#include "tooltips.hpp"
using namespace MWGui;
const int StatsWindow::sLineHeight = 18;
namespace MWGui
{
StatsWindow::StatsWindow ()
const int StatsWindow::sLineHeight = 18;
StatsWindow::StatsWindow ()
: WindowPinnableBase("openmw_stats_window.layout")
, mSkillView(NULL)
, mClientHeight(0)
@ -32,7 +34,7 @@ StatsWindow::StatsWindow ()
, mBounty(0)
, mSkillWidgets()
, mChanged(true)
{
{
setCoord(0,0,498, 342);
const char *names[][2] =
@ -66,25 +68,25 @@ StatsWindow::StatsWindow ()
MyGUI::WindowPtr t = static_cast<MyGUI::WindowPtr>(mMainWidget);
t->eventWindowChangeCoord += MyGUI::newDelegate(this, &StatsWindow::onWindowResize);
}
}
void StatsWindow::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
void StatsWindow::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
if (mSkillView->getViewOffset().top + _rel*0.3 > 0)
mSkillView->setViewOffset(MyGUI::IntPoint(0, 0));
else
mSkillView->setViewOffset(MyGUI::IntPoint(0, mSkillView->getViewOffset().top + _rel*0.3));
}
}
void StatsWindow::onWindowResize(MyGUI::Window* window)
{
void StatsWindow::onWindowResize(MyGUI::Window* window)
{
mLeftPane->setCoord( MyGUI::IntCoord(0, 0, 0.44*window->getSize().width, window->getSize().height) );
mRightPane->setCoord( MyGUI::IntCoord(0.44*window->getSize().width, 0, 0.56*window->getSize().width, window->getSize().height) );
mSkillView->setCanvasSize (mSkillView->getWidth(), std::max(mSkillView->getHeight(), mClientHeight));
}
}
void StatsWindow::setBar(const std::string& name, const std::string& tname, int val, int max)
{
void StatsWindow::setBar(const std::string& name, const std::string& tname, int val, int max)
{
MyGUI::ProgressPtr pt;
getWidget(pt, name);
pt->setProgressRange(max);
@ -93,16 +95,16 @@ void StatsWindow::setBar(const std::string& name, const std::string& tname, int
std::stringstream out;
out << val << "/" << max;
setText(tname, out.str().c_str());
}
}
void StatsWindow::setPlayerName(const std::string& playerName)
{
void StatsWindow::setPlayerName(const std::string& playerName)
{
static_cast<MyGUI::Window*>(mMainWidget)->setCaption(playerName);
adjustWindowCaption();
}
}
void StatsWindow::setValue (const std::string& id, const MWMechanics::Stat<int>& value)
{
void StatsWindow::setValue (const std::string& id, const MWMechanics::Stat<int>& value)
{
static const char *ids[] =
{
"AttribVal1", "AttribVal2", "AttribVal3", "AttribVal4", "AttribVal5",
@ -129,10 +131,10 @@ void StatsWindow::setValue (const std::string& id, const MWMechanics::Stat<int>&
break;
}
}
}
void StatsWindow::setValue (const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
void StatsWindow::setValue (const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
static const char *ids[] =
{
"HBar", "MBar", "FBar",
@ -166,30 +168,30 @@ void StatsWindow::setValue (const std::string& id, const MWMechanics::DynamicSta
}
}
}
}
}
void StatsWindow::setValue (const std::string& id, const std::string& value)
{
void StatsWindow::setValue (const std::string& id, const std::string& value)
{
if (id=="name")
setPlayerName (value);
else if (id=="race")
setText ("RaceText", value);
else if (id=="class")
setText ("ClassText", value);
}
}
void StatsWindow::setValue (const std::string& id, int value)
{
void StatsWindow::setValue (const std::string& id, int value)
{
if (id=="level")
{
std::ostringstream text;
text << value;
setText("LevelText", text.str());
}
}
}
void StatsWindow::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechanics::Stat<float>& value)
{
void StatsWindow::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechanics::Stat<float>& value)
{
mSkillValues[parSkill] = value;
MyGUI::TextBox* widget = mSkillWidgetMap[(int)parSkill];
if (widget)
@ -205,10 +207,10 @@ void StatsWindow::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechani
widget->setCaption(text);
widget->_setWidgetState(state);
}
}
}
void StatsWindow::configureSkills (const std::vector<int>& major, const std::vector<int>& minor)
{
void StatsWindow::configureSkills (const std::vector<int>& major, const std::vector<int>& minor)
{
mMajorSkills = major;
mMinorSkills = minor;
@ -226,10 +228,10 @@ void StatsWindow::configureSkills (const std::vector<int>& major, const std::vec
}
updateSkillArea();
}
}
void StatsWindow::onFrame ()
{
void StatsWindow::onFrame ()
{
if (!mMainWidget->getVisible())
return;
@ -257,37 +259,37 @@ void StatsWindow::onFrame ()
if (mChanged)
updateSkillArea();
}
}
void StatsWindow::setFactions (const FactionList& factions)
{
void StatsWindow::setFactions (const FactionList& factions)
{
if (mFactions != factions)
{
mFactions = factions;
mChanged = true;
}
}
}
void StatsWindow::setExpelled (const std::set<std::string>& expelled)
{
void StatsWindow::setExpelled (const std::set<std::string>& expelled)
{
if (mExpelled != expelled)
{
mExpelled = expelled;
mChanged = true;
}
}
}
void StatsWindow::setBirthSign (const std::string& signId)
{
void StatsWindow::setBirthSign (const std::string& signId)
{
if (signId != mBirthSignId)
{
mBirthSignId = signId;
mChanged = true;
}
}
}
void StatsWindow::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
void StatsWindow::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::ImageBox* separator = mSkillView->createWidget<MyGUI::ImageBox>("MW_HLine",
MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18),
MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
@ -296,10 +298,10 @@ void StatsWindow::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
coord1.top += separator->getHeight();
coord2.top += separator->getHeight();
}
}
void StatsWindow::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
void StatsWindow::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* groupWidget = mSkillView->createWidget<MyGUI::TextBox>("SandBrightText",
MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height),
MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
@ -309,10 +311,10 @@ void StatsWindow::addGroup(const std::string &label, MyGUI::IntCoord &coord1, My
coord1.top += sLineHeight;
coord2.top += sLineHeight;
}
}
MyGUI::TextBox* StatsWindow::addValueItem(const std::string& text, const std::string &value, const std::string& state, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* StatsWindow::addValueItem(const std::string& text, const std::string &value, const std::string& state, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox *skillNameWidget, *skillValueWidget;
skillNameWidget = mSkillView->createWidget<MyGUI::TextBox>("SandText", coord1, MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
@ -331,10 +333,10 @@ MyGUI::TextBox* StatsWindow::addValueItem(const std::string& text, const std::st
coord2.top += sLineHeight;
return skillValueWidget;
}
}
MyGUI::Widget* StatsWindow::addItem(const std::string& text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::Widget* StatsWindow::addItem(const std::string& text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* skillNameWidget;
skillNameWidget = mSkillView->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
@ -347,10 +349,10 @@ MyGUI::Widget* StatsWindow::addItem(const std::string& text, MyGUI::IntCoord &co
coord2.top += sLineHeight;
return skillNameWidget;
}
}
void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
// Add a line separator if there are items above
if (!mSkillWidgets.empty())
{
@ -407,10 +409,10 @@ void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId,
mSkillWidgetMap[skillId] = widget;
}
}
}
void StatsWindow::updateSkillArea()
{
void StatsWindow::updateSkillArea()
{
mChanged = false;
for (std::vector<MyGUI::Widget*>::iterator it = mSkillWidgets.begin(); it != mSkillWidgets.end(); ++it)
@ -566,9 +568,10 @@ void StatsWindow::updateSkillArea()
mClientHeight = coord1.top;
mSkillView->setCanvasSize (mSkillView->getWidth(), std::max(mSkillView->getHeight(), mClientHeight));
}
}
void StatsWindow::onPinToggled()
{
void StatsWindow::onPinToggled()
{
MWBase::Environment::get().getWindowManager()->setHMSVisibility(!mPinned);
}
}

43
apps/openmw/mwgui/textinput.cpp
View file

@ -3,11 +3,12 @@
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/environment.hpp"
using namespace MWGui;
TextInputDialog::TextInputDialog()
: WindowModal("openmw_text_input.layout")
namespace MWGui
{
TextInputDialog::TextInputDialog()
: WindowModal("openmw_text_input.layout")
{
// Centre dialog
center();
@ -20,10 +21,10 @@ TextInputDialog::TextInputDialog()
// Make sure the edit box has focus
MyGUI::InputManager::getInstance().setKeyFocusWidget(mTextEdit);
}
}
void TextInputDialog::setNextButtonShow(bool shown)
{
void TextInputDialog::setNextButtonShow(bool shown)
{
MyGUI::Button* okButton;
getWidget(okButton, "OKButton");
@ -31,24 +32,24 @@ void TextInputDialog::setNextButtonShow(bool shown)
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sNext", ""));
else
okButton->setCaption(MWBase::Environment::get().getWindowManager()->getGameSettingString("sOK", ""));
}
}
void TextInputDialog::setTextLabel(const std::string &label)
{
void TextInputDialog::setTextLabel(const std::string &label)
{
setText("LabelT", label);
}
}
void TextInputDialog::open()
{
void TextInputDialog::open()
{
WindowModal::open();
// Make sure the edit box has focus
MyGUI::InputManager::getInstance().setKeyFocusWidget(mTextEdit);
}
}
// widget controls
// widget controls
void TextInputDialog::onOkClicked(MyGUI::Widget* _sender)
{
void TextInputDialog::onOkClicked(MyGUI::Widget* _sender)
{
if (mTextEdit->getCaption() == "")
{
MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage37}");
@ -56,10 +57,10 @@ void TextInputDialog::onOkClicked(MyGUI::Widget* _sender)
}
else
eventDone(this);
}
}
void TextInputDialog::onTextAccepted(MyGUI::Edit* _sender)
{
void TextInputDialog::onTextAccepted(MyGUI::Edit* _sender)
{
if (mTextEdit->getCaption() == "")
{
MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage37}");
@ -67,4 +68,6 @@ void TextInputDialog::onTextAccepted(MyGUI::Edit* _sender)
}
else
eventDone(this);
}
}

232
apps/openmw/mwgui/tooltips.cpp
View file

@ -9,10 +9,10 @@
#include "mapwindow.hpp"
#include "inventorywindow.hpp"
using namespace MWGui;
using namespace MyGUI;
namespace MWGui
{
ToolTips::ToolTips() :
ToolTips::ToolTips() :
Layout("openmw_tooltips.layout")
, mGameMode(true)
, mFullHelp(false)
@ -24,7 +24,7 @@ ToolTips::ToolTips() :
, mLastMouseX(0)
, mLastMouseY(0)
, mHorizontalScrollIndex(0)
{
{
getWidget(mDynamicToolTipBox, "DynamicToolTipBox");
mDynamicToolTipBox->setVisible(false);
@ -41,15 +41,15 @@ ToolTips::ToolTips() :
{
mMainWidget->getChildAt(i)->setVisible(false);
}
}
}
void ToolTips::setEnabled(bool enabled)
{
void ToolTips::setEnabled(bool enabled)
{
mEnabled = enabled;
}
}
void ToolTips::onFrame(float frameDuration)
{
void ToolTips::onFrame(float frameDuration)
{
while (mDynamicToolTipBox->getChildCount())
{
@ -62,7 +62,7 @@ void ToolTips::onFrame(float frameDuration)
mMainWidget->getChildAt(i)->setVisible(false);
}
const IntSize &viewSize = RenderManager::getInstance().getViewSize();
const MyGUI::IntSize &viewSize = MyGUI::RenderManager::getInstance().getViewSize();
if (!mEnabled)
{
@ -71,7 +71,7 @@ void ToolTips::onFrame(float frameDuration)
if (!mGameMode)
{
const MyGUI::IntPoint& mousePos = InputManager::getInstance().getMousePosition();
const MyGUI::IntPoint& mousePos = MyGUI::InputManager::getInstance().getMousePosition();
if (MWBase::Environment::get().getWindowManager()->getWorldMouseOver() && ((MWBase::Environment::get().getWindowManager()->getMode() == GM_Console)
|| (MWBase::Environment::get().getWindowManager()->getMode() == GM_Container)
@ -84,7 +84,7 @@ void ToolTips::onFrame(float frameDuration)
const MWWorld::Class& objectclass = MWWorld::Class::get (mFocusObject);
IntSize tooltipSize;
MyGUI::IntSize tooltipSize;
if ((!objectclass.hasToolTip(mFocusObject))&&(MWBase::Environment::get().getWindowManager()->getMode() == GM_Console))
{
setCoord(0, 0, 300, 300);
@ -97,7 +97,7 @@ void ToolTips::onFrame(float frameDuration)
else
tooltipSize = getToolTipViaPtr(true);
IntPoint tooltipPosition = InputManager::getInstance().getMousePosition() + IntPoint(0, 24);
MyGUI::IntPoint tooltipPosition = MyGUI::InputManager::getInstance().getMousePosition() + MyGUI::IntPoint(0, 24);
// make the tooltip stay completely in the viewport
if ((tooltipPosition.left + tooltipSize.width) > viewSize.width)
@ -114,7 +114,7 @@ void ToolTips::onFrame(float frameDuration)
else
{
const MyGUI::IntPoint& lastPressed = InputManager::getInstance().getLastPressedPosition(MyGUI::MouseButton::Left);
const MyGUI::IntPoint& lastPressed = MyGUI::InputManager::getInstance().getLastPressedPosition(MyGUI::MouseButton::Left);
if (mousePos == lastPressed) // mouseclick makes tooltip disappear
return;
@ -135,11 +135,11 @@ void ToolTips::onFrame(float frameDuration)
if (mRemainingDelay > 0)
return;
Widget* focus = InputManager::getInstance().getMouseFocusWidget();
MyGUI::Widget* focus = MyGUI::InputManager::getInstance().getMouseFocusWidget();
if (focus == 0)
return;
IntSize tooltipSize;
MyGUI::IntSize tooltipSize;
// try to go 1 level up until there is a widget that has tooltip
// this is necessary because some skin elements are actually separate widgets
@ -252,7 +252,7 @@ void ToolTips::onFrame(float frameDuration)
else
throw std::runtime_error ("unknown tooltip type");
IntPoint tooltipPosition = InputManager::getInstance().getMousePosition() + IntPoint(0, 24);
MyGUI::IntPoint tooltipPosition = MyGUI::InputManager::getInstance().getMousePosition() + MyGUI::IntPoint(0, 24);
// make the tooltip stay completely in the viewport
if ((tooltipPosition.left + tooltipSize.width) > viewSize.width)
@ -271,7 +271,7 @@ void ToolTips::onFrame(float frameDuration)
{
if (!mFocusObject.isEmpty())
{
IntSize tooltipSize = getToolTipViaPtr();
MyGUI::IntSize tooltipSize = getToolTipViaPtr();
setCoord(viewSize.width/2 - tooltipSize.width/2,
std::max(0, int(mFocusToolTipY*viewSize.height - tooltipSize.height)),
@ -281,29 +281,29 @@ void ToolTips::onFrame(float frameDuration)
mDynamicToolTipBox->setVisible(true);
}
}
}
}
void ToolTips::enterGameMode()
{
void ToolTips::enterGameMode()
{
mGameMode = true;
}
}
void ToolTips::enterGuiMode()
{
void ToolTips::enterGuiMode()
{
mGameMode = false;
}
}
void ToolTips::setFocusObject(const MWWorld::Ptr& focus)
{
void ToolTips::setFocusObject(const MWWorld::Ptr& focus)
{
mFocusObject = focus;
}
}
IntSize ToolTips::getToolTipViaPtr (bool image)
{
MyGUI::IntSize ToolTips::getToolTipViaPtr (bool image)
{
// this the maximum width of the tooltip before it starts word-wrapping
setCoord(0, 0, 300, 300);
IntSize tooltipSize;
MyGUI::IntSize tooltipSize;
const MWWorld::Class& object = MWWorld::Class::get (mFocusObject);
if (!object.hasToolTip(mFocusObject))
@ -321,10 +321,10 @@ IntSize ToolTips::getToolTipViaPtr (bool image)
}
return tooltipSize;
}
}
void ToolTips::findImageExtension(std::string& image)
{
void ToolTips::findImageExtension(std::string& image)
{
int len = image.size();
if (len < 4) return;
@ -335,10 +335,10 @@ void ToolTips::findImageExtension(std::string& image)
image[len-2] = 'd';
image[len-1] = 's';
}
}
}
IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
{
MyGUI::IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
{
mDynamicToolTipBox->setVisible(true);
std::string caption = info.caption;
@ -371,7 +371,7 @@ IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
// this the maximum width of the tooltip before it starts word-wrapping
setCoord(0, 0, 300, 300);
const IntPoint padding(8, 8);
const MyGUI::IntPoint padding(8, 8);
const int maximumWidth = 500;
@ -381,32 +381,32 @@ IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
std::string realImage = "icons\\" + image;
findImageExtension(realImage);
EditBox* captionWidget = mDynamicToolTipBox->createWidget<EditBox>("NormalText", IntCoord(0, 0, 300, 300), Align::Left | Align::Top, "ToolTipCaption");
MyGUI::EditBox* captionWidget = mDynamicToolTipBox->createWidget<MyGUI::EditBox>("NormalText", MyGUI::IntCoord(0, 0, 300, 300), MyGUI::Align::Left | MyGUI::Align::Top, "ToolTipCaption");
captionWidget->setProperty("Static", "true");
captionWidget->setCaptionWithReplacing(caption);
IntSize captionSize = captionWidget->getTextSize();
MyGUI::IntSize captionSize = captionWidget->getTextSize();
int captionHeight = std::max(caption != "" ? captionSize.height : 0, imageSize);
EditBox* textWidget = mDynamicToolTipBox->createWidget<EditBox>("SandText", IntCoord(0, captionHeight+imageCaptionVPadding, 300, 300-captionHeight-imageCaptionVPadding), Align::Stretch, "ToolTipText");
MyGUI::EditBox* textWidget = mDynamicToolTipBox->createWidget<MyGUI::EditBox>("SandText", MyGUI::IntCoord(0, captionHeight+imageCaptionVPadding, 300, 300-captionHeight-imageCaptionVPadding), MyGUI::Align::Stretch, "ToolTipText");
textWidget->setProperty("Static", "true");
textWidget->setProperty("MultiLine", "true");
textWidget->setProperty("WordWrap", info.wordWrap ? "true" : "false");
textWidget->setCaptionWithReplacing(text);
textWidget->setTextAlign(Align::HCenter | Align::Top);
IntSize textSize = textWidget->getTextSize();
textWidget->setTextAlign(MyGUI::Align::HCenter | MyGUI::Align::Top);
MyGUI::IntSize textSize = textWidget->getTextSize();
captionSize += IntSize(imageSize, 0); // adjust for image
IntSize totalSize = IntSize( std::min(std::max(textSize.width,captionSize.width + ((image != "") ? imageCaptionHPadding : 0)),maximumWidth),
captionSize += MyGUI::IntSize(imageSize, 0); // adjust for image
MyGUI::IntSize totalSize = MyGUI::IntSize( std::min(std::max(textSize.width,captionSize.width + ((image != "") ? imageCaptionHPadding : 0)),maximumWidth),
((text != "") ? textSize.height + imageCaptionVPadding : 0) + captionHeight );
if (!info.effects.empty())
{
Widget* effectArea = mDynamicToolTipBox->createWidget<Widget>("",
IntCoord(0, totalSize.height, 300, 300-totalSize.height),
Align::Stretch, "ToolTipEffectArea");
MyGUI::Widget* effectArea = mDynamicToolTipBox->createWidget<MyGUI::Widget>("",
MyGUI::IntCoord(0, totalSize.height, 300, 300-totalSize.height),
MyGUI::Align::Stretch, "ToolTipEffectArea");
IntCoord coord(0, 6, totalSize.width, 24);
MyGUI::IntCoord coord(0, 6, totalSize.width, 24);
/**
* \todo
@ -415,7 +415,7 @@ IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
*/
Widgets::MWEffectListPtr effectsWidget = effectArea->createWidget<Widgets::MWEffectList>
("MW_StatName", coord, Align::Default, "ToolTipEffectsWidget");
("MW_StatName", coord, MyGUI::Align::Default, "ToolTipEffectsWidget");
effectsWidget->setEffectList(info.effects);
std::vector<MyGUI::Widget*> effectItems;
@ -427,14 +427,14 @@ IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
if (info.enchant != "")
{
assert(enchant);
Widget* enchantArea = mDynamicToolTipBox->createWidget<Widget>("",
IntCoord(0, totalSize.height, 300, 300-totalSize.height),
Align::Stretch, "ToolTipEnchantArea");
MyGUI::Widget* enchantArea = mDynamicToolTipBox->createWidget<MyGUI::Widget>("",
MyGUI::IntCoord(0, totalSize.height, 300, 300-totalSize.height),
MyGUI::Align::Stretch, "ToolTipEnchantArea");
IntCoord coord(0, 6, totalSize.width, 24);
MyGUI::IntCoord coord(0, 6, totalSize.width, 24);
Widgets::MWEffectListPtr enchantWidget = enchantArea->createWidget<Widgets::MWEffectList>
("MW_StatName", coord, Align::Default, "ToolTipEnchantWidget");
("MW_StatName", coord, MyGUI::Align::Default, "ToolTipEnchantWidget");
enchantWidget->setEffectList(Widgets::MWEffectList::effectListFromESM(&enchant->mEffects));
std::vector<MyGUI::Widget*> enchantEffectItems;
@ -451,7 +451,7 @@ IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
const int chargeWidth = 204;
TextBox* chargeText = enchantArea->createWidget<TextBox>("SandText", IntCoord(0, 0, 10, 18), Align::Default, "ToolTipEnchantChargeText");
MyGUI::TextBox* chargeText = enchantArea->createWidget<MyGUI::TextBox>("SandText", MyGUI::IntCoord(0, 0, 10, 18), MyGUI::Align::Default, "ToolTipEnchantChargeText");
chargeText->setCaptionWithReplacing("#{sCharges}");
const int chargeTextWidth = chargeText->getTextSize().width + 5;
@ -462,18 +462,18 @@ IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
chargeText->setCoord((totalSize.width - chargeAndTextWidth)/2, coord.top+6, chargeTextWidth, 18);
IntCoord chargeCoord;
MyGUI::IntCoord chargeCoord;
if (totalSize.width < chargeWidth)
{
totalSize.width = chargeWidth;
chargeCoord = IntCoord(0, coord.top+6, chargeWidth, 18);
chargeCoord = MyGUI::IntCoord(0, coord.top+6, chargeWidth, 18);
}
else
{
chargeCoord = IntCoord((totalSize.width - chargeAndTextWidth)/2 + chargeTextWidth, coord.top+6, chargeWidth, 18);
chargeCoord = MyGUI::IntCoord((totalSize.width - chargeAndTextWidth)/2 + chargeTextWidth, coord.top+6, chargeWidth, 18);
}
Widgets::MWDynamicStatPtr chargeWidget = enchantArea->createWidget<Widgets::MWDynamicStat>
("MW_ChargeBar", chargeCoord, Align::Default, "ToolTipEnchantCharge");
("MW_ChargeBar", chargeCoord, MyGUI::Align::Default, "ToolTipEnchantCharge");
chargeWidget->setValue(charge, charge);
totalSize.height += 24;
}
@ -497,83 +497,83 @@ IntSize ToolTips::createToolTip(const MWGui::ToolTipInfo& info)
}else{
horizontal_scroll = 80 - mHorizontalScrollIndex;
}
captionWidget->setPosition (IntPoint(horizontal_scroll, captionWidget->getPosition().top + padding.top));
captionWidget->setPosition (MyGUI::IntPoint(horizontal_scroll, captionWidget->getPosition().top + padding.top));
} else {
captionWidget->setPosition (captionWidget->getPosition() + padding);
}
textWidget->setPosition (textWidget->getPosition() + IntPoint(0, padding.top)); // only apply vertical padding, the horizontal works automatically due to Align::HCenter
textWidget->setPosition (textWidget->getPosition() + MyGUI::IntPoint(0, padding.top)); // only apply vertical padding, the horizontal works automatically due to Align::HCenter
if (image != "")
{
ImageBox* imageWidget = mDynamicToolTipBox->createWidget<ImageBox>("ImageBox",
IntCoord((totalSize.width - captionSize.width - imageCaptionHPadding)/2, 0, imageSize, imageSize),
Align::Left | Align::Top, "ToolTipImage");
MyGUI::ImageBox* imageWidget = mDynamicToolTipBox->createWidget<MyGUI::ImageBox>("ImageBox",
MyGUI::IntCoord((totalSize.width - captionSize.width - imageCaptionHPadding)/2, 0, imageSize, imageSize),
MyGUI::Align::Left | MyGUI::Align::Top, "ToolTipImage");
imageWidget->setImageTexture(realImage);
imageWidget->setPosition (imageWidget->getPosition() + padding);
}
totalSize += IntSize(padding.left*2, padding.top*2);
totalSize += MyGUI::IntSize(padding.left*2, padding.top*2);
return totalSize;
}
}
std::string ToolTips::toString(const float value)
{
std::string ToolTips::toString(const float value)
{
std::ostringstream stream;
stream << std::setprecision(3) << value;
return stream.str();
}
}
std::string ToolTips::toString(const int value)
{
std::string ToolTips::toString(const int value)
{
std::ostringstream stream;
stream << value;
return stream.str();
}
}
std::string ToolTips::getValueString(const int value, const std::string& prefix)
{
std::string ToolTips::getValueString(const int value, const std::string& prefix)
{
if (value == 0)
return "";
else
return "\n" + prefix + ": " + toString(value);
}
}
std::string ToolTips::getMiscString(const std::string& text, const std::string& prefix)
{
std::string ToolTips::getMiscString(const std::string& text, const std::string& prefix)
{
if (text == "")
return "";
else
return "\n" + prefix + ": " + text;
}
}
std::string ToolTips::getCountString(const int value)
{
std::string ToolTips::getCountString(const int value)
{
if (value == 1)
return "";
else
return " (" + boost::lexical_cast<std::string>(value) + ")";
}
}
void ToolTips::toggleFullHelp()
{
void ToolTips::toggleFullHelp()
{
mFullHelp = !mFullHelp;
}
}
bool ToolTips::getFullHelp() const
{
bool ToolTips::getFullHelp() const
{
return mFullHelp;
}
}
void ToolTips::setFocusObjectScreenCoords(float min_x, float min_y, float max_x, float max_y)
{
void ToolTips::setFocusObjectScreenCoords(float min_x, float min_y, float max_x, float max_y)
{
mFocusToolTipX = (min_x + max_x) / 2;
mFocusToolTipY = min_y;
}
}
void ToolTips::createSkillToolTip(MyGUI::Widget* widget, int skillId)
{
void ToolTips::createSkillToolTip(MyGUI::Widget* widget, int skillId)
{
if (skillId == -1)
return;
@ -595,10 +595,10 @@ void ToolTips::createSkillToolTip(MyGUI::Widget* widget, int skillId)
widget->setUserString("Caption_SkillNoProgressDescription", skill->mDescription);
widget->setUserString("Caption_SkillNoProgressAttribute", "#{sGoverningAttribute}: #{" + attr->mName + "}");
widget->setUserString("ImageTexture_SkillNoProgressImage", icon);
}
}
void ToolTips::createAttributeToolTip(MyGUI::Widget* widget, int attributeId)
{
void ToolTips::createAttributeToolTip(MyGUI::Widget* widget, int attributeId)
{
if (attributeId == -1)
return;
@ -611,10 +611,10 @@ void ToolTips::createAttributeToolTip(MyGUI::Widget* widget, int attributeId)
widget->setUserString("Caption_AttributeName", "#{"+name+"}");
widget->setUserString("Caption_AttributeDescription", "#{"+desc+"}");
widget->setUserString("ImageTexture_AttributeImage", icon);
}
}
void ToolTips::createSpecializationToolTip(MyGUI::Widget* widget, const std::string& name, int specId)
{
void ToolTips::createSpecializationToolTip(MyGUI::Widget* widget, const std::string& name, int specId)
{
widget->setUserString("Caption_CenteredCaption", name);
std::string specText;
// get all skills of this specialisation
@ -630,10 +630,10 @@ void ToolTips::createSpecializationToolTip(MyGUI::Widget* widget, const std::str
widget->setUserString("Caption_CenteredCaptionText", specText);
widget->setUserString("ToolTipLayout", "TextWithCenteredCaptionToolTip");
widget->setUserString("ToolTipType", "Layout");
}
}
void ToolTips::createBirthsignToolTip(MyGUI::Widget* widget, const std::string& birthsignId)
{
void ToolTips::createBirthsignToolTip(MyGUI::Widget* widget, const std::string& birthsignId)
{
const MWWorld::ESMStore &store =
MWBase::Environment::get().getWorld()->getStore();
@ -698,18 +698,18 @@ void ToolTips::createBirthsignToolTip(MyGUI::Widget* widget, const std::string&
}
widget->setUserString("Caption_BirthSignText", text);
}
}
void ToolTips::createRaceToolTip(MyGUI::Widget* widget, const ESM::Race* playerRace)
{
void ToolTips::createRaceToolTip(MyGUI::Widget* widget, const ESM::Race* playerRace)
{
widget->setUserString("Caption_CenteredCaption", playerRace->mName);
widget->setUserString("Caption_CenteredCaptionText", playerRace->mDescription);
widget->setUserString("ToolTipType", "Layout");
widget->setUserString("ToolTipLayout", "TextWithCenteredCaptionToolTip");
}
}
void ToolTips::createClassToolTip(MyGUI::Widget* widget, const ESM::Class& playerClass)
{
void ToolTips::createClassToolTip(MyGUI::Widget* widget, const ESM::Class& playerClass)
{
if (playerClass.mName == "")
return;
@ -727,10 +727,10 @@ void ToolTips::createClassToolTip(MyGUI::Widget* widget, const ESM::Class& playe
widget->setUserString("Caption_ClassSpecialisation", "#{sSpecialization}: " + specStr);
widget->setUserString("ToolTipType", "Layout");
widget->setUserString("ToolTipLayout", "ClassToolTip");
}
}
void ToolTips::createMagicEffectToolTip(MyGUI::Widget* widget, short id)
{
void ToolTips::createMagicEffectToolTip(MyGUI::Widget* widget, short id)
{
const ESM::MagicEffect* effect =
MWBase::Environment::get().getWorld ()->getStore ().get<ESM::MagicEffect>().find(id);
const std::string &name = ESM::MagicEffect::effectIdToString (id);
@ -760,10 +760,12 @@ void ToolTips::createMagicEffectToolTip(MyGUI::Widget* widget, short id)
widget->setUserString("Caption_MagicEffectDescription", effect->mDescription);
widget->setUserString("Caption_MagicEffectSchool", "#{sSchool}: " + schools[effect->mData.mSchool]);
widget->setUserString("ImageTexture_MagicEffectImage", icon);
}
}
void ToolTips::setDelay(float delay)
{
void ToolTips::setDelay(float delay)
{
mDelay = delay;
mRemainingDelay = mDelay;
}
}

418
apps/openmw/mwgui/widgets.cpp
View file

@ -12,56 +12,58 @@
#undef min
#undef max
using namespace MWGui;
using namespace MWGui::Widgets;
namespace MWGui
{
namespace Widgets
{
/* Helper functions */
/* Helper functions */
/*
/*
* Fixes the filename of a texture path to use the correct .dds extension.
* This is needed on some ESM entries which point to a .tga file instead.
*/
void MWGui::Widgets::fixTexturePath(std::string &path)
{
void fixTexturePath(std::string &path)
{
int offset = path.rfind(".");
if (offset < 0)
return;
path.replace(offset, path.length() - offset, ".dds");
}
}
/* MWSkill */
/* MWSkill */
MWSkill::MWSkill()
MWSkill::MWSkill()
: mSkillId(ESM::Skill::Length)
, mSkillNameWidget(NULL)
, mSkillValueWidget(NULL)
{
}
{
}
void MWSkill::setSkillId(ESM::Skill::SkillEnum skill)
{
void MWSkill::setSkillId(ESM::Skill::SkillEnum skill)
{
mSkillId = skill;
updateWidgets();
}
}
void MWSkill::setSkillNumber(int skill)
{
void MWSkill::setSkillNumber(int skill)
{
if (skill < 0)
setSkillId(ESM::Skill::Length);
else if (skill < ESM::Skill::Length)
setSkillId(static_cast<ESM::Skill::SkillEnum>(skill));
else
throw new std::runtime_error("Skill number out of range");
}
}
void MWSkill::setSkillValue(const SkillValue& value)
{
void MWSkill::setSkillValue(const SkillValue& value)
{
mValue = value;
updateWidgets();
}
}
void MWSkill::updateWidgets()
{
void MWSkill::updateWidgets()
{
if (mSkillNameWidget)
{
if (mSkillId == ESM::Skill::Length)
@ -85,19 +87,19 @@ void MWSkill::updateWidgets()
else
mSkillValueWidget->_setWidgetState("normal");
}
}
}
void MWSkill::onClicked(MyGUI::Widget* _sender)
{
void MWSkill::onClicked(MyGUI::Widget* _sender)
{
eventClicked(this);
}
}
MWSkill::~MWSkill()
{
}
MWSkill::~MWSkill()
{
}
void MWSkill::initialiseOverride()
{
void MWSkill::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mSkillNameWidget, "StatName");
@ -118,36 +120,36 @@ void MWSkill::initialiseOverride()
mSkillNameWidget = button;
button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWSkill::onClicked);
}
}
}
/* MWAttribute */
/* MWAttribute */
MWAttribute::MWAttribute()
MWAttribute::MWAttribute()
: mId(-1)
, mAttributeNameWidget(NULL)
, mAttributeValueWidget(NULL)
{
}
{
}
void MWAttribute::setAttributeId(int attributeId)
{
void MWAttribute::setAttributeId(int attributeId)
{
mId = attributeId;
updateWidgets();
}
}
void MWAttribute::setAttributeValue(const AttributeValue& value)
{
void MWAttribute::setAttributeValue(const AttributeValue& value)
{
mValue = value;
updateWidgets();
}
}
void MWAttribute::onClicked(MyGUI::Widget* _sender)
{
void MWAttribute::onClicked(MyGUI::Widget* _sender)
{
eventClicked(this);
}
}
void MWAttribute::updateWidgets()
{
void MWAttribute::updateWidgets()
{
if (mAttributeNameWidget)
{
if (mId < 0 || mId >= 8)
@ -181,14 +183,14 @@ void MWAttribute::updateWidgets()
else
mAttributeValueWidget->_setWidgetState("normal");
}
}
}
MWAttribute::~MWAttribute()
{
}
MWAttribute::~MWAttribute()
{
}
void MWAttribute::initialiseOverride()
{
void MWAttribute::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mAttributeNameWidget, "StatName");
@ -209,23 +211,23 @@ void MWAttribute::initialiseOverride()
mAttributeValueWidget = button;
button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWAttribute::onClicked);
}
}
}
/* MWSpell */
/* MWSpell */
MWSpell::MWSpell()
MWSpell::MWSpell()
: mSpellNameWidget(NULL)
{
}
{
}
void MWSpell::setSpellId(const std::string &spellId)
{
void MWSpell::setSpellId(const std::string &spellId)
{
mId = spellId;
updateWidgets();
}
}
void MWSpell::createEffectWidgets(std::vector<MyGUI::Widget*> &effects, MyGUI::Widget* creator, MyGUI::IntCoord &coord, int flags)
{
void MWSpell::createEffectWidgets(std::vector<MyGUI::Widget*> &effects, MyGUI::Widget* creator, MyGUI::IntCoord &coord, int flags)
{
const MWWorld::ESMStore &store =
MWBase::Environment::get().getWorld()->getStore();
@ -252,10 +254,10 @@ void MWSpell::createEffectWidgets(std::vector<MyGUI::Widget*> &effects, MyGUI::W
coord.top += effect->getHeight();
coord.width = std::max(coord.width, effect->getRequestedWidth());
}
}
}
void MWSpell::updateWidgets()
{
void MWSpell::updateWidgets()
{
if (mSpellNameWidget && MWBase::Environment::get().getWindowManager())
{
const MWWorld::ESMStore &store =
@ -267,34 +269,34 @@ void MWSpell::updateWidgets()
else
static_cast<MyGUI::TextBox*>(mSpellNameWidget)->setCaption("");
}
}
}
void MWSpell::initialiseOverride()
{
void MWSpell::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mSpellNameWidget, "StatName");
}
}
MWSpell::~MWSpell()
{
}
MWSpell::~MWSpell()
{
}
/* MWEffectList */
/* MWEffectList */
MWEffectList::MWEffectList()
MWEffectList::MWEffectList()
: mEffectList(0)
{
}
{
}
void MWEffectList::setEffectList(const SpellEffectList& list)
{
void MWEffectList::setEffectList(const SpellEffectList& list)
{
mEffectList = list;
updateWidgets();
}
}
void MWEffectList::createEffectWidgets(std::vector<MyGUI::Widget*> &effects, MyGUI::Widget* creator, MyGUI::IntCoord &coord, bool center, int flags)
{
void MWEffectList::createEffectWidgets(std::vector<MyGUI::Widget*> &effects, MyGUI::Widget* creator, MyGUI::IntCoord &coord, bool center, int flags)
{
// We don't know the width of all the elements beforehand, so we do it in
// 2 steps: first, create all widgets and check their width....
MWSpellEffectPtr effect = NULL;
@ -332,23 +334,23 @@ void MWEffectList::createEffectWidgets(std::vector<MyGUI::Widget*> &effects, MyG
// inform the parent about width
coord.width = maxwidth;
}
}
void MWEffectList::updateWidgets()
{
}
void MWEffectList::updateWidgets()
{
}
void MWEffectList::initialiseOverride()
{
void MWEffectList::initialiseOverride()
{
Base::initialiseOverride();
}
}
MWEffectList::~MWEffectList()
{
}
MWEffectList::~MWEffectList()
{
}
SpellEffectList MWEffectList::effectListFromESM(const ESM::EffectList* effects)
{
SpellEffectList MWEffectList::effectListFromESM(const ESM::EffectList* effects)
{
SpellEffectList result;
std::vector<ESM::ENAMstruct>::const_iterator end = effects->mList.end();
for (std::vector<ESM::ENAMstruct>::const_iterator it = effects->mList.begin(); it != end; ++it)
@ -365,25 +367,25 @@ SpellEffectList MWEffectList::effectListFromESM(const ESM::EffectList* effects)
result.push_back(params);
}
return result;
}
}
/* MWSpellEffect */
/* MWSpellEffect */
MWSpellEffect::MWSpellEffect()
MWSpellEffect::MWSpellEffect()
: mImageWidget(NULL)
, mTextWidget(NULL)
, mRequestedWidth(0)
{
}
{
}
void MWSpellEffect::setSpellEffect(const SpellEffectParams& params)
{
void MWSpellEffect::setSpellEffect(const SpellEffectParams& params)
{
mEffectParams = params;
updateWidgets();
}
}
void MWSpellEffect::updateWidgets()
{
void MWSpellEffect::updateWidgets()
{
if (!mEffectParams.mKnown)
{
mTextWidget->setCaption ("?");
@ -460,33 +462,33 @@ void MWSpellEffect::updateWidgets()
std::string path = std::string("icons\\") + magicEffect->mIcon;
fixTexturePath(path);
mImageWidget->setImageTexture(path);
}
}
MWSpellEffect::~MWSpellEffect()
{
}
MWSpellEffect::~MWSpellEffect()
{
}
void MWSpellEffect::initialiseOverride()
{
void MWSpellEffect::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mTextWidget, "Text");
assignWidget(mImageWidget, "Image");
}
}
/* MWDynamicStat */
/* MWDynamicStat */
MWDynamicStat::MWDynamicStat()
: mValue(0)
, mMax(1)
, mTextWidget(NULL)
, mBarWidget(NULL)
, mBarTextWidget(NULL)
{
}
MWDynamicStat::MWDynamicStat()
: mValue(0)
, mMax(1)
, mTextWidget(NULL)
, mBarWidget(NULL)
, mBarTextWidget(NULL)
{
}
void MWDynamicStat::setValue(int cur, int max)
{
void MWDynamicStat::setValue(int cur, int max)
{
mValue = cur;
mMax = max;
@ -508,33 +510,33 @@ void MWDynamicStat::setValue(int cur, int max)
else
static_cast<MyGUI::TextBox*>(mBarTextWidget)->setCaption("");
}
}
void MWDynamicStat::setTitle(const std::string& text)
{
}
void MWDynamicStat::setTitle(const std::string& text)
{
if (mTextWidget)
static_cast<MyGUI::TextBox*>(mTextWidget)->setCaption(text);
}
}
MWDynamicStat::~MWDynamicStat()
{
}
MWDynamicStat::~MWDynamicStat()
{
}
void MWDynamicStat::initialiseOverride()
{
void MWDynamicStat::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mTextWidget, "Text");
assignWidget(mBarWidget, "Bar");
assignWidget(mBarTextWidget, "BarText");
}
}
// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------
void AutoSizedWidget::notifySizeChange (MyGUI::Widget* w)
{
void AutoSizedWidget::notifySizeChange (MyGUI::Widget* w)
{
if (w->getParent () != 0)
{
Box* b = dynamic_cast<Box*>(w->getParent());
@ -550,23 +552,23 @@ void AutoSizedWidget::notifySizeChange (MyGUI::Widget* w)
w->setSize(getRequestedSize ());
}
}
}
}
MyGUI::IntSize AutoSizedTextBox::getRequestedSize()
{
MyGUI::IntSize AutoSizedTextBox::getRequestedSize()
{
return getTextSize();
}
}
void AutoSizedTextBox::setCaption(const MyGUI::UString& _value)
{
void AutoSizedTextBox::setCaption(const MyGUI::UString& _value)
{
TextBox::setCaption(_value);
notifySizeChange (this);
}
}
void AutoSizedTextBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
void AutoSizedTextBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
if (_key == "ExpandDirection")
{
mExpandDirection = MyGUI::Align::parse (_value);
@ -575,24 +577,24 @@ void AutoSizedTextBox::setPropertyOverride(const std::string& _key, const std::s
{
TextBox::setPropertyOverride (_key, _value);
}
}
}
MyGUI::IntSize AutoSizedEditBox::getRequestedSize()
{
MyGUI::IntSize AutoSizedEditBox::getRequestedSize()
{
if (getAlign().isHStretch())
throw std::runtime_error("AutoSizedEditBox can't have HStretch align (" + getName() + ")");
return MyGUI::IntSize(getSize().width, getTextSize().height);
}
}
void AutoSizedEditBox::setCaption(const MyGUI::UString& _value)
{
void AutoSizedEditBox::setCaption(const MyGUI::UString& _value)
{
EditBox::setCaption(_value);
notifySizeChange (this);
}
}
void AutoSizedEditBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
void AutoSizedEditBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
if (_key == "ExpandDirection")
{
mExpandDirection = MyGUI::Align::parse (_value);
@ -601,25 +603,25 @@ void AutoSizedEditBox::setPropertyOverride(const std::string& _key, const std::s
{
EditBox::setPropertyOverride (_key, _value);
}
}
}
MyGUI::IntSize AutoSizedButton::getRequestedSize()
{
MyGUI::IntSize AutoSizedButton::getRequestedSize()
{
MyGUI::IntSize size = getTextSize() + MyGUI::IntSize(24,0);
size.height = std::max(24, size.height);
return size;
}
}
void AutoSizedButton::setCaption(const MyGUI::UString& _value)
{
void AutoSizedButton::setCaption(const MyGUI::UString& _value)
{
Button::setCaption(_value);
notifySizeChange (this);
}
}
void AutoSizedButton::setPropertyOverride(const std::string& _key, const std::string& _value)
{
void AutoSizedButton::setPropertyOverride(const std::string& _key, const std::string& _value)
{
if (_key == "ExpandDirection")
{
mExpandDirection = MyGUI::Align::parse (_value);
@ -628,33 +630,33 @@ void AutoSizedButton::setPropertyOverride(const std::string& _key, const std::st
{
Button::setPropertyOverride (_key, _value);
}
}
}
Box::Box()
Box::Box()
: mSpacing(4)
, mPadding(0)
, mAutoResize(false)
{
{
}
}
void Box::notifyChildrenSizeChanged ()
{
void Box::notifyChildrenSizeChanged ()
{
align();
}
}
void Box::_setPropertyImpl(const std::string& _key, const std::string& _value)
{
void Box::_setPropertyImpl(const std::string& _key, const std::string& _value)
{
if (_key == "Spacing")
mSpacing = MyGUI::utility::parseValue<int>(_value);
else if (_key == "Padding")
mPadding = MyGUI::utility::parseValue<int>(_value);
else if (_key == "AutoResize")
mAutoResize = MyGUI::utility::parseValue<bool>(_value);
}
}
void HBox::align ()
{
void HBox::align ()
{
unsigned int count = getChildCount ();
size_t h_stretched_count = 0;
int total_width = 0;
@ -716,32 +718,32 @@ void HBox::align ()
if (i != count-1)
curX += mSpacing;
}
}
}
void HBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
void HBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
Box::_setPropertyImpl (_key, _value);
}
}
void HBox::setSize (const MyGUI::IntSize& _value)
{
void HBox::setSize (const MyGUI::IntSize& _value)
{
MyGUI::Widget::setSize (_value);
align();
}
}
void HBox::setCoord (const MyGUI::IntCoord& _value)
{
void HBox::setCoord (const MyGUI::IntCoord& _value)
{
MyGUI::Widget::setCoord (_value);
align();
}
}
void HBox::onWidgetCreated(MyGUI::Widget* _widget)
{
void HBox::onWidgetCreated(MyGUI::Widget* _widget)
{
align();
}
}
MyGUI::IntSize HBox::getRequestedSize ()
{
MyGUI::IntSize HBox::getRequestedSize ()
{
MyGUI::IntSize size(0,0);
for (unsigned int i = 0; i < getChildCount (); ++i)
{
@ -769,13 +771,13 @@ MyGUI::IntSize HBox::getRequestedSize ()
size.width += mPadding*2;
}
return size;
}
}
void VBox::align ()
{
void VBox::align ()
{
unsigned int count = getChildCount ();
size_t v_stretched_count = 0;
int total_height = 0;
@ -837,27 +839,27 @@ void VBox::align ()
if (i != count-1)
curY += mSpacing;
}
}
}
void VBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
void VBox::setPropertyOverride(const std::string& _key, const std::string& _value)
{
Box::_setPropertyImpl (_key, _value);
}
}
void VBox::setSize (const MyGUI::IntSize& _value)
{
void VBox::setSize (const MyGUI::IntSize& _value)
{
MyGUI::Widget::setSize (_value);
align();
}
}
void VBox::setCoord (const MyGUI::IntCoord& _value)
{
void VBox::setCoord (const MyGUI::IntCoord& _value)
{
MyGUI::Widget::setCoord (_value);
align();
}
}
MyGUI::IntSize VBox::getRequestedSize ()
{
MyGUI::IntSize VBox::getRequestedSize ()
{
MyGUI::IntSize size(0,0);
for (unsigned int i = 0; i < getChildCount (); ++i)
{
@ -885,9 +887,11 @@ MyGUI::IntSize VBox::getRequestedSize ()
size.width += mPadding*2;
}
return size;
}
}
void VBox::onWidgetCreated(MyGUI::Widget* _widget)
{
void VBox::onWidgetCreated(MyGUI::Widget* _widget)
{
align();
}
}
}

555
apps/openmw/mwgui/windowmanagerimp.cpp
View file

@ -39,9 +39,10 @@
#include "companionwindow.hpp"
#include "inventorywindow.hpp"
using namespace MWGui;
namespace MWGui
{
WindowManager::WindowManager(
WindowManager::WindowManager(
const Compiler::Extensions& extensions, int fpsLevel, bool newGame, OEngine::Render::OgreRenderer *ogre,
const std::string& logpath, const std::string& cacheDir, bool consoleOnlyScripts,
Translation::Storage& translationDataStorage)
@ -99,7 +100,7 @@ WindowManager::WindowManager(
, mSubtitlesEnabled(Settings::Manager::getBool ("subtitles", "GUI"))
, mHudEnabled(true)
, mTranslationDataStorage (translationDataStorage)
{
{
// Set up the GUI system
mGuiManager = new OEngine::GUI::MyGUIManager(mRendering->getWindow(), mRendering->getScene(), false, logpath);
mGui = mGuiManager->getGui();
@ -202,10 +203,10 @@ WindowManager::WindowManager(
// Set up visibility
updateVisible();
}
}
WindowManager::~WindowManager()
{
WindowManager::~WindowManager()
{
delete mConsole;
delete mMessageBoxManager;
delete mHud;
@ -244,10 +245,10 @@ WindowManager::~WindowManager()
cleanupGarbage();
delete mGuiManager;
}
}
void WindowManager::cleanupGarbage()
{
void WindowManager::cleanupGarbage()
{
// Delete any dialogs which are no longer in use
if (!mGarbageDialogs.empty())
{
@ -257,10 +258,10 @@ void WindowManager::cleanupGarbage()
}
mGarbageDialogs.clear();
}
}
}
void WindowManager::update()
{
void WindowManager::update()
{
cleanupGarbage();
mHud->setFPS(mFPS);
@ -270,10 +271,10 @@ void WindowManager::update()
mHud->update();
mCursor->update();
}
}
void WindowManager::updateVisible()
{
void WindowManager::updateVisible()
{
// Start out by hiding everything except the HUD
mMap->setVisible(false);
mMenu->setVisible(false);
@ -456,10 +457,10 @@ void WindowManager::updateVisible()
// Unsupported mode, switch back to game
break;
}
}
}
void WindowManager::setValue (const std::string& id, const MWMechanics::Stat<int>& value)
{
void WindowManager::setValue (const std::string& id, const MWMechanics::Stat<int>& value)
{
mStatsWindow->setValue (id, value);
mCharGen->setValue(id, value);
@ -486,20 +487,20 @@ void WindowManager::setValue (const std::string& id, const MWMechanics::Stat<int
mPlayerAttributes[attributes[i]] = value;
break;
}
}
}
void WindowManager::setValue (int parSkill, const MWMechanics::Stat<float>& value)
{
void WindowManager::setValue (int parSkill, const MWMechanics::Stat<float>& value)
{
/// \todo Don't use the skill enum as a parameter type (we will have to drop it anyway, once we
/// allow custom skills.
mStatsWindow->setValue(static_cast<ESM::Skill::SkillEnum> (parSkill), value);
mCharGen->setValue(static_cast<ESM::Skill::SkillEnum> (parSkill), value);
mPlayerSkillValues[parSkill] = value;
}
}
void WindowManager::setValue (const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
void WindowManager::setValue (const std::string& id, const MWMechanics::DynamicStat<float>& value)
{
mStatsWindow->setValue (id, value);
mHud->setValue (id, value);
mCharGen->setValue(id, value);
@ -518,72 +519,72 @@ void WindowManager::setValue (const std::string& id, const MWMechanics::DynamicS
mPlayerFatigue = value;
mCharGen->setPlayerFatigue (value);
}
}
}
#if 0
MWMechanics::DynamicStat<int> WindowManager::getValue(const std::string& id)
{
#if 0
MWMechanics::DynamicStat<int> WindowManager::getValue(const std::string& id)
{
if(id == "HBar")
return layerHealth;
else if (id == "MBar")
return mPlayerMagicka;
else if (id == "FBar")
return mPlayerFatigue;
}
#endif
}
#endif
void WindowManager::setValue (const std::string& id, const std::string& value)
{
void WindowManager::setValue (const std::string& id, const std::string& value)
{
mStatsWindow->setValue (id, value);
if (id=="name")
mPlayerName = value;
else if (id=="race")
mPlayerRaceId = value;
}
}
void WindowManager::setValue (const std::string& id, int value)
{
void WindowManager::setValue (const std::string& id, int value)
{
mStatsWindow->setValue (id, value);
}
}
void WindowManager::setPlayerClass (const ESM::Class &class_)
{
void WindowManager::setPlayerClass (const ESM::Class &class_)
{
mStatsWindow->setValue("class", class_.mName);
}
}
void WindowManager::configureSkills (const SkillList& major, const SkillList& minor)
{
void WindowManager::configureSkills (const SkillList& major, const SkillList& minor)
{
mStatsWindow->configureSkills (major, minor);
mCharGen->configureSkills(major, minor);
mPlayerMajorSkills = major;
mPlayerMinorSkills = minor;
}
}
void WindowManager::setReputation (int reputation)
{
void WindowManager::setReputation (int reputation)
{
mStatsWindow->setReputation (reputation);
}
}
void WindowManager::setBounty (int bounty)
{
void WindowManager::setBounty (int bounty)
{
mStatsWindow->setBounty (bounty);
}
}
void WindowManager::updateSkillArea()
{
void WindowManager::updateSkillArea()
{
mStatsWindow->updateSkillArea();
}
}
void WindowManager::removeDialog(OEngine::GUI::Layout*dialog)
{
void WindowManager::removeDialog(OEngine::GUI::Layout*dialog)
{
if (!dialog)
return;
dialog->setVisible(false);
mGarbageDialogs.push_back(dialog);
}
}
void WindowManager::messageBox (const std::string& message, const std::vector<std::string>& buttons)
{
void WindowManager::messageBox (const std::string& message, const std::vector<std::string>& buttons)
{
if(buttons.empty()){
/* If there are no buttons, and there is a dialogue window open, messagebox goes to the dialogue window */
if(!mGuiModes.empty() && mGuiModes.back() == GM_Dialogue)
@ -597,20 +598,20 @@ void WindowManager::messageBox (const std::string& message, const std::vector<st
mMessageBoxManager->createInteractiveMessageBox(message, buttons);
MWBase::Environment::get().getInputManager()->changeInputMode(isGuiMode());
}
}
}
void WindowManager::enterPressed ()
{
void WindowManager::enterPressed ()
{
mMessageBoxManager->enterPressed();
}
}
int WindowManager::readPressedButton ()
{
int WindowManager::readPressedButton ()
{
return mMessageBoxManager->readPressedButton();
}
}
std::string WindowManager::getGameSettingString(const std::string &id, const std::string &default_)
{
std::string WindowManager::getGameSettingString(const std::string &id, const std::string &default_)
{
const ESM::GameSetting *setting =
MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>().search(id);
@ -618,10 +619,10 @@ std::string WindowManager::getGameSettingString(const std::string &id, const std
return setting->mValue.getString();
return default_;
}
}
void WindowManager::onDialogueWindowBye()
{
void WindowManager::onDialogueWindowBye()
{
if (mDialogueWindow)
{
//FIXME set some state and stuff?
@ -629,10 +630,10 @@ void WindowManager::onDialogueWindowBye()
mDialogueWindow->setVisible(false);
}
removeGuiMode(GM_Dialogue);
}
}
void WindowManager::onFrame (float frameDuration)
{
void WindowManager::onFrame (float frameDuration)
{
mMessageBoxManager->onFrame(frameDuration);
mToolTips->onFrame(frameDuration);
@ -665,10 +666,10 @@ void WindowManager::onFrame (float frameDuration)
mContainerWindow->checkReferenceAvailable();
mCompanionWindow->checkReferenceAvailable();
mConsole->checkReferenceAvailable();
}
}
void WindowManager::changeCell(MWWorld::Ptr::CellStore* cell)
{
void WindowManager::changeCell(MWWorld::Ptr::CellStore* cell)
{
if (cell->mCell->isExterior())
{
std::string name;
@ -705,86 +706,86 @@ void WindowManager::changeCell(MWWorld::Ptr::CellStore* cell)
mHud->setCellPrefix( cell->mCell->mName );
}
}
}
void WindowManager::setInteriorMapTexture(const int x, const int y)
{
void WindowManager::setInteriorMapTexture(const int x, const int y)
{
mMap->setActiveCell(x,y, true);
mHud->setActiveCell(x,y, true);
}
}
void WindowManager::setPlayerPos(const float x, const float y)
{
void WindowManager::setPlayerPos(const float x, const float y)
{
mMap->setPlayerPos(x,y);
mHud->setPlayerPos(x,y);
}
}
void WindowManager::setPlayerDir(const float x, const float y)
{
void WindowManager::setPlayerDir(const float x, const float y)
{
mMap->setPlayerDir(x,y);
mHud->setPlayerDir(x,y);
}
}
void WindowManager::setHMSVisibility(bool visible)
{
void WindowManager::setHMSVisibility(bool visible)
{
mHud->setHmsVisible (visible);
}
}
void WindowManager::setMinimapVisibility(bool visible)
{
void WindowManager::setMinimapVisibility(bool visible)
{
mHud->setMinimapVisible (visible);
}
}
void WindowManager::toggleFogOfWar()
{
void WindowManager::toggleFogOfWar()
{
mMap->toggleFogOfWar();
mHud->toggleFogOfWar();
}
}
void WindowManager::setFocusObject(const MWWorld::Ptr& focus)
{
void WindowManager::setFocusObject(const MWWorld::Ptr& focus)
{
mToolTips->setFocusObject(focus);
}
}
void WindowManager::setFocusObjectScreenCoords(float min_x, float min_y, float max_x, float max_y)
{
void WindowManager::setFocusObjectScreenCoords(float min_x, float min_y, float max_x, float max_y)
{
mToolTips->setFocusObjectScreenCoords(min_x, min_y, max_x, max_y);
}
}
void WindowManager::toggleFullHelp()
{
void WindowManager::toggleFullHelp()
{
mToolTips->toggleFullHelp();
}
}
bool WindowManager::getFullHelp() const
{
bool WindowManager::getFullHelp() const
{
return mToolTips->getFullHelp();
}
}
void WindowManager::setWeaponVisibility(bool visible)
{
void WindowManager::setWeaponVisibility(bool visible)
{
mHud->setWeapVisible (visible);
}
}
void WindowManager::setSpellVisibility(bool visible)
{
void WindowManager::setSpellVisibility(bool visible)
{
mHud->setSpellVisible (visible);
mHud->setEffectVisible (visible);
}
}
void WindowManager::setMouseVisible(bool visible)
{
void WindowManager::setMouseVisible(bool visible)
{
mCursor->setVisible(visible);
}
}
void WindowManager::setDragDrop(bool dragDrop)
{
void WindowManager::setDragDrop(bool dragDrop)
{
mToolTips->setEnabled(!dragDrop);
MWBase::Environment::get().getInputManager()->setDragDrop(dragDrop);
}
}
void WindowManager::onRetrieveTag(const MyGUI::UString& _tag, MyGUI::UString& _result)
{
void WindowManager::onRetrieveTag(const MyGUI::UString& _tag, MyGUI::UString& _result)
{
std::string tag(_tag);
std::string tokenToFind = "sCell=";
@ -804,10 +805,10 @@ void WindowManager::onRetrieveTag(const MyGUI::UString& _tag, MyGUI::UString& _r
else
_result = tag;
}
}
}
void WindowManager::processChangedSettings(const Settings::CategorySettingVector& changed)
{
void WindowManager::processChangedSettings(const Settings::CategorySettingVector& changed)
{
mHud->setFpsLevel(Settings::Manager::getInt("fps", "HUD"));
mToolTips->setDelay(Settings::Manager::getFloat("tooltip delay", "GUI"));
@ -852,10 +853,10 @@ void WindowManager::processChangedSettings(const Settings::CategorySettingVector
mGuiManager->updateWindow (mRendering->getWindow ());
mLoadingScreen->updateWindow (mRendering->getWindow ());
}
}
}
void WindowManager::pushGuiMode(GuiMode mode)
{
void WindowManager::pushGuiMode(GuiMode mode)
{
if (mode==GM_Inventory && mAllowed==GW_None)
return;
@ -872,10 +873,10 @@ void WindowManager::pushGuiMode(GuiMode mode)
MWBase::Environment::get().getInputManager()->changeInputMode(!gameMode);
updateVisible();
}
}
void WindowManager::popGuiMode()
{
void WindowManager::popGuiMode()
{
if (!mGuiModes.empty())
mGuiModes.pop_back();
@ -883,10 +884,10 @@ void WindowManager::popGuiMode()
MWBase::Environment::get().getInputManager()->changeInputMode(!gameMode);
updateVisible();
}
}
void WindowManager::removeGuiMode(GuiMode mode)
{
void WindowManager::removeGuiMode(GuiMode mode)
{
std::vector<GuiMode>::iterator it = mGuiModes.begin();
while (it != mGuiModes.end())
{
@ -900,103 +901,103 @@ void WindowManager::removeGuiMode(GuiMode mode)
MWBase::Environment::get().getInputManager()->changeInputMode(!gameMode);
updateVisible();
}
}
void WindowManager::setSelectedSpell(const std::string& spellId, int successChancePercent)
{
void WindowManager::setSelectedSpell(const std::string& spellId, int successChancePercent)
{
mHud->setSelectedSpell(spellId, successChancePercent);
const ESM::Spell* spell =
MWBase::Environment::get().getWorld()->getStore().get<ESM::Spell>().find(spellId);
mSpellWindow->setTitle(spell->mName);
}
}
void WindowManager::setSelectedEnchantItem(const MWWorld::Ptr& item)
{
void WindowManager::setSelectedEnchantItem(const MWWorld::Ptr& item)
{
const ESM::Enchantment* ench = MWBase::Environment::get().getWorld()->getStore().get<ESM::Enchantment>()
.find(MWWorld::Class::get(item).getEnchantment(item));
int chargePercent = item.getCellRef().mEnchantmentCharge / static_cast<float>(ench->mData.mCharge) * 100;
mHud->setSelectedEnchantItem(item, chargePercent);
mSpellWindow->setTitle(MWWorld::Class::get(item).getName(item));
}
}
void WindowManager::setSelectedWeapon(const MWWorld::Ptr& item)
{
void WindowManager::setSelectedWeapon(const MWWorld::Ptr& item)
{
int durabilityPercent = item.getCellRef().mCharge / static_cast<float>(MWWorld::Class::get(item).getItemMaxHealth(item)) * 100;
mHud->setSelectedWeapon(item, durabilityPercent);
mInventoryWindow->setTitle(MWWorld::Class::get(item).getName(item));
}
}
void WindowManager::unsetSelectedSpell()
{
void WindowManager::unsetSelectedSpell()
{
mHud->unsetSelectedSpell();
mSpellWindow->setTitle("#{sNone}");
}
}
void WindowManager::unsetSelectedWeapon()
{
void WindowManager::unsetSelectedWeapon()
{
mHud->unsetSelectedWeapon();
mInventoryWindow->setTitle("#{sSkillHandtohand}");
}
}
void WindowManager::getMousePosition(int &x, int &y)
{
void WindowManager::getMousePosition(int &x, int &y)
{
const MyGUI::IntPoint& pos = MyGUI::InputManager::getInstance().getMousePosition();
x = pos.left;
y = pos.top;
}
}
void WindowManager::getMousePosition(float &x, float &y)
{
void WindowManager::getMousePosition(float &x, float &y)
{
const MyGUI::IntPoint& pos = MyGUI::InputManager::getInstance().getMousePosition();
x = pos.left;
y = pos.top;
const MyGUI::IntSize& viewSize = MyGUI::RenderManager::getInstance().getViewSize();
x /= viewSize.width;
y /= viewSize.height;
}
}
bool WindowManager::getWorldMouseOver()
{
bool WindowManager::getWorldMouseOver()
{
return mHud->getWorldMouseOver();
}
}
void WindowManager::executeInConsole (const std::string& path)
{
void WindowManager::executeInConsole (const std::string& path)
{
mConsole->executeFile (path);
}
}
void WindowManager::wmUpdateFps(float fps, unsigned int triangleCount, unsigned int batchCount)
{
void WindowManager::wmUpdateFps(float fps, unsigned int triangleCount, unsigned int batchCount)
{
mFPS = fps;
mTriangleCount = triangleCount;
mBatchCount = batchCount;
}
}
MyGUI::Gui* WindowManager::getGui() const { return mGui; }
MyGUI::Gui* WindowManager::getGui() const { return mGui; }
MWGui::DialogueWindow* WindowManager::getDialogueWindow() { return mDialogueWindow; }
MWGui::ContainerWindow* WindowManager::getContainerWindow() { return mContainerWindow; }
MWGui::InventoryWindow* WindowManager::getInventoryWindow() { return mInventoryWindow; }
MWGui::BookWindow* WindowManager::getBookWindow() { return mBookWindow; }
MWGui::ScrollWindow* WindowManager::getScrollWindow() { return mScrollWindow; }
MWGui::CountDialog* WindowManager::getCountDialog() { return mCountDialog; }
MWGui::ConfirmationDialog* WindowManager::getConfirmationDialog() { return mConfirmationDialog; }
MWGui::TradeWindow* WindowManager::getTradeWindow() { return mTradeWindow; }
MWGui::SpellBuyingWindow* WindowManager::getSpellBuyingWindow() { return mSpellBuyingWindow; }
MWGui::TravelWindow* WindowManager::getTravelWindow() { return mTravelWindow; }
MWGui::SpellWindow* WindowManager::getSpellWindow() { return mSpellWindow; }
MWGui::Console* WindowManager::getConsole() { return mConsole; }
MWGui::DialogueWindow* WindowManager::getDialogueWindow() { return mDialogueWindow; }
MWGui::ContainerWindow* WindowManager::getContainerWindow() { return mContainerWindow; }
MWGui::InventoryWindow* WindowManager::getInventoryWindow() { return mInventoryWindow; }
MWGui::BookWindow* WindowManager::getBookWindow() { return mBookWindow; }
MWGui::ScrollWindow* WindowManager::getScrollWindow() { return mScrollWindow; }
MWGui::CountDialog* WindowManager::getCountDialog() { return mCountDialog; }
MWGui::ConfirmationDialog* WindowManager::getConfirmationDialog() { return mConfirmationDialog; }
MWGui::TradeWindow* WindowManager::getTradeWindow() { return mTradeWindow; }
MWGui::SpellBuyingWindow* WindowManager::getSpellBuyingWindow() { return mSpellBuyingWindow; }
MWGui::TravelWindow* WindowManager::getTravelWindow() { return mTravelWindow; }
MWGui::SpellWindow* WindowManager::getSpellWindow() { return mSpellWindow; }
MWGui::Console* WindowManager::getConsole() { return mConsole; }
bool WindowManager::isAllowed (GuiWindow wnd) const
{
bool WindowManager::isAllowed (GuiWindow wnd) const
{
return mAllowed & wnd;
}
}
void WindowManager::allow (GuiWindow wnd)
{
void WindowManager::allow (GuiWindow wnd)
{
mAllowed = (GuiWindow)(mAllowed | wnd);
if (wnd & GW_Inventory)
@ -1006,176 +1007,178 @@ void WindowManager::allow (GuiWindow wnd)
}
updateVisible();
}
}
void WindowManager::disallowAll()
{
void WindowManager::disallowAll()
{
mAllowed = GW_None;
mBookWindow->setInventoryAllowed (false);
mScrollWindow->setInventoryAllowed (false);
updateVisible();
}
}
void WindowManager::toggleVisible (GuiWindow wnd)
{
void WindowManager::toggleVisible (GuiWindow wnd)
{
mShown = (mShown & wnd) ? (GuiWindow) (mShown & ~wnd) : (GuiWindow) (mShown | wnd);
updateVisible();
}
}
bool WindowManager::isGuiMode() const
{
bool WindowManager::isGuiMode() const
{
return !mGuiModes.empty() || mMessageBoxManager->isInteractiveMessageBox();
}
}
bool WindowManager::isConsoleMode() const
{
bool WindowManager::isConsoleMode() const
{
if (!mGuiModes.empty() && mGuiModes.back()==GM_Console)
return true;
return false;
}
}
MWGui::GuiMode WindowManager::getMode() const
{
MWGui::GuiMode WindowManager::getMode() const
{
if (mGuiModes.empty())
return GM_None;
return mGuiModes.back();
}
}
std::map<int, MWMechanics::Stat<float> > WindowManager::getPlayerSkillValues()
{
std::map<int, MWMechanics::Stat<float> > WindowManager::getPlayerSkillValues()
{
return mPlayerSkillValues;
}
}
std::map<int, MWMechanics::Stat<int> > WindowManager::getPlayerAttributeValues()
{
std::map<int, MWMechanics::Stat<int> > WindowManager::getPlayerAttributeValues()
{
return mPlayerAttributes;
}
}
WindowManager::SkillList WindowManager::getPlayerMinorSkills()
{
WindowManager::SkillList WindowManager::getPlayerMinorSkills()
{
return mPlayerMinorSkills;
}
}
WindowManager::SkillList WindowManager::getPlayerMajorSkills()
{
WindowManager::SkillList WindowManager::getPlayerMajorSkills()
{
return mPlayerMajorSkills;
}
}
void WindowManager::disallowMouse()
{
void WindowManager::disallowMouse()
{
mInputBlocker->setVisible (true);
}
}
void WindowManager::allowMouse()
{
void WindowManager::allowMouse()
{
mInputBlocker->setVisible (!isGuiMode ());
}
}
void WindowManager::notifyInputActionBound ()
{
void WindowManager::notifyInputActionBound ()
{
mSettingsWindow->updateControlsBox ();
allowMouse();
}
}
void WindowManager::showCrosshair (bool show)
{
void WindowManager::showCrosshair (bool show)
{
mHud->setCrosshairVisible (show && mCrosshairEnabled);
}
}
void WindowManager::activateQuickKey (int index)
{
void WindowManager::activateQuickKey (int index)
{
mQuickKeysMenu->activateQuickKey(index);
}
}
bool WindowManager::getSubtitlesEnabled ()
{
bool WindowManager::getSubtitlesEnabled ()
{
return mSubtitlesEnabled;
}
}
void WindowManager::toggleHud ()
{
void WindowManager::toggleHud ()
{
mHudEnabled = !mHudEnabled;
mHud->setVisible (mHudEnabled);
}
}
void WindowManager::setLoadingProgress (const std::string& stage, int depth, int current, int total)
{
void WindowManager::setLoadingProgress (const std::string& stage, int depth, int current, int total)
{
mLoadingScreen->setLoadingProgress (stage, depth, current, total);
}
}
void WindowManager::loadingDone ()
{
void WindowManager::loadingDone ()
{
mLoadingScreen->loadingDone ();
}
}
bool WindowManager::getPlayerSleeping ()
{
bool WindowManager::getPlayerSleeping ()
{
return mWaitDialog->getSleeping();
}
}
void WindowManager::wakeUpPlayer()
{
void WindowManager::wakeUpPlayer()
{
mWaitDialog->wakeUp();
}
}
void WindowManager::addVisitedLocation(const std::string& name, int x, int y)
{
void WindowManager::addVisitedLocation(const std::string& name, int x, int y)
{
mMap->addVisitedLocation (name, x, y);
}
}
void WindowManager::startSpellMaking(MWWorld::Ptr actor)
{
void WindowManager::startSpellMaking(MWWorld::Ptr actor)
{
mSpellCreationDialog->startSpellMaking (actor);
}
}
void WindowManager::startEnchanting (MWWorld::Ptr actor)
{
void WindowManager::startEnchanting (MWWorld::Ptr actor)
{
mEnchantingDialog->startEnchanting (actor);
}
}
void WindowManager::startSelfEnchanting(MWWorld::Ptr soulgem)
{
void WindowManager::startSelfEnchanting(MWWorld::Ptr soulgem)
{
mEnchantingDialog->startSelfEnchanting(soulgem);
}
}
void WindowManager::startTraining(MWWorld::Ptr actor)
{
void WindowManager::startTraining(MWWorld::Ptr actor)
{
mTrainingWindow->startTraining(actor);
}
}
void WindowManager::startRepair(MWWorld::Ptr actor)
{
void WindowManager::startRepair(MWWorld::Ptr actor)
{
mMerchantRepair->startRepair(actor);
}
}
void WindowManager::startRepairItem(MWWorld::Ptr item)
{
void WindowManager::startRepairItem(MWWorld::Ptr item)
{
mRepair->startRepairItem(item);
}
}
const Translation::Storage& WindowManager::getTranslationDataStorage() const
{
const Translation::Storage& WindowManager::getTranslationDataStorage() const
{
return mTranslationDataStorage;
}
}
void WindowManager::showCompanionWindow(MWWorld::Ptr actor)
{
void WindowManager::showCompanionWindow(MWWorld::Ptr actor)
{
mCompanionWindow->open(actor);
}
}
void WindowManager::changePointer(const std::string &name)
{
void WindowManager::changePointer(const std::string &name)
{
mCursor->onCursorChange(name);
}
}
void WindowManager::showSoulgemDialog(MWWorld::Ptr item)
{
void WindowManager::showSoulgemDialog(MWWorld::Ptr item)
{
mSoulgemDialog->show(item);
}
}
void WindowManager::frameStarted (float dt)
{
void WindowManager::frameStarted (float dt)
{
mInventoryWindow->doRenderUpdate ();
}
}

15
apps/openmw/mwgui/windowpinnablebase.cpp
View file

@ -2,19 +2,19 @@
#include "exposedwindow.hpp"
using namespace MWGui;
WindowPinnableBase::WindowPinnableBase(const std::string& parLayout)
: WindowBase(parLayout), mPinned(false), mVisible(false)
namespace MWGui
{
WindowPinnableBase::WindowPinnableBase(const std::string& parLayout)
: WindowBase(parLayout), mPinned(false), mVisible(false)
{
ExposedWindow* window = static_cast<ExposedWindow*>(mMainWidget);
mPinButton = window->getSkinWidget ("Button");
mPinButton->eventMouseButtonClick += MyGUI::newDelegate(this, &WindowPinnableBase::onPinButtonClicked);
}
}
void WindowPinnableBase::onPinButtonClicked(MyGUI::Widget* _sender)
{
void WindowPinnableBase::onPinButtonClicked(MyGUI::Widget* _sender)
{
mPinned = !mPinned;
if (mPinned)
@ -23,4 +23,5 @@ void WindowPinnableBase::onPinButtonClicked(MyGUI::Widget* _sender)
mPinButton->changeWidgetSkin ("PinUp");
onPinToggled();
}
}

2
apps/openmw/mwmechanics/mechanicsmanagerimp.cpp
View file

@ -548,7 +548,7 @@ namespace MWMechanics
float bribeMod;
if (type == PT_Bribe10) bribeMod = gmst.find("fBribe10Mod")->getFloat();
if (type == PT_Bribe100) bribeMod = gmst.find("fBribe100Mod")->getFloat();
else if (type == PT_Bribe100) bribeMod = gmst.find("fBribe100Mod")->getFloat();
else bribeMod = gmst.find("fBribe1000Mod")->getFloat();
float target3 = d * (playerRating3 - npcRating3 + 50) + bribeMod;

33
apps/openmw/mwmechanics/pathfinding.cpp
View file

@ -1,5 +1,5 @@
#include "pathfinding.hpp"
#include <boost/graph/astar_search.hpp>
#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/graph/adjacency_list.hpp>
#include "boost/tuple/tuple.hpp"
#include "OgreMath.h"
@ -55,7 +55,7 @@ namespace
struct found_path {};
class goalVisited : public boost::default_astar_visitor
/*class goalVisited : public boost::default_astar_visitor
{
public:
goalVisited(PointID goal) : mGoal(goal) {}
@ -69,7 +69,7 @@ namespace
PointID mGoal;
};
class DistanceHeuristic : public boost::astar_heuristic <PathGridGraph, float>
class DistanceHeuristic : public boost::atasr_heuristic <PathGridGraph, float>
{
public:
DistanceHeuristic(const PathGridGraph & l, PointID goal)
@ -87,11 +87,23 @@ namespace
private:
const PathGridGraph & mGraph;
PointID mGoal;
};
}
};*/
class goalVisited : public boost::default_dijkstra_visitor
{
public:
goalVisited(PointID goal) : mGoal(goal) {}
void examine_vertex(PointID u, const PathGridGraph g)
{
if(u == mGoal)
throw found_path();
}
private:
PointID mGoal;
};
namespace MWMechanics
{
PathGridGraph buildGraph(const ESM::Pathgrid* pathgrid,float xCell = 0,float yCell = 0)
{
PathGridGraph graph;
@ -126,11 +138,10 @@ namespace MWMechanics
std::list<ESM::Pathgrid::Point> shortest_path;
try {
boost::astar_search
boost::dijkstra_shortest_paths
(
graph,
start,
DistanceHeuristic(graph,end),
boost::predecessor_map(&p[0]).distance_map(&d[0]).visitor(goalVisited(end))//.weight_map(boost::get(&Edge::distance, graph))
);
@ -146,6 +157,10 @@ namespace MWMechanics
//end of helpers functions
}
namespace MWMechanics
{
PathFinder::PathFinder()
{
mIsPathConstructed = false;

12
apps/openmw/mwworld/store.hpp
View file

@ -415,8 +415,18 @@ namespace MWWorld
}
};
struct DynamicExtCmp
{
bool operator()(const std::pair<int, int> &left, const std::pair<int, int> &right) const {
if (left.first == right.first) {
return left.second < right.second;
}
return left.first < right.first;
}
};
typedef std::map<std::string, ESM::Cell> DynamicInt;
typedef std::map<std::pair<int, int>, ESM::Cell> DynamicExt;
typedef std::map<std::pair<int, int>, ESM::Cell, DynamicExtCmp> DynamicExt;
DynamicInt mInt;
DynamicExt mExt;

4
libs/openengine/bullet/physic.cpp
View file

@ -511,8 +511,8 @@ namespace Physic
void PhysicEngine::stepSimulation(double deltaT)
{
// This isn't needed as there are no dynamic objects at this point
//dynamicsWorld->stepSimulation(deltaT,10, 1/60.0);
// This seems to be needed for character controller objects
dynamicsWorld->stepSimulation(deltaT,10, 1/60.0);
if(isDebugCreated)
{
mDebugDrawer->step();

61
readme.txt
View file

@ -3,7 +3,7 @@ OpenMW: A reimplementation of The Elder Scrolls III: Morrowind
OpenMW is an attempt at recreating the engine for the popular role-playing game
Morrowind by Bethesda Softworks. You need to own and install the original game for OpenMW to work.
Version: 0.22.0
Version: 0.23.0
License: GPL (see GPL3.txt for more information)
Website: http://www.openmw.org
@ -94,6 +94,65 @@ Allowed options:
CHANGELOG
0.23.0
Bug #522: Player collides with placeable items
Bug #553: Open/Close sounds played when accessing main menu w/ Journal Open
Bug #561: Tooltip word wrapping delay
Bug #578: Bribing works incorrectly
Bug #601: PositionCell fails on negative coordinates
Bug #606: Some NPCs hairs not rendered with Better Heads addon
Bug #609: Bad rendering of bone boots
Bug #613: Messagebox causing assert to fail
Bug #631: Segfault on shutdown
Bug #634: Exception when talking to Calvus Horatius in Mournhold, royal palace courtyard
Bug #635: Scale NPCs depending on race
Bug #643: Dialogue Race select function is inverted
Bug #646: Twohanded weapons don't work properly
Bug #654: Crash when dropping objects without a collision shape
Bug #655/656: Objects that were disabled or deleted (but not both) were added to the scene when re-entering a cell
Bug #660: "g" in "change" cut off in Race Menu
Bug #661: Arrille sells me the key to his upstairs room
Bug #662: Day counter starts at 2 instead of 1
Bug #663: Cannot select "come unprepared" topic in dialog with Dagoth Ur
Bug #665: Pickpocket -> "Grab all" grabs all NPC inventory, even not listed in container window.
Bug #666: Looking up/down problem
Bug #667: Active effects border visible during loading
Bug #669: incorrect player position at new game start
Bug #670: race selection menu: sex, face and hair left button not totally clickable
Bug #671: new game: player is naked
Bug #674: buying or selling items doesn't change amount of gold
Bug #675: fatigue is not set to its maximum when starting a new game
Bug #678: Wrong rotation order causes RefData's rotation to be stored incorrectly
Bug #680: different gold coins in Tel Mara
Bug #682: Race menu ignores playable flag for some hairs and faces
Bug #685: Script compiler does not accept ":" after a function name
Bug #688: dispose corpse makes cross-hair to disappear
Bug #691: Auto equipping ignores equipment conditions
Bug #692: OpenMW doesnt load "loose file" texture packs that places resources directly in data folder
Bug #696: Draugr incorrect head offset
Bug #697: Sail transparency issue
Bug #700: "On the rocks" mod does not load its UV coordinates correctly.
Bug #702: Some race mods don't work
Bug #711: Crash during character creation
Bug #715: Growing Tauryon
Feature #55/657: Item Repairing
Feature #62/87: Enchanting
Feature #99: Pathfinding
Feature #104: AI Package: Travel
Feature #129: Levelled items
Feature #204: Texture animations
Feature #239: Fallback-Settings
Feature #535: Console object selection improvements
Feature #629: Add levelup description in levelup layout dialog
Feature #630: Optional format subrecord in (tes3) header
Feature #641: Armor rating
Feature #645: OnDeath script function
Feature #683: Companion item UI
Feature #698: Basic Particles
Task #648: Split up components/esm/loadlocks
Task #695: mwgui cleanup
0.22.0
Bug #311: Potential infinite recursion in script compiler