path: root/macosx/PlatMacOSX.cxx

// Scintilla source code edit control
// PlatMacOSX.cxx - implementation of platform facilities on MacOS X/Carbon
// Based on work by Evan Jones (c) 2002 <ejones@uwaterloo.ca>
// Based on PlatGTK.cxx Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.

#include <cstring>
#include <cstdio>
#include <cstdlib>

#include <assert.h>

#include <sys/time.h>

#include <Carbon/Carbon.h>
#include "QuartzTextLayout.h"
#include "TCarbonEvent.h"

#include "Platform.h"
#include "Scintilla.h"
#include "PlatMacOSX.h"
#include "XPM.h"

using namespace Scintilla;

#include "ScintillaWidget.h"


extern sptr_t scintilla_send_message(void* sci, unsigned int iMessage, uptr_t wParam, sptr_t lParam);

inline CGRect PRectangleToCGRect( PRectangle& rc ) {
    return CGRectMake( rc.left, rc.top, rc.Width(), rc.Height() );
}

inline PRectangle CGRectToPRectangle( const CGRect& rect ) {
    PRectangle rc;
    rc.left = (int)( rect.origin.x + 0.5 );
    rc.top = (int)( rect.origin.y + 0.5 );
    rc.right = (int)( rect.origin.x + rect.size.width + 0.5 );
    rc.bottom = (int)( rect.origin.y + rect.size.height + 0.5 );
    return rc;
}

Scintilla::Point Scintilla::Point::FromLong(long lpoint) {
  return Scintilla::Point(
               Platform::LowShortFromLong(lpoint),
               Platform::HighShortFromLong(lpoint));
}

// The Palette is just ignored on Mac OS X. OS X runs "Millions" or "Thousands" of colours.
Scintilla::Palette::Palette() {
}

Scintilla::Palette::~Palette() {
}

void Scintilla::Palette::Release() {
}

// Do nothing if it "wants" a colour. Copy the colour from desired to allocated if it is "finding" a colour.
void Scintilla::Palette::WantFind(ColourPair &cp, bool want) {
    if (want) {
    } else {
        cp.allocated.Set(cp.desired.AsLong());
    }
}

void Scintilla::Palette::Allocate(Window &/*w*/) {
    // OS X always runs in thousands or millions of colours
}

Font::Font() : fid(0) {}

Font::~Font() { Release(); }


void Font::Create(const char *faceName, int /*characterSet*/,
                  int size, bool bold, bool italic, int /*extraFontFlag*/) {
    // TODO: How should I handle the characterSet request?
    Release();

    fid = new QuartzTextStyle();

    // Find the font
    QuartzFont font( faceName, strlen( faceName ) );

    // We set Font, Size, Bold, Italic
    QuartzTextSize textSize( size );
    QuartzTextBold isBold( bold );
    QuartzTextItalic isItalic( italic );

    // Actually set the attributes
    QuartzTextStyleAttribute* attributes[] = { &font, &textSize, &isBold, &isItalic };
    reinterpret_cast<QuartzTextStyle*>( fid )->setAttributes( attributes, sizeof( attributes ) / sizeof( *attributes ) );

    //ATSStyleRenderingOptions rendering = kATSStyleNoAntiAliasing;
    //reinterpret_cast<QuartzTextStyle*>( fid )->setAttribute( kATSUStyleRenderingOptionsTag, sizeof( rendering ), &rendering );

    // TODO: Why do I have to manually set this?
    reinterpret_cast<QuartzTextStyle*>( fid )->setFontFeature( kLigaturesType, kCommonLigaturesOffSelector );
}

void Font::Release() {
    if (fid)
            delete reinterpret_cast<QuartzTextStyle*>( fid );

    fid = 0;
}

SurfaceImpl::SurfaceImpl() {
    bitmapData = NULL; // Release will try and delete bitmapData if != NULL
    gc = NULL;
    textLayout = new QuartzTextLayout(NULL);
    Release();
}

SurfaceImpl::~SurfaceImpl() {
    Release();
    delete textLayout;
}

void SurfaceImpl::Release() {
    textLayout->setContext (NULL);
    if ( bitmapData != NULL )
        {
        delete[] bitmapData;
        // We only "own" the graphics context if we are a bitmap context
        if ( gc != NULL ) CGContextRelease( gc );
        }
    bitmapData = NULL;
    gc = NULL;

    bitmapWidth = 0;
    bitmapHeight = 0;
    x = 0;
    y = 0;
    //inited = false;
}

bool SurfaceImpl::Initialised() {
    // We are initalised if the graphics context is not null
  return gc != NULL;// || port != NULL;
}

void SurfaceImpl::Init(WindowID /*wid*/) {
    // To be able to draw, the surface must get a CGContext handle.  We save the graphics port,
    // then aquire/release the context on an as-need basis (see above).
    // XXX Docs on QDBeginCGContext are light, a better way to do this would be good.
    // AFAIK we should not hold onto a context retrieved this way, thus the need for
    // aquire/release of the context.

    Release();
}

void SurfaceImpl::Init(SurfaceID sid, WindowID /*wid*/) {
    Release();
    gc = reinterpret_cast<CGContextRef>( sid );
    CGContextSetLineWidth( gc, 1.0 );
    textLayout->setContext (gc);
}

void SurfaceImpl::InitPixMap(int width, int height, Surface* /*surface_*/, WindowID /*wid*/) {
    Release();
    // Create a new bitmap context, along with the RAM for the bitmap itself
    bitmapWidth = width;
    bitmapHeight = height;

    const int bitmapBytesPerRow   = (width * BYTES_PER_PIXEL);
    const int bitmapByteCount     = (bitmapBytesPerRow * height);

    // create an RGB color space
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    if( colorSpace == NULL )
        return;

    // create the bitmap
    bitmapData = new uint8_t[ bitmapByteCount ];
    if( bitmapData != NULL ) {
        // create the context
        gc = CGBitmapContextCreate( bitmapData,
                                    width,
                                    height,
                                    BITS_PER_COMPONENT,
                                    bitmapBytesPerRow,
                                    colorSpace,
                                    kCGImageAlphaPremultipliedLast);

        if( gc == NULL ) {
            // the context couldn't be created for some reason,
            // and we have no use for the bitmap without the context
            delete[] bitmapData;
            bitmapData = NULL;
        }
        textLayout->setContext (gc);
    }

    // the context retains the color space, so we can release it
    CGColorSpaceRelease( colorSpace );

    if ( gc != NULL && bitmapData != NULL )
    {
        // "Erase" to white
        CGContextClearRect( gc, CGRectMake( 0, 0, width, height ) );
        CGContextSetRGBFillColor( gc, 1.0, 1.0, 1.0, 1.0 );
        CGContextFillRect( gc, CGRectMake( 0, 0, width, height ) );
    }
}

void SurfaceImpl::PenColour(ColourAllocated fore) {
    if (gc) {
        ColourDesired colour( fore.AsLong() );

        // Set the Stroke color to match
        CGContextSetRGBStrokeColor( gc, colour.GetRed() / 255.0, colour.GetGreen() / 255.0, colour.GetBlue() / 255.0, 1.0 );
    }
}

void SurfaceImpl::FillColour(const ColourAllocated& back) {
    if (gc) {
        ColourDesired colour( back.AsLong() );

        // Set the Fill color to match
        CGContextSetRGBFillColor( gc, colour.GetRed() / 255.0, colour.GetGreen() / 255.0, colour.GetBlue() / 255.0, 1.0 );
    }
}

CGImageRef SurfaceImpl::GetImage() {
    // For now, assume that GetImage can only be called on PixMap surfaces
    if ( bitmapData == NULL ) return NULL;

    CGContextFlush( gc );

    // create an RGB color space
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
    if( colorSpace == NULL )
        return NULL;

    const int bitmapBytesPerRow   = ((int) bitmapWidth * BYTES_PER_PIXEL);
    const int bitmapByteCount     = (bitmapBytesPerRow * (int) bitmapHeight);

    // Create a data provider
    CGDataProviderRef dataProvider = CGDataProviderCreateWithData( NULL, bitmapData, bitmapByteCount, NULL );
    CGImageRef image = NULL;
    if ( dataProvider != NULL )
    {
        // create the CGImage
        image = CGImageCreate( bitmapWidth,
                            bitmapHeight,
                            BITS_PER_COMPONENT,
                            BITS_PER_PIXEL,
                            bitmapBytesPerRow,
                            colorSpace,
                            kCGImageAlphaPremultipliedLast,
                            dataProvider,
                            NULL,
                            0,
                            kCGRenderingIntentDefault );
    }

    // the image retains the color space, so we can release it
    CGColorSpaceRelease( colorSpace );
    colorSpace = NULL;

    // Done with the data provider
    CGDataProviderRelease( dataProvider );
    dataProvider = NULL;

    return image;
}

int SurfaceImpl::LogPixelsY() {
    return 72;
}

int SurfaceImpl::DeviceHeightFont(int points) {
    int logPix = LogPixelsY();
    return (points * logPix + logPix / 2) / 72;
}

void SurfaceImpl::MoveTo(int x_, int y_) {
    x = x_;
    y = y_;
}

void SurfaceImpl::LineTo(int x_, int y_) {
    CGContextBeginPath( gc );
    // Because Quartz is based on floating point, lines are drawn with half their colour
    // on each side of the line. Integer coordinates specify the INTERSECTION of the pixel
    // divison lines. If you specify exact pixel values, you get a line that
    // is twice as thick but half as intense. To get pixel aligned rendering,
    // we render the "middle" of the pixels by adding 0.5 to the coordinates.
    CGContextMoveToPoint( gc, x + 0.5, y + 0.5 );
    CGContextAddLineToPoint( gc, x_ + 0.5, y_ + 0.5 );
    CGContextStrokePath( gc );
    x = x_;
    y = y_;
}

void SurfaceImpl::Polygon(Scintilla::Point *pts, int npts, ColourAllocated fore,
                      ColourAllocated back) {
    // Allocate memory for the array of points
    CGPoint *points = new CGPoint[ npts ];

    for (int i = 0;i < npts;i++) {
        // Quartz floating point issues: plot the MIDDLE of the pixels
        points[i].x = pts[i].x + 0.5;
        points[i].y = pts[i].y + 0.5;
    }

    CGContextBeginPath( gc );

    // Set colours
    FillColour(back);
    PenColour(fore);

    // Draw the polygon
    CGContextAddLines( gc, points, npts );
    // TODO: Should the path be automatically closed, or is that the caller's responsability?
    // Explicitly close the path, so it is closed for stroking AND filling (implicit close = filling only)
    CGContextClosePath( gc );
    CGContextDrawPath( gc, kCGPathFillStroke );

    // Deallocate memory
    delete [] points;
    points = NULL;
}

void SurfaceImpl::RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
    if ( gc ) {
        CGContextBeginPath( gc );
        FillColour(back);
        PenColour(fore);

        // Quartz integer -> float point conversion fun (see comment in SurfaceImpl::LineTo)
        // We subtract 1 from the Width() and Height() so that all our drawing is within the area defined
        // by the PRectangle. Otherwise, we draw one pixel too far to the right and bottom.
        // TODO: Create some version of PRectangleToCGRect to do this conversion for us?
        CGContextAddRect( gc, CGRectMake( rc.left + 0.5, rc.top + 0.5, rc.Width() - 1, rc.Height() - 1 ) );
        CGContextDrawPath( gc, kCGPathFillStroke );
    }
}

void SurfaceImpl::FillRectangle(PRectangle rc, ColourAllocated back) {
    if ( gc ) {
        //CGContextBeginPath( gc );
        FillColour(back);

        CGRect rect = PRectangleToCGRect( rc );

        CGContextFillRect( gc, rect );
        //CGContextDrawPath( gc, kCGPathFill );
    }
}

void drawImageRefCallback( CGImageRef pattern, CGContextRef gc )
{
    CGContextDrawImage( gc, CGRectMake( 0, 0, CGImageGetWidth( pattern ), CGImageGetHeight( pattern ) ), pattern );
}

void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern) {
    SurfaceImpl& patternSurface = static_cast<SurfaceImpl &>(surfacePattern);

    // For now, assume that copy can only be called on PixMap surfaces
    // Shows up black
    CGImageRef image = patternSurface.GetImage();
    if ( image == NULL )
        {
        FillRectangle(rc, ColourAllocated(0));
        return;
        }

    const CGPatternCallbacks drawImageCallbacks = { 0, reinterpret_cast<CGPatternDrawPatternCallback>( drawImageRefCallback ), NULL };

    CGPatternRef pattern = CGPatternCreate( image,
                                         CGRectMake( 0, 0, patternSurface.bitmapWidth, patternSurface.bitmapHeight ),
                                         CGAffineTransformIdentity,
                                         patternSurface.bitmapWidth,
                                         patternSurface.bitmapHeight,
                                         kCGPatternTilingNoDistortion,
                                         true,
                                         &drawImageCallbacks
                                         );
    if( pattern != NULL ) {

        // Create a pattern color space
        CGColorSpaceRef colorSpace = CGColorSpaceCreatePattern( NULL );
        if( colorSpace != NULL ) {

            CGContextSaveGState( gc );
            CGContextSetFillColorSpace( gc, colorSpace );

            // Unlike the documentation, you MUST pass in a "components" parameter:
            // For coloured patterns it is the alpha value.
            const float alpha = 1.0;
            CGContextSetFillPattern( gc, pattern, &alpha );
            CGContextFillRect( gc, PRectangleToCGRect( rc ) );
            CGContextRestoreGState( gc );
            // Free the color space, the pattern and image
            CGColorSpaceRelease( colorSpace );
        } /* colorSpace != NULL */
        colorSpace = NULL;
        CGPatternRelease( pattern );
        pattern = NULL;
        CGImageRelease( image );
        image = NULL;
    } /* pattern != NULL */
}

void SurfaceImpl::RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
    // TODO: Look at the Win32 API to determine what this is supposed to do:
    //  ::RoundRect(hdc, rc.left + 1, rc.top, rc.right - 1, rc.bottom, 8, 8 );

    // Create a rectangle with semicircles at the corners
    const int MAX_RADIUS = 4;
    int radius = Platform::Minimum( MAX_RADIUS, rc.Height()/2 );
    radius = Platform::Minimum( radius, rc.Width()/2 );

    // Points go clockwise, starting from just below the top left
    // Corners are kept together, so we can easily create arcs to connect them
    CGPoint corners[4][3] =
        {
            {
                { rc.left, rc.top + radius },
                { rc.left, rc.top },
                { rc.left + radius, rc.top },
            },
            {
                { rc.right - radius - 1, rc.top },
                { rc.right - 1, rc.top },
                { rc.right - 1, rc.top + radius },
            },
            {
                { rc.right - 1, rc.bottom - radius - 1 },
                { rc.right - 1, rc.bottom - 1 },
                { rc.right - radius - 1, rc.bottom - 1 },
            },
            {
                { rc.left + radius, rc.bottom - 1 },
                { rc.left, rc.bottom - 1 },
                { rc.left, rc.bottom - radius - 1 },
            },
        };

    // Align the points in the middle of the pixels
    // TODO: Should I include these +0.5 in the array creation code above?
    for( int i = 0; i < 4*3; ++ i )
        {
        CGPoint* c = (CGPoint*) corners;
        c[i].x += 0.5;
        c[i].y += 0.5;
        }

    PenColour( fore );
    FillColour( back );

    // Move to the last point to begin the path
    CGContextBeginPath( gc );
    CGContextMoveToPoint( gc, corners[3][2].x, corners[3][2].y );

    for ( int i = 0; i < 4; ++ i )
        {
        CGContextAddLineToPoint( gc, corners[i][0].x, corners[i][0].y );
        CGContextAddArcToPoint( gc, corners[i][1].x, corners[i][1].y, corners[i][2].x, corners[i][2].y, radius );
        }

    // Close the path to enclose it for stroking and for filling, then draw it
    CGContextClosePath( gc );
    CGContextDrawPath( gc, kCGPathFillStroke );
}

void Scintilla::SurfaceImpl::AlphaRectangle(PRectangle rc, int /*cornerSize*/, ColourAllocated fill, int alphaFill,
                                            ColourAllocated /*outline*/, int /*alphaOutline*/, int /*flags*/)
{
    if ( gc ) {
        ColourDesired colour( fill.AsLong() );

        // Set the Fill color to match
        CGContextSetRGBFillColor( gc, colour.GetRed() / 255.0, colour.GetGreen() / 255.0, colour.GetBlue() / 255.0, alphaFill / 100.0 );
        CGRect rect = PRectangleToCGRect( rc );
        CGContextFillRect( gc, rect );
    }
}

void SurfaceImpl::Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
    // Drawing an ellipse with bezier curves. Code modified from:
    // http://www.codeguru.com/gdi/ellipse.shtml
    // MAGICAL CONSTANT to map ellipse to beziers 2/3*(sqrt(2)-1)
    const double EToBConst = 0.2761423749154;

    CGSize offset = CGSizeMake((int)(rc.Width() * EToBConst), (int)(rc.Height() * EToBConst));
    CGPoint centre = CGPointMake((rc.left + rc.right) / 2, (rc.top + rc.bottom) / 2);

    // The control point array
    CGPoint cCtlPt[13];

    // Assign values to all the control points
    cCtlPt[0].x  =
        cCtlPt[1].x  =
        cCtlPt[11].x =
        cCtlPt[12].x = rc.left + 0.5;
    cCtlPt[5].x  =
        cCtlPt[6].x  =
        cCtlPt[7].x  = rc.right - 0.5;
    cCtlPt[2].x  =
        cCtlPt[10].x = centre.x - offset.width + 0.5;
    cCtlPt[4].x  =
        cCtlPt[8].x  = centre.x + offset.width + 0.5;
    cCtlPt[3].x  =
        cCtlPt[9].x  = centre.x + 0.5;

    cCtlPt[2].y  =
        cCtlPt[3].y  =
        cCtlPt[4].y  = rc.top + 0.5;
    cCtlPt[8].y  =
        cCtlPt[9].y  =
        cCtlPt[10].y = rc.bottom - 0.5;
    cCtlPt[7].y  =
        cCtlPt[11].y = centre.y + offset.height + 0.5;
    cCtlPt[1].y =
        cCtlPt[5].y  = centre.y - offset.height + 0.5;
    cCtlPt[0].y =
        cCtlPt[12].y =
        cCtlPt[6].y  = centre.y + 0.5;

    FillColour(back);
    PenColour(fore);

    CGContextBeginPath( gc );
    CGContextMoveToPoint( gc, cCtlPt[0].x, cCtlPt[0].y );

    for ( int i = 1; i < 13; i += 3 )
        {
        CGContextAddCurveToPoint( gc, cCtlPt[i].x, cCtlPt[i].y, cCtlPt[i+1].x, cCtlPt[i+1].y, cCtlPt[i+2].x, cCtlPt[i+2].y );
        }

    // Close the path to enclose it for stroking and for filling, then draw it
    CGContextClosePath( gc );
    CGContextDrawPath( gc, kCGPathFillStroke );
}

void SurfaceImpl::CopyImageRectangle(Surface &surfaceSource, PRectangle srcRect, PRectangle dstRect)
{
    SurfaceImpl& source = static_cast<SurfaceImpl &>(surfaceSource);
    CGImageRef image = source.GetImage();

    CGRect src = PRectangleToCGRect(srcRect);
    CGRect dst = PRectangleToCGRect(dstRect);

    /* source from QuickDrawToQuartz2D.pdf on developer.apple.com */
    float w = (float) CGImageGetWidth(image);
    float h = (float) CGImageGetHeight(image);
    CGRect drawRect = CGRectMake (0, 0, w, h);
    if (!CGRectEqualToRect (src, dst))
    {
        float sx = CGRectGetWidth(dst) / CGRectGetWidth(src);
        float sy = CGRectGetHeight(dst) / CGRectGetHeight(src);
        float dx = CGRectGetMinX(dst) - (CGRectGetMinX(src) * sx);
        float dy = CGRectGetMinY(dst) - (CGRectGetMinY(src) * sy);
        drawRect = CGRectMake (dx, dy, w*sx, h*sy);
    }
    CGContextSaveGState (gc);
    CGContextClipToRect (gc, dst);
    CGContextDrawImage (gc, drawRect, image);
    CGContextRestoreGState (gc);
}

void SurfaceImpl::Copy(PRectangle rc, Scintilla::Point from, Surface &surfaceSource) {
    // Maybe we have to make the Surface two contexts:
    // a bitmap context which we do all the drawing on, and then a "real" context
    // which we copy the output to when we call "Synchronize". Ugh! Gross and slow!

    // For now, assume that copy can only be called on PixMap surfaces
    SurfaceImpl& source = static_cast<SurfaceImpl &>(surfaceSource);

    // Get the CGImageRef
    CGImageRef image = source.GetImage();
    // If we could not get an image reference, fill the rectangle black
    if ( image == NULL )
        {
        FillRectangle( rc, ColourAllocated( 0 ) );
        return;
        }

    // Now draw the image on the surface

    // Some fancy clipping work is required here: draw only inside of rc
    CGContextSaveGState( gc );
    CGContextClipToRect( gc, PRectangleToCGRect( rc ) );

    //Platform::DebugPrintf(stderr, "Copy: CGContextDrawImage: (%d, %d) - (%d X %d)\n", rc.left - from.x, rc.top - from.y, source.bitmapWidth, source.bitmapHeight );
    CGContextDrawImage( gc, CGRectMake( rc.left - from.x, rc.top - from.y, source.bitmapWidth, source.bitmapHeight ), image );

    // Undo the clipping fun
    CGContextRestoreGState( gc );

    // Done with the image
    CGImageRelease( image );
    image = NULL;
}

void SurfaceImpl::DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len,
                                 ColourAllocated fore, ColourAllocated back) {

    FillRectangle(rc, back);
    DrawTextTransparent( rc, font_, ybase, s, len, fore );
}

void SurfaceImpl::DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len,
                                  ColourAllocated fore, ColourAllocated back) {

    CGContextSaveGState( gc );
    CGContextClipToRect( gc, PRectangleToCGRect( rc ) );
    DrawTextNoClip( rc, font_, ybase, s, len, fore, back );
    CGContextRestoreGState( gc );
}

void SurfaceImpl::DrawTextTransparent(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore) {
    textLayout->setText (reinterpret_cast<const UInt8*>(s), len, *reinterpret_cast<QuartzTextStyle*>(font_.GetID()));

    // The Quartz RGB fill color influences the ATSUI color
    FillColour(fore);
    // Draw the text, with the Y axis flipped
    textLayout->draw( rc.left, ybase, true );
}

void SurfaceImpl::MeasureWidths(Font &font_, const char *s, int len, int *positions) {
    // sample at http://developer.apple.com/samplecode/ATSUICurveAccessDemo/listing1.html
    // sample includes use of ATSUGetGlyphInfo which would be better for older
    // OSX systems.  We should expand to using that on older systems as well.
    for (int i = 0; i < len; i++)
            positions [i] = 0;
            
    // We need the right X coords, so we have to append a char to get the left coord of thast extra char
    char* buf = (char*) malloc (len+1);
    if (!buf)
            return;
            
    memcpy (buf, s, len);
    buf [len] = '.';
    
    textLayout->setText (reinterpret_cast<const UInt8*>(buf), len+1, *reinterpret_cast<QuartzTextStyle*>(font_.GetID()));
    ATSUGlyphInfoArray* theGlyphInfoArrayPtr;
    ByteCount theArraySize;

    // Get the GlyphInfoArray
    ATSUTextLayout layout = textLayout->getLayout();
    if ( noErr == ATSUGetGlyphInfo (layout, 0, textLayout->getLength(), &theArraySize, NULL))
    {
        theGlyphInfoArrayPtr = (ATSUGlyphInfoArray *) malloc (theArraySize + sizeof(ItemCount) + sizeof(ATSUTextLayout));
        if (theGlyphInfoArrayPtr)
        {
            if (noErr == ATSUGetGlyphInfo (layout, 0, textLayout->getLength(), &theArraySize, theGlyphInfoArrayPtr))
            {
                // do not count the first item, which is at the beginning of the line
                for ( UniCharCount unicodePosition = 1, i = 0; i < len && unicodePosition < theGlyphInfoArrayPtr->numGlyphs; unicodePosition ++ )
                {
                    // The ideal position is the x coordinate of the glyph, relative to the beginning of the line
                    int position = (int)( theGlyphInfoArrayPtr->glyphs[unicodePosition].idealX + 0.5 );    // These older APIs return float values
                    unsigned char uch = s[i];
                    positions[i++] = position;

                    // If we are using unicode (UTF8), map the Unicode position back to the UTF8 characters,
                    // as 1 unicode character can map to multiple UTF8 characters.
                    // See: http://www.tbray.org/ongoing/When/200x/2003/04/26/UTF
                    // Or: http://www.cl.cam.ac.uk/~mgk25/unicode.html
                    if ( unicodeMode ) 
                    {
                        unsigned char mask = 0xc0;
                        int count = 1;
                        // Add one additonal byte for each extra high order one in the byte
                        while ( uch >= mask && count < 8 ) 
                        {
                            positions[i++] = position;
                            count ++;
                            mask = mask >> 1 | 0x80; // add an additional one in the highest order position
                        }
                    }
                }
            }

            // Free the GlyphInfoArray
            free (theGlyphInfoArrayPtr);
        }
    }
    free (buf);
}

int SurfaceImpl::WidthText(Font &font_, const char *s, int len) {
    if (font_.GetID())
    {
        textLayout->setText (reinterpret_cast<const UInt8*>(s), len, *reinterpret_cast<QuartzTextStyle*>(font_.GetID()));

        // TODO: Maybe I should add some sort of text measurement features to QuartzTextLayout?
        unsigned long actualNumberOfBounds = 0;
        ATSTrapezoid glyphBounds;

        // We get a single bound, since the text should only require one. If it requires more, there is an issue
        if ( ATSUGetGlyphBounds( textLayout->getLayout(), 0, 0, kATSUFromTextBeginning, kATSUToTextEnd, kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds ) != noErr || actualNumberOfBounds != 1 )
        {
            Platform::DebugDisplay( "ATSUGetGlyphBounds failed in WidthText" );
            return 0;
        }

        //Platform::DebugPrintf( "WidthText: \"%*s\" = %ld\n", len, s, Fix2Long( glyphBounds.upperRight.x - glyphBounds.upperLeft.x ) );
        return Fix2Long( glyphBounds.upperRight.x - glyphBounds.upperLeft.x );
    }
    return 1;
}

int SurfaceImpl::WidthChar(Font &font_, char ch) {
    char str[2] = { ch, '\0' };
    if (font_.GetID())
    {
        textLayout->setText (reinterpret_cast<const UInt8*>(str), 1, *reinterpret_cast<QuartzTextStyle*>(font_.GetID()));

        // TODO: Maybe I should add some sort of text measurement features to QuartzTextLayout?
        unsigned long actualNumberOfBounds = 0;
        ATSTrapezoid glyphBounds;

        // We get a single bound, since the text should only require one. If it requires more, there is an issue
        if ( ATSUGetGlyphBounds( textLayout->getLayout(), 0, 0, kATSUFromTextBeginning, kATSUToTextEnd, kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds ) != noErr || actualNumberOfBounds != 1 )
        {
            Platform::DebugDisplay( "ATSUGetGlyphBounds failed in WidthChar" );
            return 0;
        }

        return Fix2Long( glyphBounds.upperRight.x - glyphBounds.upperLeft.x );
    }
    else
        return 1;
}

// Three possible strategies for determining ascent and descent of font:
// 1) Call ATSUGetGlyphBounds with string containing all letters, numbers and punctuation.
// 2) Use the ascent and descent fields of the font.
// 3) Call ATSUGetGlyphBounds with string as 1 but also including accented capitals.
// Smallest values given by 1 and largest by 3 with 2 in between.
// Techniques 1 and 2 sometimes chop off extreme portions of ascenders and
// descenders but are mostly OK except for accented characters which are
// rarely used in code.

// This string contains a good range of characters to test for size.
const char sizeString[] = "`~!@#$%^&*()-_=+\\|[]{};:\"\'<,>.?/1234567890"
                          "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

int SurfaceImpl::Ascent(Font &font_) {
    if (!font_.GetID())
        return 1;

    ATSUTextMeasurement ascent = reinterpret_cast<QuartzTextStyle*>( font_.GetID() )->getAttribute<ATSUTextMeasurement>( kATSUAscentTag );
    return Fix2Long( ascent );
}

int SurfaceImpl::Descent(Font &font_) {
    if (!font_.GetID())
        return 1;

    ATSUTextMeasurement descent = reinterpret_cast<QuartzTextStyle*>( font_.GetID() )->getAttribute<ATSUTextMeasurement>( kATSUDescentTag );
    return Fix2Long( descent );
}

int SurfaceImpl::InternalLeading(Font &) {
    // TODO: How do we get EM_Size?
    // internal leading = ascent - descent - EM_size
    return 0;
}

int SurfaceImpl::ExternalLeading(Font &font_) {
    if (!font_.GetID())
        return 1;

    ATSUTextMeasurement lineGap = reinterpret_cast<QuartzTextStyle*>( font_.GetID() )->getAttribute<ATSUTextMeasurement>( kATSULeadingTag );
    return Fix2Long( lineGap );
}

int SurfaceImpl::Height(Font &font_) {
    return Ascent(font_) + Descent(font_);
}

int SurfaceImpl::AverageCharWidth(Font &font_) {

    if (!font_.GetID())
        return 1;

    const int sizeStringLength = (sizeof( sizeString ) / sizeof( sizeString[0] ) - 1);
    int width = WidthText( font_, sizeString, sizeStringLength  );

    return (int) ((width / (float) sizeStringLength) + 0.5);

    /*
    ATSUStyle textStyle = reinterpret_cast<QuartzTextStyle*>( font_.GetID() )->getATSUStyle();
    ATSUFontID fontID;

    ByteCount actualSize = 0;
    if ( ATSUGetAttribute( textStyle, kATSUFontTag, sizeof( fontID ), &fontID, &actualSize ) != noErr )
        {
Platform::DebugDisplay( "ATSUGetAttribute failed" );
        return 1;
        }

    ATSFontMetrics metrics;
    memset( &metrics, 0, sizeof( metrics ) );
    if ( ATSFontGetHorizontalMetrics( fontID, kATSOptionFlagsDefault, &metrics ) != noErr )
    {
        Platform::DebugDisplay( "ATSFontGetHorizontalMetrics failed in AverageCharWidth" );
        return 1;
    }

    printf( "%f %f %f\n", metrics.avgAdvanceWidth * 32, metrics.ascent * 32, metrics.descent * 32 );

    return (int) (metrics.avgAdvanceWidth + 0.5);*/
}

int SurfaceImpl::SetPalette(Scintilla::Palette *, bool) {
    // Mac OS X is always true colour (I think) so this doesn't matter
    return 0;
}

void SurfaceImpl::SetClip(PRectangle rc) {
    CGContextClipToRect( gc, PRectangleToCGRect( rc ) );
}

void SurfaceImpl::FlushCachedState() {
    CGContextSynchronize( gc );
}

void SurfaceImpl::SetUnicodeMode(bool unicodeMode_) {
    unicodeMode = unicodeMode_;
}

void SurfaceImpl::SetDBCSMode(int codePage) {
    // TODO: Implement this for code pages != UTF-8
}

Surface *Surface::Allocate() {
    return new SurfaceImpl(  );
}

Window::~Window() {
}

void Window::Destroy() {
    if (windowRef) {
        DisposeWindow(reinterpret_cast<WindowRef>( windowRef ));
    }
    wid = 0;
}

bool Window::HasFocus() {
    // TODO: Test this
    return HIViewSubtreeContainsFocus( reinterpret_cast<HIViewRef>( wid ) );
}

PRectangle Window::GetPosition() {
    // Before any size allocated pretend its 1000 wide so not scrolled
    PRectangle rc(0, 0, 1000, 1000);

    // The frame rectangle gives the position of this view inside the parent view
    if (wid) {
        HIRect controlFrame;
        HIViewGetFrame( reinterpret_cast<HIViewRef>( wid ), &controlFrame );
        rc = CGRectToPRectangle( controlFrame );
    }

    return rc;
}

void Window::SetPosition(PRectangle rc) {
    // Moves this view inside the parent view
    if ( wid )
    {
        // Set the frame on the view, the function handles the rest
        CGRect r = PRectangleToCGRect( rc );
        HIViewSetFrame( reinterpret_cast<HIViewRef>( wid ), &r );
    }
}

void Window::SetPositionRelative(PRectangle rc, Window window) {
    // used to actually move child windows (ie. listbox/calltip) so we have to move
    // the window, not the hiview
    if (windowRef) {
        // we go through some contortions here to get an accurate location for our
        // child windows.  This is necessary due to the multiple ways an embedding
        // app may be setup.  See SciTest/main.c (GOOD && BAD) for test case.
        WindowRef relativeWindow = GetControlOwner(reinterpret_cast<HIViewRef>( window.GetID() ));
        WindowRef thisWindow = reinterpret_cast<WindowRef>( windowRef );

        Rect portBounds;
        ::GetWindowBounds(relativeWindow, kWindowStructureRgn, &portBounds);
        //fprintf(stderr, "portBounds %d %d %d %d\n", portBounds.left, portBounds.top, portBounds.right, portBounds.bottom);
        PRectangle hbounds = window.GetPosition();
        //fprintf(stderr, "hbounds %d %d %d %d\n", hbounds.left, hbounds.top, hbounds.right, hbounds.bottom);
        HIViewRef parent = HIViewGetSuperview(reinterpret_cast<HIViewRef>( window.GetID() ));
        Rect pbounds;
        GetControlBounds(parent, &pbounds);
        //fprintf(stderr, "pbounds %d %d %d %d\n", pbounds.left, pbounds.top, pbounds.right, pbounds.bottom);

        PRectangle bounds;
        bounds.top = portBounds.top + pbounds.top + hbounds.top + rc.top;
        bounds.bottom = bounds.top + rc.Height();
        bounds.left = portBounds.left + pbounds.left + hbounds.left + rc.left;
        bounds.right = bounds.left + rc.Width();
        //fprintf(stderr, "bounds %d %d %d %d\n", bounds.left, bounds.top, bounds.right, bounds.bottom);

        MoveWindow(thisWindow, bounds.left, bounds.top, false);
        SizeWindow(thisWindow, bounds.Width(), bounds.Height(), true);

        SetPosition(PRectangle(0,0,rc.Width(),rc.Height()));
    } else {
        SetPosition(rc);
    }
}

PRectangle Window::GetClientPosition() {
    // This means, in MacOS X terms, get the "frame bounds". Call GetPosition, just like on Win32.
    return GetPosition();
}

void Window::Show(bool show) {
    if ( wid ) {
        HIViewSetVisible( reinterpret_cast<HIViewRef>( wid ), show );
    }
    // this is necessary for calltip/listbox
    if (windowRef) {
        WindowRef thisWindow = reinterpret_cast<WindowRef>( windowRef );
        if (show) {
            ShowWindow( thisWindow );
            DrawControls( thisWindow );
        } else
            HideWindow( thisWindow );
    }
}

void Window::InvalidateAll() {
    if ( wid ) {
        HIViewSetNeedsDisplay( reinterpret_cast<HIViewRef>( wid ), true );
    }
}

void Window::InvalidateRectangle(PRectangle rc) {
    if (wid) {
        // Create a rectangular region
        RgnHandle region = NewRgn();
        SetRectRgn( region, rc.left, rc.top, rc.right, rc.bottom );

        // Make that region invalid
        HIViewSetNeedsDisplayInRegion( reinterpret_cast<HIViewRef>( wid ), region, true );
        DisposeRgn( region );
    }
}

void Window::SetFont(Font &) {
    // TODO: Do I need to implement this? MSDN: specifies the font that a control is to use when drawing text.
}

void Window::SetCursor(Cursor curs) {
    if (wid) {
        // TODO: This isn't really implemented correctly. I should be using
        // mouse tracking rectangles to only set the mouse cursor when it is over the control
        ThemeCursor cursor;

        switch ( curs ) {
            case cursorText:
                cursor = kThemeIBeamCursor;
                break;
            case cursorArrow:
                cursor = kThemeArrowCursor;
                break;
            case cursorWait:
                cursor = kThemeWatchCursor;
                break;
            case cursorHoriz:
                cursor = kThemeResizeLeftRightCursor;
                break;
            case cursorVert:
                cursor = kThemeResizeUpDownCursor;
                break;
            case cursorReverseArrow:
            case cursorUp:
            default:
                cursor = kThemeArrowCursor;
                break;
        }

        SetThemeCursor( cursor );
    }
}

void Window::SetTitle(const char *s) {
    WindowRef window = GetControlOwner(reinterpret_cast<HIViewRef>( wid ));
    CFStringRef title = CFStringCreateWithCString(kCFAllocatorDefault, s, kCFStringEncodingMacRoman);
    SetWindowTitleWithCFString(window, title);
    CFRelease(title);
}

PRectangle Window::GetMonitorRect(Point) {
	return PRectangle();
}

ListBox::ListBox() {}

ListBox::~ListBox() {}

static const OSType scintillaListBoxType = 'sclb';

enum {
    kItemsPerContainer = 1,
    kIconColumn = 'icon',
    kTextColumn = 'text'
};
static SInt32 kScrollBarWidth = 0;

class LineData {
    int *types;
        CFStringRef *strings;
    int len;
    int maximum;
public:
    LineData() :types(0), strings(0), len(0), maximum(0) {}
    ~LineData() {
        Clear();
    }
    void Clear() {
        delete []types;
        types = 0;
        for (int i=0; i<maximum; i++) {
          if (strings[i]) CFRelease(strings[i]);
        }
        delete []strings;
        strings = 0;
        len = 0;
        maximum = 0;
    }
    void Add(int index, int type, CFStringRef str ) {
        if (index >= maximum) {
            if (index >= len) {
                int lenNew = (index+1) * 2;
                int *typesNew = new int[lenNew];
                CFStringRef *stringsNew = new CFStringRef[lenNew];
                for (int i=0; i<maximum; i++) {
                    typesNew[i] = types[i];
                    stringsNew[i] = strings[i];
                }
                delete []types;
                delete []strings;
                types = typesNew;
                strings = stringsNew;
                len = lenNew;
            }
            while (maximum < index) {
                types[maximum] = 0;
                strings[maximum] = 0;
                maximum++;
            }
        }
        types[index] = type;
        strings[index] = str;
        if (index == maximum) {
            maximum++;
        }
    }
    int GetType(int index) {
        if (index < maximum) {
            return types[index];
        } else {
            return 0;
        }
    }
    CFStringRef GetString(int index) {
        if (index < maximum) {
            return strings[index];
        } else {
            return 0;
        }
    }
};

class ListBoxImpl : public ListBox {
private:
    ControlRef lb;
    XPMSet xset;
    int lineHeight;
    bool unicodeMode;
    int desiredVisibleRows;
    unsigned int maxItemWidth;
    unsigned int aveCharWidth;
    Font font;
    int maxWidth;

    void InstallDataBrowserCustomCallbacks();
    void ConfigureDataBrowser();

    static pascal OSStatus  WindowEventHandler(EventHandlerCallRef  inCallRef,
                                               EventRef inEvent,
                                               void *inUserData );
    EventHandlerRef eventHandler;

protected:
    WindowRef windowRef;

public:
    LineData ld;
    CallBackAction doubleClickAction;
    void *doubleClickActionData;

    ListBoxImpl() : lb(NULL), lineHeight(10), unicodeMode(false),
            desiredVisibleRows(5), maxItemWidth(0), aveCharWidth(8),
            doubleClickAction(NULL), doubleClickActionData(NULL)
    {
      if (kScrollBarWidth == 0)
        GetThemeMetric(kThemeMetricScrollBarWidth, &kScrollBarWidth);
    }

    ~ListBoxImpl() {};
    void SetFont(Font &font);
    void Create(Window &parent, int ctrlID, Scintilla::Point pt, int lineHeight_, bool unicodeMode_);
    void SetAverageCharWidth(int width);
    void SetVisibleRows(int rows);
    int GetVisibleRows() const;
    PRectangle GetDesiredRect();
    int CaretFromEdge();
    void Clear();
    void Append(char *s, int type = -1);
    int Length();
    void Select(int n);
    int GetSelection();
    int Find(const char *prefix);
    void GetValue(int n, char *value, int len);
    void Sort();
    void RegisterImage(int type, const char *xpm_data);
    void ClearRegisteredImages();
    void SetDoubleClickAction(CallBackAction action, void *data) {
        doubleClickAction = action;
        doubleClickActionData = data;
    }

    int IconWidth();
    void ShowHideScrollbar();
#ifdef DB_TABLE_ROW_HEIGHT
    void SetRowHeight(DataBrowserItemID itemID);
#endif

    void DrawRow(DataBrowserItemID item,
                 DataBrowserPropertyID property,
                 DataBrowserItemState itemState,
                 const Rect *theRect);

    void SetList(const char* list, char separator, char typesep);
};

ListBox *ListBox::Allocate() {
    ListBoxImpl *lb = new ListBoxImpl();
    return lb;
}

void ListBoxImpl::Create(Window &/*parent*/, int /*ctrlID*/, Scintilla::Point /*pt*/,
                         int lineHeight_, bool unicodeMode_) {
    lineHeight = lineHeight_;
    unicodeMode = unicodeMode_;
    maxWidth = 2000;

    WindowClass windowClass = kHelpWindowClass;
    WindowAttributes attributes = kWindowNoAttributes;
    Rect contentBounds;
    WindowRef outWindow;

    contentBounds.top = contentBounds.left = 0;
    contentBounds.right = 100;
    contentBounds.bottom = lineHeight * desiredVisibleRows;

    CreateNewWindow(windowClass, attributes, &contentBounds, &outWindow);

    InstallStandardEventHandler(GetWindowEventTarget(outWindow));

    ControlRef root;
    CreateRootControl(outWindow, &root);

    CreateDataBrowserControl(outWindow, &contentBounds, kDataBrowserListView, &lb);

#ifdef DB_TABLE_ROW_HEIGHT
    // XXX does not seem to have any effect
    SetDataBrowserTableViewRowHeight(lb, lineHeight);
#endif

    // get rid of the frame, forces databrowser to the full size
    // of the window
    Boolean frameAndFocus = false;
    SetControlData(lb, kControlNoPart, kControlDataBrowserIncludesFrameAndFocusTag,
           sizeof(frameAndFocus), &frameAndFocus);

    ListBoxImpl* lbThis = this;
    SetControlProperty( lb, scintillaListBoxType, 0, sizeof( this ), &lbThis );

    ConfigureDataBrowser();
    InstallDataBrowserCustomCallbacks();

    // install event handlers
    static const EventTypeSpec kWindowEvents[] =
        {
          { kEventClassMouse, kEventMouseDown },
          { kEventClassMouse, kEventMouseMoved },
        };

    eventHandler = NULL;
    InstallWindowEventHandler( outWindow, WindowEventHandler,
                   GetEventTypeCount( kWindowEvents ),
                   kWindowEvents, this, &eventHandler );

    wid = lb;
    SetControlVisibility(lb, true, true);
    SetControl(lb);
    SetWindow(outWindow);
}

pascal OSStatus ListBoxImpl::WindowEventHandler(
    EventHandlerCallRef inCallRef,
    EventRef            inEvent,
    void*               inUserData )
{

    switch (GetEventClass(inEvent)) {
    case kEventClassMouse:
      switch (GetEventKind(inEvent))
        {
        case kEventMouseMoved:
          {
            SetThemeCursor( kThemeArrowCursor );
            break;
          }
        case kEventMouseDown:
          {
            // we cannot handle the double click from the databrowser notify callback as
            // calling doubleClickAction causes the listbox to be destroyed.  It is
            // safe to do it from this event handler since the destroy event will be queued
            // until we're done here.
            TCarbonEvent        event( inEvent );
            EventMouseButton inMouseButton;
            event.GetParameter<EventMouseButton>( kEventParamMouseButton, typeMouseButton, &inMouseButton );

            UInt32 inClickCount;
            event.GetParameter( kEventParamClickCount, &inClickCount );
            if (inMouseButton == kEventMouseButtonPrimary && inClickCount == 2) {
              // handle our single mouse click now
              ListBoxImpl* listbox = reinterpret_cast<ListBoxImpl*>( inUserData );
              const WindowRef window = GetControlOwner(listbox->lb);
              const HIViewRef rootView = HIViewGetRoot( window );
              HIViewRef targetView = NULL;
              HIViewGetViewForMouseEvent( rootView, inEvent, &targetView );
              if ( targetView == listbox->lb )
                {
                  if (listbox->doubleClickAction != NULL) {
                listbox->doubleClickAction(listbox->doubleClickActionData);
                  }
                }
            }
          }
      }
    }
    return eventNotHandledErr;
}

#ifdef DB_TABLE_ROW_HEIGHT
void ListBoxImpl::SetRowHeight(DataBrowserItemID itemID)
{
    // XXX does not seem to have any effect
    SetDataBrowserTableViewItemRowHeight(lb, itemID, lineHeight);
}
#endif

void ListBoxImpl::DrawRow(DataBrowserItemID item,
         DataBrowserPropertyID property,
         DataBrowserItemState itemState,
         const Rect *theRect)
{
    Rect row = *theRect;
    row.left = 0;

    ColourPair fore;

    if (itemState == kDataBrowserItemIsSelected) {
      long        systemVersion;
      Gestalt( gestaltSystemVersion, &systemVersion );
      //  Panther DB starts using kThemeBrushSecondaryHighlightColor for inactive browser hilighting
      if ( (systemVersion >= 0x00001030) && (IsControlActive( lb ) == false) )
          SetThemePen( kThemeBrushSecondaryHighlightColor, 32, true );
      else
        //SetThemePen( kThemeBrushPrimaryHighlightColor, 32, true );
        SetThemePen( kThemeBrushAlternatePrimaryHighlightColor, 32, true );

      PaintRect(&row);
      fore = ColourDesired(0xff,0xff,0xff);
    }

    int widthPix = xset.GetWidth() + 2;
    int pixId = ld.GetType(item - 1);
    XPM *pxpm = xset.Get(pixId);

    char s[255];
    GetValue(item - 1, s, 255);

    Surface *surfaceItem = Surface::Allocate();
    if (surfaceItem) {
        CGContextRef    cgContext;
        GrafPtr        port;
        Rect bounds;

        GetControlBounds(lb, &bounds);
        GetPort( &port );
        QDBeginCGContext( port, &cgContext );

        CGContextSaveGState( cgContext );
        CGContextTranslateCTM(cgContext, 0, bounds.bottom - bounds.top);
        CGContextScaleCTM(cgContext, 1.0, -1.0);

        surfaceItem->Init(cgContext, NULL);

        int left = row.left;
        if (pxpm) {
            PRectangle rc(left + 1, row.top,
                    left + 1 + widthPix, row.bottom);
            pxpm->Draw(surfaceItem, rc);
        }

        // draw the text
        PRectangle trc(left + 2 + widthPix, row.top, row.right, row.bottom);
        int ascent = surfaceItem->Ascent(font) - surfaceItem->InternalLeading(font);
        int ytext = trc.top + ascent + 1;
        trc.bottom = ytext + surfaceItem->Descent(font) + 1;
        surfaceItem->DrawTextTransparent( trc, font, ytext, s, strlen(s), fore.allocated );

        CGContextRestoreGState( cgContext );
        QDEndCGContext( port, &cgContext );
        delete surfaceItem;
    }
}


pascal void ListBoxDrawItemCallback(ControlRef browser, DataBrowserItemID item,
                    DataBrowserPropertyID property,
                    DataBrowserItemState itemState,
                    const Rect *theRect, SInt16 gdDepth,
                    Boolean colorDevice)
{
    if (property != kIconColumn) return;
    ListBoxImpl* lbThis = NULL;
    OSStatus err;
    err = GetControlProperty( browser, scintillaListBoxType, 0, sizeof( lbThis ), NULL, &lbThis );
    // adjust our rect
    lbThis->DrawRow(item, property, itemState, theRect);

}

void ListBoxImpl::ConfigureDataBrowser()
{
    DataBrowserViewStyle viewStyle;
    DataBrowserSelectionFlags selectionFlags;
    ::GetDataBrowserViewStyle(lb, &viewStyle);

    ::SetDataBrowserHasScrollBars(lb, false, true);
    ::SetDataBrowserListViewHeaderBtnHeight(lb, 0);
    ::GetDataBrowserSelectionFlags(lb, &selectionFlags);
    ::SetDataBrowserSelectionFlags(lb, selectionFlags |= kDataBrowserSelectOnlyOne);
    // if you change the hilite style, also change the style in ListBoxDrawItemCallback
    ::SetDataBrowserTableViewHiliteStyle(lb, kDataBrowserTableViewFillHilite);

    Rect insetRect;
    ::GetDataBrowserScrollBarInset(lb, &insetRect);

    insetRect.right = kScrollBarWidth - 1;
    ::SetDataBrowserScrollBarInset(lb, &insetRect);

    switch (viewStyle)
    {
      case kDataBrowserListView:
      {
        DataBrowserListViewColumnDesc iconCol;
        iconCol.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
        iconCol.headerBtnDesc.minimumWidth = 0;
        iconCol.headerBtnDesc.maximumWidth = maxWidth;
        iconCol.headerBtnDesc.titleOffset = 0;
        iconCol.headerBtnDesc.titleString = NULL;
        iconCol.headerBtnDesc.initialOrder = kDataBrowserOrderIncreasing;

        iconCol.headerBtnDesc.btnFontStyle.flags = kControlUseJustMask;
        iconCol.headerBtnDesc.btnFontStyle.just = teFlushLeft;

        iconCol.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;

        iconCol.propertyDesc.propertyID = kIconColumn;
        iconCol.propertyDesc.propertyType = kDataBrowserCustomType;
        iconCol.propertyDesc.propertyFlags = kDataBrowserListViewSelectionColumn;

        ::AddDataBrowserListViewColumn(lb, &iconCol, kDataBrowserListViewAppendColumn);
      }  break;

    }
}

void ListBoxImpl::InstallDataBrowserCustomCallbacks()
{
    DataBrowserCustomCallbacks callbacks;

    callbacks.version = kDataBrowserLatestCustomCallbacks;
    verify_noerr(InitDataBrowserCustomCallbacks(&callbacks));
    callbacks.u.v1.drawItemCallback = NewDataBrowserDrawItemUPP(ListBoxDrawItemCallback);
    callbacks.u.v1.hitTestCallback = NULL;//NewDataBrowserHitTestUPP(ListBoxHitTestCallback);
    callbacks.u.v1.trackingCallback = NULL;//NewDataBrowserTrackingUPP(ListBoxTrackingCallback);
    callbacks.u.v1.editTextCallback = NULL;
    callbacks.u.v1.dragRegionCallback = NULL;
    callbacks.u.v1.acceptDragCallback = NULL;
    callbacks.u.v1.receiveDragCallback = NULL;

    SetDataBrowserCustomCallbacks(lb, &callbacks);
}

void ListBoxImpl::SetFont(Font &font_) {
    // Having to do this conversion is LAME
    QuartzTextStyle *ts = reinterpret_cast<QuartzTextStyle*>( font_.GetID() );
    ControlFontStyleRec style;
    ATSUAttributeValuePtr value;
    ATSUFontID        fontID;
    style.flags = kControlUseFontMask | kControlUseSizeMask | kControlAddToMetaFontMask;
    ts->getAttribute( kATSUFontTag, sizeof(fontID), &fontID, NULL );
    ATSUFontIDtoFOND(fontID, &style.font, NULL);
    ts->getAttribute( kATSUSizeTag, sizeof(Fixed), &value, NULL );
    style.size = ((SInt16)FixRound((SInt32)value));
    SetControlFontStyle(lb, &style);

#ifdef DB_TABLE_ROW_HEIGHT
    //  XXX this doesn't *stick*
    ATSUTextMeasurement ascent = ts->getAttribute<ATSUTextMeasurement>( kATSUAscentTag );
    ATSUTextMeasurement descent = ts->getAttribute<ATSUTextMeasurement>( kATSUDescentTag );
    lineHeight = Fix2Long( ascent ) + Fix2Long( descent );
    SetDataBrowserTableViewRowHeight(lb, lineHeight + lineLeading);
#endif

    // !@&^#%$ we cant copy Font, but we need one for our custom drawing
    Str255 fontName255;
    char fontName[256];
    FMGetFontFamilyName(style.font, fontName255);

    CFStringRef fontNameCF = ::CFStringCreateWithPascalString( kCFAllocatorDefault, fontName255, kCFStringEncodingMacRoman );
    ::CFStringGetCString( fontNameCF, fontName, (CFIndex)255, kCFStringEncodingMacRoman );

    font.Create((const char *)fontName, 0, style.size, false, false);
}

void ListBoxImpl::SetAverageCharWidth(int width) {
        aveCharWidth = width;
}

void ListBoxImpl::SetVisibleRows(int rows) {
    desiredVisibleRows = rows;
}

int ListBoxImpl::GetVisibleRows() const {
    // XXX Windows & GTK do this, but it seems incorrect to me.  Other logic
    //     to do with visible rows is essentially the same across platforms.
    return desiredVisibleRows;
    /*
    // This would be more correct
    int rows = Length();
    if ((rows == 0) || (rows > desiredVisibleRows))
        rows = desiredVisibleRows;
    return rows;
    */
}

PRectangle ListBoxImpl::GetDesiredRect() {
    PRectangle rcDesired = GetPosition();

    // XXX because setting the line height on the table doesnt
    //     *stick*, we'll have to suffer and just use whatever
    //     the table desides is the correct height.
    UInt16 itemHeight;// = lineHeight;
    GetDataBrowserTableViewRowHeight(lb, &itemHeight);

    int rows = Length();
    if ((rows == 0) || (rows > desiredVisibleRows))
        rows = desiredVisibleRows;

    rcDesired.bottom = itemHeight * rows;
    rcDesired.right = rcDesired.left + maxItemWidth + aveCharWidth;

    if (Length() > rows) 
        rcDesired.right += kScrollBarWidth;
    rcDesired.right += IconWidth();

    // Set the column width
    ::SetDataBrowserTableViewColumnWidth (lb, UInt16 (rcDesired.right - rcDesired.left));
    return rcDesired;
}

void ListBoxImpl::ShowHideScrollbar() {
    int rows = Length();
    if (rows > desiredVisibleRows) {
        ::SetDataBrowserHasScrollBars(lb, false, true);
    } else {
        ::SetDataBrowserHasScrollBars(lb, false, false);
    }
}

int ListBoxImpl::IconWidth() {
    return xset.GetWidth() + 2;
}

int ListBoxImpl::CaretFromEdge() {
    return 0;
}

void ListBoxImpl::Clear() {
    // passing NULL to "items" arg 4 clears the list
    maxItemWidth = 0;
    ld.Clear();
    AddDataBrowserItems (lb, kDataBrowserNoItem, 0, NULL, kDataBrowserItemNoProperty);
}

void ListBoxImpl::Append(char *s, int type) {
    int count = Length();
    CFStringRef r = CFStringCreateWithCString(NULL, s, kTextEncodingMacRoman);
    ld.Add(count, type, r);

    Scintilla::SurfaceImpl surface;
    unsigned int width = surface.WidthText (font, s, strlen (s));
    if (width > maxItemWidth)
        maxItemWidth = width;

    DataBrowserItemID items[1];
    items[0] = count + 1;
    AddDataBrowserItems (lb, kDataBrowserNoItem, 1, items, kDataBrowserItemNoProperty);
    ShowHideScrollbar();
}

void ListBoxImpl::SetList(const char* list, char separator, char typesep) {
    // XXX copied from PlatGTK, should be in base class
    Clear();
    int count = strlen(list) + 1;
    char *words = new char[count];
    if (words) {
        memcpy(words, list, count);
        char *startword = words;
        char *numword = NULL;
        int i = 0;
        for (; words[i]; i++) {
            if (words[i] == separator) {
                words[i] = '\0';
                if (numword)
                    *numword = '\0';
                Append(startword, numword?atoi(numword + 1):-1);
                startword = words + i + 1;
                numword = NULL;
            } else if (words[i] == typesep) {
                numword = words + i;
            }
        }
        if (startword) {
            if (numword)
                *numword = '\0';
            Append(startword, numword?atoi(numword + 1):-1);
        }
        delete []words;
    }
}

int ListBoxImpl::Length() {
    UInt32 numItems = 0;
    GetDataBrowserItemCount(lb, kDataBrowserNoItem, false, kDataBrowserItemAnyState, &numItems);
    return (int)numItems;
}

void ListBoxImpl::Select(int n) {
    DataBrowserItemID items[1];
    items[0] = n + 1;
    SetDataBrowserSelectedItems(lb, 1, items, kDataBrowserItemsAssign);
    RevealDataBrowserItem(lb, items[0], kIconColumn, kDataBrowserRevealOnly);
    // force update on selection
    Draw1Control(lb);
}

int ListBoxImpl::GetSelection() {
    Handle selectedItems = NewHandle(0);
    GetDataBrowserItems(lb, kDataBrowserNoItem, true, kDataBrowserItemIsSelected, selectedItems);
    UInt32 numSelectedItems = GetHandleSize(selectedItems)/sizeof(DataBrowserItemID);
    if (numSelectedItems == 0) {
        return -1;
    }
    HLock( selectedItems );
    DataBrowserItemID *individualItem = (DataBrowserItemID*)( *selectedItems );
    DataBrowserItemID selected[numSelectedItems];
    selected[0] = *individualItem;
    HUnlock( selectedItems );
    return selected[0] - 1;
}

int ListBoxImpl::Find(const char *prefix) {
    int count = Length();
    char s[255];
    for (int i = 0; i < count; i++) {
        GetValue(i, s, 255);
        if (s[0] != NULL && (0 == strncmp(prefix, s, strlen(prefix)))) {
            return i;
        }
    }
    return - 1;
}

void ListBoxImpl::GetValue(int n, char *value, int len) {
    CFStringRef textString = ld.GetString(n);
    if (textString == NULL) {
        value[0] = '\0';
        return;
    }
    CFIndex numUniChars = CFStringGetLength( textString );

    // XXX how do we know the encoding of the listbox?
    CFStringEncoding encoding = kCFStringEncodingUTF8; //( IsUnicodeMode() ? kCFStringEncodingUTF8 : kCFStringEncodingASCII);
    CFIndex maximumByteLength = CFStringGetMaximumSizeForEncoding( numUniChars, encoding ) + 1;
    char* text = new char[maximumByteLength];
    CFIndex usedBufferLength = 0;
    CFStringGetBytes( textString, CFRangeMake( 0, numUniChars ), encoding,
              '?', false, reinterpret_cast<UInt8*>( text ),
              maximumByteLength, &usedBufferLength );
    text[usedBufferLength] = '\0'; // null terminate the ASCII/UTF8 string

    if (text && len > 0) {
        strncpy(value, text, len);
        value[len - 1] = '\0';
    } else {
        value[0] = '\0';
    }
    delete []text;
}

void ListBoxImpl::Sort() {
    // TODO: Implement this
    fprintf(stderr, "ListBox::Sort\n");
}

void ListBoxImpl::RegisterImage(int type, const char *xpm_data) {
    xset.Add(type, xpm_data);
}

void ListBoxImpl::ClearRegisteredImages() {
    xset.Clear();
}

Menu::Menu() : mid(0) { }

void Menu::CreatePopUp() {
    // TODO: Could I just feed a constant menu ID parameter, or does
    // it really need to be unique?
    static int nextMenuID = 1;
    Destroy();
    OSStatus err;
    err = CreateNewMenu( nextMenuID++, 0, reinterpret_cast<MenuRef*>( &mid ) );
}

void Menu::Destroy() {
    if ( mid != NULL )
    {
        ReleaseMenu( reinterpret_cast<MenuRef>( mid ) );
        mid = NULL;
    }
}

void Menu::Show(Point pt, Window &) {
    UInt32 userSelection = 0;
    SInt16 menuId = 0;
    MenuItemIndex menuItem = 0;
    ::Point globalPoint;
    globalPoint.h = pt.x;
    globalPoint.v = pt.y;
    OSStatus err;
    err = ContextualMenuSelect( reinterpret_cast<MenuRef>( mid ), globalPoint,
                                false, kCMHelpItemRemoveHelp, NULL,
                                NULL, &userSelection,
                                &menuId,
                                &menuItem
                                );
}

// TODO: Consider if I should be using GetCurrentEventTime instead of gettimeoday
ElapsedTime::ElapsedTime() {
    struct timeval curTime;
    int retVal;
    retVal = gettimeofday( &curTime, NULL );

    bigBit = curTime.tv_sec;
    littleBit = curTime.tv_usec;
}

double ElapsedTime::Duration(bool reset) {
    struct timeval curTime;
    int retVal;
    retVal = gettimeofday( &curTime, NULL );
    long endBigBit = curTime.tv_sec;
    long endLittleBit = curTime.tv_usec;
    double result = 1000000.0 * (endBigBit - bigBit);
    result += endLittleBit - littleBit;
    result /= 1000000.0;
    if (reset) {
        bigBit = endBigBit;
        littleBit = endLittleBit;
    }
    return result;
}

ColourDesired Platform::Chrome() {
    RGBColor c;
    GetThemeBrushAsColor(kThemeBrushButtonActiveDarkShadow , 24, true, &c);
    return ColourDesired(c.red>>8, c.green>>8, c.blue>>8);
}

ColourDesired Platform::ChromeHighlight() {
    RGBColor c;
    GetThemeBrushAsColor(kThemeBrushButtonInactiveLightShadow , 24, true, &c);
    return ColourDesired(c.red>>8, c.green>>8, c.blue>>8);
}

static Str255 PlatformDefaultFontName;
const char *Platform::DefaultFont() {
    long fid = HighShortFromLong(GetScriptVariable(smCurrentScript, smScriptAppFondSize));
    FMGetFontFamilyName(fid, PlatformDefaultFontName);
    char* defaultFontName = (char*) PlatformDefaultFontName;
    defaultFontName[defaultFontName[0]+1] = 0;
    ++defaultFontName;

    return defaultFontName;
}

int Platform::DefaultFontSize() {
    return LowShortFromLong(GetScriptVariable(smCurrentScript, smScriptAppFondSize));
}

unsigned int Platform::DoubleClickTime() {
    // Convert from ticks to milliseconds. I think it would be better to use the events to tell us
    // when we have a double and triple click, but what do I know?
    return static_cast<unsigned int>( TicksToEventTime( GetDblTime() ) / kEventDurationMillisecond );
}

bool Platform::MouseButtonBounce() {
    return false;
}

bool Platform::IsKeyDown(int keyCode) {
    return false;
    // TODO: Map Scintilla/Windows key codes to Mac OS X key codes
    // TODO: Do I need this?
    /*
    // Inspired by code at: http://www.sover.net/~jams/Morgan/docs/GameInputMethods.txt

    // Get the keys
    KeyMap keys;
    GetKeys( keys );

    // Calculate the key map index
    long keyMapIndex = keys[keyCode/8];
    // Calculate the individual bit to check
    short bitToCheck = keyCode % 8;
    // Check the status of the key
    return ( keyMapIndex >> bitToCheck ) & 0x01;
     */
}

long Platform::SendScintilla(WindowID w, unsigned int msg, unsigned long wParam, long lParam) {
    return scintilla_send_message( w, msg, wParam, lParam );
}

bool Platform::IsDBCSLeadByte(int /*codePage*/, char /*ch*/) {
    // TODO: Implement this for code pages != UTF-8
    return false;
}

int Platform::DBCSCharLength(int /*codePage*/, const char* /*s*/) {
    // TODO: Implement this for code pages != UTF-8
    return 1;
}

int Platform::DBCSCharMaxLength() {
    // TODO: Implement this for code pages != UTF-8
    //return CFStringGetMaximumSizeForEncoding( 1, CFStringEncoding encoding );
    return 2;
}

// These are utility functions not really tied to a platform
int Platform::Minimum(int a, int b) {
    if (a < b)
        return a;
    else
        return b;
}

int Platform::Maximum(int a, int b) {
    if (a > b)
        return a;
    else
        return b;
}

//#define TRACE
#ifdef TRACE

void Platform::DebugDisplay(const char *s) {
    fprintf( stderr, s );
}

void Platform::DebugPrintf(const char *format, ...) {
    const int BUF_SIZE = 2000;
    char buffer[BUF_SIZE];

    va_list pArguments;
    va_start(pArguments, format);
    vsnprintf(buffer, BUF_SIZE, format, pArguments);
    va_end(pArguments);
    Platform::DebugDisplay(buffer);
}

#else

void Platform::DebugDisplay(const char *) {}

void Platform::DebugPrintf(const char *, ...) {}

#endif

// Not supported for GTK+
static bool assertionPopUps = true;

bool Platform::ShowAssertionPopUps(bool assertionPopUps_) {
    bool ret = assertionPopUps;
    assertionPopUps = assertionPopUps_;
    return ret;
}

void Platform::Assert(const char *c, const char *file, int line) {
    char buffer[2000];
    sprintf(buffer, "Assertion [%s] failed at %s %d", c, file, line);
    strcat(buffer, "\r\n");
    Platform::DebugDisplay(buffer);
#ifdef DEBUG 
    // Jump into debugger in assert on Mac (CL269835)
    ::Debugger();
#endif
}

int Platform::Clamp(int val, int minVal, int maxVal) {
    if (val > maxVal)
        val = maxVal;
    if (val < minVal)
        val = minVal;
    return val;
}