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

///////////////////////////////////////////////////////////////////////////////
// Name:        src/aui/tabartgtk.cpp
// Purpose:     implementation of the wxAuiGTKTabArt
// Author:      Jens Lody and Teodor Petrov
// Modified by:
// Created:     2012-03-23
// RCS-ID:      $Id$
// Copyright:   (c) 2012 Jens Lody <jens@codeblocks.org>
//                  and Teodor Petrov
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

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

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

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_AUI

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

#include "wx/gtk/dc.h"
#include "wx/gtk/private.h"

#include <gtk/gtk.h>

#include "wx/aui/auibook.h"
#include "wx/aui/tabartgtk.h"
#include "wx/renderer.h"

namespace
{

static int s_CloseIconSize = 16; // default size

}

wxAuiGtkTabArt::wxAuiGtkTabArt()//:
//    m_Xthickness(0),
//    m_Ythickness(0),
//    m_TabHBorder(0),
//    m_TabVBorder(0)

{
}

wxAuiTabArt* wxAuiGtkTabArt::Clone()
{
    wxAuiGtkTabArt* clone = new wxAuiGtkTabArt();

    clone->SetNormalFont(m_normalFont);
    clone->SetSelectedFont(m_normalFont);
    clone->SetMeasuringFont(m_normalFont);

    return clone;
}

void wxAuiGtkTabArt::DrawBackground(wxDC& dc, wxWindow* WXUNUSED(wnd), const wxRect& rect)
{
    wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
    GdkWindow* window = impldc->GetGDKWindow();

    gtk_style_apply_default_background(gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget()),
                                       window,
                                       true,
                                       GTK_STATE_NORMAL,
                                       NULL,
                                       rect.x, rect.y, rect.width, rect.height);
}

void ButtonStateAndShadow(int button_state, GtkStateType &state, GtkShadowType &shadow)
{

    if (button_state & wxAUI_BUTTON_STATE_DISABLED)
    {
        state = GTK_STATE_INSENSITIVE;
        shadow = GTK_SHADOW_ETCHED_IN;
    }
    else if (button_state & wxAUI_BUTTON_STATE_HOVER)
    {
        state = GTK_STATE_PRELIGHT;
        shadow = GTK_SHADOW_OUT;
    }
    else if (button_state & wxAUI_BUTTON_STATE_PRESSED)
    {
        state = GTK_STATE_ACTIVE;
        shadow = GTK_SHADOW_IN;
    }
    else
    {
        state = GTK_STATE_NORMAL;
        shadow = GTK_SHADOW_OUT;
    }
}

wxRect DrawCloseButton(wxDC& dc,
                       GtkWidget *widget,
                       int button_state,
                       wxRect const &in_rect,
                       int orientation,
                       GdkRectangle* clipRect)
{
    GtkStyle *style_button = gtk_widget_get_style(wxGTKPrivate::GetButtonWidget());
    int xthickness = style_button->xthickness;
    int ythickness = style_button->ythickness;

    wxBitmap bmp(gtk_widget_render_icon(widget, GTK_STOCK_CLOSE, GTK_ICON_SIZE_SMALL_TOOLBAR, "tab"));

    if(bmp.GetWidth() != s_CloseIconSize || bmp.GetHeight() != s_CloseIconSize)
    {
        wxImage img = bmp.ConvertToImage();
        img.Rescale(s_CloseIconSize, s_CloseIconSize);
        bmp = img;
    }

    int button_size = s_CloseIconSize + 2 * xthickness;

    wxRect out_rect;

    if (orientation == wxLEFT)
        out_rect.x = in_rect.x - ythickness;
    else
        out_rect.x = in_rect.x + in_rect.width - button_size - ythickness;

    out_rect.y = in_rect.y + (in_rect.height - button_size) / 2;
    out_rect.width = button_size;
    out_rect.height = button_size;

    wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
    GdkWindow* window = impldc->GetGDKWindow();

    if (button_state == wxAUI_BUTTON_STATE_HOVER)
    {
        gtk_paint_box(style_button, window,
                      GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, clipRect, widget, "button",
                     out_rect.x, out_rect.y, out_rect.width, out_rect.height);
    }
    else if (button_state == wxAUI_BUTTON_STATE_PRESSED)
    {
        gtk_paint_box(style_button, window,
                      GTK_STATE_ACTIVE, GTK_SHADOW_IN, clipRect, widget, "button",
                      out_rect.x, out_rect.y, out_rect.width, out_rect.height);
    }


    dc.DrawBitmap(bmp, out_rect.x + xthickness, out_rect.y + ythickness, true);

    return out_rect;
}

void wxAuiGtkTabArt::DrawTab(wxDC& dc, wxWindow* wnd, const wxAuiNotebookPage& page,
                             const wxRect& in_rect, int close_button_state, wxRect* out_tab_rect,
                             wxRect* out_button_rect, int* x_extent)
{
    GtkWidget *widget = wnd->GetHandle();
    GtkStyle *style_notebook = gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget());

    wxRect const &window_rect = wnd->GetRect();

    int focus_width = 0;

    gtk_widget_style_get(wxGTKPrivate::GetNotebookWidget(),
                         "focus-line-width", &focus_width,
                         NULL);

    int gap_x = 0, gap_width = 0;
    int tab_pos;
    if (m_flags &wxAUI_NB_BOTTOM)
        tab_pos = wxAUI_NB_BOTTOM;
    else //if (m_flags & wxAUI_NB_TOP) {}
        tab_pos = wxAUI_NB_TOP;

    // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
    // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}

    // figure out the size of the tab
    wxSize tab_size = GetTabSize(dc, wnd, page.caption, page.bitmap,
                                    page.active, close_button_state, x_extent);

    wxRect tab_rect = in_rect;
    tab_rect.width = tab_size.x;
    tab_rect.height = tab_size.y;
    tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;

    if (page.active)
        tab_rect.height += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
    // if no bitmap is set, we need a tiny correction
    if (! page.bitmap.IsOk())
        tab_rect.height += 1;

    int gap_height = 6 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
    int gap_y = tab_rect.y - gap_height;

    switch (tab_pos)
    {
        case wxAUI_NB_TOP:
            tab_rect.y -= 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
            if (!page.active)
                tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
            gap_y = tab_rect.y + tab_rect.height;
            // fall through
        case wxAUI_NB_BOTTOM:
            gap_x = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder / 2;
            gap_width = tab_rect.width;
            break;
    }
    tab_rect.y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
    gap_y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;

    int padding = focus_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;

    int clip_width = tab_rect.width;
    if (tab_rect.x + tab_rect.width > in_rect.x + in_rect.width)
        clip_width = (in_rect.x + in_rect.width) - tab_rect.x;

    dc.SetClippingRegion(tab_rect.x, tab_rect.y - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder, clip_width, tab_rect.height + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder);

    GdkRectangle area;
    area.x = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
    area.y = tab_rect.y - 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
    area.width = clip_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
    area.height = tab_rect.height + 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;

    wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
    GdkWindow* window = impldc->GetGDKWindow();

    if (tab_pos == wxAUI_NB_BOTTOM)
    {
        if (page.active)
        {
            gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
                              NULL, widget,
                              const_cast<char*>("notebook"),
                              window_rect.x, gap_y,
                              window_rect.width, gap_height,
                              GTK_POS_BOTTOM, gap_x , gap_width);
        }
        gtk_paint_extension(style_notebook, window,
                           page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
                           &area, widget,
                           const_cast<char*>("tab"),
                           tab_rect.x, tab_rect.y,
                           tab_rect.width, tab_rect.height,
                           GTK_POS_TOP);
    }
    else
    {
        if (page.active)
        {
            gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
                              NULL, widget,
                              const_cast<char*>("notebook"),
                              window_rect.x, gap_y,
                              window_rect.width, gap_height,
                              GTK_POS_TOP, gap_x , gap_width);
        }
        gtk_paint_extension(style_notebook, window,
                           page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
                           &area, widget,
                           const_cast<char*>("tab"),
                           tab_rect.x, tab_rect.y,
                           tab_rect.width, tab_rect.height,
                           GTK_POS_BOTTOM);
    }

    wxCoord textX = tab_rect.x + padding + style_notebook->xthickness;

    int bitmap_offset = 0;
    if (page.bitmap.IsOk())
    {
        bitmap_offset = textX;

        // draw bitmap
        int bitmapY = tab_rect.y +(tab_rect.height - page.bitmap.GetHeight()) / 2;
        if(!page.active)
        {
            if (tab_pos == wxAUI_NB_TOP)
                bitmapY += style_notebook->ythickness / 2;
            else
                bitmapY -= style_notebook->ythickness / 2;
        }
        dc.DrawBitmap(page.bitmap,
                      bitmap_offset,
                      bitmapY,
                      true);

        textX += page.bitmap.GetWidth() + padding;
    }

    wxCoord textW, textH, textY;

    dc.SetFont(m_normalFont);
    dc.GetTextExtent(page.caption, &textW, &textH);
    textY = tab_rect.y + (tab_rect.height - textH) / 2;
    if(!page.active)
    {
        if (tab_pos == wxAUI_NB_TOP)
            textY += style_notebook->ythickness / 2;
        else
            textY -= style_notebook->ythickness / 2;
    }

    // draw tab text
    GdkColor text_colour = page.active ? style_notebook->fg[GTK_STATE_NORMAL] : style_notebook->fg[GTK_STATE_ACTIVE];
    dc.SetTextForeground(wxColor(text_colour));
    GdkRectangle focus_area;

    int padding_focus = padding - focus_width;
    focus_area.x = tab_rect.x + padding_focus;
    focus_area.y = textY - focus_width;
    focus_area.width = tab_rect.width - 2 * padding_focus;
    focus_area.height = textH + 2 * focus_width;

    if(page.active && (wnd->FindFocus() == wnd) && focus_area.x <= (area.x + area.width))
    {
        // clipping seems not to work here, so we we have to recalc the focus-area manually
        if((focus_area.x + focus_area.width) > (area.x + area.width))
            focus_area.width = area.x + area.width - focus_area.x + focus_width - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
        gtk_paint_focus (style_notebook, window,
                         GTK_STATE_ACTIVE, NULL, widget, "tab",
                         focus_area.x, focus_area.y, focus_area.width, focus_area.height);
    }

    dc.DrawText(page.caption, textX, textY);

    // draw close-button on tab (if enabled)
    if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
    {
        wxRect rect(tab_rect.x, tab_rect.y, tab_rect.width - style_notebook->xthickness, tab_rect.height);
        if(!page.active)
        {
            if (tab_pos == wxAUI_NB_TOP)
                rect.y += style_notebook->ythickness / 2;
            else
                rect.y -= style_notebook->ythickness / 2;
        }
        *out_button_rect = DrawCloseButton(dc, widget, close_button_state, rect, wxRIGHT, &area);
    }

    tab_rect.width = std::min(tab_rect.width, clip_width);
    *out_tab_rect = tab_rect;

    dc.DestroyClippingRegion();
}

wxRect DrawSimpleArrow(wxDC& dc,
                       GtkWidget *widget,
                       int button_state,
                       wxRect const &in_rect,
                       int orientation,
                       GtkArrowType arrow_type)
{
    int scroll_arrow_hlength, scroll_arrow_vlength;
    gtk_widget_style_get(widget,
                         "scroll-arrow-hlength", &scroll_arrow_hlength,
                         "scroll-arrow-vlength", &scroll_arrow_vlength,
                         NULL);

    GtkStateType state;
    GtkShadowType shadow;
    ButtonStateAndShadow(button_state, state, shadow);

    wxRect out_rect;

    if (orientation == wxLEFT)
        out_rect.x = in_rect.x;
    else
        out_rect.x = in_rect.x + in_rect.width - scroll_arrow_hlength;
    out_rect.y = (in_rect.y + in_rect.height - 3 * gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget())->ythickness - scroll_arrow_vlength) / 2;
    out_rect.width = scroll_arrow_hlength;
    out_rect.height = scroll_arrow_vlength;

    wxGTKDCImpl *impldc = (wxGTKDCImpl*) dc.GetImpl();
    GdkWindow* window = impldc->GetGDKWindow();
    gtk_paint_arrow (gtk_widget_get_style(wxGTKPrivate::GetButtonWidget()), window, state, shadow, NULL, widget, "notebook",
                     arrow_type, TRUE, out_rect.x, out_rect.y, out_rect.width, out_rect.height);

    return out_rect;
}

void wxAuiGtkTabArt::DrawButton(wxDC& dc, wxWindow* wnd,
                            const wxRect& in_rect,
                            int bitmap_id,
                            int button_state,
                            int orientation,
                            wxRect* out_rect)
{
    GtkWidget *widget = wnd->GetHandle();
    wxRect rect = in_rect;
    if (m_flags &wxAUI_NB_BOTTOM)
        rect.y += 2 * gtk_widget_get_style(wxGTKPrivate::GetButtonWidget())->ythickness;

    switch (bitmap_id)
    {
        case wxAUI_BUTTON_CLOSE:
            rect.y -= 2 * gtk_widget_get_style(wxGTKPrivate::GetButtonWidget())->ythickness;
            rect = DrawCloseButton(dc, widget, button_state, rect, orientation, NULL);
            break;

        case wxAUI_BUTTON_LEFT:
            rect = DrawSimpleArrow(dc, widget, button_state, rect, orientation, GTK_ARROW_LEFT);
            break;

        case wxAUI_BUTTON_RIGHT:
            rect = DrawSimpleArrow(dc, widget, button_state, rect, orientation, GTK_ARROW_RIGHT);
            break;

        case wxAUI_BUTTON_WINDOWLIST:
            {
                rect.height -= 4 * gtk_widget_get_style(wxGTKPrivate::GetButtonWidget())->ythickness;
                rect.width = rect.height;
                rect.x = in_rect.x + in_rect.width - rect.width;

                if (button_state == wxAUI_BUTTON_STATE_HOVER)
                    wxRendererNative::Get().DrawComboBoxDropButton(wnd, dc, rect, wxCONTROL_CURRENT);
                else if (button_state == wxAUI_BUTTON_STATE_PRESSED)
                    wxRendererNative::Get().DrawComboBoxDropButton(wnd, dc, rect, wxCONTROL_PRESSED);
                else
                    wxRendererNative::Get().DrawDropArrow(wnd, dc, rect);
            }
            break;
    }

    *out_rect = rect;
}


int wxAuiGtkTabArt::GetBestTabCtrlSize(wxWindow* wnd,
                                   const wxAuiNotebookPageArray& pages,
                                   const wxSize& required_bmp_size)
{
    SetMeasuringFont(m_normalFont);
    SetSelectedFont(m_normalFont);
    int tab_height = 3 * gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget())->ythickness + wxAuiGenericTabArt::GetBestTabCtrlSize(wnd, pages, required_bmp_size);
    return tab_height;
}

wxSize wxAuiGtkTabArt::GetTabSize(wxDC& dc,
                              wxWindow* wnd,
                              const wxString& caption,
                              const wxBitmap& bitmap,
                              bool active,
                              int close_button_state,
                              int* x_extent)
{
    wxSize s = wxAuiGenericTabArt::GetTabSize(dc, wnd, caption, bitmap, active, close_button_state, x_extent);

    int overlap = 0;
    gtk_widget_style_get (wnd->GetHandle(),
        "focus-line-width", &overlap,
        NULL);
    *x_extent -= overlap;
    return s;
}
#endif  // wxUSE_AUI
Commit	Line	Data
069358b7 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/aui/tabartgtk.cpp
	3	// Purpose: implementation of the wxAuiGTKTabArt
	4	// Author: Jens Lody and Teodor Petrov
	5	// Modified by:
	6	// Created: 2012-03-23
54195d23	7	// RCS-ID: $Id$
069358b7 VZ	8	// Copyright: (c) 2012 Jens Lody <jens@codeblocks.org>
	9	// and Teodor Petrov
	10	// Licence: wxWindows licence
	11	///////////////////////////////////////////////////////////////////////////////
	12
	13	// ============================================================================
	14	// declarations
	15	// ============================================================================
	16
	17	// ----------------------------------------------------------------------------
	18	// headers
	19	// ----------------------------------------------------------------------------
	20
	21	// For compilers that support precompilation, includes "wx.h".
	22	#include "wx/wxprec.h"
	23
	24	#ifdef __BORLANDC__
	25	#pragma hdrstop
	26	#endif
	27
	28	#if wxUSE_AUI
	29
	30	#ifndef WX_PRECOMP
	31	#include "wx/dc.h"
	32	#include "wx/dcclient.h"
	33	#include "wx/settings.h"
	34	#include "wx/image.h"
	35	#endif
	36
	37	#include "wx/gtk/dc.h"
	38	#include "wx/gtk/private.h"
	39
	40	#include <gtk/gtk.h>
	41
	42	#include "wx/aui/auibook.h"
	43	#include "wx/aui/tabartgtk.h"
	44	#include "wx/renderer.h"
	45
	46	namespace
	47	{
	48
	49	static int s_CloseIconSize = 16; // default size
	50
	51	}
	52
	53	wxAuiGtkTabArt::wxAuiGtkTabArt()//:
	54	// m_Xthickness(0),
	55	// m_Ythickness(0),
	56	// m_TabHBorder(0),
	57	// m_TabVBorder(0)
	58
	59	{
	60	}
	61
	62	wxAuiTabArt* wxAuiGtkTabArt::Clone()
	63	{
	64	wxAuiGtkTabArt* clone = new wxAuiGtkTabArt();
	65
	66	clone->SetNormalFont(m_normalFont);
	67	clone->SetSelectedFont(m_normalFont);
	68	clone->SetMeasuringFont(m_normalFont);
	69
	70	return clone;
	71	}
72
73	void wxAuiGtkTabArt::DrawBackground(wxDC& dc, wxWindow* WXUNUSED(wnd), const wxRect& rect)
74	{
75	wxGTKDCImpl impldc = (wxGTKDCImpl) dc.GetImpl();
76	GdkWindow* window = impldc->GetGDKWindow();
77
78	gtk_style_apply_default_background(gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget()),
79	window,
80	true,
81	GTK_STATE_NORMAL,
82	NULL,
83	rect.x, rect.y, rect.width, rect.height);
84	}
85
86	void ButtonStateAndShadow(int button_state, GtkStateType &state, GtkShadowType &shadow)
87	{
88
89	if (button_state & wxAUI_BUTTON_STATE_DISABLED)
90	{
91	state = GTK_STATE_INSENSITIVE;
92	shadow = GTK_SHADOW_ETCHED_IN;
93	}
94	else if (button_state & wxAUI_BUTTON_STATE_HOVER)
95	{
96	state = GTK_STATE_PRELIGHT;
97	shadow = GTK_SHADOW_OUT;
98	}
99	else if (button_state & wxAUI_BUTTON_STATE_PRESSED)
100	{
101	state = GTK_STATE_ACTIVE;
102	shadow = GTK_SHADOW_IN;
103	}
104	else
105	{
106	state = GTK_STATE_NORMAL;
107	shadow = GTK_SHADOW_OUT;
108	}
109	}
110
111	wxRect DrawCloseButton(wxDC& dc,
112	GtkWidget *widget,
113	int button_state,
114	wxRect const &in_rect,
115	int orientation,
116	GdkRectangle* clipRect)
117	{
118	GtkStyle *style_button = gtk_widget_get_style(wxGTKPrivate::GetButtonWidget());
119	int xthickness = style_button->xthickness;
120	int ythickness = style_button->ythickness;
121
54195d23	122	wxBitmap bmp(gtk_widget_render_icon(widget, GTK_STOCK_CLOSE, GTK_ICON_SIZE_SMALL_TOOLBAR, "tab"));
069358b7 VZ	123
	124	if(bmp.GetWidth() != s_CloseIconSize \|\| bmp.GetHeight() != s_CloseIconSize)
	125	{
	126	wxImage img = bmp.ConvertToImage();
	127	img.Rescale(s_CloseIconSize, s_CloseIconSize);
	128	bmp = img;
	129	}
	130
	131	int button_size = s_CloseIconSize + 2 * xthickness;
	132
	133	wxRect out_rect;
	134
	135	if (orientation == wxLEFT)
	136	out_rect.x = in_rect.x - ythickness;
	137	else
	138	out_rect.x = in_rect.x + in_rect.width - button_size - ythickness;
	139
	140	out_rect.y = in_rect.y + (in_rect.height - button_size) / 2;
	141	out_rect.width = button_size;
	142	out_rect.height = button_size;
	143
	144	wxGTKDCImpl impldc = (wxGTKDCImpl) dc.GetImpl();
	145	GdkWindow* window = impldc->GetGDKWindow();
	146
	147	if (button_state == wxAUI_BUTTON_STATE_HOVER)
	148	{
	149	gtk_paint_box(style_button, window,
	150	GTK_STATE_PRELIGHT, GTK_SHADOW_OUT, clipRect, widget, "button",
	151	out_rect.x, out_rect.y, out_rect.width, out_rect.height);
	152	}
	153	else if (button_state == wxAUI_BUTTON_STATE_PRESSED)
	154	{
	155	gtk_paint_box(style_button, window,
	156	GTK_STATE_ACTIVE, GTK_SHADOW_IN, clipRect, widget, "button",
	157	out_rect.x, out_rect.y, out_rect.width, out_rect.height);
	158	}
	159
	160
	161	dc.DrawBitmap(bmp, out_rect.x + xthickness, out_rect.y + ythickness, true);
	162
	163	return out_rect;
	164	}
	165
	166	void wxAuiGtkTabArt::DrawTab(wxDC& dc, wxWindow* wnd, const wxAuiNotebookPage& page,
	167	const wxRect& in_rect, int close_button_state, wxRect* out_tab_rect,
	168	wxRect* out_button_rect, int* x_extent)
	169	{
	170	GtkWidget *widget = wnd->GetHandle();
	171	GtkStyle *style_notebook = gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget());
	172
	173	wxRect const &window_rect = wnd->GetRect();
	174
	175	int focus_width = 0;
	176
	177	gtk_widget_style_get(wxGTKPrivate::GetNotebookWidget(),
	178	"focus-line-width", &focus_width,
	179	NULL);
	180
	181	int gap_x = 0, gap_width = 0;
	182	int tab_pos;
	183	if (m_flags &wxAUI_NB_BOTTOM)
	184	tab_pos = wxAUI_NB_BOTTOM;
	185	else //if (m_flags & wxAUI_NB_TOP) {}
	186	tab_pos = wxAUI_NB_TOP;
187
188	// TODO: else if (m_flags &wxAUI_NB_LEFT) {}
189	// TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
190
191	// figure out the size of the tab
192	wxSize tab_size = GetTabSize(dc, wnd, page.caption, page.bitmap,
193	page.active, close_button_state, x_extent);
194
195	wxRect tab_rect = in_rect;
196	tab_rect.width = tab_size.x;
197	tab_rect.height = tab_size.y;
198	tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
199
200	if (page.active)
201	tab_rect.height += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
202	// if no bitmap is set, we need a tiny correction
203	if (! page.bitmap.IsOk())
204	tab_rect.height += 1;
205
206	int gap_height = 6 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
207	int gap_y = tab_rect.y - gap_height;
208
209	switch (tab_pos)
210	{
211	case wxAUI_NB_TOP:
212	tab_rect.y -= 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
213	if (!page.active)
214	tab_rect.y += 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
215	gap_y = tab_rect.y + tab_rect.height;
216	// fall through
217	case wxAUI_NB_BOTTOM:
218	gap_x = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder / 2;
219	gap_width = tab_rect.width;
220	break;
221	}
222	tab_rect.y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
223	gap_y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
224
225	int padding = focus_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
226
227	int clip_width = tab_rect.width;
228	if (tab_rect.x + tab_rect.width > in_rect.x + in_rect.width)
229	clip_width = (in_rect.x + in_rect.width) - tab_rect.x;
230
231	dc.SetClippingRegion(tab_rect.x, tab_rect.y - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder, clip_width, tab_rect.height + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder);
232
233	GdkRectangle area;
234	area.x = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
235	area.y = tab_rect.y - 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
236	area.width = clip_width + GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
237	area.height = tab_rect.height + 2 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
238
239	wxGTKDCImpl impldc = (wxGTKDCImpl) dc.GetImpl();
240	GdkWindow* window = impldc->GetGDKWindow();
241
242	if (tab_pos == wxAUI_NB_BOTTOM)
243	{
244	if (page.active)
245	{
246	gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
247	NULL, widget,
248	const_cast<char*>("notebook"),
249	window_rect.x, gap_y,
250	window_rect.width, gap_height,
251	GTK_POS_BOTTOM, gap_x , gap_width);
252	}
253	gtk_paint_extension(style_notebook, window,
254	page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
255	&area, widget,
256	const_cast<char*>("tab"),
257	tab_rect.x, tab_rect.y,
258	tab_rect.width, tab_rect.height,
259	GTK_POS_TOP);
260	}
261	else
262	{
263	if (page.active)
264	{
265	gtk_paint_box_gap(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
266	NULL, widget,
267	const_cast<char*>("notebook"),
268	window_rect.x, gap_y,
269	window_rect.width, gap_height,
270	GTK_POS_TOP, gap_x , gap_width);
271	}
272	gtk_paint_extension(style_notebook, window,
273	page.active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
274	&area, widget,
275	const_cast<char*>("tab"),
276	tab_rect.x, tab_rect.y,
277	tab_rect.width, tab_rect.height,
278	GTK_POS_BOTTOM);
279	}
280
281	wxCoord textX = tab_rect.x + padding + style_notebook->xthickness;
282
283	int bitmap_offset = 0;
284	if (page.bitmap.IsOk())
285	{
286	bitmap_offset = textX;
287
288	// draw bitmap
289	int bitmapY = tab_rect.y +(tab_rect.height - page.bitmap.GetHeight()) / 2;
290	if(!page.active)
291	{
292	if (tab_pos == wxAUI_NB_TOP)
293	bitmapY += style_notebook->ythickness / 2;
294	else
295	bitmapY -= style_notebook->ythickness / 2;
296	}
297	dc.DrawBitmap(page.bitmap,
298	bitmap_offset,
299	bitmapY,
300	true);
301
302	textX += page.bitmap.GetWidth() + padding;
303	}
304
305	wxCoord textW, textH, textY;
306
307	dc.SetFont(m_normalFont);
308	dc.GetTextExtent(page.caption, &textW, &textH);
309	textY = tab_rect.y + (tab_rect.height - textH) / 2;
310	if(!page.active)
311	{
312	if (tab_pos == wxAUI_NB_TOP)
313	textY += style_notebook->ythickness / 2;
314	else
315	textY -= style_notebook->ythickness / 2;
316	}
317
318	// draw tab text
319	GdkColor text_colour = page.active ? style_notebook->fg[GTK_STATE_NORMAL] : style_notebook->fg[GTK_STATE_ACTIVE];
320	dc.SetTextForeground(wxColor(text_colour));
321	GdkRectangle focus_area;
322
323	int padding_focus = padding - focus_width;
324	focus_area.x = tab_rect.x + padding_focus;
325	focus_area.y = textY - focus_width;
326	focus_area.width = tab_rect.width - 2 * padding_focus;
327	focus_area.height = textH + 2 * focus_width;
328
329	if(page.active && (wnd->FindFocus() == wnd) && focus_area.x <= (area.x + area.width))
330	{
331	// clipping seems not to work here, so we we have to recalc the focus-area manually
332	if((focus_area.x + focus_area.width) > (area.x + area.width))
333	focus_area.width = area.x + area.width - focus_area.x + focus_width - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder;
334	gtk_paint_focus (style_notebook, window,
335	GTK_STATE_ACTIVE, NULL, widget, "tab",
336	focus_area.x, focus_area.y, focus_area.width, focus_area.height);
337	}
338
339	dc.DrawText(page.caption, textX, textY);
340
341	// draw close-button on tab (if enabled)
342	if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
343	{
344	wxRect rect(tab_rect.x, tab_rect.y, tab_rect.width - style_notebook->xthickness, tab_rect.height);
345	if(!page.active)
346	{
347	if (tab_pos == wxAUI_NB_TOP)
348	rect.y += style_notebook->ythickness / 2;
349	else
350	rect.y -= style_notebook->ythickness / 2;
351	}
352	*out_button_rect = DrawCloseButton(dc, widget, close_button_state, rect, wxRIGHT, &area);
353	}
354
355	tab_rect.width = std::min(tab_rect.width, clip_width);
356	*out_tab_rect = tab_rect;
357
358	dc.DestroyClippingRegion();
359	}
360
361	wxRect DrawSimpleArrow(wxDC& dc,
362	GtkWidget *widget,
363	int button_state,
364	wxRect const &in_rect,
365	int orientation,
366	GtkArrowType arrow_type)
367	{
368	int scroll_arrow_hlength, scroll_arrow_vlength;
369	gtk_widget_style_get(widget,
370	"scroll-arrow-hlength", &scroll_arrow_hlength,
371	"scroll-arrow-vlength", &scroll_arrow_vlength,
372	NULL);
373
374	GtkStateType state;
375	GtkShadowType shadow;
376	ButtonStateAndShadow(button_state, state, shadow);
377
378	wxRect out_rect;
379
380	if (orientation == wxLEFT)
381	out_rect.x = in_rect.x;
382	else
383	out_rect.x = in_rect.x + in_rect.width - scroll_arrow_hlength;
384	out_rect.y = (in_rect.y + in_rect.height - 3 * gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget())->ythickness - scroll_arrow_vlength) / 2;
385	out_rect.width = scroll_arrow_hlength;
386	out_rect.height = scroll_arrow_vlength;
387
388	wxGTKDCImpl impldc = (wxGTKDCImpl) dc.GetImpl();
389	GdkWindow* window = impldc->GetGDKWindow();
390	gtk_paint_arrow (gtk_widget_get_style(wxGTKPrivate::GetButtonWidget()), window, state, shadow, NULL, widget, "notebook",
391	arrow_type, TRUE, out_rect.x, out_rect.y, out_rect.width, out_rect.height);
392
393	return out_rect;
394	}
395
396	void wxAuiGtkTabArt::DrawButton(wxDC& dc, wxWindow* wnd,
397	const wxRect& in_rect,
398	int bitmap_id,
399	int button_state,
400	int orientation,
401	wxRect* out_rect)
402	{
403	GtkWidget *widget = wnd->GetHandle();
404	wxRect rect = in_rect;
405	if (m_flags &wxAUI_NB_BOTTOM)
406	rect.y += 2 * gtk_widget_get_style(wxGTKPrivate::GetButtonWidget())->ythickness;
407
408	switch (bitmap_id)
409	{
410	case wxAUI_BUTTON_CLOSE:
411	rect.y -= 2 * gtk_widget_get_style(wxGTKPrivate::GetButtonWidget())->ythickness;
412	rect = DrawCloseButton(dc, widget, button_state, rect, orientation, NULL);
413	break;
414
415	case wxAUI_BUTTON_LEFT:
416	rect = DrawSimpleArrow(dc, widget, button_state, rect, orientation, GTK_ARROW_LEFT);
417	break;
418
419	case wxAUI_BUTTON_RIGHT:
420	rect = DrawSimpleArrow(dc, widget, button_state, rect, orientation, GTK_ARROW_RIGHT);
421	break;
422
423	case wxAUI_BUTTON_WINDOWLIST:
424	{
425	rect.height -= 4 * gtk_widget_get_style(wxGTKPrivate::GetButtonWidget())->ythickness;
426	rect.width = rect.height;
427	rect.x = in_rect.x + in_rect.width - rect.width;
428
429	if (button_state == wxAUI_BUTTON_STATE_HOVER)
430	wxRendererNative::Get().DrawComboBoxDropButton(wnd, dc, rect, wxCONTROL_CURRENT);
431	else if (button_state == wxAUI_BUTTON_STATE_PRESSED)
432	wxRendererNative::Get().DrawComboBoxDropButton(wnd, dc, rect, wxCONTROL_PRESSED);
433	else
434	wxRendererNative::Get().DrawDropArrow(wnd, dc, rect);
435	}
436	break;
437	}
438
439	*out_rect = rect;
440	}
441
442
443	int wxAuiGtkTabArt::GetBestTabCtrlSize(wxWindow* wnd,
444	const wxAuiNotebookPageArray& pages,
445	const wxSize& required_bmp_size)
446	{
447	SetMeasuringFont(m_normalFont);
448	SetSelectedFont(m_normalFont);
449	int tab_height = 3 * gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget())->ythickness + wxAuiGenericTabArt::GetBestTabCtrlSize(wnd, pages, required_bmp_size);
450	return tab_height;
451	}
452
453	wxSize wxAuiGtkTabArt::GetTabSize(wxDC& dc,
454	wxWindow* wnd,
455	const wxString& caption,
456	const wxBitmap& bitmap,
457	bool active,
458	int close_button_state,
459	int* x_extent)
460	{
461	wxSize s = wxAuiGenericTabArt::GetTabSize(dc, wnd, caption, bitmap, active, close_button_state, x_extent);
462
463	int overlap = 0;
464	gtk_widget_style_get (wnd->GetHandle(),
465	"focus-line-width", &overlap,
466	NULL);
467	*x_extent -= overlap;
468	return s;
469	}
470	#endif // wxUSE_AUI