--- /dev/null
+"""
+Tab art provider code - a tab provider provides all drawing functionality to
+the L{AuiNotebook}. This allows the L{AuiNotebook} to have a plugable look-and-feel.
+
+By default, a L{AuiNotebook} uses an instance of this class called L{AuiDefaultTabArt}
+which provides bitmap art and a colour scheme that is adapted to the major platforms'
+look. You can either derive from that class to alter its behaviour or write a
+completely new tab art class. Call L{AuiNotebook.SetArtProvider} to make use this
+new tab art.
+"""
+
+__author__ = "Andrea Gavana <andrea.gavana@gmail.com>"
+__date__ = "31 March 2009"
+
+
+import wx
+
+if wx.Platform == '__WXMAC__':
+ import Carbon.Appearance
+
+from aui_utilities import BitmapFromBits, StepColour, IndentPressedBitmap, ChopText
+from aui_utilities import GetBaseColour, DrawMACCloseButton, LightColour, TakeScreenShot
+from aui_utilities import CopyAttributes
+
+from aui_constants import *
+
+
+# -- GUI helper classes and functions --
+class AuiCommandCapture(wx.PyEvtHandler):
+ """ A class to handle the dropdown window menu. """
+
+ def __init__(self):
+ """ Default class constructor. """
+
+ wx.PyEvtHandler.__init__(self)
+ self._last_id = 0
+
+
+ def GetCommandId(self):
+ """ Returns the event command identifier. """
+
+ return self._last_id
+
+
+ def ProcessEvent(self, event):
+ """
+ Processes an event, searching event tables and calling zero or more suitable
+ event handler function(s).
+
+ :param `event`: the event to process.
+
+ :note: Normally, your application would not call this function: it is called
+ in the wxPython implementation to dispatch incoming user interface events
+ to the framework (and application).
+ However, you might need to call it if implementing new functionality (such as
+ a new control) where you define new event types, as opposed to allowing the
+ user to override functions.
+
+ An instance where you might actually override the L{ProcessEvent} function is where
+ you want to direct event processing to event handlers not normally noticed by
+ wxPython. For example, in the document/view architecture, documents and views
+ are potential event handlers. When an event reaches a frame, L{ProcessEvent} will
+ need to be called on the associated document and view in case event handler
+ functions are associated with these objects.
+
+ The normal order of event table searching is as follows:
+
+ 1. If the object is disabled (via a call to `SetEvtHandlerEnabled`) the function
+ skips to step (6).
+ 2. If the object is a `wx.Window`, L{ProcessEvent} is recursively called on the window's
+ `wx.Validator`. If this returns ``True``, the function exits.
+ 3. wxWidgets `SearchEventTable` is called for this event handler. If this fails, the
+ base class table is tried, and so on until no more tables exist or an appropriate
+ function was found, in which case the function exits.
+ 4. The search is applied down the entire chain of event handlers (usually the chain
+ has a length of one). If this succeeds, the function exits.
+ 5. If the object is a `wx.Window` and the event is a `wx.CommandEvent`, L{ProcessEvent} is
+ recursively applied to the parent window's event handler. If this returns ``True``,
+ the function exits.
+ 6. Finally, L{ProcessEvent} is called on the `wx.App` object.
+ """
+
+ if event.GetEventType() == wx.wxEVT_COMMAND_MENU_SELECTED:
+ self._last_id = event.GetId()
+ return True
+
+ if self.GetNextHandler():
+ return self.GetNextHandler().ProcessEvent(event)
+
+ return False
+
+
+class AuiDefaultTabArt(object):
+ """
+ Tab art provider code - a tab provider provides all drawing functionality to
+ the L{AuiNotebook}. This allows the L{AuiNotebook} to have a plugable look-and-feel.
+
+ By default, a L{AuiNotebook} uses an instance of this class called L{AuiDefaultTabArt}
+ which provides bitmap art and a colour scheme that is adapted to the major platforms'
+ look. You can either derive from that class to alter its behaviour or write a
+ completely new tab art class. Call L{AuiNotebook.SetArtProvider} to make use this
+ new tab art.
+ """
+
+ def __init__(self):
+ """ Default class constructor. """
+
+ self._normal_font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ self._selected_font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ self._selected_font.SetWeight(wx.BOLD)
+ self._measuring_font = self._selected_font
+
+ self._fixed_tab_width = 100
+ self._tab_ctrl_height = 0
+ self._buttonRect = wx.Rect()
+
+ self.SetDefaultColours()
+
+ if wx.Platform == "__WXMAC__":
+ bmp_colour = wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DDKSHADOW)
+ self._active_close_bmp = DrawMACCloseButton(bmp_colour)
+ self._disabled_close_bmp = DrawMACCloseButton(wx.Colour(128, 128, 128))
+ else:
+ self._active_close_bmp = BitmapFromBits(nb_close_bits, 16, 16, wx.BLACK)
+ self._disabled_close_bmp = BitmapFromBits(nb_close_bits, 16, 16, wx.Colour(128, 128, 128))
+
+ self._hover_close_bmp = self._active_close_bmp
+ self._pressed_close_bmp = self._active_close_bmp
+
+ self._active_left_bmp = BitmapFromBits(nb_left_bits, 16, 16, wx.BLACK)
+ self._disabled_left_bmp = BitmapFromBits(nb_left_bits, 16, 16, wx.Colour(128, 128, 128))
+
+ self._active_right_bmp = BitmapFromBits(nb_right_bits, 16, 16, wx.BLACK)
+ self._disabled_right_bmp = BitmapFromBits(nb_right_bits, 16, 16, wx.Colour(128, 128, 128))
+
+ self._active_windowlist_bmp = BitmapFromBits(nb_list_bits, 16, 16, wx.BLACK)
+ self._disabled_windowlist_bmp = BitmapFromBits(nb_list_bits, 16, 16, wx.Colour(128, 128, 128))
+
+ if wx.Platform == "__WXMAC__":
+ # Get proper highlight colour for focus rectangle from the
+ # current Mac theme. kThemeBrushFocusHighlight is
+ # available on Mac OS 8.5 and higher
+ if hasattr(wx, 'MacThemeColour'):
+ c = wx.MacThemeColour(Carbon.Appearance.kThemeBrushFocusHighlight)
+ else:
+ brush = wx.Brush(wx.BLACK)
+ brush.MacSetTheme(Carbon.Appearance.kThemeBrushFocusHighlight)
+ c = brush.GetColour()
+ self._focusPen = wx.Pen(c, 2, wx.SOLID)
+ else:
+ self._focusPen = wx.Pen(wx.BLACK, 1, wx.USER_DASH)
+ self._focusPen.SetDashes([1, 1])
+ self._focusPen.SetCap(wx.CAP_BUTT)
+
+
+ def SetBaseColour(self, base_colour):
+ """
+ Sets a new base colour.
+
+ :param `base_colour`: an instance of `wx.Colour`.
+ """
+
+ self._base_colour = base_colour
+ self._base_colour_pen = wx.Pen(self._base_colour)
+ self._base_colour_brush = wx.Brush(self._base_colour)
+
+
+ def SetDefaultColours(self, base_colour=None):
+ """
+ Sets the default colours, which are calculated from the given base colour.
+
+ :param `base_colour`: an instance of `wx.Colour`. If defaulted to ``None``, a colour
+ is generated accordingly to the platform and theme.
+ """
+
+ if base_colour is None:
+ base_colour = GetBaseColour()
+
+ self.SetBaseColour( base_colour )
+ self._border_colour = StepColour(base_colour, 75)
+ self._border_pen = wx.Pen(self._border_colour)
+
+ self._background_top_colour = StepColour(self._base_colour, 90)
+ self._background_bottom_colour = StepColour(self._base_colour, 170)
+
+ self._tab_top_colour = self._base_colour
+ self._tab_bottom_colour = wx.WHITE
+ self._tab_gradient_highlight_colour = wx.WHITE
+
+ self._tab_inactive_top_colour = self._base_colour
+ self._tab_inactive_bottom_colour = StepColour(self._tab_inactive_top_colour, 160)
+
+ self._tab_text_colour = lambda page: page.text_colour
+ self._tab_disabled_text_colour = wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT)
+
+
+ def Clone(self):
+ """ Clones the art object. """
+
+ art = type(self)()
+ art.SetNormalFont(self.GetNormalFont())
+ art.SetSelectedFont(self.GetSelectedFont())
+ art.SetMeasuringFont(self.GetMeasuringFont())
+
+ art = CopyAttributes(art, self)
+ return art
+
+
+ def SetAGWFlags(self, agwFlags):
+ """
+ Sets the tab art flags.
+
+ :param `agwFlags`: a combination of the following values:
+
+ ==================================== ==================================
+ Flag name Description
+ ==================================== ==================================
+ ``AUI_NB_TOP`` With this style, tabs are drawn along the top of the notebook
+ ``AUI_NB_LEFT`` With this style, tabs are drawn along the left of the notebook. Not implemented yet.
+ ``AUI_NB_RIGHT`` With this style, tabs are drawn along the right of the notebook. Not implemented yet.
+ ``AUI_NB_BOTTOM`` With this style, tabs are drawn along the bottom of the notebook
+ ``AUI_NB_TAB_SPLIT`` Allows the tab control to be split by dragging a tab
+ ``AUI_NB_TAB_MOVE`` Allows a tab to be moved horizontally by dragging
+ ``AUI_NB_TAB_EXTERNAL_MOVE`` Allows a tab to be moved to another tab control
+ ``AUI_NB_TAB_FIXED_WIDTH`` With this style, all tabs have the same width
+ ``AUI_NB_SCROLL_BUTTONS`` With this style, left and right scroll buttons are displayed
+ ``AUI_NB_WINDOWLIST_BUTTON`` With this style, a drop-down list of windows is available
+ ``AUI_NB_CLOSE_BUTTON`` With this style, a close button is available on the tab bar
+ ``AUI_NB_CLOSE_ON_ACTIVE_TAB`` With this style, a close button is available on the active tab
+ ``AUI_NB_CLOSE_ON_ALL_TABS`` With this style, a close button is available on all tabs
+ ``AUI_NB_MIDDLE_CLICK_CLOSE`` Allows to close L{AuiNotebook} tabs by mouse middle button click
+ ``AUI_NB_SUB_NOTEBOOK`` This style is used by L{AuiManager} to create automatic AuiNotebooks
+ ``AUI_NB_HIDE_ON_SINGLE_TAB`` Hides the tab window if only one tab is present
+ ``AUI_NB_SMART_TABS`` Use Smart Tabbing, like ``Alt`` + ``Tab`` on Windows
+ ``AUI_NB_USE_IMAGES_DROPDOWN`` Uses images on dropdown window list menu instead of check items
+ ``AUI_NB_CLOSE_ON_TAB_LEFT`` Draws the tab close button on the left instead of on the right (a la Camino browser)
+ ``AUI_NB_TAB_FLOAT`` Allows the floating of single tabs. Known limitation: when the notebook is more or less full screen, tabs cannot be dragged far enough outside of the notebook to become floating pages
+ ``AUI_NB_DRAW_DND_TAB`` Draws an image representation of a tab while dragging (on by default)
+ ``AUI_NB_ORDER_BY_ACCESS`` Tab navigation order by last access time for the tabs
+ ``AUI_NB_NO_TAB_FOCUS`` Don't draw tab focus rectangle
+ ==================================== ==================================
+
+ """
+
+ self._agwFlags = agwFlags
+
+
+ def GetAGWFlags(self):
+ """
+ Returns the tab art flags.
+
+ :see: L{SetAGWFlags} for a list of possible return values.
+ """
+
+ return self._agwFlags
+
+
+ def SetSizingInfo(self, tab_ctrl_size, tab_count, minMaxTabWidth):
+ """
+ Sets the tab sizing information.
+
+ :param `tab_ctrl_size`: the size of the tab control area;
+ :param `tab_count`: the number of tabs;
+ :param `minMaxTabWidth`: a tuple containing the minimum and maximum tab widths
+ to be used when the ``AUI_NB_TAB_FIXED_WIDTH`` style is active.
+ """
+
+ self._fixed_tab_width = 100
+ minTabWidth, maxTabWidth = minMaxTabWidth
+
+ tot_width = tab_ctrl_size.x - self.GetIndentSize() - 4
+ agwFlags = self.GetAGWFlags()
+
+ if agwFlags & AUI_NB_CLOSE_BUTTON:
+ tot_width -= self._active_close_bmp.GetWidth()
+ if agwFlags & AUI_NB_WINDOWLIST_BUTTON:
+ tot_width -= self._active_windowlist_bmp.GetWidth()
+
+ if tab_count > 0:
+ self._fixed_tab_width = tot_width/tab_count
+
+ if self._fixed_tab_width < 100:
+ self._fixed_tab_width = 100
+
+ if self._fixed_tab_width > tot_width/2:
+ self._fixed_tab_width = tot_width/2
+
+ if self._fixed_tab_width > 220:
+ self._fixed_tab_width = 220
+
+ if minTabWidth > -1:
+ self._fixed_tab_width = max(self._fixed_tab_width, minTabWidth)
+ if maxTabWidth > -1:
+ self._fixed_tab_width = min(self._fixed_tab_width, maxTabWidth)
+
+ self._tab_ctrl_height = tab_ctrl_size.y
+
+
+ def DrawBackground(self, dc, wnd, rect):
+ """
+ Draws the tab area background.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `rect`: the tab control rectangle.
+ """
+
+ self._buttonRect = wx.Rect()
+
+ # draw background
+ agwFlags = self.GetAGWFlags()
+ if agwFlags & AUI_NB_BOTTOM:
+ r = wx.Rect(rect.x, rect.y, rect.width+2, rect.height)
+
+ # TODO: else if (agwFlags & AUI_NB_LEFT)
+ # TODO: else if (agwFlags & AUI_NB_RIGHT)
+ else: #for AUI_NB_TOP
+ r = wx.Rect(rect.x, rect.y, rect.width+2, rect.height-3)
+
+ dc.GradientFillLinear(r, self._background_top_colour, self._background_bottom_colour, wx.SOUTH)
+
+ # draw base lines
+
+ dc.SetPen(self._border_pen)
+ y = rect.GetHeight()
+ w = rect.GetWidth()
+
+ if agwFlags & AUI_NB_BOTTOM:
+ dc.SetBrush(wx.Brush(self._background_bottom_colour))
+ dc.DrawRectangle(-1, 0, w+2, 4)
+
+ # TODO: else if (agwFlags & AUI_NB_LEFT)
+ # TODO: else if (agwFlags & AUI_NB_RIGHT)
+
+ else: # for AUI_NB_TOP
+ dc.SetBrush(self._base_colour_brush)
+ dc.DrawRectangle(-1, y-4, w+2, 4)
+
+
+ def DrawTab(self, dc, wnd, page, in_rect, close_button_state, paint_control=False):
+ """
+ Draws a single tab.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `page`: the tab control page associated with the tab;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `paint_control`: whether to draw the control inside a tab (if any) on a `wx.MemoryDC`.
+ """
+
+ # if the caption is empty, measure some temporary text
+ caption = page.caption
+ if not caption:
+ caption = "Xj"
+
+ dc.SetFont(self._selected_font)
+ selected_textx, selected_texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ dc.SetFont(self._normal_font)
+ normal_textx, normal_texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ control = page.control
+
+ # figure out the size of the tab
+ tab_size, x_extent = self.GetTabSize(dc, wnd, page.caption, page.bitmap,
+ page.active, close_button_state, control)
+
+ tab_height = self._tab_ctrl_height - 3
+ tab_width = tab_size[0]
+ tab_x = in_rect.x
+ tab_y = in_rect.y + in_rect.height - tab_height
+
+ caption = page.caption
+
+ # select pen, brush and font for the tab to be drawn
+
+ if page.active:
+
+ dc.SetFont(self._selected_font)
+ textx, texty = selected_textx, selected_texty
+
+ else:
+
+ dc.SetFont(self._normal_font)
+ textx, texty = normal_textx, normal_texty
+
+ if not page.enabled:
+ dc.SetTextForeground(self._tab_disabled_text_colour)
+ pagebitmap = page.dis_bitmap
+ else:
+ dc.SetTextForeground(self._tab_text_colour(page))
+ pagebitmap = page.bitmap
+
+ # create points that will make the tab outline
+
+ clip_width = tab_width
+ if tab_x + clip_width > in_rect.x + in_rect.width:
+ clip_width = in_rect.x + in_rect.width - tab_x
+
+ # since the above code above doesn't play well with WXDFB or WXCOCOA,
+ # we'll just use a rectangle for the clipping region for now --
+ dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3)
+
+ border_points = [wx.Point() for i in xrange(6)]
+ agwFlags = self.GetAGWFlags()
+
+ if agwFlags & AUI_NB_BOTTOM:
+
+ border_points[0] = wx.Point(tab_x, tab_y)
+ border_points[1] = wx.Point(tab_x, tab_y+tab_height-6)
+ border_points[2] = wx.Point(tab_x+2, tab_y+tab_height-4)
+ border_points[3] = wx.Point(tab_x+tab_width-2, tab_y+tab_height-4)
+ border_points[4] = wx.Point(tab_x+tab_width, tab_y+tab_height-6)
+ border_points[5] = wx.Point(tab_x+tab_width, tab_y)
+
+ else: #if (agwFlags & AUI_NB_TOP)
+
+ border_points[0] = wx.Point(tab_x, tab_y+tab_height-4)
+ border_points[1] = wx.Point(tab_x, tab_y+2)
+ border_points[2] = wx.Point(tab_x+2, tab_y)
+ border_points[3] = wx.Point(tab_x+tab_width-2, tab_y)
+ border_points[4] = wx.Point(tab_x+tab_width, tab_y+2)
+ border_points[5] = wx.Point(tab_x+tab_width, tab_y+tab_height-4)
+
+ # TODO: else if (agwFlags & AUI_NB_LEFT)
+ # TODO: else if (agwFlags & AUI_NB_RIGHT)
+
+ drawn_tab_yoff = border_points[1].y
+ drawn_tab_height = border_points[0].y - border_points[1].y
+
+ if page.active:
+
+ # draw active tab
+
+ # draw base background colour
+ r = wx.Rect(tab_x, tab_y, tab_width, tab_height)
+ dc.SetPen(self._base_colour_pen)
+ dc.SetBrush(self._base_colour_brush)
+ dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4)
+
+ # this white helps fill out the gradient at the top of the tab
+ dc.SetPen( wx.Pen(self._tab_gradient_highlight_colour) )
+ dc.SetBrush( wx.Brush(self._tab_gradient_highlight_colour) )
+ dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4)
+
+ # these two points help the rounded corners appear more antialiased
+ dc.SetPen(self._base_colour_pen)
+ dc.DrawPoint(r.x+2, r.y+1)
+ dc.DrawPoint(r.x+r.width-2, r.y+1)
+
+ # set rectangle down a bit for gradient drawing
+ r.SetHeight(r.GetHeight()/2)
+ r.x += 2
+ r.width -= 2
+ r.y += r.height
+ r.y -= 2
+
+ # draw gradient background
+ top_colour = self._tab_bottom_colour
+ bottom_colour = self._tab_top_colour
+ dc.GradientFillLinear(r, bottom_colour, top_colour, wx.NORTH)
+
+ else:
+
+ # draw inactive tab
+
+ r = wx.Rect(tab_x, tab_y+1, tab_width, tab_height-3)
+
+ # start the gradent up a bit and leave the inside border inset
+ # by a pixel for a 3D look. Only the top half of the inactive
+ # tab will have a slight gradient
+ r.x += 3
+ r.y += 1
+ r.width -= 4
+ r.height /= 2
+ r.height -= 1
+
+ # -- draw top gradient fill for glossy look
+ top_colour = self._tab_inactive_top_colour
+ bottom_colour = self._tab_inactive_bottom_colour
+ dc.GradientFillLinear(r, bottom_colour, top_colour, wx.NORTH)
+
+ r.y += r.height
+ r.y -= 1
+
+ # -- draw bottom fill for glossy look
+ top_colour = self._tab_inactive_bottom_colour
+ bottom_colour = self._tab_inactive_bottom_colour
+ dc.GradientFillLinear(r, top_colour, bottom_colour, wx.SOUTH)
+
+ # draw tab outline
+ dc.SetPen(self._border_pen)
+ dc.SetBrush(wx.TRANSPARENT_BRUSH)
+ dc.DrawPolygon(border_points)
+
+ # there are two horizontal grey lines at the bottom of the tab control,
+ # this gets rid of the top one of those lines in the tab control
+ if page.active:
+
+ if agwFlags & AUI_NB_BOTTOM:
+ dc.SetPen(wx.Pen(self._background_bottom_colour))
+
+ # TODO: else if (agwFlags & AUI_NB_LEFT)
+ # TODO: else if (agwFlags & AUI_NB_RIGHT)
+ else: # for AUI_NB_TOP
+ dc.SetPen(self._base_colour_pen)
+
+ dc.DrawLine(border_points[0].x+1,
+ border_points[0].y,
+ border_points[5].x,
+ border_points[5].y)
+
+ text_offset = tab_x + 8
+ close_button_width = 0
+
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ close_button_width = self._active_close_bmp.GetWidth()
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ text_offset += close_button_width - 5
+
+ bitmap_offset = 0
+
+ if pagebitmap.IsOk():
+
+ bitmap_offset = tab_x + 8
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT and close_button_width:
+ bitmap_offset += close_button_width - 5
+
+ # draw bitmap
+ dc.DrawBitmap(pagebitmap,
+ bitmap_offset,
+ drawn_tab_yoff + (drawn_tab_height/2) - (pagebitmap.GetHeight()/2),
+ True)
+
+ text_offset = bitmap_offset + pagebitmap.GetWidth()
+ text_offset += 3 # bitmap padding
+
+ else:
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT == 0 or not close_button_width:
+ text_offset = tab_x + 8
+
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x) - close_button_width)
+
+ ypos = drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1
+
+ offset_focus = text_offset
+ if control is not None:
+ if control.GetPosition() != wx.Point(text_offset+1, ypos):
+ control.SetPosition(wx.Point(text_offset+1, ypos))
+
+ if not control.IsShown():
+ control.Show()
+
+ if paint_control:
+ bmp = TakeScreenShot(control.GetScreenRect())
+ dc.DrawBitmap(bmp, text_offset+1, ypos, True)
+
+ controlW, controlH = control.GetSize()
+ text_offset += controlW + 4
+ textx += controlW + 4
+
+ # draw tab text
+ rectx, recty, dummy = dc.GetMultiLineTextExtent(draw_text)
+ dc.DrawLabel(draw_text, wx.Rect(text_offset, ypos, rectx, recty))
+
+ # draw focus rectangle
+ if (agwFlags & AUI_NB_NO_TAB_FOCUS) == 0:
+ self.DrawFocusRectangle(dc, page, wnd, draw_text, offset_focus, bitmap_offset, drawn_tab_yoff, drawn_tab_height, rectx, recty)
+
+ out_button_rect = wx.Rect()
+
+ # draw close button if necessary
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+
+ bmp = self._disabled_close_bmp
+
+ if close_button_state == AUI_BUTTON_STATE_HOVER:
+ bmp = self._hover_close_bmp
+ elif close_button_state == AUI_BUTTON_STATE_PRESSED:
+ bmp = self._pressed_close_bmp
+
+ shift = (agwFlags & AUI_NB_BOTTOM and [1] or [0])[0]
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ rect = wx.Rect(tab_x + 4, tab_y + (tab_height - bmp.GetHeight())/2 - shift,
+ close_button_width, tab_height)
+ else:
+ rect = wx.Rect(tab_x + tab_width - close_button_width - 1,
+ tab_y + (tab_height - bmp.GetHeight())/2 - shift,
+ close_button_width, tab_height)
+
+ rect = IndentPressedBitmap(rect, close_button_state)
+ dc.DrawBitmap(bmp, rect.x, rect.y, True)
+
+ out_button_rect = rect
+
+ out_tab_rect = wx.Rect(tab_x, tab_y, tab_width, tab_height)
+
+ dc.DestroyClippingRegion()
+
+ return out_tab_rect, out_button_rect, x_extent
+
+
+ def SetCustomButton(self, bitmap_id, button_state, bmp):
+ """
+ Sets a custom bitmap for the close, left, right and window list
+ buttons.
+
+ :param `bitmap_id`: the button identifier;
+ :param `button_state`: the button state;
+ :param `bmp`: the custom bitmap to use for the button.
+ """
+
+ if bitmap_id == AUI_BUTTON_CLOSE:
+ if button_state == AUI_BUTTON_STATE_NORMAL:
+ self._active_close_bmp = bmp
+ self._hover_close_bmp = self._active_close_bmp
+ self._pressed_close_bmp = self._active_close_bmp
+ self._disabled_close_bmp = self._active_close_bmp
+
+ elif button_state == AUI_BUTTON_STATE_HOVER:
+ self._hover_close_bmp = bmp
+ elif button_state == AUI_BUTTON_STATE_PRESSED:
+ self._pressed_close_bmp = bmp
+ else:
+ self._disabled_close_bmp = bmp
+
+ elif bitmap_id == AUI_BUTTON_LEFT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ self._disabled_left_bmp = bmp
+ else:
+ self._active_left_bmp = bmp
+
+ elif bitmap_id == AUI_BUTTON_RIGHT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ self._disabled_right_bmp = bmp
+ else:
+ self._active_right_bmp = bmp
+
+ elif bitmap_id == AUI_BUTTON_WINDOWLIST:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ self._disabled_windowlist_bmp = bmp
+ else:
+ self._active_windowlist_bmp = bmp
+
+
+ def GetIndentSize(self):
+ """ Returns the tabs indent size. """
+
+ return 5
+
+
+ def GetTabSize(self, dc, wnd, caption, bitmap, active, close_button_state, control=None):
+ """
+ Returns the tab size for the given caption, bitmap and button state.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `caption`: the tab text caption;
+ :param `bitmap`: the bitmap displayed on the tab;
+ :param `active`: whether the tab is selected or not;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `control`: a `wx.Window` instance inside a tab (or ``None``).
+ """
+
+ dc.SetFont(self._measuring_font)
+ measured_textx, measured_texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ # add padding around the text
+ tab_width = measured_textx
+ tab_height = measured_texty
+
+ # if the close button is showing, add space for it
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ tab_width += self._active_close_bmp.GetWidth() + 3
+
+ # if there's a bitmap, add space for it
+ if bitmap.IsOk():
+ tab_width += bitmap.GetWidth()
+ tab_width += 3 # right side bitmap padding
+ tab_height = max(tab_height, bitmap.GetHeight())
+
+ # add padding
+ tab_width += 16
+ tab_height += 10
+
+ agwFlags = self.GetAGWFlags()
+ if agwFlags & AUI_NB_TAB_FIXED_WIDTH:
+ tab_width = self._fixed_tab_width
+
+ if control is not None:
+ tab_width += control.GetSize().GetWidth() + 4
+
+ x_extent = tab_width
+
+ return (tab_width, tab_height), x_extent
+
+
+ def DrawButton(self, dc, wnd, in_rect, button, orientation):
+ """
+ Draws a button on the tab or on the tab area, depending on the button identifier.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `button`: an instance of the button class;
+ :param `orientation`: the tab orientation.
+ """
+
+ bitmap_id, button_state = button.id, button.cur_state
+
+ if bitmap_id == AUI_BUTTON_CLOSE:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_close_bmp
+ elif button_state & AUI_BUTTON_STATE_HOVER:
+ bmp = self._hover_close_bmp
+ elif button_state & AUI_BUTTON_STATE_PRESSED:
+ bmp = self._pressed_close_bmp
+ else:
+ bmp = self._active_close_bmp
+
+ elif bitmap_id == AUI_BUTTON_LEFT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_left_bmp
+ else:
+ bmp = self._active_left_bmp
+
+ elif bitmap_id == AUI_BUTTON_RIGHT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_right_bmp
+ else:
+ bmp = self._active_right_bmp
+
+ elif bitmap_id == AUI_BUTTON_WINDOWLIST:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_windowlist_bmp
+ else:
+ bmp = self._active_windowlist_bmp
+
+ else:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = button.dis_bitmap
+ else:
+ bmp = button.bitmap
+
+ if not bmp.IsOk():
+ return
+
+ rect = wx.Rect(*in_rect)
+
+ if orientation == wx.LEFT:
+
+ rect.SetX(in_rect.x)
+ rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2))
+ rect.SetWidth(bmp.GetWidth())
+ rect.SetHeight(bmp.GetHeight())
+
+ else:
+
+ rect = wx.Rect(in_rect.x + in_rect.width - bmp.GetWidth(),
+ ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
+ bmp.GetWidth(), bmp.GetHeight())
+
+ rect = IndentPressedBitmap(rect, button_state)
+ dc.DrawBitmap(bmp, rect.x, rect.y, True)
+
+ out_rect = rect
+
+ if bitmap_id == AUI_BUTTON_RIGHT:
+ self._buttonRect = wx.Rect(rect.x, rect.y, 30, rect.height)
+
+ return out_rect
+
+
+ def DrawFocusRectangle(self, dc, page, wnd, draw_text, text_offset, bitmap_offset, drawn_tab_yoff, drawn_tab_height, textx, texty):
+ """
+ Draws the focus rectangle on a tab.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `page`: the page associated with the tab;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `draw_text`: the text that has been drawn on the tab;
+ :param `text_offset`: the text offset on the tab;
+ :param `bitmap_offset`: the bitmap offset on the tab;
+ :param `drawn_tab_yoff`: the y offset of the tab text;
+ :param `drawn_tab_height`: the height of the tab;
+ :param `textx`: the x text extent;
+ :param `texty`: the y text extent.
+ """
+
+ if self.GetAGWFlags() & AUI_NB_NO_TAB_FOCUS:
+ return
+
+ if page.active and wx.Window.FindFocus() == wnd:
+
+ focusRectText = wx.Rect(text_offset, (drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2)),
+ textx, texty)
+
+ if page.bitmap.IsOk():
+ focusRectBitmap = wx.Rect(bitmap_offset, drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
+ page.bitmap.GetWidth(), page.bitmap.GetHeight())
+
+ if page.bitmap.IsOk() and draw_text == "":
+ focusRect = wx.Rect(*focusRectBitmap)
+ elif not page.bitmap.IsOk() and draw_text != "":
+ focusRect = wx.Rect(*focusRectText)
+ elif page.bitmap.IsOk() and draw_text != "":
+ focusRect = focusRectText.Union(focusRectBitmap)
+
+ focusRect.Inflate(2, 2)
+
+ dc.SetBrush(wx.TRANSPARENT_BRUSH)
+ dc.SetPen(self._focusPen)
+ dc.DrawRoundedRectangleRect(focusRect, 2)
+
+
+ def GetBestTabCtrlSize(self, wnd, pages, required_bmp_size):
+ """
+ Returns the best tab control size.
+
+ :param `wnd`: a `wx.Window` instance object;
+ :param `pages`: the pages associated with the tabs;
+ :param `required_bmp_size`: the size of the bitmap on the tabs.
+ """
+
+ dc = wx.ClientDC(wnd)
+ dc.SetFont(self._measuring_font)
+
+ # sometimes a standard bitmap size needs to be enforced, especially
+ # if some tabs have bitmaps and others don't. This is important because
+ # it prevents the tab control from resizing when tabs are added.
+
+ measure_bmp = wx.NullBitmap
+
+ if required_bmp_size.IsFullySpecified():
+ measure_bmp = wx.EmptyBitmap(required_bmp_size.x,
+ required_bmp_size.y)
+
+ max_y = 0
+
+ for page in pages:
+
+ if measure_bmp.IsOk():
+ bmp = measure_bmp
+ else:
+ bmp = page.bitmap
+
+ # we don't use the caption text because we don't
+ # want tab heights to be different in the case
+ # of a very short piece of text on one tab and a very
+ # tall piece of text on another tab
+ s, x_ext = self.GetTabSize(dc, wnd, page.caption, bmp, True, AUI_BUTTON_STATE_HIDDEN, None)
+ max_y = max(max_y, s[1])
+
+ if page.control:
+ controlW, controlH = page.control.GetSize()
+ max_y = max(max_y, controlH+4)
+
+ return max_y + 2
+
+
+ def SetNormalFont(self, font):
+ """
+ Sets the normal font for drawing tab labels.
+
+ :param `font`: a `wx.Font` object.
+ """
+
+ self._normal_font = font
+
+
+ def SetSelectedFont(self, font):
+ """
+ Sets the selected tab font for drawing tab labels.
+
+ :param `font`: a `wx.Font` object.
+ """
+
+ self._selected_font = font
+
+
+ def SetMeasuringFont(self, font):
+ """
+ Sets the font for calculating text measurements.
+
+ :param `font`: a `wx.Font` object.
+ """
+
+ self._measuring_font = font
+
+
+ def GetNormalFont(self):
+ """ Returns the normal font for drawing tab labels. """
+
+ return self._normal_font
+
+
+ def GetSelectedFont(self):
+ """ Returns the selected tab font for drawing tab labels. """
+
+ return self._selected_font
+
+
+ def GetMeasuringFont(self):
+ """ Returns the font for calculating text measurements. """
+
+ return self._measuring_font
+
+
+ def ShowDropDown(self, wnd, pages, active_idx):
+ """
+ Shows the drop-down window menu on the tab area.
+
+ :param `wnd`: a `wx.Window` derived window instance;
+ :param `pages`: the pages associated with the tabs;
+ :param `active_idx`: the active tab index.
+ """
+
+ useImages = self.GetAGWFlags() & AUI_NB_USE_IMAGES_DROPDOWN
+ menuPopup = wx.Menu()
+
+ longest = 0
+ for i, page in enumerate(pages):
+
+ caption = page.caption
+
+ # if there is no caption, make it a space. This will prevent
+ # an assert in the menu code.
+ if caption == "":
+ caption = " "
+
+ # Save longest caption width for calculating menu width with
+ width = wnd.GetTextExtent(caption)[0]
+ if width > longest:
+ longest = width
+
+ if useImages:
+ menuItem = wx.MenuItem(menuPopup, 1000+i, caption)
+ if page.bitmap:
+ menuItem.SetBitmap(page.bitmap)
+
+ menuPopup.AppendItem(menuItem)
+
+ else:
+
+ menuPopup.AppendCheckItem(1000+i, caption)
+
+ menuPopup.Enable(1000+i, page.enabled)
+
+ if active_idx != -1 and not useImages:
+
+ menuPopup.Check(1000+active_idx, True)
+
+ # find out the screen coordinate at the bottom of the tab ctrl
+ cli_rect = wnd.GetClientRect()
+
+ # Calculate the approximate size of the popupmenu for setting the
+ # position of the menu when its shown.
+ # Account for extra padding on left/right of text on mac menus
+ if wx.Platform in ['__WXMAC__', '__WXMSW__']:
+ longest += 32
+
+ # Bitmap/Checkmark width + padding
+ longest += 20
+
+ if self.GetAGWFlags() & AUI_NB_CLOSE_BUTTON:
+ longest += 16
+
+ pt = wx.Point(cli_rect.x + cli_rect.GetWidth() - longest,
+ cli_rect.y + cli_rect.height)
+
+ cc = AuiCommandCapture()
+ wnd.PushEventHandler(cc)
+ wnd.PopupMenu(menuPopup, pt)
+ command = cc.GetCommandId()
+ wnd.PopEventHandler(True)
+
+ if command >= 1000:
+ return command - 1000
+
+ return -1
+
+
+class AuiSimpleTabArt(object):
+ """ A simple-looking implementation of a tab art. """
+
+ def __init__(self):
+ """ Default class constructor. """
+
+ self._normal_font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ self._selected_font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ self._selected_font.SetWeight(wx.BOLD)
+ self._measuring_font = self._selected_font
+
+ self._agwFlags = 0
+ self._fixed_tab_width = 100
+
+ base_colour = wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE)
+
+ background_colour = base_colour
+ normaltab_colour = base_colour
+ selectedtab_colour = wx.WHITE
+
+ self._bkbrush = wx.Brush(background_colour)
+ self._normal_bkbrush = wx.Brush(normaltab_colour)
+ self._normal_bkpen = wx.Pen(normaltab_colour)
+ self._selected_bkbrush = wx.Brush(selectedtab_colour)
+ self._selected_bkpen = wx.Pen(selectedtab_colour)
+
+ self._active_close_bmp = BitmapFromBits(nb_close_bits, 16, 16, wx.BLACK)
+ self._disabled_close_bmp = BitmapFromBits(nb_close_bits, 16, 16, wx.Colour(128, 128, 128))
+
+ self._active_left_bmp = BitmapFromBits(nb_left_bits, 16, 16, wx.BLACK)
+ self._disabled_left_bmp = BitmapFromBits(nb_left_bits, 16, 16, wx.Colour(128, 128, 128))
+
+ self._active_right_bmp = BitmapFromBits(nb_right_bits, 16, 16, wx.BLACK)
+ self._disabled_right_bmp = BitmapFromBits(nb_right_bits, 16, 16, wx.Colour(128, 128, 128))
+
+ self._active_windowlist_bmp = BitmapFromBits(nb_list_bits, 16, 16, wx.BLACK)
+ self._disabled_windowlist_bmp = BitmapFromBits(nb_list_bits, 16, 16, wx.Colour(128, 128, 128))
+
+
+ def Clone(self):
+ """ Clones the art object. """
+
+ art = type(self)()
+ art.SetNormalFont(self.GetNormalFont())
+ art.SetSelectedFont(self.GetSelectedFont())
+ art.SetMeasuringFont(self.GetMeasuringFont())
+
+ art = CopyAttributes(art, self)
+ return art
+
+
+ def SetAGWFlags(self, agwFlags):
+ """
+ Sets the tab art flags.
+
+ :param `agwFlags`: a combination of the following values:
+
+ ==================================== ==================================
+ Flag name Description
+ ==================================== ==================================
+ ``AUI_NB_TOP`` With this style, tabs are drawn along the top of the notebook
+ ``AUI_NB_LEFT`` With this style, tabs are drawn along the left of the notebook. Not implemented yet.
+ ``AUI_NB_RIGHT`` With this style, tabs are drawn along the right of the notebook. Not implemented yet.
+ ``AUI_NB_BOTTOM`` With this style, tabs are drawn along the bottom of the notebook
+ ``AUI_NB_TAB_SPLIT`` Allows the tab control to be split by dragging a tab
+ ``AUI_NB_TAB_MOVE`` Allows a tab to be moved horizontally by dragging
+ ``AUI_NB_TAB_EXTERNAL_MOVE`` Allows a tab to be moved to another tab control
+ ``AUI_NB_TAB_FIXED_WIDTH`` With this style, all tabs have the same width
+ ``AUI_NB_SCROLL_BUTTONS`` With this style, left and right scroll buttons are displayed
+ ``AUI_NB_WINDOWLIST_BUTTON`` With this style, a drop-down list of windows is available
+ ``AUI_NB_CLOSE_BUTTON`` With this style, a close button is available on the tab bar
+ ``AUI_NB_CLOSE_ON_ACTIVE_TAB`` With this style, a close button is available on the active tab
+ ``AUI_NB_CLOSE_ON_ALL_TABS`` With this style, a close button is available on all tabs
+ ``AUI_NB_MIDDLE_CLICK_CLOSE`` Allows to close L{AuiNotebook} tabs by mouse middle button click
+ ``AUI_NB_SUB_NOTEBOOK`` This style is used by L{AuiManager} to create automatic AuiNotebooks
+ ``AUI_NB_HIDE_ON_SINGLE_TAB`` Hides the tab window if only one tab is present
+ ``AUI_NB_SMART_TABS`` Use Smart Tabbing, like ``Alt`` + ``Tab`` on Windows
+ ``AUI_NB_USE_IMAGES_DROPDOWN`` Uses images on dropdown window list menu instead of check items
+ ``AUI_NB_CLOSE_ON_TAB_LEFT`` Draws the tab close button on the left instead of on the right (a la Camino browser)
+ ``AUI_NB_TAB_FLOAT`` Allows the floating of single tabs. Known limitation: when the notebook is more or less full screen, tabs cannot be dragged far enough outside of the notebook to become floating pages
+ ``AUI_NB_DRAW_DND_TAB`` Draws an image representation of a tab while dragging (on by default)
+ ``AUI_NB_ORDER_BY_ACCESS`` Tab navigation order by last access time for the tabs
+ ``AUI_NB_NO_TAB_FOCUS`` Don't draw tab focus rectangle
+ ==================================== ==================================
+
+ """
+
+ self._agwFlags = agwFlags
+
+
+ def GetAGWFlags(self):
+ """
+ Returns the tab art flags.
+
+ :see: L{SetAGWFlags} for a list of possible return values.
+ """
+
+ return self._agwFlags
+
+
+ def SetSizingInfo(self, tab_ctrl_size, tab_count, minMaxTabWidth):
+ """
+ Sets the tab sizing information.
+
+ :param `tab_ctrl_size`: the size of the tab control area;
+ :param `tab_count`: the number of tabs;
+ :param `minMaxTabWidth`: a tuple containing the minimum and maximum tab widths
+ to be used when the ``AUI_NB_TAB_FIXED_WIDTH`` style is active.
+ """
+
+ self._fixed_tab_width = 100
+ minTabWidth, maxTabWidth = minMaxTabWidth
+
+ tot_width = tab_ctrl_size.x - self.GetIndentSize() - 4
+
+ if self._agwFlags & AUI_NB_CLOSE_BUTTON:
+ tot_width -= self._active_close_bmp.GetWidth()
+ if self._agwFlags & AUI_NB_WINDOWLIST_BUTTON:
+ tot_width -= self._active_windowlist_bmp.GetWidth()
+
+ if tab_count > 0:
+ self._fixed_tab_width = tot_width/tab_count
+
+ if self._fixed_tab_width < 100:
+ self._fixed_tab_width = 100
+
+ if self._fixed_tab_width > tot_width/2:
+ self._fixed_tab_width = tot_width/2
+
+ if self._fixed_tab_width > 220:
+ self._fixed_tab_width = 220
+
+ if minTabWidth > -1:
+ self._fixed_tab_width = max(self._fixed_tab_width, minTabWidth)
+ if maxTabWidth > -1:
+ self._fixed_tab_width = min(self._fixed_tab_width, maxTabWidth)
+
+ self._tab_ctrl_height = tab_ctrl_size.y
+
+
+ def DrawBackground(self, dc, wnd, rect):
+ """
+ Draws the tab area background.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `rect`: the tab control rectangle.
+ """
+
+ # draw background
+ dc.SetBrush(self._bkbrush)
+ dc.SetPen(wx.TRANSPARENT_PEN)
+ dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2)
+
+ # draw base line
+ dc.SetPen(wx.GREY_PEN)
+ dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1)
+
+
+ def DrawTab(self, dc, wnd, page, in_rect, close_button_state, paint_control=False):
+ """
+ Draws a single tab.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `page`: the tab control page associated with the tab;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `paint_control`: whether to draw the control inside a tab (if any) on a `wx.MemoryDC`.
+ """
+
+ # if the caption is empty, measure some temporary text
+ caption = page.caption
+ if caption == "":
+ caption = "Xj"
+
+ agwFlags = self.GetAGWFlags()
+
+ dc.SetFont(self._selected_font)
+ selected_textx, selected_texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ dc.SetFont(self._normal_font)
+ normal_textx, normal_texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ control = page.control
+
+ # figure out the size of the tab
+ tab_size, x_extent = self.GetTabSize(dc, wnd, page.caption, page.bitmap,
+ page.active, close_button_state, control)
+
+ tab_height = tab_size[1]
+ tab_width = tab_size[0]
+ tab_x = in_rect.x
+ tab_y = in_rect.y + in_rect.height - tab_height
+
+ caption = page.caption
+ # select pen, brush and font for the tab to be drawn
+
+ if page.active:
+
+ dc.SetPen(self._selected_bkpen)
+ dc.SetBrush(self._selected_bkbrush)
+ dc.SetFont(self._selected_font)
+ textx = selected_textx
+ texty = selected_texty
+
+ else:
+
+ dc.SetPen(self._normal_bkpen)
+ dc.SetBrush(self._normal_bkbrush)
+ dc.SetFont(self._normal_font)
+ textx = normal_textx
+ texty = normal_texty
+
+ if not page.enabled:
+ dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
+ else:
+ dc.SetTextForeground(page.text_colour)
+
+ # -- draw line --
+
+ points = [wx.Point() for i in xrange(7)]
+ points[0].x = tab_x
+ points[0].y = tab_y + tab_height - 1
+ points[1].x = tab_x + tab_height - 3
+ points[1].y = tab_y + 2
+ points[2].x = tab_x + tab_height + 3
+ points[2].y = tab_y
+ points[3].x = tab_x + tab_width - 2
+ points[3].y = tab_y
+ points[4].x = tab_x + tab_width
+ points[4].y = tab_y + 2
+ points[5].x = tab_x + tab_width
+ points[5].y = tab_y + tab_height - 1
+ points[6] = points[0]
+
+ dc.SetClippingRect(in_rect)
+ dc.DrawPolygon(points)
+
+ dc.SetPen(wx.GREY_PEN)
+ dc.DrawLines(points)
+
+ close_button_width = 0
+
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+
+ close_button_width = self._active_close_bmp.GetWidth()
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ if control:
+ text_offset = tab_x + (tab_height/2) + close_button_width - (textx/2) - 2
+ else:
+ text_offset = tab_x + (tab_height/2) + ((tab_width+close_button_width)/2) - (textx/2) - 2
+ else:
+ if control:
+ text_offset = tab_x + (tab_height/2) + close_button_width - (textx/2)
+ else:
+ text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2)
+
+ else:
+
+ text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2)
+ if control:
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ text_offset = tab_x + (tab_height/3) - (textx/2) + close_button_width + 2
+ else:
+ text_offset = tab_x + (tab_height/3) - (textx/2)
+
+ # set minimum text offset
+ if text_offset < tab_x + tab_height:
+ text_offset = tab_x + tab_height
+
+ # chop text if necessary
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x))
+ else:
+ draw_text = ChopText(dc, caption,
+ tab_width - (text_offset-tab_x) - close_button_width)
+
+ ypos = (tab_y + tab_height)/2 - (texty/2) + 1
+
+ if control is not None:
+ if control.GetPosition() != wx.Point(text_offset+1, ypos):
+ control.SetPosition(wx.Point(text_offset+1, ypos))
+
+ if not control.IsShown():
+ control.Show()
+
+ if paint_control:
+ bmp = TakeScreenShot(control.GetScreenRect())
+ dc.DrawBitmap(bmp, text_offset+1, ypos, True)
+
+ controlW, controlH = control.GetSize()
+ text_offset += controlW + 4
+
+ # draw tab text
+ rectx, recty, dummy = dc.GetMultiLineTextExtent(draw_text)
+ dc.DrawLabel(draw_text, wx.Rect(text_offset, ypos, rectx, recty))
+
+ # draw focus rectangle
+ if page.active and wx.Window.FindFocus() == wnd and (agwFlags & AUI_NB_NO_TAB_FOCUS) == 0:
+
+ focusRect = wx.Rect(text_offset, ((tab_y + tab_height)/2 - (texty/2) + 1),
+ selected_textx, selected_texty)
+
+ focusRect.Inflate(2, 2)
+ # TODO:
+ # This should be uncommented when DrawFocusRect will become
+ # available in wxPython
+ # wx.RendererNative.Get().DrawFocusRect(wnd, dc, focusRect, 0)
+
+ out_button_rect = wx.Rect()
+ # draw close button if necessary
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+
+ if page.active:
+ bmp = self._active_close_bmp
+ else:
+ bmp = self._disabled_close_bmp
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ rect = wx.Rect(tab_x + tab_height - 2,
+ tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
+ close_button_width, tab_height - 1)
+ else:
+ rect = wx.Rect(tab_x + tab_width - close_button_width - 1,
+ tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
+ close_button_width, tab_height - 1)
+
+ self.DrawButtons(dc, rect, bmp, wx.WHITE, close_button_state)
+ out_button_rect = wx.Rect(*rect)
+
+ out_tab_rect = wx.Rect(tab_x, tab_y, tab_width, tab_height)
+ dc.DestroyClippingRegion()
+
+ return out_tab_rect, out_button_rect, x_extent
+
+
+ def DrawButtons(self, dc, _rect, bmp, bkcolour, button_state):
+ """
+ Convenience method to draw tab buttons.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `_rect`: the tab rectangle;
+ :param `bmp`: the tab bitmap;
+ :param `bkcolour`: the tab background colour;
+ :param `button_state`: the state of the tab button.
+ """
+
+ rect = wx.Rect(*_rect)
+
+ if button_state == AUI_BUTTON_STATE_PRESSED:
+ rect.x += 1
+ rect.y += 1
+
+ if button_state in [AUI_BUTTON_STATE_HOVER, AUI_BUTTON_STATE_PRESSED]:
+ dc.SetBrush(wx.Brush(StepColour(bkcolour, 120)))
+ dc.SetPen(wx.Pen(StepColour(bkcolour, 75)))
+
+ # draw the background behind the button
+ dc.DrawRectangle(rect.x, rect.y, 15, 15)
+
+ # draw the button itself
+ dc.DrawBitmap(bmp, rect.x, rect.y, True)
+
+
+ def GetIndentSize(self):
+ """ Returns the tabs indent size. """
+
+ return 0
+
+
+ def GetTabSize(self, dc, wnd, caption, bitmap, active, close_button_state, control=None):
+ """
+ Returns the tab size for the given caption, bitmap and button state.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `caption`: the tab text caption;
+ :param `bitmap`: the bitmap displayed on the tab;
+ :param `active`: whether the tab is selected or not;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `control`: a `wx.Window` instance inside a tab (or ``None``).
+ """
+
+ dc.SetFont(self._measuring_font)
+ measured_textx, measured_texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ tab_height = measured_texty + 4
+ tab_width = measured_textx + tab_height + 5
+
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ tab_width += self._active_close_bmp.GetWidth()
+
+ if self._agwFlags & AUI_NB_TAB_FIXED_WIDTH:
+ tab_width = self._fixed_tab_width
+
+ if control is not None:
+ controlW, controlH = control.GetSize()
+ tab_width += controlW + 4
+
+ x_extent = tab_width - (tab_height/2) - 1
+
+ return (tab_width, tab_height), x_extent
+
+
+ def DrawButton(self, dc, wnd, in_rect, button, orientation):
+ """
+ Draws a button on the tab or on the tab area, depending on the button identifier.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `button`: an instance of the button class;
+ :param `orientation`: the tab orientation.
+ """
+
+ bitmap_id, button_state = button.id, button.cur_state
+
+ if bitmap_id == AUI_BUTTON_CLOSE:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_close_bmp
+ else:
+ bmp = self._active_close_bmp
+
+ elif bitmap_id == AUI_BUTTON_LEFT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_left_bmp
+ else:
+ bmp = self._active_left_bmp
+
+ elif bitmap_id == AUI_BUTTON_RIGHT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_right_bmp
+ else:
+ bmp = self._active_right_bmp
+
+ elif bitmap_id == AUI_BUTTON_WINDOWLIST:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = self._disabled_windowlist_bmp
+ else:
+ bmp = self._active_windowlist_bmp
+
+ else:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ bmp = button.dis_bitmap
+ else:
+ bmp = button.bitmap
+
+ if not bmp.IsOk():
+ return
+
+ rect = wx.Rect(*in_rect)
+
+ if orientation == wx.LEFT:
+
+ rect.SetX(in_rect.x)
+ rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2))
+ rect.SetWidth(bmp.GetWidth())
+ rect.SetHeight(bmp.GetHeight())
+
+ else:
+
+ rect = wx.Rect(in_rect.x + in_rect.width - bmp.GetWidth(),
+ ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
+ bmp.GetWidth(), bmp.GetHeight())
+
+ self.DrawButtons(dc, rect, bmp, wx.WHITE, button_state)
+
+ out_rect = wx.Rect(*rect)
+ return out_rect
+
+
+ def ShowDropDown(self, wnd, pages, active_idx):
+ """
+ Shows the drop-down window menu on the tab area.
+
+ :param `wnd`: a `wx.Window` derived window instance;
+ :param `pages`: the pages associated with the tabs;
+ :param `active_idx`: the active tab index.
+ """
+
+ menuPopup = wx.Menu()
+ useImages = self.GetAGWFlags() & AUI_NB_USE_IMAGES_DROPDOWN
+
+ for i, page in enumerate(pages):
+
+ if useImages:
+ menuItem = wx.MenuItem(menuPopup, 1000+i, page.caption)
+ if page.bitmap:
+ menuItem.SetBitmap(page.bitmap)
+
+ menuPopup.AppendItem(menuItem)
+
+ else:
+
+ menuPopup.AppendCheckItem(1000+i, page.caption)
+
+ menuPopup.Enable(1000+i, page.enabled)
+
+ if active_idx != -1 and not useImages:
+ menuPopup.Check(1000+active_idx, True)
+
+ # find out where to put the popup menu of window
+ # items. Subtract 100 for now to center the menu
+ # a bit, until a better mechanism can be implemented
+ pt = wx.GetMousePosition()
+ pt = wnd.ScreenToClient(pt)
+
+ if pt.x < 100:
+ pt.x = 0
+ else:
+ pt.x -= 100
+
+ # find out the screen coordinate at the bottom of the tab ctrl
+ cli_rect = wnd.GetClientRect()
+ pt.y = cli_rect.y + cli_rect.height
+
+ cc = AuiCommandCapture()
+ wnd.PushEventHandler(cc)
+ wnd.PopupMenu(menuPopup, pt)
+ command = cc.GetCommandId()
+ wnd.PopEventHandler(True)
+
+ if command >= 1000:
+ return command-1000
+
+ return -1
+
+
+ def GetBestTabCtrlSize(self, wnd, pages, required_bmp_size):
+ """
+ Returns the best tab control size.
+
+ :param `wnd`: a `wx.Window` instance object;
+ :param `pages`: the pages associated with the tabs;
+ :param `required_bmp_size`: the size of the bitmap on the tabs.
+ """
+
+ dc = wx.ClientDC(wnd)
+ dc.SetFont(self._measuring_font)
+ s, x_extent = self.GetTabSize(dc, wnd, "ABCDEFGHIj", wx.NullBitmap, True,
+ AUI_BUTTON_STATE_HIDDEN, None)
+
+ max_y = s[1]
+
+ for page in pages:
+ if page.control:
+ controlW, controlH = page.control.GetSize()
+ max_y = max(max_y, controlH+4)
+
+ textx, texty, dummy = dc.GetMultiLineTextExtent(page.caption)
+ max_y = max(max_y, texty)
+
+ return max_y + 3
+
+
+ def SetNormalFont(self, font):
+ """
+ Sets the normal font for drawing tab labels.
+
+ :param `font`: a `wx.Font` object.
+ """
+
+ self._normal_font = font
+
+
+ def SetSelectedFont(self, font):
+ """
+ Sets the selected tab font for drawing tab labels.
+
+ :param `font`: a `wx.Font` object.
+ """
+
+ self._selected_font = font
+
+
+ def SetMeasuringFont(self, font):
+ """
+ Sets the font for calculating text measurements.
+
+ :param `font`: a `wx.Font` object.
+ """
+
+ self._measuring_font = font
+
+
+ def GetNormalFont(self):
+ """ Returns the normal font for drawing tab labels. """
+
+ return self._normal_font
+
+
+ def GetSelectedFont(self):
+ """ Returns the selected tab font for drawing tab labels. """
+
+ return self._selected_font
+
+
+ def GetMeasuringFont(self):
+ """ Returns the font for calculating text measurements. """
+
+ return self._measuring_font
+
+
+ def SetCustomButton(self, bitmap_id, button_state, bmp):
+ """
+ Sets a custom bitmap for the close, left, right and window list
+ buttons.
+
+ :param `bitmap_id`: the button identifier;
+ :param `button_state`: the button state;
+ :param `bmp`: the custom bitmap to use for the button.
+ """
+
+ if bitmap_id == AUI_BUTTON_CLOSE:
+ if button_state == AUI_BUTTON_STATE_NORMAL:
+ self._active_close_bmp = bmp
+ self._hover_close_bmp = self._active_close_bmp
+ self._pressed_close_bmp = self._active_close_bmp
+ self._disabled_close_bmp = self._active_close_bmp
+
+ elif button_state == AUI_BUTTON_STATE_HOVER:
+ self._hover_close_bmp = bmp
+ elif button_state == AUI_BUTTON_STATE_PRESSED:
+ self._pressed_close_bmp = bmp
+ else:
+ self._disabled_close_bmp = bmp
+
+ elif bitmap_id == AUI_BUTTON_LEFT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ self._disabled_left_bmp = bmp
+ else:
+ self._active_left_bmp = bmp
+
+ elif bitmap_id == AUI_BUTTON_RIGHT:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ self._disabled_right_bmp = bmp
+ else:
+ self._active_right_bmp = bmp
+
+ elif bitmap_id == AUI_BUTTON_WINDOWLIST:
+ if button_state & AUI_BUTTON_STATE_DISABLED:
+ self._disabled_windowlist_bmp = bmp
+ else:
+ self._active_windowlist_bmp = bmp
+
+
+class VC71TabArt(AuiDefaultTabArt):
+ """ A class to draw tabs using the Visual Studio 2003 (VC71) style. """
+
+ def __init__(self):
+ """ Default class constructor. """
+
+ AuiDefaultTabArt.__init__(self)
+
+
+ def Clone(self):
+ """ Clones the art object. """
+
+ art = type(self)()
+ art.SetNormalFont(self.GetNormalFont())
+ art.SetSelectedFont(self.GetSelectedFont())
+ art.SetMeasuringFont(self.GetMeasuringFont())
+
+ art = CopyAttributes(art, self)
+ return art
+
+
+ def DrawTab(self, dc, wnd, page, in_rect, close_button_state, paint_control=False):
+ """
+ Draws a single tab.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `page`: the tab control page associated with the tab;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `paint_control`: whether to draw the control inside a tab (if any) on a `wx.MemoryDC`.
+ """
+
+ # Visual studio 7.1 style
+ # This code is based on the renderer included in FlatNotebook
+
+ # figure out the size of the tab
+
+ control = page.control
+ tab_size, x_extent = self.GetTabSize(dc, wnd, page.caption, page.bitmap, page.active,
+ close_button_state, control)
+
+ tab_height = self._tab_ctrl_height - 3
+ tab_width = tab_size[0]
+ tab_x = in_rect.x
+ tab_y = in_rect.y + in_rect.height - tab_height
+ clip_width = tab_width
+
+ if tab_x + clip_width > in_rect.x + in_rect.width - 4:
+ clip_width = (in_rect.x + in_rect.width) - tab_x - 4
+
+ dc.SetClippingRegion(tab_x, tab_y, clip_width + 1, tab_height - 3)
+ agwFlags = self.GetAGWFlags()
+
+ if agwFlags & AUI_NB_BOTTOM:
+ tab_y -= 1
+
+ dc.SetPen((page.active and [wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DHIGHLIGHT))] or \
+ [wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DSHADOW))])[0])
+ dc.SetBrush((page.active and [wx.Brush(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE))] or \
+ [wx.TRANSPARENT_BRUSH])[0])
+
+ if page.active:
+
+ tabH = tab_height - 2
+ dc.DrawRectangle(tab_x, tab_y, tab_width, tabH)
+
+ rightLineY1 = (agwFlags & AUI_NB_BOTTOM and [vertical_border_padding - 2] or \
+ [vertical_border_padding - 1])[0]
+ rightLineY2 = tabH + 3
+ dc.SetPen(wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DSHADOW)))
+ dc.DrawLine(tab_x + tab_width - 1, rightLineY1 + 1, tab_x + tab_width - 1, rightLineY2)
+
+ if agwFlags & AUI_NB_BOTTOM:
+ dc.DrawLine(tab_x + 1, rightLineY2 - 3 , tab_x + tab_width - 1, rightLineY2 - 3)
+
+ dc.SetPen(wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DDKSHADOW)))
+ dc.DrawLine(tab_x + tab_width, rightLineY1, tab_x + tab_width, rightLineY2)
+
+ if agwFlags & AUI_NB_BOTTOM:
+ dc.DrawLine(tab_x, rightLineY2 - 2, tab_x + tab_width, rightLineY2 - 2)
+
+ else:
+
+ # We dont draw a rectangle for non selected tabs, but only
+ # vertical line on the right
+ blackLineY1 = (agwFlags & AUI_NB_BOTTOM and [vertical_border_padding + 2] or \
+ [vertical_border_padding + 1])[0]
+ blackLineY2 = tab_height - 5
+ dc.DrawLine(tab_x + tab_width, blackLineY1, tab_x + tab_width, blackLineY2)
+
+ border_points = [0, 0]
+
+ if agwFlags & AUI_NB_BOTTOM:
+
+ border_points[0] = wx.Point(tab_x, tab_y)
+ border_points[1] = wx.Point(tab_x, tab_y + tab_height - 6)
+
+ else: # if (agwFlags & AUI_NB_TOP)
+
+ border_points[0] = wx.Point(tab_x, tab_y + tab_height - 4)
+ border_points[1] = wx.Point(tab_x, tab_y + 2)
+
+ drawn_tab_yoff = border_points[1].y
+ drawn_tab_height = border_points[0].y - border_points[1].y
+
+ text_offset = tab_x + 8
+ close_button_width = 0
+
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ close_button_width = self._active_close_bmp.GetWidth()
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ text_offset += close_button_width - 5
+
+ if not page.enabled:
+ dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
+ pagebitmap = page.dis_bitmap
+ else:
+ dc.SetTextForeground(page.text_colour)
+ pagebitmap = page.bitmap
+
+ shift = 0
+ if agwFlags & AUI_NB_BOTTOM:
+ shift = (page.active and [1] or [2])[0]
+
+ bitmap_offset = 0
+ if pagebitmap.IsOk():
+ bitmap_offset = tab_x + 8
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT and close_button_width:
+ bitmap_offset += close_button_width - 5
+
+ # draw bitmap
+ dc.DrawBitmap(pagebitmap, bitmap_offset,
+ drawn_tab_yoff + (drawn_tab_height/2) - (pagebitmap.GetHeight()/2) + shift,
+ True)
+
+ text_offset = bitmap_offset + pagebitmap.GetWidth()
+ text_offset += 3 # bitmap padding
+
+ else:
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT == 0 or not close_button_width:
+ text_offset = tab_x + 8
+
+ # if the caption is empty, measure some temporary text
+ caption = page.caption
+
+ if caption == "":
+ caption = "Xj"
+
+ if page.active:
+ dc.SetFont(self._selected_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+ else:
+ dc.SetFont(self._normal_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x) - close_button_width)
+
+ ypos = drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1 + shift
+
+ offset_focus = text_offset
+
+ if control is not None:
+ if control.GetPosition() != wx.Point(text_offset+1, ypos):
+ control.SetPosition(wx.Point(text_offset+1, ypos))
+
+ if not control.IsShown():
+ control.Show()
+
+ if paint_control:
+ bmp = TakeScreenShot(control.GetScreenRect())
+ dc.DrawBitmap(bmp, text_offset+1, ypos, True)
+
+ controlW, controlH = control.GetSize()
+ text_offset += controlW + 4
+ textx += controlW + 4
+
+ # draw tab text
+ rectx, recty, dummy = dc.GetMultiLineTextExtent(draw_text)
+ dc.DrawLabel(draw_text, wx.Rect(text_offset, ypos, rectx, recty))
+
+ out_button_rect = wx.Rect()
+
+ # draw focus rectangle
+ if (agwFlags & AUI_NB_NO_TAB_FOCUS) == 0:
+ self.DrawFocusRectangle(dc, page, wnd, draw_text, offset_focus, bitmap_offset, drawn_tab_yoff+shift,
+ drawn_tab_height+shift, rectx, recty)
+
+ # draw 'x' on tab (if enabled)
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ close_button_width = self._active_close_bmp.GetWidth()
+
+ bmp = self._disabled_close_bmp
+
+ if close_button_state == AUI_BUTTON_STATE_HOVER:
+ bmp = self._hover_close_bmp
+ elif close_button_state == AUI_BUTTON_STATE_PRESSED:
+ bmp = self._pressed_close_bmp
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ rect = wx.Rect(tab_x + 4,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + shift,
+ close_button_width, tab_height)
+ else:
+ rect = wx.Rect(tab_x + tab_width - close_button_width - 3,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + shift,
+ close_button_width, tab_height)
+
+ # Indent the button if it is pressed down:
+ rect = IndentPressedBitmap(rect, close_button_state)
+ dc.DrawBitmap(bmp, rect.x, rect.y, True)
+
+ out_button_rect = rect
+
+ out_tab_rect = wx.Rect(tab_x, tab_y, tab_width, tab_height)
+ dc.DestroyClippingRegion()
+
+ return out_tab_rect, out_button_rect, x_extent
+
+
+class FF2TabArt(AuiDefaultTabArt):
+ """ A class to draw tabs using the Firefox 2 (FF2) style. """
+
+ def __init__(self):
+ """ Default class constructor. """
+
+ AuiDefaultTabArt.__init__(self)
+
+
+ def Clone(self):
+ """ Clones the art object. """
+
+ art = type(self)()
+ art.SetNormalFont(self.GetNormalFont())
+ art.SetSelectedFont(self.GetSelectedFont())
+ art.SetMeasuringFont(self.GetMeasuringFont())
+
+ art = CopyAttributes(art, self)
+ return art
+
+
+ def GetTabSize(self, dc, wnd, caption, bitmap, active, close_button_state, control):
+ """
+ Returns the tab size for the given caption, bitmap and button state.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `caption`: the tab text caption;
+ :param `bitmap`: the bitmap displayed on the tab;
+ :param `active`: whether the tab is selected or not;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `control`: a `wx.Window` instance inside a tab (or ``None``).
+ """
+
+ tab_size, x_extent = AuiDefaultTabArt.GetTabSize(self, dc, wnd, caption, bitmap,
+ active, close_button_state, control)
+
+ tab_width, tab_height = tab_size
+
+ # add some vertical padding
+ tab_height += 2
+
+ return (tab_width, tab_height), x_extent
+
+
+ def DrawTab(self, dc, wnd, page, in_rect, close_button_state, paint_control=False):
+ """
+ Draws a single tab.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `page`: the tab control page associated with the tab;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `paint_control`: whether to draw the control inside a tab (if any) on a `wx.MemoryDC`.
+ """
+
+ # Firefox 2 style
+
+ control = page.control
+
+ # figure out the size of the tab
+ tab_size, x_extent = self.GetTabSize(dc, wnd, page.caption, page.bitmap,
+ page.active, close_button_state, control)
+
+ tab_height = self._tab_ctrl_height - 2
+ tab_width = tab_size[0]
+ tab_x = in_rect.x
+ tab_y = in_rect.y + in_rect.height - tab_height
+
+ clip_width = tab_width
+ if tab_x + clip_width > in_rect.x + in_rect.width - 4:
+ clip_width = (in_rect.x + in_rect.width) - tab_x - 4
+
+ dc.SetClippingRegion(tab_x, tab_y, clip_width + 1, tab_height - 3)
+
+ tabPoints = [wx.Point() for i in xrange(7)]
+
+ adjust = 0
+ if not page.active:
+ adjust = 1
+
+ agwFlags = self.GetAGWFlags()
+
+ tabPoints[0].x = tab_x + 3
+ tabPoints[0].y = (agwFlags & AUI_NB_BOTTOM and [3] or [tab_height - 2])[0]
+
+ tabPoints[1].x = tabPoints[0].x
+ tabPoints[1].y = (agwFlags & AUI_NB_BOTTOM and [tab_height - (vertical_border_padding + 2) - adjust] or \
+ [(vertical_border_padding + 2) + adjust])[0]
+
+ tabPoints[2].x = tabPoints[1].x+2
+ tabPoints[2].y = (agwFlags & AUI_NB_BOTTOM and [tab_height - vertical_border_padding - adjust] or \
+ [vertical_border_padding + adjust])[0]
+
+ tabPoints[3].x = tab_x + tab_width - 2
+ tabPoints[3].y = tabPoints[2].y
+
+ tabPoints[4].x = tabPoints[3].x + 2
+ tabPoints[4].y = tabPoints[1].y
+
+ tabPoints[5].x = tabPoints[4].x
+ tabPoints[5].y = tabPoints[0].y
+
+ tabPoints[6].x = tabPoints[0].x
+ tabPoints[6].y = tabPoints[0].y
+
+ rr = wx.RectPP(tabPoints[2], tabPoints[5])
+ self.DrawTabBackground(dc, rr, page.active, (agwFlags & AUI_NB_BOTTOM) == 0)
+
+ dc.SetBrush(wx.TRANSPARENT_BRUSH)
+ dc.SetPen(wx.Pen(wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)))
+
+ # Draw the tab as rounded rectangle
+ dc.DrawPolygon(tabPoints)
+
+ if page.active:
+ dc.DrawLine(tabPoints[0].x + 1, tabPoints[0].y, tabPoints[5].x , tabPoints[0].y)
+
+ drawn_tab_yoff = tabPoints[1].y
+ drawn_tab_height = tabPoints[0].y - tabPoints[2].y
+
+ text_offset = tab_x + 8
+ close_button_width = 0
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ close_button_width = self._active_close_bmp.GetWidth()
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ text_offset += close_button_width - 4
+
+ if not page.enabled:
+ dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
+ pagebitmap = page.dis_bitmap
+ else:
+ dc.SetTextForeground(page.text_colour)
+ pagebitmap = page.bitmap
+
+ shift = -1
+ if agwFlags & AUI_NB_BOTTOM:
+ shift = 2
+
+ bitmap_offset = 0
+ if pagebitmap.IsOk():
+ bitmap_offset = tab_x + 8
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT and close_button_width:
+ bitmap_offset += close_button_width - 4
+
+ # draw bitmap
+ dc.DrawBitmap(pagebitmap, bitmap_offset,
+ drawn_tab_yoff + (drawn_tab_height/2) - (pagebitmap.GetHeight()/2) + shift,
+ True)
+
+ text_offset = bitmap_offset + pagebitmap.GetWidth()
+ text_offset += 3 # bitmap padding
+
+ else:
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT == 0 or not close_button_width:
+ text_offset = tab_x + 8
+
+ # if the caption is empty, measure some temporary text
+ caption = page.caption
+ if caption == "":
+ caption = "Xj"
+
+ if page.active:
+ dc.SetFont(self._selected_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+ else:
+ dc.SetFont(self._normal_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x) - close_button_width + 1)
+ else:
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x) - close_button_width)
+
+ ypos = drawn_tab_yoff + drawn_tab_height/2 - texty/2 - 1 + shift
+
+ offset_focus = text_offset
+
+ if control is not None:
+ if control.GetPosition() != wx.Point(text_offset+1, ypos):
+ control.SetPosition(wx.Point(text_offset+1, ypos))
+
+ if not control.IsShown():
+ control.Show()
+
+ if paint_control:
+ bmp = TakeScreenShot(control.GetScreenRect())
+ dc.DrawBitmap(bmp, text_offset+1, ypos, True)
+
+ controlW, controlH = control.GetSize()
+ text_offset += controlW + 4
+ textx += controlW + 4
+
+ # draw tab text
+ rectx, recty, dummy = dc.GetMultiLineTextExtent(draw_text)
+ dc.DrawLabel(draw_text, wx.Rect(text_offset, ypos, rectx, recty))
+
+ # draw focus rectangle
+ if (agwFlags & AUI_NB_NO_TAB_FOCUS) == 0:
+ self.DrawFocusRectangle(dc, page, wnd, draw_text, offset_focus, bitmap_offset, drawn_tab_yoff+shift,
+ drawn_tab_height, rectx, recty)
+
+ out_button_rect = wx.Rect()
+ # draw 'x' on tab (if enabled)
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+
+ close_button_width = self._active_close_bmp.GetWidth()
+ bmp = self._disabled_close_bmp
+
+ if close_button_state == AUI_BUTTON_STATE_HOVER:
+ bmp = self._hover_close_bmp
+ elif close_button_state == AUI_BUTTON_STATE_PRESSED:
+ bmp = self._pressed_close_bmp
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ rect = wx.Rect(tab_x + 5,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + shift,
+ close_button_width, tab_height)
+ else:
+ rect = wx.Rect(tab_x + tab_width - close_button_width - 3,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + shift,
+ close_button_width, tab_height)
+
+ # Indent the button if it is pressed down:
+ rect = IndentPressedBitmap(rect, close_button_state)
+ dc.DrawBitmap(bmp, rect.x, rect.y, True)
+ out_button_rect = rect
+
+ out_tab_rect = wx.Rect(tab_x, tab_y, tab_width, tab_height)
+ dc.DestroyClippingRegion()
+
+ return out_tab_rect, out_button_rect, x_extent
+
+
+ def DrawTabBackground(self, dc, rect, focus, upperTabs):
+ """
+ Draws the tab background for the Firefox 2 style.
+ This is more consistent with L{FlatNotebook} than before.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `rect`: rectangle the tab should be confined to;
+ :param `focus`: whether the tab has focus or not;
+ :param `upperTabs`: whether the style is ``AUI_NB_TOP`` or ``AUI_NB_BOTTOM``.
+ """
+
+ # Define the rounded rectangle base on the given rect
+ # we need an array of 9 points for it
+ regPts = [wx.Point() for indx in xrange(9)]
+
+ if focus:
+ if upperTabs:
+ leftPt = wx.Point(rect.x, rect.y + (rect.height / 10)*8)
+ rightPt = wx.Point(rect.x + rect.width - 2, rect.y + (rect.height / 10)*8)
+ else:
+ leftPt = wx.Point(rect.x, rect.y + (rect.height / 10)*5)
+ rightPt = wx.Point(rect.x + rect.width - 2, rect.y + (rect.height / 10)*5)
+ else:
+ leftPt = wx.Point(rect.x, rect.y + (rect.height / 2))
+ rightPt = wx.Point(rect.x + rect.width - 2, rect.y + (rect.height / 2))
+
+ # Define the top region
+ top = wx.RectPP(rect.GetTopLeft(), rightPt)
+ bottom = wx.RectPP(leftPt, rect.GetBottomRight())
+
+ topStartColour = wx.WHITE
+
+ if not focus:
+ topStartColour = LightColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE), 50)
+
+ topEndColour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE)
+ bottomStartColour = topEndColour
+ bottomEndColour = topEndColour
+
+ # Incase we use bottom tabs, switch the colours
+ if upperTabs:
+ if focus:
+ dc.GradientFillLinear(top, topStartColour, topEndColour, wx.SOUTH)
+ dc.GradientFillLinear(bottom, bottomStartColour, bottomEndColour, wx.SOUTH)
+ else:
+ dc.GradientFillLinear(top, topEndColour , topStartColour, wx.SOUTH)
+ dc.GradientFillLinear(bottom, bottomStartColour, bottomEndColour, wx.SOUTH)
+
+ else:
+ if focus:
+ dc.GradientFillLinear(bottom, topEndColour, bottomEndColour, wx.SOUTH)
+ dc.GradientFillLinear(top, topStartColour, topStartColour, wx.SOUTH)
+ else:
+ dc.GradientFillLinear(bottom, bottomStartColour, bottomEndColour, wx.SOUTH)
+ dc.GradientFillLinear(top, topEndColour, topStartColour, wx.SOUTH)
+
+ dc.SetBrush(wx.TRANSPARENT_BRUSH)
+
+
+class VC8TabArt(AuiDefaultTabArt):
+ """ A class to draw tabs using the Visual Studio 2005 (VC8) style. """
+
+ def __init__(self):
+ """ Default class constructor. """
+
+ AuiDefaultTabArt.__init__(self)
+
+
+ def Clone(self):
+ """ Clones the art object. """
+
+ art = type(self)()
+ art.SetNormalFont(self.GetNormalFont())
+ art.SetSelectedFont(self.GetSelectedFont())
+ art.SetMeasuringFont(self.GetMeasuringFont())
+
+ art = CopyAttributes(art, self)
+ return art
+
+
+ def SetSizingInfo(self, tab_ctrl_size, tab_count, minMaxTabWidth):
+ """
+ Sets the tab sizing information.
+
+ :param `tab_ctrl_size`: the size of the tab control area;
+ :param `tab_count`: the number of tabs;
+ :param `minMaxTabWidth`: a tuple containing the minimum and maximum tab widths
+ to be used when the ``AUI_NB_TAB_FIXED_WIDTH`` style is active.
+ """
+
+ AuiDefaultTabArt.SetSizingInfo(self, tab_ctrl_size, tab_count, minMaxTabWidth)
+
+ minTabWidth, maxTabWidth = minMaxTabWidth
+ if minTabWidth > -1:
+ self._fixed_tab_width = max(self._fixed_tab_width, minTabWidth)
+ if maxTabWidth > -1:
+ self._fixed_tab_width = min(self._fixed_tab_width, maxTabWidth)
+
+ self._fixed_tab_width -= 5
+
+
+ def GetTabSize(self, dc, wnd, caption, bitmap, active, close_button_state, control=None):
+ """
+ Returns the tab size for the given caption, bitmap and button state.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `caption`: the tab text caption;
+ :param `bitmap`: the bitmap displayed on the tab;
+ :param `active`: whether the tab is selected or not;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `control`: a `wx.Window` instance inside a tab (or ``None``).
+ """
+
+ tab_size, x_extent = AuiDefaultTabArt.GetTabSize(self, dc, wnd, caption, bitmap,
+ active, close_button_state, control)
+
+ tab_width, tab_height = tab_size
+
+ # add some padding
+ tab_width += 10
+ tab_height += 2
+
+ return (tab_width, tab_height), x_extent
+
+
+ def DrawTab(self, dc, wnd, page, in_rect, close_button_state, paint_control=False):
+ """
+ Draws a single tab.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `page`: the tab control page associated with the tab;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `paint_control`: whether to draw the control inside a tab (if any) on a `wx.MemoryDC`.
+ """
+
+ # Visual Studio 8 style
+
+ control = page.control
+
+ # figure out the size of the tab
+ tab_size, x_extent = self.GetTabSize(dc, wnd, page.caption, page.bitmap,
+ page.active, close_button_state, control)
+
+ tab_height = self._tab_ctrl_height - 1
+ tab_width = tab_size[0]
+ tab_x = in_rect.x
+ tab_y = in_rect.y + in_rect.height - tab_height
+
+ clip_width = tab_width + 3
+ if tab_x + clip_width > in_rect.x + in_rect.width - 4:
+ clip_width = (in_rect.x + in_rect.width) - tab_x - 4
+
+ tabPoints = [wx.Point() for i in xrange(8)]
+
+ # If we draw the first tab or the active tab,
+ # we draw a full tab, else we draw a truncated tab
+ #
+ # X(2) X(3)
+ # X(1) X(4)
+ #
+ # X(5)
+ #
+ # X(0),(7) X(6)
+ #
+ #
+
+ adjust = 0
+ if not page.active:
+ adjust = 1
+
+ agwFlags = self.GetAGWFlags()
+ tabPoints[0].x = (agwFlags & AUI_NB_BOTTOM and [tab_x] or [tab_x + adjust])[0]
+ tabPoints[0].y = (agwFlags & AUI_NB_BOTTOM and [2] or [tab_height - 3])[0]
+
+ tabPoints[1].x = tabPoints[0].x + tab_height - vertical_border_padding - 3 - adjust
+ tabPoints[1].y = (agwFlags & AUI_NB_BOTTOM and [tab_height - (vertical_border_padding+2)] or \
+ [(vertical_border_padding+2)])[0]
+
+ tabPoints[2].x = tabPoints[1].x + 4
+ tabPoints[2].y = (agwFlags & AUI_NB_BOTTOM and [tab_height - vertical_border_padding] or \
+ [vertical_border_padding])[0]
+
+ tabPoints[3].x = tabPoints[2].x + tab_width - tab_height + vertical_border_padding
+ tabPoints[3].y = (agwFlags & AUI_NB_BOTTOM and [tab_height - vertical_border_padding] or \
+ [vertical_border_padding])[0]
+
+ tabPoints[4].x = tabPoints[3].x + 1
+ tabPoints[4].y = (agwFlags & AUI_NB_BOTTOM and [tabPoints[3].y - 1] or [tabPoints[3].y + 1])[0]
+
+ tabPoints[5].x = tabPoints[4].x + 1
+ tabPoints[5].y = (agwFlags & AUI_NB_BOTTOM and [(tabPoints[4].y - 1)] or [tabPoints[4].y + 1])[0]
+
+ tabPoints[6].x = tabPoints[2].x + tab_width - tab_height + 2 + vertical_border_padding
+ tabPoints[6].y = tabPoints[0].y
+
+ tabPoints[7].x = tabPoints[0].x
+ tabPoints[7].y = tabPoints[0].y
+
+ self.FillVC8GradientColour(dc, tabPoints, page.active)
+
+ dc.SetBrush(wx.TRANSPARENT_BRUSH)
+
+ dc.SetPen(wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNSHADOW)))
+ dc.DrawPolygon(tabPoints)
+
+ if page.active:
+ # Delete the bottom line (or the upper one, incase we use wxBOTTOM)
+ dc.SetPen(wx.WHITE_PEN)
+ dc.DrawLine(tabPoints[0].x, tabPoints[0].y, tabPoints[6].x, tabPoints[6].y)
+
+ dc.SetClippingRegion(tab_x, tab_y, clip_width + 2, tab_height - 3)
+
+ drawn_tab_yoff = tabPoints[1].y
+ drawn_tab_height = tabPoints[0].y - tabPoints[2].y
+
+ text_offset = tab_x + 20
+ close_button_width = 0
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ close_button_width = self._active_close_bmp.GetWidth()
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ text_offset += close_button_width
+
+ if not page.enabled:
+ dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
+ pagebitmap = page.dis_bitmap
+ else:
+ dc.SetTextForeground(page.text_colour)
+ pagebitmap = page.bitmap
+
+ shift = 0
+ if agwFlags & AUI_NB_BOTTOM:
+ shift = (page.active and [1] or [2])[0]
+
+ bitmap_offset = 0
+ if pagebitmap.IsOk():
+ bitmap_offset = tab_x + 20
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT and close_button_width:
+ bitmap_offset += close_button_width
+
+ # draw bitmap
+ dc.DrawBitmap(pagebitmap, bitmap_offset,
+ drawn_tab_yoff + (drawn_tab_height/2) - (pagebitmap.GetHeight()/2) + shift,
+ True)
+
+ text_offset = bitmap_offset + pagebitmap.GetWidth()
+ text_offset += 3 # bitmap padding
+
+ else:
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT == 0 or not close_button_width:
+ text_offset = tab_x + tab_height
+
+ # if the caption is empty, measure some temporary text
+ caption = page.caption
+ if caption == "":
+ caption = "Xj"
+
+ if page.active:
+ dc.SetFont(self._selected_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+ else:
+ dc.SetFont(self._normal_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x))
+ else:
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x) - close_button_width)
+
+ ypos = drawn_tab_yoff + drawn_tab_height/2 - texty/2 - 1 + shift
+
+ offset_focus = text_offset
+
+ if control is not None:
+ if control.GetPosition() != wx.Point(text_offset+1, ypos):
+ control.SetPosition(wx.Point(text_offset+1, ypos))
+
+ if not control.IsShown():
+ control.Show()
+
+ if paint_control:
+ bmp = TakeScreenShot(control.GetScreenRect())
+ dc.DrawBitmap(bmp, text_offset+1, ypos, True)
+
+ controlW, controlH = control.GetSize()
+ text_offset += controlW + 4
+ textx += controlW + 4
+
+ # draw tab text
+ rectx, recty, dummy = dc.GetMultiLineTextExtent(draw_text)
+ dc.DrawLabel(draw_text, wx.Rect(text_offset, ypos, rectx, recty))
+
+ # draw focus rectangle
+ if (agwFlags & AUI_NB_NO_TAB_FOCUS) == 0:
+ self.DrawFocusRectangle(dc, page, wnd, draw_text, offset_focus, bitmap_offset, drawn_tab_yoff+shift,
+ drawn_tab_height+shift, rectx, recty)
+
+ out_button_rect = wx.Rect()
+ # draw 'x' on tab (if enabled)
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+
+ close_button_width = self._active_close_bmp.GetWidth()
+ bmp = self._disabled_close_bmp
+
+ if close_button_state == AUI_BUTTON_STATE_HOVER:
+ bmp = self._hover_close_bmp
+ elif close_button_state == AUI_BUTTON_STATE_PRESSED:
+ bmp = self._pressed_close_bmp
+
+ if page.active:
+ xpos = tab_x + tab_width - close_button_width + 3
+ else:
+ xpos = tab_x + tab_width - close_button_width - 5
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ rect = wx.Rect(tab_x + 20,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + shift,
+ close_button_width, tab_height)
+ else:
+ rect = wx.Rect(xpos,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + shift,
+ close_button_width, tab_height)
+
+ # Indent the button if it is pressed down:
+ rect = IndentPressedBitmap(rect, close_button_state)
+ dc.DrawBitmap(bmp, rect.x, rect.y, True)
+ out_button_rect = rect
+
+ out_tab_rect = wx.Rect(tab_x, tab_y, x_extent, tab_height)
+ dc.DestroyClippingRegion()
+
+ return out_tab_rect, out_button_rect, x_extent
+
+
+ def FillVC8GradientColour(self, dc, tabPoints, active):
+ """
+ Fills the tab with the Visual Studio 2005 gradient background.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `tabPoints`: a list of `wx.Point` objects describing the tab shape;
+ :param `active`: whether the tab is selected or not.
+ """
+
+ xList = [pt.x for pt in tabPoints]
+ yList = [pt.y for pt in tabPoints]
+
+ minx, maxx = min(xList), max(xList)
+ miny, maxy = min(yList), max(yList)
+
+ rect = wx.Rect(minx, maxy, maxx-minx, miny-maxy+1)
+ region = wx.RegionFromPoints(tabPoints)
+
+ if self._buttonRect.width > 0:
+ buttonRegion = wx.Region(*self._buttonRect)
+ region.XorRegion(buttonRegion)
+
+ dc.SetClippingRegionAsRegion(region)
+
+ if active:
+ bottom_colour = top_colour = wx.WHITE
+ else:
+ bottom_colour = StepColour(self._base_colour, 90)
+ top_colour = StepColour(self._base_colour, 170)
+
+ dc.GradientFillLinear(rect, top_colour, bottom_colour, wx.SOUTH)
+ dc.DestroyClippingRegion()
+
+
+class ChromeTabArt(AuiDefaultTabArt):
+ """
+ A class to draw tabs using the Google Chrome browser style.
+ It uses custom bitmap to render the tabs, so that the look and feel is as close
+ as possible to the Chrome style.
+ """
+
+ def __init__(self):
+ """ Default class constructor. """
+
+ AuiDefaultTabArt.__init__(self)
+
+ self.SetBitmaps(mirror=False)
+
+ closeBmp = tab_close.GetBitmap()
+ closeHBmp = tab_close_h.GetBitmap()
+ closePBmp = tab_close_p.GetBitmap()
+
+ self.SetCustomButton(AUI_BUTTON_CLOSE, AUI_BUTTON_STATE_NORMAL, closeBmp)
+ self.SetCustomButton(AUI_BUTTON_CLOSE, AUI_BUTTON_STATE_HOVER, closeHBmp)
+ self.SetCustomButton(AUI_BUTTON_CLOSE, AUI_BUTTON_STATE_PRESSED, closePBmp)
+
+
+ def SetAGWFlags(self, agwFlags):
+ """
+ Sets the tab art flags.
+
+ :param `agwFlags`: a combination of the following values:
+
+ ==================================== ==================================
+ Flag name Description
+ ==================================== ==================================
+ ``AUI_NB_TOP`` With this style, tabs are drawn along the top of the notebook
+ ``AUI_NB_LEFT`` With this style, tabs are drawn along the left of the notebook. Not implemented yet.
+ ``AUI_NB_RIGHT`` With this style, tabs are drawn along the right of the notebook. Not implemented yet.
+ ``AUI_NB_BOTTOM`` With this style, tabs are drawn along the bottom of the notebook
+ ``AUI_NB_TAB_SPLIT`` Allows the tab control to be split by dragging a tab
+ ``AUI_NB_TAB_MOVE`` Allows a tab to be moved horizontally by dragging
+ ``AUI_NB_TAB_EXTERNAL_MOVE`` Allows a tab to be moved to another tab control
+ ``AUI_NB_TAB_FIXED_WIDTH`` With this style, all tabs have the same width
+ ``AUI_NB_SCROLL_BUTTONS`` With this style, left and right scroll buttons are displayed
+ ``AUI_NB_WINDOWLIST_BUTTON`` With this style, a drop-down list of windows is available
+ ``AUI_NB_CLOSE_BUTTON`` With this style, a close button is available on the tab bar
+ ``AUI_NB_CLOSE_ON_ACTIVE_TAB`` With this style, a close button is available on the active tab
+ ``AUI_NB_CLOSE_ON_ALL_TABS`` With this style, a close button is available on all tabs
+ ``AUI_NB_MIDDLE_CLICK_CLOSE`` Allows to close L{AuiNotebook} tabs by mouse middle button click
+ ``AUI_NB_SUB_NOTEBOOK`` This style is used by L{AuiManager} to create automatic AuiNotebooks
+ ``AUI_NB_HIDE_ON_SINGLE_TAB`` Hides the tab window if only one tab is present
+ ``AUI_NB_SMART_TABS`` Use Smart Tabbing, like ``Alt`` + ``Tab`` on Windows
+ ``AUI_NB_USE_IMAGES_DROPDOWN`` Uses images on dropdown window list menu instead of check items
+ ``AUI_NB_CLOSE_ON_TAB_LEFT`` Draws the tab close button on the left instead of on the right (a la Camino browser)
+ ``AUI_NB_TAB_FLOAT`` Allows the floating of single tabs. Known limitation: when the notebook is more or less full screen, tabs cannot be dragged far enough outside of the notebook to become floating pages
+ ``AUI_NB_DRAW_DND_TAB`` Draws an image representation of a tab while dragging (on by default)
+ ``AUI_NB_ORDER_BY_ACCESS`` Tab navigation order by last access time for the tabs
+ ``AUI_NB_NO_TAB_FOCUS`` Don't draw tab focus rectangle
+ ==================================== ==================================
+
+ :note: Overridden from L{AuiDefaultTabArt}.
+ """
+
+ if agwFlags & AUI_NB_TOP:
+ self.SetBitmaps(mirror=False)
+ elif agwFlags & AUI_NB_BOTTOM:
+ self.SetBitmaps(mirror=True)
+
+ AuiDefaultTabArt.SetAGWFlags(self, agwFlags)
+
+
+ def SetBitmaps(self, mirror):
+ """
+ Assigns the tab custom bitmaps
+
+ :param `mirror`: whether to vertically mirror the bitmap or not.
+ """
+
+ bmps = [tab_active_left.GetBitmap(), tab_active_center.GetBitmap(),
+ tab_active_right.GetBitmap(), tab_inactive_left.GetBitmap(),
+ tab_inactive_center.GetBitmap(), tab_inactive_right.GetBitmap()]
+
+ if mirror:
+ for indx, bmp in enumerate(bmps):
+ img = bmp.ConvertToImage()
+ img = img.Mirror(horizontally=False)
+ bmps[indx] = img.ConvertToBitmap()
+
+ self._leftActiveBmp = bmps[0]
+ self._centerActiveBmp = bmps[1]
+ self._rightActiveBmp = bmps[2]
+ self._leftInactiveBmp = bmps[3]
+ self._centerInactiveBmp = bmps[4]
+ self._rightInactiveBmp = bmps[5]
+
+
+ def Clone(self):
+ """ Clones the art object. """
+
+ art = type(self)()
+ art.SetNormalFont(self.GetNormalFont())
+ art.SetSelectedFont(self.GetSelectedFont())
+ art.SetMeasuringFont(self.GetMeasuringFont())
+
+ art = CopyAttributes(art, self)
+ return art
+
+
+ def SetSizingInfo(self, tab_ctrl_size, tab_count, minMaxTabWidth):
+ """
+ Sets the tab sizing information.
+
+ :param `tab_ctrl_size`: the size of the tab control area;
+ :param `tab_count`: the number of tabs;
+ :param `minMaxTabWidth`: a tuple containing the minimum and maximum tab widths
+ to be used when the ``AUI_NB_TAB_FIXED_WIDTH`` style is active.
+ """
+
+ AuiDefaultTabArt.SetSizingInfo(self, tab_ctrl_size, tab_count, minMaxTabWidth)
+
+ minTabWidth, maxTabWidth = minMaxTabWidth
+ if minTabWidth > -1:
+ self._fixed_tab_width = max(self._fixed_tab_width, minTabWidth)
+ if maxTabWidth > -1:
+ self._fixed_tab_width = min(self._fixed_tab_width, maxTabWidth)
+
+ self._fixed_tab_width -= 5
+
+
+ def GetTabSize(self, dc, wnd, caption, bitmap, active, close_button_state, control=None):
+ """
+ Returns the tab size for the given caption, bitmap and button state.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `caption`: the tab text caption;
+ :param `bitmap`: the bitmap displayed on the tab;
+ :param `active`: whether the tab is selected or not;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `control`: a `wx.Window` instance inside a tab (or ``None``).
+ """
+
+ tab_size, x_extent = AuiDefaultTabArt.GetTabSize(self, dc, wnd, caption, bitmap,
+ active, close_button_state, control)
+
+ tab_width, tab_height = tab_size
+
+ # add some padding
+ tab_width += self._leftActiveBmp.GetWidth()
+ tab_height += 2
+
+ tab_height = max(tab_height, self._centerActiveBmp.GetHeight())
+
+ return (tab_width, tab_height), x_extent
+
+
+ def DrawTab(self, dc, wnd, page, in_rect, close_button_state, paint_control=False):
+ """
+ Draws a single tab.
+
+ :param `dc`: a `wx.DC` device context;
+ :param `wnd`: a `wx.Window` instance object;
+ :param `page`: the tab control page associated with the tab;
+ :param `in_rect`: rectangle the tab should be confined to;
+ :param `close_button_state`: the state of the close button on the tab;
+ :param `paint_control`: whether to draw the control inside a tab (if any) on a `wx.MemoryDC`.
+ """
+
+ # Chrome tab style
+
+ control = page.control
+ # figure out the size of the tab
+ tab_size, x_extent = self.GetTabSize(dc, wnd, page.caption, page.bitmap, page.active,
+ close_button_state, control)
+
+ agwFlags = self.GetAGWFlags()
+
+ tab_height = self._tab_ctrl_height - 1
+ tab_width = tab_size[0]
+ tab_x = in_rect.x
+ tab_y = in_rect.y + in_rect.height - tab_height
+ clip_width = tab_width
+
+ if tab_x + clip_width > in_rect.x + in_rect.width - 4:
+ clip_width = (in_rect.x + in_rect.width) - tab_x - 4
+
+ dc.SetClippingRegion(tab_x, tab_y, clip_width + 1, tab_height - 3)
+ drawn_tab_yoff = 1
+
+ if page.active:
+ left = self._leftActiveBmp
+ center = self._centerActiveBmp
+ right = self._rightActiveBmp
+ else:
+ left = self._leftInactiveBmp
+ center = self._centerInactiveBmp
+ right = self._rightInactiveBmp
+
+ dc.DrawBitmap(left, tab_x, tab_y)
+ leftw = left.GetWidth()
+ centerw = center.GetWidth()
+ rightw = right.GetWidth()
+
+ available = tab_x + tab_width - rightw
+ posx = tab_x + leftw
+
+ while 1:
+ if posx >= available:
+ break
+ dc.DrawBitmap(center, posx, tab_y)
+ posx += centerw
+
+ dc.DrawBitmap(right, posx, tab_y)
+
+ drawn_tab_height = center.GetHeight()
+ text_offset = tab_x + leftw
+
+ close_button_width = 0
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+ close_button_width = self._active_close_bmp.GetWidth()
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ text_offset += close_button_width
+
+ if not page.enabled:
+ dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
+ pagebitmap = page.dis_bitmap
+ else:
+ dc.SetTextForeground(page.text_colour)
+ pagebitmap = page.bitmap
+
+ bitmap_offset = 0
+ if pagebitmap.IsOk():
+ bitmap_offset = tab_x + leftw
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT and close_button_width:
+ bitmap_offset += close_button_width
+
+ # draw bitmap
+ dc.DrawBitmap(pagebitmap, bitmap_offset,
+ drawn_tab_yoff + (drawn_tab_height/2) - (pagebitmap.GetHeight()/2),
+ True)
+
+ text_offset = bitmap_offset + pagebitmap.GetWidth()
+ text_offset += 3 # bitmap padding
+
+ else:
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT == 0 or not close_button_width:
+ text_offset = tab_x + leftw
+
+ # if the caption is empty, measure some temporary text
+ caption = page.caption
+ if caption == "":
+ caption = "Xj"
+
+ if page.active:
+ dc.SetFont(self._selected_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+ else:
+ dc.SetFont(self._normal_font)
+ textx, texty, dummy = dc.GetMultiLineTextExtent(caption)
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x) - leftw)
+ else:
+ draw_text = ChopText(dc, caption, tab_width - (text_offset-tab_x) - close_button_width - leftw)
+
+ ypos = drawn_tab_yoff + drawn_tab_height/2 - texty/2 - 1
+
+ if control is not None:
+ if control.GetPosition() != wx.Point(text_offset+1, ypos):
+ control.SetPosition(wx.Point(text_offset+1, ypos))
+
+ if not control.IsShown():
+ control.Show()
+
+ if paint_control:
+ bmp = TakeScreenShot(control.GetScreenRect())
+ dc.DrawBitmap(bmp, text_offset+1, ypos, True)
+
+ controlW, controlH = control.GetSize()
+ text_offset += controlW + 4
+
+ # draw tab text
+ rectx, recty, dummy = dc.GetMultiLineTextExtent(draw_text)
+ dc.DrawLabel(draw_text, wx.Rect(text_offset, ypos, rectx, recty))
+
+ out_button_rect = wx.Rect()
+ # draw 'x' on tab (if enabled)
+ if close_button_state != AUI_BUTTON_STATE_HIDDEN:
+
+ close_button_width = self._active_close_bmp.GetWidth()
+ bmp = self._disabled_close_bmp
+
+ if close_button_state == AUI_BUTTON_STATE_HOVER:
+ bmp = self._hover_close_bmp
+ elif close_button_state == AUI_BUTTON_STATE_PRESSED:
+ bmp = self._pressed_close_bmp
+
+ if agwFlags & AUI_NB_CLOSE_ON_TAB_LEFT:
+ rect = wx.Rect(tab_x + leftw - 2,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + 1,
+ close_button_width, tab_height)
+ else:
+ rect = wx.Rect(tab_x + tab_width - close_button_width - rightw + 2,
+ drawn_tab_yoff + (drawn_tab_height / 2) - (bmp.GetHeight() / 2) + 1,
+ close_button_width, tab_height)
+
+ if agwFlags & AUI_NB_BOTTOM:
+ rect.y -= 1
+
+ # Indent the button if it is pressed down:
+ rect = IndentPressedBitmap(rect, close_button_state)
+ dc.DrawBitmap(bmp, rect.x, rect.y, True)
+ out_button_rect = rect
+
+ out_tab_rect = wx.Rect(tab_x, tab_y, tab_width, tab_height)
+ dc.DestroyClippingRegion()
+
+ return out_tab_rect, out_button_rect, x_extent
+
+
projects / iramuteq / blobdiff