types.h

Go to the documentation of this file.

/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef OMGUI_TYPES_H
#define OMGUI_TYPES_H

// Make sure that UNICODE is defined for a windows build even if the build system forgot
#ifdef OMGUI_WIN32
#ifndef UNICODE
#define UNICODE
#endif
#endif

#include <stddef.h> // for NULL =(
#include <omgui/dllimpexp.h>
#include <omgui/refcount.h>
#include <omgui/api-prototypes.h>
#include <string>
#include <sstream>
#include <list>

namespace omgui {

#ifdef OMGUI_WIDECHARS
#define OMGUI_STR(s) L##s
    typedef std::wstring string;
    typedef std::wstringstream stringstream;
#else // !defined(OMGUI_WIDECHARS)
#define OMGUI_STR(s) s
    typedef std::string string;
    typedef std::stringstream stringstream;
#endif

enum LAYOUT_FLAGS {
    ALIGN_LEFT              = 0x01,
    ALIGN_RIGHT             = 0x02,
    ALIGN_CENTER_HORIZONTAL = 0x04,
    ALIGN_TOP               = 0x08,
    ALIGN_BOTTOM            = 0x10,
    ALIGN_CENTER_VERTICAL   = 0x20,
    ALIGN_CENTER            = ALIGN_CENTER_HORIZONTAL | ALIGN_CENTER_VERTICAL,
    EXPAND_HORIZONTAL       = 0x40,
    EXPAND_VERTICAL         = 0x80,
    EXPAND_BOTH             = EXPAND_HORIZONTAL | EXPAND_VERTICAL,
};

typedef std::list< Pointer<omgui::Widget> > ChildList;

typedef unsigned short menu_id;

typedef int object_id;
const object_id OBJECT_ID_ANY = 0;

typedef int event_id;

class Panel;
typedef Pointer<Panel> NotebookPage;

struct OMGUI_API Size
{
    int width, height;

    Size()
        : width(0),
        height(0)
    { }

    Size(int w, int h)
        : width(w),
        height(h)
    { }

    Size &operator+=(const Size &s)
    {
        width += s.width;
        height += s.height;
        return *this;
    }

    Size &operator-=(const Size &s)
    {
        width -= s.width;
        height -= s.height;
        return *this;
    }

    Size &operator*=(float f)
    {
        // silence type conversion warnings with a static_cast
        width = static_cast<int>(width * f);
        height = static_cast<int>(height * f);
        return *this;
    }

    Size &operator/=(float f)
    {
        // silence type conversion warnings with a static_cast
        width = static_cast<int>(width * f);
        height = static_cast<int>(height *f);
        return *this;
    }

    bool operator==(const Size &s)
    {
        return width == s.width && height == s.height;
    }

    bool operator!=(const Size &s)
    {
        return width != s.width || height != s.height;
    }
};

struct OMGUI_API Point
{
    int x, y;

    Point()
        : x(0),
        y(0)
    { }

    Point(int xx, int yy)
        : x(xx),
        y(yy)
    { }

    Point &operator+=(const Point &p)
    {
        x += p.x;
        y += p.y;
        return *this;
    }

    Point &operator-=(const Point &p)
    {
        x -= p.x;
        y -= p.y;
        return *this;
    }

    bool operator==(const Point &p)
    {
        return x == p.x && y == p.y;
    }

    bool operator!=(const Point &p)
    {
        return x != p.x || y != p.y;
    }
};

struct OMGUI_API Rect
{
    Size size;
    Point position;

    Rect()
        : size(0,0),
        position(0,0)
    { }

    Rect(const Size &s)
        : size(s)
    { }

    Rect(const Point &p, const Size &s)
        : size(s),
        position(p)
    { }

    Rect(int x, int y, int w, int h)
        : size(w,h),
        position(x,y)
    { }

    bool operator==(const Rect &r)
    {
        return size == r.size && position == r.position;
    }

    bool operator!=(const Rect &r)
    {
        return size != r.size || position != r.position;
    }
};

typedef int text_range_t;

struct OMGUI_API TextRange
{
    static const text_range_t END;
    text_range_t first, second;

    TextRange()
        : first(0),
        second(0)
    { }

    TextRange(text_range_t begin, text_range_t end = END)
        : first(begin),
        second(end)
    { }

    TextRange(const TextRange &other)
        : first(other.first),
        second(other.second)
    { }

    TextRange &operator=(const TextRange &other)
    {
        first = other.first;
        second = other.second;
        return *this;
    }

    void normalize()
    {
        if( first > second )
        {
            int temp = first;
            first = second;
            second = temp;
        }
    }

    TextRange(const TextRange &other, text_range_t length)
        : first(other.first),
        second(other.second)
    {
        if( first < 0 )
            first += length;
        else if( first == END )
            first = length;
        if( second < 0 )
            second += length;
        else if( second == END )
            second = length;
    }
};

// default position and size constants
/*
const float DEFAULT_VALUE(-1);
const Point DEFAULT_POS(DEFAULT_VALUE, DEFAULT_VALUE);
const Size DEFAULT_SIZE(DEFAULT_VALUE, DEFAULT_VALUE);
*/

} // namespace omgui

inline omgui::Size operator+(const omgui::Size &l, const omgui::Size &r)
{
    return omgui::Size(l.width + r.width, l.height + r.height);
}

inline omgui::Size operator-(const omgui::Size &l, const omgui::Size &r)
{
    return omgui::Size(l.width - r.width, l.height - r.height);
}

inline omgui::Size operator*(const omgui::Size &l, float f)
{
    // silence type conversion warnings with a static_cast
    return omgui::Size(static_cast<int>(l.width * f), static_cast<int>(l.height * f));
}

inline omgui::Size operator/(const omgui::Size &l, float f)
{
    // silence type conversion warnings with a static_cast
    return omgui::Size(static_cast<int>(l.width / f), static_cast<int>(l.height / f));
}

inline omgui::Point operator+(const omgui::Point &l, const omgui::Point &r)
{
    return omgui::Point(l.x + r.x, l.y + r.y);
}

inline omgui::Point operator-(const omgui::Point &l, const omgui::Point &r)
{
    return omgui::Point(l.x - r.x, l.y - r.y);
}

#endif // OMGUI_TYPES_H

---