commit ae3b08c3d594522477bf5f2f88570db00990ada6 Author: Kayne Ruse Date: Sat Apr 16 17:25:00 2016 +1000 Initial commit, read more This commit includes: * Button * TextLine * TextBox * TextField It also includes these dependencies: * Image * BoundingBox diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..497ac38 --- /dev/null +++ b/.gitignore @@ -0,0 +1,24 @@ +#Editor generated files +*.sln +*.vcproj +*.suo +*.ncb +*.user + +#Directories +Release/ +Debug/ +Out/ +release/ +debug/ +out/ + +#Project generated files +*.db +*.o +*.a +*.exe + +#Shell files +*.bat +*.sh diff --git a/README.md b/README.md new file mode 100644 index 0000000..d8ed760 --- /dev/null +++ b/README.md @@ -0,0 +1,15 @@ +## Outline + +TurtleGUI requires SDL2, SDL_image and SDL_ttf. It also requires Image and BoundingBox from [Tortuga](https://github.com/Ratstail91/Tortuga) which have been included. + +## Copyright + +Copyright (c) 2013-2016 Kayne Ruse + +This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. diff --git a/bounding_box.hpp b/bounding_box.hpp new file mode 100644 index 0000000..7784e5a --- /dev/null +++ b/bounding_box.hpp @@ -0,0 +1,65 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#pragma once + +#include +#include + +class BoundingBox { +public: + //This is explicitly a POD + int x, y; + int w, h; + + BoundingBox() = default; + BoundingBox(int i, int j): x(i), y(j), w(0), h(0) {}; + BoundingBox(int i, int j, int k, int l): x(i), y(j), w(k), h(l) {}; + ~BoundingBox() = default; + BoundingBox& operator=(BoundingBox const&) = default; + + int Size() { + return std::max(w*h,0); + } + + bool CheckOverlap(BoundingBox rhs) { + return !( + x >= rhs.x + rhs.w || + y >= rhs.y + rhs.h || + rhs.x >= x + w || + rhs.y >= y + h); + } + + BoundingBox CalcOverlap(BoundingBox rhs) { + if (!CheckOverlap(rhs)) { + return {0, 0, 0, 0}; + } + BoundingBox ret; + ret.x = std::max(x, rhs.x); + ret.y = std::max(y, rhs.y); + ret.w = std::min(x+w, rhs.x+rhs.w) - ret.x; + ret.h = std::min(y+h, rhs.y+rhs.h) - ret.y; + return ret; + } +}; + +//This is explicitly a POD +static_assert(std::is_pod::value, "BoundingBox is not a POD"); diff --git a/button.cpp b/button.cpp new file mode 100644 index 0000000..d58fed8 --- /dev/null +++ b/button.cpp @@ -0,0 +1,167 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#include "button.hpp" + +#include "render_text_texture.hpp" + +#include + +void Button::DrawTo(SDL_Renderer* renderer) { + image.SetClipY(image.GetClipH() * state); + image.DrawTo(renderer, posX, posY); +} + +void Button::SetBackgroundTexture(SDL_Renderer* renderer, SDL_Texture* texture) { + //copy the given texture + image.Free(); + + //a null texture can simply free the image + if (!texture) { + return; + } + + //get the w & h, & create + int w = 0, h = 0; + SDL_QueryTexture(texture, nullptr, nullptr, &w, &h); + image.Create(renderer, w, h); + + //copy + SDL_SetRenderTarget(renderer, image.GetTexture()); + SDL_RenderCopy(renderer, texture, nullptr, nullptr); + SDL_SetRenderTarget(renderer, nullptr); + + //prune + image.SetClipH(image.GetClipH() / 3); +} + +void Button::SetText(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, std::string s) { + //convert to texture + SDL_Texture* text = renderTextTexture(renderer, font, color, s); + + //get the dimensions & rects + int x, y, w, h; + SDL_QueryTexture(text, nullptr, nullptr, &w, &h); + x = (image.GetClipW() - w) / 2; + y = (image.GetClipH() - h) / 2; + SDL_Rect src = {0, 0, w, h}; + SDL_Rect dst; + + //draw the text to the background + SDL_SetRenderTarget(renderer, image.GetTexture()); + + for (int i = 0; i < 3; i++) { + dst = {x, y + image.GetClipH() * i, w, h}; + SDL_RenderCopy(renderer, text, &src, &dst); + } + + SDL_SetRenderTarget(renderer, nullptr); + + //free the texture + SDL_DestroyTexture(text); +} + +Button::State Button::MouseMotion(SDL_MouseMotionEvent const& event) { + //if out of bounds, exit + if (!CheckBounds(event.x, event.y)) { + return state = State::IDLE; + } + + //if in bounds, check button + if (event.state & SDL_BUTTON_LMASK && state == State::PRESSED) { + //stay pressed +// state = State::PRESSED; + } + else { + state = State::HOVER; + } + + return state; +} + +Button::State Button::MouseButtonDown(SDL_MouseButtonEvent const& event) { + //if out of bounds, exit + if (!CheckBounds(event.x, event.y)) { + return state = State::IDLE; + } + + //if in bounds, check button + if (event.button == SDL_BUTTON_LEFT) { + return state = State::PRESSED; + } + + //NOTE: if not left button down, ignore + return State::HOVER; +} + +Button::State Button::MouseButtonUp(SDL_MouseButtonEvent const& event) { + //if out of bounds, exit + if (!CheckBounds(event.x, event.y)) { + return state = State::IDLE; + } + + //if not left button up, ignore + if (event.button != SDL_BUTTON_LEFT) { + return state; + } + + //if in bounds and left button up, send release signal + if (state == State::PRESSED) { + state = State::HOVER; + return State::RELEASED; + } + + return state; +} + +void Button::SetState(State s) { + state = s; +} + +Button::State Button::GetState() { + return state; +} + +int Button::SetX(int i) { + return posX = i; +} + +int Button::SetY(int i) { + return posY = i; +} + +int Button::GetX() const { + return posX; +} + +int Button::GetY() const { + return posY; +} + +bool Button::CheckBounds(int x, int y) { + //return if true (x, y) is within bounds, otherwise return false + return !( + x < posX || + y < posY || + x > posX + image.GetClipW() || + y > posY + image.GetClipH() + ); +} \ No newline at end of file diff --git a/button.hpp b/button.hpp new file mode 100644 index 0000000..2d9da37 --- /dev/null +++ b/button.hpp @@ -0,0 +1,67 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#pragma once + +#include "image.hpp" + +#include "SDL2/SDL_ttf.h" + +#include + +class Button { +public: + enum State { + IDLE = 0, HOVER = 1, PRESSED = 2, RELEASED = 3 + }; + + //methods + Button() = default; + ~Button() = default; + + void DrawTo(SDL_Renderer*); + + //setup + void SetBackgroundTexture(SDL_Renderer*, SDL_Texture*); + void SetText(SDL_Renderer*, TTF_Font*, SDL_Color, std::string); + + //capture input + State MouseMotion(SDL_MouseMotionEvent const&); + State MouseButtonDown(SDL_MouseButtonEvent const&); + State MouseButtonUp(SDL_MouseButtonEvent const&); + + //states + void SetState(State); //TODO: idle, busy or disabled + State GetState(); + + //accessors & mutators + int SetX(int x); + int SetY(int y); + int GetX() const; + int GetY() const; + +protected: + bool CheckBounds(int x, int y); + + Image image; + State state = State::IDLE; + int posX = 0, posY = 0; +}; diff --git a/image.cpp b/image.cpp new file mode 100644 index 0000000..7eadeaf --- /dev/null +++ b/image.cpp @@ -0,0 +1,211 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#include "image.hpp" + +#include "SDL2/SDL_image.h" + +#include +#include + +Image& Image::operator=(Image const& rhs) { + //don't screw yourself + if (this == &rhs) { + return *this; + } + + Free(); + + //Copy the other Image's stuff + texture = rhs.texture; + clip = rhs.clip; + local = false; +} + +Image& Image::operator=(Image&& rhs) { + //don't screw yourself + if (this == &rhs) { + return *this; + } + + Free(); + + //Steal the other Image's stuff + texture = rhs.texture; + clip = rhs.clip; + local = rhs.local; + + rhs.texture = nullptr; + rhs.clip = {0, 0, 0, 0}; + rhs.local = false; +} + +SDL_Texture* Image::Load(SDL_Renderer* renderer, std::string fname) { + Free(); + + //load the file into a surface + SDL_Surface* surface = IMG_Load(fname.c_str()); + if (!surface) { + std::ostringstream msg; + msg << "Failed to load an image file: " << fname; + msg << "; " << IMG_GetError(); + throw(std::runtime_error(msg.str())); + } + + //create a texture from this surface + texture = SDL_CreateTextureFromSurface(renderer, surface); + if (!texture) { + std::ostringstream msg; + msg << "Failed to convert a newly loaded image file: " << fname; + msg << "; " << SDL_GetError(); + throw(std::runtime_error(msg.str())); + } + + //set the metadata + clip.x = 0; + clip.y = 0; + if (SDL_QueryTexture(texture, nullptr, nullptr, &clip.w, &clip.h)) { + std::ostringstream msg; + msg << "Failed to record metadata for a newly loaded image file: " << fname; + msg << "; " << SDL_GetError(); + throw(std::runtime_error(msg.str())); + } + local = true; + + //free the surface & return + SDL_FreeSurface(surface); + return texture; +} + +SDL_Texture* Image::Create(SDL_Renderer* renderer, Uint16 w, Uint16 h, SDL_Color blank) { + Free(); + + //make the texture + texture = SDL_CreateTexture(renderer, + SDL_PIXELFORMAT_RGBA8888, + SDL_TEXTUREACCESS_TARGET, + w, h); + + //check + if (!texture) { + std::ostringstream msg; + msg << "Failed to create a texture; " << SDL_GetError(); + throw(std::runtime_error(msg.str())); + } + + //set the metadata + clip.x = 0; + clip.y = 0; + if (SDL_QueryTexture(texture, nullptr, nullptr, &clip.w, &clip.h)) { + std::ostringstream msg; + msg << "Failed to record metadata for a newly created image"; + msg << "; " << SDL_GetError(); + throw(std::runtime_error(msg.str())); + } + local = true; + + //blank (black) texture + SDL_SetRenderTarget(renderer, texture); + SDL_SetRenderDrawColor(renderer, blank.r, blank.g, blank.b, blank.a); + SDL_RenderFillRect(renderer, nullptr); + SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0); + SDL_SetRenderTarget(renderer, nullptr); + + return texture; +} + +SDL_Texture* Image::CopyTexture(SDL_Renderer* renderer, SDL_Texture* ptr) { + Free(); + int w = 0, h = 0; + + //get the info + SDL_QueryTexture(ptr, nullptr, nullptr, &w, &h); + + //create a texture of (w, h) size (also sets the metadata) + Create(renderer, w, h); + + //copy the argument texture to the local texture + SDL_SetRenderTarget(renderer, texture); + SDL_RenderCopy(renderer, ptr, nullptr, nullptr); + SDL_SetRenderTarget(renderer, nullptr); + + //return the local texture + return texture; +} + +SDL_Texture* Image::SetTexture(SDL_Texture* ptr) { + Free(); + + texture = ptr; + + //set the metadata + clip.x = 0; + clip.y = 0; + if (SDL_QueryTexture(texture, nullptr, nullptr, &clip.w, &clip.h)) { + std::ostringstream msg; + msg << "Failed to record metadata for a newly set image"; + msg << "; " << SDL_GetError(); + throw(std::runtime_error(msg.str())); + } + local = false; + + return texture; +} + +SDL_Texture* Image::GetTexture() const { + return texture; +} + +void Image::Free() { + if (local) { + SDL_DestroyTexture(texture); + local = false; + } + texture = nullptr; + clip = {0, 0, 0, 0}; +} + +void Image::DrawTo(SDL_Renderer* const renderer, Sint16 x, Sint16 y, double scaleX, double scaleY) { + if (!texture) { + throw(std::logic_error("No image texture to draw")); + } + SDL_Rect sclip = clip; + SDL_Rect dclip = {x, y, Uint16(clip.w * scaleX), Uint16(clip.h * scaleY)}; + SDL_RenderCopy(renderer, texture, &sclip, &dclip); +} + +void Image::SetAlpha(Uint8 a) { + if (SDL_SetTextureAlphaMod(texture, a)) { + std::ostringstream msg; + msg << "Failed to set alpha; " << SDL_GetError(); + throw(std::runtime_error(msg.str())); + } +} + +Uint8 Image::GetAlpha() { + Uint8 ret = 0; + if (SDL_GetTextureAlphaMod(texture, &ret)) { + std::ostringstream msg; + msg << "Failed to get alpha; " << SDL_GetError(); + throw(std::runtime_error(msg.str())); + } + return ret; +} \ No newline at end of file diff --git a/image.hpp b/image.hpp new file mode 100644 index 0000000..b4e62f8 --- /dev/null +++ b/image.hpp @@ -0,0 +1,73 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#pragma once + +#include "SDL2/SDL.h" + +#include + +class Image { +public: + Image() = default; + Image(Image const& rhs) { *this = rhs; } + Image(Image&& rhs) { *this = std::move(rhs); } + Image(SDL_Renderer* r, std::string fname) { Load(r, fname); } + Image(SDL_Renderer* r, Uint16 w, Uint16 h) { Create(r, w, h); } + Image(SDL_Texture* p) { SetTexture(p); } + virtual ~Image() { Free(); } + + Image& operator=(Image const&); + Image& operator=(Image&&); + + SDL_Texture* Load(SDL_Renderer* renderer, std::string fname); + SDL_Texture* Create(SDL_Renderer* renderer, Uint16 w, Uint16 h, SDL_Color blank = {0, 0, 0, 255}); + SDL_Texture* CopyTexture(SDL_Renderer* renderer, SDL_Texture* ptr); + SDL_Texture* SetTexture(SDL_Texture*); + SDL_Texture* GetTexture() const; + virtual void Free(); + + void DrawTo(SDL_Renderer* const, Sint16 x, Sint16 y, double scaleX = 1.0, double scaleY = 1.0); + + void SetAlpha(Uint8 a); + Uint8 GetAlpha(); + + //Clip handlers + SDL_Rect SetClip(SDL_Rect r) { return clip = r; } + SDL_Rect GetClip() const { return clip; } + + Sint16 SetClipX(Sint16 x) { return clip.x = x; } + Sint16 SetClipY(Sint16 y) { return clip.y = y; } + Uint16 SetClipW(Uint16 w) { return clip.w = w; } + Uint16 SetClipH(Uint16 h) { return clip.h = h; } + + Sint16 GetClipX() const { return clip.x; } + Sint16 GetClipY() const { return clip.y; } + Uint16 GetClipW() const { return clip.w; } + Uint16 GetClipH() const { return clip.h; } + + bool GetLocal() const { return local; } + +protected: + SDL_Texture* texture = nullptr; + SDL_Rect clip = {0, 0, 0, 0}; + bool local = false; +}; \ No newline at end of file diff --git a/makefile b/makefile new file mode 100644 index 0000000..6242a6e --- /dev/null +++ b/makefile @@ -0,0 +1,31 @@ +#config +INCLUDES+=. +LIBS+= +CXXFLAGS+=-std=c++11 $(addprefix -I,$(INCLUDES)) + +#source +CXXSRC=$(wildcard *.cpp) + +#objects +OBJDIR=obj +OBJ+=$(addprefix $(OBJDIR)/,$(CXXSRC:.cpp=.o)) + +OUTDIR=. +OUT=libturtlegui.a + +#targets +all: $(OBJ) $(OUT) + ar -crs $(OUT) $(OBJ) + +$(OBJ): | $(OBJDIR) + +$(OUT): | $(OUTDIR) + +$(OBJDIR): + mkdir $(OBJDIR) + +$(OUTDIR): + mkdir $(OUTDIR) + +$(OBJDIR)/%.o: %.cpp + $(CXX) $(CXXFLAGS) -c -o $@ $< diff --git a/render_text_texture.cpp b/render_text_texture.cpp new file mode 100644 index 0000000..bd02f48 --- /dev/null +++ b/render_text_texture.cpp @@ -0,0 +1,46 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#include "render_text_texture.hpp" + +#include + +SDL_Texture* renderTextTexture(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, std::string str) { + //make the surface (from SDL_ttf) + SDL_Surface* surface = TTF_RenderText_Solid(font, str.c_str(), color); + if (!surface) { + throw(std::runtime_error("Failed to create a TTF surface")); + } + + //convert to texture + SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface); + + //cleanup + SDL_FreeSurface(surface); + + //check + if (!texture) { + throw(std::runtime_error("Failed to create a TTF texture")); + } + + //NOTE: free the texture yourself + return texture; +} \ No newline at end of file diff --git a/render_text_texture.hpp b/render_text_texture.hpp new file mode 100644 index 0000000..1aca1ed --- /dev/null +++ b/render_text_texture.hpp @@ -0,0 +1,29 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#pragma once + +#include "SDL2/SDL.h" +#include "SDL2/SDL_ttf.h" + +#include + +SDL_Texture* renderTextTexture(SDL_Renderer*, TTF_Font*, SDL_Color color, std::string); \ No newline at end of file diff --git a/text_box.cpp b/text_box.cpp new file mode 100644 index 0000000..f597d73 --- /dev/null +++ b/text_box.cpp @@ -0,0 +1,75 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#include "text_box.hpp" + +#include + +TextBox::TextBox() { + // +} + +TextBox::~TextBox() { + // +} + +void TextBox::DrawTo(SDL_Renderer* renderer) { + int renderY = posY; + for (std::list::iterator it = lineList.begin(); it != lineList.end(); it++) { + it->SetX(posX); + it->SetY(renderY); + it->DrawTo(renderer); + renderY += it->GetPointHeight(); + } +} + +void TextBox::PushLine(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, std::string str) { + lineList.emplace_back(renderer, font, color, str, 0, 0); +} + +void TextBox::PopLine(int num) { + //prevent underflow + num < lineList.size() ? num : lineList.size(); + + for (int i = 0; i < num; ++i) { + lineList.pop_front(); + } +} + +void TextBox::ClearLines() { + lineList.clear(); +} + +int TextBox::SetX(int i) { + return posX = i; +} + +int TextBox::SetY(int i) { + return posY = i; +} + +int TextBox::GetX() const { + return posX; +} + +int TextBox::GetY() const { + return posY; +} diff --git a/text_box.hpp b/text_box.hpp new file mode 100644 index 0000000..0e96bc8 --- /dev/null +++ b/text_box.hpp @@ -0,0 +1,51 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#pragma once + +#include "text_line.hpp" + +#include "SDL2/SDL.h" +#include "SDL2/SDL_ttf.h" + +#include +#include + +class TextBox { +public: + TextBox(); + ~TextBox(); + + void DrawTo(SDL_Renderer*); + + void PushLine(SDL_Renderer*, TTF_Font*, SDL_Color color, std::string); + void PopLine(int num = 1); + void ClearLines(); + + int SetX(int i); + int SetY(int i); + int GetX() const; + int GetY() const; + +private: + std::list lineList; + int posX = 0, posY = 0; +}; \ No newline at end of file diff --git a/text_field.cpp b/text_field.cpp new file mode 100644 index 0000000..c9056be --- /dev/null +++ b/text_field.cpp @@ -0,0 +1,109 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#include "text_field.hpp" + +#include "render_text_texture.hpp" + +TextField::TextField() { + // +} + +TextField::~TextField() { + SDL_DestroyTexture(texture); +} + +void TextField::DrawTo(SDL_Renderer* renderer) { + if (!texture) { + return; + } + SDL_Rect dclip = {posX, posY, 0, 0}; + SDL_QueryTexture(texture, nullptr, nullptr, &dclip.w, &dclip.h); + SDL_RenderCopy(renderer, texture, nullptr, &dclip); +} + +std::string TextField::PushText(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, std::string s) { + text += s; + return SetText(renderer, font, color, text); +} + +std::string TextField::SetText(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, std::string s) { + text = s; + SDL_DestroyTexture(texture); + if (text.size()) { + texture = renderTextTexture(renderer, font, color, text); + } + else { + texture = nullptr; + } + return text; +} + +std::string TextField::PopChars(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, int i) { + if (text.size() > 0) { + text.erase(text.size() - i); + } + return SetText(renderer, font, color, text); +} + +std::string TextField::GetText() { + return text; +} + +bool TextField::MouseButtonDown(SDL_MouseButtonEvent const& event) { + BoundingBox cursorBox = {event.x, event.y, 0, 0}; + BoundingBox fieldBox = bounds; + fieldBox.x += posX; + fieldBox.y += posY; + return focus = fieldBox.CheckOverlap(cursorBox); +} + +BoundingBox TextField::SetBounds(BoundingBox b) { + return bounds = b; +} + +BoundingBox TextField::GetBounds() { + return bounds; +} + +bool TextField::SetFocus(bool b) { + return focus = b; +} + +bool TextField::GetFocus() { + return focus; +} + +int TextField::SetX(int i) { + return posX = i; +} + +int TextField::SetY(int i) { + return posY = i; +} + +int TextField::GetX() const { + return posX; +} + +int TextField::GetY() const { + return posY; +} diff --git a/text_field.hpp b/text_field.hpp new file mode 100644 index 0000000..5bdbc21 --- /dev/null +++ b/text_field.hpp @@ -0,0 +1,65 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#pragma once + +#include "bounding_box.hpp" + +#include "SDL2/SDL.h" +#include "SDL2/SDL_ttf.h" + +#include + +class TextField { +public: + TextField(); + ~TextField(); + + void DrawTo(SDL_Renderer*); + + //input + std::string PushText(SDL_Renderer*, TTF_Font*, SDL_Color color, std::string); + std::string SetText(SDL_Renderer*, TTF_Font*, SDL_Color color, std::string); + std::string PopChars(SDL_Renderer*, TTF_Font*, SDL_Color color, int i); + + std::string GetText(); + + bool MouseButtonDown(SDL_MouseButtonEvent const& event); + + BoundingBox SetBounds(BoundingBox b); + BoundingBox GetBounds(); + + bool SetFocus(bool b); + bool GetFocus(); + + //accessors & mutators + int SetX(int i); + int SetY(int i); + int GetX() const; + int GetY() const; + +private: + SDL_Texture* texture = nullptr; + std::string text; + BoundingBox bounds; + bool focus = false; + int posX = 0, posY = 0; +}; \ No newline at end of file diff --git a/text_line.cpp b/text_line.cpp new file mode 100644 index 0000000..865f07e --- /dev/null +++ b/text_line.cpp @@ -0,0 +1,78 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#include "text_line.hpp" + +#include "render_text_texture.hpp" + +#include + +TextLine::TextLine() { + // +} + +TextLine::TextLine(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, std::string str, int x, int y) { + SetText(renderer, font, color, str); + posX = x; + posY = y; +} + +TextLine::~TextLine() { + ClearText(); +} + +void TextLine::DrawTo(SDL_Renderer* renderer) { + SDL_Rect dclip = {posX, posY, 0, 0}; + SDL_QueryTexture(texture, nullptr, nullptr, &dclip.w, &dclip.h); + SDL_RenderCopy(renderer, texture, nullptr, &dclip); +} + +void TextLine::SetText(SDL_Renderer* renderer, TTF_Font* font, SDL_Color color, std::string str) { + //just use the above global function + SDL_DestroyTexture(texture); + texture = renderTextTexture(renderer, font, color, str); + pointHeight = TTF_FontHeight(font); +} + +void TextLine::ClearText() { + SDL_DestroyTexture(texture); + pointHeight = 0; +} + +int TextLine::SetX(int i) { + return posX = i; +} + +int TextLine::SetY(int i) { + return posY = i; +} + +int TextLine::GetX() const { + return posX; +} + +int TextLine::GetY() const { + return posY; +} + +int TextLine::GetPointHeight() { + return pointHeight; +} \ No newline at end of file diff --git a/text_line.hpp b/text_line.hpp new file mode 100644 index 0000000..ffa6661 --- /dev/null +++ b/text_line.hpp @@ -0,0 +1,53 @@ +/* Copyright: (c) Kayne Ruse 2013-2016 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. +*/ +#pragma once + +#include "SDL2/SDL.h" +#include "SDL2/SDL_ttf.h" + +#include + +class TextLine { +public: + TextLine(); + TextLine(SDL_Renderer*, TTF_Font*, SDL_Color, std::string, int x, int y); + virtual ~TextLine(); + + void DrawTo(SDL_Renderer*); + + void SetText(SDL_Renderer*, TTF_Font*, SDL_Color, std::string); + void ClearText(); + + //accessors & mutators + int SetX(int i); + int SetY(int i); + int GetX() const; + int GetY() const; + + //utility + int GetPointHeight(); + +protected: + SDL_Texture* texture = nullptr; + int posX = 0, posY = 0; + int pointHeight = 0; //internal use for TextBox +}; \ No newline at end of file