[wxWidgets.git] / src / aui / dockart.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/aui/dockart.cpp
// Purpose:     wxaui: wx advanced user interface - docking window manager
// Author:      Benjamin I. Williams
// Modified by:
// Created:     2005-05-17
// RCS-ID:      $Id$
// Copyright:   (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
// Licence:     wxWindows Library Licence, Version 3.1
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_AUI

#include "wx/aui/framemanager.h"
#include "wx/aui/dockart.h"

#ifndef WX_PRECOMP
    #include "wx/settings.h"
    #include "wx/dcclient.h"
    #include "wx/image.h"
#endif

#ifdef __WXMAC__
#include "wx/mac/private.h"
#endif

// -- wxDefaultDockArt class implementation --

// wxDefaultDockArt is an art provider class which does all of the drawing for
// wxFrameManager.  This allows the library caller to customize the dock art
// (probably by deriving from this class), or to completely replace all drawing
// with custom dock art (probably by writing a new stand-alone class derived
// from the wxDockArt base class). The active dock art class can be set via
// wxFrameManager::SetDockArt()


// StepColour() it a utility function that simply darkens
// or lightens a color, based on the specified percentage
static wxColor StepColour(const wxColor& c, int percent)
{
    int r = c.Red(), g = c.Green(), b = c.Blue();
    return wxColour((unsigned char)wxMin((r*percent)/100,255),
                    (unsigned char)wxMin((g*percent)/100,255),
                    (unsigned char)wxMin((b*percent)/100,255));
}

static wxColor LightContrastColour(const wxColour& c)
{
    int amount = 120;

    // if the color is especially dark, then
    // make the contrast even lighter
    if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
        amount = 160;

    return StepColour(c, amount);
}

// BitmapFromBits() is a utility function that creates a
// masked bitmap from raw bits (XBM format)
static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h,
                               const wxColour& color)
{
    wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
    img.Replace(255,255,255,123,123,123);
    img.Replace(0,0,0,color.Red(),color.Green(),color.Blue());
    img.SetMaskColour(123,123,123);
    return wxBitmap(img);
}


static void DrawGradientRectangle(wxDC& dc,
                                  const wxRect& rect,
                                  const wxColour& start_color,
                                  const wxColour& end_color,
                                  int direction)
{
    int rd, gd, bd, high = 0;
    rd = end_color.Red() - start_color.Red();
    gd = end_color.Green() - start_color.Green();
    bd = end_color.Blue() - start_color.Blue();

    if (direction == wxAUI_GRADIENT_VERTICAL)
        high = rect.GetHeight()-1;
         else
        high = rect.GetWidth()-1;

    for (int i = 0; i <= high; ++i)
    {
        int r = start_color.Red() +  ((i*rd*100)/high)/100;
        int g = start_color.Green() + ((i*gd*100)/high)/100;
        int b = start_color.Blue() + ((i*bd*100)/high)/100;

        wxPen p(wxColor((unsigned char)r,
                        (unsigned char)g,
                        (unsigned char)b));
        dc.SetPen(p);

        if (direction == wxAUI_GRADIENT_VERTICAL)
            dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i);
             else
            dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height);
    }

}

wxDefaultDockArt::wxDefaultDockArt()
{
#ifdef __WXMAC__
    wxBrush toolbarbrush;
    toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
    wxColor base_color = toolbarbrush.GetColour();
#else
    wxColor base_color = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
#endif

    wxColor darker1_color = StepColour(base_color, 85);
    wxColor darker2_color = StepColour(base_color, 70);
    wxColor darker3_color = StepColour(base_color, 60);
    wxColor darker4_color = StepColour(base_color, 50);
    wxColor darker5_color = StepColour(base_color, 40);

    m_active_caption_colour = LightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
    m_active_caption_gradient_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
    m_active_caption_text_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
    m_inactive_caption_colour = StepColour(darker1_color, 80);
    m_inactive_caption_gradient_colour = darker1_color;
    m_inactive_caption_text_colour = *wxBLACK;

#ifdef __WXMAC__
    m_sash_brush = toolbarbrush;
    m_background_brush = toolbarbrush;
    m_gripper_brush = toolbarbrush;
#else
    m_sash_brush = wxBrush(base_color);
    m_background_brush = wxBrush(base_color);
    m_gripper_brush = wxBrush(base_color);
#endif
    m_border_pen = wxPen(darker2_color);
    m_gripper_pen1 = wxPen(darker5_color);
    m_gripper_pen2 = wxPen(darker3_color);
    m_gripper_pen3 = *wxWHITE_PEN;

#ifdef __WXMAC__
    m_caption_font = *wxSMALL_FONT;
#else
    m_caption_font = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
#endif

    // some built in bitmaps
#ifdef __WXMAC__
     static unsigned char close_bits[]={
         0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
         0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
         0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
#else
    static unsigned char close_bits[]={
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xfb,0xcf,0xf9,
        0x9f,0xfc,0x3f,0xfe,0x3f,0xfe,0x9f,0xfc,0xcf,0xf9,0xef,0xfb,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
#endif

    static unsigned char pin_bits[]={
        0xff,0xff,0xff,0xff,0xff,0xff,0x1f,0xfc,0xdf,0xfc,0xdf,0xfc,
        0xdf,0xfc,0xdf,0xfc,0xdf,0xfc,0x0f,0xf8,0x7f,0xff,0x7f,0xff,
        0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff};

#ifdef __WXMAC__
    m_inactive_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE);
#else
    m_inactive_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour);
#endif
    m_inactive_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
#ifdef __WXMAC__
    m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE );
#else
    m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_active_caption_text_colour);
#endif
    m_active_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour);

    // default metric values
#ifdef __WXMAC__
    SInt32 height;
    GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
    m_sash_size = height;
#else
    m_sash_size = 4;
#endif
    m_caption_size = 17;
    m_border_size = 1;
    m_button_size = 14;
    m_gripper_size = 9;
    m_gradient_type = wxAUI_GRADIENT_VERTICAL;
}

int wxDefaultDockArt::GetMetric(int id)
{
    switch (id)
    {
        case wxAUI_ART_SASH_SIZE:          return m_sash_size;
        case wxAUI_ART_CAPTION_SIZE:       return m_caption_size;
        case wxAUI_ART_GRIPPER_SIZE:       return m_gripper_size;
        case wxAUI_ART_PANE_BORDER_SIZE:   return m_border_size;
        case wxAUI_ART_PANE_BUTTON_SIZE:   return m_button_size;
        case wxAUI_ART_GRADIENT_TYPE:      return m_gradient_type;
        default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
    }

    return 0;
}

void wxDefaultDockArt::SetMetric(int id, int new_val)
{
    switch (id)
    {
        case wxAUI_ART_SASH_SIZE:          m_sash_size = new_val; break;
        case wxAUI_ART_CAPTION_SIZE:       m_caption_size = new_val; break;
        case wxAUI_ART_GRIPPER_SIZE:       m_gripper_size = new_val; break;
        case wxAUI_ART_PANE_BORDER_SIZE:   m_border_size = new_val; break;
        case wxAUI_ART_PANE_BUTTON_SIZE:   m_button_size = new_val; break;
        case wxAUI_ART_GRADIENT_TYPE:      m_gradient_type = new_val; break;
        default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
    }
}

wxColour wxDefaultDockArt::GetColour(int id)
{
    switch (id)
    {
        case wxAUI_ART_BACKGROUND_COLOUR:                return m_background_brush.GetColour();
        case wxAUI_ART_SASH_COLOUR:                      return m_sash_brush.GetColour();
        case wxAUI_ART_INACTIVE_CAPTION_COLOUR:          return m_inactive_caption_colour;
        case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour;
        case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR:     return m_inactive_caption_text_colour;
        case wxAUI_ART_ACTIVE_CAPTION_COLOUR:            return m_active_caption_colour;
        case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR:   return m_active_caption_gradient_colour;
        case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR:       return m_active_caption_text_colour;
        case wxAUI_ART_BORDER_COLOUR:                    return m_border_pen.GetColour();
        case wxAUI_ART_GRIPPER_COLOUR:                   return m_gripper_brush.GetColour();
        default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
    }

    return wxColour();
}

void wxDefaultDockArt::SetColour(int id, const wxColor& colour)
{
    switch (id)
    {
        case wxAUI_ART_BACKGROUND_COLOUR:                m_background_brush.SetColour(colour); break;
        case wxAUI_ART_SASH_COLOUR:                      m_sash_brush.SetColour(colour); break;
        case wxAUI_ART_INACTIVE_CAPTION_COLOUR:          m_inactive_caption_colour = colour; break;
        case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactive_caption_gradient_colour = colour; break;
        case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR:     m_inactive_caption_text_colour = colour; break;
        case wxAUI_ART_ACTIVE_CAPTION_COLOUR:            m_active_caption_colour = colour; break;
        case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR:   m_active_caption_gradient_colour = colour; break;
        case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR:       m_active_caption_text_colour = colour; break;
        case wxAUI_ART_BORDER_COLOUR:                    m_border_pen.SetColour(colour); break;
        case wxAUI_ART_GRIPPER_COLOUR:
            m_gripper_brush.SetColour(colour);
            m_gripper_pen1.SetColour(StepColour(colour, 40));
            m_gripper_pen2.SetColour(StepColour(colour, 60));
            break;
        default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
    }
}

void wxDefaultDockArt::SetFont(int id, const wxFont& font)
{
    if (id == wxAUI_ART_CAPTION_FONT)
        m_caption_font = font;
}

wxFont wxDefaultDockArt::GetFont(int id)
{
    if (id == wxAUI_ART_CAPTION_FONT)
        return m_caption_font;
    return wxNullFont;
}

void wxDefaultDockArt::DrawSash(wxDC& dc, int, const wxRect& rect)
{
#ifdef __WXMAC__
    HIRect splitterRect = CGRectMake( rect.x , rect.y , rect.width , rect.height );
    CGContextRef cgContext ;
#if wxMAC_USE_CORE_GRAPHICS
    cgContext = ((wxMacCGContext*)(dc.GetGraphicContext()))->GetNativeContext() ;
#else
    Rect bounds ;
    GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ;
    QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
    CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
    CGContextScaleCTM( cgContext , 1 , -1 ) ;
#endif

    HIThemeSplitterDrawInfo drawInfo ;
    drawInfo.version = 0 ;
    drawInfo.state = kThemeStateActive ;
    drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
    HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;

#if wxMAC_USE_CORE_GRAPHICS
#else
    QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
#endif

#else
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.SetBrush(m_sash_brush);
    dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
#endif
}


void wxDefaultDockArt::DrawBackground(wxDC& dc, int, const wxRect& rect)
{
    dc.SetPen(*wxTRANSPARENT_PEN);
#ifdef __WXMAC__
    // we have to clear first, otherwise we are drawing a light striped pattern
    // over an already darker striped background
    dc.SetBrush(*wxWHITE_BRUSH) ;
    dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
#endif
    dc.SetBrush(m_background_brush);
    dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
}

void wxDefaultDockArt::DrawBorder(wxDC& dc, const wxRect& _rect,
                                  wxPaneInfo& pane)
{
    dc.SetPen(m_border_pen);
    dc.SetBrush(*wxTRANSPARENT_BRUSH);

    wxRect rect = _rect;
    int i, border_width = GetMetric(wxAUI_ART_PANE_BORDER_SIZE);

    if (pane.IsToolbar())
    {
        for (i = 0; i < border_width; ++i)
        {
            dc.SetPen(*wxWHITE_PEN);
            dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
            dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
            dc.SetPen(m_border_pen);
            dc.DrawLine(rect.x, rect.y+rect.height-1,
                        rect.x+rect.width, rect.y+rect.height-1);
            dc.DrawLine(rect.x+rect.width-1, rect.y,
                        rect.x+rect.width-1, rect.y+rect.height);
            rect.Deflate(1);
        }
    }
    else
    {
        for (i = 0; i < border_width; ++i)
        {
            dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
            rect.Deflate(1);
        }
    }
}


void wxDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active)
{
    if (m_gradient_type == wxAUI_GRADIENT_NONE)
    {
        if (active)
            dc.SetBrush(wxBrush(m_active_caption_colour));
             else
            dc.SetBrush(wxBrush(m_inactive_caption_colour));

        dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
    }
    else
    {
        if (active)
        {
            // on mac the gradients are expected to become darker from the top
#ifdef __WXMAC__
            DrawGradientRectangle(dc, rect,
                                 m_active_caption_gradient_colour,
                                 m_active_caption_colour,
                                 m_gradient_type);
#else
            DrawGradientRectangle(dc, rect,
                                 m_active_caption_colour,
                                 m_active_caption_gradient_colour,
                                 m_gradient_type);
#endif
        }
         else
        {
            // on mac the gradients are expected to become darker from the top
#ifdef __WXMAC__
            DrawGradientRectangle(dc, rect,
                                 m_inactive_caption_gradient_colour,
                                 m_inactive_caption_colour,
                                 m_gradient_type);
#else
            DrawGradientRectangle(dc, rect,
                                 m_inactive_caption_colour,
                                 m_inactive_caption_gradient_colour,
                                 m_gradient_type);
#endif
        }
    }
}


void wxDefaultDockArt::DrawCaption(wxDC& dc,
                                   const wxString& text,
                                   const wxRect& rect,
                                   wxPaneInfo& pane)
{
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.SetFont(m_caption_font);

    DrawCaptionBackground(dc, rect,
                          (pane.state & wxPaneInfo::optionActive)?true:false);

    if (pane.state & wxPaneInfo::optionActive)
        dc.SetTextForeground(m_active_caption_text_colour);
    else
        dc.SetTextForeground(m_inactive_caption_text_colour);


    wxCoord w,h;
    dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);

    dc.SetClippingRegion(rect);
    dc.DrawText(text, rect.x+3, rect.y+(rect.height/2)-(h/2)-1);
    dc.DestroyClippingRegion();
}

void wxDefaultDockArt::DrawGripper(wxDC& dc,
                                   const wxRect& rect,
                                   wxPaneInfo& pane)
{
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.SetBrush(m_gripper_brush);

    dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);

    if (!pane.HasGripperTop())
    {
        int y = 5;
        while (1)
        {
            dc.SetPen(m_gripper_pen1);
            dc.DrawPoint(rect.x+3, rect.y+y);
            dc.SetPen(m_gripper_pen2);
            dc.DrawPoint(rect.x+3, rect.y+y+1);
            dc.DrawPoint(rect.x+4, rect.y+y);
            dc.SetPen(m_gripper_pen3);
            dc.DrawPoint(rect.x+5, rect.y+y+1);
            dc.DrawPoint(rect.x+5, rect.y+y+2);
            dc.DrawPoint(rect.x+4, rect.y+y+2);

            y += 4;
            if (y > rect.GetHeight()-5)
                break;
        }
    }
    else
    {
        int x = 5;
        while (1)
        {
            dc.SetPen(m_gripper_pen1);
            dc.DrawPoint(rect.x+x, rect.y+3);
            dc.SetPen(m_gripper_pen2);
            dc.DrawPoint(rect.x+x+1, rect.y+3);
            dc.DrawPoint(rect.x+x, rect.y+4);
            dc.SetPen(m_gripper_pen3);
            dc.DrawPoint(rect.x+x+1, rect.y+5);
            dc.DrawPoint(rect.x+x+2, rect.y+5);
            dc.DrawPoint(rect.x+x+2, rect.y+4);

            x += 4;
            if (x > rect.GetWidth()-5)
                break;
        }
    }
}

void wxDefaultDockArt::DrawPaneButton(wxDC& dc,
                                      int button,
                                      int button_state,
                                      const wxRect& _rect,
                                      wxPaneInfo& pane)
{
    wxRect rect = _rect;

    if (button_state == wxAUI_BUTTON_STATE_PRESSED)
    {
        rect.x++;
        rect.y++;
    }

    if (button_state == wxAUI_BUTTON_STATE_HOVER ||
        button_state == wxAUI_BUTTON_STATE_PRESSED)
    {
        if (pane.state & wxPaneInfo::optionActive)
        {
            dc.SetBrush(wxBrush(StepColour(m_active_caption_colour, 120)));
            dc.SetPen(wxPen(StepColour(m_active_caption_colour, 70)));
        }
         else
        {
            dc.SetBrush(wxBrush(StepColour(m_inactive_caption_colour, 120)));
            dc.SetPen(wxPen(StepColour(m_inactive_caption_colour, 70)));
        }

        // draw the background behind the button
        dc.DrawRectangle(rect.x, rect.y, 15, 15);
    }

    wxBitmap bmp;
    switch (button)
    {
        default:
        case wxPaneInfo::buttonClose:
            if (pane.state & wxPaneInfo::optionActive)
                bmp = m_active_close_bitmap;
                 else
                bmp = m_inactive_close_bitmap;
            break;
        case wxPaneInfo::buttonPin:
            if (pane.state & wxPaneInfo::optionActive)
                bmp = m_active_pin_bitmap;
                 else
                bmp = m_inactive_pin_bitmap;
            break;
    }

    // draw the button itself
    dc.DrawBitmap(bmp, rect.x, rect.y, true);
}


#endif // wxUSE_AUI
Commit	Line	Data
50acee04	1	///////////////////////////////////////////////////////////////////////////////
be66f18e	2	// Name: src/aui/dockart.cpp
50acee04 JS	3	// Purpose: wxaui: wx advanced user interface - docking window manager
	4	// Author: Benjamin I. Williams
	5	// Modified by:
	6	// Created: 2005-05-17
be66f18e	7	// RCS-ID: $Id$
50acee04 JS	8	// Copyright: (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
	9	// Licence: wxWindows Library Licence, Version 3.1
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#include "wx/wxprec.h"
	21
	22	#ifdef __BORLANDC__
	23	#pragma hdrstop
	24	#endif
	25
	26	#if wxUSE_AUI
	27
50acee04 JS	28	#include "wx/aui/framemanager.h"
	29	#include "wx/aui/dockart.h"
	30
	31	#ifndef WX_PRECOMP
be66f18e WS	32	#include "wx/settings.h"
be66f18e WS	33	#include "wx/dcclient.h"
155ecd4c	34	#include "wx/image.h"
50acee04 JS	35	#endif
50acee04 JS	36
d618ed9b RD	37	#ifdef __WXMAC__
	38	#include "wx/mac/private.h"
	39	#endif
	40
50acee04 JS	41	// -- wxDefaultDockArt class implementation --
	42
	43	// wxDefaultDockArt is an art provider class which does all of the drawing for
	44	// wxFrameManager. This allows the library caller to customize the dock art
	45	// (probably by deriving from this class), or to completely replace all drawing
	46	// with custom dock art (probably by writing a new stand-alone class derived
	47	// from the wxDockArt base class). The active dock art class can be set via
	48	// wxFrameManager::SetDockArt()
	49
	50
	51	// StepColour() it a utility function that simply darkens
	52	// or lightens a color, based on the specified percentage
	53	static wxColor StepColour(const wxColor& c, int percent)
	54	{
	55	int r = c.Red(), g = c.Green(), b = c.Blue();
be66f18e WS	56	return wxColour((unsigned char)wxMin((r*percent)/100,255),
	57	(unsigned char)wxMin((g*percent)/100,255),
	58	(unsigned char)wxMin((b*percent)/100,255));
50acee04 JS	59	}
	60
	61	static wxColor LightContrastColour(const wxColour& c)
	62	{
	63	int amount = 120;
	64
	65	// if the color is especially dark, then
	66	// make the contrast even lighter
	67	if (c.Red() < 128 && c.Green() < 128 && c.Blue() < 128)
	68	amount = 160;
	69
	70	return StepColour(c, amount);
	71	}
	72
	73	// BitmapFromBits() is a utility function that creates a
	74	// masked bitmap from raw bits (XBM format)
	75	static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h,
	76	const wxColour& color)
	77	{
	78	wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
	79	img.Replace(255,255,255,123,123,123);
	80	img.Replace(0,0,0,color.Red(),color.Green(),color.Blue());
	81	img.SetMaskColour(123,123,123);
	82	return wxBitmap(img);
	83	}
	84
	85
	86	static void DrawGradientRectangle(wxDC& dc,
	87	const wxRect& rect,
	88	const wxColour& start_color,
	89	const wxColour& end_color,
	90	int direction)
	91	{
	92	int rd, gd, bd, high = 0;
	93	rd = end_color.Red() - start_color.Red();
	94	gd = end_color.Green() - start_color.Green();
	95	bd = end_color.Blue() - start_color.Blue();
	96
	97	if (direction == wxAUI_GRADIENT_VERTICAL)
	98	high = rect.GetHeight()-1;
	99	else
	100	high = rect.GetWidth()-1;
	101
	102	for (int i = 0; i <= high; ++i)
	103	{
	104	int r = start_color.Red() + ((ird100)/high)/100;
	105	int g = start_color.Green() + ((igd100)/high)/100;
	106	int b = start_color.Blue() + ((ibd100)/high)/100;
	107
be66f18e WS	108	wxPen p(wxColor((unsigned char)r,
	109	(unsigned char)g,
	110	(unsigned char)b));
50acee04 JS	111	dc.SetPen(p);
	112
	113	if (direction == wxAUI_GRADIENT_VERTICAL)
	114	dc.DrawLine(rect.x, rect.y+i, rect.x+rect.width, rect.y+i);
	115	else
	116	dc.DrawLine(rect.x+i, rect.y, rect.x+i, rect.y+rect.height);
	117	}
	118
	119	}
	120
	121	wxDefaultDockArt::wxDefaultDockArt()
	122	{
	123	#ifdef __WXMAC__
	124	wxBrush toolbarbrush;
	125	toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
	126	wxColor base_color = toolbarbrush.GetColour();
	127	#else
	128	wxColor base_color = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
	129	#endif
be66f18e	130
50acee04 JS	131	wxColor darker1_color = StepColour(base_color, 85);
	132	wxColor darker2_color = StepColour(base_color, 70);
	133	wxColor darker3_color = StepColour(base_color, 60);
	134	wxColor darker4_color = StepColour(base_color, 50);
	135	wxColor darker5_color = StepColour(base_color, 40);
	136
	137	m_active_caption_colour = LightContrastColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
	138	m_active_caption_gradient_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
	139	m_active_caption_text_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
	140	m_inactive_caption_colour = StepColour(darker1_color, 80);
	141	m_inactive_caption_gradient_colour = darker1_color;
	142	m_inactive_caption_text_colour = *wxBLACK;
	143
	144	#ifdef __WXMAC__
	145	m_sash_brush = toolbarbrush;
	146	m_background_brush = toolbarbrush;
	147	m_gripper_brush = toolbarbrush;
	148	#else
	149	m_sash_brush = wxBrush(base_color);
	150	m_background_brush = wxBrush(base_color);
	151	m_gripper_brush = wxBrush(base_color);
	152	#endif
	153	m_border_pen = wxPen(darker2_color);
	154	m_gripper_pen1 = wxPen(darker5_color);
	155	m_gripper_pen2 = wxPen(darker3_color);
	156	m_gripper_pen3 = *wxWHITE_PEN;
	157
	158	#ifdef __WXMAC__
	159	m_caption_font = *wxSMALL_FONT;
	160	#else
	161	m_caption_font = wxFont(8, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE);
	162	#endif
	163
	164	// some built in bitmaps
	165	#ifdef __WXMAC__
	166	static unsigned char close_bits[]={
	167	0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
	168	0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
	169	0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
	170	#else
	171	static unsigned char close_bits[]={
	172	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xfb,0xcf,0xf9,
	173	0x9f,0xfc,0x3f,0xfe,0x3f,0xfe,0x9f,0xfc,0xcf,0xf9,0xef,0xfb,
	174	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
	175	#endif
	176
	177	static unsigned char pin_bits[]={
	178	0xff,0xff,0xff,0xff,0xff,0xff,0x1f,0xfc,0xdf,0xfc,0xdf,0xfc,
	179	0xdf,0xfc,0xdf,0xfc,0xdf,0xfc,0x0f,0xf8,0x7f,0xff,0x7f,0xff,
	180	0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
be66f18e	181
50acee04 JS	182	#ifdef __WXMAC__
	183	m_inactive_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE);
	184	#else
	185	m_inactive_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_inactive_caption_text_colour);
	186	#endif
	187	m_inactive_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_inactive_caption_text_colour);
	188	#ifdef __WXMAC__
	189	m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, *wxWHITE );
	190	#else
	191	m_active_close_bitmap = BitmapFromBits(close_bits, 16, 16, m_active_caption_text_colour);
	192	#endif
	193	m_active_pin_bitmap = BitmapFromBits(pin_bits, 16, 16, m_active_caption_text_colour);
	194
	195	// default metric values
	196	#ifdef __WXMAC__
	197	SInt32 height;
	198	GetThemeMetric( kThemeMetricSmallPaneSplitterHeight , &height );
	199	m_sash_size = height;
	200	#else
	201	m_sash_size = 4;
	202	#endif
	203	m_caption_size = 17;
	204	m_border_size = 1;
	205	m_button_size = 14;
	206	m_gripper_size = 9;
	207	m_gradient_type = wxAUI_GRADIENT_VERTICAL;
	208	}
	209
	210	int wxDefaultDockArt::GetMetric(int id)
	211	{
	212	switch (id)
	213	{
	214	case wxAUI_ART_SASH_SIZE: return m_sash_size;
	215	case wxAUI_ART_CAPTION_SIZE: return m_caption_size;
	216	case wxAUI_ART_GRIPPER_SIZE: return m_gripper_size;
	217	case wxAUI_ART_PANE_BORDER_SIZE: return m_border_size;
	218	case wxAUI_ART_PANE_BUTTON_SIZE: return m_button_size;
	219	case wxAUI_ART_GRADIENT_TYPE: return m_gradient_type;
	220	default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
	221	}
	222
	223	return 0;
	224	}
	225
	226	void wxDefaultDockArt::SetMetric(int id, int new_val)
	227	{
	228	switch (id)
	229	{
	230	case wxAUI_ART_SASH_SIZE: m_sash_size = new_val; break;
	231	case wxAUI_ART_CAPTION_SIZE: m_caption_size = new_val; break;
	232	case wxAUI_ART_GRIPPER_SIZE: m_gripper_size = new_val; break;
	233	case wxAUI_ART_PANE_BORDER_SIZE: m_border_size = new_val; break;
	234	case wxAUI_ART_PANE_BUTTON_SIZE: m_button_size = new_val; break;
	235	case wxAUI_ART_GRADIENT_TYPE: m_gradient_type = new_val; break;
	236	default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
	237	}
	238	}
	239
	240	wxColour wxDefaultDockArt::GetColour(int id)
	241	{
	242	switch (id)
	243	{
be66f18e WS	244	case wxAUI_ART_BACKGROUND_COLOUR: return m_background_brush.GetColour();
	245	case wxAUI_ART_SASH_COLOUR: return m_sash_brush.GetColour();
	246	case wxAUI_ART_INACTIVE_CAPTION_COLOUR: return m_inactive_caption_colour;
	247	case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: return m_inactive_caption_gradient_colour;
	248	case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR: return m_inactive_caption_text_colour;
	249	case wxAUI_ART_ACTIVE_CAPTION_COLOUR: return m_active_caption_colour;
	250	case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR: return m_active_caption_gradient_colour;
	251	case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR: return m_active_caption_text_colour;
	252	case wxAUI_ART_BORDER_COLOUR: return m_border_pen.GetColour();
	253	case wxAUI_ART_GRIPPER_COLOUR: return m_gripper_brush.GetColour();
50acee04 JS	254	default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
	255	}
	256
	257	return wxColour();
	258	}
	259
	260	void wxDefaultDockArt::SetColour(int id, const wxColor& colour)
	261	{
	262	switch (id)
	263	{
	264	case wxAUI_ART_BACKGROUND_COLOUR: m_background_brush.SetColour(colour); break;
	265	case wxAUI_ART_SASH_COLOUR: m_sash_brush.SetColour(colour); break;
	266	case wxAUI_ART_INACTIVE_CAPTION_COLOUR: m_inactive_caption_colour = colour; break;
	267	case wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR: m_inactive_caption_gradient_colour = colour; break;
	268	case wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR: m_inactive_caption_text_colour = colour; break;
	269	case wxAUI_ART_ACTIVE_CAPTION_COLOUR: m_active_caption_colour = colour; break;
	270	case wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR: m_active_caption_gradient_colour = colour; break;
	271	case wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR: m_active_caption_text_colour = colour; break;
	272	case wxAUI_ART_BORDER_COLOUR: m_border_pen.SetColour(colour); break;
	273	case wxAUI_ART_GRIPPER_COLOUR:
	274	m_gripper_brush.SetColour(colour);
	275	m_gripper_pen1.SetColour(StepColour(colour, 40));
	276	m_gripper_pen2.SetColour(StepColour(colour, 60));
	277	break;
	278	default: wxFAIL_MSG(wxT("Invalid Metric Ordinal")); break;
	279	}
	280	}
	281
	282	void wxDefaultDockArt::SetFont(int id, const wxFont& font)
	283	{
	284	if (id == wxAUI_ART_CAPTION_FONT)
	285	m_caption_font = font;
	286	}
	287
	288	wxFont wxDefaultDockArt::GetFont(int id)
	289	{
	290	if (id == wxAUI_ART_CAPTION_FONT)
	291	return m_caption_font;
	292	return wxNullFont;
	293	}
	294
	295	void wxDefaultDockArt::DrawSash(wxDC& dc, int, const wxRect& rect)
	296	{
	297	#ifdef __WXMAC__
	298	HIRect splitterRect = CGRectMake( rect.x , rect.y , rect.width , rect.height );
	299	CGContextRef cgContext ;
	300	#if wxMAC_USE_CORE_GRAPHICS
	301	cgContext = ((wxMacCGContext*)(dc.GetGraphicContext()))->GetNativeContext() ;
	302	#else
	303	Rect bounds ;
	304	GetPortBounds( (CGrafPtr) dc.m_macPort , &bounds ) ;
	305	QDBeginCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
	306	CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
	307	CGContextScaleCTM( cgContext , 1 , -1 ) ;
	308	#endif
be66f18e	309
50acee04 JS	310	HIThemeSplitterDrawInfo drawInfo ;
	311	drawInfo.version = 0 ;
	312	drawInfo.state = kThemeStateActive ;
	313	drawInfo.adornment = kHIThemeSplitterAdornmentNone ;
be66f18e WS	314	HIThemeDrawPaneSplitter( &splitterRect , &drawInfo , cgContext , kHIThemeOrientationNormal ) ;
be66f18e WS	315
50acee04 JS	316	#if wxMAC_USE_CORE_GRAPHICS
	317	#else
	318	QDEndCGContext( (CGrafPtr) dc.m_macPort , &cgContext ) ;
	319	#endif
	320
	321	#else
	322	dc.SetPen(*wxTRANSPARENT_PEN);
	323	dc.SetBrush(m_sash_brush);
	324	dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
	325	#endif
	326	}
	327
	328
	329	void wxDefaultDockArt::DrawBackground(wxDC& dc, int, const wxRect& rect)
	330	{
	331	dc.SetPen(*wxTRANSPARENT_PEN);
	332	#ifdef __WXMAC__
	333	// we have to clear first, otherwise we are drawing a light striped pattern
	334	// over an already darker striped background
	335	dc.SetBrush(*wxWHITE_BRUSH) ;
	336	dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
	337	#endif
	338	dc.SetBrush(m_background_brush);
	339	dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
	340	}
	341
	342	void wxDefaultDockArt::DrawBorder(wxDC& dc, const wxRect& _rect,
	343	wxPaneInfo& pane)
	344	{
	345	dc.SetPen(m_border_pen);
	346	dc.SetBrush(*wxTRANSPARENT_BRUSH);
	347
	348	wxRect rect = _rect;
	349	int i, border_width = GetMetric(wxAUI_ART_PANE_BORDER_SIZE);
	350
	351	if (pane.IsToolbar())
	352	{
	353	for (i = 0; i < border_width; ++i)
	354	{
	355	dc.SetPen(*wxWHITE_PEN);
	356	dc.DrawLine(rect.x, rect.y, rect.x+rect.width, rect.y);
	357	dc.DrawLine(rect.x, rect.y, rect.x, rect.y+rect.height);
be66f18e	358	dc.SetPen(m_border_pen);
50acee04 JS	359	dc.DrawLine(rect.x, rect.y+rect.height-1,
	360	rect.x+rect.width, rect.y+rect.height-1);
	361	dc.DrawLine(rect.x+rect.width-1, rect.y,
	362	rect.x+rect.width-1, rect.y+rect.height);
	363	rect.Deflate(1);
	364	}
	365	}
696978ee	366	else
50acee04 JS	367	{
	368	for (i = 0; i < border_width; ++i)
	369	{
	370	dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
	371	rect.Deflate(1);
	372	}
	373	}
	374	}
	375
	376
	377	void wxDefaultDockArt::DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active)
	378	{
	379	if (m_gradient_type == wxAUI_GRADIENT_NONE)
	380	{
	381	if (active)
	382	dc.SetBrush(wxBrush(m_active_caption_colour));
	383	else
	384	dc.SetBrush(wxBrush(m_inactive_caption_colour));
	385
	386	dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
	387	}
696978ee	388	else
50acee04 JS	389	{
	390	if (active)
	391	{
	392	// on mac the gradients are expected to become darker from the top
	393	#ifdef __WXMAC__
	394	DrawGradientRectangle(dc, rect,
	395	m_active_caption_gradient_colour,
	396	m_active_caption_colour,
	397	m_gradient_type);
	398	#else
	399	DrawGradientRectangle(dc, rect,
	400	m_active_caption_colour,
	401	m_active_caption_gradient_colour,
	402	m_gradient_type);
	403	#endif
	404	}
	405	else
	406	{
	407	// on mac the gradients are expected to become darker from the top
	408	#ifdef __WXMAC__
	409	DrawGradientRectangle(dc, rect,
	410	m_inactive_caption_gradient_colour,
	411	m_inactive_caption_colour,
	412	m_gradient_type);
	413	#else
	414	DrawGradientRectangle(dc, rect,
	415	m_inactive_caption_colour,
	416	m_inactive_caption_gradient_colour,
	417	m_gradient_type);
	418	#endif
	419	}
	420	}
	421	}
	422
	423
	424	void wxDefaultDockArt::DrawCaption(wxDC& dc,
	425	const wxString& text,
	426	const wxRect& rect,
	427	wxPaneInfo& pane)
	428	{
	429	dc.SetPen(*wxTRANSPARENT_PEN);
	430	dc.SetFont(m_caption_font);
	431
	432	DrawCaptionBackground(dc, rect,
	433	(pane.state & wxPaneInfo::optionActive)?true:false);
	434
	435	if (pane.state & wxPaneInfo::optionActive)
	436	dc.SetTextForeground(m_active_caption_text_colour);
696978ee	437	else
50acee04 JS	438	dc.SetTextForeground(m_inactive_caption_text_colour);
	439
	440
	441	wxCoord w,h;
	442	dc.GetTextExtent(wxT("ABCDEFHXfgkj"), &w, &h);
	443
	444	dc.SetClippingRegion(rect);
	445	dc.DrawText(text, rect.x+3, rect.y+(rect.height/2)-(h/2)-1);
	446	dc.DestroyClippingRegion();
	447	}
	448
	449	void wxDefaultDockArt::DrawGripper(wxDC& dc,
	450	const wxRect& rect,
	451	wxPaneInfo& pane)
	452	{
	453	dc.SetPen(*wxTRANSPARENT_PEN);
	454	dc.SetBrush(m_gripper_brush);
	455
	456	dc.DrawRectangle(rect.x, rect.y, rect.width,rect.height);
	457
	458	if (!pane.HasGripperTop())
	459	{
	460	int y = 5;
	461	while (1)
	462	{
	463	dc.SetPen(m_gripper_pen1);
	464	dc.DrawPoint(rect.x+3, rect.y+y);
	465	dc.SetPen(m_gripper_pen2);
	466	dc.DrawPoint(rect.x+3, rect.y+y+1);
	467	dc.DrawPoint(rect.x+4, rect.y+y);
	468	dc.SetPen(m_gripper_pen3);
	469	dc.DrawPoint(rect.x+5, rect.y+y+1);
	470	dc.DrawPoint(rect.x+5, rect.y+y+2);
	471	dc.DrawPoint(rect.x+4, rect.y+y+2);
	472
	473	y += 4;
	474	if (y > rect.GetHeight()-5)
	475	break;
	476	}
	477	}
	478	else
	479	{
	480	int x = 5;
	481	while (1)
	482	{
	483	dc.SetPen(m_gripper_pen1);
	484	dc.DrawPoint(rect.x+x, rect.y+3);
	485	dc.SetPen(m_gripper_pen2);
	486	dc.DrawPoint(rect.x+x+1, rect.y+3);
	487	dc.DrawPoint(rect.x+x, rect.y+4);
	488	dc.SetPen(m_gripper_pen3);
	489	dc.DrawPoint(rect.x+x+1, rect.y+5);
	490	dc.DrawPoint(rect.x+x+2, rect.y+5);
	491	dc.DrawPoint(rect.x+x+2, rect.y+4);
	492
	493	x += 4;
	494	if (x > rect.GetWidth()-5)
	495	break;
	496	}
	497	}
	498	}
	499
	500	void wxDefaultDockArt::DrawPaneButton(wxDC& dc,
	501	int button,
502	int button_state,
503	const wxRect& _rect,
504	wxPaneInfo& pane)
505	{
506	wxRect rect = _rect;
507
508	if (button_state == wxAUI_BUTTON_STATE_PRESSED)
509	{
510	rect.x++;
511	rect.y++;
512	}
513
514	if (button_state == wxAUI_BUTTON_STATE_HOVER \|\|
515	button_state == wxAUI_BUTTON_STATE_PRESSED)
516	{
517	if (pane.state & wxPaneInfo::optionActive)
518	{
519	dc.SetBrush(wxBrush(StepColour(m_active_caption_colour, 120)));
520	dc.SetPen(wxPen(StepColour(m_active_caption_colour, 70)));
521	}
522	else
523	{
524	dc.SetBrush(wxBrush(StepColour(m_inactive_caption_colour, 120)));
525	dc.SetPen(wxPen(StepColour(m_inactive_caption_colour, 70)));
526	}
527
528	// draw the background behind the button
529	dc.DrawRectangle(rect.x, rect.y, 15, 15);
530	}
531
532	wxBitmap bmp;
533	switch (button)
534	{
535	default:
536	case wxPaneInfo::buttonClose:
537	if (pane.state & wxPaneInfo::optionActive)
538	bmp = m_active_close_bitmap;
539	else
540	bmp = m_inactive_close_bitmap;
541	break;
542	case wxPaneInfo::buttonPin:
543	if (pane.state & wxPaneInfo::optionActive)
544	bmp = m_active_pin_bitmap;
545	else
546	bmp = m_inactive_pin_bitmap;
547	break;
548	}
549
550	// draw the button itself
551	dc.DrawBitmap(bmp, rect.x, rect.y, true);
552	}
553
554
555	#endif // wxUSE_AUI