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;

57
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())
gfx.fillRect({ getGlobalPosition(), getSize() }, getDrawBoxColor());
else
{
beforeDraw(gfx); beforeDraw(gfx);
if (m_showBackground && m_showBorder) if (m_useBackgroundGradient && m_showBorder)
gfx.outlinedRoundRect({ getGlobalPosition(), getSize() }, m_backgroundColor, m_borderColor, m_borderRadius, m_borderWidth); gfx.fillGradientRect({ getGlobalPosition(), getSize() }, m_backgroundGradient);
else if (m_showBackground) else if (m_showBackground)
gfx.fillRoundRect({ getGlobalPosition(), getSize() }, m_backgroundColor, m_borderRadius); 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;

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

@ -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;
} }