Buttons

GUITest/GUIElements.hpp

@@ -1,33 +1,141 @@
 #include "SynGame.hpp"
 
+sf::Font font;
+
+#pragma region Text
+    class SynText
+    {
+        private:
+            int x;
+            int y;
+            int offsetX;
+            int offsetY;
+            bool isCentered;
+            sf::Text textDisplay;
+        public:
+            SynText(std::string = "", int = 0, int = 0, int = 0, int = 0, bool = false);
+            void SetText(std::string);
+            void SetOffset(int, int);
+            void SetPosition(int, int);
+            void SetCentered(bool);
+            sf::Text GetText();
+            ~SynText();
+    };
+
+    SynText::SynText(std::string text, int x, int y, int offsetX, int offsetY, bool isCentered)
+    {    
+        this -> isCentered = isCentered;
+        textDisplay.setFont(font);
+        SetText(text);
+        SetOffset(offsetX, offsetX);
+        SetPosition(x, y);
+        textDisplay.setColor(sf::Color::Red);
+    }
+
+    void SynText::SetText(std::string text)
+    {
+        textDisplay.setString(text);
+        SetPosition(x, y);
+    }
+
+    void SynText::SetPosition(int x, int y)
+    {
+        this -> x = x;
+        this -> y = y;
+        x += offsetX;
+        y += offsetY;
+
+        if(isCentered)
+            textDisplay.setOrigin((int)textDisplay.getLocalBounds().width / 2, (int)textDisplay.getLocalBounds().height / 2);
+        
+        textDisplay.setPosition(x, y);
+    }
+
+    void SynText::SetOffset(int offsetX, int offsetY)
+    {
+        this -> offsetX = offsetX;
+        this -> offsetY = offsetY;
+        SetPosition(x, y);
+    }
+    void SynText::SetCentered(bool isCentered)
+    {
+        this -> isCentered = isCentered;
+    }
+
+    sf::Text SynText::GetText()
+    {
+        return textDisplay;
+    }
+
+    SynText::~SynText()
+    {
+    }
+#pragma endregion
+
+#pragma region Button
     class SynButton
     {
         private:
-        sf::Text textDisplay;
-        std::string text;
-        static sf::Font font;
+            SynText synText;
+            void (*action)(int);
+            int *value;
             int x;
             int y;
             int width;
             int height;
-        void (*action)(int);
-        int *value;
+            sf::Vertex vertices[4];
+            void CalculateVertices();
         public:
-        SynButton(std::string, int, int, int, int);
+            SynButton(std::string = "", int = 0, int = 0, int = 0, int = 0);
+            void SetText(std::string);
+            void SetPosition(int, int);
+            void SetArea(int, int);
             void Bind(void (*)(int), int *);
             bool IsMouseOver(int, int);
             void Click();
+            sf::Text GetText();
+            sf::Vertex *GetVertices();
             ~SynButton();
     };
 
+    void SynButton::CalculateVertices()
+    {
+        float newWidth = width / 2;
+        float newHeight = height / 2;
+        vertices[0].position = sf::Vector2f(x, y);
+        vertices[1].position = sf::Vector2f(x + newWidth, y);
+        vertices[2].position = sf::Vector2f(x + newWidth, y + newHeight);
+        vertices[3].position = sf::Vector2f(x, y + newHeight);
+    }
+
     SynButton::SynButton(std::string text, int x, int y, int width, int height)
     {
-    textDisplay.setFont(font);
-    textDisplay.setString(text);
+        synText.SetCentered(true);
+        synText.SetOffset(0, -5);
+        SetArea(width, height);
+        SetPosition(x, y);
+        CalculateVertices();
+    }
+
+    void SynButton::SetText(std::string text)
+    {
+        synText.SetText(text);
+    }
+
+    void SynButton::SetPosition(int x, int y)
+    {
         this -> x = x;
         this -> y = y;
+        synText.SetPosition(x + width / 4, y + height / 4);
+        CalculateVertices();
+    }
+
+    void SynButton::SetArea(int width, int height)
+    {
         this -> width = width;
         this -> height = height;
+        synText.SetPosition(x + width / 4, y + height / 4);
+        CalculateVertices();
     }
 
     void SynButton::Bind(void (*action)(int), int *value)
@@ -42,9 +150,9 @@ bool SynButton::IsMouseOver(int mouseX, int mouseY)
         int halfWidth = width / 2;
         int halfHeight = height / 2;
         isOver = mouseX <= x + halfWidth && 
-             mouseX >= x - halfWidth && 
+                mouseX >= x && 
                 mouseY <= y + halfHeight && 
-             mouseY >= y - halfHeight;
+                mouseY >= y;
         return isOver;
     }
 
@@ -52,8 +160,19 @@ void SynButton::Click()
     {
         if(value)
             action(*value);
+        else
+            action(y);
+    }
+    sf::Text SynButton::GetText()
+    {
+        return synText.GetText();
+    }
+    sf::Vertex *SynButton::GetVertices()
+    {
+        return vertices;
     }
 
     SynButton::~SynButton()
     {
     }
+#pragma endregion

GUITest/GUIWindow.hpp

@@ -1,27 +1,106 @@
 #include "SynGame.hpp"
+#include <iostream>
 
 class GUIWindow : public Window
 {
     private:
+        SynButton *buttons;
+        SynText output;
+        void BinaryButton();
+        void QuaternaryButton();
+        void OctalButton();
+        void HexadecimalButton();
     public:
         GUIWindow(unsigned int = 960, unsigned int = 540, std::string = "Window", sf::Uint32 = sf::Style::Titlebar | sf::Style::Close);
         void Update();
+        void ButtonCheck(sf::Vector2i);
         ~GUIWindow();
 };
 
+void GUIWindow::BinaryButton()
+{
+    output.SetText("Output: Binary");
+}
+
+void GUIWindow::QuaternaryButton()
+{
+    output.SetText("Output: Quaternary");
+}
+
+void GUIWindow::OctalButton()
+{
+    output.SetText("Output: Octal");
+}
+
+void GUIWindow::HexadecimalButton()
+{
+    output.SetText("Output: Hexadecimal");
+}
+
 GUIWindow::GUIWindow(unsigned int width, unsigned int height, std::string title, sf::Uint32 style) : Window(width, height, title, style)
 {
+    output.SetText("Output: ");
+    output.SetCentered(true);
+    output.SetPosition(window.getSize().x / 2, window.getSize().y / 2);
+    output.SetOffset(0, 0);
+    buttons = new SynButton[4];
 
+    (buttons + 0) -> SetText("Binary"); 
+    (buttons + 1) -> SetText("Quaternary");
+    (buttons + 2) -> SetText("Octal");
+    (buttons + 3) -> SetText("Hexadecimal");
+    
+    (buttons + 0) -> SetArea(400, 100); (buttons + 0) -> SetPosition(650, 100);
+    (buttons + 1) -> SetArea(400, 100); (buttons + 1) -> SetPosition(650, 200);
+    (buttons + 2) -> SetArea(400, 100); (buttons + 2) -> SetPosition(650, 300);
+    (buttons + 3) -> SetArea(400, 100); (buttons + 3) -> SetPosition(650, 400);
+
+    (buttons + 0) -> Bind((void (*)(int))&BinaryButton, NULL);
+    (buttons + 1) -> Bind((void (*)(int))&QuaternaryButton, NULL);
+    (buttons + 2) -> Bind((void (*)(int))&OctalButton, NULL);
+    (buttons + 3) -> Bind((void (*)(int))&HexadecimalButton, NULL);
 }
 
 void GUIWindow::Update()
 {
+    
+    int buttonCounter;
+
+    Window::Update();
+
     if(!isFocused) 
         return;
 
-    Window::Update();
+    window.clear(sf::Color::Black);
+
+    for (buttonCounter = 0; buttonCounter < 4; buttonCounter++)
+    {
+        window.draw((buttons + buttonCounter) -> GetVertices(), 4, sf::PrimitiveType::Quads);
+        window.draw((buttons + buttonCounter) -> GetText());
+    }
+
+    window.draw(output.GetText());
+    window.display();
+}
+
+
+void GUIWindow::ButtonCheck(sf::Vector2i mousePos)
+{
+    int i;
+    SynButton *current;
+    for (i = 0; i < 4; i++)
+    {
+        current = buttons + i;
+        if(current -> IsMouseOver(mousePos.x, mousePos.y))
+        {
+            (buttons + i) -> Click();
+            break;
+        }
+    }
+    
 }
 
 GUIWindow::~GUIWindow()
 {
+    if(buttons) delete buttons;
 }

GUITest/SynGame.hpp

@@ -8,7 +8,7 @@
     #include <vector>
     #include <iostream>
     #include <cmath>
+    #include "GUIElements.hpp"
     #include "Window.hpp"
     #include "GUIWindow.hpp"
-    #include "GUIElements.hpp"
 #endif

GUITest/Window.hpp

@@ -62,6 +62,7 @@
             bool isFocused;
             bool fullscreen;
             virtual void Update();
+            virtual void ButtonCheck(sf::Vector2i);
         public:
             Window(unsigned int = 960, unsigned int = 540, std::string = "Window", sf::Uint32 = sf::Style::Titlebar | sf::Style::Close);
             virtual void CreateWindow();
@@ -82,6 +83,8 @@
                 isFocused = false;
             else if (event.type == sf::Event::GainedFocus)
                 isFocused = true;
+            else if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
+                ButtonCheck(sf::Mouse::getPosition(window));
             if(sf::Keyboard::isKeyPressed(sf::Keyboard::F))
             {
                 fullscreen = !fullscreen;
@@ -96,6 +99,11 @@
         timer.UpdateTime();
     }
 
+    void Window::ButtonCheck(sf::Vector2i mousePos)
+    {
+
+    }
+
     Window::Window(unsigned int width, unsigned int height, std::string title, sf::Uint32 style)
     {
         this -> size.x = width;
@@ -130,7 +138,7 @@
             size.y = videoMode.height;
             window.create(videoMode, title, sf::Style::Fullscreen);
         }
-
+        window.setVerticalSyncEnabled(true);
         timer.ResetTimer();
     }
 

GUITest/main.cpp

@@ -2,6 +2,7 @@
 
 int main()
 {
+    font.loadFromFile("../OpenSans-Bold.ttf");
     GUIWindow window(960, 540, "GUI Test");
 
     while (window.IsOpen())