Debian Codegraph @

src/platform/X11/agg_platform_support.cpp

raw
1 //----------------------------------------------------------------------------
2 // Anti-Grain Geometry - Version 2.4
3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
4 //
5 // Permission to copy, use, modify, sell and distribute this software
6 // is granted provided this copyright notice appears in all copies.
7 // This software is provided "as is" without express or implied
8 // warranty, and with no claim as to its suitability for any purpose.
9 //
10 //----------------------------------------------------------------------------
11 // Contact: [email protected]
12 // [email protected]
13 // http://www.antigrain.com
14 //----------------------------------------------------------------------------
15 //
16 // class platform_support. X11 version.
17 //
18 //----------------------------------------------------------------------------
19
20 #include <cstdio>
21 #include <cstring>
22 #include <cstdlib>
23 #include <cctype>
24 #include <ctime>
25 #include <X11/Xlib.h>
26 #include <X11/Xutil.h>
27 #include <X11/Xatom.h>
28 #include <X11/keysym.h>
29 #include "agg_basics.h"
30 #include "agg_pixfmt_gray.h"
31 #include "agg_pixfmt_rgb.h"
32 #include "agg_pixfmt_rgba.h"
33 #include "util/agg_color_conv_rgb8.h"
34 #include "platform/agg_platform_support.h"
35
36
37 namespace agg
38 {
39 //------------------------------------------------------------------------
40 class platform_specific
41 {
42 public:
43 platform_specific(pix_format_e format, bool flip_y);
44 ~platform_specific();
45
46 void caption(const char* capt);
47 void put_image(const rendering_buffer* src);
48
49 pix_format_e m_format;
50 pix_format_e m_sys_format;
51 int m_byte_order;
52 bool m_flip_y;
53 unsigned m_bpp;
54 unsigned m_sys_bpp;
55 Display* m_display;
56 int m_screen;
57 int m_depth;
58 Visual* m_visual;
59 Window m_window;
60 GC m_gc;
61 XImage* m_ximg_window;
62 XSetWindowAttributes m_window_attributes;
63 Atom m_close_atom;
64 unsigned char* m_buf_window;
65 unsigned char* m_buf_img[platform_support::max_images];
66 unsigned m_keymap[256];
67
68 bool m_update_flag;
69 bool m_resize_flag;
70 bool m_initialized;
71 //bool m_wait_mode;
72 std::clock_t m_sw_start;
73 };
74
75
76
77 //------------------------------------------------------------------------
78 platform_specific::platform_specific(pix_format_e format, bool flip_y) :
79 m_format(format),
80 m_sys_format(pix_format_undefined),
81 m_byte_order(LSBFirst),
82 m_flip_y(flip_y),
83 m_bpp(0),
84 m_sys_bpp(0),
85 m_display(0),
86 m_screen(0),
87 m_depth(0),
88 m_visual(0),
89 m_window(0),
90 m_gc(0),
91 m_ximg_window(0),
92 m_close_atom(0),
93
94 m_buf_window(0),
95
96 m_update_flag(true),
97 m_resize_flag(true),
98 m_initialized(false)
99 //m_wait_mode(true)
100 {
101 std::memset(m_buf_img, 0, sizeof(m_buf_img));
102
103 unsigned i;
104 for(i = 0; i < 256; i++)
105 {
106 m_keymap[i] = i;
107 }
108
109 m_keymap[XK_Pause&0xFF] = key_pause;
110 m_keymap[XK_Clear&0xFF] = key_clear;
111
112 m_keymap[XK_KP_0&0xFF] = key_kp0;
113 m_keymap[XK_KP_1&0xFF] = key_kp1;
114 m_keymap[XK_KP_2&0xFF] = key_kp2;
115 m_keymap[XK_KP_3&0xFF] = key_kp3;
116 m_keymap[XK_KP_4&0xFF] = key_kp4;
117 m_keymap[XK_KP_5&0xFF] = key_kp5;
118 m_keymap[XK_KP_6&0xFF] = key_kp6;
119 m_keymap[XK_KP_7&0xFF] = key_kp7;
120 m_keymap[XK_KP_8&0xFF] = key_kp8;
121 m_keymap[XK_KP_9&0xFF] = key_kp9;
122
123 m_keymap[XK_KP_Insert&0xFF] = key_kp0;
124 m_keymap[XK_KP_End&0xFF] = key_kp1;
125 m_keymap[XK_KP_Down&0xFF] = key_kp2;
126 m_keymap[XK_KP_Page_Down&0xFF] = key_kp3;
127 m_keymap[XK_KP_Left&0xFF] = key_kp4;
128 m_keymap[XK_KP_Begin&0xFF] = key_kp5;
129 m_keymap[XK_KP_Right&0xFF] = key_kp6;
130 m_keymap[XK_KP_Home&0xFF] = key_kp7;
131 m_keymap[XK_KP_Up&0xFF] = key_kp8;
132 m_keymap[XK_KP_Page_Up&0xFF] = key_kp9;
133 m_keymap[XK_KP_Delete&0xFF] = key_kp_period;
134 m_keymap[XK_KP_Decimal&0xFF] = key_kp_period;
135 m_keymap[XK_KP_Divide&0xFF] = key_kp_divide;
136 m_keymap[XK_KP_Multiply&0xFF] = key_kp_multiply;
137 m_keymap[XK_KP_Subtract&0xFF] = key_kp_minus;
138 m_keymap[XK_KP_Add&0xFF] = key_kp_plus;
139 m_keymap[XK_KP_Enter&0xFF] = key_kp_enter;
140 m_keymap[XK_KP_Equal&0xFF] = key_kp_equals;
141
142 m_keymap[XK_Up&0xFF] = key_up;
143 m_keymap[XK_Down&0xFF] = key_down;
144 m_keymap[XK_Right&0xFF] = key_right;
145 m_keymap[XK_Left&0xFF] = key_left;
146 m_keymap[XK_Insert&0xFF] = key_insert;
147 m_keymap[XK_Home&0xFF] = key_delete;
148 m_keymap[XK_End&0xFF] = key_end;
149 m_keymap[XK_Page_Up&0xFF] = key_page_up;
150 m_keymap[XK_Page_Down&0xFF] = key_page_down;
151
152 m_keymap[XK_F1&0xFF] = key_f1;
153 m_keymap[XK_F2&0xFF] = key_f2;
154 m_keymap[XK_F3&0xFF] = key_f3;
155 m_keymap[XK_F4&0xFF] = key_f4;
156 m_keymap[XK_F5&0xFF] = key_f5;
157 m_keymap[XK_F6&0xFF] = key_f6;
158 m_keymap[XK_F7&0xFF] = key_f7;
159 m_keymap[XK_F8&0xFF] = key_f8;
160 m_keymap[XK_F9&0xFF] = key_f9;
161 m_keymap[XK_F10&0xFF] = key_f10;
162 m_keymap[XK_F11&0xFF] = key_f11;
163 m_keymap[XK_F12&0xFF] = key_f12;
164 m_keymap[XK_F13&0xFF] = key_f13;
165 m_keymap[XK_F14&0xFF] = key_f14;
166 m_keymap[XK_F15&0xFF] = key_f15;
167
168 m_keymap[XK_Num_Lock&0xFF] = key_numlock;
169 m_keymap[XK_Caps_Lock&0xFF] = key_capslock;
170 m_keymap[XK_Scroll_Lock&0xFF] = key_scrollock;
171
172 switch(m_format)
173 {
174 default: break;
175 case pix_format_gray8:
176 case pix_format_sgray8:
177 m_bpp = 8;
178 break;
179
180 case pix_format_gray16:
181 m_bpp = 16;
182 break;
183
184 case pix_format_gray32:
185 m_bpp = 32;
186 break;
187
188 case pix_format_rgb565:
189 case pix_format_rgb555:
190 m_bpp = 16;
191 break;
192
193 case pix_format_rgb24:
194 case pix_format_bgr24:
195 case pix_format_srgb24:
196 case pix_format_sbgr24:
197 m_bpp = 24;
198 break;
199
200 case pix_format_bgra32:
201 case pix_format_abgr32:
202 case pix_format_argb32:
203 case pix_format_rgba32:
204 case pix_format_sbgra32:
205 case pix_format_sabgr32:
206 case pix_format_sargb32:
207 case pix_format_srgba32:
208 m_bpp = 32;
209 break;
210
211 case pix_format_rgb48:
212 case pix_format_bgr48:
213 m_bpp = 48;
214 break;
215
216 case pix_format_bgra64:
217 case pix_format_abgr64:
218 case pix_format_argb64:
219 case pix_format_rgba64:
220 m_bpp = 64;
221 break;
222
223 case pix_format_rgb96:
224 case pix_format_bgr96:
225 m_bpp = 96;
226 break;
227
228 case pix_format_bgra128:
229 case pix_format_abgr128:
230 case pix_format_argb128:
231 case pix_format_rgba128:
232 m_bpp = 128;
233 break;
234 }
235 m_sw_start = std::clock();
236 }
237
238 //------------------------------------------------------------------------
239 platform_specific::~platform_specific()
240 {
241 }
242
243 //------------------------------------------------------------------------
244 void platform_specific::caption(const char* capt)
245 {
246 XTextProperty tp;
247 tp.value = (unsigned char *)capt;
248 tp.encoding = XA_WM_NAME;
249 tp.format = 8;
250 tp.nitems = std::strlen(capt);
251 XSetWMName(m_display, m_window, &tp);
252 XStoreName(m_display, m_window, capt);
253 XSetIconName(m_display, m_window, capt);
254 XSetWMIconName(m_display, m_window, &tp);
255 }
256
257
258 //------------------------------------------------------------------------
259 void platform_specific::put_image(const rendering_buffer* src)
260 {
261 if(m_ximg_window == 0) return;
262 m_ximg_window->data = (char*)m_buf_window;
263
264 if(m_format == m_sys_format)
265 {
266 XPutImage(m_display,
267 m_window,
268 m_gc,
269 m_ximg_window,
270 0, 0, 0, 0,
271 src->width(),
272 src->height());
273 }
274 else
275 {
276 int row_len = src->width() * m_sys_bpp / 8;
277 unsigned char* buf_tmp =
278 new unsigned char[row_len * src->height()];
279
280 rendering_buffer rbuf_tmp;
281 rbuf_tmp.attach(buf_tmp,
282 src->width(),
283 src->height(),
284 m_flip_y ? -row_len : row_len);
285
286 switch(m_sys_format)
287 {
288 default: break;
289 case pix_format_rgb555:
290 switch(m_format)
291 {
292 default: break;
293 case pix_format_rgb555: color_conv(&rbuf_tmp, src, color_conv_rgb555_to_rgb555()); break;
294 case pix_format_rgb565: color_conv(&rbuf_tmp, src, color_conv_rgb565_to_rgb555()); break;
295 case pix_format_rgb24: color_conv(&rbuf_tmp, src, color_conv_rgb24_to_rgb555()); break;
296 case pix_format_bgr24: color_conv(&rbuf_tmp, src, color_conv_bgr24_to_rgb555()); break;
297 case pix_format_rgba32: color_conv(&rbuf_tmp, src, color_conv_rgba32_to_rgb555()); break;
298 case pix_format_argb32: color_conv(&rbuf_tmp, src, color_conv_argb32_to_rgb555()); break;
299 case pix_format_bgra32: color_conv(&rbuf_tmp, src, color_conv_bgra32_to_rgb555()); break;
300 case pix_format_abgr32: color_conv(&rbuf_tmp, src, color_conv_abgr32_to_rgb555()); break;
301 }
302 break;
303
304 case pix_format_rgb565:
305 switch(m_format)
306 {
307 default: break;
308 case pix_format_rgb555: color_conv(&rbuf_tmp, src, color_conv_rgb555_to_rgb565()); break;
309 case pix_format_rgb565: color_conv(&rbuf_tmp, src, color_conv_rgb565_to_rgb565()); break;
310 case pix_format_rgb24: color_conv(&rbuf_tmp, src, color_conv_rgb24_to_rgb565()); break;
311 case pix_format_bgr24: color_conv(&rbuf_tmp, src, color_conv_bgr24_to_rgb565()); break;
312 case pix_format_rgba32: color_conv(&rbuf_tmp, src, color_conv_rgba32_to_rgb565()); break;
313 case pix_format_argb32: color_conv(&rbuf_tmp, src, color_conv_argb32_to_rgb565()); break;
314 case pix_format_bgra32: color_conv(&rbuf_tmp, src, color_conv_bgra32_to_rgb565()); break;
315 case pix_format_abgr32: color_conv(&rbuf_tmp, src, color_conv_abgr32_to_rgb565()); break;
316 }
317 break;
318
319 case pix_format_rgba32:
320 switch(m_format)
321 {
322 default: break;
323 case pix_format_sgray8: convert<pixfmt_srgba32, pixfmt_sgray8>(&rbuf_tmp, src); break;
324 case pix_format_gray8: convert<pixfmt_srgba32, pixfmt_gray8>(&rbuf_tmp, src); break;
325 case pix_format_gray16: convert<pixfmt_srgba32, pixfmt_gray16>(&rbuf_tmp, src); break;
326 case pix_format_gray32: convert<pixfmt_srgba32, pixfmt_gray32>(&rbuf_tmp, src); break;
327 case pix_format_rgb555: color_conv(&rbuf_tmp, src, color_conv_rgb555_to_rgba32()); break;
328 case pix_format_rgb565: color_conv(&rbuf_tmp, src, color_conv_rgb565_to_rgba32()); break;
329 case pix_format_srgb24: convert<pixfmt_srgba32, pixfmt_srgb24>(&rbuf_tmp, src); break;
330 case pix_format_sbgr24: convert<pixfmt_srgba32, pixfmt_sbgr24>(&rbuf_tmp, src); break;
331 case pix_format_rgb24: convert<pixfmt_srgba32, pixfmt_rgb24>(&rbuf_tmp, src); break;
332 case pix_format_bgr24: convert<pixfmt_srgba32, pixfmt_bgr24>(&rbuf_tmp, src); break;
333 case pix_format_srgba32: convert<pixfmt_srgba32, pixfmt_srgba32>(&rbuf_tmp, src); break;
334 case pix_format_sargb32: convert<pixfmt_srgba32, pixfmt_sargb32>(&rbuf_tmp, src); break;
335 case pix_format_sabgr32: convert<pixfmt_srgba32, pixfmt_sabgr32>(&rbuf_tmp, src); break;
336 case pix_format_sbgra32: convert<pixfmt_srgba32, pixfmt_sbgra32>(&rbuf_tmp, src); break;
337 case pix_format_rgba32: convert<pixfmt_srgba32, pixfmt_rgba32>(&rbuf_tmp, src); break;
338 case pix_format_argb32: convert<pixfmt_srgba32, pixfmt_argb32>(&rbuf_tmp, src); break;
339 case pix_format_abgr32: convert<pixfmt_srgba32, pixfmt_abgr32>(&rbuf_tmp, src); break;
340 case pix_format_bgra32: convert<pixfmt_srgba32, pixfmt_bgra32>(&rbuf_tmp, src); break;
341 case pix_format_rgb48: convert<pixfmt_srgba32, pixfmt_rgb48>(&rbuf_tmp, src); break;
342 case pix_format_bgr48: convert<pixfmt_srgba32, pixfmt_bgr48>(&rbuf_tmp, src); break;
343 case pix_format_rgba64: convert<pixfmt_srgba32, pixfmt_rgba64>(&rbuf_tmp, src); break;
344 case pix_format_argb64: convert<pixfmt_srgba32, pixfmt_argb64>(&rbuf_tmp, src); break;
345 case pix_format_abgr64: convert<pixfmt_srgba32, pixfmt_abgr64>(&rbuf_tmp, src); break;
346 case pix_format_bgra64: convert<pixfmt_srgba32, pixfmt_bgra64>(&rbuf_tmp, src); break;
347 case pix_format_rgb96: convert<pixfmt_srgba32, pixfmt_rgb96>(&rbuf_tmp, src); break;
348 case pix_format_bgr96: convert<pixfmt_srgba32, pixfmt_bgr96>(&rbuf_tmp, src); break;
349 case pix_format_rgba128: convert<pixfmt_srgba32, pixfmt_rgba128>(&rbuf_tmp, src); break;
350 case pix_format_argb128: convert<pixfmt_srgba32, pixfmt_argb128>(&rbuf_tmp, src); break;
351 case pix_format_abgr128: convert<pixfmt_srgba32, pixfmt_abgr128>(&rbuf_tmp, src); break;
352 case pix_format_bgra128: convert<pixfmt_srgba32, pixfmt_bgra128>(&rbuf_tmp, src); break;
353 }
354 break;
355
356 case pix_format_abgr32:
357 switch(m_format)
358 {
359 default: break;
360 case pix_format_sgray8: convert<pixfmt_sabgr32, pixfmt_sgray8>(&rbuf_tmp, src); break;
361 case pix_format_gray8: convert<pixfmt_sabgr32, pixfmt_gray8>(&rbuf_tmp, src); break;
362 case pix_format_gray16: convert<pixfmt_sabgr32, pixfmt_gray16>(&rbuf_tmp, src); break;
363 case pix_format_gray32: convert<pixfmt_sabgr32, pixfmt_gray32>(&rbuf_tmp, src); break;
364 case pix_format_rgb555: color_conv(&rbuf_tmp, src, color_conv_rgb555_to_abgr32()); break;
365 case pix_format_rgb565: color_conv(&rbuf_tmp, src, color_conv_rgb565_to_abgr32()); break;
366 case pix_format_srgb24: convert<pixfmt_sabgr32, pixfmt_srgb24>(&rbuf_tmp, src); break;
367 case pix_format_sbgr24: convert<pixfmt_sabgr32, pixfmt_sbgr24>(&rbuf_tmp, src); break;
368 case pix_format_rgb24: convert<pixfmt_sabgr32, pixfmt_rgb24>(&rbuf_tmp, src); break;
369 case pix_format_bgr24: convert<pixfmt_sabgr32, pixfmt_bgr24>(&rbuf_tmp, src); break;
370 case pix_format_srgba32: convert<pixfmt_sabgr32, pixfmt_srgba32>(&rbuf_tmp, src); break;
371 case pix_format_sargb32: convert<pixfmt_sabgr32, pixfmt_sargb32>(&rbuf_tmp, src); break;
372 case pix_format_sabgr32: convert<pixfmt_sabgr32, pixfmt_sabgr32>(&rbuf_tmp, src); break;
373 case pix_format_sbgra32: convert<pixfmt_sabgr32, pixfmt_sbgra32>(&rbuf_tmp, src); break;
374 case pix_format_rgba32: convert<pixfmt_sabgr32, pixfmt_rgba32>(&rbuf_tmp, src); break;
375 case pix_format_argb32: convert<pixfmt_sabgr32, pixfmt_argb32>(&rbuf_tmp, src); break;
376 case pix_format_abgr32: convert<pixfmt_sabgr32, pixfmt_abgr32>(&rbuf_tmp, src); break;
377 case pix_format_bgra32: convert<pixfmt_sabgr32, pixfmt_bgra32>(&rbuf_tmp, src); break;
378 case pix_format_rgb48: convert<pixfmt_sabgr32, pixfmt_rgb48>(&rbuf_tmp, src); break;
379 case pix_format_bgr48: convert<pixfmt_sabgr32, pixfmt_bgr48>(&rbuf_tmp, src); break;
380 case pix_format_rgba64: convert<pixfmt_sabgr32, pixfmt_rgba64>(&rbuf_tmp, src); break;
381 case pix_format_argb64: convert<pixfmt_sabgr32, pixfmt_argb64>(&rbuf_tmp, src); break;
382 case pix_format_abgr64: convert<pixfmt_sabgr32, pixfmt_abgr64>(&rbuf_tmp, src); break;
383 case pix_format_bgra64: convert<pixfmt_sabgr32, pixfmt_bgra64>(&rbuf_tmp, src); break;
384 case pix_format_rgb96: convert<pixfmt_sabgr32, pixfmt_rgb96>(&rbuf_tmp, src); break;
385 case pix_format_bgr96: convert<pixfmt_sabgr32, pixfmt_bgr96>(&rbuf_tmp, src); break;
386 case pix_format_rgba128: convert<pixfmt_sabgr32, pixfmt_rgba128>(&rbuf_tmp, src); break;
387 case pix_format_argb128: convert<pixfmt_sabgr32, pixfmt_argb128>(&rbuf_tmp, src); break;
388 case pix_format_abgr128: convert<pixfmt_sabgr32, pixfmt_abgr128>(&rbuf_tmp, src); break;
389 case pix_format_bgra128: convert<pixfmt_sabgr32, pixfmt_bgra128>(&rbuf_tmp, src); break;
390 }
391 break;
392
393 case pix_format_argb32:
394 switch(m_format)
395 {
396 default: break;
397 case pix_format_sgray8: convert<pixfmt_sargb32, pixfmt_sgray8>(&rbuf_tmp, src); break;
398 case pix_format_gray8: convert<pixfmt_sargb32, pixfmt_gray8>(&rbuf_tmp, src); break;
399 case pix_format_gray16: convert<pixfmt_sargb32, pixfmt_gray16>(&rbuf_tmp, src); break;
400 case pix_format_gray32: convert<pixfmt_sargb32, pixfmt_gray32>(&rbuf_tmp, src); break;
401 case pix_format_rgb555: color_conv(&rbuf_tmp, src, color_conv_rgb555_to_argb32()); break;
402 case pix_format_rgb565: color_conv(&rbuf_tmp, src, color_conv_rgb565_to_argb32()); break;
403 case pix_format_srgb24: convert<pixfmt_sargb32, pixfmt_srgb24>(&rbuf_tmp, src); break;
404 case pix_format_sbgr24: convert<pixfmt_sargb32, pixfmt_sbgr24>(&rbuf_tmp, src); break;
405 case pix_format_rgb24: convert<pixfmt_sargb32, pixfmt_rgb24>(&rbuf_tmp, src); break;
406 case pix_format_bgr24: convert<pixfmt_sargb32, pixfmt_bgr24>(&rbuf_tmp, src); break;
407 case pix_format_srgba32: convert<pixfmt_sargb32, pixfmt_srgba32>(&rbuf_tmp, src); break;
408 case pix_format_sargb32: convert<pixfmt_sargb32, pixfmt_sargb32>(&rbuf_tmp, src); break;
409 case pix_format_sabgr32: convert<pixfmt_sargb32, pixfmt_sabgr32>(&rbuf_tmp, src); break;
410 case pix_format_sbgra32: convert<pixfmt_sargb32, pixfmt_sbgra32>(&rbuf_tmp, src); break;
411 case pix_format_rgba32: convert<pixfmt_sargb32, pixfmt_rgba32>(&rbuf_tmp, src); break;
412 case pix_format_argb32: convert<pixfmt_sargb32, pixfmt_argb32>(&rbuf_tmp, src); break;
413 case pix_format_abgr32: convert<pixfmt_sargb32, pixfmt_abgr32>(&rbuf_tmp, src); break;
414 case pix_format_bgra32: convert<pixfmt_sargb32, pixfmt_bgra32>(&rbuf_tmp, src); break;
415 case pix_format_rgb48: convert<pixfmt_sargb32, pixfmt_rgb48>(&rbuf_tmp, src); break;
416 case pix_format_bgr48: convert<pixfmt_sargb32, pixfmt_bgr48>(&rbuf_tmp, src); break;
417 case pix_format_rgba64: convert<pixfmt_sargb32, pixfmt_rgba64>(&rbuf_tmp, src); break;
418 case pix_format_argb64: convert<pixfmt_sargb32, pixfmt_argb64>(&rbuf_tmp, src); break;
419 case pix_format_abgr64: convert<pixfmt_sargb32, pixfmt_abgr64>(&rbuf_tmp, src); break;
420 case pix_format_bgra64: convert<pixfmt_sargb32, pixfmt_bgra64>(&rbuf_tmp, src); break;
421 case pix_format_rgb96: convert<pixfmt_sargb32, pixfmt_rgb96>(&rbuf_tmp, src); break;
422 case pix_format_bgr96: convert<pixfmt_sargb32, pixfmt_bgr96>(&rbuf_tmp, src); break;
423 case pix_format_rgba128: convert<pixfmt_sargb32, pixfmt_rgba128>(&rbuf_tmp, src); break;
424 case pix_format_argb128: convert<pixfmt_sargb32, pixfmt_argb128>(&rbuf_tmp, src); break;
425 case pix_format_abgr128: convert<pixfmt_sargb32, pixfmt_abgr128>(&rbuf_tmp, src); break;
426 case pix_format_bgra128: convert<pixfmt_sargb32, pixfmt_bgra128>(&rbuf_tmp, src); break;
427 }
428 break;
429
430 case pix_format_bgra32:
431 switch(m_format)
432 {
433 default: break;
434 case pix_format_sgray8: convert<pixfmt_sbgra32, pixfmt_sgray8>(&rbuf_tmp, src); break;
435 case pix_format_gray8: convert<pixfmt_sbgra32, pixfmt_gray8>(&rbuf_tmp, src); break;
436 case pix_format_gray16: convert<pixfmt_sbgra32, pixfmt_gray16>(&rbuf_tmp, src); break;
437 case pix_format_gray32: convert<pixfmt_sbgra32, pixfmt_gray32>(&rbuf_tmp, src); break;
438 case pix_format_rgb555: color_conv(&rbuf_tmp, src, color_conv_rgb555_to_bgra32()); break;
439 case pix_format_rgb565: color_conv(&rbuf_tmp, src, color_conv_rgb565_to_bgra32()); break;
440 case pix_format_srgb24: convert<pixfmt_sbgra32, pixfmt_srgb24>(&rbuf_tmp, src); break;
441 case pix_format_sbgr24: convert<pixfmt_sbgra32, pixfmt_sbgr24>(&rbuf_tmp, src); break;
442 case pix_format_rgb24: convert<pixfmt_sbgra32, pixfmt_rgb24>(&rbuf_tmp, src); break;
443 case pix_format_bgr24: convert<pixfmt_sbgra32, pixfmt_bgr24>(&rbuf_tmp, src); break;
444 case pix_format_srgba32: convert<pixfmt_sbgra32, pixfmt_srgba32>(&rbuf_tmp, src); break;
445 case pix_format_sargb32: convert<pixfmt_sbgra32, pixfmt_sargb32>(&rbuf_tmp, src); break;
446 case pix_format_sabgr32: convert<pixfmt_sbgra32, pixfmt_sabgr32>(&rbuf_tmp, src); break;
447 case pix_format_sbgra32: convert<pixfmt_sbgra32, pixfmt_sbgra32>(&rbuf_tmp, src); break;
448 case pix_format_rgba32: convert<pixfmt_sbgra32, pixfmt_rgba32>(&rbuf_tmp, src); break;
449 case pix_format_argb32: convert<pixfmt_sbgra32, pixfmt_argb32>(&rbuf_tmp, src); break;
450 case pix_format_abgr32: convert<pixfmt_sbgra32, pixfmt_abgr32>(&rbuf_tmp, src); break;
451 case pix_format_bgra32: convert<pixfmt_sbgra32, pixfmt_bgra32>(&rbuf_tmp, src); break;
452 case pix_format_rgb48: convert<pixfmt_sbgra32, pixfmt_rgb48>(&rbuf_tmp, src); break;
453 case pix_format_bgr48: convert<pixfmt_sbgra32, pixfmt_bgr48>(&rbuf_tmp, src); break;
454 case pix_format_rgba64: convert<pixfmt_sbgra32, pixfmt_rgba64>(&rbuf_tmp, src); break;
455 case pix_format_argb64: convert<pixfmt_sbgra32, pixfmt_argb64>(&rbuf_tmp, src); break;
456 case pix_format_abgr64: convert<pixfmt_sbgra32, pixfmt_abgr64>(&rbuf_tmp, src); break;
457 case pix_format_bgra64: convert<pixfmt_sbgra32, pixfmt_bgra64>(&rbuf_tmp, src); break;
458 case pix_format_rgb96: convert<pixfmt_sbgra32, pixfmt_rgb96>(&rbuf_tmp, src); break;
459 case pix_format_bgr96: convert<pixfmt_sbgra32, pixfmt_bgr96>(&rbuf_tmp, src); break;
460 case pix_format_rgba128: convert<pixfmt_sbgra32, pixfmt_rgba128>(&rbuf_tmp, src); break;
461 case pix_format_argb128: convert<pixfmt_sbgra32, pixfmt_argb128>(&rbuf_tmp, src); break;
462 case pix_format_abgr128: convert<pixfmt_sbgra32, pixfmt_abgr128>(&rbuf_tmp, src); break;
463 case pix_format_bgra128: convert<pixfmt_sbgra32, pixfmt_bgra128>(&rbuf_tmp, src); break;
464 }
465 break;
466 }
467
468 m_ximg_window->data = (char*)buf_tmp;
469 XPutImage(m_display,
470 m_window,
471 m_gc,
472 m_ximg_window,
473 0, 0, 0, 0,
474 src->width(),
475 src->height());
476
477 delete [] buf_tmp;
478 }
479 }
480
481
482 //------------------------------------------------------------------------
483 platform_support::platform_support(pix_format_e format, bool flip_y) :
484 m_specific(new platform_specific(format, flip_y)),
485 m_format(format),
486 m_bpp(m_specific->m_bpp),
487 m_window_flags(0),
488 m_wait_mode(true),
489 m_flip_y(flip_y),
490 m_initial_width(10),
491 m_initial_height(10)
492 {
493 std::strcpy(m_caption, "AGG Application");
494 }
495
496 //------------------------------------------------------------------------
497 platform_support::~platform_support()
498 {
499 delete m_specific;
500 }
501
502
503
504 //------------------------------------------------------------------------
505 void platform_support::caption(const char* cap)
506 {
507 std::strcpy(m_caption, cap);
508 if(m_specific->m_initialized)
509 {
510 m_specific->caption(cap);
511 }
512 }
513
514
515 //------------------------------------------------------------------------
516 enum xevent_mask_e
517 {
518 xevent_mask =
519 PointerMotionMask|
520 ButtonPressMask|
521 ButtonReleaseMask|
522 ExposureMask|
523 KeyPressMask|
524 StructureNotifyMask
525 };
526
527
528 //------------------------------------------------------------------------
529 bool platform_support::init(unsigned width, unsigned height, unsigned flags)
530 {
531 m_window_flags = flags;
532
533 m_specific->m_display = XOpenDisplay(NULL);
534 if(m_specific->m_display == 0)
535 {
536 std::fprintf(stderr, "Unable to open DISPLAY!\n");
537 return false;
538 }
539
540 m_specific->m_screen = XDefaultScreen(m_specific->m_display);
541 m_specific->m_depth = XDefaultDepth(m_specific->m_display,
542 m_specific->m_screen);
543 m_specific->m_visual = XDefaultVisual(m_specific->m_display,
544 m_specific->m_screen);
545 unsigned long r_mask = m_specific->m_visual->red_mask;
546 unsigned long g_mask = m_specific->m_visual->green_mask;
547 unsigned long b_mask = m_specific->m_visual->blue_mask;
548
549 //std::printf("depth=%d, red=%08x, green=%08x, blue=%08x\n",
550 // m_specific->m_depth,
551 // m_specific->m_visual->red_mask,
552 // m_specific->m_visual->green_mask,
553 // m_specific->m_visual->blue_mask);
554
555
556 // // NOT COMPLETED YET!
557 // // Try to find an appropriate Visual if the default doesn't fit.
558 // if(m_specific->m_depth < 15 ||
559 // r_mask == 0 || g_mask == 0 || b_mask == 0)
560 // {
561 //
562 // // This is an attempt to find an appropriate Visual if
563 // // the default one doesn't match the minumum requirements
564 // static int depth[] = { 32, 24, 16, 15 };
565 // int i;
566 // for(int i = 0; i < 4; i++)
567 // {
568 // XVisualInfo vi;
569 // if(XMatchVisualInfo(m_specific->m_display,
570 // m_specific->m_screen,
571 // depth[i],
572 // TrueColor,
573 // &vi))
574 // {
575 // // std::printf("TrueColor depth=%d, red=%08x, green=%08x, blue=%08x, bits=%d\n",
576 // // vi.depth,
577 // // vi.visual->red_mask,
578 // // vi.visual->green_mask,
579 // // vi.visual->blue_mask,
580 // // vi.bits_per_rgb);
581 // m_specific->m_depth = vi.depth;
582 // m_specific->m_visual = vi.visual;
583 // r_mask = m_specific->m_visual->red_mask;
584 // g_mask = m_specific->m_visual->green_mask;
585 // b_mask = m_specific->m_visual->blue_mask;
586 // break;
587 // }
588 // if(XMatchVisualInfo(m_specific->m_display,
589 // m_specific->m_screen,
590 // depth[i],
591 // DirectColor,
592 // &vi))
593 // {
594 // // std::printf("DirectColor depth=%d, red=%08x, green=%08x, blue=%08x, bits=%d\n",
595 // // vi.depth,
596 // // vi.visual->red_mask,
597 // // vi.visual->green_mask,
598 // // vi.visual->blue_mask,
599 // // vi.bits_per_rgb);
600 // m_specific->m_depth = vi.depth;
601 // m_specific->m_visual = vi.visual;
602 // r_mask = m_specific->m_visual->red_mask;
603 // g_mask = m_specific->m_visual->green_mask;
604 // b_mask = m_specific->m_visual->blue_mask;
605 // break;
606 // }
607 // }
608 // }
609
610 if(m_specific->m_depth < 15 ||
611 r_mask == 0 || g_mask == 0 || b_mask == 0)
612 {
613 std::fprintf(stderr,
614 "There's no Visual compatible with minimal AGG requirements:\n"
615 "At least 15-bit color depth and True- or DirectColor class.\n\n");
616 XCloseDisplay(m_specific->m_display);
617 return false;
618 }
619
620 int t = 1;
621 int hw_byte_order = LSBFirst;
622 if(*(char*)&t == 0) hw_byte_order = MSBFirst;
623
624 // Perceive SYS-format by mask
625 switch(m_specific->m_depth)
626 {
627 case 15:
628 m_specific->m_sys_bpp = 16;
629 if(r_mask == 0x7C00 && g_mask == 0x3E0 && b_mask == 0x1F)
630 {
631 m_specific->m_sys_format = pix_format_rgb555;
632 m_specific->m_byte_order = hw_byte_order;
633 }
634 break;
635
636 case 16:
637 m_specific->m_sys_bpp = 16;
638 if(r_mask == 0xF800 && g_mask == 0x7E0 && b_mask == 0x1F)
639 {
640 m_specific->m_sys_format = pix_format_rgb565;
641 m_specific->m_byte_order = hw_byte_order;
642 }
643 break;
644
645 case 24:
646 case 32:
647 m_specific->m_sys_bpp = 32;
648 if(g_mask == 0xFF00)
649 {
650 if(r_mask == 0xFF && b_mask == 0xFF0000)
651 {
652 switch(m_specific->m_format)
653 {
654 case pix_format_rgba32:
655 m_specific->m_sys_format = pix_format_rgba32;
656 m_specific->m_byte_order = LSBFirst;
657 break;
658
659 case pix_format_abgr32:
660 m_specific->m_sys_format = pix_format_abgr32;
661 m_specific->m_byte_order = MSBFirst;
662 break;
663
664 default:
665 m_specific->m_byte_order = hw_byte_order;
666 m_specific->m_sys_format =
667 (hw_byte_order == LSBFirst) ?
668 pix_format_rgba32 :
669 pix_format_abgr32;
670 break;
671 }
672 }
673
674 if(r_mask == 0xFF0000 && b_mask == 0xFF)
675 {
676 switch(m_specific->m_format)
677 {
678 case pix_format_argb32:
679 m_specific->m_sys_format = pix_format_argb32;
680 m_specific->m_byte_order = MSBFirst;
681 break;
682
683 case pix_format_bgra32:
684 m_specific->m_sys_format = pix_format_bgra32;
685 m_specific->m_byte_order = LSBFirst;
686 break;
687
688 default:
689 m_specific->m_byte_order = hw_byte_order;
690 m_specific->m_sys_format =
691 (hw_byte_order == MSBFirst) ?
692 pix_format_argb32 :
693 pix_format_bgra32;
694 break;
695 }
696 }
697 }
698 break;
699 }
700
701 if(m_specific->m_sys_format == pix_format_undefined)
702 {
703 std::fprintf(stderr,
704 "RGB masks are not compatible with AGG pixel formats:\n"
705 "R=%08lx, R=%08lx, B=%08lx\n", r_mask, g_mask, b_mask);
706 XCloseDisplay(m_specific->m_display);
707 return false;
708 }
709
710
711
712 std::memset(&m_specific->m_window_attributes,
713 0,
714 sizeof(m_specific->m_window_attributes));
715
716 m_specific->m_window_attributes.border_pixel =
717 XBlackPixel(m_specific->m_display, m_specific->m_screen);
718
719 m_specific->m_window_attributes.background_pixel =
720 XWhitePixel(m_specific->m_display, m_specific->m_screen);
721
722 m_specific->m_window_attributes.override_redirect = 0;
723
724 unsigned long window_mask = CWBackPixel | CWBorderPixel;
725
726 m_specific->m_window =
727 XCreateWindow(m_specific->m_display,
728 XDefaultRootWindow(m_specific->m_display),
729 0, 0,
730 width,
731 height,
732 0,
733 m_specific->m_depth,
734 InputOutput,
735 CopyFromParent,
736 window_mask,
737 &m_specific->m_window_attributes);
738
739
740 m_specific->m_gc = XCreateGC(m_specific->m_display,
741 m_specific->m_window,
742 0, 0);
743 m_specific->m_buf_window =
744 new unsigned char[width * height * (m_bpp / 8)];
745
746 std::memset(m_specific->m_buf_window, 255, width * height * (m_bpp / 8));
747
748 m_rbuf_window.attach(m_specific->m_buf_window,
749 width,
750 height,
751 m_flip_y ? -width * (m_bpp / 8) : width * (m_bpp / 8));
752
753 m_specific->m_ximg_window =
754 XCreateImage(m_specific->m_display,
755 m_specific->m_visual, //CopyFromParent,
756 m_specific->m_depth,
757 ZPixmap,
758 0,
759 (char*)m_specific->m_buf_window,
760 width,
761 height,
762 m_specific->m_sys_bpp,
763 width * (m_specific->m_sys_bpp / 8));
764 m_specific->m_ximg_window->byte_order = m_specific->m_byte_order;
765
766 m_specific->caption(m_caption);
767 m_initial_width = width;
768 m_initial_height = height;
769
770 if(!m_specific->m_initialized)
771 {
772 on_init();
773 m_specific->m_initialized = true;
774 }
775
776 trans_affine_resizing(width, height);
777 on_resize(width, height);
778 m_specific->m_update_flag = true;
779
780 XSizeHints *hints = XAllocSizeHints();
781 if(hints)
782 {
783 if(flags & window_resize)
784 {
785 hints->min_width = 32;
786 hints->min_height = 32;
787 hints->max_width = 4096;
788 hints->max_height = 4096;
789 }
790 else
791 {
792 hints->min_width = width;
793 hints->min_height = height;
794 hints->max_width = width;
795 hints->max_height = height;
796 }
797 hints->flags = PMaxSize | PMinSize;
798
799 XSetWMNormalHints(m_specific->m_display,
800 m_specific->m_window,
801 hints);
802
803 XFree(hints);
804 }
805
806
807 XMapWindow(m_specific->m_display,
808 m_specific->m_window);
809
810 XSelectInput(m_specific->m_display,
811 m_specific->m_window,
812 xevent_mask);
813
814
815 m_specific->m_close_atom = XInternAtom(m_specific->m_display,
816 "WM_DELETE_WINDOW",
817 false);
818
819 XSetWMProtocols(m_specific->m_display,
820 m_specific->m_window,
821 &m_specific->m_close_atom,
822 1);
823
824 return true;
825 }
826
827
828
829 //------------------------------------------------------------------------
830 void platform_support::update_window()
831 {
832 m_specific->put_image(&m_rbuf_window);
833
834 // When m_wait_mode is true we can discard all the events
835 // came while the image is being drawn. In this case
836 // the X server does not accumulate mouse motion events.
837 // When m_wait_mode is false, i.e. we have some idle drawing
838 // we cannot afford to miss any events
839 XSync(m_specific->m_display, m_wait_mode);
840 }
841
842
843 //------------------------------------------------------------------------
844 int platform_support::run()
845 {
846 XFlush(m_specific->m_display);
847
848 bool quit = false;
849 unsigned flags;
850 int cur_x;
851 int cur_y;
852
853 while(!quit)
854 {
855 if(m_specific->m_update_flag)
856 {
857 on_draw();
858 update_window();
859 m_specific->m_update_flag = false;
860 }
861
862 if(!m_wait_mode)
863 {
864 if(XPending(m_specific->m_display) == 0)
865 {
866 on_idle();
867 continue;
868 }
869 }
870
871 XEvent x_event;
872 XNextEvent(m_specific->m_display, &x_event);
873
874 // In the Idle mode discard all intermediate MotionNotify events
875 if(!m_wait_mode && x_event.type == MotionNotify)
876 {
877 XEvent te = x_event;
878 for(;;)
879 {
880 if(XPending(m_specific->m_display) == 0) break;
881 XNextEvent(m_specific->m_display, &te);
882 if(te.type != MotionNotify) break;
883 }
884 x_event = te;
885 }
886
887 switch(x_event.type)
888 {
889 case ConfigureNotify:
890 {
891 if(x_event.xconfigure.width != int(m_rbuf_window.width()) ||
892 x_event.xconfigure.height != int(m_rbuf_window.height()))
893 {
894 int width = x_event.xconfigure.width;
895 int height = x_event.xconfigure.height;
896
897 delete [] m_specific->m_buf_window;
898 m_specific->m_ximg_window->data = 0;
899 XDestroyImage(m_specific->m_ximg_window);
900
901 m_specific->m_buf_window =
902 new unsigned char[width * height * (m_bpp / 8)];
903
904 m_rbuf_window.attach(m_specific->m_buf_window,
905 width,
906 height,
907 m_flip_y ?
908 -width * (m_bpp / 8) :
909 width * (m_bpp / 8));
910
911 m_specific->m_ximg_window =
912 XCreateImage(m_specific->m_display,
913 m_specific->m_visual, //CopyFromParent,
914 m_specific->m_depth,
915 ZPixmap,
916 0,
917 (char*)m_specific->m_buf_window,
918 width,
919 height,
920 m_specific->m_sys_bpp,
921 width * (m_specific->m_sys_bpp / 8));
922 m_specific->m_ximg_window->byte_order = m_specific->m_byte_order;
923
924 trans_affine_resizing(width, height);
925 on_resize(width, height);
926 on_draw();
927 update_window();
928 }
929 }
930 break;
931
932 case Expose:
933 m_specific->put_image(&m_rbuf_window);
934 XFlush(m_specific->m_display);
935 XSync(m_specific->m_display, false);
936 break;
937
938 case KeyPress:
939 {
940 KeySym key = XLookupKeysym(&x_event.xkey, 0);
941 flags = 0;
942 if(x_event.xkey.state & Button1Mask) flags |= mouse_left;
943 if(x_event.xkey.state & Button3Mask) flags |= mouse_right;
944 if(x_event.xkey.state & ShiftMask) flags |= kbd_shift;
945 if(x_event.xkey.state & ControlMask) flags |= kbd_ctrl;
946
947 bool left = false;
948 bool up = false;
949 bool right = false;
950 bool down = false;
951
952 switch(m_specific->m_keymap[key & 0xFF])
953 {
954 case key_left:
955 left = true;
956 break;
957
958 case key_up:
959 up = true;
960 break;
961
962 case key_right:
963 right = true;
964 break;
965
966 case key_down:
967 down = true;
968 break;
969
970 case key_f2:
971 copy_window_to_img(max_images - 1);
972 save_img(max_images - 1, "screenshot");
973 break;
974 }
975
976 if(m_ctrls.on_arrow_keys(left, right, down, up))
977 {
978 on_ctrl_change();
979 force_redraw();
980 }
981 else
982 {
983 on_key(x_event.xkey.x,
984 m_flip_y ?
985 m_rbuf_window.height() - x_event.xkey.y :
986 x_event.xkey.y,
987 m_specific->m_keymap[key & 0xFF],
988 flags);
989 }
990 }
991 break;
992
993
994 case ButtonPress:
995 {
996 flags = 0;
997 if(x_event.xbutton.state & ShiftMask) flags |= kbd_shift;
998 if(x_event.xbutton.state & ControlMask) flags |= kbd_ctrl;
999 if(x_event.xbutton.button == Button1) flags |= mouse_left;
1000 if(x_event.xbutton.button == Button3) flags |= mouse_right;
1001
1002 cur_x = x_event.xbutton.x;
1003 cur_y = m_flip_y ? m_rbuf_window.height() - x_event.xbutton.y :
1004 x_event.xbutton.y;
1005
1006 if(flags & mouse_left)
1007 {
1008 if(m_ctrls.on_mouse_button_down(cur_x, cur_y))
1009 {
1010 m_ctrls.set_cur(cur_x, cur_y);
1011 on_ctrl_change();
1012 force_redraw();
1013 }
1014 else
1015 {
1016 if(m_ctrls.in_rect(cur_x, cur_y))
1017 {
1018 if(m_ctrls.set_cur(cur_x, cur_y))
1019 {
1020 on_ctrl_change();
1021 force_redraw();
1022 }
1023 }
1024 else
1025 {
1026 on_mouse_button_down(cur_x, cur_y, flags);
1027 }
1028 }
1029 }
1030 if(flags & mouse_right)
1031 {
1032 on_mouse_button_down(cur_x, cur_y, flags);
1033 }
1034 //m_specific->m_wait_mode = m_wait_mode;
1035 //m_wait_mode = true;
1036 }
1037 break;
1038
1039
1040 case MotionNotify:
1041 {
1042 flags = 0;
1043 if(x_event.xmotion.state & Button1Mask) flags |= mouse_left;
1044 if(x_event.xmotion.state & Button3Mask) flags |= mouse_right;
1045 if(x_event.xmotion.state & ShiftMask) flags |= kbd_shift;
1046 if(x_event.xmotion.state & ControlMask) flags |= kbd_ctrl;
1047
1048 cur_x = x_event.xbutton.x;
1049 cur_y = m_flip_y ? m_rbuf_window.height() - x_event.xbutton.y :
1050 x_event.xbutton.y;
1051
1052 if(m_ctrls.on_mouse_move(cur_x, cur_y, (flags & mouse_left) != 0))
1053 {
1054 on_ctrl_change();
1055 force_redraw();
1056 }
1057 else
1058 {
1059 if(!m_ctrls.in_rect(cur_x, cur_y))
1060 {
1061 on_mouse_move(cur_x, cur_y, flags);
1062 }
1063 }
1064 }
1065 break;
1066
1067 case ButtonRelease:
1068 {
1069 flags = 0;
1070 if(x_event.xbutton.state & ShiftMask) flags |= kbd_shift;
1071 if(x_event.xbutton.state & ControlMask) flags |= kbd_ctrl;
1072 if(x_event.xbutton.button == Button1) flags |= mouse_left;
1073 if(x_event.xbutton.button == Button3) flags |= mouse_right;
1074
1075 cur_x = x_event.xbutton.x;
1076 cur_y = m_flip_y ? m_rbuf_window.height() - x_event.xbutton.y :
1077 x_event.xbutton.y;
1078
1079 if(flags & mouse_left)
1080 {
1081 if(m_ctrls.on_mouse_button_up(cur_x, cur_y))
1082 {
1083 on_ctrl_change();
1084 force_redraw();
1085 }
1086 }
1087 if(flags & (mouse_left | mouse_right))
1088 {
1089 on_mouse_button_up(cur_x, cur_y, flags);
1090 }
1091 }
1092 //m_wait_mode = m_specific->m_wait_mode;
1093 break;
1094
1095 case ClientMessage:
1096 if((x_event.xclient.format == 32) &&
1097 (x_event.xclient.data.l[0] == int(m_specific->m_close_atom)))
1098 {
1099 quit = true;
1100 }
1101 break;
1102 }
1103 }
1104
1105
1106 unsigned i = platform_support::max_images;
1107 while(i--)
1108 {
1109 if(m_specific->m_buf_img[i])
1110 {
1111 delete [] m_specific->m_buf_img[i];
1112 }
1113 }
1114
1115 delete [] m_specific->m_buf_window;
1116 m_specific->m_ximg_window->data = 0;
1117 XDestroyImage(m_specific->m_ximg_window);
1118 XFreeGC(m_specific->m_display, m_specific->m_gc);
1119 XDestroyWindow(m_specific->m_display, m_specific->m_window);
1120 XCloseDisplay(m_specific->m_display);
1121
1122 return 0;
1123 }
1124
1125
1126
1127 //------------------------------------------------------------------------
1128 const char* platform_support::img_ext() const { return ".ppm"; }
1129
1130 //------------------------------------------------------------------------
1131 const char* platform_support::full_file_name(const char* file_name)
1132 {
1133 return file_name;
1134 }
1135
1136 //------------------------------------------------------------------------
1137 bool platform_support::load_img(unsigned idx, const char* file)
1138 {
1139 if(idx < max_images)
1140 {
1141 char buf[1024];
1142 std::strcpy(buf, file);
1143 int len = std::strlen(buf);
1144 if(len < 4 || strcasecmp(buf + len - 4, ".ppm") != 0)
1145 {
1146 std::strcat(buf, ".ppm");
1147 }
1148
1149 FILE* fd = std::fopen(buf, "rb");
1150 if(fd == 0) return false;
1151
1152 if((len = std::fread(buf, 1, 1022, fd)) == 0)
1153 {
1154 fclose(fd);
1155 return false;
1156 }
1157 buf[len] = 0;
1158
1159 if(buf[0] != 'P' && buf[1] != '6')
1160 {
1161 std::fclose(fd);
1162 return false;
1163 }
1164
1165 char* ptr = buf + 2;
1166
1167 while(*ptr && !std::isdigit((unsigned char)(*ptr))) ptr++;
1168 if(*ptr == 0)
1169 {
1170 std::fclose(fd);
1171 return false;
1172 }
1173
1174 unsigned width = std::atoi(ptr);
1175 if(width == 0 || width > 4096)
1176 {
1177 std::fclose(fd);
1178 return false;
1179 }
1180 while(*ptr && isdigit((unsigned char)(*ptr))) ptr++;
1181 while(*ptr && !isdigit((unsigned char)(*ptr))) ptr++;
1182 if(*ptr == 0)
1183 {
1184 std::fclose(fd);
1185 return false;
1186 }
1187 unsigned height = std::atoi(ptr);
1188 if(height == 0 || height > 4096)
1189 {
1190 std::fclose(fd);
1191 return false;
1192 }
1193 while(*ptr && isdigit((unsigned char)(*ptr))) ptr++;
1194 while(*ptr && !isdigit((unsigned char)(*ptr))) ptr++;
1195 if(std::atoi(ptr) != 255)
1196 {
1197 std::fclose(fd);
1198 return false;
1199 }
1200 while(*ptr && isdigit((unsigned char)(*ptr))) ptr++;
1201 if(*ptr == 0)
1202 {
1203 std::fclose(fd);
1204 return false;
1205 }
1206 ptr++;
1207 std::fseek(fd, long(ptr - buf), SEEK_SET);
1208
1209 create_img(idx, width, height);
1210 bool ret = true;
1211
1212 if(m_format == pix_format_rgb24)
1213 {
1214 std::size_t sz = std::fread(m_specific->m_buf_img[idx], 1, width * height * 3, fd);
1215 if (sz != width * height * 3)
1216 ret = false;
1217 }
1218 else
1219 {
1220 unsigned char* buf_img = new unsigned char [width * height * 3];
1221 rendering_buffer rbuf_img;
1222 rbuf_img.attach(buf_img,
1223 width,
1224 height,
1225 m_flip_y ?
1226 -width * 3 :
1227 width * 3);
1228
1229 std::size_t sz = std::fread(buf_img, 1, width * height * 3, fd);
1230 if (sz != width * height * 3)
1231 ret = false;
1232
1233 switch(m_format)
1234 {
1235 case pix_format_sgray8:
1236 convert<pixfmt_sgray8, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1237 break;
1238
1239 case pix_format_gray8:
1240 convert<pixfmt_gray8, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1241 break;
1242
1243 case pix_format_gray16:
1244 convert<pixfmt_gray16, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1245 break;
1246
1247 case pix_format_gray32:
1248 convert<pixfmt_gray32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1249 break;
1250
1251 case pix_format_rgb555:
1252 color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgb555());
1253 break;
1254
1255 case pix_format_rgb565:
1256 color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgb565());
1257 break;
1258
1259 case pix_format_sbgr24:
1260 convert<pixfmt_sbgr24, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1261 break;
1262
1263 case pix_format_rgb24:
1264 convert<pixfmt_rgb24, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1265 break;
1266
1267 case pix_format_bgr24:
1268 convert<pixfmt_bgr24, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1269 break;
1270
1271 case pix_format_srgba32:
1272 convert<pixfmt_srgba32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1273 break;
1274
1275 case pix_format_sargb32:
1276 convert<pixfmt_sargb32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1277 break;
1278
1279 case pix_format_sbgra32:
1280 convert<pixfmt_sbgra32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1281 break;
1282
1283 case pix_format_sabgr32:
1284 convert<pixfmt_sabgr32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1285 break;
1286
1287 case pix_format_rgba32:
1288 convert<pixfmt_rgba32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1289 break;
1290
1291 case pix_format_argb32:
1292 convert<pixfmt_argb32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1293 break;
1294
1295 case pix_format_bgra32:
1296 convert<pixfmt_bgra32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1297 break;
1298
1299 case pix_format_abgr32:
1300 convert<pixfmt_abgr32, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1301 break;
1302
1303 case pix_format_rgb48:
1304 convert<pixfmt_rgb48, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1305 break;
1306
1307 case pix_format_bgr48:
1308 convert<pixfmt_bgr48, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1309 break;
1310
1311 case pix_format_rgba64:
1312 convert<pixfmt_rgba64, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1313 break;
1314
1315 case pix_format_argb64:
1316 convert<pixfmt_argb64, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1317 break;
1318
1319 case pix_format_bgra64:
1320 convert<pixfmt_bgra64, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1321 break;
1322
1323 case pix_format_abgr64:
1324 convert<pixfmt_abgr64, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1325 break;
1326
1327 case pix_format_rgb96:
1328 convert<pixfmt_rgb96, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1329 break;
1330
1331 case pix_format_bgr96:
1332 convert<pixfmt_bgr96, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1333 break;
1334
1335 case pix_format_rgba128:
1336 convert<pixfmt_rgba128, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1337 break;
1338
1339 case pix_format_argb128:
1340 convert<pixfmt_argb128, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1341 break;
1342
1343 case pix_format_bgra128:
1344 convert<pixfmt_bgra128, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1345 break;
1346
1347 case pix_format_abgr128:
1348 convert<pixfmt_abgr128, pixfmt_srgb24>(m_rbuf_img+idx, &rbuf_img);
1349 break;
1350
1351 default:
1352 ret = false;
1353 }
1354 delete [] buf_img;
1355 }
1356
1357 std::fclose(fd);
1358 return ret;
1359 }
1360 return false;
1361 }
1362
1363
1364
1365
1366 //------------------------------------------------------------------------
1367 bool platform_support::save_img(unsigned idx, const char* file)
1368 {
1369 if(idx < max_images && rbuf_img(idx).buf())
1370 {
1371 char buf[1024];
1372 std::strcpy(buf, file);
1373 int len = std::strlen(buf);
1374 if(len < 4 || strcasecmp(buf + len - 4, ".ppm") != 0)
1375 {
1376 std::strcat(buf, ".ppm");
1377 }
1378
1379 FILE* fd = std::fopen(buf, "wb");
1380 if(fd == 0) return false;
1381
1382 unsigned w = rbuf_img(idx).width();
1383 unsigned h = rbuf_img(idx).height();
1384
1385 std::fprintf(fd, "P6\n%d %d\n255\n", w, h);
1386
1387 unsigned y;
1388 unsigned char* tmp_buf = new unsigned char [w * 3];
1389 for(y = 0; y < rbuf_img(idx).height(); y++)
1390 {
1391 const unsigned char* src = rbuf_img(idx).row_ptr(m_flip_y ? h - 1 - y : y);
1392 switch(m_format)
1393 {
1394 case pix_format_sgray8:
1395 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_sgray8>());
1396 break;
1397
1398 case pix_format_gray8:
1399 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_gray8>());
1400 break;
1401
1402 case pix_format_gray16:
1403 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_gray16>());
1404 break;
1405
1406 case pix_format_gray32:
1407 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_gray32>());
1408 break;
1409
1410 default: break;
1411 case pix_format_rgb555:
1412 color_conv_row(tmp_buf, src, w, color_conv_rgb555_to_rgb24());
1413 break;
1414
1415 case pix_format_rgb565:
1416 color_conv_row(tmp_buf, src, w, color_conv_rgb565_to_rgb24());
1417 break;
1418
1419 case pix_format_sbgr24:
1420 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_sbgr24>());
1421 break;
1422
1423 case pix_format_srgb24:
1424 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_srgb24>());
1425 break;
1426
1427 case pix_format_bgr24:
1428 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_bgr24>());
1429 break;
1430
1431 case pix_format_rgb24:
1432 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_rgb24>());
1433 break;
1434
1435 case pix_format_srgba32:
1436 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_srgba32>());
1437 break;
1438
1439 case pix_format_sargb32:
1440 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_sargb32>());
1441 break;
1442
1443 case pix_format_sbgra32:
1444 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_sbgra32>());
1445 break;
1446
1447 case pix_format_sabgr32:
1448 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_sabgr32>());
1449 break;
1450
1451 case pix_format_rgba32:
1452 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_rgba32>());
1453 break;
1454
1455 case pix_format_argb32:
1456 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_argb32>());
1457 break;
1458
1459 case pix_format_bgra32:
1460 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_bgra32>());
1461 break;
1462
1463 case pix_format_abgr32:
1464 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_abgr32>());
1465 break;
1466
1467 case pix_format_bgr48:
1468 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_bgr48>());
1469 break;
1470
1471 case pix_format_rgb48:
1472 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_rgb48>());
1473 break;
1474
1475 case pix_format_rgba64:
1476 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_rgba64>());
1477 break;
1478
1479 case pix_format_argb64:
1480 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_argb64>());
1481 break;
1482
1483 case pix_format_bgra64:
1484 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_bgra64>());
1485 break;
1486
1487 case pix_format_abgr64:
1488 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_abgr64>());
1489 break;
1490
1491 case pix_format_bgr96:
1492 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_bgr96>());
1493 break;
1494
1495 case pix_format_rgb96:
1496 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_rgb96>());
1497 break;
1498
1499 case pix_format_rgba128:
1500 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_rgba128>());
1501 break;
1502
1503 case pix_format_argb128:
1504 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_argb128>());
1505 break;
1506
1507 case pix_format_bgra128:
1508 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_bgra128>());
1509 break;
1510
1511 case pix_format_abgr128:
1512 color_conv_row(tmp_buf, src, w, conv_row<pixfmt_srgb24, pixfmt_abgr128>());
1513 break;
1514 }
1515 std::fwrite(tmp_buf, 1, w * 3, fd);
1516 }
1517 delete [] tmp_buf;
1518 std::fclose(fd);
1519 return true;
1520 }
1521 return false;
1522 }
1523
1524
1525
1526 //------------------------------------------------------------------------
1527 bool platform_support::create_img(unsigned idx, unsigned width, unsigned height)
1528 {
1529 if(idx < max_images)
1530 {
1531 if(width == 0) width = rbuf_window().width();
1532 if(height == 0) height = rbuf_window().height();
1533 delete [] m_specific->m_buf_img[idx];
1534 m_specific->m_buf_img[idx] =
1535 new unsigned char[width * height * (m_bpp / 8)];
1536
1537 m_rbuf_img[idx].attach(m_specific->m_buf_img[idx],
1538 width,
1539 height,
1540 m_flip_y ?
1541 -width * (m_bpp / 8) :
1542 width * (m_bpp / 8));
1543 return true;
1544 }
1545 return false;
1546 }
1547
1548
1549 //------------------------------------------------------------------------
1550 void platform_support::force_redraw()
1551 {
1552 m_specific->m_update_flag = true;
1553 }
1554
1555
1556 //------------------------------------------------------------------------
1557 void platform_support::message(const char* msg)
1558 {
1559 std::fprintf(stderr, "%s\n", msg);
1560 }
1561
1562 //------------------------------------------------------------------------
1563 void platform_support::start_timer()
1564 {
1565 m_specific->m_sw_start = clock();
1566 }
1567
1568 //------------------------------------------------------------------------
1569 double platform_support::elapsed_time() const
1570 {
1571 std::clock_t stop = std::clock();
1572 return double(stop - m_specific->m_sw_start) * 1000.0 / CLOCKS_PER_SEC;
1573 }
1574
1575
1576 //------------------------------------------------------------------------
1577 void platform_support::on_init() {}
1578 void platform_support::on_resize(int sx, int sy) {}
1579 void platform_support::on_idle() {}
1580 void platform_support::on_mouse_move(int x, int y, unsigned flags) {}
1581 void platform_support::on_mouse_button_down(int x, int y, unsigned flags) {}
1582 void platform_support::on_mouse_button_up(int x, int y, unsigned flags) {}
1583 void platform_support::on_key(int x, int y, unsigned key, unsigned flags) {}
1584 void platform_support::on_ctrl_change() {}
1585 void platform_support::on_draw() {}
1586 void platform_support::on_post_draw(void* raw_handler) {}
1587
1588
1589
1590 }
1591
1592
1593 int agg_main(int argc, char* argv[]);
1594
1595
1596 int main(int argc, char* argv[])
1597 {
1598 return agg_main(argc, argv);
1599 }
1600
1601
1602
1603
1604
1605