1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/*
* UltraStar Deluxe - Karaoke Game
*
* UltraStar Deluxe is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef DRAWABLE_CONTROL_HPP
#define DRAWABLE_CONTROL_HPP
#include <SDL/SDL.h>
#include <boost/thread/shared_mutex.hpp>
#include <boost/signals2.hpp>
#include <log4cpp/Category.hh>
#include "drawable.hpp"
#include "control.hpp"
#include "utils/point.hpp"
#include "utils/dimension.hpp"
#include "utils/rectangle.hpp"
#include "background.hpp"
#include "static.hpp"
namespace usdx
{
class Container;
class DrawableControl : public Drawable, public Control
{
private:
static log4cpp::Category& log;
/**
* Coordinates of the top-left corner of the control.
*/
Point<int> position;
/**
* Size of the control.
*/
Dimension<int> size;
/**
* If true, clipping is set-up before the component is drawn, to cut off
* all the drawing outside the specified size of the control.
*/
bool clipping_required;
/**
* Whether the control should be able to get the focus.
*/
bool focusable;
/**
* Background of the control. The background is drawn, before the real
* content is drawn.
*/
Background* background;
/**
* Optional box around the control. Used for debugging.
*/
Static* debug_box;
mutable boost::shared_mutex position_mutex;
mutable boost::shared_mutex size_mutex;
mutable boost::shared_mutex clipping_required_mutex;
mutable boost::shared_mutex background_mutex;
protected:
Container* parent;
class ContainerHelper
{
private:
DrawableControl* self;
public:
ContainerHelper(DrawableControl*);
virtual void add(Container*) const;
};
DrawableControl(Container*, const ContainerHelper&);
bool is_clipping_required(void) const;
void set_clipping_required(const bool);
bool is_focusable(void) const;
void set_focusable(const bool);
/**
* Function get called, if the control should draw itself it the
* current position on the OpenGL screen. If clipping is required, the
* clipping gets set-up before this function gets called.
*/
virtual void draw(void);
public:
DrawableControl(Container*);
virtual ~DrawableControl();
/**
* Force the control to redraw it self.
*/
void repaint(void);
virtual void set_position(const Point<int>& position);
virtual void set_position(int left, int top);
const Point<int>& get_position(void) const;
int get_left(void) const;
int get_top(void) const;
virtual void set_size(const Dimension<int>& size);
virtual void set_size(int width, int height);
const Dimension<int>& get_size(void) const;
int get_width(void) const;
int get_height(void) const;
Container* get_parent(void) const;
void remove_parent(void);
void set_background(Background*);
const Background* get_background(void) const;
const Rectangle<int> get_absolut_rect(void) const;
virtual DrawableControl* get_component_at(const Point<int>& p);
virtual void mouse_move(const Point<int>& p);
virtual void mouse_down(uint8_t button, const Point<int>& p);
virtual void mouse_up(uint8_t button, const Point<int>& p);
virtual void mouse_enter(void);
virtual void mouse_leave(void);
virtual void mouse_click(uint8_t button, const Point<int>& p);
virtual void mouse_dbl_click(uint8_t button, const Point<int>& p);
boost::signals2::signal<void (const Point<int>&)> on_mouse_move;
boost::signals2::signal<void (uint8_t, const Point<int>&)> on_mouse_down;
boost::signals2::signal<void (uint8_t, const Point<int>&)> on_mouse_up;
boost::signals2::signal<void (void)> on_mouse_enter;
boost::signals2::signal<void (void)> on_mouse_leave;
boost::signals2::signal<void (uint8_t, const Point<int>&)> on_mouse_click;
boost::signals2::signal<void (uint8_t, const Point<int>&)> on_mouse_dbl_click;
};
}
#endif
|
