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
// 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()

{
}

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 wxAuiGtkTabArt::DrawBorder(wxDC& WXUNUSED(dc), wxWindow* wnd, const wxRect& rect)
{
    int generic_border_width = wxAuiGenericTabArt::GetBorderWidth(wnd);

    if (!wnd) return;
    if (!wnd->m_wxwindow) return;
    if (!gtk_widget_is_drawable(wnd->m_wxwindow)) return;

    GtkStyle *style_notebook = gtk_widget_get_style(wxGTKPrivate::GetNotebookWidget());

    gtk_paint_box(style_notebook, wnd->GTKGetDrawingWindow(), GTK_STATE_NORMAL, GTK_SHADOW_OUT,
                  NULL, wnd->m_wxwindow,
                  const_cast<char*>("notebook"),
                  rect.x + generic_border_width + 1, rect.y + generic_border_width + 1,
                  rect.width - (generic_border_width + 1), rect.height - (generic_border_width + 1));
}

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 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;

    int gap_rect_height = 10 * GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder;
    int gap_rect_x = 1, gap_start = 0, gap_width = 0;
    int gap_rect_y = tab_rect.y - gap_rect_height;
    int gap_rect_width = window_rect.width;

    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_rect_y = tab_rect.y + tab_rect.height - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
            // fall through
        case wxAUI_NB_BOTTOM:
            gap_start = tab_rect.x - GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder / 2;
            gap_width = tab_rect.width;
            break;
        // TODO: case wxAUI_NB_LEFT: break;
        // TODO: case wxAUI_NB_RIGHT: break;
    }
    tab_rect.y += GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder / 2;
    gap_rect_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();

    // Before drawing the active tab itself, draw a box without border, because some themes
    // have transparent gaps and a line would be visible at the bottom of the tab
    if (page.active)
        gtk_paint_box(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
                      NULL, widget,
                      const_cast<char*>("notebook"),
                      gap_rect_x, gap_rect_y,
                      gap_rect_width, gap_rect_height);

    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"),
                              gap_rect_x, gap_rect_y,
                              gap_rect_width, gap_rect_height,
                              GTK_POS_BOTTOM, gap_start , 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"),
                              gap_rect_x, gap_rect_y,
                              gap_rect_width, gap_rect_height,
                              GTK_POS_TOP, gap_start , 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);
    }

    // After drawing the inactive tab itself, draw a box with the same dimensions as the gap-box,
    // otherwise we don't get a gap-box, if the active tab is invisible
    if (!page.active)
        gtk_paint_box(style_notebook, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
                      NULL, widget,
                      const_cast<char*>("notebook"),
                      gap_rect_x, gap_rect_y,
                      gap_rect_width, gap_rect_height);

    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);
    }

    if ( clip_width < tab_rect.width )
        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;
}

int wxAuiGtkTabArt::GetBorderWidth(wxWindow* wnd)
{
    return wxAuiGenericTabArt::GetBorderWidth(wnd) + wxMax(GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_hborder,
                                                           GTK_NOTEBOOK (wxGTKPrivate::GetNotebookWidget())->tab_vborder);
}

int wxAuiGtkTabArt::GetAdditionalBorderSpace(wxWindow* wnd)
{
    return 2 * GetBorderWidth(wnd);
}

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