Remove deps on pandas

<https://github.com/ydb-platform/ydb/pull/14418>

<https://github.com/ydb-platform/ydb/pull/14419>
\-- аналогичные правки в gh

Хочу залить в обход синка, чтобы посмотреть удалится ли pandas в нашей gh репе через piglet
commit_hash:abca127aa37d4dbb94b07e1e18cdb8eb5b711860

2 files changed, 0 insertions, 1351 deletions

diff --git a/contrib/python/matplotlib/py3/extern/agg24-svn/src/platform/mac/agg_mac_pmap.cpp b/contrib/python/matplotlib/py3/extern/agg24-svn/src/platform/mac/agg_mac_pmap.cpp
deleted file mode 100644
index dc85fd69ffd..00000000000
--- a/contrib/python/matplotlib/py3/extern/agg24-svn/src/platform/mac/agg_mac_pmap.cpp
+++ /dev/null
@@ -1,298 +0,0 @@
-//----------------------------------------------------------------------------
-//
-//----------------------------------------------------------------------------
-// Contact: mcseemagg@yahoo.com
-//          baer@karto.baug.ethz.ch
-//----------------------------------------------------------------------------
-//
-// class pixel_map
-//
-//----------------------------------------------------------------------------
-
-#include <string.h>
-#include <Carbon.h>
-#include <QuickTimeComponents.h>
-#include <ImageCompression.h>
-#include "platform/mac/agg_mac_pmap.h"
-#include "agg_basics.h"
-
-namespace agg
-{
-
-    //------------------------------------------------------------------------
-    pixel_map::~pixel_map()
-    {
-        destroy();
-    }
-
-
-    //------------------------------------------------------------------------
-    pixel_map::pixel_map() :
-        m_pmap(0),
-        m_buf(0),
-        m_bpp(0),
-        m_img_size(0)
-
-    {
-    }
-
-
-    //------------------------------------------------------------------------
-    void pixel_map::destroy()
-    {
-		delete[] m_buf;
-		m_buf = NULL;
-		if (m_pmap != nil)
-		{
-			DisposeGWorld(m_pmap);
-			m_pmap = nil;
-		}
-    }
-
-
-    //------------------------------------------------------------------------
-    void pixel_map::create(unsigned width, 
-                           unsigned height, 
-                           org_e    org,
-                           unsigned clear_val)
-    {
-        destroy();
-        if(width == 0)  width = 1;
-        if(height == 0) height = 1;
-        m_bpp = org;
-        
-        Rect	r;
-    	int		row_bytes = calc_row_len (width, m_bpp);
-    	MacSetRect(&r, 0, 0, width, height);
-    	m_buf = new unsigned char[m_img_size = row_bytes * height];
- 		// The Quicktime version for creating GWorlds is more flexible than the classical function.
-    	QTNewGWorldFromPtr (&m_pmap, m_bpp, &r, nil, nil, 0, m_buf, row_bytes);
-
-        // create_gray_scale_palette(m_pmap);  I didn't care about gray scale palettes so far.
-        if(clear_val <= 255)
-        {
-            memset(m_buf, clear_val, m_img_size);
-        }
-    }
-
-
-
-    //------------------------------------------------------------------------
-    void pixel_map::clear(unsigned clear_val)
-    {
-        if(m_buf) memset(m_buf, clear_val, m_img_size);
-    }
-
-
-    //static
-    //This function is just copied from the Win32 plattform support.
-    //Is also seems to be appropriate for MacOS as well, but it is not
-    //thouroughly tested so far.
-    //------------------------------------------------------------------------
-
-    unsigned pixel_map::calc_row_len(unsigned width, unsigned bits_per_pixel)
-    {
-        unsigned n = width;
-        unsigned k;
-
-        switch(bits_per_pixel)
-        {
-            case  1: k = n;
-                     n = n >> 3;
-                     if(k & 7) n++; 
-                     break;
-
-            case  4: k = n;
-                     n = n >> 1;
-                     if(k & 3) n++; 
-                     break;
-
-            case  8:
-                     break;
-
-            case 16: n = n << 1;
-                     break;
-
-            case 24: n = (n << 1) + n; 
-                     break;
-
-            case 32: n = n << 2;
-                     break;
-
-            default: n = 0;
-                     break;
-        }
-        return ((n + 3) >> 2) << 2;
-    }
-
-
-
-
-    //------------------------------------------------------------------------
-    void pixel_map::draw(WindowRef window, const Rect *device_rect, const Rect *pmap_rect) const
-    {
-        if(m_pmap == nil || m_buf == NULL) return;
-
-		PixMapHandle	pm = GetGWorldPixMap (m_pmap);
-		CGrafPtr		port = GetWindowPort (window);
-		Rect			dest_rect;
-
-		// Again, I used the Quicktime version.
-		// Good old 'CopyBits' does better interpolation when scaling
-		// but does not support all pixel depths.
-		MacSetRect (&dest_rect, 0, 0, this->width(), this->height());
-		ImageDescriptionHandle		image_description;
-		MakeImageDescriptionForPixMap (pm, &image_description);	   
-		if (image_description != nil)
-		{
-			DecompressImage (GetPixBaseAddr (pm), image_description, GetPortPixMap (port), nil, &dest_rect, ditherCopy, nil);	   
-			DisposeHandle ((Handle) image_description);
-		}
-	}
-
-
-    //------------------------------------------------------------------------
-    void pixel_map::draw(WindowRef window, int x, int y, double scale) const
-    {
-        if(m_pmap == nil || m_buf == NULL) return;
-        unsigned width  = (unsigned)(this->width() * scale);
-        unsigned height = (unsigned)(this->height() * scale);
-        Rect rect;
-        SetRect (&rect, x, y, x + width, y + height);
-        draw(window, &rect);
-    }
-
-
-
-    //------------------------------------------------------------------------
-    void pixel_map::blend(WindowRef window, const Rect *device_rect, const Rect *bmp_rect) const
-    {
-		draw (window, device_rect, bmp_rect);	// currently just mapped to drawing method
-    }
-    
-
-    //------------------------------------------------------------------------
-    void pixel_map::blend(WindowRef window, int x, int y, double scale) const
-    {
-        draw(window, x, y, scale);	// currently just mapped to drawing method
-    }
-
-
-    // I let Quicktime handle image import since it supports most popular
-    // image formats such as:
-    // *.psd, *.bmp, *.tif, *.png, *.jpg, *.gif, *.pct, *.pcx
-    //------------------------------------------------------------------------
-    bool pixel_map::load_from_qt(const char *filename)
-    {
-		FSSpec						fss;
-		OSErr						err;
-		
-		// get file specification to application directory
-		err = HGetVol(nil, &fss.vRefNum, &fss.parID);
-		if (err == noErr)
-		{
-			CopyCStringToPascal(filename, fss.name);
-			GraphicsImportComponent		gi;
-			err = GetGraphicsImporterForFile (&fss, &gi);
-			if (err == noErr)
-			{
-				ImageDescriptionHandle	desc;
-				GraphicsImportGetImageDescription(gi, &desc);
-// For simplicity, all images are currently converted to 32 bit.
-				// create an empty pixelmap
-				short depth = 32;
-				create ((**desc).width, (**desc).height, (org_e)depth, 0xff);
-				DisposeHandle ((Handle)desc);
-				// let Quicktime draw to pixelmap
-				GraphicsImportSetGWorld(gi, m_pmap, nil);
-				GraphicsImportDraw(gi);
-// Well, this is a hack. The graphics importer sets the alpha channel of the pixelmap to 0x00
-// for imported images without alpha channel but this would cause agg to draw an invisible image.
-				// set alpha channel to 0xff
-				unsigned char * buf = m_buf;
-				for (unsigned int size = 0; size < m_img_size; size += 4)
-				{
-					*buf = 0xff;
-					buf += 4;
-				}
-			}
-		}
-        return err == noErr;
-    }
-
-
-
-    //------------------------------------------------------------------------
-    bool pixel_map::save_as_qt(const char *filename) const
-    {
-		FSSpec						fss;
- 		OSErr						err;
-		
-		// get file specification to application directory
-		err = HGetVol(nil, &fss.vRefNum, &fss.parID);
-		if (err == noErr)
-		{
-     		GraphicsExportComponent		ge;
-  			CopyCStringToPascal(filename, fss.name);
-  			// I decided to use PNG as output image file type.
-  			// There are a number of other available formats.
-  			// Should I check the file suffix to choose the image file format?
-			err = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypePNG, &ge);
-			if (err == noErr)
-			{
-    			err = GraphicsExportSetInputGWorld(ge, m_pmap);
-	    		if (err == noErr)
-    			{
-    				err = GraphicsExportSetOutputFile (ge, &fss);
-    				if (err == noErr)
-    				{
-    					GraphicsExportDoExport(ge, nil);
-    				}
-    			}
-    			CloseComponent(ge);
-    		}
-    	}
-    	
-        return err == noErr;
-    }
-
-    //------------------------------------------------------------------------
-    unsigned char* pixel_map::buf()
-    {
-        return m_buf;
-    }
-
-    //------------------------------------------------------------------------
-    unsigned pixel_map::width() const
-    {
-        if(m_pmap == nil) return 0;
-		PixMapHandle	pm = GetGWorldPixMap (m_pmap);
-		Rect			bounds;
-		GetPixBounds (pm, &bounds);
-		return bounds.right - bounds.left;
-    }
-
-    //------------------------------------------------------------------------
-    unsigned pixel_map::height() const
-    {
-        if(m_pmap == nil) return 0;
-		PixMapHandle	pm = GetGWorldPixMap (m_pmap);
-		Rect			bounds;
-		GetPixBounds (pm, &bounds);
-		return bounds.bottom - bounds.top;
-    }
-
-    //------------------------------------------------------------------------
-    int pixel_map::row_bytes() const
-    {
-        if(m_pmap == nil) return 0;
- 		PixMapHandle	pm = GetGWorldPixMap (m_pmap);
-        return calc_row_len(width(), GetPixDepth(pm));
-    }
-
-
-
-}
-
-
-
diff --git a/contrib/python/matplotlib/py3/extern/agg24-svn/src/platform/mac/agg_platform_support.cpp b/contrib/python/matplotlib/py3/extern/agg24-svn/src/platform/mac/agg_platform_support.cpp
deleted file mode 100644
index f518dbe1f27..00000000000
--- a/contrib/python/matplotlib/py3/extern/agg24-svn/src/platform/mac/agg_platform_support.cpp
+++ /dev/null
@@ -1,1053 +0,0 @@
-//----------------------------------------------------------------------------
-// Anti-Grain Geometry - Version 2.4 
-// Copyright (C) 2002-2005 Maxim Shemanarev (McSeem)
-// Copyright (C) 2003 Hansruedi Baer (MacOS support)
-//
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
-// This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-//
-//----------------------------------------------------------------------------
-// Contact: mcseem@antigrain.com
-//          mcseemagg@yahoo.com
-//          http://www.antigrain.com
-//			baer@karto.baug.eth.ch
-//----------------------------------------------------------------------------
-//
-// class platform_support
-//
-//----------------------------------------------------------------------------
-//
-// Note:
-// I tried to retain the original structure for the Win32 platform as far
-// as possible. Currently, not all features are implemented but the examples
-// should work properly.
-// HB
-//----------------------------------------------------------------------------
-
-#include <Carbon.h>
-#if defined(__MWERKS__)
-#include "console.h"
-#endif
-#include <string.h>
-#include <unistd.h>
-#include "platform/agg_platform_support.h"
-#include "platform/mac/agg_mac_pmap.h"
-#include "util/agg_color_conv_rgb8.h"
-
-
-namespace agg
-{
-    
-pascal OSStatus DoWindowClose (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal OSStatus DoWindowDrawContent (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal OSStatus DoAppQuit (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal OSStatus DoMouseDown (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal OSStatus DoMouseUp (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal OSStatus DoMouseDragged (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal OSStatus DoKeyDown (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal OSStatus DoKeyUp (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData);
-pascal void DoPeriodicTask (EventLoopTimerRef theTimer, void* userData);
-
-
-    //------------------------------------------------------------------------
-    class platform_specific
-    {
-    public:
-        platform_specific(pix_format_e format, bool flip_y);
-
-        void create_pmap(unsigned width, unsigned height, 
-                         rendering_buffer* wnd);
-
-        void display_pmap(WindowRef window, const rendering_buffer* src);
-        bool load_pmap(const char* fn, unsigned idx, 
-                       rendering_buffer* dst);
-
-        bool save_pmap(const char* fn, unsigned idx, 
-                       const rendering_buffer* src);
-
-        unsigned translate(unsigned keycode);
-
-        pix_format_e     m_format;
-        pix_format_e     m_sys_format;
-        bool             m_flip_y;
-        unsigned         m_bpp;
-        unsigned         m_sys_bpp;
-        WindowRef        m_window;
-        pixel_map   	 m_pmap_window;
-        pixel_map        m_pmap_img[platform_support::max_images];
-        unsigned         m_keymap[256];
-        unsigned         m_last_translated_key;
-        int              m_cur_x;
-        int              m_cur_y;
-        unsigned         m_input_flags;
-        bool             m_redraw_flag;
-        UnsignedWide     m_sw_freq;
-        UnsignedWide     m_sw_start;
-    };
-
-
-    //------------------------------------------------------------------------
-    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_window(nil),
-        m_last_translated_key(0),
-        m_cur_x(0),
-        m_cur_y(0),
-        m_input_flags(0),
-        m_redraw_flag(true)
-    {
-        memset(m_keymap, 0, sizeof(m_keymap));
-
-        //Keyboard input is not yet fully supported nor tested
-        //m_keymap[VK_PAUSE]       = key_pause;
-        m_keymap[kClearCharCode]      = key_clear;
-
-        //m_keymap[VK_NUMPAD0]    = key_kp0;
-        //m_keymap[VK_NUMPAD1]    = key_kp1;
-        //m_keymap[VK_NUMPAD2]    = key_kp2;
-        //m_keymap[VK_NUMPAD3]    = key_kp3;
-        //m_keymap[VK_NUMPAD4]    = key_kp4;
-        //m_keymap[VK_NUMPAD5]    = key_kp5;
-        //m_keymap[VK_NUMPAD6]    = key_kp6;
-        //m_keymap[VK_NUMPAD7]    = key_kp7;
-        //m_keymap[VK_NUMPAD8]    = key_kp8;
-        //m_keymap[VK_NUMPAD9]    = key_kp9;
-        //m_keymap[VK_DECIMAL]    = key_kp_period;
-        //m_keymap[VK_DIVIDE]     = key_kp_divide;
-        //m_keymap[VK_MULTIPLY]   = key_kp_multiply;
-        //m_keymap[VK_SUBTRACT]   = key_kp_minus;
-        //m_keymap[VK_ADD]        = key_kp_plus;
-
-        m_keymap[kUpArrowCharCode]    = key_up;
-        m_keymap[kDownArrowCharCode]  = key_down;
-        m_keymap[kRightArrowCharCode] = key_right;
-        m_keymap[kLeftArrowCharCode]  = key_left;
-        //m_keymap[VK_INSERT]     = key_insert;
-        m_keymap[kDeleteCharCode]     = key_delete;
-        m_keymap[kHomeCharCode]       = key_home;
-        m_keymap[kEndCharCode]        = key_end;
-        m_keymap[kPageUpCharCode]     = key_page_up;
-        m_keymap[kPageDownCharCode]   = key_page_down;
-
-        //m_keymap[VK_F1]         = key_f1;
-        //m_keymap[VK_F2]         = key_f2;
-        //m_keymap[VK_F3]         = key_f3;
-        //m_keymap[VK_F4]         = key_f4;
-        //m_keymap[VK_F5]         = key_f5;
-        //m_keymap[VK_F6]         = key_f6;
-        //m_keymap[VK_F7]         = key_f7;
-        //m_keymap[VK_F8]         = key_f8;
-        //m_keymap[VK_F9]         = key_f9;
-        //m_keymap[VK_F10]        = key_f10;
-        //m_keymap[VK_F11]        = key_f11;
-        //m_keymap[VK_F12]        = key_f12;
-        //m_keymap[VK_F13]        = key_f13;
-        //m_keymap[VK_F14]        = key_f14;
-        //m_keymap[VK_F15]        = key_f15;
-
-        //m_keymap[VK_NUMLOCK]    = key_numlock;
-        //m_keymap[VK_CAPITAL]    = key_capslock;
-        //m_keymap[VK_SCROLL]     = key_scrollock;
-
-        switch(m_format)
-        {
-        case pix_format_gray8:
-            m_sys_format = pix_format_gray8;
-            m_bpp = 8;
-            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_rgb24:
-        case pix_format_bgr24:
-            m_sys_format = pix_format_rgb24;
-            m_bpp = 24;
-            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_argb32;
-            m_bpp = 32;
-            m_sys_bpp = 32;
-            break;
-        }
-        ::Microseconds(&m_sw_freq);
-        ::Microseconds(&m_sw_start);
-    }
-
-
-    //------------------------------------------------------------------------
-    void platform_specific::create_pmap(unsigned width, 
-                                        unsigned height,
-                                        rendering_buffer* wnd)
-    {
-        m_pmap_window.create(width, height, org_e(m_bpp));
-        wnd->attach(m_pmap_window.buf(), 
-                    m_pmap_window.width(),
-                    m_pmap_window.height(),
-                      m_flip_y ?
-                     -m_pmap_window.row_bytes() :
-                      m_pmap_window.row_bytes());
-    }
-
-
-    //------------------------------------------------------------------------
-    void platform_specific::display_pmap(WindowRef window, const rendering_buffer* src)
-    {
-        if(m_sys_format == m_format)
-        {
-            m_pmap_window.draw(window);
-        }
-        else
-        {
-            pixel_map pmap_tmp;
-            pmap_tmp.create(m_pmap_window.width(), 
-                            m_pmap_window.height(),
-                            org_e(m_sys_bpp));
-
-            rendering_buffer rbuf_tmp;
-            rbuf_tmp.attach(pmap_tmp.buf(),
-                            pmap_tmp.width(),
-                            pmap_tmp.height(),
-                            m_flip_y ?
-                             -pmap_tmp.row_bytes() :
-                              pmap_tmp.row_bytes());
-
-            switch(m_format)
-            {
-            case pix_format_gray8:
-                return;
-
-            case pix_format_rgb565:
-                color_conv(&rbuf_tmp, src, color_conv_rgb565_to_rgb555());
-                break;
-
-            case pix_format_bgr24:
-                color_conv(&rbuf_tmp, src, color_conv_bgr24_to_rgb24());
-                break;
-
-            case pix_format_abgr32:
-                color_conv(&rbuf_tmp, src, color_conv_abgr32_to_argb32());
-                break;
-
-            case pix_format_bgra32:
-                color_conv(&rbuf_tmp, src, color_conv_bgra32_to_argb32());
-                break;
-
-            case pix_format_rgba32:
-                color_conv(&rbuf_tmp, src, color_conv_rgba32_to_argb32());
-                break;
-            }
-            pmap_tmp.draw(window);
-        }
-    }
-
-
-    //------------------------------------------------------------------------
-    bool platform_specific::save_pmap(const char* fn, unsigned idx, 
-                                      const rendering_buffer* src)
-    {
-        if(m_sys_format == m_format)
-        {
-            return m_pmap_img[idx].save_as_qt(fn);
-        }
-        else
-        {
-            pixel_map pmap_tmp;
-            pmap_tmp.create(m_pmap_img[idx].width(), 
-                            m_pmap_img[idx].height(),
-                            org_e(m_sys_bpp));
-
-            rendering_buffer rbuf_tmp;
-            rbuf_tmp.attach(pmap_tmp.buf(),
-                            pmap_tmp.width(),
-                            pmap_tmp.height(),
-                            m_flip_y ?
-                             -pmap_tmp.row_bytes() :
-                              pmap_tmp.row_bytes());
-            switch(m_format)
-            {
-            case pix_format_gray8:
-                return false;
-
-            case pix_format_rgb565:
-                color_conv(&rbuf_tmp, src, color_conv_rgb565_to_rgb555());
-                break;
-
-            case pix_format_rgb24:
-                color_conv(&rbuf_tmp, src, color_conv_rgb24_to_bgr24());
-                break;
-
-            case pix_format_abgr32:
-                color_conv(&rbuf_tmp, src, color_conv_abgr32_to_bgra32());
-                break;
-
-            case pix_format_argb32:
-                color_conv(&rbuf_tmp, src, color_conv_argb32_to_bgra32());
-                break;
-
-            case pix_format_rgba32:
-                color_conv(&rbuf_tmp, src, color_conv_rgba32_to_bgra32());
-                break;
-            }
-            return pmap_tmp.save_as_qt(fn);
-        }
-        return true;
-    }
-
-
-
-    //------------------------------------------------------------------------
-    bool platform_specific::load_pmap(const char* fn, unsigned idx, 
-                                      rendering_buffer* dst)
-    {
-        pixel_map pmap_tmp;
-        if(!pmap_tmp.load_from_qt(fn)) return false;
-
-        rendering_buffer rbuf_tmp;
-        rbuf_tmp.attach(pmap_tmp.buf(),
-                        pmap_tmp.width(),
-                        pmap_tmp.height(),
-                        m_flip_y ?
-                         -pmap_tmp.row_bytes() :
-                          pmap_tmp.row_bytes());
-
-        m_pmap_img[idx].create(pmap_tmp.width(), 
-                               pmap_tmp.height(), 
-                               org_e(m_bpp),
-                               0);
-
-        dst->attach(m_pmap_img[idx].buf(),
-                    m_pmap_img[idx].width(),
-                    m_pmap_img[idx].height(),
-                    m_flip_y ?
-                      -m_pmap_img[idx].row_bytes() :
-                       m_pmap_img[idx].row_bytes());
-
-        switch(m_format)
-        {
-        case pix_format_gray8:
-            return false;
-            break;
-
-        case pix_format_rgb555:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb555()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_rgb555()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_rgb555()); break;
-            }
-            break;
-
-        case pix_format_rgb565:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb565()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_rgb565()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_rgb565()); break;
-            }
-            break;
-
-        case pix_format_rgb24:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgb24()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_rgb24()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_rgb24()); break;
-            }
-            break;
-
-        case pix_format_bgr24:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_bgr24()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_bgr24()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_bgr24()); break;
-            }
-            break;
-
-        case pix_format_abgr32:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_abgr32()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_abgr32()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_abgr32()); break;
-            }
-            break;
-
-        case pix_format_argb32:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_argb32()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_argb32()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_argb32()); break;
-            }
-            break;
-
-        case pix_format_bgra32:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_bgra32()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_bgra32()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_bgra32()); break;
-            }
-            break;
-
-        case pix_format_rgba32:
-            switch(pmap_tmp.bpp())
-            {
-            case 16: color_conv(dst, &rbuf_tmp, color_conv_rgb555_to_rgba32()); break;
-            case 24: color_conv(dst, &rbuf_tmp, color_conv_rgb24_to_rgba32()); break;
-            case 32: color_conv(dst, &rbuf_tmp, color_conv_argb32_to_rgba32()); break;
-            }
-            break;
-        }
-        
-        return true;
-    }
-
-
-
-
-
-
-
-
-    //------------------------------------------------------------------------
-    unsigned platform_specific::translate(unsigned keycode)
-    {
-        return m_last_translated_key = (keycode > 255) ? 0 : m_keymap[keycode];
-    }
-
-
-
-    //------------------------------------------------------------------------
-    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;
-    }
-
-
-
-    //------------------------------------------------------------------------
-    void platform_support::caption(const char* cap)
-    {
-        strcpy(m_caption, cap);
-        if(m_specific->m_window)
-        {
-        	SetWindowTitleWithCFString (m_specific->m_window, CFStringCreateWithCStringNoCopy (nil, cap, kCFStringEncodingASCII, nil));
-        }
-    }
-
-
-
-    //------------------------------------------------------------------------
-    static unsigned get_key_flags(UInt32 wflags)
-    {
-        unsigned flags = 0;
-        
-         if(wflags & shiftKey)   flags |= kbd_shift;
-         if(wflags & controlKey) flags |= kbd_ctrl;
-
-        return flags;
-    }
-
-
-    //------------------------------------------------------------------------
-    void platform_support::message(const char* msg)
-    {
-		SInt16 item;
-		Str255 p_msg;
-		
-		::CopyCStringToPascal (msg, p_msg);
-		::StandardAlert (kAlertPlainAlert, (const unsigned char*) "\013AGG Message", p_msg, NULL, &item);
-		//::StandardAlert (kAlertPlainAlert, (const unsigned char*) "\pAGG Message", p_msg, NULL, &item);
-    }
-
-
-    //------------------------------------------------------------------------
-    void platform_support::start_timer()
-    {
-		::Microseconds (&(m_specific->m_sw_start));
-    }
-
-
-    //------------------------------------------------------------------------
-    double platform_support::elapsed_time() const
-    {
-        UnsignedWide stop;
-        ::Microseconds(&stop);
-        return double(stop.lo - 
-                      m_specific->m_sw_start.lo) * 1e6 / 
-                      double(m_specific->m_sw_freq.lo);
-    }
-
-
-    //------------------------------------------------------------------------
-    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;
-
-		// application
-		EventTypeSpec		eventType;
-		EventHandlerUPP		handlerUPP;
-
-		eventType.eventClass = kEventClassApplication;
-		eventType.eventKind = kEventAppQuit;
-
-		handlerUPP = NewEventHandlerUPP(DoAppQuit);
-
-		InstallApplicationEventHandler (handlerUPP, 1, &eventType, nil, nil);
-
-		eventType.eventClass = kEventClassMouse;
-		eventType.eventKind = kEventMouseDown;
-		handlerUPP = NewEventHandlerUPP(DoMouseDown);
-		InstallApplicationEventHandler (handlerUPP, 1, &eventType, this, nil);
-
-		eventType.eventKind = kEventMouseUp;
-		handlerUPP = NewEventHandlerUPP(DoMouseUp);
-		InstallApplicationEventHandler (handlerUPP, 1, &eventType, this, nil);
-		
-		eventType.eventKind = kEventMouseDragged;
-		handlerUPP = NewEventHandlerUPP(DoMouseDragged);
-		InstallApplicationEventHandler (handlerUPP, 1, &eventType, this, nil);
-
-		eventType.eventClass = kEventClassKeyboard;
-		eventType.eventKind = kEventRawKeyDown;
-		handlerUPP = NewEventHandlerUPP(DoKeyDown);
-		InstallApplicationEventHandler (handlerUPP, 1, &eventType, this, nil);
-
-		eventType.eventKind = kEventRawKeyUp;
-		handlerUPP = NewEventHandlerUPP(DoKeyUp);
-		InstallApplicationEventHandler (handlerUPP, 1, &eventType, this, nil);
-
-		eventType.eventKind = kEventRawKeyRepeat;
-		handlerUPP = NewEventHandlerUPP(DoKeyDown);		// 'key repeat' is translated to 'key down'
-		InstallApplicationEventHandler (handlerUPP, 1, &eventType, this, nil);
-
-		WindowAttributes	windowAttrs;
-		Rect				bounds;
-
-		// window
-		windowAttrs = kWindowCloseBoxAttribute | kWindowCollapseBoxAttribute | kWindowStandardHandlerAttribute;
-		SetRect (&bounds, 0, 0, width, height);
-		OffsetRect (&bounds, 100, 100);
-		CreateNewWindow (kDocumentWindowClass, windowAttrs, &bounds, &m_specific->m_window);
-
-        if(m_specific->m_window == nil)
-        {
-            return false;
-        }
-
-		// I assume the text is ASCII.
-		// Change to kCFStringEncodingMacRoman, kCFStringEncodingISOLatin1, kCFStringEncodingUTF8 or what else you need.
-        SetWindowTitleWithCFString (m_specific->m_window, CFStringCreateWithCStringNoCopy (nil, m_caption, kCFStringEncodingASCII, nil));
-		
-		eventType.eventClass = kEventClassWindow;
-		eventType.eventKind = kEventWindowClose;
-
-		handlerUPP = NewEventHandlerUPP(DoWindowClose);
-		InstallWindowEventHandler (m_specific->m_window, handlerUPP, 1, &eventType, this, NULL);
-
-		eventType.eventKind = kEventWindowDrawContent;
-		handlerUPP = NewEventHandlerUPP(DoWindowDrawContent);
-		InstallWindowEventHandler (m_specific->m_window, handlerUPP, 1, &eventType, this, NULL);
-		
-		// Periodic task
-		// Instead of an idle function I use the Carbon event timer.
-		// You may decide to change the wait value which is currently 50 milliseconds.
-		EventLoopRef		mainLoop;
-		EventLoopTimerUPP	timerUPP;
-		EventLoopTimerRef	theTimer;
-
-		mainLoop = GetMainEventLoop();
-		timerUPP = NewEventLoopTimerUPP (DoPeriodicTask);
-		InstallEventLoopTimer (mainLoop, 0, 50 * kEventDurationMillisecond, timerUPP, this, &theTimer);
-
-        m_specific->create_pmap(width, height, &m_rbuf_window);
-        m_initial_width = width;
-        m_initial_height = height;
-        on_init();
-        on_resize(width, height);
-        m_specific->m_redraw_flag = true;
-		
-  		ShowWindow (m_specific->m_window);
-  		SetPortWindowPort (m_specific->m_window);
-		
-      return true;
-    }
-
-
-    //------------------------------------------------------------------------
-    int platform_support::run()
-    {
-		
-		RunApplicationEventLoop ();
-        return true;
-    }
-
-
-    //------------------------------------------------------------------------
-    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 defined(__MWERKS__)
-            if(len < 4 || stricmp(fn + len - 4, ".BMP") != 0)
-#else
-	        if(len < 4 || strncasecmp(fn + len - 4, ".BMP", 4) != 0)
-#endif
-            {
-                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 defined(__MWERKS__)
-            if(len < 4 || stricmp(fn + len - 4, ".BMP") != 0)
-#else
-	        if(len < 4 || strncasecmp(fn + len - 4, ".BMP", 4) != 0)
-#endif
-            {
-                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();
-            m_specific->m_pmap_img[idx].create(width, height, org_e(m_specific->m_bpp));
-            m_rbuf_img[idx].attach(m_specific->m_pmap_img[idx].buf(), 
-                                   m_specific->m_pmap_img[idx].width(),
-                                   m_specific->m_pmap_img[idx].height(),
-                                   m_flip_y ?
-                                   -m_specific->m_pmap_img[idx].row_bytes() :
-                                    m_specific->m_pmap_img[idx].row_bytes());
-            return true;
-        }
-        return false;
-    }
-
-
-    //------------------------------------------------------------------------
-    void platform_support::force_redraw()
-    {
-    	Rect	bounds;
-    	
-        m_specific->m_redraw_flag = true;
-        // on_ctrl_change ();
-		on_draw();
-
-    	SetRect(&bounds, 0, 0, m_rbuf_window.width(), m_rbuf_window.height());
-    	InvalWindowRect(m_specific->m_window, &bounds);
-    }
-
-
-
-    //------------------------------------------------------------------------
-    void platform_support::update_window()
-    {
-        m_specific->display_pmap(m_specific->m_window, &m_rbuf_window);
-    }
-
-
-    //------------------------------------------------------------------------
-    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) {}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoWindowClose (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-	userData;
-	
-	QuitApplicationEventLoop ();
-
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoAppQuit (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-	userData;
-	
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoMouseDown (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-	Point wheresMyMouse;
-	UInt32 modifier;
-	
-	GetEventParameter (theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &wheresMyMouse);
-	GlobalToLocal (&wheresMyMouse);
-	GetEventParameter (theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifier);
-
-    platform_support * app = reinterpret_cast<platform_support*>(userData);
-
-    app->m_specific->m_cur_x = wheresMyMouse.h;
-    if(app->flip_y())
-    {
-        app->m_specific->m_cur_y = app->rbuf_window().height() - wheresMyMouse.v;
-    }
-    else
-    {
-        app->m_specific->m_cur_y = wheresMyMouse.v;
-    }
-    app->m_specific->m_input_flags = mouse_left | get_key_flags(modifier);
-    
-    app->m_ctrls.set_cur(app->m_specific->m_cur_x, 
-                         app->m_specific->m_cur_y);
-    if(app->m_ctrls.on_mouse_button_down(app->m_specific->m_cur_x, 
-                                         app->m_specific->m_cur_y))
-    {
-        app->on_ctrl_change();
-        app->force_redraw();
-    }
-    else
-    {
-        if(app->m_ctrls.in_rect(app->m_specific->m_cur_x, 
-                                app->m_specific->m_cur_y))
-        {
-            if(app->m_ctrls.set_cur(app->m_specific->m_cur_x, 
-                                    app->m_specific->m_cur_y))
-            {
-                app->on_ctrl_change();
-                app->force_redraw();
-            }
-        }
-        else
-        {
-            app->on_mouse_button_down(app->m_specific->m_cur_x, 
-                                      app->m_specific->m_cur_y, 
-                                      app->m_specific->m_input_flags);
-        }
-    }
-
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoMouseUp (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-	Point wheresMyMouse;
-	UInt32 modifier;
-	
-	GetEventParameter (theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &wheresMyMouse);
-	GlobalToLocal (&wheresMyMouse);
-	GetEventParameter (theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifier);
-
-    platform_support * app = reinterpret_cast<platform_support*>(userData);
-
-    app->m_specific->m_cur_x = wheresMyMouse.h;
-    if(app->flip_y())
-    {
-        app->m_specific->m_cur_y = app->rbuf_window().height() - wheresMyMouse.v;
-    }
-    else
-    {
-        app->m_specific->m_cur_y = wheresMyMouse.v;
-    }
-    app->m_specific->m_input_flags = mouse_left | get_key_flags(modifier);
-
-    if(app->m_ctrls.on_mouse_button_up(app->m_specific->m_cur_x, 
-                                       app->m_specific->m_cur_y))
-    {
-        app->on_ctrl_change();
-        app->force_redraw();
-    }
-    app->on_mouse_button_up(app->m_specific->m_cur_x, 
-                            app->m_specific->m_cur_y, 
-                            app->m_specific->m_input_flags);
-
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoMouseDragged (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-	Point wheresMyMouse;
-	UInt32 modifier;
-	
-	GetEventParameter (theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &wheresMyMouse);
-	GlobalToLocal (&wheresMyMouse);
-	GetEventParameter (theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifier);
-
-    platform_support * app = reinterpret_cast<platform_support*>(userData);
-
-    app->m_specific->m_cur_x = wheresMyMouse.h;
-    if(app->flip_y())
-    {
-        app->m_specific->m_cur_y = app->rbuf_window().height() - wheresMyMouse.v;
-    }
-    else
-    {
-        app->m_specific->m_cur_y = wheresMyMouse.v;
-    }
-    app->m_specific->m_input_flags = mouse_left | get_key_flags(modifier);
-
-
-    if(app->m_ctrls.on_mouse_move(
-        app->m_specific->m_cur_x, 
-        app->m_specific->m_cur_y,
-        (app->m_specific->m_input_flags & mouse_left) != 0))
-    {
-        app->on_ctrl_change();
-        app->force_redraw();
-    }
-    else
-    {
-        app->on_mouse_move(app->m_specific->m_cur_x, 
-                           app->m_specific->m_cur_y, 
-                           app->m_specific->m_input_flags);
-    }
-
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoKeyDown (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-	char key_code;
-	UInt32 modifier;
-	
-	GetEventParameter (theEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &key_code);
-	GetEventParameter (theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifier);
-
-	platform_support * app = reinterpret_cast<platform_support*>(userData);
-
-	app->m_specific->m_last_translated_key = 0;
-    switch(modifier) 
-    {
-        case controlKey:
-            app->m_specific->m_input_flags |= kbd_ctrl;
-            break;
-
-        case shiftKey:
-            app->m_specific->m_input_flags |= kbd_shift;
-            break;
-
-        default:
-            app->m_specific->translate(key_code);
-            break;
-    }
-
-    if(app->m_specific->m_last_translated_key)
-    {
-        bool left  = false;
-        bool up    = false;
-        bool right = false;
-        bool down  = false;
-
-        switch(app->m_specific->m_last_translated_key)
-        {
-        case key_left:
-            left = true;
-            break;
-
-        case key_up:
-            up = true;
-            break;
-
-        case key_right:
-            right = true;
-            break;
-
-        case key_down:
-            down = true;
-            break;
-
-		//On a Mac, screenshots are handled by the system.
-        case key_f2:                        
-            app->copy_window_to_img(agg::platform_support::max_images - 1);
-            app->save_img(agg::platform_support::max_images - 1, "screenshot");
-            break;
-        }
-
-
-        if(app->m_ctrls.on_arrow_keys(left, right, down, up))
-        {
-            app->on_ctrl_change();
-            app->force_redraw();
-        }
-        else
-        {
-            app->on_key(app->m_specific->m_cur_x,
-                        app->m_specific->m_cur_y,
-                        app->m_specific->m_last_translated_key,
-                        app->m_specific->m_input_flags);
-        }
-    }
-
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoKeyUp (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-	char key_code;
-	UInt32 modifier;
-	
-	GetEventParameter (theEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &key_code);
-	GetEventParameter (theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifier);
-
-	platform_support * app = reinterpret_cast<platform_support*>(userData);
-
-    app->m_specific->m_last_translated_key = 0;
-    switch(modifier) 
-    {
-        case controlKey:
-            app->m_specific->m_input_flags &= ~kbd_ctrl;
-            break;
-
-        case shiftKey:
-            app->m_specific->m_input_flags &= ~kbd_shift;
-            break;
-    }
-    
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal OSStatus DoWindowDrawContent (EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
-{
-    platform_support * app = reinterpret_cast<platform_support*>(userData);
-
-    if(app)
-    {
-        if(app->m_specific->m_redraw_flag)
-        {
-            app->on_draw();
-            app->m_specific->m_redraw_flag = false;
-        }
-        app->m_specific->display_pmap(app->m_specific->m_window, &app->rbuf_window());
-    }
-
-	return CallNextEventHandler (nextHandler, theEvent);
-}
-
-
-//------------------------------------------------------------------------
-pascal void DoPeriodicTask (EventLoopTimerRef theTimer, void* userData)
-{
-    platform_support * app = reinterpret_cast<platform_support*>(userData);
-    
-    if(!app->wait_mode())
-		app->on_idle();
-}
-
-
-}
-
-
-
-
-//----------------------------------------------------------------------------
-int agg_main(int argc, char* argv[]);
-
-
-// Hm. Classic MacOS does not know command line input.
-// CodeWarrior provides a way to mimic command line input.
-// The function 'ccommand' can be used to get the command
-// line arguments.
-//----------------------------------------------------------------------------
-int main(int argc, char* argv[])
-{
-#if defined(__MWERKS__)
-	// argc = ccommand (&argv);
-#endif
-    
-    // Check if we are launched by double-clicking under OSX 
-	// Get rid of extra argument, this will confuse the standard argument parsing
-	// calls used in the examples to get the name of the image file to be used
-    if ( argc >= 2 && strncmp (argv[1], "-psn", 4) == 0 ) {
-        argc = 1;
-    } 
-
-launch:
-    return agg_main(argc, argv);
-}
\ No newline at end of file