mirror of
https://github.com/RetroDECK/ES-DE.git
synced 2024-11-24 15:15:38 +00:00
daa62123d1
Added minimum message height to GuiMsgBox. TextComponent now vertically centers text. Fixed a bug that would cause ScraperSearchComponent to return results continuously until another search was started.
357 lines
9.1 KiB
C++
357 lines
9.1 KiB
C++
#pragma once
|
|
|
|
#include "IList.h"
|
|
#include "../Renderer.h"
|
|
#include "../resources/Font.h"
|
|
#include "../InputManager.h"
|
|
#include <vector>
|
|
#include <string>
|
|
#include <memory>
|
|
#include "../Sound.h"
|
|
#include "../Log.h"
|
|
#include "../ThemeData.h"
|
|
#include <functional>
|
|
|
|
struct TextListData
|
|
{
|
|
unsigned int colorId;
|
|
std::shared_ptr<TextCache> textCache;
|
|
};
|
|
|
|
//A graphical list. Supports multiple colors for rows and scrolling.
|
|
template <typename T>
|
|
class TextListComponent : public IList<TextListData, T>
|
|
{
|
|
protected:
|
|
using IList<TextListData, T>::mEntries;
|
|
using IList<TextListData, T>::listUpdate;
|
|
using IList<TextListData, T>::listInput;
|
|
using IList<TextListData, T>::listRenderTitleOverlay;
|
|
using IList<TextListData, T>::getTransform;
|
|
using IList<TextListData, T>::mSize;
|
|
using IList<TextListData, T>::mCursor;
|
|
using IList<TextListData, T>::Entry;
|
|
|
|
public:
|
|
using IList<TextListData, T>::size;
|
|
using IList<TextListData, T>::isScrolling;
|
|
using IList<TextListData, T>::stopScrolling;
|
|
|
|
TextListComponent(Window* window);
|
|
|
|
bool input(InputConfig* config, Input input) override;
|
|
void update(int deltaTime) override;
|
|
void render(const Eigen::Affine3f& parentTrans) override;
|
|
void applyTheme(const std::shared_ptr<ThemeData>& theme, const std::string& view, const std::string& element, unsigned int properties) override;
|
|
|
|
void add(const std::string& name, const T& obj, unsigned int colorId);
|
|
|
|
enum Alignment
|
|
{
|
|
ALIGN_LEFT,
|
|
ALIGN_CENTER,
|
|
ALIGN_RIGHT
|
|
};
|
|
|
|
inline void setAlignment(Alignment align) { mAlignment = align; }
|
|
|
|
inline void setCursorChangedCallback(const std::function<void(CursorState state)>& func) { mCursorChangedCallback = func; }
|
|
|
|
inline void setFont(const std::shared_ptr<Font>& font)
|
|
{
|
|
mFont = font;
|
|
|
|
for(auto it = mEntries.begin(); it != mEntries.end(); it++)
|
|
it->data.textCache.reset();
|
|
}
|
|
|
|
inline void setSelectorColor(unsigned int color) { mSelectorColor = color; }
|
|
inline void setSelectedColor(unsigned int color) { mSelectedColor = color; }
|
|
inline void setScrollSound(const std::shared_ptr<Sound>& sound) { mScrollSound = sound; }
|
|
inline void setColor(unsigned int id, unsigned int color) { mColors[id] = color; }
|
|
inline void setSound(const std::shared_ptr<Sound>& sound) { mScrollSound = sound; }
|
|
|
|
protected:
|
|
virtual void onScroll(int amt) { if(mScrollSound) mScrollSound->play(); }
|
|
virtual void onCursorChanged(const CursorState& state);
|
|
|
|
|
|
private:
|
|
static const int MARQUEE_DELAY = 900;
|
|
static const int MARQUEE_SPEED = 16;
|
|
static const int MARQUEE_RATE = 3;
|
|
|
|
int mMarqueeOffset;
|
|
int mMarqueeTime;
|
|
|
|
Alignment mAlignment;
|
|
float mHorizontalMargin;
|
|
|
|
std::function<void(CursorState state)> mCursorChangedCallback;
|
|
|
|
std::shared_ptr<Font> mFont;
|
|
unsigned int mSelectorColor;
|
|
unsigned int mSelectedColor;
|
|
std::shared_ptr<Sound> mScrollSound;
|
|
static const unsigned int COLOR_ID_COUNT = 2;
|
|
unsigned int mColors[COLOR_ID_COUNT];
|
|
};
|
|
|
|
template <typename T>
|
|
TextListComponent<T>::TextListComponent(Window* window) :
|
|
IList<TextListData, T>(window)
|
|
{
|
|
mMarqueeOffset = 0;
|
|
mMarqueeTime = -MARQUEE_DELAY;
|
|
|
|
mHorizontalMargin = 0;
|
|
mAlignment = ALIGN_CENTER;
|
|
|
|
mFont = Font::get(FONT_SIZE_MEDIUM);
|
|
mSelectorColor = 0x000000FF;
|
|
mSelectedColor = 0;
|
|
mColors[0] = 0x0000FFFF;
|
|
mColors[1] = 0x00FF00FF;
|
|
}
|
|
|
|
template <typename T>
|
|
void TextListComponent<T>::render(const Eigen::Affine3f& parentTrans)
|
|
{
|
|
Eigen::Affine3f trans = parentTrans * getTransform();
|
|
|
|
std::shared_ptr<Font>& font = mFont;
|
|
|
|
if(size() == 0)
|
|
{
|
|
Renderer::setMatrix(trans);
|
|
font->drawText("The list is empty.", Eigen::Vector2f(0, 0), 0xFF0000FF);
|
|
return;
|
|
}
|
|
|
|
const int cutoff = 0;
|
|
const int entrySize = (int)font->getHeight() + 5;
|
|
|
|
int startEntry = 0;
|
|
|
|
//number of entries that can fit on the screen simultaniously
|
|
int screenCount = (int)(mSize.y() / entrySize + 0.5f);
|
|
|
|
if(size() >= screenCount)
|
|
{
|
|
startEntry = mCursor - (int)(screenCount * 0.5);
|
|
if(startEntry < 0)
|
|
startEntry = 0;
|
|
if(startEntry >= size() - screenCount)
|
|
startEntry = size() - screenCount;
|
|
}
|
|
|
|
float y = (float)cutoff;
|
|
|
|
int listCutoff = startEntry + screenCount;
|
|
if(listCutoff > size())
|
|
listCutoff = size();
|
|
|
|
Eigen::Vector3f dim(mSize.x(), mSize.y(), 0);
|
|
dim = trans * dim - trans.translation();
|
|
Renderer::pushClipRect(Eigen::Vector2i((int)trans.translation().x(), (int)trans.translation().y()), Eigen::Vector2i((int)dim.x(), (int)dim.y()));
|
|
|
|
for(int i = startEntry; i < listCutoff; i++)
|
|
{
|
|
//draw selector bar
|
|
if(mCursor == i)
|
|
{
|
|
Renderer::setMatrix(trans);
|
|
Renderer::drawRect(0, (int)y, (int)mSize.x(), (int)font->getHeight(), mSelectorColor);
|
|
}
|
|
|
|
typename IList<TextListData, T>::Entry& entry = mEntries.at((unsigned int)i);
|
|
|
|
unsigned int color;
|
|
if(mCursor == i && mSelectedColor)
|
|
color = mSelectedColor;
|
|
else
|
|
color = mColors[entry.data.colorId];
|
|
|
|
if(!entry.data.textCache)
|
|
entry.data.textCache = std::unique_ptr<TextCache>(font->buildTextCache(entry.name, 0, 0, 0x000000FF));
|
|
|
|
entry.data.textCache->setColor(color);
|
|
|
|
Eigen::Vector3f offset(0, y, 0);
|
|
|
|
switch(mAlignment)
|
|
{
|
|
case ALIGN_LEFT:
|
|
offset[0] = mHorizontalMargin;
|
|
break;
|
|
case ALIGN_CENTER:
|
|
offset[0] = (mSize.x() - entry.data.textCache->metrics.size.x()) / 2;
|
|
if(offset[0] < 0)
|
|
offset[0] = 0;
|
|
break;
|
|
case ALIGN_RIGHT:
|
|
offset[0] = (mSize.x() - entry.data.textCache->metrics.size.x());
|
|
offset[0] -= mHorizontalMargin;
|
|
if(offset[0] < 0)
|
|
offset[0] = 0;
|
|
|
|
break;
|
|
}
|
|
|
|
if(mCursor == i)
|
|
offset[0] -= mMarqueeOffset;
|
|
|
|
Eigen::Affine3f drawTrans = trans;
|
|
drawTrans.translate(offset);
|
|
Renderer::setMatrix(drawTrans);
|
|
|
|
font->renderTextCache(entry.data.textCache.get());
|
|
|
|
y += entrySize;
|
|
}
|
|
|
|
Renderer::popClipRect();
|
|
|
|
listRenderTitleOverlay(trans);
|
|
|
|
GuiComponent::renderChildren(trans);
|
|
}
|
|
|
|
template <typename T>
|
|
bool TextListComponent<T>::input(InputConfig* config, Input input)
|
|
{
|
|
if(size() > 0)
|
|
{
|
|
if(input.value != 0)
|
|
{
|
|
if(config->isMappedTo("down", input))
|
|
{
|
|
listInput(1);
|
|
return true;
|
|
}
|
|
|
|
if(config->isMappedTo("up", input))
|
|
{
|
|
listInput(-1);
|
|
return true;
|
|
}
|
|
if(config->isMappedTo("pagedown", input))
|
|
{
|
|
listInput(10);
|
|
return true;
|
|
}
|
|
|
|
if(config->isMappedTo("pageup", input))
|
|
{
|
|
listInput(-10);
|
|
return true;
|
|
}
|
|
}else{
|
|
if(config->isMappedTo("down", input) || config->isMappedTo("up", input) ||
|
|
config->isMappedTo("pagedown", input) || config->isMappedTo("pageup", input))
|
|
{
|
|
stopScrolling();
|
|
}
|
|
}
|
|
}
|
|
|
|
return GuiComponent::input(config, input);
|
|
}
|
|
|
|
template <typename T>
|
|
void TextListComponent<T>::update(int deltaTime)
|
|
{
|
|
listUpdate(deltaTime);
|
|
if(!isScrolling() && size() > 0)
|
|
{
|
|
//if we're not scrolling and this object's text goes outside our size, marquee it!
|
|
const std::string& text = mEntries.at((unsigned int)mCursor).name;
|
|
|
|
Eigen::Vector2f textSize = mFont->sizeText(text);
|
|
|
|
//it's long enough to marquee
|
|
if(textSize.x() - mMarqueeOffset > mSize.x() - 12 - (mAlignment != ALIGN_CENTER ? mHorizontalMargin : 0))
|
|
{
|
|
mMarqueeTime += deltaTime;
|
|
while(mMarqueeTime > MARQUEE_SPEED)
|
|
{
|
|
mMarqueeOffset += MARQUEE_RATE;
|
|
mMarqueeTime -= MARQUEE_SPEED;
|
|
}
|
|
}
|
|
}
|
|
|
|
GuiComponent::update(deltaTime);
|
|
}
|
|
|
|
//list management stuff
|
|
template <typename T>
|
|
void TextListComponent<T>::add(const std::string& name, const T& obj, unsigned int color)
|
|
{
|
|
assert(color < COLOR_ID_COUNT);
|
|
|
|
typename IList<TextListData, T>::Entry entry;
|
|
entry.name = name;
|
|
entry.object = obj;
|
|
entry.data.colorId = color;
|
|
static_cast<IList< TextListData, T >*>(this)->add(entry);
|
|
}
|
|
|
|
template <typename T>
|
|
void TextListComponent<T>::onCursorChanged(const CursorState& state)
|
|
{
|
|
mMarqueeOffset = 0;
|
|
mMarqueeTime = -MARQUEE_DELAY;
|
|
|
|
if(mCursorChangedCallback)
|
|
mCursorChangedCallback(state);
|
|
}
|
|
|
|
template <typename T>
|
|
void TextListComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme, const std::string& view, const std::string& element, unsigned int properties)
|
|
{
|
|
GuiComponent::applyTheme(theme, view, element, properties);
|
|
|
|
const ThemeData::ThemeElement* elem = theme->getElement(view, element, "textlist");
|
|
if(!elem)
|
|
return;
|
|
|
|
using namespace ThemeFlags;
|
|
if(properties & COLOR)
|
|
{
|
|
if(elem->has("selectorColor"))
|
|
setSelectorColor(elem->get<unsigned int>("selectorColor"));
|
|
if(elem->has("selectedColor"))
|
|
setSelectedColor(elem->get<unsigned int>("selectedColor"));
|
|
if(elem->has("primaryColor"))
|
|
setColor(0, elem->get<unsigned int>("primaryColor"));
|
|
if(elem->has("secondaryColor"))
|
|
setColor(1, elem->get<unsigned int>("secondaryColor"));
|
|
}
|
|
|
|
setFont(Font::getFromTheme(elem, properties, mFont));
|
|
|
|
if(properties & SOUND && elem->has("scrollSound"))
|
|
setSound(Sound::get(elem->get<std::string>("scrollSound")));
|
|
|
|
if(properties & ALIGNMENT)
|
|
{
|
|
if(elem->has("alignment"))
|
|
{
|
|
const std::string& str = elem->get<std::string>("alignment");
|
|
if(str == "left")
|
|
setAlignment(ALIGN_LEFT);
|
|
else if(str == "center")
|
|
setAlignment(ALIGN_CENTER);
|
|
else if(str == "right")
|
|
setAlignment(ALIGN_RIGHT);
|
|
else
|
|
LOG(LogError) << "Unknown TextListComponent alignment \"" << str << "\"!";
|
|
}
|
|
if(elem->has("horizontalMargin"))
|
|
{
|
|
mHorizontalMargin = elem->get<float>("horizontalMargin") * (this->mParent ? this->mParent->getSize().x() : (float)Renderer::getScreenWidth());
|
|
}
|
|
}
|
|
}
|