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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
|
/****************************************************************************
* NxWidgets/libnxwidgets/include/cnxtkwindow.hxx
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
* me be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __INCLUDE_CNXTKWINDOW_HXX
#define __INCLUDE_CNXTKWINDOW_HXX
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <stdbool.h>
#include <nuttx/nx/nxglib.h>
#include <nuttx/nx/nx.h>
#include <nuttx/nx/nxtk.h>
#include "ccallback.hxx"
#include "inxwindow.hxx"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/****************************************************************************
* Implementation Classes
****************************************************************************/
#if defined(__cplusplus)
namespace NXWidgets
{
class CNxToolbar;
struct SBitmap;
/**
* This class defines operations on a framed NX window.
* There are three instances that represent an NX window from the
* perspective of NXWidgets.
*
* - There is one widget control instance per NX window,
* - One CCallback instance per window,
* - One window instance.
*
* There a various kinds of of window instances, but each inherits
* (1) CCallback and dispatches the Windows callbacks and (2) INxWindow
* that describes the common window behavior.
*/
class CNxTkWindow : protected CCallback, public INxWindow
{
protected:
NXHANDLE m_hNxServer; /**< Handle to the NX server. */
NXTKWINDOW m_hNxTkWindow; /**< Handle to the NX raw window */
CWidgetControl *m_widgetControl; /**< Controlling widget for the window */
CNxToolbar *m_toolbar; /**< Child toolbar */
public:
/**
* Constructor. Creates an uninitialized instance of the CNxTkWindow
* object. The open() method must be called to initialize the instance.
*
* The general steps to create any window include:
* 1) Create a dumb CWigetControl instance
* 2) Pass the dumb CWidgetControl instance to the window constructor
* that inherits from INxWindow.
* 3) The window constructor call CWidgetControl methods to "smarten"
* the CWidgetControl instance with window-specific knowledge.
* 4) Call the open() method on the window to display the window.
* 5) After that, the fully smartened CWidgetControl instance can
* be used to generate additional widgets.
* 6) After that, the fully smartened CWidgetControl instance can
* be used to generate additional widgets by passing it to the
* widget constructor
*
* @param hNxServer Handle to the NX server.
* @param widgetControl Controlling widget for this window.
*/
CNxTkWindow(NXHANDLE hNxServer, CWidgetControl *pWidgetControl);
/**
* Destructor.
*/
~CNxTkWindow(void);
/**
* Creates a new window. Window creation is separate from
* object instantiation so that failures can be reported.
*
* @return True if the window was successfully opened.
*/
bool open(void);
/**
* Each implementation of INxWindow must provide a method to recover
* the contained CWidgetControl instance.
*
* @return The contained CWidgetControl instance
*/
CWidgetControl *getWidgetControl(void) const;
/**
* Open a toolbar on the framed window. Toolbar creation is separate
* from object instantion so that errors can be reported
*
* @return True if the toolbar was successfully created.
*/
CNxToolbar *openToolbar(nxgl_coord_t height);
/**
* Detach the toolbar. This should *ONLY* be called by the toolbar
* instance itself. If this is called by end-user logic, it will
* screw things up miserably.
*/
inline void detachToolbar(void)
{
m_toolbar = (CNxToolbar *)NULL;
}
/**
* Request the position and size information of the window. The values
* will be returned asynchronously through the client callback method.
* The GetPosition() method may than be called to obtain the positional
* data as provided by the callback.
*
* @return True on success, false on any failure.
*/
bool requestPosition(void);
/**
* Get the position of the window (as reported by the NX callback).
*
* @return True on success, false on any failure.
*/
bool getPosition(FAR struct nxgl_point_s *pPos);
/**
* Get the size of the window (as reported by the NX callback).
*
* @return The size.
*/
bool getSize(FAR struct nxgl_size_s *pSize);
/**
* Set the position and size of the window.
*
* @param pPos The new position of the window.
* @return True on success, false on any failure.
*/
bool setPosition(FAR const struct nxgl_point_s *pPos);
/**
* Set the size of the selected window.
*
* @param pSize The new size of the window.
* @return True on success, false on any failure.
*/
bool setSize(FAR const struct nxgl_size_s *pSize);
/**
* Bring the window to the top of the display.
*
* @return True on success, false on any failure.
*/
bool raise(void);
/**
* Lower the window to the bottom of the display.
*
* @return True on success, false on any failure.
*/
bool lower(void);
/**
* Set an individual pixel in the window with the specified color.
*
* @param pPos The location of the pixel to be filled.
* @param color The color to use in the fill.
*
* @return True on success; false on failure.
*/
bool setPixel(FAR const struct nxgl_point_s *pPos,
nxgl_mxpixel_t color);
/**
* Fill the specified rectangle in the window with the specified color.
*
* @param pRect The location to be filled.
* @param color The color to use in the fill.
*
* @return True on success; false on failure.
*/
bool fill(FAR const struct nxgl_rect_s *pRect,
nxgl_mxpixel_t color);
/**
* Get the raw contents of graphic memory within a rectangular region. NOTE:
* Since raw graphic memory is returned, the returned memory content may be
* the memory of windows above this one and may not necessarily belong to
* this window unless you assure that this is the top window.
*
* @param rect The location to be copied
* @param dest - The describes the destination bitmap to receive the
* graphics data.
*/
void getRectangle(FAR const struct nxgl_rect_s *rect, struct SBitmap *dest);
/**
* Fill the specified trapezoidal region in the window with the specified
* color.
*
* @param pClip Clipping rectangle relative to window (may be null).
* @param pTrap The trapezoidal region to be filled.
* @param color The color to use in the fill.
*
* @return True on success; false on failure.
*/
bool fillTrapezoid(FAR const struct nxgl_rect_s *pClip,
FAR const struct nxgl_trapezoid_s *pTrap,
nxgl_mxpixel_t color);
/**
* Fill the specified line in the window with the specified color.
*
* @param vector - Describes the line to be drawn
* @param width - The width of the line
* @param color - The color to use to fill the line
*
* @return True on success; false on failure.
*/
bool drawLine(FAR struct nxgl_vector_s *vector,
nxgl_coord_t width,
nxgl_mxpixel_t color);
/**
* Draw a filled circle at the specified position, size, and color.
*
* @param center The window-relative coordinates of the circle center.
* @param radius The radius of the rectangle in pixels.
* @param color The color of the rectangle.
*/
bool drawFilledCircle(struct nxgl_point_s *center, nxgl_coord_t radius,
nxgl_mxpixel_t color);
/**
* Move a rectangular region within the window.
*
* @param pRect Describes the rectangular region to move.
* @param pOffset The offset to move the region.
*
* @return True on success; false on failure.
*/
bool move(FAR const struct nxgl_rect_s *pRect,
FAR const struct nxgl_point_s *pOffset);
/**
* Copy a rectangular region of a larger image into the rectangle in the
* specified window.
*
* @param pDest Describes the rectangular on the display that will receive
* the bitmap.
* @param pSrc The start of the source image.
* @param pOrigin the pOrigin of the upper, left-most corner of the full
* bitmap. Both pDest and pOrigin are in window coordinates, however,
* pOrigin may lie outside of the display.
* @param stride The width of the full source image in bytes.
*
* @return True on success; false on failure.
*/
bool bitmap(FAR const struct nxgl_rect_s *pDest,
FAR const void *pSrc,
FAR const struct nxgl_point_s *pOrigin,
unsigned int stride);
};
}
#endif // __cplusplus
#endif // __INCLUDE_CNXTKWINDOW_HXX
|