void RegionTextureControl::updateRegionProperty(Property* _sender, const MyGUI::UString& _owner)
{
if (_owner != mTypeName)
{
if (_sender->getName() == "Position")
updatePosition();
else if (_sender->getName() == "Visible")
updateVisible();
else if (_sender->getName() == "Enabled")
updateVisible();
}
}
void Slot::setVisible(bool value) {
if(value != this->visible)
{
this->visible = value;
updateVisible(this->visible);
}
}
void ToolBarChanger::removeItem(QAction *AHandle)
{
QWidget *widget = FHandles.key(AHandle, NULL);
if (widget && AHandle!=FAllignChange)
{
AHandle->deleteLater();
FToolBar->removeAction(AHandle);
disconnect(widget,SIGNAL(destroyed(QObject *)),this,SLOT(onWidgetDestroyed(QObject *)));
Action *action = FButtons.key(qobject_cast<QToolButton *>(widget), NULL);
if (action)
FButtons.take(action)->deleteLater();
int group = FWidgets.key(widget);
FWidgets.remove(group,widget);
if (!FWidgets.contains(group))
{
QAction *separator = FSeparators.take(group);
FToolBar->removeAction(separator);
delete separator;
updateSeparatorVisible();
}
if (FWidgets.keys().last()<=TBG_ALLIGN_CHANGE)
{
FAllignChange->setVisible(false);
}
FHandles.remove(widget);
emit itemRemoved(AHandle);
updateVisible();
}
void StateTextureControl::updateStateProperties()
{
updateVisible();
updatePosition();
updateUnselectedStates();
}
void
AnGenericRowProvider::addRow(AnListClass *row)
{
allrows_.push_back(row);
addSubject(row); /* Register at observer */
updateVisible();
}
void Water::setActive(bool active)
{
mActive = active;
updateVisible();
sh::Factory::getInstance ().setSharedParameter ("waterEnabled", sh::makeProperty<sh::FloatValue> (new sh::FloatValue(active ? 1.0 : 0.0)));
}
void Water::applyRTT()
{
delete mReflection;
mReflection = NULL;
delete mRefraction;
mRefraction = NULL;
// Create rendertarget for reflection
//int rttsize = Settings::Manager::getInt("rtt size", "Water");
if (Settings::Manager::getBool("shader", "Water"))
{
mReflection = new PlaneReflection(mSceneMgr, mSky);
mReflection->setParentCamera (mCamera);
mReflection->setHeight(mTop);
if (Settings::Manager::getBool("refraction", "Water"))
{
mRefraction = new Refraction(mCamera);
mRefraction->setHeight(mTop);
}
}
updateVisible();
}
QAction *ToolBarChanger::insertWidget(QWidget *AWidget, int AGroup)
{
if (!FWidgets.values().contains(AWidget))
{
if (AGroup > TBG_ALLIGN_CHANGE)
FAllignChange->setVisible(true);
QMap<int, QAction *>::const_iterator it = FSeparators.upperBound(AGroup);
QAction *before = it!=FSeparators.end() ? it.value() : NULL;
QAction *handle = before!=NULL ? FToolBar->insertWidget(before, AWidget) : FToolBar->addWidget(AWidget);
if (!FSeparators.contains(AGroup))
{
QAction *separator = FToolBar->insertSeparator(handle);
separator->setVisible(FSeparatorsVisible);
FSeparators.insert(AGroup, separator);
updateSeparatorVisible();
}
FWidgets.insertMulti(AGroup,AWidget);
FHandles.insert(AWidget, handle);
connect(AWidget,SIGNAL(destroyed(QObject *)),SLOT(onWidgetDestroyed(QObject *)));
emit itemInserted(before,handle,FButtons.key(qobject_cast<QToolButton *>(AWidget)),AWidget,AGroup);
updateVisible();
}
return FHandles.value(AWidget);
}
void WidgetListBox::subActive(Widget &widget) {
if (widget.getTag().endsWith("#Up")) {
scrollUp(1);
return;
}
if (widget.getTag().endsWith("#Down")) {
scrollDown(1);
return;
}
if (widget.getTag().endsWith("#Bar")) {
ptrdiff_t max = _items.size() - _visibleItems.size();
if (max <= 0)
return;
size_t startItem = _scrollbar->getState() * max;
if (startItem == _startItem)
return;
_startItem = startItem;
updateVisible();
return;
}
WidgetListItem *listItem = dynamic_cast<WidgetListItem *>(&widget);
if (listItem) {
if (_selectedItem != listItem->_itemNumber) {
_selectedItem = listItem->_itemNumber;
setActive(true);
}
}
}
/**
* @inheritDoc
*/
void Slot::setVisible(bool value)
{
if(value != _visible)
{
_visible = value;
updateVisible(_visible);
}
}
void WindowManager::disallowAll()
{
mAllowed = GW_None;
mBookWindow->setInventoryAllowed (false);
mScrollWindow->setInventoryAllowed (false);
updateVisible();
}
bool
AnGenericRowProvider::removeRawRow(unsigned int idx)
{
if (idx >= allrows_.size())
return false;
removeSubject(allrows_[idx]);
allrows_.erase(allrows_.begin()+idx);
updateVisible();
return true;
}
void WindowManager::popGuiMode()
{
if (!mGuiModes.empty())
mGuiModes.pop_back();
bool gameMode = !isGuiMode();
MWBase::Environment::get().getInputManager()->changeInputMode(!gameMode);
updateVisible();
}
void
AnGenericRowProvider::setSortProperty(AnListProperty *sortprop)
{
if (sortProperty_)
removeSubject(sortProperty_);
sortProperty_ = sortprop;
if (sortProperty_)
addSubject(sortProperty_);
updateVisible();
}
void
AnGenericRowProvider::setFilterProperty(AnListProperty *filter)
{
if (filterProperty_)
removeSubject(filterProperty_);
filterProperty_ = filter;
if (filterProperty_)
addSubject(filterProperty_);
filterString_ = wxEmptyString;
updateVisible();
}
void WidgetListBox::scrollUp(size_t n) {
if (_visibleItems.empty())
return;
if (_startItem == 0)
return;
_startItem -= MIN<size_t>(n, _startItem);
updateVisible();
updateScrollbarPosition();
}
void WidgetListBox::scrollDown(size_t n) {
if (_visibleItems.empty())
return;
if (_startItem + _visibleItems.size() >= _items.size())
return;
_startItem += MIN<size_t>(n, _items.size() - _visibleItems.size() - _startItem);
updateVisible();
updateScrollbarPosition();
}
void WidgetGridBox::scrollUp(uint n) {
if (_visibleItems.empty())
return;
if (_startItem == 0)
return;
_startItem -= MIN<uint>(n * _itemsByRow, _startItem);
updateVisible();
updateScrollbarPosition();
}
void WindowManager::allow (GuiWindow wnd)
{
mAllowed = (GuiWindow)(mAllowed | wnd);
if (wnd & GW_Inventory)
{
mBookWindow->setInventoryAllowed (true);
mScrollWindow->setInventoryAllowed (true);
}
updateVisible();
}
void
AnGenericRowProvider::setRowData(const std::vector<AnListClass *> &rowData)
{
clearRows();
std::vector<AnListClass *>::const_iterator it;
for (it = rowData.begin(); it != rowData.end(); ++it) {
addSubject(*it);
allrows_.push_back(*it);
}
updateVisible();
}
void SeparatorTextureControl::updateSeparatorProperty(Property* _sender, const MyGUI::UString& _owner)
{
if (_owner != mTypeName)
{
if (_sender->getName() == "Offset")
updatePosition();
else if (_sender->getName() == "Visible")
{
updateVisible();
updateUnselectedStates();
}
}
}
void WidgetGridBox::scrollDown(uint n) {
if (_visibleItems.empty())
return;
if (_startItem + _visibleItems.size() >= _items.size())
return;
_startItem += MIN<uint>(n * _itemsByRow, (_items.size() + _items.size() %
_itemsByRow) - _visibleItems.size() - _startItem);
updateVisible();
updateScrollbarPosition();
}
void WindowManager::removeGuiMode(GuiMode mode)
{
std::vector<GuiMode>::iterator it = mGuiModes.begin();
while (it != mGuiModes.end())
{
if (*it == mode)
it = mGuiModes.erase(it);
else
++it;
}
bool gameMode = !isGuiMode();
MWBase::Environment::get().getInputManager()->changeInputMode(!gameMode);
updateVisible();
}
void
Water::updateUnderwater(bool underwater)
{
if (!mActive) {
return;
}
mIsUnderwater =
underwater &&
mWater->isVisible() &&
mCamera->getPolygonMode() == Ogre::PM_SOLID;
if (mReflection)
mReflection->setUnderwater (mIsUnderwater);
if (mRefraction)
mRefraction->setUnderwater (mIsUnderwater);
updateVisible();
}
void WindowManager::pushGuiMode(GuiMode mode)
{
if (mode==GM_Inventory && mAllowed==GW_None)
return;
// If this mode already exists somewhere in the stack, just bring it to the front.
if (std::find(mGuiModes.begin(), mGuiModes.end(), mode) != mGuiModes.end())
{
mGuiModes.erase(std::find(mGuiModes.begin(), mGuiModes.end(), mode));
}
mGuiModes.push_back(mode);
bool gameMode = !isGuiMode();
MWBase::Environment::get().getInputManager()->changeInputMode(!gameMode);
updateVisible();
}
void WidgetGridBox::subActive(Widget &widget) {
if (widget.getTag().endsWith("#Up")) {
scrollUp(1);
return;
}
if (widget.getTag().endsWith("#Down")) {
scrollDown(1);
return;
}
if (widget.getTag().endsWith("#Bar")) {
if (_itemsByRow == 0)
return;
// Round up
const size_t rowCount = (_items.size() + (_itemsByRow - 1)) / _itemsByRow;
const size_t visibleRow = (_visibleItems.size() + (_itemsByRow - 1)) / _itemsByRow;
const ptrdiff_t maxStartRow = rowCount - visibleRow;
if (maxStartRow <= 0)
return;
const size_t startRow = _scrollbar->getState() * maxStartRow;
const size_t startItem = startRow * _itemsByRow;
if (startItem == _startItem)
return;
_startItem = startItem;
updateVisible();
return;
}
WidgetListItem *listItem = dynamic_cast<WidgetListItem *>(&widget);
if (listItem) {
if (_selectedItem != listItem->getItemNumber()) {
_selectedItem = listItem->getItemNumber();
setActive(true);
playSound("gui_button", Sound::kSoundTypeSFX);
}
}
}
ToolBarChanger::ToolBarChanger(QToolBar *AToolBar) : QObject(AToolBar)
{
FIntVisible = false;
FExtVisible = AToolBar->isVisible();
FSeparatorsVisible = true;
FManageVisibility = true;
FVisibleTimerStarted = false;
FChangingIntVisible = 0;
FToolBar = AToolBar;
FToolBar->clear();
FToolBar->installEventFilter(this);
QWidget *widget = new QWidget(FToolBar);
widget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
FAllignChange = insertWidget(widget, TBG_ALLIGN_CHANGE);
FAllignChange->setVisible(false);
updateVisible();
}
void WidgetGridBox::subActive(Widget &widget) {
if (widget.getTag().endsWith("#Up")) {
scrollUp(1);
return;
}
if (widget.getTag().endsWith("#Down")) {
scrollDown(1);
return;
}
if (widget.getTag().endsWith("#Bar")) {
if (_items.size() - _visibleItems.size() == 0)
return;
uint maxIfFilled = _items.size() + _itemsByRow - _items.size() % _itemsByRow;
uint maxVisible = floor(_contentHeight / _items.front()->getHeight()) * _itemsByRow;
uint startItem = floor(_scrollbar->getState() * (maxIfFilled - maxVisible)
/ _itemsByRow) * _itemsByRow;
if (startItem == _startItem)
return;
_startItem = startItem;
updateVisible();
return;
}
WidgetListItem *listItem = dynamic_cast<WidgetListItem *>(&widget);
if (listItem) {
if (_selectedItem != listItem->getItemNumber()) {
_selectedItem = listItem->getItemNumber();
setActive(true);
playSound("gui_button", Sound::kSoundTypeSFX);
}
}
}
void Water::updateWaterMaterial()
{
if (mReflection)
{
mReflection->removeChildren(0, mReflection->getNumChildren());
mParent->removeChild(mReflection);
mReflection = NULL;
}
if (mRefraction)
{
mRefraction->removeChildren(0, mRefraction->getNumChildren());
mParent->removeChild(mRefraction);
mRefraction = NULL;
}
if (Settings::Manager::getBool("shader", "Water"))
{
mReflection = new Reflection;
mReflection->setWaterLevel(mTop);
mReflection->setScene(mSceneRoot);
mParent->addChild(mReflection);
if (Settings::Manager::getBool("refraction", "Water"))
{
mRefraction = new Refraction;
mRefraction->setWaterLevel(mTop);
mRefraction->setScene(mSceneRoot);
mParent->addChild(mRefraction);
}
createShaderWaterStateSet(mWaterGeom, mReflection, mRefraction);
}
else
createSimpleWaterStateSet(mWaterGeom, mFallback->getFallbackFloat("Water_World_Alpha"));
updateVisible();
}
void Water::toggle()
{
mToggled = !mToggled;
updateVisible();
}
