sylar/OmniaFramework
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added anim() to stylesheet + refactored Widget.hpp

Browse source
This commit is contained in:
OmniaX-Dev 2026-04-20 06:49:00 +02:00
parent 0cf7478c24
commit 67a2b5f10e
24 changed files with 625 additions and 366 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
extra/DefaultTheme.oss
View file

@ -134,9 +134,16 @@ window.backgroundColor = rgba(160, 160, 160, 255)
useBackgroundGradient = true useBackgroundGradient = true
padding = rect(15, 8, 15, 8) padding = rect(15, 8, 15, 8)
margin = rect(0, 0, 0, 0) margin = rect(0, 0, 0, 0)
icon = file("img.png") (icon) {
showIcon = true show = true
iconANimation = anim( image = file("img.png")
animation = anim(frameCount: 36, \
fps: 60, \
columns: 9, \
rows: 4, \
frameWidth: 256, \
frameHeight: 256)
}
} }
(button:hover) { (button:hover) {
borderColor = $accentColor borderColor = $accentColor
@ -148,3 +155,25 @@ window.backgroundColor = rgba(160, 160, 160, 255)
backgroundGradient = gradientV(rgb(120, 120, 120) - rgb(160, 160, 160)) backgroundGradient = gradientV(rgb(120, 120, 120) - rgb(160, 160, 160))
} }
% ==================== % ====================
(image) {
path = file("img.png")
animated = true
animation = anim(frameCount: 36, \
fps: 60, \
columns: 9, \
rows: 4, \
frameWidth: 256, \
frameHeight: 256)
backgroundColor = #999999FF
backgroundGradient = gradientV(rgb(160, 160, 160) - rgb(120, 120, 120))
borderColor = $accentColorDark
borderRadius = 0
borderWidth = 1
showBackground = true
showBorder = true
useBackgroundGradient = true
padding = rect(15, 8, 15, 8)
margin = rect(0, 0, 0, 0)
}

1
src/ogfx/gui/WidgetManager.cpp
View file

@ -139,6 +139,7 @@ namespace ogfx
{ {
if (w == nullptr) continue; if (w == nullptr) continue;
if (w->isInvalid()) continue; if (w->isInvalid()) continue;
if (!w->isThemingEnabled()) continue;
w->__applyTheme(theme, true); w->__applyTheme(theme, true);
w->reloadTheme(); w->reloadTheme();
} }

31
src/ogfx/gui/Window.cpp
View file

@ -15,7 +15,7 @@
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with OmniaFramework. If not, see <https://www.gnu.org/licenses/>. along with OmniaFramewo6 If not, see <https://www.gnu.org/licenses/>.
*/ */
#include "Window.hpp" #include "Window.hpp"
@ -86,7 +86,7 @@ namespace ogfx
m_window = SDL_CreateWindow("", m_windowWidth, m_windowHeight, SDL_WINDOW_RESIZABLE); m_window = SDL_CreateWindow("", m_windowWidth, m_windowHeight, SDL_WINDOW_RESIZABLE);
m_renderer = SDL_CreateRenderer(m_window, nullptr); m_renderer = SDL_CreateRenderer(m_window, nullptr);
SDL_SetWindowMinimumSize(m_window, m_windowWidth, m_windowHeight); SDL_SetWindowMinimumSize(m_window, m_windowWidth, m_windowHeight);
SDL_SetWindowPosition(m_window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED); setPosition(WindowsPositionCenter);
SDL_SetWindowTitle(m_window, m_title.c_str()); SDL_SetWindowTitle(m_window, m_title.c_str());
SDL_StartTextInput(m_window); SDL_StartTextInput(m_window);
@ -260,6 +260,33 @@ namespace ogfx
SDL_SetRenderScale(m_renderer, s, s); SDL_SetRenderScale(m_renderer, s, s);
} }
void WindowCore::setPosition(const IPoint& pos)
{
IPoint p = pos;
if (p.x < 0)
p.x = SDL_WINDOWPOS_CENTERED;
if (p.y < 0)
p.y = SDL_WINDOWPOS_CENTERED;
SDL_SetWindowPosition(m_window, p.x, p.y);
}
void WindowCore::setWindowState(eWindowState state)
{
switch (state)
{
case eWindowState::Default:
SDL_RestoreWindow(m_window);
break;
case eWindowState::Maximized:
SDL_MaximizeWindow(m_window);
break;
case eWindowState::Minimized:
SDL_MinimizeWindow(m_window);
break;
default: break;
}
}
WindowCore::State WindowCore::getWindowState(void) const WindowCore::State WindowCore::getWindowState(void) const
{ {
SDL_WindowFlags flags = SDL_GetWindowFlags(m_window); SDL_WindowFlags flags = SDL_GetWindowFlags(m_window);

9
src/ogfx/gui/Window.hpp
View file

@ -65,6 +65,11 @@ namespace ogfx
Center, Center,
Left Left
}; };
public: enum class eWindowState : u8 {
Default = 0,
Maximized,
Minimized
};
public: struct State public: struct State
{ {
bool fullscreen { false }; bool fullscreen { false };
@ -85,6 +90,8 @@ namespace ogfx
void setTitle(const String& title); void setTitle(const String& title);
void setCursor(eCursor cursor); void setCursor(eCursor cursor);
void setUserScale(f32 scale); void setUserScale(f32 scale);
void setPosition(const IPoint& pos);
void setWindowState(eWindowState state);
State getWindowState(void) const; State getWindowState(void) const;
eCursor getCurosr(void) const; eCursor getCurosr(void) const;
void enableResizable(bool enable = true); void enableResizable(bool enable = true);
@ -186,6 +193,8 @@ namespace ogfx
inline static constexpr i32 MaxBlockingEventsFPS { 240 }; inline static constexpr i32 MaxBlockingEventsFPS { 240 };
inline static constexpr i32 DefaultBlockingEventsFPS { 30 }; inline static constexpr i32 DefaultBlockingEventsFPS { 30 };
inline static const IPoint WindowsPositionCenter { -1, -1 };
private: private:
inline static ostd::Stylesheet DefaultTheme; inline static ostd::Stylesheet DefaultTheme;
stdumap<String, std::pair<String, bool>> m_defaultStylesheetVariables; stdumap<String, std::pair<String, bool>> m_defaultStylesheetVariables;

22
src/ogfx/gui/widgets/Button.cpp
View file

@ -32,37 +32,17 @@ namespace ogfx
setText(text); setText(text);
setPadding({ 5, 5, 5, 5 }); setPadding({ 5, 5, 5, 5 });
setTypeName("ogfx::gui::widgets::Button"); setTypeName("ogfx::gui::widgets::Button");
disableDrawBox();
disableChildren(); disableChildren();
enableBackground(false); enableBackground(false);
setStylesheetCategoryName("button");
validate(); validate();
return *this; return *this;
} }
void Button::applyTheme(const ostd::Stylesheet& theme)
{
setTextColor(getThemeValue<Color>(theme, "button.textColor", Colors::White));
setBackGroundColor(getThemeValue<Color>(theme, "button.backgroundColor", Colors::Transparent));
setFontSize(getThemeValue<i32>(theme, "button.fontSize", 20));
setBorderRadius(getThemeValue<i32>(theme, "button.borderRadius", 10));
setBorderWidth(getThemeValue<i32>(theme, "button.borderWidth", 2));
enableBorder(getThemeValue<bool>(theme, "button.showBorder", false));
setBorderColor(getThemeValue<Color>(theme, "button.borderColor", Colors::White));
enableBackground(getThemeValue<bool>(theme, "button.showBackground", false));
setPadding(getThemeValue<Rectangle>(theme, "button.padding", { 5, 5, 5, 5 }));
setMargin(getThemeValue<Rectangle>(theme, "button.margin", { 0, 0, 0, 0 }));
m_useBackgroundGradient = getThemeValue<bool>(theme, "button.useBackgroundGradient", false);
m_backgroundGradient = getThemeValue<ColorGradient>(theme, "button.backgroundGradient", m_backgroundGradient);
if (m_useBackgroundGradient && isBackgoundEnabled())
enableBackground(false);
}
void Button::onDraw(ogfx::BasicRenderer2D& gfx) void Button::onDraw(ogfx::BasicRenderer2D& gfx)
{ {
if (m_textChanged) if (m_textChanged)
__update_size(gfx); __update_size(gfx);
if (m_useBackgroundGradient)
gfx.fillGradientRect(getGlobalBounds(), m_backgroundGradient);
gfx.drawString(getText(), getGlobalContentPosition(), getTextColor(), getFontSize()); gfx.drawString(getText(), getGlobalContentPosition(), getTextColor(), getFontSize());
} }

12
src/ogfx/gui/widgets/Button.hpp
View file

@ -34,14 +34,9 @@ namespace ogfx
inline Button(WindowCore& window) : Widget({ 0, 0, 0, 0 }, window) { create(""); } inline Button(WindowCore& window) : Widget({ 0, 0, 0, 0 }, window) { create(""); }
inline Button(WindowCore& window, const String& text) : Widget({ 0, 0, 0, 0 }, window) { create(text); } inline Button(WindowCore& window, const String& text) : Widget({ 0, 0, 0, 0 }, window) { create(text); }
Button& create(const String& text); Button& create(const String& text);
void applyTheme(const ostd::Stylesheet& theme) override;
void onDraw(ogfx::BasicRenderer2D& gfx) override; void onDraw(ogfx::BasicRenderer2D& gfx) override;
void setText(const String& text); void setText(const String& text);
inline String getText(void) const { return m_text; } inline String getText(void) const { return m_text; }
inline Color getTextColor(void) const { return m_textColor; }
inline void setTextColor(const Color& color) { m_textColor = color; }
inline i32 getFontSize(void) const { return m_fontSize; }
inline void setFontSize(i32 fontSize) { m_fontSize = fontSize; }
private: private:
void __update_size(ogfx::BasicRenderer2D& gfx); void __update_size(ogfx::BasicRenderer2D& gfx);
@ -49,13 +44,6 @@ namespace ogfx
private: private:
String m_text { "" }; String m_text { "" };
bool m_textChanged { false }; bool m_textChanged { false };
i32 m_fontSize { 20 };
Color m_textColor { 255, 255, 255 };
bool m_useBackgroundGradient { false };
ColorGradient m_backgroundGradient {
{ Color { 160, 160, 160 }, Color { 120, 120, 120 } },
{ 1.0f }
};
}; };
} }
} }

20
src/ogfx/gui/widgets/CheckBox.cpp
View file

@ -32,29 +32,19 @@ namespace ogfx
setText(text); setText(text);
setPadding({ 5, 5, 5, 5 }); setPadding({ 5, 5, 5, 5 });
setTypeName("ogfx::gui::widgets::Label"); setTypeName("ogfx::gui::widgets::Label");
disableDrawBox();
disableChildren(); disableChildren();
enableBackground(false); enableBackground(false);
setStylesheetCategoryName("checkbox");
validate(); validate();
return *this; return *this;
} }
void CheckBox::applyTheme(const ostd::Stylesheet& theme) void CheckBox::applyTheme(const ostd::Stylesheet& theme)
{ {
setCheckBorderColor(getThemeValue<Color>(theme, "checkbox.checkBorderColor", Colors::White)); setCheckBorderColor(getThemeValue<Color>(theme, "checkBorderColor", Colors::White));
setCheckBoxColor(getThemeValue<Color>(theme, "checkbox.checkBoxColor", Colors::White)); setCheckBoxColor(getThemeValue<Color>(theme, "checkBoxColor", Colors::White));
setTextColor(getThemeValue<Color>(theme, "checkbox.textColor", Colors::Black)); m_checkBorderRadius = getThemeValue<i32>(theme, "checkBorderRadius", 5);
setBackGroundColor(getThemeValue<Color>(theme, "checkbox.backgroundColor", Colors::Transparent)); m_checkBorderWidth = getThemeValue<i32>(theme, "checkBorderWidth", 1);
setFontSize(getThemeValue<i32>(theme, "checkbox.fontSize", 28));
setBorderRadius(getThemeValue<i32>(theme, "checkbox.borderRadius", 10));
setBorderWidth(getThemeValue<i32>(theme, "checkbox.borderWidth", 2));
enableBorder(getThemeValue<bool>(theme, "checkbox.showBorder", false));
setBorderColor(getThemeValue<Color>(theme, "checkbox.borderColor", Colors::White));
enableBackground(getThemeValue<bool>(theme, "checkbox.showBackground", false));
setPadding(getThemeValue<Rectangle>(theme, "checkbox.padding", { 5, 5, 5, 5 }));
setMargin(getThemeValue<Rectangle>(theme, "checkbox.margin", { 0, 0, 0, 0 }));
m_checkBorderRadius = getThemeValue<i32>(theme, "checkbox.checkBorderRadius", 5);
m_checkBorderWidth = getThemeValue<i32>(theme, "checkbox.checkBorderWidth", 1);
} }
void CheckBox::onDraw(ogfx::BasicRenderer2D& gfx) void CheckBox::onDraw(ogfx::BasicRenderer2D& gfx)

6
src/ogfx/gui/widgets/CheckBox.hpp
View file

@ -46,10 +46,6 @@ namespace ogfx
inline void setCheckBorderColor(const Color& color) { m_checkBorderColor = color; } inline void setCheckBorderColor(const Color& color) { m_checkBorderColor = color; }
inline Color getCheckBoxColor(void) const { return m_checkBoxColor; } inline Color getCheckBoxColor(void) const { return m_checkBoxColor; }
inline void setCheckBoxColor(const Color& color) { m_checkBoxColor = color; } inline void setCheckBoxColor(const Color& color) { m_checkBoxColor = color; }
inline Color getTextColor(void) const { return m_textColor; }
inline void setTextColor(const Color& color) { m_textColor = color; }
inline i32 getFontSize(void) const { return m_fontSize; }
inline void setFontSize(i32 fontSize) { m_fontSize = fontSize; }
inline bool isChecked(void) const { return m_checked; } inline bool isChecked(void) const { return m_checked; }
inline void setStateChangedCallback(std::function<void(CheckBox&, bool)> callback) { callback_onStateChanged = callback; } inline void setStateChangedCallback(std::function<void(CheckBox&, bool)> callback) { callback_onStateChanged = callback; }
@ -60,8 +56,6 @@ namespace ogfx
bool m_checked { false }; bool m_checked { false };
String m_text { "" }; String m_text { "" };
bool m_textChanged { false }; bool m_textChanged { false };
i32 m_fontSize { 20 };
Color m_textColor { 255, 255, 255 };
f32 m_spacing { 10 }; f32 m_spacing { 10 };
Vec2 m_checkSize { 0, 0 }; Vec2 m_checkSize { 0, 0 };
i32 m_checkBorderRadius { 5 }; i32 m_checkBorderRadius { 5 };

32
src/ogfx/gui/widgets/Containers.cpp
View file

@ -32,33 +32,25 @@ namespace ogfx
{ {
setPadding({ 5, 5, 5, 5 }); setPadding({ 5, 5, 5, 5 });
setTypeName("ogfx::gui::widgets::Panel"); setTypeName("ogfx::gui::widgets::Panel");
disableDrawBox();
disableFocus(); disableFocus();
enableStopEvents(); enableStopEvents();
setStylesheetCategoryName("panel");
validate(); validate();
return *this; return *this;
} }
void Panel::applyTheme(const ostd::Stylesheet& theme) void Panel::applyTheme(const ostd::Stylesheet& theme)
{ {
setBackGroundColor(getThemeValue<Color>(theme, "panel.backgroundColor", Colors::Gray)); setScrollSpeed(getThemeValue<f32>(theme, "scrollSpeed", 0.8f));
setBorderRadius(getThemeValue<i32>(theme, "panel.borderRadius", 8)); setScrollSmoothFactor(getThemeValue<f32>(theme, "scrollSmoothFactor", 0.7f));
setBorderWidth(getThemeValue<i32>(theme, "panel.borderWidth", 2)); m_titleColor = getThemeValue<Color>(theme, "titleColor", Colors::Black);
enableBorder(getThemeValue<bool>(theme, "panel.showBorder", true)); m_titlebarColor = getThemeValue<Color>(theme, "titlebarColor", Colors::Transparent);
enableBackground(getThemeValue<bool>(theme, "panel.showBackground", true)); m_titlebarBorderColor = getThemeValue<Color>(theme, "titlebarBorderColor", Colors::Black);
setBorderColor(getThemeValue<Color>(theme, "panel.borderColor", Colors::Black)); m_titlebarHeight = getThemeValue<f32>(theme, "titlebarHeight", 30);
setPadding(getThemeValue<Rectangle>(theme, "panel.padding", { 15, 15, 15, 15 })); m_titlebarBorderWidth = getThemeValue<i32>(theme, "titlebarBorderWidth", 1);
setMargin(getThemeValue<Rectangle>(theme, "panel.margin", { 0, 0, 0, 0 })); m_titlebarFontSize = getThemeValue<i32>(theme, "titlebarFontSize", 26);
setScrollSpeed(getThemeValue<f32>(theme, "panel.scrollSpeed", 0.8f)); m_titleTextAlign = getThemeValue<i32>(theme, "titlebarTextAlign", cast<i32>(WindowCore::eTextAlign::Left));
setScrollSmoothFactor(getThemeValue<f32>(theme, "panel.scrollSmoothFactor", 0.7f)); setTitlebarType(getThemeValue<String>(theme, "titlebarType", TitleBarTypes::None));
m_titleColor = getThemeValue<Color>(theme, "panel.titleColor", Colors::Black);
m_titlebarColor = getThemeValue<Color>(theme, "panel.titlebarColor", Colors::Transparent);
m_titlebarBorderColor = getThemeValue<Color>(theme, "panel.titlebarBorderColor", Colors::Black);
m_titlebarHeight = getThemeValue<f32>(theme, "panel.titlebarHeight", 30);
m_titlebarBorderWidth = getThemeValue<i32>(theme, "panel.titlebarBorderWidth", 1);
m_titlebarFontSize = getThemeValue<i32>(theme, "panel.titlebarFontSize", 26);
m_titleTextAlign = getThemeValue<i32>(theme, "panel.titlebarTextAlign", cast<i32>(WindowCore::eTextAlign::Left));
setTitlebarType(getThemeValue<String>(theme, "panel.titlebarType", TitleBarTypes::None));
} }
void Panel::afterDraw(ogfx::BasicRenderer2D& gfx) void Panel::afterDraw(ogfx::BasicRenderer2D& gfx)
@ -141,9 +133,9 @@ namespace ogfx
{ {
setPadding({ 0, 0, 0, 0 }); setPadding({ 0, 0, 0, 0 });
setTypeName("ogfx::gui::widgets::TabPanel"); setTypeName("ogfx::gui::widgets::TabPanel");
disableDrawBox();
disableFocus(); disableFocus();
enableStopEvents(); enableStopEvents();
setStylesheetCategoryName("tabPanel");
validate(); validate();
return *this; return *this;
} }

2
src/ogfx/gui/widgets/Containers.hpp
View file

@ -49,8 +49,6 @@ namespace ogfx
void afterDraw(ogfx::BasicRenderer2D& gfx) override; void afterDraw(ogfx::BasicRenderer2D& gfx) override;
void setTitlebarType(const String& type); void setTitlebarType(const String& type);
String getTitlebarType(void) const; String getTitlebarType(void) const;
inline void setBackGroundColor(const Color& color) { m_backgroundColor = color; }
inline Color getBackgroundColor(void) { return m_backgroundColor; }
inline String getTitle(void) const { return m_title; } inline String getTitle(void) const { return m_title; }
inline void setTitle(const String& title) { m_title = title; } inline void setTitle(const String& title) { m_title = title; }
inline f32 getTitlebarHeight(void) const { return m_titlebarHeight; } inline f32 getTitlebarHeight(void) const { return m_titlebarHeight; }

18
src/ogfx/gui/widgets/Label.cpp
View file

@ -32,32 +32,18 @@ namespace ogfx
setText(text); setText(text);
setPadding({ 5, 5, 5, 5 }); setPadding({ 5, 5, 5, 5 });
setTypeName("ogfx::gui::widgets::Label"); setTypeName("ogfx::gui::widgets::Label");
disableDrawBox();
disableChildren(); disableChildren();
enableBackground(false); enableBackground(false);
setStylesheetCategoryName("label");
validate(); validate();
return *this; return *this;
} }
void Label::applyTheme(const ostd::Stylesheet& theme)
{
setColor(getThemeValue<Color>(theme, "label.textColor", Colors::White));
setBackGroundColor(getThemeValue<Color>(theme, "label.backgroundColor", Colors::Transparent));
setFontSize(getThemeValue<i32>(theme, "label.fontSize", 20));
setBorderRadius(getThemeValue<i32>(theme, "label.borderRadius", 10));
setBorderWidth(getThemeValue<i32>(theme, "label.borderWidth", 2));
enableBorder(getThemeValue<bool>(theme, "label.showBorder", false));
setBorderColor(getThemeValue<Color>(theme, "label.borderColor", Colors::White));
enableBackground(getThemeValue<bool>(theme, "label.showBackground", false));
setPadding(getThemeValue<Rectangle>(theme, "label.padding", { 5, 5, 5, 5 }));
setMargin(getThemeValue<Rectangle>(theme, "label.margin", { 0, 0, 0, 0 }));
}
void Label::onDraw(ogfx::BasicRenderer2D& gfx) void Label::onDraw(ogfx::BasicRenderer2D& gfx)
{ {
if (m_textChanged) if (m_textChanged)
__update_size(gfx); __update_size(gfx);
gfx.drawString(getText(), getGlobalContentPosition(), getColor(), getFontSize()); gfx.drawString(getText(), getGlobalContentPosition(), getTextColor(), getFontSize());
} }
void Label::setText(const String& text) void Label::setText(const String& text)

7
src/ogfx/gui/widgets/Label.hpp
View file

@ -34,14 +34,9 @@ namespace ogfx
inline Label(WindowCore& window) : Widget({ 0, 0, 0, 0 }, window) { create(""); } inline Label(WindowCore& window) : Widget({ 0, 0, 0, 0 }, window) { create(""); }
inline Label(WindowCore& window, const String& text) : Widget({ 0, 0, 0, 0 }, window) { create(text); } inline Label(WindowCore& window, const String& text) : Widget({ 0, 0, 0, 0 }, window) { create(text); }
Label& create(const String& text); Label& create(const String& text);
void applyTheme(const ostd::Stylesheet& theme) override;
void onDraw(ogfx::BasicRenderer2D& gfx) override; void onDraw(ogfx::BasicRenderer2D& gfx) override;
void setText(const String& text); void setText(const String& text);
inline String getText(void) const { return m_text; } inline String getText(void) const { return m_text; }
inline Color getColor(void) const { return m_color; }
inline void setColor(const Color& color) { m_color = color; }
inline i32 getFontSize(void) const { return m_fontSize; }
inline void setFontSize(i32 fontSize) { m_fontSize = fontSize; }
private: private:
void __update_size(ogfx::BasicRenderer2D& gfx); void __update_size(ogfx::BasicRenderer2D& gfx);
@ -49,8 +44,6 @@ namespace ogfx
private: private:
String m_text { "" }; String m_text { "" };
bool m_textChanged { false }; bool m_textChanged { false };
i32 m_fontSize { 20 };
Color m_color { 255, 255, 255 };
}; };
} }
} }

6
src/ogfx/gui/widgets/RootWidget.cpp
View file

@ -30,9 +30,9 @@ namespace ogfx
{ {
RootWidget::RootWidget(WindowCore& window) : Widget({ 0, 0, 0, 0 }, window) RootWidget::RootWidget(WindowCore& window) : Widget({ 0, 0, 0, 0 }, window)
{ {
disableDrawBox(); setRootChild();
m_rootChild = true;
setSize(cast<f32>(window.getWindowWidth()), cast<f32>(window.getWindowHeight())); setSize(cast<f32>(window.getWindowWidth()), cast<f32>(window.getWindowHeight()));
setStylesheetCategoryName("window");
setTypeName("ogfx::gui::widgets::RootWidget"); setTypeName("ogfx::gui::widgets::RootWidget");
} }
@ -43,7 +43,7 @@ namespace ogfx
void RootWidget::applyTheme(const ostd::Stylesheet& theme) void RootWidget::applyTheme(const ostd::Stylesheet& theme)
{ {
m_color = getThemeValue<Color>(theme, "window.backgroundColor", getWindow().getClearColor()); m_color = getThemeValue<Color>(theme, "backgroundColor", getWindow().getClearColor());
} }
void RootWidget::onDraw(ogfx::BasicRenderer2D& gfx) void RootWidget::onDraw(ogfx::BasicRenderer2D& gfx)

48
src/ogfx/gui/widgets/Scrollbar.cpp
View file

@ -32,24 +32,24 @@ namespace ogfx
setPadding({ 0, 0, 0, 0 }); setPadding({ 0, 0, 0, 0 });
setMargin({ 0, 0, 0, 0 }); setMargin({ 0, 0, 0, 0 });
setTypeName("ogfx::gui::widgets::Label"); setTypeName("ogfx::gui::widgets::Label");
disableDrawBox();
disableChildren(); disableChildren();
enableBackground(true); enableBackground(true);
enableBorder(false); enableBorder(false);
enableTopMost(true); enableTopMost(true);
allowIgnoreScroll(true); enableIgnoreScroll(true);
setStylesheetCategoryName("scrollbar");
validate(); validate();
return *this; return *this;
} }
void VerticalScrollBar::applyTheme(const ostd::Stylesheet& theme) void VerticalScrollBar::applyTheme(const ostd::Stylesheet& theme)
{ {
w = getThemeValue<f32>(theme, "scrollbar.width", 15); w = getThemeValue<f32>(theme, "width", 15);
m_thumbColor = getThemeValue<Color>(theme, "scrollbar.thumb.color", { 120, 120, 120 }); m_thumbColor = getThemeValue<Color>(theme, "thumb.color", { 120, 120, 120 });
m_thumbBorderRadius = getThemeValue<f32>(theme, "scrollbar.thumb.borderRadius", 16); m_thumbBorderRadius = getThemeValue<f32>(theme, "thumb.borderRadius", 16);
m_thumbBorderColor = getThemeValue<Color>(theme, "scrollbar.thumb.borderColor", { 150, 150, 150 }); m_thumbBorderColor = getThemeValue<Color>(theme, "thumb.borderColor", { 150, 150, 150 });
m_thumbShowBorder = getThemeValue<bool>(theme, "scrollbar.thumb.showBorder", true); m_thumbShowBorder = getThemeValue<bool>(theme, "thumb.showBorder", true);
m_trackColor = getThemeValue<Color>(theme, "scrollbar.track.color", { 70, 70, 70 }); m_trackColor = getThemeValue<Color>(theme, "track.color", { 70, 70, 70 });
} }
void VerticalScrollBar::afterDraw(ogfx::BasicRenderer2D& gfx) void VerticalScrollBar::afterDraw(ogfx::BasicRenderer2D& gfx)
@ -155,24 +155,24 @@ namespace ogfx
setPadding({ 0, 0, 0, 0 }); setPadding({ 0, 0, 0, 0 });
setMargin({ 0, 0, 0, 0 }); setMargin({ 0, 0, 0, 0 });
setTypeName("ogfx::gui::widgets::Label"); setTypeName("ogfx::gui::widgets::Label");
disableDrawBox();
disableChildren(); disableChildren();
enableBackground(true); enableBackground(true);
enableBorder(false); enableBorder(false);
enableTopMost(true); enableTopMost(true);
allowIgnoreScroll(true); enableIgnoreScroll(true);
setStylesheetCategoryName("scrollbar");
validate(); validate();
return *this; return *this;
} }
void HorizontalScrollbar::applyTheme(const ostd::Stylesheet& theme) void HorizontalScrollbar::applyTheme(const ostd::Stylesheet& theme)
{ {
h = getThemeValue<f32>(theme, "scrollbar.width", 15); h = getThemeValue<f32>(theme, "width", 15);
m_thumbColor = getThemeValue<Color>(theme, "scrollbar.thumb.color", { 120, 120, 120 }); m_thumbColor = getThemeValue<Color>(theme, "thumb.color", { 120, 120, 120 });
m_thumbBorderRadius = getThemeValue<f32>(theme, "scrollbar.thumb.borderRadius", 16); m_thumbBorderRadius = getThemeValue<f32>(theme, "thumb.borderRadius", 16);
m_thumbBorderColor = getThemeValue<Color>(theme, "scrollbar.thumb.borderColor", { 150, 150, 150 }); m_thumbBorderColor = getThemeValue<Color>(theme, "thumb.borderColor", { 150, 150, 150 });
m_thumbShowBorder = getThemeValue<bool>(theme, "scrollbar.thumb.showBorder", true); m_thumbShowBorder = getThemeValue<bool>(theme, "thumb.showBorder", true);
m_trackColor = getThemeValue<Color>(theme, "scrollbar.track.color", { 70, 70, 70 }); m_trackColor = getThemeValue<Color>(theme, "track.color", { 70, 70, 70 });
} }
void HorizontalScrollbar::afterDraw(ogfx::BasicRenderer2D& gfx) void HorizontalScrollbar::afterDraw(ogfx::BasicRenderer2D& gfx)
@ -277,8 +277,8 @@ namespace ogfx
ScrollableWidget& ScrollableWidget::create(void) ScrollableWidget& ScrollableWidget::create(void)
{ {
setTypeName("ogfx::gui::widgets::ScrollableWidget"); setTypeName("ogfx::gui::widgets::ScrollableWidget");
allowVScroll(true); enableVScroll(true);
allowHScroll(true); enableHScroll(true);
m_vScrollbar.enableManualDraw(true); m_vScrollbar.enableManualDraw(true);
addWidget(m_vScrollbar); addWidget(m_vScrollbar);
m_hScrollbar.setMargin({ 0, 0, 0, 0 }); m_hScrollbar.setMargin({ 0, 0, 0, 0 });
@ -321,7 +321,7 @@ namespace ogfx
void ScrollableWidget::onMouseScrolled(const Event& event) void ScrollableWidget::onMouseScrolled(const Event& event)
{ {
if (isVScrollAllowed()) if (isVScrollEnabled())
{ {
bool mouseInsideHScrollbar = m_hScrollbar.isMouseInsideThumb({ event.mouse->position_x, event.mouse->position_y }) && needsHScroll(); bool mouseInsideHScrollbar = m_hScrollbar.isMouseInsideThumb({ event.mouse->position_x, event.mouse->position_y }) && needsHScroll();
if (std::abs(event.mouse->scrollAmount.y) > 0 && !mouseInsideHScrollbar) if (std::abs(event.mouse->scrollAmount.y) > 0 && !mouseInsideHScrollbar)
@ -339,7 +339,7 @@ namespace ogfx
event.handle(); event.handle();
} }
} }
if (isHScrollAllowed()) if (isHScrollEnabled())
{ {
if (std::abs(event.mouse->scrollAmount.x) > 0) if (std::abs(event.mouse->scrollAmount.x) > 0)
{ {
@ -383,12 +383,12 @@ namespace ogfx
bool ScrollableWidget::needsVScroll(void) const bool ScrollableWidget::needsVScroll(void) const
{ {
return isVScrollAllowed() && getContentExtents().h > getContentBounds().h; return isVScrollEnabled() && getContentExtents().h > getContentBounds().h;
} }
bool ScrollableWidget::needsHScroll(void) const bool ScrollableWidget::needsHScroll(void) const
{ {
return isHScrollAllowed() && getContentExtents().w > getContentBounds().w; return isHScrollEnabled() && getContentExtents().w > getContentBounds().w;
} }
void ScrollableWidget::onWidgetAdded(Widget& child) void ScrollableWidget::onWidgetAdded(Widget& child)
@ -401,7 +401,7 @@ namespace ogfx
f32 ScrollableWidget::getVScrollbarSize(void) const f32 ScrollableWidget::getVScrollbarSize(void) const
{ {
if (!isVScrollAllowed()) if (!isVScrollEnabled())
return 0; return 0;
if (!needsVScroll()) if (!needsVScroll())
return 0; return 0;
@ -410,7 +410,7 @@ namespace ogfx
f32 ScrollableWidget::getHScrollbarSize(void) const f32 ScrollableWidget::getHScrollbarSize(void) const
{ {
if (!isHScrollAllowed()) if (!isHScrollEnabled())
return 0; return 0;
if (!needsHScroll()) if (!needsHScroll())
return 0; return 0;

63
src/ogfx/gui/widgets/Widget.cpp
View file

@ -61,7 +61,7 @@ namespace ogfx
if (!m_rootChild && m_parent != nullptr) if (!m_rootChild && m_parent != nullptr)
{ {
glob += m_parent->getGlobalPosition(); glob += m_parent->getGlobalPosition();
if (!isIgnoreScrollAllowed()) if (!isIgnoreScrollEnabled())
{ {
glob += m_parent->getPadding().getPosition(); glob += m_parent->getPadding().getPosition();
glob += m_parent->getContentOffset(); glob += m_parent->getContentOffset();
@ -109,7 +109,7 @@ namespace ogfx
for (auto* child : m_widgets.getWidgets()) for (auto* child : m_widgets.getWidgets())
{ {
if (!child || child->isInvalid()) continue; if (!child || child->isInvalid()) continue;
if (child->isIgnoreScrollAllowed()) continue; if (child->isIgnoreScrollEnabled()) continue;
if (!child->isVisible()) continue; if (!child->isVisible()) continue;
Vec2 localPos = getPadding().getPosition() + child->getPosition() + child->getMargin().getPosition() + child->getContentBounds().getPosition(); Vec2 localPos = getPadding().getPosition() + child->getPosition() + child->getMargin().getPosition() + child->getContentBounds().getPosition();
maxX = std::max(maxX, localPos.x + child->getw() + child->getMargin().w); maxX = std::max(maxX, localPos.x + child->getw() + child->getMargin().w);
@ -138,6 +138,8 @@ namespace ogfx
{ {
if (getWindow().theme() == nullptr) if (getWindow().theme() == nullptr)
return; return;
if (!isThemingEnabled())
return;
auto& theme = *getWindow().theme(); auto& theme = *getWindow().theme();
applyTheme(theme); applyTheme(theme);
@ -214,20 +216,38 @@ namespace ogfx
m_visible = v; m_visible = v;
} }
void Widget::setCallback(eCallback type, EventCallback callback)
{
switch (type)
{
case eCallback::MousePressed: callback_onMousePressed = std::move(callback); break;
case eCallback::MouseReleased: callback_onMouseReleased = std::move(callback); break;
case eCallback::MouseMoved: callback_onMouseMoved = std::move(callback); break;
case eCallback::MouseScrolled: callback_onMouseScrolled = std::move(callback); break;
case eCallback::DragAndDrop: callback_onDragAndDrop = std::move(callback); break;
case eCallback::MouseEntered: callback_onMouseEntered = std::move(callback); break;
case eCallback::MouseExited: callback_onMouseExited = std::move(callback); break;
case eCallback::MouseDragged: callback_onMouseDragged = std::move(callback); break;
case eCallback::KeyPressed: callback_onKeyPressed = std::move(callback); break;
case eCallback::KeyReleased: callback_onKeyReleased = std::move(callback); break;
case eCallback::TextEntered: callback_onTextEntered = std::move(callback); break;
case eCallback::WindowClosed: callback_onWindowClosed = std::move(callback); break;
case eCallback::WindowResized: callback_onWindowResized = std::move(callback); break;
case eCallback::WindowFocused: callback_onWindowFocused = std::move(callback); break;
case eCallback::WindowFocusLost: callback_onWindowFocusLost = std::move(callback); break;
default: break;
}
}
void Widget::__draw(ogfx::BasicRenderer2D& gfx) void Widget::__draw(ogfx::BasicRenderer2D& gfx)
{ {
if (!isVisible()) if (!isVisible())
return; return;
if (isDrawBoxEnabled()) beforeDraw(gfx);
gfx.fillRect({ getGlobalPosition(), getSize() }, getDrawBoxColor()); if (m_useBackgroundGradient && m_showBorder)
else gfx.fillGradientRect({ getGlobalPosition(), getSize() }, m_backgroundGradient);
{ else if (m_showBackground)
beforeDraw(gfx); gfx.fillRoundRect({ getGlobalPosition(), getSize() }, m_backgroundColor, m_borderRadius);
if (m_showBackground && m_showBorder)
gfx.outlinedRoundRect({ getGlobalPosition(), getSize() }, m_backgroundColor, m_borderColor, m_borderRadius, m_borderWidth);
else if (m_showBackground)
gfx.fillRoundRect({ getGlobalPosition(), getSize() }, m_backgroundColor, m_borderRadius);
}
onDraw(gfx); onDraw(gfx);
// gfx.fillRect(getGlobalPureContentBounds(), { 0, 255, 0, 120 }); // gfx.fillRect(getGlobalPureContentBounds(), { 0, 255, 0, 120 });
@ -431,7 +451,26 @@ namespace ogfx
{ {
if (propagate && hasChildren()) if (propagate && hasChildren())
m_widgets.onThemeApplied(theme); m_widgets.onThemeApplied(theme);
apply_common_theme_values(theme);
applyTheme(theme); applyTheme(theme);
} }
void Widget::apply_common_theme_values(const ostd::Stylesheet& theme)
{
setTextColor(getThemeValue<Color>(theme, "textColor", m_textColor));
setBackgroundColor(getThemeValue<Color>(theme, "backgroundColor", m_backgroundColor));
setFontSize(getThemeValue<i32>(theme, "fontSize", m_fontSize));
setBorderRadius(getThemeValue<i32>(theme, "borderRadius", m_borderRadius));
setBorderWidth(getThemeValue<i32>(theme, "borderWidth", m_borderWidth));
enableBorder(getThemeValue<bool>(theme, "showBorder", m_showBorder));
setBorderColor(getThemeValue<Color>(theme, "borderColor", m_borderColor));
enableBackground(getThemeValue<bool>(theme, "showBackground", m_showBackground));
setPadding(getThemeValue<Rectangle>(theme, "padding", m_padding));
setMargin(getThemeValue<Rectangle>(theme, "margin", m_margin));
enableBackgroundGradient(getThemeValue<bool>(theme, "useBackgroundGradient", m_useBackgroundGradient));
setBackgroundGradient(getThemeValue<ColorGradient>(theme, "backgroundGradient", m_backgroundGradient));
if (isBackgroundGradientEnabled() && isBackgroundEnabled())
enableBackground(false);
}
} }
} }

353
src/ogfx/gui/widgets/Widget.hpp
View file

@ -25,6 +25,7 @@
#include <ostd/data/BaseObject.hpp> #include <ostd/data/BaseObject.hpp>
#include <ostd/math/Geometry.hpp> #include <ostd/math/Geometry.hpp>
#include <ostd/io/Stylesheet.hpp> #include <ostd/io/Stylesheet.hpp>
#include <ostd/utils/Defines.hpp>
#include <functional> #include <functional>
namespace ogfx namespace ogfx
@ -38,30 +39,31 @@ namespace ogfx
String fullKey; String fullKey;
ostd::Stylesheet::TypeVariant value; ostd::Stylesheet::TypeVariant value;
}; };
public: enum class eCallback
{
MousePressed = 0,
MouseReleased,
MouseMoved,
MouseScrolled,
DragAndDrop,
MouseEntered,
MouseExited,
MouseDragged,
KeyPressed,
KeyReleased,
TextEntered,
WindowClosed,
WindowResized,
WindowFocused,
WindowFocusLost
};
public: using EventCallback = std::function<void(const Event&)>; public: using EventCallback = std::function<void(const Event&)>;
public: public:
// ================================== MAIN =================================
Widget(const Rectangle& bounds, WindowCore& window); Widget(const Rectangle& bounds, WindowCore& window);
bool addWidget(Widget& child, const Vec2& position = { 0, 0 }, bool __skip_callback = false); bool addWidget(Widget& child, const Vec2& position = { 0, 0 }, bool __skip_callback = false);
bool removeWidget(Widget& child); bool removeWidget(Widget& child);
virtual Vec2 getGlobalPosition(void) const;
virtual Vec2 getGlobalContentPosition(void) const;
virtual Rectangle getGlobalBounds(void) const;
virtual Rectangle getContentBounds(void) const;
virtual Rectangle getPureContentBounds(void) const;
virtual Rectangle getGlobalContentBounds(void) const;
virtual Rectangle getGlobalPureContentBounds(void) const;
virtual Rectangle getContentExtents(void) const;
using Rectangle::contains;
bool contains(Vec2 p, bool includeBounds = false) const override;
void enable(bool enable = true); void enable(bool enable = true);
virtual void applyTheme(const ostd::Stylesheet& theme) = 0;
inline virtual Vec2 getScrollOffset(void) const { return { 0, 0 }; }
inline virtual void setScrollOffset(const Vec2& offset) { }
inline virtual void addScrollOffset(const Vec2& offset) { }
inline virtual bool needsVScroll(void) const { return false; }
inline virtual bool needsHScroll(void) const { return false; }
inline virtual f32 getVScrollbarSize(void) const { return 0; }
inline virtual f32 getHScrollbarSize(void) const { return 0; }
void addThemeOverride(const String& fullKey, ostd::Stylesheet::TypeVariant value); void addThemeOverride(const String& fullKey, ostd::Stylesheet::TypeVariant value);
void reloadTheme(bool propagate = false); void reloadTheme(bool propagate = false);
void setThemeQualifier(const String& qualifier, bool value = true); void setThemeQualifier(const String& qualifier, bool value = true);
@ -69,32 +71,18 @@ namespace ogfx
bool addThemeID(const String& id); bool addThemeID(const String& id);
bool removeThemeID(const String& id); bool removeThemeID(const String& id);
void setVisible(bool v); void setVisible(bool v);
inline const ostd::Stylesheet::QualifierList& getThemeQualifierList(void) const { return m_qualifierList; } void setCallback(eCallback type, EventCallback callback);
using Rectangle::contains; bool contains(Vec2 p, bool includeBounds = false) const override;
template<typename T>
inline T getThemeValue(const ostd::Stylesheet &theme, const String& key, const T& fallback)
{
return theme.get<T>(property(key), fallback, getThemeIDList(), getThemeQualifierList());
}
// ==========================================================================
inline virtual void onDraw(ogfx::BasicRenderer2D& gfx) { }
inline virtual void afterDraw(ogfx::BasicRenderer2D& gfx) { }
inline virtual void beforeDraw(ogfx::BasicRenderer2D& gfx) { }
inline virtual void onUpdate(void) { }
inline virtual void onWidgetAdded(Widget& child) { }
inline virtual void onMousePressed(const Event& event) { }
inline virtual void onMouseReleased(const Event& event) { }
inline virtual void onMouseMoved(const Event& event) { }
inline virtual void onMouseScrolled(const Event& event) { }
inline virtual void onDragAndDrop(const Event& event) { }
inline virtual void onMouseEntered(const Event& event) { }
inline virtual void onMouseExited(const Event& event) { }
inline virtual void onMouseDragged(const Event& event) { }
inline virtual void onKeyPressed(const Event& event) { }
inline virtual void onKeyReleased(const Event& event) { }
inline virtual void onTextEntered(const Event& event) { }
inline virtual void onFocusGained(const Event& event) { }
inline virtual void onFocusLost(const Event& event) { }
inline virtual void onWindowClosed(const Event& event) { }
inline virtual void onWindowResized(const Event& event) { }
inline virtual void onWindowFocused(const Event& event) { }
inline virtual void onWindowFocusLost(const Event& event) { }
// ================================== CORE =================================
void __draw(ogfx::BasicRenderer2D& gfx); void __draw(ogfx::BasicRenderer2D& gfx);
void __update(void); void __update(void);
void __onMousePressed(const Event& event); void __onMousePressed(const Event& event);
@ -113,103 +101,155 @@ namespace ogfx
void __onWindowFocused(const Event& event); void __onWindowFocused(const Event& event);
void __onWindowFocusLost(const Event& event); void __onWindowFocusLost(const Event& event);
void __applyTheme(const ostd::Stylesheet& theme, bool propagate); void __applyTheme(const ostd::Stylesheet& theme, bool propagate);
// ==========================================================================
inline virtual void setMousePressedCallback(EventCallback callback) { callback_onMousePressed = callback; }
inline virtual void setMouseReleasedCallback(EventCallback callback) { callback_onMouseReleased = callback; }
inline virtual void setMouseMovedCallback(EventCallback callback) { callback_onMouseMoved = callback; }
inline virtual void setMouseScrolledCallback(EventCallback callback) { callback_onMouseScrolled = callback; }
inline virtual void setDragAndDropCallback(EventCallback callback) { callback_onDragAndDrop = callback; }
inline virtual void setMouseEnteredCallback(EventCallback callback) { callback_onMouseEntered = callback; }
inline virtual void setMouseExitedCallback(EventCallback callback) { callback_onMouseExited = callback; }
inline virtual void setMouseDraggedCallback(EventCallback callback) { callback_onMouseDragged = callback; }
inline virtual void setKeyPressedCallback(EventCallback callback) { callback_onKeyPressed = callback; }
inline virtual void setKeyReleasedCallback(EventCallback callback) { callback_onKeyReleased = callback; }
inline virtual void setTextEnteredCallback(EventCallback callback) { callback_onTextEntered = callback; }
inline virtual void setWindowClosedCallback(EventCallback callback) { callback_onWindowClosed = callback; }
inline virtual void setWindowResizedCallback(EventCallback callback) { callback_onWindowResized = callback; }
inline virtual void setWindowFocusedCallback(EventCallback callback) { callback_onWindowFocused = callback; }
inline virtual void setWindowFocusLostCallback(EventCallback callback) { callback_onWindowFocusLost = callback; }
inline bool hasChildren(void) const { return m_allowChildren && m_widgets.widgetCount() > 0; }
inline virtual bool isInvalid(void) const override { return ostd::BaseObject::isInvalid() || (m_parent == nullptr && !m_rootChild); }
inline void setTabIndex(i32 tabIndex) { m_tabIndex = tabIndex; }
inline i32 getTabIndex(void) const { return m_tabIndex; }
inline bool isFocused(void) const { return m_focused; }
inline WindowCore& getWindow(void) { return *m_window; }
inline Widget* getParent(void) { return m_parent; }
inline i32 getZIndex(void) const { return m_zIndex; }
inline bool isChildrenEnabled(void) const { return m_allowChildren; }
inline void setPadding(const Rectangle& pad) { m_padding = pad; }
inline void setMargin(const Rectangle& margin) { m_margin = margin; }
inline void setContentOffset(const Vec2& offset) { m_contentOffset = offset; }
inline Rectangle getPadding(void) const { return m_padding; }
inline Rectangle getMargin(void) const { return m_margin; }
inline Vec2 getContentOffset(void) const { return m_contentOffset; }
inline bool isMouseInside(void) const { return m_mouseInside; }
inline ogfx::MouseEventData::eButton getPressedMouseButton(void) const { return m_pressedButton; }
inline const stdvec<String>& getThemeIDList(void) const { return m_themeIDList; }
inline bool isEnabled(void) const { return m_enabled; }
inline bool isFocusEnabled(void) const { return m_allowFocus; }
inline void enableFocus(bool enable = true) { m_allowFocus = enable; }
inline void disableFocus(void) { enableFocus(false); }
inline void disable(void) { enable(false); }
inline void enableStopEvents(bool enable = true) { m_stopEvents = enable; }
inline bool isDragAndDropEnabled(void) const { return m_acceptDragAndDrop; }
inline void enableDragAndDrop(bool enable = true) { m_acceptDragAndDrop = enable; }
inline void disableDragAndDrop(void) { enableDragAndDrop(false); }
inline void setBackGroundColor(const Color& color) { m_backgroundColor = color; }
inline Color getBackgroundColor(void) { return m_backgroundColor; }
inline void enableBackground(bool enable = true) { m_showBackground = enable; }
inline bool isBackgoundEnabled(void) const { return m_showBackground; }
inline void setBorderColor(const Color& color) { m_borderColor = color; }
inline Color getBorderColor(void) { return m_borderColor; }
inline void enableBorder(bool enable = true) { m_showBorder = enable; }
inline bool isBorderEnabled(void) const { return m_showBorder; }
inline void enableManualDraw(bool enable = true) { m_manualDraw = enable; }
inline bool isManualDrawEnabled(void) const { return m_manualDraw; }
inline void enableTopMost(bool enable = true) { m_topMost = enable; }
inline bool isTopMostEnabled(void) const { return m_topMost; }
inline void setBorderRadius(i32 br) { m_borderRadius = br; }
inline i32 getBorderRadius(void) const { return m_borderRadius; }
inline void setBorderWidth(i32 bw) { m_borderWidth = bw; }
inline i32 getBorderWidth(void) const { return m_borderWidth; }
inline bool isVisible(void) const { return m_visible; }
inline void show(void) { setVisible(true); }
inline void hide(void) { setVisible(false); }
inline void allowVScroll(bool allow = true) { m_vScrollEnabled = allow; }
inline bool isVScrollAllowed(void) const { return m_vScrollEnabled; }
inline void allowHScroll(bool allow = true) { m_hScrollEnabled = allow; }
inline bool isHScrollAllowed(void) const { return m_hScrollEnabled; }
inline void allowIgnoreScroll(bool allow = true) { m_ignoreScroll = allow; }
inline bool isIgnoreScrollAllowed(void) const { return m_ignoreScroll; }
template<typename T> // =============================== DIMENSIONS ===============================
inline T getThemeValue(const ostd::Stylesheet &theme, const String& key, const T& fallback) virtual Vec2 getGlobalPosition(void) const;
{ virtual Vec2 getGlobalContentPosition(void) const;
return theme.get<T>(key, fallback, getThemeIDList(), getThemeQualifierList()); virtual Rectangle getGlobalBounds(void) const;
} virtual Rectangle getContentBounds(void) const;
virtual Rectangle getPureContentBounds(void) const;
virtual Rectangle getGlobalContentBounds(void) const;
virtual Rectangle getGlobalPureContentBounds(void) const;
virtual Rectangle getContentExtents(void) const;
// ==========================================================================
// ================================= GETSET =================================
inline static void setDragAndDropData(ostd::BaseObject& data) { s_dragAndDropData = &data; s_hasDragAndDropData = true; } inline static void setDragAndDropData(ostd::BaseObject& data) { s_dragAndDropData = &data; s_hasDragAndDropData = true; }
inline static void clearDragAndDropData(void) { s_dragAndDropData = nullptr; } inline static void clearDragAndDropData(void) { s_dragAndDropData = nullptr; }
inline static ostd::BaseObject* getDragAndDropData(void) { return s_dragAndDropData; } inline static ostd::BaseObject* getDragAndDropData(void) { return s_dragAndDropData; }
inline WindowCore& getWindow(void) { return *m_window; }
inline Widget* getParent(void) { return m_parent; }
inline i32 getZIndex(void) const { return m_zIndex; }
inline ogfx::MouseEventData::eButton getPressedMouseButton(void) const { return m_pressedButton; }
inline const stdvec<String>& getThemeIDList(void) const { return m_themeIDList; }
inline const ostd::Stylesheet::QualifierList& getThemeQualifierList(void) const { return m_qualifierList; }
inline String getStylesheetCategoryName(void) const { return m_stylesheetCategoryName; }
OSTD_PARAM_GETSET(Color, TextColor, m_textColor);
OSTD_PARAM_GETSET(Color, BackgroundColor, m_backgroundColor);
OSTD_PARAM_GETSET(Color, BorderColor, m_borderColor);
OSTD_PARAM_GETSET(i32, BorderRadius, m_borderRadius);
OSTD_PARAM_GETSET(i32, BorderWidth, m_borderWidth);
OSTD_PARAM_GETSET(i32, FontSize, m_fontSize);
OSTD_PARAM_GETSET(ostd::ColorGradient, BackgroundGradient, m_backgroundGradient);
OSTD_PARAM_GETSET(Rectangle, Padding, m_padding);
OSTD_PARAM_GETSET(Rectangle, Margin, m_margin);
OSTD_PARAM_GETSET(i32, TabIndex, m_tabIndex);
OSTD_PARAM_GETSET(Vec2, ContentOffset, m_contentOffset);
// BOOL PARAMETERS
inline bool isVisible(void) const { return m_visible; }
inline void show(void) { setVisible(true); }
inline void hide(void) { setVisible(false); }
inline bool isChildrenEnabled(void) const { return m_allowChildren; }
inline bool isEnabled(void) const { return m_enabled; }
inline void disable(void) { enable(false); }
inline bool isFocused(void) const { return m_focused; }
inline bool isMouseInside(void) const { return m_mouseInside; }
inline bool hasChildren(void) const { return m_allowChildren && m_widgets.widgetCount() > 0; }
inline bool isRootChild(void) const { return m_rootChild; }
inline void setRootChild(void) { m_rootChild = true; }
inline virtual bool isInvalid(void) const override { return ostd::BaseObject::isInvalid() || (m_parent == nullptr && !m_rootChild); }
OSTD_BOOL_PARAM_GETSET_E(Focus, m_allowFocus);
OSTD_BOOL_PARAM_GETSET_E(StopEvents, m_stopEvents);
OSTD_BOOL_PARAM_GETSET_E(DragAndDrop, m_acceptDragAndDrop);
OSTD_BOOL_PARAM_GETSET_E(Background, m_showBackground);
OSTD_BOOL_PARAM_GETSET_E(Border, m_showBorder);
OSTD_BOOL_PARAM_GETSET_E(ManualDraw, m_manualDraw);
OSTD_BOOL_PARAM_GETSET_E(TopMost, m_topMost);
OSTD_BOOL_PARAM_GETSET_E(IgnoreScroll, m_ignoreScroll);
OSTD_BOOL_PARAM_GETSET_E(VScroll, m_vScrollEnabled);
OSTD_BOOL_PARAM_GETSET_E(HScroll, m_vScrollEnabled);
OSTD_BOOL_PARAM_GETSET_E(BackgroundGradient, m_useBackgroundGradient);
OSTD_BOOL_PARAM_GETSET_E(Theming, m_enableTheming);
// ==========================================================================
protected: protected:
void apply_common_theme_values(const ostd::Stylesheet& theme);
inline void disableChildren(void) { m_allowChildren = false; } inline void disableChildren(void) { m_allowChildren = false; }
inline void disableDrawBox(void) { m_drawBox = false; } inline void setStylesheetCategoryName(const String& name) { m_stylesheetCategoryName = name; }
inline void enableDrawBox(void) { m_drawBox = true; } inline String property(const ostd::String& prop) const { return m_stylesheetCategoryName + "." + prop; }
inline bool isDrawBoxEnabled(void) const { return m_drawBox; }
inline void setDrawBoxColor(const Color& color) { m_drawBoxColor = color; } private:
inline Color getDrawBoxColor(void) { return m_drawBoxColor; } // ======= CORE =======
WindowCore* m_window { nullptr };
Widget* m_parent { nullptr };
WidgetManager m_widgets;
protected:
bool m_rootChild { false }; bool m_rootChild { false };
bool m_focused { false };
i32 m_tabIndex { -1 };
i32 m_zIndex { -1 };
MouseEventData::eButton m_pressedButton { MouseEventData::eButton::None };
// ====================
// ======= BOOL =======
bool m_allowChildren { true };
bool m_mouseInside { false };
bool m_allowFocus { true };
bool m_enabled { true };
bool m_stopEvents { true };
bool m_clipContents { true };
bool m_acceptDragAndDrop { false };
bool m_visible { true };
bool m_ignoreScroll { false};
bool m_manualDraw { false };
bool m_topMost { false };
bool m_vScrollEnabled { false };
bool m_hScrollEnabled { false };
bool m_enableTheming { true };
// ====================
// ====== THEMING =====
String m_stylesheetCategoryName { "" };
stdvec<String> m_themeIDList;
ostd::Stylesheet::QualifierList m_qualifierList {
{ "disabled", false },
{ "pressed", false },
{ "hover", false },
{ "focused", false },
{ "active", false }
};
stdvec<ThemeOverride> m_themeOverrides;
Rectangle m_padding { 0, 0, 0, 0 };
Rectangle m_margin { 0, 0, 0, 0 };
Vec2 m_contentOffset { 0, 0 };
i32 m_borderRadius { 10 }; i32 m_borderRadius { 10 };
i32 m_borderWidth { 2 }; i32 m_borderWidth { 2 };
Color m_borderColor { 255, 255, 255 }; Color m_borderColor { 255, 255, 255 };
bool m_showBorder { false }; bool m_showBorder { false };
Color m_backgroundColor { Colors::Transparent }; Color m_backgroundColor { Colors::Transparent };
bool m_showBackground { false }; bool m_showBackground { false };
i32 m_fontSize { 20 };
Color m_textColor { 255, 255, 255 };
bool m_useBackgroundGradient { false };
ColorGradient m_backgroundGradient {
{ Color { 160, 160, 160 }, Color { 120, 120, 120 } },
{ 1.0f }
};
// ====================
// ====== STATIC ======
static ostd::BaseObject* s_dragAndDropData;
static bool s_hasDragAndDropData;
friend class WidgetManager;
// ====================
// =============================== CALLBACKS/DUMMIES ===============================
protected:
EventCallback callback_onMousePressed { nullptr }; EventCallback callback_onMousePressed { nullptr };
EventCallback callback_onMouseReleased { nullptr }; EventCallback callback_onMouseReleased { nullptr };
EventCallback callback_onDragAndDrop { nullptr }; EventCallback callback_onDragAndDrop { nullptr };
@ -226,49 +266,40 @@ namespace ogfx
EventCallback callback_onWindowFocused { nullptr }; EventCallback callback_onWindowFocused { nullptr };
EventCallback callback_onWindowFocusLost { nullptr }; EventCallback callback_onWindowFocusLost { nullptr };
private: public:
WindowCore* m_window { nullptr }; // ====================== DUMMIES ======================
Widget* m_parent { nullptr }; inline virtual void applyTheme(const ostd::Stylesheet& theme) { }
bool m_focused { false }; inline virtual Vec2 getScrollOffset(void) const { return { 0, 0 }; }
i32 m_tabIndex { -1 }; inline virtual void setScrollOffset(const Vec2& offset) { }
i32 m_zIndex { -1 }; inline virtual void addScrollOffset(const Vec2& offset) { }
WidgetManager m_widgets; inline virtual bool needsVScroll(void) const { return false; }
bool m_allowChildren { true }; inline virtual bool needsHScroll(void) const { return false; }
bool m_mouseInside { false }; inline virtual f32 getVScrollbarSize(void) const { return 0; }
bool m_allowFocus { true }; inline virtual f32 getHScrollbarSize(void) const { return 0; }
bool m_enabled { true }; // =====================================================
bool m_stopEvents { true };
bool m_clipContents { true };
bool m_acceptDragAndDrop { false };
bool m_visible { true };
bool m_ignoreScroll { false};
bool m_manualDraw { false };
bool m_topMost { false };
bool m_vScrollEnabled { false };
bool m_hScrollEnabled { false };
MouseEventData::eButton m_pressedButton { MouseEventData::eButton::None };
stdvec<String> m_themeIDList; inline virtual void onDraw(ogfx::BasicRenderer2D& gfx) { }
ostd::Stylesheet::QualifierList m_qualifierList { inline virtual void afterDraw(ogfx::BasicRenderer2D& gfx) { }
{ "disabled", false }, inline virtual void beforeDraw(ogfx::BasicRenderer2D& gfx) { }
{ "pressed", false }, inline virtual void onUpdate(void) { }
{ "hover", false }, inline virtual void onWidgetAdded(Widget& child) { }
{ "focused", false }, inline virtual void onMousePressed(const Event& event) { }
{ "active", false } inline virtual void onMouseReleased(const Event& event) { }
}; inline virtual void onMouseMoved(const Event& event) { }
stdvec<ThemeOverride> m_themeOverrides; inline virtual void onMouseScrolled(const Event& event) { }
inline virtual void onDragAndDrop(const Event& event) { }
bool m_drawBox { true }; inline virtual void onMouseEntered(const Event& event) { }
Color m_drawBoxColor { 255, 0, 0 }; inline virtual void onMouseExited(const Event& event) { }
inline virtual void onMouseDragged(const Event& event) { }
Rectangle m_padding { 0, 0, 0, 0 }; inline virtual void onKeyPressed(const Event& event) { }
Rectangle m_margin { 0, 0, 0, 0 }; inline virtual void onKeyReleased(const Event& event) { }
Vec2 m_contentOffset { 0, 0 }; inline virtual void onTextEntered(const Event& event) { }
inline virtual void onFocusGained(const Event& event) { }
static ostd::BaseObject* s_dragAndDropData; inline virtual void onFocusLost(const Event& event) { }
static bool s_hasDragAndDropData; inline virtual void onWindowClosed(const Event& event) { }
inline virtual void onWindowResized(const Event& event) { }
friend class WidgetManager; inline virtual void onWindowFocused(const Event& event) { }
inline virtual void onWindowFocusLost(const Event& event) { }
}; };
} }
} }

42
src/ogfx/utils/Animation.hpp
View file

@ -20,54 +20,16 @@
#pragma once #pragma once
#include <ostd/data/Types.hpp> #include <ostd/data/AnimationData.hpp>
#include <ostd/math/Geometry.hpp> #include <ostd/math/Geometry.hpp>
#include <ostd/utils/Time.hpp> #include <ostd/utils/Time.hpp>
#include <ogfx/resources/Image.hpp> #include <ogfx/resources/Image.hpp>
namespace ogfx namespace ogfx
{ {
using AnimationData = ostd::AnimationData;
class Animation class Animation
{ {
public: struct AnimationData : public ostd::__i_stringeable {
i32 frameCount { 1 };
i32 stillFrame { 0 };
f64 fps { 60.0 };
i32 rowOffset { 0 };
i32 columnOffset { 0 };
f32 pixelOffsetX { 0.0f };
f32 pixelOffsetY { 0.0f };
i32 rows { 1 };
i32 columns { 1 };
f32 frameWidth{ 32 };
f32 frameHeight { 32 };
bool still { false };
bool turnBack { false };
bool random { false };
inline String toString(void) const override
{
String str = "";
str.add("AnimData {");
str.add(" ").add("frameCount: ").add(frameCount).add(",\n");
str.add(" ").add("stillFrame: ").add(stillFrame).add(",\n");
str.add(" ").add("rowOffset: ").add(rowOffset).add(",\n");
str.add(" ").add("columnOffset: ").add(columnOffset).add(",\n");
str.add(" ").add("pixelOffsetX: ").add(pixelOffsetX, 2).add(",\n");
str.add(" ").add("pixelOffsetY: ").add(pixelOffsetY, 2).add(",\n");
str.add(" ").add("rows: ").add(rows).add(",\n");
str.add(" ").add("columns: ").add(columns).add(",\n");
str.add(" ").add("frameWidth: ").add(frameWidth, 2).add(",\n");
str.add(" ").add("frameHeight: ").add(frameHeight, 2).add(",\n");
str.add(" ").add("still: ").add(STR_BOOL(still)).add(",\n");
str.add(" ").add("turnBack: ").add(STR_BOOL(turnBack)).add(",\n");
str.add(" ").add("random: ").add(STR_BOOL(random)).add(",\n");
str.add("}");
return str;
}
};
public: public:
inline Animation(void) { } inline Animation(void) { }
inline Animation(const AnimationData& ad) { create(ad); }; inline Animation(const AnimationData& ad) { create(ad); };

67
src/ostd/data/AnimationData.hpp Normal file
View file

@ -0,0 +1,67 @@
/*
OmniaFramework - A collection of useful functionality
Copyright (C) 2025 OmniaX-Dev
This file is part of OmniaFramework.
OmniaFramework 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 3 of the License, or
(at your option) any later version.
OmniaFramework 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 OmniaFramework. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <ostd/data/Types.hpp>
#include <ostd/string/String.hpp>
namespace ostd
{
struct AnimationData : public ostd::__i_stringeable {
i32 frameCount { 1 };
i32 stillFrame { 0 };
f64 fps { 60.0 };
i32 rowOffset { 0 };
i32 columnOffset { 0 };
f32 pixelOffsetX { 0.0f };
f32 pixelOffsetY { 0.0f };
i32 rows { 1 };
i32 columns { 1 };
f32 frameWidth{ 32 };
f32 frameHeight { 32 };
bool still { false };
bool turnBack { false };
bool random { false };
inline String toString(void) const override
{
String str = "";
str.add("AnimData {");
str.add(" ").add("frameCount: ").add(frameCount).add(",\n");
str.add(" ").add("stillFrame: ").add(stillFrame).add(",\n");
str.add(" ").add("rowOffset: ").add(rowOffset).add(",\n");
str.add(" ").add("columnOffset: ").add(columnOffset).add(",\n");
str.add(" ").add("pixelOffsetX: ").add(pixelOffsetX, 2).add(",\n");
str.add(" ").add("pixelOffsetY: ").add(pixelOffsetY, 2).add(",\n");
str.add(" ").add("rows: ").add(rows).add(",\n");
str.add(" ").add("columns: ").add(columns).add(",\n");
str.add(" ").add("frameWidth: ").add(frameWidth, 2).add(",\n");
str.add(" ").add("frameHeight: ").add(frameHeight, 2).add(",\n");
str.add(" ").add("still: ").add(STR_BOOL(still)).add(",\n");
str.add(" ").add("turnBack: ").add(STR_BOOL(turnBack)).add(",\n");
str.add(" ").add("random: ").add(STR_BOOL(random)).add(",\n");
str.add("}");
return str;
}
};
}

138
src/ostd/io/Stylesheet.cpp
View file

@ -63,6 +63,8 @@ namespace ostd
stdvec<String> group; stdvec<String> group;
u32 groupSelectorCount = 0; u32 groupSelectorCount = 0;
bool debug_print = false; bool debug_print = false;
bool brokenLine = false;
String brokenLineBuffer = "";
for (auto& line : lines) for (auto& line : lines)
{ {
lineNumber++; lineNumber++;
@ -73,6 +75,18 @@ namespace ostd
line.substr(0, line.indexOf("%")).trim(); line.substr(0, line.indexOf("%")).trim();
if (line == "") if (line == "")
continue; continue;
if (brokenLine)
{
line = brokenLineBuffer + line;
brokenLine = false;
brokenLineBuffer = "";
}
if (line.endsWith("\\"))
{
brokenLine = true;
brokenLineBuffer = line.new_trim().substr(0, line.len() - 1).trim();
continue;
}
if (line.startsWith("const ") || line.startsWith("$")) if (line.startsWith("const ") || line.startsWith("$"))
{ {
bool is_const = false; bool is_const = false;
@ -283,6 +297,15 @@ namespace ostd
} }
return false; return false;
}; };
auto l_isAnim = [this](String& value) -> bool {
value.trim();
if (value.startsWith("anim(") && value.endsWith(")"))
{
value.substr(5, value.len() - 1).trim();
return true;
}
return false;
};
if (key.startsWith("@")) if (key.startsWith("@"))
{ {
@ -313,6 +336,14 @@ namespace ostd
return false; return false;
set(key, grad, themeID); set(key, grad, themeID);
} }
else if (l_isAnim(value))
{
bool outError = false;
AnimationData ad = parseAnim(value, outError);
if (outError)
return false;
set(key, ad, themeID);
}
else if (l_isFile(value)) else if (l_isFile(value))
{ {
bool exists = ostd::FileSystem::fileExists(value) || bool exists = ostd::FileSystem::fileExists(value) ||
@ -510,6 +541,113 @@ namespace ostd
return grad; return grad;
} }
AnimationData Stylesheet::parseAnim(const String& _value, bool& outError)
{
String value = _value.new_toLower().trim();
AnimationData ad;
auto tokens = value.tokenize(",");
auto l_error = [&](bool err) -> AnimationData {
outError = err;
return ad;
};
for (auto& tok : tokens)
{
if (tok.count(":") != 1 || tok.startsWith(":") || tok.endsWith(":"))
return l_error(true);
String prop = tok.new_substr(0, tok.indexOf(":")).trim();
String val = tok.new_substr(tok.indexOf(":") + 1).trim();
if (prop == "framecount")
{
if (!val.isInt())
return l_error(true);
ad.frameCount = val.toInt();
}
else if (prop == "stillframe")
{
if (!val.isInt())
return l_error(true);
ad.stillFrame = val.toInt();
}
else if (prop == "fps")
{
if (!val.isNumeric(true))
return l_error(true);
ad.fps = val.toFloat();
}
else if (prop == "rowoffset")
{
if (!val.isInt())
return l_error(true);
ad.rowOffset = val.toInt();
}
else if (prop == "columnoffset")
{
if (!val.isInt())
return l_error(true);
ad.columnOffset = val.toInt();
}
else if (prop == "pixeloffsetx")
{
if (!val.isNumeric(true))
return l_error(true);
ad.pixelOffsetX = val.toFloat();
}
else if (prop == "pixeloffsety")
{
if (!val.isNumeric(true))
return l_error(true);
ad.pixelOffsetY = val.toFloat();
}
else if (prop == "rows")
{
if (!val.isInt())
return l_error(true);
ad.rows = val.toInt();
}
else if (prop == "columns")
{
if (!val.isInt())
return l_error(true);
ad.columns = val.toInt();
}
else if (prop == "framewidth")
{
if (!val.isNumeric(true))
return l_error(true);
ad.frameWidth = val.toFloat();
}
else if (prop == "frameheight")
{
if (!val.isNumeric(true))
return l_error(true);
ad.frameHeight = val.toFloat();
}
else if (prop == "still")
{
if (!val.isBool())
return l_error(true);
ad.still = val.toBool();
}
else if (prop == "turnback")
{
if (!val.isBool())
return l_error(true);
ad.turnBack = val.toBool();
}
else if (prop == "random")
{
if (!val.isBool())
return l_error(true);
ad.random = val.toBool();
}
else
{
return l_error(true);
}
}
return l_error(false);
}
void Stylesheet::debugPrint(void) void Stylesheet::debugPrint(void)
{ {
for (const auto&[key, value] : m_values) for (const auto&[key, value] : m_values)

4
src/ostd/io/Stylesheet.hpp
View file

@ -23,6 +23,7 @@
#include <ostd/string/TextStyleParser.hpp> #include <ostd/string/TextStyleParser.hpp>
#include <ostd/data/Color.hpp> #include <ostd/data/Color.hpp>
#include <ostd/math/Geometry.hpp> #include <ostd/math/Geometry.hpp>
#include <ostd/data/AnimationData.hpp>
#include <variant> #include <variant>
@ -32,7 +33,7 @@ namespace ostd
{ {
public: using QualifierList = stdvec<std::pair<const String, bool>>; public: using QualifierList = stdvec<std::pair<const String, bool>>;
public: using VariableList = stdumap<String, std::pair<String, bool>>; public: using VariableList = stdumap<String, std::pair<String, bool>>;
public: using TypeVariant = std::variant<i32, f32, bool, String, Color, Rectangle, Vec2, ColorGradient>; public: using TypeVariant = std::variant<i32, f32, bool, String, Color, Rectangle, Vec2, ColorGradient, AnimationData>;
public: public:
Stylesheet(void); Stylesheet(void);
Stylesheet& clear(void); Stylesheet& clear(void);
@ -63,6 +64,7 @@ namespace ostd
String parseGroupSelector(const String& rawSelector) const; String parseGroupSelector(const String& rawSelector) const;
stdvec<String> parseGroup(const String& selector, const stdvec<String>& group); stdvec<String> parseGroup(const String& selector, const stdvec<String>& group);
ColorGradient parseColorGradient(const String& _value); ColorGradient parseColorGradient(const String& _value);
AnimationData parseAnim(const String& _value, bool& outError);
private: private:
stdumap<String, TypeVariant> m_values; stdumap<String, TypeVariant> m_values;

12
src/ostd/string/String.cpp
View file

@ -460,6 +460,18 @@ namespace ostd
return std::stod(m_data); return std::stod(m_data);
} }
bool String::toBool(void) const
{
String str = new_toLower().trim();
return str == "true";
}
bool String::isBool(void) const
{
String str = new_toLower().trim();
return str == "true" || str == "false";
}
bool String::isNumeric(bool decimal) const bool String::isNumeric(bool decimal) const
{ {
if (decimal) if (decimal)

2
src/ostd/string/String.hpp
View file

@ -156,6 +156,8 @@ namespace ostd
i64 toInt(void) const; i64 toInt(void) const;
f32 toFloat(void) const; f32 toFloat(void) const;
f64 toDouble(void) const; f64 toDouble(void) const;
bool toBool(void) const;
bool isBool(void) const;
bool isNumeric(bool decimal = false) const; bool isNumeric(bool decimal = false) const;
bool isInt(void) const; bool isInt(void) const;
bool isHex(void) const; bool isHex(void) const;

40
src/ostd/utils/Defines.hpp
View file

@ -1,21 +1,21 @@
/* /*
OmniaFramework - A collection of useful functionality OmniaFramework - A collection of useful functionality
Copyright (C) 2025 OmniaX-Dev Copyright (C) 2025 OmniaX-Dev
This file is part of OmniaFramework. This file is part of OmniaFramework.
OmniaFramework is free software: you can redistribute it and/or modify OmniaFramework is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
OmniaFramework is distributed in the hope that it will be useful, OmniaFramework is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with OmniaFramework. If not, see <https://www.gnu.org/licenses/>. along with OmniaFramework. If not, see <https://www.gnu.org/licenses/>.
*/ */
#pragma once #pragma once
@ -57,3 +57,17 @@
#else #else
#define _DEBUG(n) std::cout << (i32)n << "\n"; #define _DEBUG(n) std::cout << (i32)n << "\n";
#endif #endif
#define OSTD_BOOL_PARAM_GETSET_E(name, member) \
inline bool is##name##Enabled(void) const { return member; } \
inline void enable##name(bool enable = true) { member = enable; } \
inline void disable##name(void) { enable##name(false); }
#define OSTD_BOOL_PARAM_GETSET_I(name, member) \
inline bool is##name(void) const { return member; } \
inline void enable##name(bool enable = true) { member = enable; } \
inline void disable##name(void) { enable##name(false); }
#define OSTD_PARAM_GETSET(type, name, member) \
inline type get##name(void) const { return member; } \
inline void set##name(const type& value) { member = value; } \

21
src/test/GuiTest.cpp
View file

@ -33,7 +33,7 @@ class Window : public ogfx::gui::Window
inline void onInitialize(void) override inline void onInitialize(void) override
{ {
m_img.loadFromFile("./img.png", m_gfx); m_img.loadFromFile("./img.png", m_gfx);
ogfx::Animation::AnimationData ad; ogfx::AnimationData ad;
ad.columns = 9; ad.columns = 9;
ad.rows = 4; ad.rows = 4;
ad.frameWidth = 256; ad.frameWidth = 256;
@ -45,10 +45,11 @@ class Window : public ogfx::gui::Window
m_label1.setText("Show Panel2"); m_label1.setText("Show Panel2");
m_label1.setMousePressedCallback([&](const ogfx::gui::Event& event) -> void { m_label1.setCallback(ogfx::gui::Widget::eCallback::MousePressed, [&](const ogfx::gui::Event& event) -> void {
m_check1.setChecked(!m_check1.isChecked()); m_check1.setChecked(!m_check1.isChecked());
m_label1.addy(10); m_label1.addy(10);
}); });
m_label1.disableTheming();
m_label1.addThemeOverride("@.label.showBackground", true); m_label1.addThemeOverride("@.label.showBackground", true);
m_label1.addThemeOverride("@.label.backgroundColor", Colors::Beige); m_label1.addThemeOverride("@.label.backgroundColor", Colors::Beige);
m_label1.addThemeOverride("@.label.showBorder", true); m_label1.addThemeOverride("@.label.showBorder", true);
@ -56,6 +57,8 @@ class Window : public ogfx::gui::Window
m_label1.addThemeOverride("@.label.borderColor", Colors::DarkMagenta); m_label1.addThemeOverride("@.label.borderColor", Colors::DarkMagenta);
m_label1.addThemeOverride("@:pressed.label.backgroundColor", Colors::Crimson); m_label1.addThemeOverride("@:pressed.label.backgroundColor", Colors::Crimson);
m_label1.addThemeOverride("@:hover.label.backgroundColor", Colors::DarkRed); m_label1.addThemeOverride("@:hover.label.backgroundColor", Colors::DarkRed);
m_label1.setBackgroundColor(Colors::Red);
m_label1.enableBackground();
m_label1.reloadTheme(); m_label1.reloadTheme();
m_check1.setText("Check this out!"); m_check1.setText("Check this out!");
@ -65,7 +68,7 @@ class Window : public ogfx::gui::Window
}); });
m_btn1.setText("BUTTON"); m_btn1.setText("BUTTON");
m_btn1.setMousePressedCallback([&](const ogfx::gui::Event& event) -> void { m_btn1.setCallback(ogfx::gui::Widget::eCallback::MousePressed, [&](const ogfx::gui::Event& event) -> void {
}); });
@ -75,13 +78,13 @@ class Window : public ogfx::gui::Window
m_label5.setText("Label5"); m_label5.setText("Label5");
m_panel1.setSize(700, 300); m_panel1.setSize(700, 300);
m_panel1.allowVScroll(false); m_panel1.disableVScroll();
m_panel1.allowHScroll(false); m_panel1.disableHScroll();
m_panel1.setTitle("Panel 1"); m_panel1.setTitle("Panel 1");
m_panel3.setSize(150, 150); m_panel3.setSize(150, 150);
m_panel3.allowVScroll(false); m_panel3.disableVScroll();
m_panel3.allowHScroll(false); m_panel3.disableHScroll();
m_panel3.setTitle("Panel 3"); m_panel3.setTitle("Panel 3");
m_panel2.setSize(600, 400); m_panel2.setSize(600, 400);
@ -148,8 +151,10 @@ i32 main(i32 argc, char** argv)
{ {
ostd::initialize(); ostd::initialize();
Window window; Window window;
window.initialize(800, 600, "OmniaFramework - Test Window"); window.initialize(1200, 800, "OmniaFramework - Test Window");
window.setClearColor({ 0, 0, 0 }); window.setClearColor({ 0, 0, 0 });
window.setPosition({ 50, 50 });
window.setWindowState(ogfx::WindowCore::eWindowState::Maximized);
window.mainLoop(); window.mainLoop();
return 0; return 0;
} }