dropdown.cpp

Go to the documentation of this file.

/*
 * The ManaPlus Client
 * Copyright (C) 2006-2009 The Mana World Development Team
 * Copyright (C) 2009-2010 The Mana Developers
 * Copyright (C) 2011-2019 The ManaPlus Developers
 * Copyright (C) 2019-2021 Andrei Karas
 *
 * This file is part of The ManaPlus Client.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "gui/widgets/dropdown.h"
 
#include "settings.h"
 
#include "gui/gui.h"
#include "gui/skin.h"
 
#include "gui/fonts/font.h"
 
#include "gui/models/extendedlistmodel.h"
 
#include "gui/widgets/createwidget.h"
#include "gui/widgets/popuplist.h"
 
#include "render/graphics.h"
 
#include "resources/imagerect.h"
 
#include "debug.h"
 
int DropDown::instances = 0;
Image *DropDown::buttons[2][2];
ImageRect DropDown::skinRect;
float DropDown::mAlpha = 1.0;
Skin *DropDown::mSkin = nullptr;
 
static std::string const dropdownFiles[2] =
{
 "dropdown.xml",
 "dropdown_pressed.xml"
};
 
DropDown::DropDown(const Widget2 *const widget,
 ListModel *const listModel,
 const bool isExtended,
 const Modal modal,
 ActionListener *const listener,
 const std::string &eventId) :
 ActionListener(),
 BasicContainer(widget),
 KeyListener(),
 MouseListener(),
 FocusListener(),
 SelectionListener(),
 mPopup(CREATEWIDGETR(PopupList, this, listModel, isExtended, modal)),
 mShadowColor(getThemeColor(ThemeColorId::DROPDOWN_SHADOW, 255U)),
 mHighlightColor(getThemeColor(ThemeColorId::HIGHLIGHT, 255U)),
 mPadding(1),
 mImagePadding(2),
 mSpacing(0),
 mFoldedUpHeight(0),
 mSelectionListeners(),
 mExtended(isExtended),
 mDroppedDown(false),
 mPushed(false),
 mIsDragged(false)
{
 mAllowLogic = false;
 mFrameSize = 2;
 mForegroundColor2 = getThemeColor(ThemeColorId::DROPDOWN_OUTLINE, 255U);
 
 mPopup->setHeight(100);
 
 // Initialize graphics
 if (instances == 0 && (theme != nullptr))
 {
 // Load the background skin
 for (int i = 0; i < 2; i ++)
 {
 Skin *const skin = theme->load(dropdownFiles[i],
 "dropdown.xml",
 true,
 Theme::getThemePath());
 if (skin != nullptr)
 {
 if (i == 0)
 mSkin = skin;
 const ImageRect &rect = skin->getBorder();
 for (int f = 0; f < 2; f ++)
 {
 if (rect.grid[f] != nullptr)
 {
 rect.grid[f]->incRef();
 buttons[f][i] = rect.grid[f];
 buttons[f][i]->setAlpha(mAlpha);
 }
 else
 {
 buttons[f][i] = nullptr;
 }
 }
 if (i != 0)
 theme->unload(skin);
 }
 else
 {
 for (int f = 0; f < 2; f ++)
 buttons[f][i] = nullptr;
 }
 }
 
 // get the border skin
 theme->loadRect(skinRect, "dropdown_background.xml", "", 0, 8);
 }
 
 instances++;
 
 setWidth(100);
 setFocusable(true);
 setListModel(listModel);
 
 if (mPopup->getSelected() < 0)
 mPopup->setSelected(0);
 
 addMouseListener(this);
 addKeyListener(this);
 addFocusListener(this);
 
 adjustHeight();
// mPopup->setForegroundColorAll(getThemeColor(ThemeColorId::DROPDOWN,
// 255U),
// getThemeColor(ThemeColorId::DROPDOWN_OUTLINE, 255U));
 mForegroundColor = getThemeColor(ThemeColorId::DROPDOWN, 255U);
 mForegroundColor2 = getThemeColor(ThemeColorId::DROPDOWN_OUTLINE, 255U);
 
 if (!eventId.empty())
 setActionEventId(eventId);
 
 if (listener != nullptr)
 addActionListener(listener);
 
 mPopup->adjustSize();
 
 if (mSkin != nullptr)
 {
 mSpacing = mSkin->getOption("spacing");
 mFrameSize = CAST_U32(mSkin->getOption("frameSize"));
 mPadding = mSkin->getPadding();
 mImagePadding = mSkin->getOption("imagePadding");
 }
 adjustHeight();
}
 
DropDown::~DropDown()
{
 if (gui != nullptr)
 gui->removeDragged(this);
 
 instances--;
 if (instances == 0)
 {
 for (int f = 0; f < 2; f ++)
 {
 for (int i = 0; i < 2; i ++)
 {
 if (buttons[f][i] != nullptr)
 buttons[f][i]->decRef();
 }
 }
 if (theme != nullptr)
 {
 theme->unload(mSkin);
 Theme::unloadRect(skinRect, 0, 8);
 }
 }
}
 
void DropDown::updateAlpha()
{
 const float alpha = std::max(settings.guiAlpha,
 theme->getMinimumOpacity());
 
 if (mAlpha != alpha)
 {
 mAlpha = alpha;
 
 if (buttons[0][0] != nullptr)
 buttons[0][0]->setAlpha(mAlpha);
 if (buttons[0][1] != nullptr)
 buttons[0][1]->setAlpha(mAlpha);
 if (buttons[1][0] != nullptr)
 buttons[1][0]->setAlpha(mAlpha);
 if (buttons[1][1] != nullptr)
 buttons[1][1]->setAlpha(mAlpha);
 
 for (int a = 0; a < 9; a++)
 {
 if (skinRect.grid[a] != nullptr)
 skinRect.grid[a]->setAlpha(mAlpha);
 }
 }
}
 
void DropDown::draw(Graphics *const graphics)
{
 BLOCK_START("DropDown::draw")
 int h;
 
 if (mDroppedDown)
 h = mFoldedUpHeight;
 else
 h = mDimension.height;
 
 updateAlpha();
 
 const unsigned int alpha = CAST_U32(mAlpha * 255.0F);
 mHighlightColor.a = alpha;
 mShadowColor.a = alpha;
 
 ListModel *const model = mPopup->getListModel();
 if ((model != nullptr) && mPopup->getSelected() >= 0)
 {
 Font *const font = getFont();
 if (mExtended)
 {
 const int sel = mPopup->getSelected();
 ExtendedListModel *const model2
 = static_cast<ExtendedListModel *>(model);
 const Image *const image = model2->getImageAt(sel);
 if (image == nullptr)
 {
 font->drawString(graphics,
 mForegroundColor,
 mForegroundColor2,
 model->getElementAt(sel),
 mPadding, mPadding);
 }
 else
 {
 graphics->drawImage(image,
 mImagePadding,
 (mDimension.height - image->getHeight()) / 2 + mPadding);
 font->drawString(graphics,
 mForegroundColor,
 mForegroundColor2,
 model->getElementAt(sel),
 image->getWidth() + mImagePadding + mSpacing, mPadding);
 }
 }
 else
 {
 font->drawString(graphics,
 mForegroundColor,
 mForegroundColor2,
 model->getElementAt(mPopup->getSelected()),
 mPadding, mPadding);
 }
 }
 
 if (isFocused())
 {
 const int pad = 2 * mPadding;
 graphics->setColor(mHighlightColor);
 graphics->drawRectangle(Rect(mPadding, mPadding,
 mDimension.width - h - pad, h - pad));
 }
 
 drawButton(graphics);
 
 if (mDroppedDown)
 {
 // Draw two lines separating the ListBox with selected
 // element view.
 const int w = mDimension.width;
 graphics->setColor(mHighlightColor);
 graphics->drawLine(0, h, w, h);
 graphics->setColor(mShadowColor);
 graphics->drawLine(0, h + 1, w, h + 1);
 }
 BLOCK_END("DropDown::draw")
}
 
void DropDown::safeDraw(Graphics *const graphics)
{
 DropDown::draw(graphics);
}
 
void DropDown::drawFrame(Graphics *const graphics)
{
 BLOCK_START("DropDown::drawFrame")
 const int bs2 = CAST_S32(getFrameSize());
 const Rect &rect = mDimension;
 graphics->drawImageRect(0, 0,
 rect.width + bs2, rect.height + bs2,
 skinRect);
 BLOCK_END("DropDown::drawFrame")
}
 
void DropDown::safeDrawFrame(Graphics *const graphics)
{
 BLOCK_START("DropDown::drawFrame")
 const int bs2 = CAST_S32(getFrameSize());
 const Rect &rect = mDimension;
 graphics->drawImageRect(0, 0,
 rect.width + bs2, rect.height + bs2,
 skinRect);
 BLOCK_END("DropDown::drawFrame")
}
 
void DropDown::drawButton(Graphics *const graphics)
{
 Image *const image = buttons[mDroppedDown][mPushed];
 if (image != nullptr)
 {
 const int height = mDroppedDown ? mFoldedUpHeight : mDimension.height;
 graphics->drawImage(image,
 mDimension.width - image->getWidth() - mImagePadding,
 (height - image->getHeight()) / 2);
 }
}
 
void DropDown::keyPressed(KeyEvent& event)
{
 if (event.isConsumed())
 return;
 
 const InputActionT actionId = event.getActionId();
 PRAGMA45(GCC diagnostic push)
 PRAGMA45(GCC diagnostic ignored "-Wswitch-enum")
 switch (actionId)
 {
 case InputAction::GUI_SELECT:
 case InputAction::GUI_SELECT2:
 dropDown();
 break;
 
 case InputAction::GUI_UP:
 setSelected(getSelected() - 1);
 break;
 
 case InputAction::GUI_DOWN:
 setSelected(getSelected() + 1);
 break;
 
 case InputAction::GUI_HOME:
 setSelected(0);
 break;
 
 case InputAction::GUI_END:
 if (mPopup->getListModel() != nullptr)
 {
 setSelected(mPopup->getListModel()->
 getNumberOfElements() - 1);
 }
 break;
 
 default:
 return;
 }
 PRAGMA45(GCC diagnostic pop)
 
 event.consume();
}
 
void DropDown::hideDrop(bool event)
{
 if (event)
 distributeActionEvent();
 mPopup->setVisible(Visible_false);
}
 
void DropDown::mousePressed(MouseEvent& event)
{
 event.consume();
 // If we have a mouse press on the widget.
 if (event.getButton() == MouseButton::LEFT
 && !mDroppedDown && event.getSource() == this)
 {
 mPushed = true;
 dropDown();
 }
 else
 {
 mPushed = false;
 foldUp();
 hideDrop(true);
 }
}
 
void DropDown::mouseReleased(MouseEvent &event)
{
 if (mIsDragged)
 mPushed = false;
 
 const MouseButtonT button = event.getButton();
 const int x = event.getX();
 const int y = event.getY();
 // Released outside of widget. Can happen when we have modal
 // input focus.
 if ((0 > y || y >= mDimension.height || x < 0 || x >= mDimension.width)
 && button == MouseButton::LEFT)
 {
 if (mIsDragged)
 foldUp();
 }
 else if (button == MouseButton::LEFT)
 {
 mPushed = false;
 }
 
 mIsDragged = false;
}
 
void DropDown::mouseDragged(MouseEvent &event)
{
 mIsDragged = true;
 event.consume();
}
 
void DropDown::mouseWheelMovedUp(MouseEvent& event)
{
 setSelected(getSelected() - 1);
 event.consume();
}
 
void DropDown::mouseWheelMovedDown(MouseEvent& event)
{
 setSelected(getSelected() + 1);
 event.consume();
}
 
void DropDown::setSelectedString(const std::string &str)
{
 ListModel *const listModel = mPopup->getListModel();
 if (listModel == nullptr)
 return;
 
 for (int f = 0; f < listModel->getNumberOfElements(); f ++)
 {
 if (listModel->getElementAt(f) == str)
 {
 setSelected(f);
 break;
 }
 }
}
 
std::string DropDown::getSelectedString() const
{
 ListModel *const listModel = mPopup->getListModel();
 if (listModel == nullptr)
 return "";
 
 return listModel->getElementAt(getSelected());
}
 
void DropDown::adjustHeight()
{
 setHeight(getFont()->getHeight() + 2 * mPadding);
}
 
void DropDown::dropDown()
{
 if (!mDroppedDown)
 {
 if (mParent == nullptr)
 return;
 mDroppedDown = true;
 mFoldedUpHeight = getHeight();
 adjustHeight();
 
 int x = 0;
 int y = 0;
 getAbsolutePosition(x, y);
 const int frame = CAST_S32(mParent->getFrameSize());
 const int pad = mPopup->getPadding();
 const int pad2 = pad * 2;
 
 // here width should be adjusted on some other parameters
 mPopup->setWidth(mDimension.width - pad2 + 8);
 mPopup->show(x - mPadding - frame - 1, y + mDimension.height);
 mPopup->requestMoveToTop();
 mPopup->requestFocus();
 }
}
 
void DropDown::foldUp()
{
 if (mDroppedDown)
 {
 mDroppedDown = false;
 adjustHeight();
 }
}
 
int DropDown::getSelected() const
{
 return mPopup->getSelected();
}
 
void DropDown::setSelected(int selected)
{
 if (selected >= 0)
 mPopup->setSelected(selected);
}
 
void DropDown::setListModel(ListModel *const listModel)
{
 mPopup->setListModel(listModel);
 
 if (mPopup->getSelected() < 0)
 mPopup->setSelected(0);
 
 adjustHeight();
}
 
ListModel *DropDown::getListModel()
{
 return mPopup->getListModel();
}
 
void DropDown::action(const ActionEvent &actionEvent A_UNUSED)
{
 foldUp();
 distributeActionEvent();
}
 
Rect DropDown::getChildrenArea()
{
 if (mDroppedDown)
 {
 // Calculate the children area (with the one pixel border in mind)
 return Rect(1, mFoldedUpHeight + 1,
 mDimension.width - 2, mDimension.height - mFoldedUpHeight - 2);
 }
 
 return Rect();
}
 
void DropDown::valueChanged(const SelectionEvent& event A_UNUSED)
{
}
 
void DropDown::updateSelection()
{
 mDroppedDown = false;
 mPushed = false;
 distributeActionEvent();
 distributeValueChangedEvent();
}
 
void DropDown::addSelectionListener(SelectionListener* selectionListener)
{
 mSelectionListeners.push_back(selectionListener);
}
 
void DropDown::removeSelectionListener(SelectionListener* listener)
{
 mSelectionListeners.remove(listener);
}
 
void DropDown::distributeValueChangedEvent()
{
 for (SelectionListenerIterator iter = mSelectionListeners.begin();
 iter != mSelectionListeners.end();
 ++iter)
 {
 SelectionEvent event(this);
 (*iter)->valueChanged(event);
 }
}