formatting agg::platform_support implementation code - gsl-shell.git - gsl-shell

diff --git a/agg-plot/agg_platform_support_win32.cpp b/agg-plot/agg_platform_support_win32.cpp
index 751ecca5..e096c82f 100644
--- a/agg-plot/agg_platform_support_win32.cpp
+++ b/agg-plot/agg_platform_support_win32.cpp

@@ -37,158 +37,158 @@ namespace agg

{

static inline void pixel_map_attach (pixel_map& pm, rendering_buffer *rbuf,

- bool flip_y)

+ bool flip_y)

{

int stride = pm.stride();

rbuf->attach(pm.buf(), pm.width(), pm.height(), flip_y ? stride : -stride);

}

- //------------------------------------------------------------------------

- HINSTANCE g_windows_instance = 0;

- int g_windows_cmd_show = 0;

+ //------------------------------------------------------------------------

+ HINSTANCE g_windows_instance = 0;

+ int g_windows_cmd_show = 0;

- //------------------------------------------------------------------------

- class platform_specific

- {

- public:

- platform_specific(pix_format_e format, bool flip_y);

- ~platform_specific();

-

- void create_pmap(unsigned width, unsigned height,

- rendering_buffer* wnd);

-

- void display_pmap(HDC dc, const rendering_buffer* src,

- const agg::rect_base<int> *rect = 0);

-

- bool load_pmap(const char* fn, unsigned idx,

- rendering_buffer* dst);

-

- bool save_pmap(const char* fn, unsigned idx,

- const rendering_buffer* src);

-

- void close();

-

- pix_format_e m_format;

- pix_format_e m_sys_format;

- bool m_flip_y;

- unsigned m_bpp;

- unsigned m_sys_bpp;

- HWND m_hwnd;

- pixel_map m_pmap_window;

- BITMAPINFO* m_bmp_draw;

- pixel_map m_pmap_img[platform_support::max_images];

- int m_cur_x;

- int m_cur_y;

- unsigned m_input_flags;

- bool m_redraw_flag;

- HDC m_current_dc;

- LARGE_INTEGER m_sw_freq;

- LARGE_INTEGER m_sw_start;

-

- bool m_is_mapped;

- bool m_is_ready;

-

- pthread_mutex_t m_mutex[1];

-

- static void bitmap_info_resize (BITMAPINFO* bmp, unsigned w, unsigned h);

- };

-

-

- //------------------------------------------------------------------------

- platform_specific::platform_specific(pix_format_e format, bool flip_y) :

- m_format(format),

- m_sys_format(pix_format_undefined),

- m_flip_y(flip_y),

- m_bpp(0),

- m_sys_bpp(0),

- m_hwnd(0),

- m_bmp_draw(0),

- m_cur_x(0),

- m_cur_y(0),

- m_input_flags(0),

- m_redraw_flag(true),

- m_current_dc(0),

- m_is_mapped(false),

- m_is_ready(false)

- {

+ //------------------------------------------------------------------------

+ class platform_specific

+ {

+ public:

+ platform_specific(pix_format_e format, bool flip_y);

+ ~platform_specific();

+

+ void create_pmap(unsigned width, unsigned height,

+ rendering_buffer* wnd);

+

+ void display_pmap(HDC dc, const rendering_buffer* src,

+ const agg::rect_base<int> *rect = 0);

+

+ bool load_pmap(const char* fn, unsigned idx,

+ rendering_buffer* dst);

+

+ bool save_pmap(const char* fn, unsigned idx,

+ const rendering_buffer* src);

+

+ void close();

+

+ pix_format_e m_format;

+ pix_format_e m_sys_format;

+ bool m_flip_y;

+ unsigned m_bpp;

+ unsigned m_sys_bpp;

+ HWND m_hwnd;

+ pixel_map m_pmap_window;

+ BITMAPINFO* m_bmp_draw;

+ pixel_map m_pmap_img[platform_support::max_images];

+ int m_cur_x;

+ int m_cur_y;

+ unsigned m_input_flags;

+ bool m_redraw_flag;

+ HDC m_current_dc;

+ LARGE_INTEGER m_sw_freq;

+ LARGE_INTEGER m_sw_start;

+

+ bool m_is_mapped;

+ bool m_is_ready;

+

+ pthread_mutex_t m_mutex[1];

+

+ static void bitmap_info_resize (BITMAPINFO* bmp, unsigned w, unsigned h);

+ };

- switch(m_format)

- {

- case pix_format_bw:

- m_sys_format = pix_format_bw;

- m_bpp = 1;

- m_sys_bpp = 1;

- break;

-

- case pix_format_gray8:

- m_sys_format = pix_format_gray8;

- m_bpp = 8;

- m_sys_bpp = 8;

- break;

-

- case pix_format_gray16:

- m_sys_format = pix_format_gray8;

- m_bpp = 16;

- m_sys_bpp = 8;

- break;

-

- case pix_format_rgb565:

- case pix_format_rgb555:

- m_sys_format = pix_format_rgb555;

- m_bpp = 16;

- m_sys_bpp = 16;

- break;

-

- case pix_format_rgbAAA:

- case pix_format_bgrAAA:

- case pix_format_rgbBBA:

- case pix_format_bgrABB:

- m_sys_format = pix_format_bgr24;

- m_bpp = 32;

- m_sys_bpp = 24;

- break;

-

- case pix_format_rgb24:

- case pix_format_bgr24:

- m_sys_format = pix_format_bgr24;

- m_bpp = 24;

- m_sys_bpp = 24;

- break;

-

- case pix_format_rgb48:

- case pix_format_bgr48:

- m_sys_format = pix_format_bgr24;

- m_bpp = 48;

- m_sys_bpp = 24;

- break;

-

- case pix_format_bgra32:

- case pix_format_abgr32:

- case pix_format_argb32:

- case pix_format_rgba32:

- m_sys_format = pix_format_bgra32;

- m_bpp = 32;

- m_sys_bpp = 32;

- break;

-

- case pix_format_bgra64:

- case pix_format_abgr64:

- case pix_format_argb64:

- case pix_format_rgba64:

- m_sys_format = pix_format_bgra32;

- m_bpp = 64;

- m_sys_bpp = 32;

- break;

-

- default:

- /* */;

- }

- ::QueryPerformanceFrequency(&m_sw_freq);

- ::QueryPerformanceCounter(&m_sw_start);

-

- pthread_mutex_init (m_mutex, NULL);

- }

+

+ //------------------------------------------------------------------------

+ platform_specific::platform_specific(pix_format_e format, bool flip_y) :

+ m_format(format),

+ m_sys_format(pix_format_undefined),

+ m_flip_y(flip_y),

+ m_bpp(0),

+ m_sys_bpp(0),

+ m_hwnd(0),

+ m_bmp_draw(0),

+ m_cur_x(0),

+ m_cur_y(0),

+ m_input_flags(0),

+ m_redraw_flag(true),

+ m_current_dc(0),

+ m_is_mapped(false),

+ m_is_ready(false)

+ {

+

+ switch(m_format)

+ {

+ case pix_format_bw:

+ m_sys_format = pix_format_bw;

+ m_bpp = 1;

+ m_sys_bpp = 1;

+ break;

+

+ case pix_format_gray8:

+ m_sys_format = pix_format_gray8;

+ m_bpp = 8;

+ m_sys_bpp = 8;

+ break;

+

+ case pix_format_gray16:

+ m_sys_format = pix_format_gray8;

+ m_bpp = 16;

+ m_sys_bpp = 8;

+ break;

+

+ case pix_format_rgb565:

+ case pix_format_rgb555:

+ m_sys_format = pix_format_rgb555;

+ m_bpp = 16;

+ m_sys_bpp = 16;

+ break;

+

+ case pix_format_rgbAAA:

+ case pix_format_bgrAAA:

+ case pix_format_rgbBBA:

+ case pix_format_bgrABB:

+ m_sys_format = pix_format_bgr24;

+ m_bpp = 32;

+ m_sys_bpp = 24;

+ break;

+

+ case pix_format_rgb24:

+ case pix_format_bgr24:

+ m_sys_format = pix_format_bgr24;

+ m_bpp = 24;

+ m_sys_bpp = 24;

+ break;

+

+ case pix_format_rgb48:

+ case pix_format_bgr48:

+ m_sys_format = pix_format_bgr24;

+ m_bpp = 48;

+ m_sys_bpp = 24;

+ break;

+

+ case pix_format_bgra32:

+ case pix_format_abgr32:

+ case pix_format_argb32:

+ case pix_format_rgba32:

+ m_sys_format = pix_format_bgra32;

+ m_bpp = 32;

+ m_sys_bpp = 32;

+ break;

+

+ case pix_format_bgra64:

+ case pix_format_abgr64:

+ case pix_format_argb64:

+ case pix_format_rgba64:

+ m_sys_format = pix_format_bgra32;

+ m_bpp = 64;

+ m_sys_bpp = 32;

+ break;

+

+ default:

+ /* */;

+ }

+ ::QueryPerformanceFrequency(&m_sw_freq);

+ ::QueryPerformanceCounter(&m_sw_start);

+

+ pthread_mutex_init (m_mutex, NULL);

+ }

//------------------------------------------------------------------------

platform_specific::~platform_specific()

@@ -205,325 +205,325 @@ namespace agg

}

- //------------------------------------------------------------------------

- void platform_specific::create_pmap(unsigned width,

- unsigned height,

- rendering_buffer* wnd)

- {

- m_pmap_window.create(width, height, org_e(m_bpp));

- pixel_map_attach (m_pmap_window, wnd, m_flip_y);

+ //------------------------------------------------------------------------

+ void platform_specific::create_pmap(unsigned width,

+ unsigned height,

+ rendering_buffer* wnd)

+ {

+ m_pmap_window.create(width, height, org_e(m_bpp));

+ pixel_map_attach (m_pmap_window, wnd, m_flip_y);

- if (m_bmp_draw)

- delete [] (unsigned char*) m_bmp_draw;

- m_bmp_draw = pixel_map::create_bitmap_info(width, height,

- org_e(m_sys_bpp));

- }

+ if (m_bmp_draw)

+ delete [] (unsigned char*) m_bmp_draw;

+ m_bmp_draw = pixel_map::create_bitmap_info(width, height,

+ org_e(m_sys_bpp));

+ }

//------------------------------------------------------------------------

template <class RenBufDst, class RenBufSrc>

static void convert_pmap(RenBufDst* dst, const RenBufSrc* src,

- pix_format_e format, bool copy_req)

+ pix_format_e format, bool copy_req)

{

switch(format)

{

case pix_format_gray8:

case pix_format_bgr24:

- if (copy_req)

- dst->copy_from(*src);

- break;

+ if (copy_req)

+ dst->copy_from(*src);

+ break;

case pix_format_gray16:

- my_color_conv(dst, src, color_conv_gray16_to_gray8());

- break;

+ my_color_conv(dst, src, color_conv_gray16_to_gray8());

+ break;

case pix_format_rgb565:

- my_color_conv(dst, src, color_conv_rgb565_to_rgb555());

- break;

+ my_color_conv(dst, src, color_conv_rgb565_to_rgb555());

+ break;

case pix_format_rgbAAA:

- my_color_conv(dst, src, color_conv_rgbAAA_to_bgr24());

- break;

+ my_color_conv(dst, src, color_conv_rgbAAA_to_bgr24());

+ break;

case pix_format_bgrAAA:

- my_color_conv(dst, src, color_conv_bgrAAA_to_bgr24());

- break;

+ my_color_conv(dst, src, color_conv_bgrAAA_to_bgr24());

+ break;

case pix_format_rgbBBA:

- my_color_conv(dst, src, color_conv_rgbBBA_to_bgr24());

- break;

+ my_color_conv(dst, src, color_conv_rgbBBA_to_bgr24());

+ break;

case pix_format_bgrABB:

- my_color_conv(dst, src, color_conv_bgrABB_to_bgr24());

- break;

+ my_color_conv(dst, src, color_conv_bgrABB_to_bgr24());

+ break;

case pix_format_rgb24:

- my_color_conv(dst, src, color_conv_rgb24_to_bgr24());

- break;

+ my_color_conv(dst, src, color_conv_rgb24_to_bgr24());

+ break;

case pix_format_rgb48:

- my_color_conv(dst, src, color_conv_rgb48_to_bgr24());

- break;

+ my_color_conv(dst, src, color_conv_rgb48_to_bgr24());

+ break;

case pix_format_bgr48:

- my_color_conv(dst, src, color_conv_bgr48_to_bgr24());

- break;

+ my_color_conv(dst, src, color_conv_bgr48_to_bgr24());

+ break;

case pix_format_abgr32:

- my_color_conv(dst, src, color_conv_abgr32_to_bgra32());

- break;

+ my_color_conv(dst, src, color_conv_abgr32_to_bgra32());

+ break;

case pix_format_argb32:

- my_color_conv(dst, src, color_conv_argb32_to_bgra32());

- break;

+ my_color_conv(dst, src, color_conv_argb32_to_bgra32());

+ break;

case pix_format_rgba32:

- my_color_conv(dst, src, color_conv_rgba32_to_bgra32());

- break;

+ my_color_conv(dst, src, color_conv_rgba32_to_bgra32());

+ break;

case pix_format_bgra64:

- my_color_conv(dst, src, color_conv_bgra64_to_bgra32());

- break;

+ my_color_conv(dst, src, color_conv_bgra64_to_bgra32());

+ break;

case pix_format_abgr64:

- my_color_conv(dst, src, color_conv_abgr64_to_bgra32());

- break;

+ my_color_conv(dst, src, color_conv_abgr64_to_bgra32());

+ break;

case pix_format_argb64:

- my_color_conv(dst, src, color_conv_argb64_to_bgra32());

- break;

+ my_color_conv(dst, src, color_conv_argb64_to_bgra32());

+ break;

case pix_format_rgba64:

- my_color_conv(dst, src, color_conv_rgba64_to_bgra32());

- break;

+ my_color_conv(dst, src, color_conv_rgba64_to_bgra32());

+ break;

default:

- /* */;

+ /* */;

}

}

- //------------------------------------------------------------------------

+ //------------------------------------------------------------------------

void platform_specific::display_pmap(HDC dc, const rendering_buffer* src,

- const agg::rect_base<int> *ri)

+ const agg::rect_base<int> *ri)

{

if(m_sys_format == m_format && ri == 0)

{

- m_pmap_window.draw(dc);

+ m_pmap_window.draw(dc);

}

else

{

- agg::rect_base<int> r(0, 0, src->width(), src->height());

- if (ri)

- r = agg::intersect_rectangles(r, *ri);

+ agg::rect_base<int> r(0, 0, src->width(), src->height());

+ if (ri)

+ r = agg::intersect_rectangles(r, *ri);

- int w = r.x2 - r.x1, h = r.y2 - r.y1;

+ int w = r.x2 - r.x1, h = r.y2 - r.y1;

- bitmap_info_resize (m_bmp_draw, w, h);

+ bitmap_info_resize (m_bmp_draw, w, h);

- pixel_map pmap;

- pmap.attach_to_bmp(m_bmp_draw);

+ pixel_map pmap;

+ pmap.attach_to_bmp(m_bmp_draw);

- rendering_buffer rbuf_tmp;

- pixel_map_attach (pmap, &rbuf_tmp, m_flip_y);

+ rendering_buffer rbuf_tmp;

+ pixel_map_attach (pmap, &rbuf_tmp, m_flip_y);

- rendering_buffer_ro src_view;

- rendering_buffer_get_const_view(src_view, *src, r, m_bpp / 8, m_flip_y);

+ rendering_buffer_ro src_view;

+ rendering_buffer_get_const_view(src_view, *src, r, m_bpp / 8, m_flip_y);

- convert_pmap(&rbuf_tmp, &src_view, m_format, true);

+ convert_pmap(&rbuf_tmp, &src_view, m_format, true);

- unsigned int wh = m_pmap_window.height();

- RECT wrect;

- wrect.left = r.x1;

- wrect.right = r.x2;

- wrect.bottom = wh - r.y1;

- wrect.top = wh - r.y2;

+ unsigned int wh = m_pmap_window.height();

+ RECT wrect;

+ wrect.left = r.x1;

+ wrect.right = r.x2;

+ wrect.bottom = wh - r.y1;

+ wrect.top = wh - r.y2;

- RECT brect;

- brect.left = 0;

- brect.right = w;

- brect.bottom = h;

- brect.top = 0;

+ RECT brect;

+ brect.left = 0;

+ brect.right = w;

+ brect.bottom = h;

+ brect.top = 0;

- pmap.draw(dc, &wrect, &brect);

+ pmap.draw(dc, &wrect, &brect);

}

}

- //------------------------------------------------------------------------

- bool platform_specific::save_pmap(const char* fn, unsigned idx,

- const rendering_buffer* src)

- {

- pixel_map& img = m_pmap_img[idx];

+ //------------------------------------------------------------------------

+ bool platform_specific::save_pmap(const char* fn, unsigned idx,

+ const rendering_buffer* src)

+ {

+ pixel_map& img = m_pmap_img[idx];

- if(m_sys_format == m_format)

- {

- return img.save_as_bmp(fn);

- }

+ if(m_sys_format == m_format)

+ {

+ return img.save_as_bmp(fn);

+ }

- pixel_map pmap;

- pmap.create(img.width(), img.height(), org_e(m_sys_bpp));

+ pixel_map pmap;

+ pmap.create(img.width(), img.height(), org_e(m_sys_bpp));

- rendering_buffer rbuf_tmp;

- pixel_map_attach (pmap, &rbuf_tmp, m_flip_y);

+ rendering_buffer rbuf_tmp;

+ pixel_map_attach (pmap, &rbuf_tmp, m_flip_y);

- convert_pmap(&rbuf_tmp, src, m_format, false);

- return pmap.save_as_bmp(fn);

- }

+ convert_pmap(&rbuf_tmp, src, m_format, false);

+ return pmap.save_as_bmp(fn);

+ }

- //------------------------------------------------------------------------

- bool platform_specific::load_pmap(const char* fn, unsigned idx,

- rendering_buffer* dst)

- {

- pixel_map& img = m_pmap_img[idx];

+ //------------------------------------------------------------------------

+ bool platform_specific::load_pmap(const char* fn, unsigned idx,

+ rendering_buffer* dst)

+ {

+ pixel_map& img = m_pmap_img[idx];

- pixel_map pmap;

- if(!pmap.load_from_bmp(fn)) return false;

+ pixel_map pmap;

+ if(!pmap.load_from_bmp(fn)) return false;

- rendering_buffer rbuf_tmp;

- pixel_map_attach (pmap, &rbuf_tmp, m_flip_y);

-

- img.create(pmap.width(), pmap.height(), org_e(m_bpp), 0);

- pixel_map_attach (img, dst, m_flip_y);

-

- switch(m_format)

- {

- case pix_format_gray8:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_gray8()); break;

- }

- break;

-

- case pix_format_gray16:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_gray16()); break;

- }

- break;

-

- case pix_format_rgb555:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb555()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb555()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgb555()); break;

- }

- break;

-

- case pix_format_rgb565:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb565()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb565()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgb565()); break;

- }

- break;

-

- case pix_format_rgb24:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb24()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb24()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgb24()); break;

- }

- break;

-

- case pix_format_bgr24:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_bgr24()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgr24()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_bgr24()); break;

- }

- break;

-

- case pix_format_rgb48:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb48()); break;

- }

- break;

-

- case pix_format_bgr48:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgr48()); break;

- }

- break;

-

- case pix_format_abgr32:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_abgr32()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_abgr32()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_abgr32()); break;

- }

- break;

-

- case pix_format_argb32:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_argb32()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_argb32()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_argb32()); break;

- }

- break;

-

- case pix_format_bgra32:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_bgra32()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgra32()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_bgra32()); break;

- }

- break;

-

- case pix_format_rgba32:

- switch(pmap.bpp())

- {

- case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgba32()); break;

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgba32()); break;

- case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgba32()); break;

- }

- break;

-

- case pix_format_abgr64:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_abgr64()); break;

- }

- break;

-

- case pix_format_argb64:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_argb64()); break;

- }

- break;

-

- case pix_format_bgra64:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgra64()); break;

- }

- break;

-

- case pix_format_rgba64:

- switch(pmap.bpp())

- {

- case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgba64()); break;

- }

- break;

-

- default:

- return false;

- }

+ rendering_buffer rbuf_tmp;

+ pixel_map_attach (pmap, &rbuf_tmp, m_flip_y);

- return true;

- }

+ img.create(pmap.width(), pmap.height(), org_e(m_bpp), 0);

+ pixel_map_attach (img, dst, m_flip_y);

+

+ switch(m_format)

+ {

+ case pix_format_gray8:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_gray8()); break;

+ }

+ break;

+

+ case pix_format_gray16:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_gray16()); break;

+ }

+ break;

+

+ case pix_format_rgb555:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb555()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb555()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgb555()); break;

+ }

+ break;

+

+ case pix_format_rgb565:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb565()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb565()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgb565()); break;

+ }

+ break;

+

+ case pix_format_rgb24:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb24()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb24()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgb24()); break;

+ }

+ break;

+

+ case pix_format_bgr24:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_bgr24()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgr24()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_bgr24()); break;

+ }

+ break;

+

+ case pix_format_rgb48:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgb48()); break;

+ }

+ break;

+

+ case pix_format_bgr48:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgr48()); break;

+ }

+ break;

+

+ case pix_format_abgr32:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_abgr32()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_abgr32()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_abgr32()); break;

+ }

+ break;

+

+ case pix_format_argb32:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_argb32()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_argb32()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_argb32()); break;

+ }

+ break;

+

+ case pix_format_bgra32:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_bgra32()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgra32()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_bgra32()); break;

+ }

+ break;

+

+ case pix_format_rgba32:

+ switch(pmap.bpp())

+ {

+ case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgba32()); break;

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgba32()); break;

+ case 32: color_conv(dst, &rbuf_tmp, color_conv_bgra32_to_rgba32()); break;

+ }

+ break;

+

+ case pix_format_abgr64:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_abgr64()); break;

+ }

+ break;

+

+ case pix_format_argb64:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_argb64()); break;

+ }

+ break;

+

+ case pix_format_bgra64:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_bgra64()); break;

+ }

+ break;

+

+ case pix_format_rgba64:

+ switch(pmap.bpp())

+ {

+ case 24: color_conv(dst, &rbuf_tmp, color_conv_bgr24_to_rgba64()); break;

+ }

+ break;

+

+ default:

+ return false;

+ }

+

+ return true;

+ }

void platform_specific::bitmap_info_resize (BITMAPINFO* bmp, unsigned w, unsigned h)

{

@@ -539,390 +539,390 @@ namespace agg

}

- //------------------------------------------------------------------------

- platform_support::platform_support(pix_format_e format, bool flip_y) :

- m_specific(new platform_specific(format, flip_y)),

- m_format(format),

- m_bpp(m_specific->m_bpp),

- m_window_flags(0),

- m_wait_mode(true),

- m_flip_y(flip_y),

- m_initial_width(10),

- m_initial_height(10)

- {

- strcpy(m_caption, "Anti-Grain Geometry Application");

- }

+ //------------------------------------------------------------------------

+ platform_support::platform_support(pix_format_e format, bool flip_y) :

+ m_specific(new platform_specific(format, flip_y)),

+ m_format(format),

+ m_bpp(m_specific->m_bpp),

+ m_window_flags(0),

+ m_wait_mode(true),

+ m_flip_y(flip_y),

+ m_initial_width(10),

+ m_initial_height(10)

+ {

+ strcpy(m_caption, "Anti-Grain Geometry Application");

+ }

- //------------------------------------------------------------------------

- platform_support::~platform_support()

- {

- delete m_specific;

- }

+ //------------------------------------------------------------------------

+ platform_support::~platform_support()

+ {

+ delete m_specific;

+ }

- //------------------------------------------------------------------------

- void platform_support::caption(const char* cap)

- {

- strcpy(m_caption, cap);

- if(m_specific->m_hwnd)

- {

- SetWindowText(m_specific->m_hwnd, m_caption);

- }

- }

+ //------------------------------------------------------------------------

+ void platform_support::caption(const char* cap)

+ {

+ strcpy(m_caption, cap);

+ if(m_specific->m_hwnd)

+ {

+ SetWindowText(m_specific->m_hwnd, m_caption);

+ }

+ }

- //------------------------------------------------------------------------

- void platform_support::start_timer()

- {

- ::QueryPerformanceCounter(&(m_specific->m_sw_start));

- }

+ //------------------------------------------------------------------------

+ void platform_support::start_timer()

+ {

+ ::QueryPerformanceCounter(&(m_specific->m_sw_start));

+ }

- //------------------------------------------------------------------------

- double platform_support::elapsed_time() const

- {

- LARGE_INTEGER stop;

- ::QueryPerformanceCounter(&stop);

- return double(stop.QuadPart -

- m_specific->m_sw_start.QuadPart) * 1000.0 /

- double(m_specific->m_sw_freq.QuadPart);

- }

+ //------------------------------------------------------------------------

+ double platform_support::elapsed_time() const

+ {

+ LARGE_INTEGER stop;

+ ::QueryPerformanceCounter(&stop);

+ return double(stop.QuadPart -

+ m_specific->m_sw_start.QuadPart) * 1000.0 /

+ double(m_specific->m_sw_freq.QuadPart);

+ }

- void* platform_support::raw_display_handler()

- {

- return m_specific->m_current_dc;

- }

+ void* platform_support::raw_display_handler()

+ {

+ return m_specific->m_current_dc;

+ }

- //------------------------------------------------------------------------

- LRESULT CALLBACK window_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

- {

- PAINTSTRUCT ps;

- HDC paintDC;

-

- void* user_data = reinterpret_cast<void*>(::GetWindowLong(hWnd, GWL_USERDATA));

- platform_support* app = 0;

-

- if(user_data)

- {

- app = reinterpret_cast<platform_support*>(user_data);

- }

-

- if(app == 0)

- {

- if(msg == WM_DESTROY)

- {

- ::PostQuitMessage(0);

- return 0;

- }

- return ::DefWindowProc(hWnd, msg, wParam, lParam);

- }

-

- HDC dc = ::GetDC(app->m_specific->m_hwnd);

- app->m_specific->m_current_dc = dc;

- LRESULT ret = 0;

-

- switch(msg)

- {

+ //------------------------------------------------------------------------

+ LRESULT CALLBACK window_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)

+ {

+ PAINTSTRUCT ps;

+ HDC paintDC;

+

+ void* user_data = reinterpret_cast<void*>(::GetWindowLong(hWnd, GWL_USERDATA));

+ platform_support* app = 0;

+

+ if(user_data)

+ {

+ app = reinterpret_cast<platform_support*>(user_data);

+ }

+

+ if(app == 0)

+ {

+ if(msg == WM_DESTROY)

+ {

+ ::PostQuitMessage(0);

+ return 0;

+ }

+ return ::DefWindowProc(hWnd, msg, wParam, lParam);

+ }

+

+ HDC dc = ::GetDC(app->m_specific->m_hwnd);

+ app->m_specific->m_current_dc = dc;

+ LRESULT ret = 0;

+

+ switch(msg)

+ {

//--------------------------------------------------------------------

- case WM_CREATE:

- break;

+ case WM_CREATE:

+ break;

//--------------------------------------------------------------------

- case WM_SIZE:

- try

- {

- app->m_specific->create_pmap(LOWORD(lParam), HIWORD(lParam),

- &app->rbuf_window());

-

- app->trans_affine_resizing(LOWORD(lParam), HIWORD(lParam));

- app->on_resize(LOWORD(lParam), HIWORD(lParam));

- app->force_redraw();

- }

- catch (std::bad_alloc&)

- {

- ::PostQuitMessage(1);

- }

-

- app->m_specific->m_is_ready = false;

-

- break;

+ case WM_SIZE:

+ try

+ {

+ app->m_specific->create_pmap(LOWORD(lParam), HIWORD(lParam),

+ &app->rbuf_window());

+

+ app->trans_affine_resizing(LOWORD(lParam), HIWORD(lParam));

+ app->on_resize(LOWORD(lParam), HIWORD(lParam));

+ app->force_redraw();

+ }

+ catch (std::bad_alloc&)

+ {

+ ::PostQuitMessage(1);

+ }

+

+ app->m_specific->m_is_ready = false;

+

+ break;

//--------------------------------------------------------------------

- case WM_ERASEBKGND:

- break;

+ case WM_ERASEBKGND:

+ break;

//--------------------------------------------------------------------

- case WM_PAINT:

- paintDC = ::BeginPaint(hWnd, &ps);

- app->m_specific->m_current_dc = paintDC;

- if(app->m_specific->m_redraw_flag)

- {

- app->on_draw();

- app->m_specific->m_redraw_flag = false;

- }

- app->m_specific->display_pmap(paintDC, &app->rbuf_window());

- app->on_post_draw(paintDC);

- app->m_specific->m_current_dc = 0;

- ::EndPaint(hWnd, &ps);

-

- app->m_specific->m_is_mapped = true;

- app->m_specific->m_is_ready = true;

- break;

+ case WM_PAINT:

+ paintDC = ::BeginPaint(hWnd, &ps);

+ app->m_specific->m_current_dc = paintDC;

+ if(app->m_specific->m_redraw_flag)

+ {

+ app->on_draw();

+ app->m_specific->m_redraw_flag = false;

+ }

+ app->m_specific->display_pmap(paintDC, &app->rbuf_window());

+ app->on_post_draw(paintDC);

+ app->m_specific->m_current_dc = 0;

+ ::EndPaint(hWnd, &ps);

+

+ app->m_specific->m_is_mapped = true;

+ app->m_specific->m_is_ready = true;

+ break;

//--------------------------------------------------------------------

- case WM_COMMAND:

- break;

+ case WM_COMMAND:

+ break;

//--------------------------------------------------------------------

- case WM_DESTROY:

- ::PostQuitMessage(0);

- break;

+ case WM_DESTROY:

+ ::PostQuitMessage(0);

+ break;

//--------------------------------------------------------------------

- default:

- ret = ::DefWindowProc(hWnd, msg, wParam, lParam);

- break;

- }

- app->m_specific->m_current_dc = 0;

- ::ReleaseDC(app->m_specific->m_hwnd, dc);

+ default:

+ ret = ::DefWindowProc(hWnd, msg, wParam, lParam);

+ break;

+ }

+ app->m_specific->m_current_dc = 0;

+ ::ReleaseDC(app->m_specific->m_hwnd, dc);

- return ret;

- }

+ return ret;

+ }

- //------------------------------------------------------------------------

- void platform_support::message(const char* msg)

- {

- ::MessageBox(m_specific->m_hwnd, msg, "AGG Message", MB_OK);

- }

+ //------------------------------------------------------------------------

+ void platform_support::message(const char* msg)

+ {

+ ::MessageBox(m_specific->m_hwnd, msg, "AGG Message", MB_OK);

+ }

- //------------------------------------------------------------------------

- bool platform_support::init(unsigned width, unsigned height, unsigned flags)

- {

- if(m_specific->m_sys_format == pix_format_undefined)

- {

- return false;

- }

-

- m_window_flags = flags;

-

- int wflags = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;

-

- WNDCLASS wc;

- wc.lpszClassName = "AGGAppAGGAppMenu";

- wc.cbClsExtra = 0;

- wc.cbWndExtra = 0;

- ::RegisterClass(&wc);

-

- wflags = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;

-

- if(m_window_flags & window_resize)

- {

- wflags |= WS_THICKFRAME | WS_MAXIMIZEBOX;

- }

-

- m_specific->m_hwnd = ::CreateWindow("AGGAppClass",

- m_caption,

- wflags,

- 100,

- 100,

- width,

- height,

- 0,

- 0,

- g_windows_instance,

- 0);

-

- if(m_specific->m_hwnd == 0)

- {

- return false;

- }

-

-

- try

- {

- RECT rct;

- ::GetClientRect(m_specific->m_hwnd, &rct);

-

- ::MoveWindow(m_specific->m_hwnd, // handle to window

- 100, // horizontal position

- 100, // vertical position

- width + (width - (rct.right - rct.left)),

- height + (height - (rct.bottom - rct.top)),

- FALSE);

+ //------------------------------------------------------------------------

+ bool platform_support::init(unsigned width, unsigned height, unsigned flags)

+ {

+ if(m_specific->m_sys_format == pix_format_undefined)

+ {

+ return false;

+ }

+

+ m_window_flags = flags;

+

+ int wflags = CS_OWNDC | CS_VREDRAW | CS_HREDRAW;

+

+ WNDCLASS wc;

+ wc.lpszClassName = "AGGAppClass";

+ wc.lpfnWndProc = window_proc;

+ wc.style = wflags;

+ wc.hInstance = g_windows_instance;

+ wc.hIcon = LoadIcon(0, IDI_APPLICATION);

+ wc.hCursor = LoadCursor(0, IDC_ARROW);

+ wc.hbrBackground = (HBRUSH)(COLOR_WINDOW);

+ wc.lpszMenuName = "AGGAppMenu";

+ wc.cbClsExtra = 0;

+ wc.cbWndExtra = 0;

+ ::RegisterClass(&wc);

+

+ wflags = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;

+

+ if(m_window_flags & window_resize)

+ {

+ wflags |= WS_THICKFRAME | WS_MAXIMIZEBOX;

+ }

+

+ m_specific->m_hwnd = ::CreateWindow("AGGAppClass",

+ m_caption,

+ wflags,

+ 100,

+ 100,

+ width,

+ height,

+ 0,

+ 0,

+ g_windows_instance,

+ 0);

+

+ if(m_specific->m_hwnd == 0)

+ {

+ return false;

+ }

+

+

+ try

+ {

+ RECT rct;

+ ::GetClientRect(m_specific->m_hwnd, &rct);

+

+ ::MoveWindow(m_specific->m_hwnd, // handle to window

+ 100, // horizontal position

+ 100, // vertical position

+ width + (width - (rct.right - rct.left)),

+ height + (height - (rct.bottom - rct.top)),

+ FALSE);

- ::SetWindowLong(m_specific->m_hwnd, GWL_USERDATA, (LONG)this);

- m_specific->create_pmap(width, height, &m_rbuf_window);

- m_initial_width = width;

- m_initial_height = height;

- on_init();

- m_specific->m_redraw_flag = true;

- ::ShowWindow(m_specific->m_hwnd, g_windows_cmd_show);

- ::SetForegroundWindow(m_specific->m_hwnd);

- }

- catch (std::bad_alloc&)

- {

- return false;

- }

- return true;

- }

+ ::SetWindowLong(m_specific->m_hwnd, GWL_USERDATA, (LONG)this);

+ m_specific->create_pmap(width, height, &m_rbuf_window);

+ m_initial_width = width;

+ m_initial_height = height;

+ on_init();

+ m_specific->m_redraw_flag = true;

+ ::ShowWindow(m_specific->m_hwnd, g_windows_cmd_show);

+ ::SetForegroundWindow(m_specific->m_hwnd);

+ }

+ catch (std::bad_alloc&)

+ {

+ return false;

+ }

+ return true;

+ }

- //------------------------------------------------------------------------

- int platform_support::run()

- {

- MSG msg;

-

- for(;;)

- {

- if(m_wait_mode)

- {

- bool status;

-

- if (m_specific->m_is_ready)

- {

- pthread_mutex_unlock (m_specific->m_mutex);

- status = ::GetMessage(&msg, 0, 0, 0);

- pthread_mutex_lock (m_specific->m_mutex);

- }

- else

- {

- status = ::GetMessage(&msg, 0, 0, 0);

- }

-

- if(! status)

- {

- break;

- }

- ::TranslateMessage(&msg);

- ::DispatchMessage(&msg);

- }

+ //------------------------------------------------------------------------

+ int platform_support::run()

+ {

+ MSG msg;

+

+ for(;;)

+ {

+ if(m_wait_mode)

+ {

+ bool status;

+

+ if (m_specific->m_is_ready)

+ {

+ pthread_mutex_unlock (m_specific->m_mutex);

+ status = ::GetMessage(&msg, 0, 0, 0);

+ pthread_mutex_lock (m_specific->m_mutex);

+ }

else

- {

- if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))

- {

- ::TranslateMessage(&msg);

- if(msg.message == WM_QUIT)

- {

- break;

- }

- ::DispatchMessage(&msg);

- }

- else

- {

- on_idle();

- }

- }

- }

-

- return (int)msg.wParam;

- }

+ {

+ status = ::GetMessage(&msg, 0, 0, 0);

+ }

+

+ if(! status)

+ {

+ break;

+ }

+ ::TranslateMessage(&msg);

+ ::DispatchMessage(&msg);

+ }

+ else

+ {

+ if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))

+ {

+ ::TranslateMessage(&msg);

+ if(msg.message == WM_QUIT)

+ {

+ break;

+ }

+ ::DispatchMessage(&msg);

+ }

+ else

+ {

+ on_idle();

+ }

+ }

+ }

+ return (int)msg.wParam;

+ }

- //------------------------------------------------------------------------

- const char* platform_support::img_ext() const { return ".bmp"; }

+ //------------------------------------------------------------------------

+ const char* platform_support::img_ext() const { return ".bmp"; }

- //------------------------------------------------------------------------

- const char* platform_support::full_file_name(const char* file_name)

- {

- return file_name;

- }

- //------------------------------------------------------------------------

- bool platform_support::load_img(unsigned idx, const char* file)

- {

- if(idx < max_images)

- {

- char fn[1024];

- strcpy(fn, file);

- int len = strlen(fn);

- if(len < 4 || stricmp(fn + len - 4, ".BMP") != 0)

- {

- strcat(fn, ".bmp");

- }

- return m_specific->load_pmap(fn, idx, &m_rbuf_img[idx]);

- }

- return true;

- }

+ //------------------------------------------------------------------------

+ const char* platform_support::full_file_name(const char* file_name)

+ {

+ return file_name;

+ }

+ //------------------------------------------------------------------------

+ bool platform_support::load_img(unsigned idx, const char* file)

+ {

+ if(idx < max_images)

+ {

+ char fn[1024];

+ strcpy(fn, file);

+ int len = strlen(fn);

+ if(len < 4 || stricmp(fn + len - 4, ".BMP") != 0)

+ {

+ strcat(fn, ".bmp");

+ }

+ return m_specific->load_pmap(fn, idx, &m_rbuf_img[idx]);

+ }

+ return true;

+ }

- //------------------------------------------------------------------------

- bool platform_support::save_img(unsigned idx, const char* file)

- {

- if(idx < max_images)

- {

- char fn[1024];

- strcpy(fn, file);

- int len = strlen(fn);

- if(len < 4 || stricmp(fn + len - 4, ".BMP") != 0)

- {

- strcat(fn, ".bmp");

- }

- return m_specific->save_pmap(fn, idx, &m_rbuf_img[idx]);

- }

- return true;

- }

+ //------------------------------------------------------------------------

+ bool platform_support::save_img(unsigned idx, const char* file)

+ {

+ if(idx < max_images)

+ {

+ char fn[1024];

+ strcpy(fn, file);

+ int len = strlen(fn);

+ if(len < 4 || stricmp(fn + len - 4, ".BMP") != 0)

+ {

+ strcat(fn, ".bmp");

+ }

+ return m_specific->save_pmap(fn, idx, &m_rbuf_img[idx]);

+ }

+ return true;

+ }

- //------------------------------------------------------------------------

- bool platform_support::create_img(unsigned idx, unsigned width, unsigned height)

- {

- if(idx < max_images)

- {

- if(width == 0) width = m_specific->m_pmap_window.width();

- if(height == 0) height = m_specific->m_pmap_window.height();

-

- pixel_map& pmap = m_specific->m_pmap_img[idx];

- pmap.create(width, height, org_e(m_specific->m_bpp));

- pixel_map_attach (pmap, &m_rbuf_img[idx], m_flip_y);

- return true;

- }

- return false;

- }

+ //------------------------------------------------------------------------

+ bool platform_support::create_img(unsigned idx, unsigned width, unsigned height)

+ {

+ if(idx < max_images)

+ {

+ if(width == 0) width = m_specific->m_pmap_window.width();

+ if(height == 0) height = m_specific->m_pmap_window.height();

- //------------------------------------------------------------------------

- void platform_support::force_redraw()

- {

- m_specific->m_redraw_flag = true;

- ::InvalidateRect(m_specific->m_hwnd, 0, FALSE);

- }

+ pixel_map& pmap = m_specific->m_pmap_img[idx];

+ pmap.create(width, height, org_e(m_specific->m_bpp));

+ pixel_map_attach (pmap, &m_rbuf_img[idx], m_flip_y);

+ return true;

+ }

+ return false;

+ }

+ //------------------------------------------------------------------------

+ void platform_support::force_redraw()

+ {

+ m_specific->m_redraw_flag = true;

+ ::InvalidateRect(m_specific->m_hwnd, 0, FALSE);

+ }

- //------------------------------------------------------------------------

- void platform_support::update_window()

- {

- HDC dc = ::GetDC(m_specific->m_hwnd);

- m_specific->display_pmap(dc, &m_rbuf_window);

- ::ReleaseDC(m_specific->m_hwnd, dc);

- }

- //------------------------------------------------------------------------

- void platform_support::on_init() {}

- void platform_support::on_resize(int sx, int sy) {}

- void platform_support::on_idle() {}

- void platform_support::on_mouse_move(int x, int y, unsigned flags) {}

- void platform_support::on_mouse_button_down(int x, int y, unsigned flags) {}

- void platform_support::on_mouse_button_up(int x, int y, unsigned flags) {}

- void platform_support::on_key(int x, int y, unsigned key, unsigned flags) {}

- void platform_support::on_ctrl_change() {}

- void platform_support::on_draw() {}

- void platform_support::on_post_draw(void* raw_handler) {}

+ //------------------------------------------------------------------------

+ void platform_support::update_window()

+ {

+ HDC dc = ::GetDC(m_specific->m_hwnd);

+ m_specific->display_pmap(dc, &m_rbuf_window);

+ ::ReleaseDC(m_specific->m_hwnd, dc);

+ }

+

+

+ //------------------------------------------------------------------------

+ void platform_support::on_init() {}

+ void platform_support::on_resize(int sx, int sy) {}

+ void platform_support::on_idle() {}

+ void platform_support::on_mouse_move(int x, int y, unsigned flags) {}

+ void platform_support::on_mouse_button_down(int x, int y, unsigned flags) {}

+ void platform_support::on_mouse_button_up(int x, int y, unsigned flags) {}

+ void platform_support::on_key(int x, int y, unsigned key, unsigned flags) {}

+ void platform_support::on_ctrl_change() {}

+ void platform_support::on_draw() {}

+ void platform_support::on_post_draw(void* raw_handler) {}

}

void

diff --git a/agg-plot/agg_platform_support_x11.cpp b/agg-plot/agg_platform_support_x11.cpp
index 6c04a719..d25b3a94 100644
--- a/agg-plot/agg_platform_support_x11.cpp
+++ b/agg-plot/agg_platform_support_x11.cpp

@@ -88,15 +88,15 @@ class buffer_image {

public:

buffer_image(unsigned bpp, unsigned byte_order,

- unsigned width, unsigned height, x_connection *xc = 0);

+ unsigned width, unsigned height, x_connection *xc = 0);

~buffer_image()

{

delete [] m_buffer;

if (m_img)

{

- m_img->data = 0;

- XDestroyImage(m_img);

+ m_img->data = 0;

+ XDestroyImage(m_img);

}

m_x_connection = 0;

};

@@ -108,7 +108,7 @@ public:

};

buffer_image::buffer_image(unsigned bpp, unsigned byte_order,

- unsigned width, unsigned height, x_connection *xc)

+ unsigned width, unsigned height, x_connection *xc)

{

unsigned row_size = width * (bpp / 8);

unsigned buf_size = height * row_size;

@@ -122,8 +122,8 @@ buffer_image::buffer_image(unsigned bpp, unsigned byte_order,

if (xc)

{

m_img = XCreateImage(xc->display, xc->visual, xc->depth,

- ZPixmap, 0, (char*) m_buffer,

- m_width, m_height, m_bpp, row_size);

+ ZPixmap, 0, (char*) m_buffer,

+ m_width, m_height, m_bpp, row_size);

m_img->byte_order = byte_order;

}

else

@@ -222,25 +222,25 @@ namespace agg

{

default: break;

case pix_format_gray8:

- m_bpp = 8;

- break;

+ m_bpp = 8;

+ break;

case pix_format_rgb565:

case pix_format_rgb555:

- m_bpp = 16;

- break;

+ m_bpp = 16;

+ break;

case pix_format_rgb24:

case pix_format_bgr24:

- m_bpp = 24;

- break;

+ m_bpp = 24;

+ break;

case pix_format_bgra32:

case pix_format_abgr32:

case pix_format_argb32:

case pix_format_rgba32:

- m_bpp = 32;

- break;

+ m_bpp = 32;

+ break;

}

m_sw_start = clock();

@@ -269,7 +269,7 @@ namespace agg

close_connections();

}

- void platform_specific::send_close_request(x_connection *xc)

+ void platform_specific::send_close_request(x_connection *xc)

{

XEvent ev;

@@ -315,110 +315,110 @@ namespace agg

if (m_format == m_sys_format)

{

- rbuf_draw.copy_from(src_view);

+ rbuf_draw.copy_from(src_view);

}

else

{

- switch(m_sys_format)

- {

- default: break;

- case pix_format_rgb555:

- switch(m_format)

- {

- default: break;

- case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_rgb555()); break;

- case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_rgb555()); break;

- case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_rgb555()); break;

- case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_rgb555()); break;

- case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_rgb555()); break;

- case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_rgb555()); break;

- case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_rgb555()); break;

- case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_rgb555()); break;

- }

- break;

+ switch(m_sys_format)

+ {

+ default: break;

+ case pix_format_rgb555:

+ switch(m_format)

+ {

+ default: break;

+ case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_rgb555()); break;

+ case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_rgb555()); break;

+ case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_rgb555()); break;

+ case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_rgb555()); break;

+ case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_rgb555()); break;

+ case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_rgb555()); break;

+ case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_rgb555()); break;

+ case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_rgb555()); break;

+ }

+ break;

- case pix_format_rgb565:

- switch(m_format)

- {

- default: break;

- case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_rgb565()); break;

- case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_rgb565()); break;

- case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_rgb565()); break;

- case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_rgb565()); break;

- case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_rgb565()); break;

- case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_rgb565()); break;

- case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_rgb565()); break;

- case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_rgb565()); break;

- }

- break;

+ case pix_format_rgb565:

+ switch(m_format)

+ {

+ default: break;

+ case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_rgb565()); break;

+ case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_rgb565()); break;

+ case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_rgb565()); break;

+ case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_rgb565()); break;

+ case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_rgb565()); break;

+ case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_rgb565()); break;

+ case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_rgb565()); break;

+ case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_rgb565()); break;

+ }

+ break;

- case pix_format_rgba32:

- switch(m_format)

- {

- default: break;

- case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_rgba32()); break;

- case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_rgba32()); break;

- case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_rgba32()); break;

- case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_rgba32()); break;

- case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_rgba32()); break;

- case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_rgba32()); break;

- case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_rgba32()); break;

- case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_rgba32()); break;

- }

- break;

+ case pix_format_rgba32:

+ switch(m_format)

+ {

+ default: break;

+ case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_rgba32()); break;

+ case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_rgba32()); break;

+ case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_rgba32()); break;

+ case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_rgba32()); break;

+ case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_rgba32()); break;

+ case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_rgba32()); break;

+ case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_rgba32()); break;

+ case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_rgba32()); break;

+ }

+ break;

- case pix_format_abgr32:

- switch(m_format)

- {

- default: break;

- case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_abgr32()); break;

- case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_abgr32()); break;

- case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_abgr32()); break;

- case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_abgr32()); break;

- case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_abgr32()); break;

- case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_abgr32()); break;

- case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_abgr32()); break;

- case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_abgr32()); break;

- }

- break;

+ case pix_format_abgr32:

+ switch(m_format)

+ {

+ default: break;

+ case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_abgr32()); break;

+ case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_abgr32()); break;

+ case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_abgr32()); break;

+ case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_abgr32()); break;

+ case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_abgr32()); break;

+ case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_abgr32()); break;

+ case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_abgr32()); break;

+ case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_abgr32()); break;

+ }

+ break;

- case pix_format_argb32:

- switch(m_format)

- {

- default: break;

- case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_argb32()); break;

- case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_argb32()); break;

- case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_argb32()); break;

- case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_argb32()); break;

- case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_argb32()); break;

- case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_argb32()); break;

- case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_argb32()); break;

- case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_argb32()); break;

- }

- break;

+ case pix_format_argb32:

+ switch(m_format)

+ {

+ default: break;

+ case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_argb32()); break;

+ case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_argb32()); break;

+ case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_argb32()); break;

+ case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_argb32()); break;

+ case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_argb32()); break;

+ case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_argb32()); break;

+ case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_argb32()); break;

+ case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_argb32()); break;

+ }

+ break;

- case pix_format_bgra32:

- switch(m_format)

- {

- default: break;

- case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_bgra32()); break;

- case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_bgra32()); break;

- case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_bgra32()); break;

- case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_bgra32()); break;

- case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_bgra32()); break;

- case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_bgra32()); break;

- case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_bgra32()); break;

- case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_bgra32()); break;

- }

- break;

- }

+ case pix_format_bgra32:

+ switch(m_format)

+ {

+ default: break;

+ case pix_format_rgb555: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb555_to_bgra32()); break;

+ case pix_format_rgb565: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb565_to_bgra32()); break;

+ case pix_format_rgb24: my_color_conv(&rbuf_draw, &src_view, color_conv_rgb24_to_bgra32()); break;

+ case pix_format_bgr24: my_color_conv(&rbuf_draw, &src_view, color_conv_bgr24_to_bgra32()); break;

+ case pix_format_rgba32: my_color_conv(&rbuf_draw, &src_view, color_conv_rgba32_to_bgra32()); break;

+ case pix_format_argb32: my_color_conv(&rbuf_draw, &src_view, color_conv_argb32_to_bgra32()); break;

+ case pix_format_abgr32: my_color_conv(&rbuf_draw, &src_view, color_conv_abgr32_to_bgra32()); break;

+ case pix_format_bgra32: my_color_conv(&rbuf_draw, &src_view, color_conv_bgra32_to_bgra32()); break;

+ }

+ break;

+ }

}

Display *dsp = m_draw_conn.display;

int x_dst = r.x1, y_dst = (m_flip_y ? src->height() - (r.y1 + h) : r.y1);

XPutImage(dsp, m_window, m_gc, m_draw_img->ximage(),

- 0, 0, x_dst, y_dst, w, h);

+ 0, 0, x_dst, y_dst, w, h);

}

//------------------------------------------------------------------------

@@ -449,7 +449,7 @@ namespace agg

strcpy(m_caption, cap);

if(m_specific->m_initialized)

{

- m_specific->caption(cap);

+ m_specific->caption(cap);

}

}

@@ -477,8 +477,8 @@ namespace agg

if (!m_specific->m_draw_conn.init())

{

- m_specific->close_connections();

- return false;

+ m_specific->close_connections();

+ return false;

}

x_connection *xc = &m_specific->m_main_conn;

@@ -490,11 +490,11 @@ namespace agg

if(xc->depth < 15 || r_mask == 0 || g_mask == 0 || b_mask == 0)

{

- fprintf(stderr,

- "There's no Visual compatible with minimal AGG requirements:\n"

- "At least 15-bit color depth and True- or DirectColor class.\n\n");

- m_specific->close_connections();

- return false;

+ fprintf(stderr,

+ "There's no Visual compatible with minimal AGG requirements:\n"

+ "At least 15-bit color depth and True- or DirectColor class.\n\n");

+ m_specific->close_connections();

+ return false;

}

int t = 1;

@@ -505,88 +505,88 @@ namespace agg

switch(xc->depth)

{

case 15:

- m_specific->m_sys_bpp = 16;

- if(r_mask == 0x7C00 && g_mask == 0x3E0 && b_mask == 0x1F)

- {

- m_specific->m_sys_format = pix_format_rgb555;

- m_specific->m_byte_order = hw_byte_order;

- }

- break;

+ m_specific->m_sys_bpp = 16;

+ if(r_mask == 0x7C00 && g_mask == 0x3E0 && b_mask == 0x1F)

+ {

+ m_specific->m_sys_format = pix_format_rgb555;

+ m_specific->m_byte_order = hw_byte_order;

+ }

+ break;

case 16:

- m_specific->m_sys_bpp = 16;

- if(r_mask == 0xF800 && g_mask == 0x7E0 && b_mask == 0x1F)

- {

- m_specific->m_sys_format = pix_format_rgb565;

- m_specific->m_byte_order = hw_byte_order;

- }

- break;

+ m_specific->m_sys_bpp = 16;

+ if(r_mask == 0xF800 && g_mask == 0x7E0 && b_mask == 0x1F)

+ {

+ m_specific->m_sys_format = pix_format_rgb565;

+ m_specific->m_byte_order = hw_byte_order;

+ }

+ break;

case 24:

case 32:

- m_specific->m_sys_bpp = 32;

- if(g_mask == 0xFF00)

- {

- if(r_mask == 0xFF && b_mask == 0xFF0000)

- {

- switch(m_specific->m_format)

- {

- case pix_format_rgba32:

- m_specific->m_sys_format = pix_format_rgba32;

- m_specific->m_byte_order = LSBFirst;

- break;

+ m_specific->m_sys_bpp = 32;

+ if(g_mask == 0xFF00)

+ {

+ if(r_mask == 0xFF && b_mask == 0xFF0000)

+ {

+ switch(m_specific->m_format)

+ {

+ case pix_format_rgba32:

+ m_specific->m_sys_format = pix_format_rgba32;

+ m_specific->m_byte_order = LSBFirst;

+ break;

- case pix_format_abgr32:

- m_specific->m_sys_format = pix_format_abgr32;

- m_specific->m_byte_order = MSBFirst;

- break;

-

- default:

- m_specific->m_byte_order = hw_byte_order;

- m_specific->m_sys_format =

- (hw_byte_order == LSBFirst) ?

- pix_format_rgba32 :

- pix_format_abgr32;

- break;

- }

- }

+ case pix_format_abgr32:

+ m_specific->m_sys_format = pix_format_abgr32;

+ m_specific->m_byte_order = MSBFirst;

+ break;

+

+ default:

+ m_specific->m_byte_order = hw_byte_order;

+ m_specific->m_sys_format =

+ (hw_byte_order == LSBFirst) ?

+ pix_format_rgba32 :

+ pix_format_abgr32;

+ break;

+ }

+ }

- if(r_mask == 0xFF0000 && b_mask == 0xFF)

- {

- switch(m_specific->m_format)

- {

- case pix_format_argb32:

- m_specific->m_sys_format = pix_format_argb32;

- m_specific->m_byte_order = MSBFirst;

- break;

+ if(r_mask == 0xFF0000 && b_mask == 0xFF)

+ {

+ switch(m_specific->m_format)

+ {

+ case pix_format_argb32:

+ m_specific->m_sys_format = pix_format_argb32;

+ m_specific->m_byte_order = MSBFirst;

+ break;

- case pix_format_bgra32:

- m_specific->m_sys_format = pix_format_bgra32;

- m_specific->m_byte_order = LSBFirst;

- break;

-

- default:

- m_specific->m_byte_order = hw_byte_order;

- m_specific->m_sys_format =

- (hw_byte_order == MSBFirst) ?

- pix_format_argb32 :

- pix_format_bgra32;

- break;

- }

- }

- }

- break;

+ case pix_format_bgra32:

+ m_specific->m_sys_format = pix_format_bgra32;

+ m_specific->m_byte_order = LSBFirst;

+ break;

+

+ default:

+ m_specific->m_byte_order = hw_byte_order;

+ m_specific->m_sys_format =

+ (hw_byte_order == MSBFirst) ?

+ pix_format_argb32 :

+ pix_format_bgra32;

+ break;

+ }

+ }

+ }

+ break;

}

if(m_specific->m_sys_format == pix_format_undefined)

{

- fprintf(stderr,

- "RGB masks are not compatible with AGG pixel formats:\n"

- "R=%08x, R=%08x, B=%08x\n",

- (unsigned)r_mask, (unsigned)g_mask, (unsigned)b_mask);

+ fprintf(stderr,

+ "RGB masks are not compatible with AGG pixel formats:\n"

+ "R=%08x, R=%08x, B=%08x\n",

+ (unsigned)r_mask, (unsigned)g_mask, (unsigned)b_mask);

- m_specific->close_connections();

- return false;

+ m_specific->close_connections();

+ return false;

}

XSetWindowAttributes *win_attr = &m_specific->m_window_attributes;

@@ -602,9 +602,9 @@ namespace agg

m_specific->m_window =

XCreateWindow(xc->display, XDefaultRootWindow(xc->display),

- 0, 0, width, height,

- 0, xc->depth, InputOutput, CopyFromParent,

- window_mask, win_attr);

+ 0, 0, width, height,

+ 0, xc->depth, InputOutput, CopyFromParent,

+ window_mask, win_attr);

m_specific->m_gc = XCreateGC(xc->display, m_specific->m_window, 0, 0);

@@ -615,10 +615,10 @@ namespace agg

if (m_specific->m_main_img == 0 || m_specific->m_draw_img == 0)

{

- XFreeGC(xc->display, m_specific->m_gc);

- XDestroyWindow(xc->display, m_specific->m_window);

- m_specific->close_connections();

- return false;

+ XFreeGC(xc->display, m_specific->m_gc);

+ XDestroyWindow(xc->display, m_specific->m_window);

+ m_specific->close_connections();

+ return false;

}

m_specific->m_main_img->attach(m_rbuf_window, m_flip_y);

@@ -629,8 +629,8 @@ namespace agg

if(!m_specific->m_initialized)

{

- on_init();

- m_specific->m_initialized = true;

+ on_init();

+ m_specific->m_initialized = true;

}

trans_affine_resizing(width, height);

@@ -640,25 +640,25 @@ namespace agg

XSizeHints *hints = XAllocSizeHints();

if(hints)

{

- if(flags & window_resize)

- {

- hints->min_width = 32;

- hints->min_height = 32;

- hints->max_width = 4096;

- hints->max_height = 4096;

- }

- else

- {

- hints->min_width = width;

- hints->min_height = height;

- hints->max_width = width;

- hints->max_height = height;

- }

- hints->flags = PMaxSize | PMinSize;

-

- XSetWMNormalHints(xc->display, m_specific->m_window, hints);

-

- XFree(hints);

+ if(flags & window_resize)

+ {

+ hints->min_width = 32;

+ hints->min_height = 32;

+ hints->max_width = 4096;

+ hints->max_height = 4096;

+ }

+ else

+ {

+ hints->min_width = width;

+ hints->min_height = height;

+ hints->max_width = width;

+ hints->max_height = height;

+ }

+ hints->flags = PMaxSize | PMinSize;

+

+ XSetWMNormalHints(xc->display, m_specific->m_window, hints);

+

+ XFree(hints);

}

@@ -709,112 +709,112 @@ namespace agg

while(!quit)

{

- if(ps->m_update_flag && ps->m_is_mapped)

- {

- on_draw();

- update_window();

- ps->m_update_flag = false;

- }

-

- if(!m_wait_mode)

- {

- if(XPending(xc->display) == 0)

- {

- on_idle();

- continue;

- }

- }

-

- XEvent x_event;

- if (ps->m_is_mapped)

- {

- pthread_mutex_unlock (ps->m_mutex);

- XNextEvent(xc->display, &x_event);

- pthread_mutex_lock (ps->m_mutex);

- }

- else

- {

- XNextEvent(xc->display, &x_event);

- }

+ if(ps->m_update_flag && ps->m_is_mapped)

+ {

+ on_draw();

+ update_window();

+ ps->m_update_flag = false;

+ }

+

+ if(!m_wait_mode)

+ {

+ if(XPending(xc->display) == 0)

+ {

+ on_idle();

+ continue;

+ }

+ }

+

+ XEvent x_event;

+ if (ps->m_is_mapped)

+ {

+ pthread_mutex_unlock (ps->m_mutex);

+ XNextEvent(xc->display, &x_event);

+ pthread_mutex_lock (ps->m_mutex);

+ }

+ else

+ {

+ XNextEvent(xc->display, &x_event);

+ }

- // In the Idle mode discard all intermediate MotionNotify events

- if(!m_wait_mode && x_event.type == MotionNotify)

- {

- XEvent te = x_event;

- for(;;)

- {

- if(XPending(xc->display) == 0) break;

- XNextEvent(xc->display, &te);

- if(te.type != MotionNotify) break;

- }

- x_event = te;

- }

-

- switch(x_event.type)

- {

- case MapNotify:

- {

- on_draw();

- update_window();

- ps->m_is_mapped = true;

- ps->m_update_flag = false;

- }

- break;

-

- case ConfigureNotify:

- {

- if(x_event.xconfigure.width != int(m_rbuf_window.width()) ||

- x_event.xconfigure.height != int(m_rbuf_window.height()))

- {

- int width = x_event.xconfigure.width;

- int height = x_event.xconfigure.height;

-

- delete ps->m_main_img;

- delete ps->m_draw_img;

-

- ps->m_main_img = new(std::nothrow) buffer_image(ps->m_bpp, ps->m_byte_order, width, height);

- ps->m_draw_img = new(std::nothrow) buffer_image(ps->m_sys_bpp, ps->m_byte_order, width, height, dc);

-

- if (ps->m_main_img == 0 || ps->m_draw_img == 0)

- {

- quit = true;

- ret = 1;

- break;

- }

+ // In the Idle mode discard all intermediate MotionNotify events

+ if(!m_wait_mode && x_event.type == MotionNotify)

+ {

+ XEvent te = x_event;

+ for(;;)

+ {

+ if(XPending(xc->display) == 0) break;

+ XNextEvent(xc->display, &te);

+ if(te.type != MotionNotify) break;

+ }

+ x_event = te;

+ }

+

+ switch(x_event.type)

+ {

+ case MapNotify:

+ {

+ on_draw();

+ update_window();

+ ps->m_is_mapped = true;

+ ps->m_update_flag = false;

+ }

+ break;

+

+ case ConfigureNotify:

+ {

+ if(x_event.xconfigure.width != int(m_rbuf_window.width()) ||

+ x_event.xconfigure.height != int(m_rbuf_window.height()))

+ {

+ int width = x_event.xconfigure.width;

+ int height = x_event.xconfigure.height;

+

+ delete ps->m_main_img;

+ delete ps->m_draw_img;

+

+ ps->m_main_img = new(std::nothrow) buffer_image(ps->m_bpp, ps->m_byte_order, width, height);

+ ps->m_draw_img = new(std::nothrow) buffer_image(ps->m_sys_bpp, ps->m_byte_order, width, height, dc);

+

+ if (ps->m_main_img == 0 || ps->m_draw_img == 0)

+ {

+ quit = true;

+ ret = 1;

+ break;

+ }

- ps->m_main_img->attach(m_rbuf_window, m_flip_y);

-

- trans_affine_resizing(width, height);

- on_resize(width, height);

- on_draw();

- update_window();

- }

- }

- break;

-

- case Expose:

- ps->put_image(&m_rbuf_window);

- XFlush(xc->display);

- XSync(xc->display, false);

- break;

-

- case ClientMessage:

- if((x_event.xclient.format == 32) &&

- (x_event.xclient.data.l[0] == int(ps->m_close_atom)))

- {

- quit = true;

- }

- break;

- }

+ ps->m_main_img->attach(m_rbuf_window, m_flip_y);

+

+ trans_affine_resizing(width, height);

+ on_resize(width, height);

+ on_draw();

+ update_window();

+ }

+ }

+ break;

+

+ case Expose:

+ ps->put_image(&m_rbuf_window);

+ XFlush(xc->display);

+ XSync(xc->display, false);

+ break;

+

+ case ClientMessage:

+ if((x_event.xclient.format == 32) &&

+ (x_event.xclient.data.l[0] == int(ps->m_close_atom)))

+ {

+ quit = true;

+ }

+ break;

+ }

}

unsigned i = platform_support::max_images;

while(i--)

{

- if(ps->m_buf_img[i])

- {

- delete [] ps->m_buf_img[i];

- }

+ if(ps->m_buf_img[i])

+ {

+ delete [] ps->m_buf_img[i];

+ }

}

ps->free_x_resources();

@@ -839,132 +839,132 @@ namespace agg

{

if(idx < max_images)

{

- char buf[1024];

- strcpy(buf, file);

- int len = strlen(buf);

- if(len < 4 || strcasecmp(buf + len - 4, ".ppm") != 0)

- {

- strcat(buf, ".ppm");

- }

+ char buf[1024];

+ strcpy(buf, file);

+ int len = strlen(buf);

+ if(len < 4 || strcasecmp(buf + len - 4, ".ppm") != 0)

+ {

+ strcat(buf, ".ppm");

+ }

- FILE* fd = fopen(buf, "rb");

- if(fd == 0) return false;

-

- if((len = fread(buf, 1, 1022, fd)) == 0)

- {

- fclose(fd);

- return false;

- }

- buf[len] = 0;

+ FILE* fd = fopen(buf, "rb");

+ if(fd == 0) return false;

+

+ if((len = fread(buf, 1, 1022, fd)) == 0)

+ {

+ fclose(fd);

+ return false;

+ }

+ buf[len] = 0;

- if(buf[0] != 'P' && buf[1] != '6')

- {

- fclose(fd);

- return false;

- }

+ if(buf[0] != 'P' && buf[1] != '6')

+ {

+ fclose(fd);

+ return false;

+ }

- char* ptr = buf + 2;

+ char* ptr = buf + 2;

- while(*ptr && !isdigit(*ptr)) ptr++;

- if(*ptr == 0)

- {

- fclose(fd);

- return false;

- }

+ while(*ptr && !isdigit(*ptr)) ptr++;

+ if(*ptr == 0)

+ {

+ fclose(fd);

+ return false;

+ }

- unsigned width = atoi(ptr);

- if(width == 0 || width > 4096)

- {

- fclose(fd);

- return false;

- }

- while(*ptr && isdigit(*ptr)) ptr++;

- while(*ptr && !isdigit(*ptr)) ptr++;

- if(*ptr == 0)

- {

- fclose(fd);

- return false;

- }

- unsigned height = atoi(ptr);

- if(height == 0 || height > 4096)

- {

- fclose(fd);

- return false;

- }

- while(*ptr && isdigit(*ptr)) ptr++;

- while(*ptr && !isdigit(*ptr)) ptr++;

- if(atoi(ptr) != 255)

- {

- fclose(fd);

- return false;

- }

- while(*ptr && isdigit(*ptr)) ptr++;

- if(*ptr == 0)

- {

- fclose(fd);

- return false;

- }

- ptr++;

- fseek(fd, long(ptr - buf), SEEK_SET);

+ unsigned width = atoi(ptr);

+ if(width == 0 || width > 4096)

+ {

+ fclose(fd);

+ return false;

+ }

+ while(*ptr && isdigit(*ptr)) ptr++;

+ while(*ptr && !isdigit(*ptr)) ptr++;

+ if(*ptr == 0)

+ {

+ fclose(fd);

+ return false;

+ }

+ unsigned height = atoi(ptr);

+ if(height == 0 || height > 4096)

+ {

+ fclose(fd);

+ return false;

+ }

+ while(*ptr && isdigit(*ptr)) ptr++;

+ while(*ptr && !isdigit(*ptr)) ptr++;

+ if(atoi(ptr) != 255)

+ {

+ fclose(fd);

+ return false;

+ }

+ while(*ptr && isdigit(*ptr)) ptr++;

+ if(*ptr == 0)

+ {

+ fclose(fd);

+ return false;

+ }

+ ptr++;

+ fseek(fd, long(ptr - buf), SEEK_SET);

- create_img(idx, width, height);

- bool ret = true;

+ create_img(idx, width, height);

+ bool ret = true;

- if(m_format == pix_format_rgb24)

- {

- fread(m_specific->m_buf_img[idx], 1, width * height * 3, fd);

- }

- else

- {

- unsigned char* buf_img = new unsigned char [width * height * 3];

- rendering_buffer rbuf_img;

- rbuf_img.attach(buf_img,

- width,

- height,

- m_flip_y ?

- -width * 3 :

- width * 3);

+ if(m_format == pix_format_rgb24)

+ {

+ fread(m_specific->m_buf_img[idx], 1, width * height * 3, fd);

+ }

+ else

+ {

+ unsigned char* buf_img = new unsigned char [width * height * 3];

+ rendering_buffer rbuf_img;

+ rbuf_img.attach(buf_img,

+ width,

+ height,

+ m_flip_y ?

+ -width * 3 :

+ width * 3);

- fread(buf_img, 1, width * height * 3, fd);

+ fread(buf_img, 1, width * height * 3, fd);

- switch(m_format)

- {

- case pix_format_rgb555:

- color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgb555());

- break;

+ switch(m_format)

+ {

+ case pix_format_rgb555:

+ color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgb555());

+ break;

- case pix_format_rgb565:

- color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgb565());

- break;

+ case pix_format_rgb565:

+ color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgb565());

+ break;

- case pix_format_bgr24:

- color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_bgr24());

- break;

+ case pix_format_bgr24:

+ color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_bgr24());

+ break;

- case pix_format_rgba32:

- color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgba32());

- break;

+ case pix_format_rgba32:

+ color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_rgba32());

+ break;

- case pix_format_argb32:

- color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_argb32());

- break;

+ case pix_format_argb32:

+ color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_argb32());

+ break;

- case pix_format_bgra32:

- color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_bgra32());

- break;

+ case pix_format_bgra32:

+ color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_bgra32());

+ break;

- case pix_format_abgr32:

- color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_abgr32());

- break;

+ case pix_format_abgr32:

+ color_conv(m_rbuf_img+idx, &rbuf_img, color_conv_rgb24_to_abgr32());

+ break;

- default:

- ret = false;

- }

- delete [] buf_img;

- }

+ default:

+ ret = false;

+ }

+ delete [] buf_img;

+ }

- fclose(fd);

- return ret;

+ fclose(fd);

+ return ret;

}

return false;

}

@@ -977,67 +977,67 @@ namespace agg

{

if(idx < max_images && rbuf_img(idx).buf())

{

- char buf[1024];

- strcpy(buf, file);

- int len = strlen(buf);

- if(len < 4 || strcasecmp(buf + len - 4, ".ppm") != 0)

- {

- strcat(buf, ".ppm");

- }

+ char buf[1024];

+ strcpy(buf, file);

+ int len = strlen(buf);

+ if(len < 4 || strcasecmp(buf + len - 4, ".ppm") != 0)

+ {

+ strcat(buf, ".ppm");

+ }

- FILE* fd = fopen(buf, "wb");

- if(fd == 0) return false;

+ FILE* fd = fopen(buf, "wb");

+ if(fd == 0) return false;

- unsigned w = rbuf_img(idx).width();

- unsigned h = rbuf_img(idx).height();

+ unsigned w = rbuf_img(idx).width();

+ unsigned h = rbuf_img(idx).height();

- fprintf(fd, "P6\n%d %d\n255\n", w, h);

+ fprintf(fd, "P6\n%d %d\n255\n", w, h);

- unsigned y;

- unsigned char* tmp_buf = new unsigned char [w * 3];

- for(y = 0; y < rbuf_img(idx).height(); y++)

- {

- const unsigned char* src = rbuf_img(idx).row_ptr(m_flip_y ? h - 1 - y : y);

- switch(m_format)

- {

- default: break;

- case pix_format_rgb555:

- color_conv_row(tmp_buf, src, w, color_conv_rgb555_to_rgb24());

- break;

+ unsigned y;

+ unsigned char* tmp_buf = new unsigned char [w * 3];

+ for(y = 0; y < rbuf_img(idx).height(); y++)

+ {

+ const unsigned char* src = rbuf_img(idx).row_ptr(m_flip_y ? h - 1 - y : y);

+ switch(m_format)

+ {

+ default: break;

+ case pix_format_rgb555:

+ color_conv_row(tmp_buf, src, w, color_conv_rgb555_to_rgb24());

+ break;

- case pix_format_rgb565:

- color_conv_row(tmp_buf, src, w, color_conv_rgb565_to_rgb24());

- break;

+ case pix_format_rgb565:

+ color_conv_row(tmp_buf, src, w, color_conv_rgb565_to_rgb24());

+ break;

- case pix_format_bgr24:

- color_conv_row(tmp_buf, src, w, color_conv_bgr24_to_rgb24());

- break;

+ case pix_format_bgr24:

+ color_conv_row(tmp_buf, src, w, color_conv_bgr24_to_rgb24());

+ break;

- case pix_format_rgb24:

- color_conv_row(tmp_buf, src, w, color_conv_rgb24_to_rgb24());

- break;

+ case pix_format_rgb24:

+ color_conv_row(tmp_buf, src, w, color_conv_rgb24_to_rgb24());

+ break;

- case pix_format_rgba32:

- color_conv_row(tmp_buf, src, w, color_conv_rgba32_to_rgb24());

- break;

+ case pix_format_rgba32:

+ color_conv_row(tmp_buf, src, w, color_conv_rgba32_to_rgb24());

+ break;

- case pix_format_argb32:

- color_conv_row(tmp_buf, src, w, color_conv_argb32_to_rgb24());

- break;

+ case pix_format_argb32:

+ color_conv_row(tmp_buf, src, w, color_conv_argb32_to_rgb24());

+ break;

- case pix_format_bgra32:

- color_conv_row(tmp_buf, src, w, color_conv_bgra32_to_rgb24());

- break;

+ case pix_format_bgra32:

+ color_conv_row(tmp_buf, src, w, color_conv_bgra32_to_rgb24());

+ break;

- case pix_format_abgr32:

- color_conv_row(tmp_buf, src, w, color_conv_abgr32_to_rgb24());

- break;

- }

- fwrite(tmp_buf, 1, w * 3, fd);

- }

- delete [] tmp_buf;

- fclose(fd);

- return true;

+ case pix_format_abgr32:

+ color_conv_row(tmp_buf, src, w, color_conv_abgr32_to_rgb24());

+ break;

+ }

+ fwrite(tmp_buf, 1, w * 3, fd);

+ }

+ delete [] tmp_buf;

+ fclose(fd);

+ return true;

}

return false;

}

@@ -1049,19 +1049,19 @@ namespace agg

{

if(idx < max_images)

{

- if(width == 0) width = rbuf_window().width();

- if(height == 0) height = rbuf_window().height();

- delete [] m_specific->m_buf_img[idx];

- m_specific->m_buf_img[idx] =

- new unsigned char[width * height * (m_bpp / 8)];

-

- m_rbuf_img[idx].attach(m_specific->m_buf_img[idx],

- width,

- height,

- m_flip_y ?

- -width * (m_bpp / 8) :

- width * (m_bpp / 8));

- return true;

+ if(width == 0) width = rbuf_window().width();

+ if(height == 0) height = rbuf_window().height();

+ delete [] m_specific->m_buf_img[idx];

+ m_specific->m_buf_img[idx] =

+ new unsigned char[width * height * (m_bpp / 8)];

+

+ m_rbuf_img[idx].attach(m_specific->m_buf_img[idx],

+ width,

+ height,

+ m_flip_y ?

+ -width * (m_bpp / 8) :

+ width * (m_bpp / 8));

+ return true;

}

return false;

}