jgrogan/stuff-from-scratch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move windows to uptr. Add simple text editing.

Browse source
This commit is contained in:
jmsgrogan 2020-06-20 16:34:10 +01:00
parent 2bcc7b3d83
commit b99708e7d3
55 changed files with 1257 additions and 994 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,5 +1,5 @@
# limmto
limmto (Light Multi-Media Tool) is a low-dependency C++ library for working with a range of digital media.
limmto (Light Multi-Media Tool) is a free, low-dependency C++ library for working with digital media.
```bash
mkdir build

24
apps/gui-main.cpp
View file

@ -6,19 +6,19 @@
int main(int argc, char *argv[])
{
auto command_line_args = CommandLineArgs::CreateUnique();
command_line_args->Process(argc, argv);
command_line_args->RecordLaunchPath();
auto args = CommandLineArgs::CreateUnique();
args->Process(argc, argv);
args->RecordLaunchPath();
// Start the main app
auto main_app = MainApplication::Create();
main_app->Initialize(std::move(command_line_args));
// Start the main app
auto main_app = MainApplication::Create();
main_app->Initialize(std::move(args));
// Start the gui app
auto gui_app = std::make_shared<GuiApplication>();
gui_app->SetMainApplication(main_app);
gui_app->Run();
// Start the gui app
auto gui_app = GuiApplication();
gui_app.SetMainApplication(main_app);
gui_app.Run();
main_app->ShutDown();
return 0;
main_app->ShutDown();
return 0;
}

65
src/client/GuiApplication.cpp
View file

@ -1,8 +1,8 @@
#include "GuiApplication.h"
#include <iostream>
#include "Widget.h"
#include "HorizontalSpacer.h"
#include "TextBox.h"
#include "Button.h"
#include "Label.h"
#include "XcbInterface.h"
@ -12,11 +12,11 @@
#include "WindowManager.h"
GuiApplication::GuiApplication()
: AbstractDesktopApp(),
mMainApplication(),
mDesktopManager()
: AbstractDesktopApp(),
mMainApplication(),
mDesktopManager(DesktopManager::Create())
{
mDesktopManager = DesktopManager::Create();
}
GuiApplication::~GuiApplication()
@ -26,45 +26,46 @@ GuiApplication::~GuiApplication()
void GuiApplication::SetMainApplication(MainApplicationPtr app)
{
mMainApplication = app;
//mDesktopManager->SetMainApp(shared_from_this());
mMainApplication = app;
}
void GuiApplication::Run()
{
auto mainWindow = mDesktopManager->GetWindowManager()->GetMainWindow();
auto mainWindow = mDesktopManager->GetWindowManager()->GetMainWindow();
mainWindow->SetSize(800, 600);
mainWindow->SetSize(800, 600);
auto label = Label::Create();
label->SetLabel("Click the button!!");
label->SetBackgroundColor(Color::Create(0, 200, 200));
auto label = Label::Create();
label->SetLabel("Type text!!");
label->SetBackgroundColor(Color::Create(0, 200, 200));
auto button = Button::Create();
button->SetLabel("Ok");
button->SetBackgroundColor(Color::Create(0, 0, 200));
auto textBox = TextBox::Create();
auto spacer = HorizontalSpacer::Create();
spacer->AddWidget(label);
spacer->AddWidget(button);
auto button = Button::Create();
button->SetLabel("Save");
button->SetBackgroundColor(Color::Create(0, 0, 200));
mainWindow->AddWidget(spacer);
auto spacer = HorizontalSpacer::Create();
spacer->AddWidget(std::move(label));
spacer->AddWidget(std::move(textBox));
spacer->AddWidget(std::move(button));
mDesktopManager->SetKeyboard(XcbKeyboard::Create());
mainWindow->AddWidget(std::move(spacer));
mDesktopManager->SetKeyboard(XcbKeyboard::Create());
bool useOpenGl = false;
XcbInterface window_interface;
window_interface.SetUseOpenGl(useOpenGl);
window_interface.Initialize();
window_interface.AddWindow(mainWindow);
window_interface.ShowWindow(mainWindow);
if(useOpenGl)
{
window_interface.CreateOpenGlDrawable(mainWindow);
}
bool useOpenGl = false;
XcbInterface window_interface;
window_interface.SetUseOpenGl(useOpenGl);
window_interface.Initialize();
window_interface.AddWindow(mainWindow);
window_interface.ShowWindow(mainWindow);
if(useOpenGl)
{
window_interface.CreateOpenGlDrawable(mainWindow);
}
window_interface.Loop(mDesktopManager);
window_interface.Loop(mDesktopManager.get());
window_interface.ShutDown();
window_interface.ShutDown();
}

14
src/client/GuiApplication.h
View file

@ -6,21 +6,21 @@
#include "AbstractDesktopApp.h"
#include "DesktopManager.h"
class GuiApplication : public AbstractDesktopApp, std::enable_shared_from_this<GuiApplication>
class GuiApplication : public AbstractDesktopApp
{
private:
DesktopManagerPtr mDesktopManager;
MainApplicationPtr mMainApplication;
DesktopManagerUPtr mDesktopManager;
MainApplicationPtr mMainApplication;
public:
GuiApplication();
GuiApplication();
~GuiApplication();
~GuiApplication();
void SetMainApplication(MainApplicationPtr app);
void SetMainApplication(MainApplicationPtr app);
void Run();
void Run();
};

34
src/console/MainApplication.cpp
View file

@ -6,8 +6,8 @@
#include <filesystem>
MainApplication::MainApplication()
: mDatabaseManager(),
mCommandLineArgs()
: mDatabaseManager(),
mCommandLineArgs()
{
}
@ -22,16 +22,16 @@ void MainApplication::Initialize(CommandLineArgsUPtr commandLineArgs)
mCommandLineArgs = std::move(commandLineArgs);
std::string launch_path = mCommandLineArgs->GetLaunchPath().string();
FileLogger::GetInstance().SetWorkDirectory(launch_path);
FileLogger::GetInstance().Open();
MLOG_INFO("Launched");
FileLogger::GetInstance().SetWorkDirectory(launch_path);
FileLogger::GetInstance().Open();
MLOG_INFO("Launched");
mDatabaseManager = DatabaseManager::Create();
mDatabaseManager->CreateDatabase(launch_path + "/database.db");
mDatabaseManager = DatabaseManager::Create();
mDatabaseManager->CreateDatabase(launch_path + "/database.db");
mNetworkManager = NetworkManager::Create();
mNetworkManager = NetworkManager::Create();
mAudioManager = AudioManager::Create();
mAudioManager = AudioManager::Create();
}
void MainApplication::Run()
@ -77,13 +77,13 @@ void MainApplication::Run()
void MainApplication::RunServer()
{
mNetworkManager->RunHttpServer();
mNetworkManager->RunHttpServer();
}
void MainApplication::PlayAudio()
{
//MidiReader reader;
//reader.Read("/home/james/sample.mid");
//MidiReader reader;
//reader.Read("/home/james/sample.mid");
auto device = AudioDevice::Create();
mAudioManager->GetAudioInterface()->OpenDevice(device);
mAudioManager->GetAudioInterface()->Play(device);
@ -100,13 +100,13 @@ void MainApplication::ConvertDocument(const std::string& inputPath, const std::s
void MainApplication::ShutDown()
{
mDatabaseManager->OnShutDown();
mNetworkManager->ShutDown();
MLOG_INFO("Shut down");
FileLogger::GetInstance().Close();
mDatabaseManager->OnShutDown();
mNetworkManager->ShutDown();
MLOG_INFO("Shut down");
FileLogger::GetInstance().Close();
}
std::shared_ptr<MainApplication> MainApplication::Create()
{
return std::make_shared<MainApplication>();
return std::make_shared<MainApplication>();
}

18
src/console/MainApplication.h
View file

@ -14,23 +14,23 @@ class MainApplication
private:
CommandLineArgsUPtr mCommandLineArgs;
DatabaseManagerPtr mDatabaseManager;
NetworkManagerPtr mNetworkManager;
AudioManagerPtr mAudioManager;
DatabaseManagerPtr mDatabaseManager;
NetworkManagerPtr mNetworkManager;
AudioManagerPtr mAudioManager;
public:
MainApplication();
MainApplication();
~MainApplication();
~MainApplication();
void Initialize(CommandLineArgsUPtr commandLineArgs);
void Initialize(CommandLineArgsUPtr commandLineArgs);
void Run();
void Run();
void ShutDown();
void ShutDown();
static std::shared_ptr<MainApplication> Create();
static std::shared_ptr<MainApplication> Create();
private:
void RunServer();

41
src/core/Color.cpp
View file

@ -1,36 +1,47 @@
#include "Color.h"
Color::Color(unsigned r, unsigned g, unsigned b, double a)
: mR(r),
mG(g),
mB(b),
mAlpha(a)
: mR(r),
mG(g),
mB(b),
mAlpha(a)
{
}
std::shared_ptr<Color> Color::Create(unsigned r, unsigned g, unsigned b,
double a )
std::shared_ptr<Color> Color::CreateShared(unsigned r, unsigned g, unsigned b,
double a )
{
return std::make_shared<Color>(r, g, b, a);
return std::make_shared<Color>(r, g, b, a);
}
unsigned Color::GetR()
std::unique_ptr<Color> Color::Create(unsigned r, unsigned g, unsigned b,
double a )
{
return mR;
return std::make_unique<Color>(r, g, b, a);
}
unsigned Color::GetG()
std::unique_ptr<Color> Color::Create(const Color& color)
{
return mG;
return std::make_unique<Color>(color);
}
unsigned Color::GetB()
unsigned Color::GetR() const
{
return mB;
return mR;
}
double Color::GetAlpha()
unsigned Color::GetG() const
{
return mAlpha;
return mG;
}
unsigned Color::GetB() const
{
return mB;
}
double Color::GetAlpha() const
{
return mAlpha;
}

24
src/core/Color.h
View file

@ -3,21 +3,23 @@
class Color
{
unsigned mR;
unsigned mG;
unsigned mB;
double mAlpha;
unsigned mR;
unsigned mG;
unsigned mB;
double mAlpha;
public:
Color(unsigned r, unsigned g, unsigned b, double a = 1.0);
Color(unsigned r, unsigned g, unsigned b, double a = 1.0);
static std::shared_ptr<Color> CreateShared(unsigned r, unsigned g, unsigned b, double a = 1.0);
static std::unique_ptr<Color> Create(unsigned r, unsigned g, unsigned b, double a = 1.0);
static std::unique_ptr<Color> Create(const Color& color);
static std::shared_ptr<Color> Create(unsigned r, unsigned g, unsigned b, double a = 1.0);
unsigned GetR();
unsigned GetG();
unsigned GetB();
double GetAlpha();
unsigned GetR() const;
unsigned GetG() const;
unsigned GetB() const;
double GetAlpha() const;
};
using ColorPtr = std::shared_ptr<Color>;
using ColorUPtr = std::unique_ptr<Color>;

1
src/ui_elements/CMakeLists.txt
View file

@ -10,6 +10,7 @@ list(APPEND ui_elements_LIB_INCLUDES
widgets/Button.cpp
widgets/Label.cpp
widgets/HorizontalSpacer.cpp
widgets/TextBox.cpp
widgets/elements/GeometryElement.cpp
widgets/elements/RectangleElement.cpp
widgets/elements/TextElement.cpp

6
src/ui_elements/desktop_elements/Keyboard.cpp
View file

@ -1,13 +1,13 @@
#include "Keyboard.h"
Keyboard::Keyboard()
:mKeyMap()
:mKeyMap()
{
}
std::shared_ptr<Keyboard> Keyboard::Create()
std::unique_ptr<Keyboard> Keyboard::Create()
{
return std::make_shared<Keyboard>();
return std::make_unique<Keyboard>();
}

21
src/ui_elements/desktop_elements/Keyboard.h
View file

@ -6,21 +6,22 @@
class Keyboard
{
public:
using KeyCode = unsigned;
using KeyCode = unsigned;
protected:
std::map<KeyCode, std::string> mKeyMap;
std::map<KeyCode, std::string> mKeyMap;
public:
Keyboard();
virtual ~Keyboard() = default;
Keyboard();
static std::shared_ptr<Keyboard> Create();
virtual ~Keyboard() = default;
virtual std::string GetKeyString(KeyCode code)
{
return "";
}
static std::unique_ptr<Keyboard> Create();
virtual std::string GetKeyString(KeyCode code)
{
return "";
}
};
using KeyboardPtr = std::shared_ptr<Keyboard>;
using KeyboardUPtr = std::unique_ptr<Keyboard>;

57
src/ui_elements/desktop_elements/Window.cpp
View file

@ -2,9 +2,9 @@
namespace mt{
Window::Window()
:mWidth(400),
mHeight(300),
mWidget()
:mWidth(400),
mHeight(300),
mWidget()
{
}
@ -14,54 +14,59 @@ Window::~Window()
}
std::vector<VisualLayerPtr> Window::GetLayers()
std::unique_ptr<Window> Window::Create()
{
return mLayers;
return std::make_unique<Window>();
}
void Window::OnMouseEvent(MouseEventPtr event)
std::vector<VisualLayer*> Window::GetLayers()
{
mWidget->OnMouseEvent(event);
return mLayers;
}
void Window::OnPaint(PaintEventPtr event)
void Window::OnMouseEvent(const MouseEvent* event)
{
mLayers.clear();
mWidget->SetSize(mWidth, mHeight);
mWidget->OnPaintEvent(event);
auto layers = mWidget->GetLayers();
mLayers.insert(mLayers.end(), layers.begin(), layers.end());
mWidget->OnMouseEvent(event);
}
std::shared_ptr<Window> Window::Create()
void Window::OnKeyboardEvent(const KeyboardEvent* event)
{
return std::make_shared<Window>();
mWidget->OnKeyboardEvent(event);
}
void Window::AddWidget(WidgetPtr widget)
void Window::OnPaint(const PaintEvent* event)
{
mWidget = widget;
mLayers.clear();
mWidget->SetSize(mWidth, mHeight);
mWidget->OnPaintEvent(event);
auto layers = mWidget->GetLayers();
mLayers.insert(mLayers.end(), layers.begin(), layers.end());
}
WidgetPtr Window::GetWidget()
void Window::AddWidget(WidgetUPtr widget)
{
return mWidget;
mWidget = std::move(widget);
}
unsigned Window::GetWidth()
Widget* Window::GetWidget() const
{
return mWidth;
return mWidget.get();
}
unsigned Window::GetHeight()
unsigned Window::GetWidth() const
{
return mHeight;
return mWidth;
}
unsigned Window::GetHeight() const
{
return mHeight;
}
void Window::SetSize(unsigned width, unsigned height)
{
mWidth = width;
mHeight = height;
mWidth = width;
mHeight = height;
}
}

35
src/ui_elements/desktop_elements/Window.h
View file

@ -5,6 +5,7 @@
#include "PaintEvent.h"
#include "MouseEvent.h"
#include "KeyboardEvent.h"
#include "VisualLayer.h"
#include "Widget.h"
@ -16,35 +17,37 @@ class Window
private:
WidgetPtr mWidget;
unsigned mWidth;
unsigned mHeight;
std::vector<VisualLayerPtr> mLayers;
WidgetUPtr mWidget;
unsigned mWidth;
unsigned mHeight;
std::vector<VisualLayer*> mLayers;
public:
Window();
Window();
~Window();
~Window();
static std::shared_ptr<Window> Create();
static std::unique_ptr<Window> Create();
void AddWidget(WidgetPtr widget);
void AddWidget(WidgetUPtr widget);
WidgetPtr GetWidget();
Widget* GetWidget() const;
std::vector<VisualLayerPtr> GetLayers();
std::vector<VisualLayer*> GetLayers();
unsigned GetWidth();
unsigned GetWidth() const;
unsigned GetHeight();
unsigned GetHeight() const;
void SetSize(unsigned width, unsigned height);
void SetSize(unsigned width, unsigned height);
void OnPaint(PaintEventPtr event);
void OnPaint(const PaintEvent* event);
void OnMouseEvent(MouseEventPtr event);
void OnMouseEvent(const MouseEvent* event);
void OnKeyboardEvent(const KeyboardEvent* event);
};
}
using WindowPtr = std::shared_ptr<mt::Window>;
using WindowUPtr = std::unique_ptr<mt::Window>;

24
src/ui_elements/ui_events/KeyboardEvent.cpp
View file

@ -1,11 +1,11 @@
#include "KeyboardEvent.h"
KeyboardEvent::KeyboardEvent()
: UiEvent(),
mAction(),
mKeyString()
: UiEvent(),
mAction(),
mKeyString()
{
mType = UiEvent::Type::Keyboard;
mType = UiEvent::Type::Keyboard;
}
KeyboardEvent::~KeyboardEvent()
@ -13,27 +13,27 @@ KeyboardEvent::~KeyboardEvent()
}
std::shared_ptr<KeyboardEvent> KeyboardEvent::Create()
std::unique_ptr<KeyboardEvent> KeyboardEvent::Create()
{
return std::make_shared<KeyboardEvent>();
return std::make_unique<KeyboardEvent>();
}
void KeyboardEvent::SetKeyString(const std::string& key)
{
mKeyString = key;
mKeyString = key;
}
std::string KeyboardEvent::GetKeyString()
std::string KeyboardEvent::GetKeyString() const
{
return mKeyString;
return mKeyString;
}
void KeyboardEvent::SetAction(Action action)
{
mAction = action;
mAction = action;
}
KeyboardEvent::Action KeyboardEvent::GetAction()
KeyboardEvent::Action KeyboardEvent::GetAction() const
{
return mAction;
return mAction;
}

30
src/ui_elements/ui_events/KeyboardEvent.h
View file

@ -8,32 +8,32 @@
class KeyboardEvent : public UiEvent
{
public:
enum class Action
{
Pressed,
Released
};
enum class Action
{
Pressed,
Released
};
private:
Action mAction;
std::string mKeyString;
Action mAction;
std::string mKeyString;
public:
KeyboardEvent();
KeyboardEvent();
~KeyboardEvent();
~KeyboardEvent();
static std::shared_ptr<KeyboardEvent> Create();
static std::unique_ptr<KeyboardEvent> Create();
void SetKeyString(const std::string& key);
void SetKeyString(const std::string& key);
std::string GetKeyString();
std::string GetKeyString() const;
void SetAction(Action action);
void SetAction(Action action);
Action GetAction();
Action GetAction() const;
};
using KeyboardEventPtr = std::shared_ptr<KeyboardEvent>;
using KeyboardEventUPtr = std::unique_ptr<KeyboardEvent>;

32
src/ui_elements/ui_events/MouseEvent.cpp
View file

@ -1,12 +1,12 @@
#include "MouseEvent.h"
MouseEvent::MouseEvent()
: UiEvent(),
mClientLocation(0, 0),
mScreenLocation(0, 0),
mAction()
: UiEvent(),
mClientLocation(0, 0),
mScreenLocation(0, 0),
mAction()
{
mType = UiEvent::Type::Mouse;
mType = UiEvent::Type::Mouse;
}
MouseEvent::~MouseEvent()
@ -14,38 +14,38 @@ MouseEvent::~MouseEvent()
}
std::shared_ptr<MouseEvent> MouseEvent::Create()
std::unique_ptr<MouseEvent> MouseEvent::Create()
{
return std::make_shared<MouseEvent>();
return std::make_unique<MouseEvent>();
}
void MouseEvent::SetClientLocation(Pixel location)
{
mClientLocation = location;
mClientLocation = location;
}
void MouseEvent::SetScreenLocation(Pixel location)
{
mScreenLocation = location;
mScreenLocation = location;
}
void MouseEvent::SetAction(MouseEvent::Action action)
{
mAction = action;
mAction = action;
}
Pixel MouseEvent::GetClientLocation()
Pixel MouseEvent::GetClientLocation() const
{
return mClientLocation;
return mClientLocation;
}
Pixel MouseEvent::GetScreenLocation()
Pixel MouseEvent::GetScreenLocation() const
{
return mScreenLocation;
return mScreenLocation;
}
MouseEvent::Action MouseEvent::GetAction()
MouseEvent::Action MouseEvent::GetAction() const
{
return mAction;
return mAction;
}

36
src/ui_elements/ui_events/MouseEvent.h
View file

@ -8,35 +8,35 @@
class MouseEvent : public UiEvent
{
public:
enum class Action
{
Pressed,
Released
};
enum class Action
{
Pressed,
Released
};
private:
Pixel mClientLocation;
Pixel mScreenLocation;
Action mAction;
Pixel mClientLocation;
Pixel mScreenLocation;
Action mAction;
public:
MouseEvent();
MouseEvent();
~MouseEvent();
~MouseEvent();
static std::shared_ptr<MouseEvent> Create();
static std::unique_ptr<MouseEvent> Create();
void SetClientLocation(Pixel location);
void SetClientLocation(Pixel location);
void SetScreenLocation(Pixel location);
void SetScreenLocation(Pixel location);
void SetAction(Action action);
void SetAction(Action action);
Pixel GetClientLocation();
Pixel GetClientLocation() const;
Pixel GetScreenLocation();
Pixel GetScreenLocation() const;
Action GetAction();
Action GetAction() const;
};
using MouseEventPtr = std::shared_ptr<MouseEvent>;
using MouseEventUPtr = std::unique_ptr<MouseEvent>;

8
src/ui_elements/ui_events/PaintEvent.cpp
View file

@ -1,9 +1,9 @@
#include "PaintEvent.h"
PaintEvent::PaintEvent()
: UiEvent()
: UiEvent()
{
mType = UiEvent::Type::Paint;
mType = UiEvent::Type::Paint;
}
PaintEvent::~PaintEvent()
@ -11,8 +11,8 @@ PaintEvent::~PaintEvent()
}
std::shared_ptr<PaintEvent> PaintEvent::Create()
std::unique_ptr<PaintEvent> PaintEvent::Create()
{
return std::make_shared<PaintEvent>();
return std::make_unique<PaintEvent>();
}

8
src/ui_elements/ui_events/PaintEvent.h
View file

@ -8,10 +8,10 @@ class PaintEvent : public UiEvent
{
public:
PaintEvent();
PaintEvent();
~PaintEvent();
~PaintEvent();
static std::shared_ptr<PaintEvent> Create();
static std::unique_ptr<PaintEvent> Create();
};
using PaintEventPtr = std::shared_ptr<PaintEvent>;
using PaintEventUPtr = std::unique_ptr<PaintEvent>;

10
src/ui_elements/ui_events/UiEvent.cpp
View file

@ -1,7 +1,7 @@
#include "UiEvent.h"
UiEvent::UiEvent()
: mType(Type::Unknown)
: mType(Type::Unknown)
{
}
@ -11,13 +11,13 @@ UiEvent::~UiEvent()
}
std::shared_ptr<UiEvent> UiEvent::Create()
std::unique_ptr<UiEvent> UiEvent::Create()
{
return std::make_shared<UiEvent>();
return std::make_unique<UiEvent>();
}
UiEvent::Type UiEvent::GetType()
UiEvent::Type UiEvent::GetType() const
{
return mType;
return mType;
}

24
src/ui_elements/ui_events/UiEvent.h
View file

@ -6,24 +6,24 @@ class UiEvent
{
public:
enum class Type{
Unknown,
Paint,
Mouse,
Keyboard
};
enum class Type{
Unknown,
Paint,
Mouse,
Keyboard
};
protected:
UiEvent::Type mType;
UiEvent::Type mType;
public:
UiEvent();
UiEvent();
virtual ~UiEvent();
virtual ~UiEvent();
static std::shared_ptr<UiEvent> Create();
static std::unique_ptr<UiEvent> Create();
Type GetType();
Type GetType() const;
};
using UiEventPtr = std::shared_ptr<UiEvent>;
using UiEventUPtr = std::unique_ptr<UiEvent>;

47
src/ui_elements/widgets/Button.cpp
View file

@ -2,43 +2,42 @@
#include <iostream>
Button::Button()
: Widget(),
mLabel()
: Widget(),
mLabel()
{
}
std::shared_ptr<Button> Button::Create()
std::unique_ptr<Button> Button::Create()
{
return std::make_shared<Button>();
return std::make_unique<Button>();
}
void Button::SetLabel(const std::string& text)
{
mLabel = text;
mLabel = text;
}
void Button::OnMyMouseEvent(MouseEventPtr event)
void Button::OnMyMouseEvent(const MouseEvent* event)
{
if(event->GetAction() == MouseEvent::Action::Pressed)
{
std::cout << "Clicked !!" << std::endl;
SetBackgroundColor(Color::Create(0, 255, 0));
}
if(event->GetAction() == MouseEvent::Action::Pressed)
{
std::cout << "Clicked !!" << std::endl;
SetBackgroundColor(Color::Create(0, 255, 0));
}
}
void Button::OnPaintEvent(PaintEventPtr event)
void Button::OnPaintEvent(const PaintEvent* event)
{
mLayers.clear();
AddBackground(event);
if(!mLabel.empty())
{
auto middle = DiscretePoint(mLocation.GetX() + mWidth/2,
mLocation.GetY() + mHeight/2);
auto text = TextElement::Create(mLabel, middle);
auto textLayer = VisualLayer::Create();
textLayer->SetText(text);
mLayers.push_back(textLayer);
}
mMyLayers.clear();
AddBackground(event);
if(!mLabel.empty())
{
auto middle = DiscretePoint(mLocation.GetX() + mWidth/2,
mLocation.GetY() + mHeight/2);
auto textLayer = VisualLayer::Create();
textLayer->SetText(TextElement::Create(mLabel, middle));
mMyLayers.push_back(std::move(textLayer));
}
CopyMyLayers();
}

14
src/ui_elements/widgets/Button.h
View file

@ -5,20 +5,20 @@
class Button : public Widget
{
private:
std::string mLabel;
std::string mLabel;
public:
Button();
Button();
void SetLabel(const std::string& text);
static std::unique_ptr<Button> Create();
static std::shared_ptr<Button> Create();
void SetLabel(const std::string& text);
void OnPaintEvent(PaintEventPtr event);
void OnPaintEvent(const PaintEvent* event) override;
protected:
void OnMyMouseEvent(MouseEventPtr event);
void OnMyMouseEvent(const MouseEvent* event) override;
};
using ButtonPtr = std::shared_ptr<Button>;
using ButtonUPtr = std::unique_ptr<Button>;

37
src/ui_elements/widgets/HorizontalSpacer.cpp
View file

@ -1,33 +1,34 @@
#include "HorizontalSpacer.h"
#include <algorithm>
HorizontalSpacer::HorizontalSpacer()
: Widget()
: Widget()
{
}
std::shared_ptr<HorizontalSpacer> HorizontalSpacer::Create()
std::unique_ptr<HorizontalSpacer> HorizontalSpacer::Create()
{
return std::make_shared<HorizontalSpacer>();
return std::make_unique<HorizontalSpacer>();
}
void HorizontalSpacer::AddChildLayers(PaintEventPtr event)
void HorizontalSpacer::AddChildLayers(const PaintEvent* event)
{
unsigned delta = mHeight / mChildren.size();
for(std::size_t idx=0; idx<mChildren.size(); idx++)
{
auto child = mChildren[idx];
child->SetSize(mWidth, delta);
child->SetLocation(DiscretePoint(mLocation.GetX(), mLocation.GetY() + delta*idx));
child->OnPaintEvent(event);
auto layers = child->GetLayers();
mLayers.insert(mLayers.end(), layers.begin(), layers.end());
}
mLayers.clear();
unsigned delta = mHeight / mChildren.size();
for(std::size_t idx=0; idx<mChildren.size(); idx++)
{
auto& child = mChildren[idx];
child->SetSize(mWidth, delta);
child->SetLocation(DiscretePoint(mLocation.GetX(), mLocation.GetY() + delta*idx));
child->OnPaintEvent(event);
auto layers = child->GetLayers();
mLayers.insert(mLayers.end(), layers.begin(), layers.end());
}
}
void HorizontalSpacer::OnPaintEvent(PaintEventPtr event)
void HorizontalSpacer::OnPaintEvent(const PaintEvent* event)
{
mLayers.clear();
AddChildLayers(event);
AddChildLayers(event);
}

10
src/ui_elements/widgets/HorizontalSpacer.h
View file

@ -6,13 +6,13 @@ class HorizontalSpacer : public Widget
{
public:
HorizontalSpacer();
HorizontalSpacer();
static std::shared_ptr<HorizontalSpacer> Create();
static std::unique_ptr<HorizontalSpacer> Create();
void AddChildLayers(PaintEventPtr event) override;
void AddChildLayers(const PaintEvent* event) override;
void OnPaintEvent(PaintEventPtr event) override;
void OnPaintEvent(const PaintEvent* event) override;
};
using HorizontalSpacerPtr = std::shared_ptr<HorizontalSpacer>;
using HorizontalSpacerUPtr = std::unique_ptr<HorizontalSpacer>;

34
src/ui_elements/widgets/Label.cpp
View file

@ -2,34 +2,34 @@
#include "TextElement.h"
Label::Label()
: Widget(),
mLabel()
: Widget(),
mLabel()
{
}
std::shared_ptr<Label> Label::Create()
std::unique_ptr<Label> Label::Create()
{
return std::make_shared<Label>();
return std::make_unique<Label>();
}
void Label::SetLabel(const std::string& text)
{
mLabel = text;
mLabel = text;
}
void Label::OnPaintEvent(PaintEventPtr event)
void Label::OnPaintEvent(const PaintEvent* event)
{
mLayers.clear();
AddBackground(event);
mMyLayers.clear();
AddBackground(event);
if(!mLabel.empty())
{
auto middle = DiscretePoint(mLocation.GetX() + mWidth/2,
mLocation.GetY() + mHeight/2);
auto text = TextElement::Create(mLabel, middle);
auto textLayer = VisualLayer::Create();
textLayer->SetText(text);
mLayers.push_back(textLayer);
}
if(!mLabel.empty())
{
auto middle = DiscretePoint(mLocation.GetX() + mWidth/2,
mLocation.GetY() + mHeight/2);
auto textLayer = VisualLayer::Create();
textLayer->SetText(TextElement::Create(mLabel, middle));
mMyLayers.push_back(std::move(textLayer));
}
CopyMyLayers();
}

12
src/ui_elements/widgets/Label.h
View file

@ -6,17 +6,17 @@ class Label : public Widget
{
private:
std::string mLabel;
std::string mLabel;
public:
Label();
Label();
void SetLabel(const std::string& text);
static std::unique_ptr<Label> Create();
static std::shared_ptr<Label> Create();
void SetLabel(const std::string& text);
void OnPaintEvent(PaintEventPtr event);
void OnPaintEvent(const PaintEvent* event) override;
};
using LabelPtr = std::shared_ptr<Label>;
using LabelUPtr = std::unique_ptr<Label>;

97
src/ui_elements/widgets/TextBox.cpp Normal file
View file

@ -0,0 +1,97 @@
#include "TextBox.h"
#include "TextElement.h"
#include <string>
#include <sstream>
TextBox::TextBox()
: Widget(),
mContent(),
mCaps(false)
{
mBackgroundColor = Color::Create(200, 200, 200);
}
std::unique_ptr<TextBox> TextBox::Create()
{
return std::make_unique<TextBox>();
}
void TextBox::SetContent(const std::string& text)
{
mContent = text;
}
std::string TextBox::GetContent() const
{
return mContent;
}
void TextBox::AppendContent(const std::string& text)
{
mContent += text;
}
bool TextBox::OnMyKeyboardEvent(const KeyboardEvent* event)
{
if(!event) return false;
const auto keyString = event->GetKeyString();
if (keyString == "KEY_RETURN")
{
AppendContent("\n");
}
else if (keyString == "KEY_BACK")
{
mContent = mContent.substr(0, mContent.size()-1);
}
else if (keyString == "KEY_SPACE")
{
AppendContent(" ");
}
else if (keyString == "KEY_CAPS")
{
mCaps = !mCaps;
}
else
{
if (mCaps && !keyString.empty())
{
const char c = std::toupper(keyString[0]);
AppendContent(std::string(&c));
}
else
{
AppendContent(keyString);
}
}
return true;
}
void TextBox::OnPaintEvent(const PaintEvent* event)
{
mMyLayers.clear();
AddBackground(event);
double offset = 0;
if(!mContent.empty())
{
std::stringstream stream(mContent);
std::string segment;
std::vector<std::string> seglist;
while(std::getline(stream, segment, '\n'))
{
seglist.push_back(segment);
}
for(const auto& line : seglist)
{
auto loc = DiscretePoint(mLocation.GetX() + mWidth/10,
mLocation.GetY() + mHeight/10 + offset);
auto textLayer = VisualLayer::Create();
textLayer->SetText(TextElement::Create(line, loc));
mMyLayers.push_back(std::move(textLayer));
offset += 15;
}
}
CopyMyLayers();
}

29
src/ui_elements/widgets/TextBox.h Normal file
View file

@ -0,0 +1,29 @@
#pragma once
#include "Widget.h"
class TextBox : public Widget
{
private:
std::string mContent;
bool mCaps;
public:
TextBox();
static std::unique_ptr<TextBox> Create();
void SetContent(const std::string& text);
std::string GetContent() const;
void AppendContent(const std::string& text);
void OnPaintEvent(const PaintEvent* event) override;
bool OnMyKeyboardEvent(const KeyboardEvent* event) override;
};
using TextBoxUPtr = std::unique_ptr<TextBox>;

189
src/ui_elements/widgets/Widget.cpp
View file

@ -1,13 +1,16 @@
#include "RectangleElement.h"
#include "Widget.h"
#include <algorithm>
Widget::Widget()
: mLocation(DiscretePoint(0, 0)),
mWidth(100),
mHeight(100),
mLayers(),
mChildren(),
mBackgroundColor(Color::Create(200, 0, 0))
: mLocation(DiscretePoint(0, 0)),
mWidth(100),
mHeight(100),
mMyLayers(),
mLayers(),
mChildren(),
mBackgroundColor(Color::Create(200, 0, 0))
{
}
@ -17,118 +20,148 @@ Widget::~Widget()
}
void Widget::AddWidget(WidgetPtr widget)
std::unique_ptr<Widget> Widget::Create()
{
mChildren.push_back(widget);
return std::make_unique<Widget>();
}
void Widget::SetSize(unsigned width, unsigned height)
void Widget::AddWidget(WidgetUPtr widget)
{
mWidth = width;
mHeight = height;
mChildren.push_back(std::move(widget));
}
std::shared_ptr<Widget> Widget::Create()
unsigned Widget::GetWidth() const
{
return std::make_shared<Widget>();
return mWidth;
}
DiscretePoint Widget::GetLocation()
unsigned Widget::GetHeight() const
{
return mLocation;
return mHeight;
}
std::vector<VisualLayerPtr> Widget::GetLayers()
DiscretePoint Widget::GetLocation() const
{
return mLayers;
return mLocation;
}
void Widget::AddChildLayers(PaintEventPtr event)
std::vector<VisualLayer*> Widget::GetLayers() const
{
for(std::size_t idx=0; idx<mChildren.size(); idx++)
{
auto child = mChildren[idx];
child->SetSize(mWidth, mHeight);
child->SetLocation(mLocation);
child->OnPaintEvent(event);
auto layers = child->GetLayers();
mLayers.insert(mLayers.end(), layers.begin(), layers.end());
}
return mLayers;
}
void Widget::OnPaintEvent(PaintEventPtr event)
void Widget::CopyMyLayers()
{
mLayers.clear();
AddBackground(event);
AddChildLayers(event);
mLayers.clear();
mLayers.reserve(mMyLayers.size());
auto getRaw = [](const VisualLayerUPtr& uptr){return uptr.get();};
std::transform(mMyLayers.begin(), mMyLayers.end(), std::back_inserter(mLayers), getRaw);
}
bool Widget::Contains(const DiscretePoint& loc)
void Widget::AddChildLayers(const PaintEvent* event)
{
if(loc.GetX() < mLocation.GetX()) return false;
if(loc.GetX() > mLocation.GetX() + mWidth) return false;
if(loc.GetY() > mLocation.GetY() + mHeight) return false;
if(loc.GetY() < mLocation.GetY()) return false;
return true;
for(auto& child: mChildren)
{
child->SetSize(mWidth, mHeight);
child->SetLocation(mLocation);
child->OnPaintEvent(event);
const auto layers = child->GetLayers();
mLayers.insert(mLayers.end(), layers.begin(), layers.end());
}
}
bool Widget::OnMouseEvent(MouseEventPtr event)
void Widget::OnPaintEvent(const PaintEvent* event)
{
bool inChild = false;
for(const auto& child : mChildren)
{
if(child->OnMouseEvent(event))
{
inChild = true;
break;
}
}
if(!inChild)
{
if(Contains(event->GetClientLocation()))
{
OnMyMouseEvent(event);
return true;
}
else
{
return false;
}
}
return true;
mMyLayers.clear();
AddBackground(event);
CopyMyLayers();
AddChildLayers(event);
}
void Widget::OnMyMouseEvent(MouseEventPtr event)
bool Widget::Contains(const DiscretePoint& loc) const
{
if(loc.GetX() < mLocation.GetX()) return false;
if(loc.GetX() > mLocation.GetX() + mWidth) return false;
if(loc.GetY() > mLocation.GetY() + mHeight) return false;
if(loc.GetY() < mLocation.GetY()) return false;
return true;
}
bool Widget::OnKeyboardEvent(const KeyboardEvent* event)
{
bool inChild = false;
for(const auto& child : mChildren)
{
if(child->OnKeyboardEvent(event))
{
inChild = true;
break;
}
}
if(!inChild)
{
return OnMyKeyboardEvent(event);
}
return true;
}
bool Widget::OnMyKeyboardEvent(const KeyboardEvent* event)
{
return false;
}
bool Widget::OnMouseEvent(const MouseEvent* event)
{
bool inChild = false;
for(const auto& child : mChildren)
{
if(child->OnMouseEvent(event))
{
inChild = true;
break;
}
}
if(!inChild)
{
if(Contains(event->GetClientLocation()))
{
OnMyMouseEvent(event);
return true;
}
else
{
return false;
}
}
return true;
}
void Widget::OnMyMouseEvent(const MouseEvent* event)
{
}
void Widget::AddBackground(PaintEventPtr event)
void Widget::AddBackground(const PaintEvent* event)
{
auto shape = RectangleElement::Create(mLocation, mWidth, mHeight);
shape->SetFillColor(mBackgroundColor);
auto shapeLayer = VisualLayer::Create();
shapeLayer->SetShape(shape);
mLayers.push_back(shapeLayer);
auto shape = RectangleElement::Create(mLocation, mWidth, mHeight);
shape->SetFillColor(Color::Create(*mBackgroundColor));
auto shapeLayer = VisualLayer::Create();
shapeLayer->SetShape(std::move(shape));
mMyLayers.push_back(std::move(shapeLayer));
}
void Widget::SetBackgroundColor(ColorPtr color)
void Widget::SetBackgroundColor(ColorUPtr color)
{
mBackgroundColor = color;
mBackgroundColor = std::move(color);
}
void Widget::SetLocation(const DiscretePoint& loc)
{
mLocation = loc;
mLocation = loc;
}
unsigned Widget::GetWidth()
void Widget::SetSize(unsigned width, unsigned height)
{
return mWidth;
}
unsigned Widget::GetHeight()
{
return mHeight;
mWidth = width;
mHeight = height;
}

56
src/ui_elements/widgets/Widget.h
View file

@ -8,55 +8,63 @@
#include "PaintEvent.h"
#include "Color.h"
#include "MouseEvent.h"
#include "KeyboardEvent.h"
class Widget
{
protected:
DiscretePoint mLocation;
unsigned mWidth;
unsigned mHeight;
std::vector<VisualLayerPtr> mLayers;
std::vector<std::shared_ptr<Widget> > mChildren;
ColorPtr mBackgroundColor;
DiscretePoint mLocation;
unsigned mWidth;
unsigned mHeight;
std::vector<VisualLayerUPtr> mMyLayers;
std::vector<VisualLayer*> mLayers;
std::vector<std::unique_ptr<Widget> > mChildren;
ColorUPtr mBackgroundColor;
public:
Widget();
Widget();
virtual ~Widget();
virtual ~Widget();
void AddWidget(std::shared_ptr<Widget> widget);
static std::unique_ptr<Widget> Create();
void SetBackgroundColor(ColorPtr color);
void AddWidget(std::unique_ptr<Widget> widget);
void SetSize(unsigned mWidth, unsigned mHeight);
unsigned GetWidth() const;
DiscretePoint GetLocation();
unsigned GetHeight() const;
void SetLocation(const DiscretePoint& loc);
std::vector<VisualLayer*> GetLayers() const;
unsigned GetWidth();
DiscretePoint GetLocation() const;
unsigned GetHeight();
virtual void OnPaintEvent(const PaintEvent* event);
std::vector<VisualLayerPtr> GetLayers();
virtual bool OnMouseEvent(const MouseEvent* event);
static std::shared_ptr<Widget> Create();
virtual bool OnKeyboardEvent(const KeyboardEvent* event);
virtual void OnPaintEvent(PaintEventPtr event);
bool Contains(const DiscretePoint& loc) const;
virtual bool OnMouseEvent(MouseEventPtr event);
void SetBackgroundColor(ColorUPtr color);
bool Contains(const DiscretePoint& loc);
void SetSize(unsigned mWidth, unsigned mHeight);
void SetLocation(const DiscretePoint& loc);
protected:
virtual void OnMyMouseEvent(MouseEventPtr event);
virtual bool OnMyKeyboardEvent(const KeyboardEvent* event);
virtual void AddChildLayers(PaintEventPtr event);
virtual void OnMyMouseEvent(const MouseEvent* event);
virtual void AddBackground(PaintEventPtr event);
virtual void AddChildLayers(const PaintEvent* event);
virtual void AddBackground(const PaintEvent* event);
void CopyMyLayers();
};
using WidgetPtr = std::shared_ptr<Widget>;
using WidgetUPtr = std::unique_ptr<Widget>;

37
src/ui_elements/widgets/elements/GeometryElement.cpp
View file

@ -1,36 +1,39 @@
#include "GeometryElement.h"
GeometryElement::GeometryElement()
: mFillColor(Color::Create(255, 255, 255)),
mStrokeColor(Color::Create(0, 0, 0)),
mStrokeThickness(1),
mType(Type::Path)
: mFillColor(Color::Create(255, 255, 255)),
mStrokeColor(Color::Create(0, 0, 0)),
mStrokeThickness(1),
mType(Type::Path)
{
}
ColorPtr GeometryElement::GetFillColor()
Color* GeometryElement::GetFillColor() const
{
return mFillColor;
return mFillColor.get();
}
ColorPtr GeometryElement::GetStrokeColor()
Color* GeometryElement::GetStrokeColor() const
{
return mStrokeColor;
}
unsigned GeometryElement::GetStrokeThickness()
{
return mStrokeThickness;
return mStrokeColor.get();
}
void GeometryElement::SetFillColor(ColorPtr color)
unsigned GeometryElement::GetStrokeThickness() const
{
mFillColor = color;
return mStrokeThickness;
}
void GeometryElement::SetStrokeColor(ColorPtr color)
void GeometryElement::SetFillColor(ColorUPtr color)
{
mStrokeColor = color;
mFillColor = std::move(color);
}
void GeometryElement::SetStrokeColor(ColorUPtr color)
{
mStrokeColor = std::move(color);
}
void GeometryElement::SetStrokeThickness(unsigned thickness)
{
mStrokeThickness = thickness;
mStrokeThickness = thickness;
}

44
src/ui_elements/widgets/elements/GeometryElement.h
View file

@ -5,35 +5,33 @@
class GeometryElement
{
public:
enum class Type
{
Path,
Rectangle,
Circle,
Arc
};
enum class Type
{
Path,
Rectangle,
Circle,
Arc
};
private:
ColorPtr mFillColor;
ColorPtr mStrokeColor;
unsigned mStrokeThickness;
Type mType;
ColorUPtr mFillColor;
ColorUPtr mStrokeColor;
unsigned mStrokeThickness;
Type mType;
public:
GeometryElement();
virtual ~GeometryElement() = default;
GeometryElement();
virtual ~GeometryElement() = default;
ColorPtr GetFillColor();
ColorPtr GetStrokeColor();
unsigned GetStrokeThickness();
virtual Type GetType() = 0;
Color* GetFillColor() const;
Color* GetStrokeColor() const;
unsigned GetStrokeThickness() const;
virtual Type GetType() = 0;
void SetFillColor(ColorPtr color);
void SetStrokeColor(ColorPtr color);
void SetStrokeThickness(unsigned thickness);
void SetFillColor(ColorUPtr color);
void SetStrokeColor(ColorUPtr color);
void SetStrokeThickness(unsigned thickness);
};
using GeometryElementPtr = std::shared_ptr<GeometryElement>;
using GeometryElementUPtr = std::unique_ptr<GeometryElement>;

28
src/ui_elements/widgets/elements/RectangleElement.cpp
View file

@ -1,36 +1,36 @@
#include "RectangleElement.h"
RectangleElement::RectangleElement(const DiscretePoint& loc,
unsigned width, unsigned height)
: mLocation(loc),
mWidth(width),
mHeight(height)
unsigned width, unsigned height)
: mLocation(loc),
mWidth(width),
mHeight(height)
{
}
std::shared_ptr<RectangleElement> RectangleElement::Create(const DiscretePoint& loc,
unsigned width, unsigned height)
std::unique_ptr<RectangleElement> RectangleElement::Create(const DiscretePoint& loc,
unsigned width, unsigned height)
{
return std::make_shared<RectangleElement>(loc, width, height);
return std::make_unique<RectangleElement>(loc, width, height);
}
GeometryElement::Type RectangleElement::GetType()
{
return GeometryElement::Type::Rectangle;
return GeometryElement::Type::Rectangle;
}
DiscretePoint RectangleElement::GetLocation()
DiscretePoint RectangleElement::GetLocation() const
{
return mLocation;
return mLocation;
}
unsigned RectangleElement::GetWidth()
unsigned RectangleElement::GetWidth() const
{
return mWidth;
return mWidth;
}
unsigned RectangleElement::GetHeight()
unsigned RectangleElement::GetHeight() const
{
return mHeight;
return mHeight;
}

23
src/ui_elements/widgets/elements/RectangleElement.h
View file

@ -7,23 +7,22 @@
class RectangleElement : public GeometryElement
{
DiscretePoint mLocation;
unsigned mWidth;
unsigned mHeight;
DiscretePoint mLocation;
unsigned mWidth;
unsigned mHeight;
public:
RectangleElement(const DiscretePoint& loc,
unsigned width, unsigned height);
static std::shared_ptr<RectangleElement> Create(const DiscretePoint& loc,
unsigned width, unsigned height);
GeometryElement::Type GetType() override;
RectangleElement(const DiscretePoint& loc, unsigned width, unsigned height);
static std::unique_ptr<RectangleElement> Create(const DiscretePoint& loc,
unsigned width, unsigned height);
GeometryElement::Type GetType() override;
DiscretePoint GetLocation();
unsigned GetWidth();
unsigned GetHeight();
DiscretePoint GetLocation() const;
unsigned GetWidth() const;
unsigned GetHeight() const;
};
using RectangleElementPtr = std::shared_ptr<RectangleElement>;
using RectangleElementUPtr = std::unique_ptr<RectangleElement>;

36
src/ui_elements/widgets/elements/TextElement.cpp
View file

@ -1,9 +1,9 @@
#include "TextElement.h"
TextElement::TextElement(const std::string& content, const DiscretePoint& loc)
: mContent(content),
mLocation(loc),
mFontLabel("fixed")
: mContent(content),
mLocation(loc),
mFontLabel("fixed")
{
}
@ -13,27 +13,27 @@ TextElement::~TextElement()
}
std::shared_ptr<TextElement> TextElement::Create(const std::string& content, const DiscretePoint& loc)
std::unique_ptr<TextElement> TextElement::Create(const std::string& content, const DiscretePoint& loc)
{
return std::make_shared<TextElement>(content, loc);
return std::make_unique<TextElement>(content, loc);
}
DiscretePoint TextElement::GetLocation()
DiscretePoint TextElement::GetLocation() const
{
return mLocation;
return mLocation;
}
std::string TextElement::GetFontLabel() const
{
return mFontLabel;
}
std::string TextElement::GetContent() const
{
return mContent;
}
void TextElement::SetContent(const std::string& content)
{
mContent = content;
}
std::string TextElement::GetFontLabel()
{
return mFontLabel;
}
std::string TextElement::GetContent()
{
return mContent;
mContent = content;
}

22
src/ui_elements/widgets/elements/TextElement.h
View file

@ -7,25 +7,25 @@
class TextElement
{
std::string mContent;
DiscretePoint mLocation;
std::string mFontLabel;
std::string mContent;
DiscretePoint mLocation;
std::string mFontLabel;
public:
TextElement(const std::string& content, const DiscretePoint& loc);
TextElement(const std::string& content, const DiscretePoint& loc);
~TextElement();
~TextElement();
static std::shared_ptr<TextElement> Create(const std::string& content, const DiscretePoint& loc);
static std::unique_ptr<TextElement> Create(const std::string& content, const DiscretePoint& loc);
DiscretePoint GetLocation();
DiscretePoint GetLocation() const;
std::string GetContent();
std::string GetContent() const;
void SetContent(const std::string& content);
std::string GetFontLabel() const;
std::string GetFontLabel();
void SetContent(const std::string& content);
};
using TextElementPtr = std::shared_ptr<TextElement>;
using TextElementUPtr = std::unique_ptr<TextElement>;

37
src/ui_elements/widgets/elements/VisualLayer.cpp
View file

@ -1,38 +1,43 @@
#include "VisualLayer.h"
VisualLayer::VisualLayer()
: mShape(),
mText()
: mShape(),
mText()
{
}
std::shared_ptr<VisualLayer> VisualLayer::Create()
std::unique_ptr<VisualLayer> VisualLayer::Create()
{
return std::make_shared<VisualLayer>();
return std::make_unique<VisualLayer>();
}
void VisualLayer::SetShape(GeometryElementPtr shape)
bool VisualLayer::HasShape() const
{
mShape = shape;
return bool(mShape);
}
void VisualLayer::SetText(TextElementPtr text)
bool VisualLayer::HasText() const
{
mText = text;
return bool(mText);
}
bool VisualLayer::HasShape()
GeometryElement* VisualLayer::GetShape() const
{
return bool(mShape);
return mShape.get();
}
bool VisualLayer::HasText()
TextElement* VisualLayer::GetText() const
{
return bool(mText);
return mText.get();
}
GeometryElementPtr VisualLayer::GetShape()
void VisualLayer::SetShape(GeometryElementUPtr shape)
{
return mShape;
mShape = std::move(shape);
}
TextElementPtr VisualLayer::GetText()
void VisualLayer::SetText(TextElementUPtr text)
{
return mText;
mText = std::move(text);
}

23
src/ui_elements/widgets/elements/VisualLayer.h
View file

@ -6,21 +6,20 @@
class VisualLayer
{
GeometryElementPtr mShape;
TextElementPtr mText;
GeometryElementUPtr mShape;
TextElementUPtr mText;
public:
VisualLayer();
VisualLayer();
static std::shared_ptr<VisualLayer> Create();
void SetShape(GeometryElementPtr shape);
void SetText(TextElementPtr text);
bool HasShape();
bool HasText();
GeometryElementPtr GetShape();
TextElementPtr GetText();
static std::unique_ptr<VisualLayer> Create();
GeometryElement* GetShape() const;
TextElement* GetText() const;
bool HasShape() const;
bool HasText() const;
void SetShape(GeometryElementUPtr shape);
void SetText(TextElementUPtr text);
};
using VisualLayerPtr = std::shared_ptr<VisualLayer>;
using VisualLayerUPtr = std::unique_ptr<VisualLayer>;

4
src/windows/AbstractDesktopApp.h
View file

@ -6,8 +6,8 @@ class AbstractDesktopApp
{
public:
AbstractDesktopApp() = default;
virtual ~AbstractDesktopApp() = default;
AbstractDesktopApp() = default;
virtual ~AbstractDesktopApp() = default;
};
using AbstractDesktopAppPtr = std::shared_ptr<AbstractDesktopApp>;

1
src/windows/CMakeLists.txt
View file

@ -1,6 +1,7 @@
list(APPEND windows_LIB_INCLUDES
managers/WindowManager.cpp
managers/DesktopManager.cpp
managers/EventManager.cpp
ui_interfaces/x11/XcbInterface.cpp
ui_interfaces/x11/XcbLayerInterface.cpp
ui_interfaces/x11/XcbTextInterface.cpp

119
src/windows/managers/DesktopManager.cpp
View file

@ -3,14 +3,14 @@
#include <iostream>
DesktopManager::DesktopManager()
: mScreens(),
mWindowManager(),
mKeyboard(),
mMainApplication(),
mModified(false)
: mScreens(),
mWindowManager(WindowManager::Create()),
mKeyboard(Keyboard::Create()),
mMainApplication(),
mModified(false),
mEventManager(EventManager::Create())
{
mWindowManager = WindowManager::Create();
mKeyboard = Keyboard::Create();
}
DesktopManager::~DesktopManager()
@ -18,95 +18,100 @@ DesktopManager::~DesktopManager()
}
std::shared_ptr<DesktopManager> DesktopManager::Create()
std::unique_ptr<DesktopManager> DesktopManager::Create()
{
return std::make_shared<DesktopManager>();
return std::make_unique<DesktopManager>();
}
void DesktopManager::OnKeyboardEvent(KeyboardEventPtr keyboardEvent)
void DesktopManager::ClearEvents()
{
std::cout << "Key: " << keyboardEvent->GetKeyString() << std::endl;
mEventManager->ClearEvents();
}
void DesktopManager::OnPaintEvent(PaintEventPtr paintEvent)
void DesktopManager::OnKeyboardEvent(const KeyboardEvent* event)
{
GetWindowManager()->OnPaintEvent(paintEvent);
GetWindowManager()->OnKeyboardEvent(event);
}
void DesktopManager::OnMouseEvent(MouseEventPtr mouseEvent)
void DesktopManager::OnPaintEvent(const PaintEvent* event)
{
GetWindowManager()->OnMouseEvent(mouseEvent);
GetWindowManager()->OnPaintEvent(event);
}
bool DesktopManager::IsModified()
void DesktopManager::OnMouseEvent(const MouseEvent* event)
{
return mModified;
GetWindowManager()->OnMouseEvent(event);
}
void DesktopManager::OnUiEvent(UiEventPtr event)
bool DesktopManager::IsModified() const
{
mModified = false;
switch (event->GetType())
{
case (UiEvent::Type::Paint):
{
OnPaintEvent(std::dynamic_pointer_cast<PaintEvent>(event));
break;
}
case (UiEvent::Type::Keyboard):
{
OnKeyboardEvent(std::dynamic_pointer_cast<KeyboardEvent>(event));
//mModified = true;
break;
}
case (UiEvent::Type::Mouse):
{
auto mouseEvent = std::dynamic_pointer_cast<MouseEvent>(event);
return mModified;
}
OnMouseEvent(mouseEvent);
if(mouseEvent->GetAction() == MouseEvent::Action::Pressed)
{
std::cout << "mouse pressed" << std::endl;
mModified = true;
}
break;
}
default:
break;
}
void DesktopManager::OnUiEvent(UiEventUPtr eventUPtr)
{
mModified = false;
const auto event = mEventManager->AddEvent(std::move(eventUPtr));
switch (event->GetType())
{
case (UiEvent::Type::Paint):
{
OnPaintEvent(dynamic_cast<const PaintEvent*>(event));
break;
}
case (UiEvent::Type::Keyboard):
{
OnKeyboardEvent(dynamic_cast<const KeyboardEvent*>(event));
mModified = true;
break;
}
case (UiEvent::Type::Mouse):
{
auto mouseEvent = dynamic_cast<const MouseEvent*>(event);
OnMouseEvent(mouseEvent);
if(mouseEvent->GetAction() == MouseEvent::Action::Pressed)
{
std::cout << "mouse pressed" << std::endl;
mModified = true;
}
break;
}
default:
break;
}
}
void DesktopManager::SetIsModified(bool modified)
{
mModified = modified;
mModified = modified;
}
KeyboardPtr DesktopManager::GetKeyboard()
Keyboard* DesktopManager::GetKeyboard() const
{
return mKeyboard;
return mKeyboard.get();
}
void DesktopManager::SetKeyboard(KeyboardPtr keyboard)
void DesktopManager::SetKeyboard(KeyboardUPtr keyboard)
{
mKeyboard = keyboard;
mKeyboard = std::move(keyboard);
}
void DesktopManager::SetMainApp(AbstractDesktopAppPtr mainApp)
{
mMainApplication = mainApp;
mMainApplication = mainApp;
}
AbstractDesktopAppPtr DesktopManager::GetMainApp()
{
return mMainApplication;
return mMainApplication;
}
void DesktopManager::SetWindowManager(WindowManagerPtr windowManager)
void DesktopManager::SetWindowManager(WindowManagerUPtr windowManager)
{
mWindowManager = windowManager;
mWindowManager = std::move(windowManager);
}
WindowManagerPtr DesktopManager::GetWindowManager()
WindowManager* DesktopManager::GetWindowManager() const
{
return mWindowManager;
return mWindowManager.get();
}

46
src/windows/managers/DesktopManager.h
View file

@ -11,48 +11,50 @@
#include "WindowManager.h"
#include "UiEvent.h"
#include "AbstractDesktopApp.h"
#include "EventManager.h"
class DesktopManager
{
std::vector<ScreenPtr> mScreens;
WindowManagerPtr mWindowManager;
KeyboardPtr mKeyboard;
AbstractDesktopAppPtr mMainApplication;
bool mModified;
std::vector<ScreenPtr> mScreens;
WindowManagerUPtr mWindowManager;
KeyboardUPtr mKeyboard;
EventManagerUPtr mEventManager;
AbstractDesktopAppPtr mMainApplication;
bool mModified;
public:
DesktopManager();
DesktopManager();
~DesktopManager();
~DesktopManager();
static std::shared_ptr<DesktopManager> Create();
static std::unique_ptr<DesktopManager> Create();
void SetWindowManager(WindowManagerPtr windowManager);
void SetWindowManager(WindowManagerUPtr windowManager);
void SetMainApp(AbstractDesktopAppPtr mainApp);
void SetMainApp(AbstractDesktopAppPtr mainApp);
AbstractDesktopAppPtr GetMainApp();
AbstractDesktopAppPtr GetMainApp();
WindowManagerPtr GetWindowManager();
WindowManager* GetWindowManager() const;
KeyboardPtr GetKeyboard();
Keyboard* GetKeyboard() const;
bool IsModified();
bool IsModified() const;
void SetIsModified(bool modified);
void SetIsModified(bool modified);
void SetKeyboard(KeyboardPtr keyboard);
void SetKeyboard(KeyboardUPtr keyboard);
void OnUiEvent(UiEventPtr event);
void OnUiEvent(UiEventUPtr event);
void OnKeyboardEvent(KeyboardEventPtr keyboardEvent);
void OnKeyboardEvent(const KeyboardEvent* keyboardEvent);
void OnMouseEvent(MouseEventPtr mouseEvent);
void OnPaintEvent(PaintEventPtr paintEvent);
void OnMouseEvent(const MouseEvent* mouseEvent);
void OnPaintEvent(const PaintEvent* paintEvent);
void ClearEvents();
};
using DesktopManagerPtr = std::shared_ptr<DesktopManager>;
using DesktopManagerUPtr = std::unique_ptr<DesktopManager>;

24
src/windows/managers/EventManager.cpp Normal file
View file

@ -0,0 +1,24 @@
#include "EventManager.h"
EventManager::EventManager()
: mEvents()
{
}
std::unique_ptr<EventManager> EventManager::Create()
{
return std::make_unique<EventManager>();
}
UiEvent* EventManager::AddEvent(UiEventUPtr event)
{
mEvents.push_back(std::move(event));
return mEvents[mEvents.size()-1].get();
}
void EventManager::ClearEvents()
{
mEvents.clear();
}

20
src/windows/managers/EventManager.h Normal file
View file

@ -0,0 +1,20 @@
#pragma once
#include <vector>
#include "UiEvent.h"
class EventManager
{
std::vector<UiEventUPtr> mEvents;
public:
EventManager();
static std::unique_ptr<EventManager> Create();
UiEvent* AddEvent(UiEventUPtr event);
void ClearEvents();
};
using EventManagerUPtr = std::unique_ptr<EventManager>;

36
src/windows/managers/WindowManager.cpp
View file

@ -1,9 +1,9 @@
#include "WindowManager.h"
WindowManager::WindowManager()
: mWindows()
: mWindows()
{
AddWindow(mt::Window::Create());
AddWindow(mt::Window::Create());
}
WindowManager::~WindowManager()
@ -11,27 +11,39 @@ WindowManager::~WindowManager()
}
void WindowManager::OnPaintEvent(PaintEventPtr event)
std::unique_ptr<WindowManager> WindowManager::Create()
{
GetMainWindow()->OnPaint(event);
return std::make_unique<WindowManager>();
}
void WindowManager::OnMouseEvent(MouseEventPtr event)
void WindowManager::OnPaintEvent(const PaintEvent* event)
{
GetMainWindow()->OnMouseEvent(event);
GetMainWindow()->OnPaint(event);
}
void WindowManager::AddWindow(WindowPtr window)
void WindowManager::OnMouseEvent(const MouseEvent* event)
{
mWindows.push_back(window);
GetMainWindow()->OnMouseEvent(event);
}
std::shared_ptr<WindowManager> WindowManager::Create()
void WindowManager::OnKeyboardEvent(const KeyboardEvent* event)
{
return std::make_shared<WindowManager>();
GetMainWindow()->OnKeyboardEvent(event);
}
WindowPtr WindowManager::GetMainWindow()
void WindowManager::AddWindow(WindowUPtr window)
{
return mWindows[0];
mWindows.push_back(std::move(window));
}
mt::Window* WindowManager::GetMainWindow() const
{
if(mWindows.size()>0)
{
return mWindows[0].get();
}
else
{
return nullptr;
}
}

22
src/windows/managers/WindowManager.h
View file

@ -6,31 +6,33 @@
#include "Window.h"
#include "PaintEvent.h"
#include "MouseEvent.h"
#include "KeyboardEvent.h"
class WindowManager
{
private:
std::vector<WindowPtr> mWindows;
std::vector<WindowUPtr> mWindows;
public:
WindowManager();
WindowManager();
~WindowManager();
~WindowManager();
void AddWindow(WindowPtr window);
static std::unique_ptr<WindowManager> Create();
static std::shared_ptr<WindowManager> Create();
void AddWindow(WindowUPtr window);
WindowPtr GetMainWindow();
mt::Window* GetMainWindow() const;
void OnPaintEvent(PaintEventPtr event);
void OnPaintEvent(const PaintEvent* event);
void OnMouseEvent(MouseEventPtr event);
void OnMouseEvent(const MouseEvent* event);
void OnKeyboardEvent(const KeyboardEvent* event);
};
using WindowManagerPtr = std::shared_ptr<WindowManager>;
using WindowManagerUPtr = std::unique_ptr<WindowManager>;

465
src/windows/ui_interfaces/x11/XcbInterface.cpp
View file

@ -16,15 +16,15 @@
XcbInterface::XcbInterface()
: mUseOpenGl(true),
mConnection(nullptr),
mScreen(nullptr),
mWindows(),
mHandles(),
mDefaultWindow(-1),
mGraphicsContext(-1),
mX11Display(),
mGlxInterface()
: mUseOpenGl(true),
mConnection(nullptr),
mScreen(nullptr),
mWindows(),
mHandles(),
mDefaultWindow(-1),
mGraphicsContext(-1),
mX11Display(),
mGlxInterface()
{
}
@ -36,313 +36,314 @@ XcbInterface::~XcbInterface()
void XcbInterface::SetUseOpenGl(bool use)
{
mUseOpenGl = use;
mUseOpenGl = use;
}
void XcbInterface::Initialize()
{
Connect();
UpdateScreen();
CreateGraphicsContext();
Connect();
UpdateScreen();
CreateGraphicsContext();
if(mUseOpenGl)
{
InitializeOpenGl();
}
if(mUseOpenGl)
{
InitializeOpenGl();
}
}
void XcbInterface::Connect()
{
if(mUseOpenGl)
{
/* Open Xlib Display */
mX11Display = XOpenDisplay(0);
if(!mX11Display)
{
std::cerr << "Can't open X11 display" << std::endl;
return;
}
else
{
std::cout << "Got display" << std::endl;
}
if(mUseOpenGl)
{
/* Open Xlib Display */
mX11Display = XOpenDisplay(0);
if(!mX11Display)
{
std::cerr << "Can't open X11 display" << std::endl;
return;
}
else
{
std::cout << "Got display" << std::endl;
}
/* Get the XCB connection from the display */
mConnection = XGetXCBConnection(mX11Display);
if(!mConnection)
{
XCloseDisplay(mX11Display);
std::cerr << "Can't get xcb connection from display" << std::endl;
return;
}
std::cout << "Got connection" << std::endl;
/* Get the XCB connection from the display */
mConnection = XGetXCBConnection(mX11Display);
if(!mConnection)
{
XCloseDisplay(mX11Display);
std::cerr << "Can't get xcb connection from display" << std::endl;
return;
}
std::cout << "Got connection" << std::endl;
/* Acquire event queue ownership */
XSetEventQueueOwner(mX11Display, XCBOwnsEventQueue);
}
else
{
mConnection = xcb_connect(nullptr, nullptr);
}
/* Acquire event queue ownership */
XSetEventQueueOwner(mX11Display, XCBOwnsEventQueue);
}
else
{
mConnection = xcb_connect(nullptr, nullptr);
}
}
void XcbInterface::UpdateScreen()
{
if(!mConnection) return;
if(!mConnection) return;
auto screen_iter = xcb_setup_roots_iterator(xcb_get_setup(mConnection));
if(mUseOpenGl)
{
if(!mX11Display) return;
int default_screen = DefaultScreen(mX11Display);
for(int screen_num = default_screen;
screen_iter.rem && screen_num > 0;
--screen_num, xcb_screen_next(&screen_iter));
}
mScreen = screen_iter.data;
auto screen_iter = xcb_setup_roots_iterator(xcb_get_setup(mConnection));
if(mUseOpenGl)
{
if(!mX11Display) return;
int default_screen = DefaultScreen(mX11Display);
for(int screen_num = default_screen;
screen_iter.rem && screen_num > 0;
--screen_num, xcb_screen_next(&screen_iter));
}
mScreen = screen_iter.data;
}
void XcbInterface::InitializeOpenGl()
{
mGlxInterface = GlxInterface::Create();
int default_screen = DefaultScreen(mX11Display);
mGlxInterface->SetupContext(mX11Display, default_screen);
mGlxInterface = GlxInterface::Create();
int default_screen = DefaultScreen(mX11Display);
mGlxInterface->SetupContext(mX11Display, default_screen);
}
void XcbInterface::CreateOpenGlDrawable(WindowPtr window)
void XcbInterface::CreateOpenGlDrawable(mt::Window* window)
{
if(!mUseOpenGl)
{
return;
}
auto hwnd = mHandles[window];
bool result = mGlxInterface->SetupWindow(mX11Display, hwnd);
if(!result)
{
xcb_destroy_window(mConnection, hwnd);
}
if(!mUseOpenGl or !window)
{
return;
}
auto hwnd = mHandles[window];
bool result = mGlxInterface->SetupWindow(mX11Display, hwnd);
if(!result)
{
xcb_destroy_window(mConnection, hwnd);
}
}
void XcbInterface::CreateGraphicsContext()
{
if(!mConnection || !mScreen) return;
mGraphicsContext = xcb_generate_id(mConnection);
if(!mConnection || !mScreen) return;
mGraphicsContext = xcb_generate_id(mConnection);
xcb_drawable_t window = mScreen->root;
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
uint32_t values[2] = {XcbLayerInterface::GetColor(240, 240, 240), 0};
xcb_create_gc(mConnection, mGraphicsContext, window, mask, values);
xcb_drawable_t window = mScreen->root;
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
uint32_t values[2] = {XcbLayerInterface::GetColor(240, 240, 240), 0};
xcb_create_gc(mConnection, mGraphicsContext, window, mask, values);
}
void XcbInterface::MapWindow(WindowPtr window)
void XcbInterface::MapWindow(mt::Window* window)
{
if(!mConnection) return;
xcb_map_window(mConnection, mHandles[window]);
xcb_flush(mConnection);
if(!mConnection or !window) return;
xcb_map_window(mConnection, mHandles[window]);
xcb_flush(mConnection);
}
void XcbInterface::ShowWindow(WindowPtr window)
void XcbInterface::ShowWindow(mt::Window* window)
{
MapWindow(window);
MapWindow(window);
}
uint32_t XcbInterface::GetEventMask()
{
return XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_POINTER_MOTION;
return XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_BUTTON_PRESS |
XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_POINTER_MOTION;
}
void XcbInterface::AddWindow(WindowPtr window)
void XcbInterface::AddWindow(mt::Window* window)
{
if(!mConnection || !mScreen) return;
auto hwnd = xcb_generate_id(mConnection);
if(!mConnection || !mScreen || !window) return;
auto hwnd = xcb_generate_id(mConnection);
uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
uint32_t values[2] = {mScreen->white_pixel, GetEventMask()};
uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
uint32_t values[2] = {mScreen->white_pixel, GetEventMask()};
xcb_create_window (mConnection, /* connection */
XCB_COPY_FROM_PARENT, /* depth */
hwnd, /* window Id */
mScreen->root, /* parent window */
0, 0, /* x, y */
window->GetWidth(), window->GetHeight(), /* width, height */
10, /* border_width */
XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */
mScreen->root_visual, /* visual */
mask, values ); /* masks */
mWindows[hwnd] = window;
mHandles[window] = hwnd;
mDefaultWindow = hwnd;
xcb_create_window (mConnection, /* connection */
XCB_COPY_FROM_PARENT, /* depth */
hwnd, /* window Id */
mScreen->root, /* parent window */
0, 0, /* x, y */
window->GetWidth(), window->GetHeight(), /* width, height */
10, /* border_width */
XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */
mScreen->root_visual, /* visual */
mask, values ); /* masks */
mWindows[hwnd] = window;
mHandles[window] = hwnd;
mDefaultWindow = hwnd;
}
void XcbInterface::onPaint(DesktopManagerPtr desktopManager)
void XcbInterface::onPaint(DesktopManager* desktopManager)
{
auto ui_event = PaintEvent::Create();
desktopManager->OnUiEvent(ui_event);
PaintWindow(desktopManager->GetWindowManager()->GetMainWindow());
desktopManager->OnUiEvent(PaintEvent::Create());
PaintWindow(desktopManager->GetWindowManager()->GetMainWindow());
}
void XcbInterface::PaintWindow(WindowPtr window)
void XcbInterface::PaintWindow(mt::Window* window)
{
const auto hwnd = mHandles[window];
for(const auto& layer : window->GetLayers())
{
XcbLayerInterface::AddLayer(mConnection, mScreen,
hwnd, mGraphicsContext, layer);
}
if(!window) return;
const auto hwnd = mHandles[window];
for(const auto& layer : window->GetLayers())
{
XcbLayerInterface::AddLayer(mConnection, mScreen,
hwnd, mGraphicsContext, layer);
}
}
void XcbInterface::OnKeyPress(xcb_key_press_event_t* event, DesktopManagerPtr desktopManager)
void XcbInterface::OnKeyPress(xcb_key_press_event_t* event, DesktopManager* desktopManager)
{
auto ui_event = KeyboardEvent::Create();
ui_event->SetAction(KeyboardEvent::Action::Pressed);
std::string keyVal = desktopManager->GetKeyboard()->GetKeyString(event->detail);
ui_event->SetKeyString(keyVal);
desktopManager->OnUiEvent(ui_event);
auto ui_event = KeyboardEvent::Create();
ui_event->SetAction(KeyboardEvent::Action::Pressed);
std::string keyVal = desktopManager->GetKeyboard()->GetKeyString(event->detail);
ui_event->SetKeyString(keyVal);
desktopManager->OnUiEvent(std::move(ui_event));
}
void XcbInterface::OnKeyRelease(xcb_key_release_event_t* event, DesktopManagerPtr desktopManager)
void XcbInterface::OnKeyRelease(xcb_key_release_event_t* event, DesktopManager* desktopManager)
{
auto ui_event = KeyboardEvent::Create();
ui_event->SetAction(KeyboardEvent::Action::Released);
std::string keyVal = desktopManager->GetKeyboard()->GetKeyString(event->detail);
ui_event->SetKeyString(keyVal);
desktopManager->OnUiEvent(ui_event);
auto ui_event = KeyboardEvent::Create();
ui_event->SetAction(KeyboardEvent::Action::Released);
std::string keyVal = desktopManager->GetKeyboard()->GetKeyString(event->detail);
ui_event->SetKeyString(keyVal);
desktopManager->OnUiEvent(std::move(ui_event));
}
void XcbInterface::OnButtonPress(xcb_button_press_event_t* event, DesktopManagerPtr desktopManager)
void XcbInterface::OnButtonPress(xcb_button_press_event_t* event, DesktopManager* desktopManager)
{
auto ui_event = MouseEvent::Create();
auto ui_event = MouseEvent::Create();
auto x = static_cast<unsigned>(event->event_x);
auto y = static_cast<unsigned>(event->event_y);
ui_event->SetClientLocation(DiscretePoint(x, y));
ui_event->SetClientLocation(DiscretePoint(x, y));
auto screen_x = static_cast<unsigned>(event->root_x);
auto screen_y = static_cast<unsigned>(event->root_y);
ui_event->SetScreenLocation(DiscretePoint(x, y));
ui_event->SetAction(MouseEvent::Action::Pressed);
desktopManager->OnUiEvent(ui_event);
ui_event->SetAction(MouseEvent::Action::Pressed);
desktopManager->OnUiEvent(std::move(ui_event));
}
void XcbInterface::LoopOpenGl(std::shared_ptr<DesktopManager> desktopManager)
void XcbInterface::LoopOpenGl(DesktopManager* desktopManager)
{
int running = 1;
while(running)
{
/* Wait for event */
xcb_generic_event_t *event = xcb_wait_for_event(mConnection);
if(!event)
{
std::cout << "i/o error in xcb_wait_for_event" << std::endl;
return;
}
int running = 1;
while(running)
{
/* Wait for event */
xcb_generic_event_t *event = xcb_wait_for_event(mConnection);
if(!event)
{
std::cout << "i/o error in xcb_wait_for_event" << std::endl;
return;
}
switch(event->response_type & ~0x80)
{
case XCB_KEY_PRESS:
/* Quit on key press */
std::cout << "got key" << std::endl;
running = 0;
break;
case XCB_KEY_RELEASE:
/* Quit on key press */
std::cout << "got key" << std::endl;
running = 0;
break;
case XCB_EXPOSE:
std::cout << "got expose" << std::endl;
/* Handle expose event, draw and swap buffers */
mGlxInterface->Draw();
mGlxInterface->SwapBuffers(mX11Display);
std::cout << "end expose" << std::endl;
break;
default:
std::cout << "got something else" << std::endl;
break;
}
switch(event->response_type & ~0x80)
{
case XCB_KEY_PRESS:
/* Quit on key press */
std::cout << "got key" << std::endl;
running = 0;
break;
case XCB_KEY_RELEASE:
/* Quit on key press */
std::cout << "got key" << std::endl;
running = 0;
break;
case XCB_EXPOSE:
std::cout << "got expose" << std::endl;
/* Handle expose event, draw and swap buffers */
mGlxInterface->Draw();
mGlxInterface->SwapBuffers(mX11Display);
std::cout << "end expose" << std::endl;
break;
default:
std::cout << "got something else" << std::endl;
break;
}
free(event);
}
mGlxInterface->DestroyWindow(mX11Display);
//xcb_destroy_window(mConnection, window);
mGlxInterface->DestroyContext(mX11Display);
return;
free(event);
}
mGlxInterface->DestroyWindow(mX11Display);
//xcb_destroy_window(mConnection, window);
mGlxInterface->DestroyContext(mX11Display);
return;
}
void XcbInterface::ClearWindow(WindowPtr window)
void XcbInterface::ClearWindow(mt::Window* window)
{
xcb_clear_area(mConnection, 1, mHandles[window], 0, 0,
window->GetWidth(), window->GetHeight());
xcb_flush(mConnection);
if(!window) return;
xcb_clear_area(mConnection, 1, mHandles[window], 0, 0,
window->GetWidth(), window->GetHeight());
xcb_flush(mConnection);
}
void XcbInterface::Loop(DesktopManagerPtr desktopManager)
void XcbInterface::Loop(DesktopManager* desktopManager)
{
if(!mConnection) return;
if(!mConnection) return;
if(mUseOpenGl)
{
LoopOpenGl(desktopManager);
return;
}
if(mUseOpenGl)
{
LoopOpenGl(desktopManager);
return;
}
xcb_generic_event_t *event;
while ((event = xcb_wait_for_event(mConnection)))
{
switch (event->response_type & ~0x80)
{
case XCB_EXPOSE:{
auto expose_event = reinterpret_cast<xcb_expose_event_t*>(event);
xcb_generic_event_t *event;
while ((event = xcb_wait_for_event(mConnection)))
{
switch (event->response_type & ~0x80)
{
case XCB_EXPOSE:{
auto expose_event = reinterpret_cast<xcb_expose_event_t*>(event);
// Update the window
auto window = mWindows[expose_event->window];
window->SetSize(expose_event->width, expose_event->height);
// Update the window
auto window = mWindows[expose_event->window];
window->SetSize(expose_event->width, expose_event->height);
onPaint(desktopManager);
/* flush the request */
xcb_flush(mConnection);
break;
}
case XCB_KEY_PRESS: {
auto kr = reinterpret_cast<xcb_key_press_event_t*>(event);
OnKeyPress(kr, desktopManager);
break;
}
onPaint(desktopManager);
/* flush the request */
xcb_flush(mConnection);
break;
}
case XCB_KEY_PRESS: {
auto kr = reinterpret_cast<xcb_key_press_event_t*>(event);
OnKeyPress(kr, desktopManager);
break;
}
case XCB_KEY_RELEASE: {
auto kr = reinterpret_cast<xcb_key_release_event_t*>(event);
OnKeyRelease(kr, desktopManager);
break;
}
case XCB_BUTTON_PRESS: {
auto press = reinterpret_cast<xcb_button_press_event_t*>(event);
OnButtonPress(press, desktopManager);
break;
}
default:
/* Unknown event type, ignore it */
break;
}
if(desktopManager->IsModified())
{
desktopManager->SetIsModified(false);
ClearWindow(desktopManager->GetWindowManager()->GetMainWindow());
}
case XCB_KEY_RELEASE: {
auto kr = reinterpret_cast<xcb_key_release_event_t*>(event);
OnKeyRelease(kr, desktopManager);
break;
}
case XCB_BUTTON_PRESS: {
auto press = reinterpret_cast<xcb_button_press_event_t*>(event);
OnButtonPress(press, desktopManager);
break;
}
default:
/* Unknown event type, ignore it */
break;
}
if(desktopManager->IsModified())
{
desktopManager->SetIsModified(false);
ClearWindow(desktopManager->GetWindowManager()->GetMainWindow());
}
free (event);
}
free (event);
}
}
void XcbInterface::ShutDown()
{
if(!mConnection) return;
std::cout << "starting shutdown" << std::endl;
xcb_disconnect(mConnection);
if(mUseOpenGl && mX11Display)
{
//XCloseDisplay(mX11Display);
}
std::cout << "ending shutdown" << std::endl;
if(!mConnection) return;
std::cout << "starting shutdown" << std::endl;
xcb_disconnect(mConnection);
if(mUseOpenGl && mX11Display)
{
//XCloseDisplay(mX11Display);
}
std::cout << "ending shutdown" << std::endl;
}

62
src/windows/ui_interfaces/x11/XcbInterface.h
View file

@ -23,62 +23,62 @@ class XcbInterface
private:
bool mUseOpenGl;
std::map<unsigned, WindowPtr> mWindows;
std::map<WindowPtr, unsigned> mHandles;
unsigned mDefaultWindow;
xcb_connection_t* mConnection;
xcb_screen_t* mScreen;
unsigned mGraphicsContext;
_XDisplay* mX11Display;
GlxInterfacePtr mGlxInterface;
bool mUseOpenGl;
std::map<unsigned, mt::Window*> mWindows;
std::map<mt::Window*, unsigned> mHandles;
unsigned mDefaultWindow;
xcb_connection_t* mConnection;
xcb_screen_t* mScreen;
unsigned mGraphicsContext;
_XDisplay* mX11Display;
GlxInterfacePtr mGlxInterface;
public:
XcbInterface();
XcbInterface();
~XcbInterface();
~XcbInterface();
void SetUseOpenGl(bool use);
void onPaint(std::shared_ptr<DesktopManager> desktopManager);
void SetUseOpenGl(bool use);
void onPaint(DesktopManager* desktopManager);
void Initialize();
void Initialize();
void InitializeOpenGl();
void InitializeOpenGl();
void CreateOpenGlDrawable(WindowPtr window);
void CreateOpenGlDrawable(mt::Window* window);
void Loop(std::shared_ptr<DesktopManager> desktopManager);
void Loop(DesktopManager* desktopManager);
void LoopOpenGl(std::shared_ptr<DesktopManager> desktopManager);
void LoopOpenGl(DesktopManager* desktopManager);
void ShutDown();
void ShutDown();
void AddWindow(WindowPtr window);
void AddWindow(mt::Window* window);
void ShowWindow(WindowPtr window);
void ShowWindow(mt::Window* window);
void PaintWindow(WindowPtr window);
void PaintWindow(mt::Window* window);
void ClearWindow(WindowPtr window);
void ClearWindow(mt::Window* window);
private:
void Connect();
void Connect();
void UpdateScreen();
void UpdateScreen();
uint32_t GetEventMask();
uint32_t GetEventMask();
void OnKeyPress(xcb_key_press_event_t* event, DesktopManagerPtr);
void OnKeyPress(xcb_key_press_event_t* event, DesktopManager*);
void OnKeyRelease(xcb_key_press_event_t* event, DesktopManagerPtr);
void OnKeyRelease(xcb_key_press_event_t* event, DesktopManager*);
void OnButtonPress(xcb_button_press_event_t* event, DesktopManagerPtr);
void OnButtonPress(xcb_button_press_event_t* event, DesktopManager*);
void MapWindow(WindowPtr window);
void MapWindow(mt::Window* window);
void CreateGraphicsContext();
void CreateGraphicsContext();
};

25
src/windows/ui_interfaces/x11/XcbKeyboard.cpp
View file

@ -1,24 +1,25 @@
#include "XcbKeyboard.h"
XcbKeyboard::XcbKeyboard()
: Keyboard()
: Keyboard()
{
mKeyMap = {{24, "q"}, {25, "w"},
{26, "e"}, {27, "r"},
{28, "t"}, {29, "y"}, {30, "u"}, {31, "i"}, {32, "o"},
{33, "p"}, {38, "a"}, {39, "s"}, {40, "d"}, {41, "f"},
{42, "g"}, {43, "h"}, {44, "j"}, {45, "k"}, {46, "l"},
{52, "z"}, {53, "x"}, {54, "c"}, {55, "v"}, {56, "b"},
{57, "n"}, {58, "m"}};
mKeyMap = {{10, "1"}, {11, "2"}, {12, "3"}, {13, "4"}, {14, "5"}, {15, "6"},
{16, "7"}, {17, "8"}, {18, "9"}, {19, "0"}, {20, "-"}, {21, "+"}, {22, "KEY_BACK"},
{24, "q"}, {25, "w"}, {26, "e"}, {27, "r"}, {28, "t"}, {29, "y"},
{30, "u"}, {31, "i"}, {32, "o"}, {33, "p"}, {34, "["}, {35, "]"}, {36, "KEY_RETURN"},
{38, "a"}, {39, "s"}, {40, "d"}, {41, "f"}, {42, "g"}, {43, "h"},
{44, "j"}, {45, "k"}, {46, "l"}, {47, ":"}, {48, "'"}, {49, "#"},
{52, "z"}, {53, "x"}, {54, "c"}, {55, "v"}, {56, "b"},
{57, "n"}, {58, "m"}, {59, ","}, {60, "."}, {61, "/"},
{65, "KEY_SPACE"}, {66, "KEY_CAPS"}};
}
std::shared_ptr<XcbKeyboard> XcbKeyboard::Create()
std::unique_ptr<XcbKeyboard> XcbKeyboard::Create()
{
return std::make_shared<XcbKeyboard>();
return std::make_unique<XcbKeyboard>();
}
std::string XcbKeyboard::GetKeyString(KeyCode keyCode)
{
return mKeyMap[keyCode];
return mKeyMap[keyCode];
}

8
src/windows/ui_interfaces/x11/XcbKeyboard.h
View file

@ -4,11 +4,11 @@
class XcbKeyboard : public Keyboard
{
public:
XcbKeyboard();
XcbKeyboard();
static std::shared_ptr<XcbKeyboard> Create();
static std::unique_ptr<XcbKeyboard> Create();
std::string GetKeyString(KeyCode keyCode) override;
std::string GetKeyString(KeyCode keyCode) override;
};
using XcbKeyboardPtr = std::shared_ptr<XcbKeyboard>;
using XcbKeyboardUPtr = std::unique_ptr<XcbKeyboard>;

58
src/windows/ui_interfaces/x11/XcbLayerInterface.cpp
View file

@ -3,48 +3,48 @@
#include "RectangleElement.h"
#include <memory>
uint32_t XcbLayerInterface::GetColor(ColorPtr color)
uint32_t XcbLayerInterface::GetColor(const Color* color)
{
return XcbLayerInterface::GetColor(color->GetR(),
color->GetG(), color->GetB());
return XcbLayerInterface::GetColor(color->GetR(),
color->GetG(), color->GetB());
}
uint32_t XcbLayerInterface::GetColor(int r, int g, int b)
{
return b + (g<<8) + (r<<16);
return b + (g<<8) + (r<<16);
}
void XcbLayerInterface::ModifyGcColor(xcb_connection_t* connection, xcb_gcontext_t gc,
ColorPtr color)
const Color* color)
{
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
uint32_t values[2] = {XcbLayerInterface::GetColor(color), 0};
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
uint32_t values[2] = {XcbLayerInterface::GetColor(color), 0};
xcb_change_gc(connection, gc, mask, values);
xcb_change_gc(connection, gc, mask, values);
}
void XcbLayerInterface::AddLayer(xcb_connection_t* connection,
xcb_screen_t* screen, xcb_window_t window, xcb_gcontext_t gc,
VisualLayerPtr layer)
xcb_screen_t* screen, xcb_window_t window, xcb_gcontext_t gc,
VisualLayer* layer)
{
if(layer->HasText())
{
XcbTextInterface::AddTextElement(connection, screen, window, layer->GetText());
}
else if(layer->HasShape())
{
auto shape = layer->GetShape();
if(shape->GetType() == GeometryElement::Type::Rectangle)
{
auto rectangle = std::dynamic_pointer_cast<RectangleElement>(shape);
Pixel loc = rectangle->GetLocation();
auto width = static_cast<uint16_t>(rectangle->GetWidth());
auto height = static_cast<uint16_t>(rectangle->GetHeight());
xcb_rectangle_t rectangles[] = { { static_cast<int16_t>(loc.GetX()),
static_cast<int16_t>(loc.GetY()), width, height} };
XcbLayerInterface::ModifyGcColor(connection, gc, rectangle->GetFillColor());
xcb_poly_fill_rectangle(connection, window, gc, 1, rectangles);
}
}
if(layer->HasText())
{
XcbTextInterface::AddTextElement(connection, screen, window, layer->GetText());
}
else if(layer->HasShape())
{
auto shape = layer->GetShape();
if(shape->GetType() == GeometryElement::Type::Rectangle)
{
auto rectangle = dynamic_cast<RectangleElement*>(shape);
Pixel loc = rectangle->GetLocation();
auto width = static_cast<uint16_t>(rectangle->GetWidth());
auto height = static_cast<uint16_t>(rectangle->GetHeight());
xcb_rectangle_t rectangles[] = { { static_cast<int16_t>(loc.GetX()),
static_cast<int16_t>(loc.GetY()), width, height} };
XcbLayerInterface::ModifyGcColor(connection, gc, rectangle->GetFillColor());
xcb_poly_fill_rectangle(connection, window, gc, 1, rectangles);
}
}
}

14
src/windows/ui_interfaces/x11/XcbLayerInterface.h
View file

@ -8,15 +8,15 @@ class XcbLayerInterface
{
public:
static uint32_t GetColor(ColorPtr);
static uint32_t GetColor(const Color* color);
static uint32_t GetColor(int r, int g, int b);
static uint32_t GetColor(int r, int g, int b);
static void ModifyGcColor(xcb_connection_t* connection, xcb_gcontext_t gc,
ColorPtr color);
static void ModifyGcColor(xcb_connection_t* connection, xcb_gcontext_t gc,
const Color* color);
static void AddLayer(xcb_connection_t* connection,
xcb_screen_t* screen, xcb_window_t window, xcb_gcontext_t gc,
VisualLayerPtr layer);
static void AddLayer(xcb_connection_t* connection,
xcb_screen_t* screen, xcb_window_t window, xcb_gcontext_t gc,
VisualLayer* layer);
};

48
src/windows/ui_interfaces/x11/XcbTextInterface.cpp
View file

@ -2,38 +2,38 @@
#include <string.h>
xcb_gcontext_t XcbTextInterface::GetFontGC(xcb_connection_t *connection,
xcb_screen_t *screen, xcb_window_t window, const char*font_name)
xcb_screen_t *screen, xcb_window_t window, const char*font_name)
{
/* get font */
xcb_font_t font = xcb_generate_id(connection);
xcb_open_font(connection, font, strlen(font_name), font_name);
/* get font */
xcb_font_t font = xcb_generate_id(connection);
xcb_open_font(connection, font, strlen(font_name), font_name);
/* create graphics context */
xcb_gcontext_t gc = xcb_generate_id(connection);
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
uint32_t value_list[3] = {screen->black_pixel, screen->white_pixel, font };
/* create graphics context */
xcb_gcontext_t gc = xcb_generate_id(connection);
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
uint32_t value_list[3] = {screen->black_pixel, screen->white_pixel, font };
xcb_create_gc(connection, gc, window, mask, value_list);
xcb_create_gc(connection, gc, window, mask, value_list);
/* close font */
xcb_close_font(connection, font);
return gc;
/* close font */
xcb_close_font(connection, font);
return gc;
}
void XcbTextInterface::AddTextElement(xcb_connection_t* connection,
xcb_screen_t* screen, xcb_window_t window,
TextElementPtr textElement)
xcb_screen_t* screen, xcb_window_t window,
const TextElement* textElement)
{
/* get graphics context */
xcb_gcontext_t gc = XcbTextInterface::GetFontGC(connection, screen, window,
textElement->GetFontLabel().c_str());
/* get graphics context */
xcb_gcontext_t gc = XcbTextInterface::GetFontGC(connection, screen, window,
textElement->GetFontLabel().c_str());
/* draw the text */
std::string content = textElement->GetContent();
Pixel loc = textElement->GetLocation();
xcb_image_text_8(connection, content.length(), window, gc,
loc.GetX(), loc.GetY(), content.c_str());
/* draw the text */
std::string content = textElement->GetContent();
Pixel loc = textElement->GetLocation();
xcb_image_text_8(connection, content.length(), window, gc,
loc.GetX(), loc.GetY(), content.c_str());
/* free the gc */
xcb_free_gc(connection, gc);
/* free the gc */
xcb_free_gc(connection, gc);
}

10
src/windows/ui_interfaces/x11/XcbTextInterface.h
View file

@ -5,12 +5,12 @@
class XcbTextInterface
{
public:
static xcb_gcontext_t GetFontGC(xcb_connection_t* connection,
xcb_screen_t*screen, xcb_window_t window, const char*font_name);
static xcb_gcontext_t GetFontGC(xcb_connection_t* connection,
xcb_screen_t*screen, xcb_window_t window, const char*font_name);
static void AddTextElement(xcb_connection_t* connection,
xcb_screen_t* screen, xcb_window_t window,
TextElementPtr textElement);
static void AddTextElement(xcb_connection_t* connection,
xcb_screen_t* screen, xcb_window_t window,
const TextElement* textElement);
};