+++ /dev/null
-"""
-auibook contains a notebook control which implements many features common in
-applications with dockable panes. Specifically, L{AuiNotebook} implements functionality
-which allows the user to rearrange tab order via drag-and-drop, split the tab window
-into many different splitter configurations, and toggle through different themes to
-customize the control's look and feel.
-
-An effort has been made to try to maintain an API as similar to that of `wx.Notebook`.
-
-The default theme that is used is L{AuiDefaultTabArt}, which provides a modern, glossy
-look and feel. The theme can be changed by calling L{AuiNotebook.SetArtProvider}.
-"""
-
-__author__ = "Andrea Gavana <andrea.gavana@gmail.com>"
-__date__ = "31 March 2009"
-
-
-import wx
-import types
-import datetime
-
-from wx.lib.expando import ExpandoTextCtrl
-
-import framemanager
-import tabart as TA
-
-from aui_utilities import LightColour, MakeDisabledBitmap, TabDragImage
-from aui_utilities import TakeScreenShot, RescaleScreenShot
-
-from aui_constants import *
-
-# AuiNotebook events
-wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_BUTTON = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_END_DRAG = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_TAB_DCLICK = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_BG_MIDDLE_DOWN = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_BG_MIDDLE_UP = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_BG_RIGHT_DOWN = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_BG_RIGHT_UP = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK = wx.NewEventType()
-
-# Define a new event for a drag cancelled
-wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG = wx.NewEventType()
-
-# Define events for editing a tab label
-wxEVT_COMMAND_AUINOTEBOOK_BEGIN_LABEL_EDIT = wx.NewEventType()
-wxEVT_COMMAND_AUINOTEBOOK_END_LABEL_EDIT = wx.NewEventType()
-
-# Create event binders
-EVT_AUINOTEBOOK_PAGE_CLOSE = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, 1)
-""" A tab in `AuiNotebook` is being closed. Can be vetoed by calling `Veto()`. """
-EVT_AUINOTEBOOK_PAGE_CLOSED = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, 1)
-""" A tab in `AuiNotebook` has been closed. """
-EVT_AUINOTEBOOK_PAGE_CHANGED = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, 1)
-""" The page selection was changed. """
-EVT_AUINOTEBOOK_PAGE_CHANGING = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, 1)
-""" The page selection is being changed. """
-EVT_AUINOTEBOOK_BUTTON = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, 1)
-""" The user clicked on a button in the `AuiNotebook` tab area. """
-EVT_AUINOTEBOOK_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, 1)
-""" A drag-and-drop operation on a notebook tab has started. """
-EVT_AUINOTEBOOK_END_DRAG = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, 1)
-""" A drag-and-drop operation on a notebook tab has finished. """
-EVT_AUINOTEBOOK_DRAG_MOTION = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, 1)
-""" A drag-and-drop operation on a notebook tab is ongoing. """
-EVT_AUINOTEBOOK_ALLOW_DND = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, 1)
-""" Fires an event asking if it is OK to drag and drop a tab. """
-EVT_AUINOTEBOOK_DRAG_DONE = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, 1)
-""" A drag-and-drop operation on a notebook tab has finished. """
-EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, 1)
-""" The user clicked with the middle mouse button on a tab. """
-EVT_AUINOTEBOOK_TAB_MIDDLE_UP = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, 1)
-""" The user clicked with the middle mouse button on a tab. """
-EVT_AUINOTEBOOK_TAB_RIGHT_DOWN = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, 1)
-""" The user clicked with the right mouse button on a tab. """
-EVT_AUINOTEBOOK_TAB_RIGHT_UP = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, 1)
-""" The user clicked with the right mouse button on a tab. """
-EVT_AUINOTEBOOK_BG_MIDDLE_DOWN = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BG_MIDDLE_DOWN, 1)
-""" The user middle-clicked in the tab area but not over a tab or a button. """
-EVT_AUINOTEBOOK_BG_MIDDLE_UP = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BG_MIDDLE_UP, 1)
-""" The user middle-clicked in the tab area but not over a tab or a button. """
-EVT_AUINOTEBOOK_BG_RIGHT_DOWN = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BG_RIGHT_DOWN, 1)
-""" The user right-clicked in the tab area but not over a tab or a button. """
-EVT_AUINOTEBOOK_BG_RIGHT_UP = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BG_RIGHT_UP, 1)
-""" The user right-clicked in the tab area but not over a tab or a button. """
-EVT_AUINOTEBOOK_BG_DCLICK = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, 1)
-""" The user left-clicked on the tab area not occupied by `AuiNotebook` tabs. """
-EVT_AUINOTEBOOK_CANCEL_DRAG = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, 1)
-""" A drag and drop operation has been cancelled. """
-EVT_AUINOTEBOOK_TAB_DCLICK = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_TAB_DCLICK, 1)
-""" The user double-clicked with the left mouse button on a tab. """
-EVT_AUINOTEBOOK_BEGIN_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_LABEL_EDIT, 1)
-""" The user double-clicked with the left mouse button on a tab which text is editable. """
-EVT_AUINOTEBOOK_END_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_AUINOTEBOOK_END_LABEL_EDIT, 1)
-""" The user finished editing a tab label. """
-
-
-# -----------------------------------------------------------------------------
-# Auxiliary class: TabTextCtrl
-# This is the temporary ExpandoTextCtrl created when you edit the text of a tab
-# -----------------------------------------------------------------------------
-
-class TabTextCtrl(ExpandoTextCtrl):
- """ Control used for in-place edit. """
-
- def __init__(self, owner, tab, page_index):
- """
- Default class constructor.
- For internal use: do not call it in your code!
-
- :param `owner`: the L{AuiTabCtrl} owning the tab;
- :param `tab`: the actual L{AuiNotebookPage} tab;
- :param `page_index`: the L{AuiNotebook} page index for the tab.
- """
-
- self._owner = owner
- self._tabEdited = tab
- self._pageIndex = page_index
- self._startValue = tab.caption
- self._finished = False
- self._aboutToFinish = False
- self._currentValue = self._startValue
-
- x, y, w, h = self._tabEdited.rect
-
- wnd = self._tabEdited.control
- if wnd:
- x += wnd.GetSize()[0] + 2
- h = 0
-
- image_h = 0
- image_w = 0
-
- image = tab.bitmap
-
- if image.IsOk():
- image_w, image_h = image.GetWidth(), image.GetHeight()
- image_w += 6
-
- dc = wx.ClientDC(self._owner)
- h = max(image_h, dc.GetMultiLineTextExtent(tab.caption)[1])
- h = h + 2
-
- # FIXME: what are all these hardcoded 4, 8 and 11s really?
- x += image_w
- w -= image_w + 4
-
- y = (self._tabEdited.rect.height - h)/2 + 1
-
- expandoStyle = wx.WANTS_CHARS
- if wx.Platform in ["__WXGTK__", "__WXMAC__"]:
- expandoStyle |= wx.SIMPLE_BORDER
- xSize, ySize = w + 2, h
- else:
- expandoStyle |= wx.SUNKEN_BORDER
- xSize, ySize = w + 2, h+2
-
- ExpandoTextCtrl.__init__(self, self._owner, wx.ID_ANY, self._startValue,
- wx.Point(x, y), wx.Size(xSize, ySize),
- expandoStyle)
-
- if wx.Platform == "__WXMAC__":
- self.SetFont(owner.GetFont())
- bs = self.GetBestSize()
- self.SetSize((-1, bs.height))
-
- self.Bind(wx.EVT_CHAR, self.OnChar)
- self.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
- self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
-
-
- def AcceptChanges(self):
- """ Accepts/refuses the changes made by the user. """
-
- value = self.GetValue()
- notebook = self._owner.GetParent()
-
- if value == self._startValue:
- # nothing changed, always accept
- # when an item remains unchanged, the owner
- # needs to be notified that the user decided
- # not to change the tree item label, and that
- # the edit has been cancelled
- notebook.OnRenameCancelled(self._pageIndex)
- return True
-
- if not notebook.OnRenameAccept(self._pageIndex, value):
- # vetoed by the user
- return False
-
- # accepted, do rename the item
- notebook.SetPageText(self._pageIndex, value)
-
- return True
-
-
- def Finish(self):
- """ Finish editing. """
-
- if not self._finished:
-
- notebook = self._owner.GetParent()
-
- self._finished = True
- self._owner.SetFocus()
- notebook.ResetTextControl()
-
-
- def OnChar(self, event):
- """
- Handles the ``wx.EVT_CHAR`` event for L{TabTextCtrl}.
-
- :param `event`: a `wx.KeyEvent` event to be processed.
- """
-
- keycode = event.GetKeyCode()
- shiftDown = event.ShiftDown()
-
- if keycode == wx.WXK_RETURN:
- if shiftDown and self._tabEdited.IsMultiline():
- event.Skip()
- else:
- self._aboutToFinish = True
- self.SetValue(self._currentValue)
- # Notify the owner about the changes
- self.AcceptChanges()
- # Even if vetoed, close the control (consistent with MSW)
- wx.CallAfter(self.Finish)
-
- elif keycode == wx.WXK_ESCAPE:
- self.StopEditing()
-
- else:
- event.Skip()
-
-
- def OnKeyUp(self, event):
- """
- Handles the ``wx.EVT_KEY_UP`` event for L{TabTextCtrl}.
-
- :param `event`: a `wx.KeyEvent` event to be processed.
- """
-
- if not self._finished:
-
- # auto-grow the textctrl:
- mySize = self.GetSize()
-
- dc = wx.ClientDC(self)
- sx, sy, dummy = dc.GetMultiLineTextExtent(self.GetValue() + "M")
-
- self.SetSize((sx, -1))
- self._currentValue = self.GetValue()
-
- event.Skip()
-
-
- def OnKillFocus(self, event):
- """
- Handles the ``wx.EVT_KILL_FOCUS`` event for L{TabTextCtrl}.
-
- :param `event`: a `wx.FocusEvent` event to be processed.
- """
-
- if not self._finished and not self._aboutToFinish:
-
- # We must finish regardless of success, otherwise we'll get
- # focus problems:
- if not self.AcceptChanges():
- self._owner.GetParent().OnRenameCancelled(self._pageIndex)
-
- # We must let the native text control handle focus, too, otherwise
- # it could have problems with the cursor (e.g., in wxGTK).
- event.Skip()
- wx.CallAfter(self._owner.GetParent().ResetTextControl)
-
-
- def StopEditing(self):
- """ Suddenly stops the editing. """
-
- self._owner.GetParent().OnRenameCancelled(self._pageIndex)
- self.Finish()
-
-
- def item(self):
- """ Returns the item currently edited. """
-
- return self._tabEdited
-
-
-# ----------------------------------------------------------------------
-
-class AuiNotebookPage(object):
- """
- A simple class which holds information about tab captions, bitmaps and
- colours.
- """
-
- def __init__(self):
- """
- Default class constructor.
- Used internally, do not call it in your code!
- """
-
- self.window = None # page's associated window
- self.caption = "" # caption displayed on the tab
- self.bitmap = wx.NullBitmap # tab's bitmap
- self.dis_bitmap = wx.NullBitmap # tab's disabled bitmap
- self.rect = wx.Rect() # tab's hit rectangle
- self.active = False # True if the page is currently active
- self.enabled = True # True if the page is currently enabled
- self.hasCloseButton = True # True if the page has a close button using the style
- # AUI_NB_CLOSE_ON_ALL_TABS
- self.control = None # A control can now be inside a tab
- self.renamable = False # If True, a tab can be renamed by a left double-click
-
- self.text_colour = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNTEXT)
-
- self.access_time = datetime.datetime.now() # Last time this page was selected
-
-
- def IsMultiline(self):
- """ Returns whether the tab contains multiline text. """
-
- return "\n" in self.caption
-
-
-# ----------------------------------------------------------------------
-
-class AuiTabContainerButton(object):
- """
- A simple class which holds information about tab buttons and their state.
- """
-
- def __init__(self):
- """
- Default class constructor.
- Used internally, do not call it in your code!
- """
-
- self.id = -1 # button's id
- self.cur_state = AUI_BUTTON_STATE_NORMAL # current state (normal, hover, pressed, etc.)
- self.location = wx.LEFT # buttons location (wxLEFT, wxRIGHT, or wxCENTER)
- self.bitmap = wx.NullBitmap # button's hover bitmap
- self.dis_bitmap = wx.NullBitmap # button's disabled bitmap
- self.rect = wx.Rect() # button's hit rectangle
-
-
-# ----------------------------------------------------------------------
-
-class CommandNotebookEvent(wx.PyCommandEvent):
- """ A specialized command event class for events sent by L{AuiNotebook} . """
-
- def __init__(self, command_type=None, win_id=0):
- """
- Default class constructor.
-
- :param `command_type`: the event kind or an instance of `wx.PyCommandEvent`.
- :param `win_id`: the window identification number.
- """
-
- if type(command_type) == types.IntType:
- wx.PyCommandEvent.__init__(self, command_type, win_id)
- else:
- wx.PyCommandEvent.__init__(self, command_type.GetEventType(), command_type.GetId())
-
- self.old_selection = -1
- self.selection = -1
- self.drag_source = None
- self.dispatched = 0
- self.label = ""
- self.editCancelled = False
-
-
- def SetSelection(self, s):
- """
- Sets the selection member variable.
-
- :param `s`: the new selection.
- """
-
- self.selection = s
- self._commandInt = s
-
-
- def GetSelection(self):
- """ Returns the currently selected page, or -1 if none was selected. """
-
- return self.selection
-
-
- def SetOldSelection(self, s):
- """
- Sets the id of the page selected before the change.
-
- :param `s`: the old selection.
- """
-
- self.old_selection = s
-
-
- def GetOldSelection(self):
- """
- Returns the page that was selected before the change, or -1 if none was
- selected.
- """
-
- return self.old_selection
-
-
- def SetDragSource(self, s):
- """
- Sets the drag and drop source.
-
- :param `s`: the drag source.
- """
-
- self.drag_source = s
-
-
- def GetDragSource(self):
- """ Returns the drag and drop source. """
-
- return self.drag_source
-
-
- def SetDispatched(self, b):
- """
- Sets the event as dispatched (used for automatic L{AuiNotebook} ).
-
- :param `b`: whether the event was dispatched or not.
- """
-
- self.dispatched = b
-
-
- def GetDispatched(self):
- """ Returns whether the event was dispatched (used for automatic L{AuiNotebook} ). """
-
- return self.dispatched
-
-
- def IsEditCancelled(self):
- """ Returns the edit cancel flag (for ``EVT_AUINOTEBOOK_BEGIN`` | ``END_LABEL_EDIT`` only)."""
-
- return self.editCancelled
-
-
- def SetEditCanceled(self, editCancelled):
- """
- Sets the edit cancel flag (for ``EVT_AUINOTEBOOK_BEGIN`` | ``END_LABEL_EDIT`` only).
-
- :param `editCancelled`: whether the editing action has been cancelled or not.
- """
-
- self.editCancelled = editCancelled
-
-
- def GetLabel(self):
- """Returns the label-itemtext (for ``EVT_AUINOTEBOOK_BEGIN`` | ``END_LABEL_EDIT`` only)."""
-
- return self.label
-
-
- def SetLabel(self, label):
- """
- Sets the label. Useful only for ``EVT_AUINOTEBOOK_END_LABEL_EDIT``.
-
- :param `label`: the new label.
- """
-
- self.label = label
-
-
-# ----------------------------------------------------------------------
-
-class AuiNotebookEvent(CommandNotebookEvent):
- """ A specialized command event class for events sent by L{AuiNotebook}. """
-
- def __init__(self, command_type=None, win_id=0):
- """
- Default class constructor.
-
- :param `command_type`: the event kind or an instance of `wx.PyCommandEvent`.
- :param `win_id`: the window identification number.
- """
-
- CommandNotebookEvent.__init__(self, command_type, win_id)
-
- if type(command_type) == types.IntType:
- self.notify = wx.NotifyEvent(command_type, win_id)
- else:
- self.notify = wx.NotifyEvent(command_type.GetEventType(), command_type.GetId())
-
-
- def GetNotifyEvent(self):
- """ Returns the actual `wx.NotifyEvent`. """
-
- return self.notify
-
-
- def IsAllowed(self):
- """ Returns whether the event is allowed or not. """
-
- return self.notify.IsAllowed()
-
-
- def Veto(self):
- """
- Prevents the change announced by this event from happening.
-
- It is in general a good idea to notify the user about the reasons for
- vetoing the change because otherwise the applications behaviour (which
- just refuses to do what the user wants) might be quite surprising.
- """
-
- self.notify.Veto()
-
-
- def Allow(self):
- """
- This is the opposite of L{Veto}: it explicitly allows the event to be
- processed. For most events it is not necessary to call this method as the
- events are allowed anyhow but some are forbidden by default (this will
- be mentioned in the corresponding event description).
- """
-
- self.notify.Allow()
-
-
-# ---------------------------------------------------------------------------- #
-# Class TabNavigatorWindow
-# ---------------------------------------------------------------------------- #
-
-class TabNavigatorWindow(wx.Dialog):
- """
- This class is used to create a modal dialog that enables "Smart Tabbing",
- similar to what you would get by hitting ``Alt`` + ``Tab`` on Windows.
- """
-
- def __init__(self, parent=None, icon=None):
- """
- Default class constructor. Used internally.
-
- :param `parent`: the L{TabNavigatorWindow} parent;
- :param `icon`: the L{TabNavigatorWindow} icon.
- """
-
- wx.Dialog.__init__(self, parent, wx.ID_ANY, "", style=0)
-
- self._selectedItem = -1
- self._indexMap = []
-
- if icon is None:
- self._bmp = Mondrian.GetBitmap()
- else:
- self._bmp = icon
-
- if self._bmp.GetSize() != (16, 16):
- img = self._bmp.ConvertToImage()
- img.Rescale(16, 16, wx.IMAGE_QUALITY_HIGH)
- self._bmp = wx.BitmapFromImage(img)
-
- sz = wx.BoxSizer(wx.VERTICAL)
-
- self._listBox = wx.ListBox(self, wx.ID_ANY, wx.DefaultPosition, wx.Size(200, 150), [], wx.LB_SINGLE | wx.NO_BORDER)
-
- mem_dc = wx.MemoryDC()
- mem_dc.SelectObject(wx.EmptyBitmap(1,1))
- font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
- font.SetWeight(wx.BOLD)
- mem_dc.SetFont(font)
-
- panelHeight = mem_dc.GetCharHeight()
- panelHeight += 4 # Place a spacer of 2 pixels
-
- # Out signpost bitmap is 24 pixels
- if panelHeight < 24:
- panelHeight = 24
-
- self._panel = wx.Panel(self, wx.ID_ANY, wx.DefaultPosition, wx.Size(200, panelHeight))
-
- sz.Add(self._panel)
- sz.Add(self._listBox, 1, wx.EXPAND)
-
- self.SetSizer(sz)
-
- # Connect events to the list box
- self._listBox.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
- self._listBox.Bind(wx.EVT_NAVIGATION_KEY, self.OnNavigationKey)
- self._listBox.Bind(wx.EVT_LISTBOX_DCLICK, self.OnItemSelected)
-
- # Connect paint event to the panel
- self._panel.Bind(wx.EVT_PAINT, self.OnPanelPaint)
- self._panel.Bind(wx.EVT_ERASE_BACKGROUND, self.OnPanelEraseBg)
-
- self.SetBackgroundColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))
- self._listBox.SetBackgroundColour(wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DFACE))
- self.PopulateListControl(parent)
-
- self.GetSizer().Fit(self)
- self.GetSizer().SetSizeHints(self)
- self.GetSizer().Layout()
- self.Centre()
-
- # Set focus on the list box to avoid having to click on it to change
- # the tab selection under GTK.
- self._listBox.SetFocus()
-
-
- def OnKeyUp(self, event):
- """
- Handles the ``wx.EVT_KEY_UP`` for the L{TabNavigatorWindow}.
-
- :param `event`: a `wx.KeyEvent` event to be processed.
- """
-
- if event.GetKeyCode() == wx.WXK_CONTROL:
- self.CloseDialog()
-
-
- def OnNavigationKey(self, event):
- """
- Handles the ``wx.EVT_NAVIGATION_KEY`` for the L{TabNavigatorWindow}.
-
- :param `event`: a `wx.NavigationKeyEvent` event to be processed.
- """
-
- selected = self._listBox.GetSelection()
- bk = self.GetParent()
- maxItems = bk.GetPageCount()
-
- if event.GetDirection():
-
- # Select next page
- if selected == maxItems - 1:
- itemToSelect = 0
- else:
- itemToSelect = selected + 1
-
- else:
-
- # Previous page
- if selected == 0:
- itemToSelect = maxItems - 1
- else:
- itemToSelect = selected - 1
-
- self._listBox.SetSelection(itemToSelect)
-
-
- def PopulateListControl(self, book):
- """
- Populates the L{TabNavigatorWindow} listbox with a list of tabs.
-
- :param `book`: the actual L{AuiNotebook}.
- """
- # Index of currently selected page
- selection = book.GetSelection()
- # Total number of pages
- count = book.GetPageCount()
- # List of (index, AuiNotebookPage)
- pages = list(enumerate(book.GetTabContainer().GetPages()))
- if book.GetAGWWindowStyleFlag() & AUI_NB_ORDER_BY_ACCESS:
- # Sort pages using last access time. Most recently used is the
- # first in line
- pages.sort(
- key = lambda element: element[1].access_time,
- reverse = True
- )
- else:
- # Manually add the current selection as first item
- # Remaining ones are added in the next loop
- del pages[selection]
- self._listBox.Append(book.GetPageText(selection))
- self._indexMap.append(selection)
-
- for (index, page) in pages:
- self._listBox.Append(book.GetPageText(index))
- self._indexMap.append(index)
-
- # Select the next entry after the current selection
- self._listBox.SetSelection(0)
- dummy = wx.NavigationKeyEvent()
- dummy.SetDirection(True)
- self.OnNavigationKey(dummy)
-
-
- def OnItemSelected(self, event):
- """
- Handles the ``wx.EVT_LISTBOX_DCLICK`` event for the wx.ListBox inside L{TabNavigatorWindow}.
-
- :param `event`: a `wx.ListEvent` event to be processed.
- """
-
- self.CloseDialog()
-
-
- def CloseDialog(self):
- """ Closes the L{TabNavigatorWindow} dialog, setting selection in L{AuiNotebook}. """
-
- bk = self.GetParent()
- self._selectedItem = self._listBox.GetSelection()
- self.EndModal(wx.ID_OK)
-
-
- def GetSelectedPage(self):
- """ Gets the page index that was selected when the dialog was closed. """
-
- return self._indexMap[self._selectedItem]
-
-
- def OnPanelPaint(self, event):
- """
- Handles the ``wx.EVT_PAINT`` event for L{TabNavigatorWindow} top panel.
-
- :param `event`: a `wx.PaintEvent` event to be processed.
- """
-
- dc = wx.PaintDC(self._panel)
- rect = self._panel.GetClientRect()
-
- bmp = wx.EmptyBitmap(rect.width, rect.height)
-
- mem_dc = wx.MemoryDC()
- mem_dc.SelectObject(bmp)
-
- endColour = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNSHADOW)
- startColour = LightColour(endColour, 50)
- mem_dc.GradientFillLinear(rect, startColour, endColour, wx.SOUTH)
-
- # Draw the caption title and place the bitmap
- # get the bitmap optimal position, and draw it
- bmpPt, txtPt = wx.Point(), wx.Point()
- bmpPt.y = (rect.height - self._bmp.GetHeight())/2
- bmpPt.x = 3
- mem_dc.DrawBitmap(self._bmp, bmpPt.x, bmpPt.y, True)
-
- # get the text position, and draw it
- font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
- font.SetWeight(wx.BOLD)
- mem_dc.SetFont(font)
- fontHeight = mem_dc.GetCharHeight()
-
- txtPt.x = bmpPt.x + self._bmp.GetWidth() + 4
- txtPt.y = (rect.height - fontHeight)/2
- mem_dc.SetTextForeground(wx.WHITE)
- mem_dc.DrawText("Opened tabs:", txtPt.x, txtPt.y)
- mem_dc.SelectObject(wx.NullBitmap)
-
- dc.DrawBitmap(bmp, 0, 0)
-
-
- def OnPanelEraseBg(self, event):
- """
- Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{TabNavigatorWindow} top panel.
-
- :param `event`: a `wx.EraseEvent` event to be processed.
-
- :note: This is intentionally empty, to reduce flicker.
- """
-
- pass
-
-
-# ----------------------------------------------------------------------
-# -- AuiTabContainer class implementation --
-
-class AuiTabContainer(object):
- """
- AuiTabContainer is a class which contains information about each
- tab. It also can render an entire tab control to a specified DC.
- It's not a window class itself, because this code will be used by
- the L{AuiManager}, where it is disadvantageous to have separate
- windows for each tab control in the case of "docked tabs".
-
- A derived class, L{AuiTabCtrl}, is an actual `wx.Window`-derived window
- which can be used as a tab control in the normal sense.
- """
-
- def __init__(self, auiNotebook):
- """
- Default class constructor.
- Used internally, do not call it in your code!
-
- :param `auiNotebook`: the parent L{AuiNotebook} window.
- """
-
- self._tab_offset = 0
- self._agwFlags = 0
- self._art = TA.AuiDefaultTabArt()
-
- self._buttons = []
- self._pages = []
- self._tab_close_buttons = []
-
- self._rect = wx.Rect()
- self._auiNotebook = auiNotebook
-
- self.AddButton(AUI_BUTTON_LEFT, wx.LEFT)
- self.AddButton(AUI_BUTTON_RIGHT, wx.RIGHT)
- self.AddButton(AUI_BUTTON_WINDOWLIST, wx.RIGHT)
- self.AddButton(AUI_BUTTON_CLOSE, wx.RIGHT)
-
-
- def SetArtProvider(self, art):
- """
- Instructs L{AuiTabContainer} to use art provider specified by parameter `art`
- for all drawing calls. This allows plugable look-and-feel features.
-
- :param `art`: an art provider.
-
- :note: The previous art provider object, if any, will be deleted by L{AuiTabContainer}.
- """
-
- del self._art
- self._art = art
-
- if self._art:
- self._art.SetAGWFlags(self._agwFlags)
-
-
- def GetArtProvider(self):
- """ Returns the current art provider being used. """
-
- return self._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
- ==================================== ==================================
-
- :todo: Implementation of flags ``AUI_NB_RIGHT`` and ``AUI_NB_LEFT``.
-
- """
-
- self._agwFlags = agwFlags
-
- # check for new close button settings
- self.RemoveButton(AUI_BUTTON_LEFT)
- self.RemoveButton(AUI_BUTTON_RIGHT)
- self.RemoveButton(AUI_BUTTON_WINDOWLIST)
- self.RemoveButton(AUI_BUTTON_CLOSE)
-
- if agwFlags & AUI_NB_SCROLL_BUTTONS:
- self.AddButton(AUI_BUTTON_LEFT, wx.LEFT)
- self.AddButton(AUI_BUTTON_RIGHT, wx.RIGHT)
-
- if agwFlags & AUI_NB_WINDOWLIST_BUTTON:
- self.AddButton(AUI_BUTTON_WINDOWLIST, wx.RIGHT)
-
- if agwFlags & AUI_NB_CLOSE_BUTTON:
- self.AddButton(AUI_BUTTON_CLOSE, wx.RIGHT)
-
- if self._art:
- self._art.SetAGWFlags(self._agwFlags)
-
-
- def GetAGWFlags(self):
- """
- Returns the tab art flags.
-
- See L{SetAGWFlags} for a list of possible return values.
-
- :see: L{SetAGWFlags}
- """
-
- return self._agwFlags
-
-
- def SetNormalFont(self, font):
- """
- Sets the normal font for drawing tab labels.
-
- :param `font`: a `wx.Font` object.
- """
-
- self._art.SetNormalFont(font)
-
-
- def SetSelectedFont(self, font):
- """
- Sets the selected tab font for drawing tab labels.
-
- :param `font`: a `wx.Font` object.
- """
-
- self._art.SetSelectedFont(font)
-
-
- def SetMeasuringFont(self, font):
- """
- Sets the font for calculating text measurements.
-
- :param `font`: a `wx.Font` object.
- """
-
- self._art.SetMeasuringFont(font)
-
-
- def SetTabRect(self, rect):
- """
- Sets the tab area rectangle.
-
- :param `rect`: an instance of `wx.Rect`, specifying the available area for L{AuiTabContainer}.
- """
-
- self._rect = rect
-
- if self._art:
- minMaxTabWidth = self._auiNotebook.GetMinMaxTabWidth()
- self._art.SetSizingInfo(rect.GetSize(), len(self._pages), minMaxTabWidth)
-
-
- def AddPage(self, page, info):
- """
- Adds a page to the tab control.
-
- :param `page`: the window associated with this tab;
- :param `info`: an instance of L{AuiNotebookPage}.
- """
-
- page_info = info
- page_info.window = page
-
- self._pages.append(page_info)
-
- # let the art provider know how many pages we have
- if self._art:
- minMaxTabWidth = self._auiNotebook.GetMinMaxTabWidth()
- self._art.SetSizingInfo(self._rect.GetSize(), len(self._pages), minMaxTabWidth)
-
- return True
-
-
- def InsertPage(self, page, info, idx):
- """
- Inserts a page in the tab control in the position specified by `idx`.
-
- :param `page`: the window associated with this tab;
- :param `info`: an instance of L{AuiNotebookPage};
- :param `idx`: the page insertion index.
- """
-
- page_info = info
- page_info.window = page
-
- if idx >= len(self._pages):
- self._pages.append(page_info)
- else:
- self._pages.insert(idx, page_info)
-
- # let the art provider know how many pages we have
- if self._art:
- minMaxTabWidth = self._auiNotebook.GetMinMaxTabWidth()
- self._art.SetSizingInfo(self._rect.GetSize(), len(self._pages), minMaxTabWidth)
-
- return True
-
-
- def MovePage(self, page, new_idx):
- """
- Moves a page in a new position specified by `new_idx`.
-
- :param `page`: the window associated with this tab;
- :param `new_idx`: the new page position.
- """
-
- idx = self.GetIdxFromWindow(page)
- if idx == -1:
- return False
-
- # get page entry, make a copy of it
- p = self.GetPage(idx)
-
- # remove old page entry
- self.RemovePage(page)
-
- # insert page where it should be
- self.InsertPage(page, p, new_idx)
-
- return True
-
-
- def RemovePage(self, wnd):
- """
- Removes a page from the tab control.
-
- :param `wnd`: an instance of `wx.Window`, a window associated with this tab.
- """
-
- minMaxTabWidth = self._auiNotebook.GetMinMaxTabWidth()
-
- for page in self._pages:
- if page.window == wnd:
- self._pages.remove(page)
- self._tab_offset = min(self._tab_offset, len(self._pages) - 1)
-
- # let the art provider know how many pages we have
- if self._art:
- self._art.SetSizingInfo(self._rect.GetSize(), len(self._pages), minMaxTabWidth)
-
- return True
-
- return False
-
-
- def SetActivePage(self, wndOrInt):
- """
- Sets the L{AuiTabContainer} active page.
-
- :param `wndOrInt`: an instance of `wx.Window` or an integer specifying a tab index.
- """
-
- if type(wndOrInt) == types.IntType:
-
- if wndOrInt >= len(self._pages):
- return False
-
- wnd = self._pages[wndOrInt].window
-
- else:
- wnd = wndOrInt
-
- found = False
-
- for indx, page in enumerate(self._pages):
- if page.window == wnd:
- page.active = True
- found = True
- else:
- page.active = False
-
- return found
-
-
- def SetNoneActive(self):
- """ Sets all the tabs as inactive (non-selected). """
-
- for page in self._pages:
- page.active = False
-
-
- def GetActivePage(self):
- """ Returns the current selected tab or ``wx.NOT_FOUND`` if none is selected. """
-
- for indx, page in enumerate(self._pages):
- if page.active:
- return indx
-
- return wx.NOT_FOUND
-
-
- def GetWindowFromIdx(self, idx):
- """
- Returns the window associated with the tab with index `idx`.
-
- :param `idx`: the tab index.
- """
-
- if idx >= len(self._pages):
- return None
-
- return self._pages[idx].window
-
-
- def GetIdxFromWindow(self, wnd):
- """
- Returns the tab index based on the window `wnd` associated with it.
-
- :param `wnd`: an instance of `wx.Window`.
- """
-
- for indx, page in enumerate(self._pages):
- if page.window == wnd:
- return indx
-
- return wx.NOT_FOUND
-
-
- def GetPage(self, idx):
- """
- Returns the page specified by the given index.
-
- :param `idx`: the tab index.
- """
-
- if idx < 0 or idx >= len(self._pages):
- raise Exception("Invalid Page index")
-
- return self._pages[idx]
-
-
- def GetPages(self):
- """ Returns a list of all the pages in this L{AuiTabContainer}. """
-
- return self._pages
-
-
- def GetPageCount(self):
- """ Returns the number of pages in the L{AuiTabContainer}. """
-
- return len(self._pages)
-
-
- def GetEnabled(self, idx):
- """
- Returns whether a tab is enabled or not.
-
- :param `idx`: the tab index.
- """
-
- if idx < 0 or idx >= len(self._pages):
- return False
-
- return self._pages[idx].enabled
-
-
- def EnableTab(self, idx, enable=True):
- """
- Enables/disables a tab in the L{AuiTabContainer}.
-
- :param `idx`: the tab index;
- :param `enable`: ``True`` to enable a tab, ``False`` to disable it.
- """
-
- if idx < 0 or idx >= len(self._pages):
- raise Exception("Invalid Page index")
-
- self._pages[idx].enabled = enable
- wnd = self.GetWindowFromIdx(idx)
- wnd.Enable(enable)
-
-
- def AddButton(self, id, location, normal_bitmap=wx.NullBitmap, disabled_bitmap=wx.NullBitmap):
- """
- Adds a button in the tab area.
-
- :param `id`: the button identifier. This can be one of the following:
-
- ============================== =================================
- Button Identifier Description
- ============================== =================================
- ``AUI_BUTTON_CLOSE`` Shows a close button on the tab area
- ``AUI_BUTTON_WINDOWLIST`` Shows a window list button on the tab area
- ``AUI_BUTTON_LEFT`` Shows a left button on the tab area
- ``AUI_BUTTON_RIGHT`` Shows a right button on the tab area
- ============================== =================================
-
- :param `location`: the button location. Can be ``wx.LEFT`` or ``wx.RIGHT``;
- :param `normal_bitmap`: the bitmap for an enabled tab;
- :param `disabled_bitmap`: the bitmap for a disabled tab.
- """
-
- button = AuiTabContainerButton()
- button.id = id
- button.bitmap = normal_bitmap
- button.dis_bitmap = disabled_bitmap
- button.location = location
- button.cur_state = AUI_BUTTON_STATE_NORMAL
-
- self._buttons.append(button)
-
-
- def RemoveButton(self, id):
- """
- Removes a button from the tab area.
-
- :param `id`: the button identifier. See L{AddButton} for a list of button identifiers.
-
- :see: L{AddButton}
- """
-
- for button in self._buttons:
- if button.id == id:
- self._buttons.remove(button)
- return
-
-
- def GetTabOffset(self):
- """ Returns the tab offset. """
-
- return self._tab_offset
-
-
- def SetTabOffset(self, offset):
- """
- Sets the tab offset.
-
- :param `offset`: the tab offset.
- """
-
- self._tab_offset = offset
-
-
- def MinimizeTabOffset(self, dc, wnd, max_width):
- """
- Minimize `self._tab_offset` to fit as many tabs as possible in the available space.
-
- :param `dc`: a `wx.DC` device context;
- :param `wnd`: an instance of `wx.Window`;
- :param `max_width`: the maximum available width for the tabs.
- """
-
- total_width = 0
-
- for i, page in reversed(list(enumerate(self._pages))):
-
- tab_button = self._tab_close_buttons[i]
- (tab_width, tab_height), x_extent = self._art.GetTabSize(dc, wnd, page.caption, page.bitmap, page.active, tab_button.cur_state, page.control)
- total_width += tab_width
-
- if total_width > max_width:
-
- tab_offset = i + 1
-
- if tab_offset < self._tab_offset and tab_offset < len(self._pages):
- self._tab_offset = tab_offset
-
- break
-
- if i == 0:
- self._tab_offset = 0
-
-
- def Render(self, raw_dc, wnd):
- """
- Renders the tab catalog to the specified `wx.DC`.
-
- It is a virtual function and can be overridden to provide custom drawing
- capabilities.
-
- :param `raw_dc`: a `wx.DC` device context;
- :param `wnd`: an instance of `wx.Window`.
- """
-
- if not raw_dc or not raw_dc.IsOk():
- return
-
- dc = wx.MemoryDC()
-
- # use the same layout direction as the window DC uses to ensure that the
- # text is rendered correctly
- dc.SetLayoutDirection(raw_dc.GetLayoutDirection())
-
- page_count = len(self._pages)
- button_count = len(self._buttons)
-
- # create off-screen bitmap
- bmp = wx.EmptyBitmap(self._rect.GetWidth(), self._rect.GetHeight())
- dc.SelectObject(bmp)
-
- if not dc.IsOk():
- return
-
- # find out if size of tabs is larger than can be
- # afforded on screen
- total_width = visible_width = 0
-
- for i in xrange(page_count):
- page = self._pages[i]
-
- # determine if a close button is on this tab
- close_button = False
- if (self._agwFlags & AUI_NB_CLOSE_ON_ALL_TABS and page.hasCloseButton) or \
- (self._agwFlags & AUI_NB_CLOSE_ON_ACTIVE_TAB and page.active and page.hasCloseButton):
-
- close_button = True
-
- control = page.control
- if control:
- try:
- control.GetSize()
- except wx.PyDeadObjectError:
- page.control = None
-
- size, x_extent = self._art.GetTabSize(dc, wnd, page.caption, page.bitmap, page.active,
- (close_button and [AUI_BUTTON_STATE_NORMAL] or \
- [AUI_BUTTON_STATE_HIDDEN])[0], page.control)
-
- if i+1 < page_count:
- total_width += x_extent
- else:
- total_width += size[0]
-
- if i >= self._tab_offset:
- if i+1 < page_count:
- visible_width += x_extent
- else:
- visible_width += size[0]
-
- if total_width > self._rect.GetWidth() or self._tab_offset != 0:
-
- # show left/right buttons
- for button in self._buttons:
- if button.id == AUI_BUTTON_LEFT or \
- button.id == AUI_BUTTON_RIGHT:
-
- button.cur_state &= ~AUI_BUTTON_STATE_HIDDEN
-
- else:
-
- # hide left/right buttons
- for button in self._buttons:
- if button.id == AUI_BUTTON_LEFT or \
- button.id == AUI_BUTTON_RIGHT:
-
- button.cur_state |= AUI_BUTTON_STATE_HIDDEN
-
- # determine whether left button should be enabled
- for button in self._buttons:
- if button.id == AUI_BUTTON_LEFT:
- if self._tab_offset == 0:
- button.cur_state |= AUI_BUTTON_STATE_DISABLED
- else:
- button.cur_state &= ~AUI_BUTTON_STATE_DISABLED
-
- if button.id == AUI_BUTTON_RIGHT:
- if visible_width < self._rect.GetWidth() - 16*button_count:
- button.cur_state |= AUI_BUTTON_STATE_DISABLED
- else:
- button.cur_state &= ~AUI_BUTTON_STATE_DISABLED
-
- # draw background
- self._art.DrawBackground(dc, wnd, self._rect)
-
- # draw buttons
- left_buttons_width = 0
- right_buttons_width = 0
-
- # draw the buttons on the right side
- offset = self._rect.x + self._rect.width
-
- for i in xrange(button_count):
- button = self._buttons[button_count - i - 1]
-
- if button.location != wx.RIGHT:
- continue
- if button.cur_state & AUI_BUTTON_STATE_HIDDEN:
- continue
-
- button_rect = wx.Rect(*self._rect)
- button_rect.SetY(1)
- button_rect.SetWidth(offset)
-
- button.rect = self._art.DrawButton(dc, wnd, button_rect, button, wx.RIGHT)
-
- offset -= button.rect.GetWidth()
- right_buttons_width += button.rect.GetWidth()
-
- offset = 0
-
- # draw the buttons on the left side
- for i in xrange(button_count):
- button = self._buttons[button_count - i - 1]
-
- if button.location != wx.LEFT:
- continue
- if button.cur_state & AUI_BUTTON_STATE_HIDDEN:
- continue
-
- button_rect = wx.Rect(offset, 1, 1000, self._rect.height)
-
- button.rect = self._art.DrawButton(dc, wnd, button_rect, button, wx.LEFT)
-
- offset += button.rect.GetWidth()
- left_buttons_width += button.rect.GetWidth()
-
- offset = left_buttons_width
-
- if offset == 0:
- offset += self._art.GetIndentSize()
-
- # prepare the tab-close-button array
- # make sure tab button entries which aren't used are marked as hidden
- for i in xrange(page_count, len(self._tab_close_buttons)):
- self._tab_close_buttons[i].cur_state = AUI_BUTTON_STATE_HIDDEN
-
- # make sure there are enough tab button entries to accommodate all tabs
- while len(self._tab_close_buttons) < page_count:
- tempbtn = AuiTabContainerButton()
- tempbtn.id = AUI_BUTTON_CLOSE
- tempbtn.location = wx.CENTER
- tempbtn.cur_state = AUI_BUTTON_STATE_HIDDEN
- self._tab_close_buttons.append(tempbtn)
-
- # buttons before the tab offset must be set to hidden
- for i in xrange(self._tab_offset):
- self._tab_close_buttons[i].cur_state = AUI_BUTTON_STATE_HIDDEN
- if self._pages[i].control:
- if self._pages[i].control.IsShown():
- self._pages[i].control.Hide()
-
- self.MinimizeTabOffset(dc, wnd, self._rect.GetWidth() - right_buttons_width - offset - 2)
-
- # draw the tabs
- active = 999
- active_offset = 0
-
- rect = wx.Rect(*self._rect)
- rect.y = 0
- rect.height = self._rect.height
-
- for i in xrange(self._tab_offset, page_count):
-
- page = self._pages[i]
- tab_button = self._tab_close_buttons[i]
-
- # determine if a close button is on this tab
- if (self._agwFlags & AUI_NB_CLOSE_ON_ALL_TABS and page.hasCloseButton) or \
- (self._agwFlags & AUI_NB_CLOSE_ON_ACTIVE_TAB and page.active and page.hasCloseButton):
-
- if tab_button.cur_state == AUI_BUTTON_STATE_HIDDEN:
-
- tab_button.id = AUI_BUTTON_CLOSE
- tab_button.cur_state = AUI_BUTTON_STATE_NORMAL
- tab_button.location = wx.CENTER
-
- else:
-
- tab_button.cur_state = AUI_BUTTON_STATE_HIDDEN
-
- rect.x = offset
- rect.width = self._rect.width - right_buttons_width - offset - 2
-
- if rect.width <= 0:
- break
-
- page.rect, tab_button.rect, x_extent = self._art.DrawTab(dc, wnd, page, rect, tab_button.cur_state)
-
- if page.active:
- active = i
- active_offset = offset
- active_rect = wx.Rect(*rect)
-
- offset += x_extent
-
- lenPages = len(self._pages)
- # make sure to deactivate buttons which are off the screen to the right
- for j in xrange(i+1, len(self._tab_close_buttons)):
- self._tab_close_buttons[j].cur_state = AUI_BUTTON_STATE_HIDDEN
- if j > 0 and j <= lenPages:
- if self._pages[j-1].control:
- if self._pages[j-1].control.IsShown():
- self._pages[j-1].control.Hide()
-
- # draw the active tab again so it stands in the foreground
- if active >= self._tab_offset and active < len(self._pages):
-
- page = self._pages[active]
- tab_button = self._tab_close_buttons[active]
-
- rect.x = active_offset
- dummy = self._art.DrawTab(dc, wnd, page, active_rect, tab_button.cur_state)
-
- raw_dc.Blit(self._rect.x, self._rect.y, self._rect.GetWidth(), self._rect.GetHeight(), dc, 0, 0)
-
-
- def IsTabVisible(self, tabPage, tabOffset, dc, wnd):
- """
- Returns whether a tab is visible or not.
-
- :param `tabPage`: the tab index;
- :param `tabOffset`: the tab offset;
- :param `dc`: a `wx.DC` device context;
- :param `wnd`: an instance of `wx.Window` derived window.
- """
-
- if not dc or not dc.IsOk():
- return False
-
- page_count = len(self._pages)
- button_count = len(self._buttons)
- self.Render(dc, wnd)
-
- # Hasn't been rendered yet assume it's visible
- if len(self._tab_close_buttons) < page_count:
- return True
-
- if self._agwFlags & AUI_NB_SCROLL_BUTTONS:
- # First check if both buttons are disabled - if so, there's no need to
- # check further for visibility.
- arrowButtonVisibleCount = 0
- for i in xrange(button_count):
-
- button = self._buttons[i]
- if button.id == AUI_BUTTON_LEFT or \
- button.id == AUI_BUTTON_RIGHT:
-
- if button.cur_state & AUI_BUTTON_STATE_HIDDEN == 0:
- arrowButtonVisibleCount += 1
-
- # Tab must be visible
- if arrowButtonVisibleCount == 0:
- return True
-
- # If tab is less than the given offset, it must be invisible by definition
- if tabPage < tabOffset:
- return False
-
- # draw buttons
- left_buttons_width = 0
- right_buttons_width = 0
-
- offset = 0
-
- # calculate size of the buttons on the right side
- offset = self._rect.x + self._rect.width
-
- for i in xrange(button_count):
- button = self._buttons[button_count - i - 1]
-
- if button.location != wx.RIGHT:
- continue
- if button.cur_state & AUI_BUTTON_STATE_HIDDEN:
- continue
-
- offset -= button.rect.GetWidth()
- right_buttons_width += button.rect.GetWidth()
-
- offset = 0
-
- # calculate size of the buttons on the left side
- for i in xrange(button_count):
- button = self._buttons[button_count - i - 1]
-
- if button.location != wx.LEFT:
- continue
- if button.cur_state & AUI_BUTTON_STATE_HIDDEN:
- continue
-
- offset += button.rect.GetWidth()
- left_buttons_width += button.rect.GetWidth()
-
- offset = left_buttons_width
-
- if offset == 0:
- offset += self._art.GetIndentSize()
-
- rect = wx.Rect(*self._rect)
- rect.y = 0
- rect.height = self._rect.height
-
- # See if the given page is visible at the given tab offset (effectively scroll position)
- for i in xrange(tabOffset, page_count):
-
- page = self._pages[i]
- tab_button = self._tab_close_buttons[i]
-
- rect.x = offset
- rect.width = self._rect.width - right_buttons_width - offset - 2
-
- if rect.width <= 0:
- return False # haven't found the tab, and we've run out of space, so return False
-
- size, x_extent = self._art.GetTabSize(dc, wnd, page.caption, page.bitmap, page.active, tab_button.cur_state, page.control)
- offset += x_extent
-
- if i == tabPage:
-
- # If not all of the tab is visible, and supposing there's space to display it all,
- # we could do better so we return False.
- if (self._rect.width - right_buttons_width - offset - 2) <= 0 and (self._rect.width - right_buttons_width - left_buttons_width) > x_extent:
- return False
- else:
- return True
-
- # Shouldn't really get here, but if it does, assume the tab is visible to prevent
- # further looping in calling code.
- return True
-
-
- def MakeTabVisible(self, tabPage, win):
- """
- Make the tab visible if it wasn't already.
-
- :param `tabPage`: the tab index;
- :param `win`: an instance of `wx.Window` derived window.
- """
-
- dc = wx.ClientDC(win)
-
- if not self.IsTabVisible(tabPage, self.GetTabOffset(), dc, win):
- for i in xrange(len(self._pages)):
- if self.IsTabVisible(tabPage, i, dc, win):
- self.SetTabOffset(i)
- win.Refresh()
- return
-
-
- def TabHitTest(self, x, y):
- """
- TabHitTest() tests if a tab was hit, passing the window pointer
- back if that condition was fulfilled.
-
- :param `x`: the mouse `x` position;
- :param `y`: the mouse `y` position.
- """
-
- if not self._rect.Contains((x,y)):
- return None
-
- btn = self.ButtonHitTest(x, y)
- if btn:
- if btn in self._buttons:
- return None
-
- for i in xrange(self._tab_offset, len(self._pages)):
- page = self._pages[i]
- if page.rect.Contains((x,y)):
- return page.window
-
- return None
-
-
- def ButtonHitTest(self, x, y):
- """
- Tests if a button was hit.
-
- :param `x`: the mouse `x` position;
- :param `y`: the mouse `y` position.
-
- :returns: and instance of L{AuiTabContainerButton} if a button was hit, ``None`` otherwise.
- """
-
- if not self._rect.Contains((x,y)):
- return None
-
- for button in self._buttons:
- if button.rect.Contains((x,y)) and \
- (button.cur_state & (AUI_BUTTON_STATE_HIDDEN|AUI_BUTTON_STATE_DISABLED)) == 0:
- return button
-
- for button in self._tab_close_buttons:
- if button.rect.Contains((x,y)) and \
- (button.cur_state & (AUI_BUTTON_STATE_HIDDEN|AUI_BUTTON_STATE_DISABLED)) == 0:
- return button
-
- return None
-
-
- def DoShowHide(self):
- """
- This function shows the active window, then hides all of the other windows
- (in that order).
- """
-
- pages = self.GetPages()
-
- # show new active page first
- for page in pages:
- if page.active:
- page.window.Show(True)
- break
-
- # hide all other pages
- for page in pages:
- if not page.active:
- page.window.Show(False)
-
-
-# ----------------------------------------------------------------------
-# -- AuiTabCtrl class implementation --
-
-class AuiTabCtrl(wx.PyControl, AuiTabContainer):
- """
- This is an actual `wx.Window`-derived window which can be used as a tab
- control in the normal sense.
- """
-
- def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize,
- style=wx.NO_BORDER|wx.WANTS_CHARS|wx.TAB_TRAVERSAL):
- """
- Default class constructor.
- Used internally, do not call it in your code!
-
- :param `parent`: the L{AuiTabCtrl} parent;
- :param `id`: an identifier for the control: a value of -1 is taken to mean a default;
- :param `pos`: the control position. A value of (-1, -1) indicates a default position,
- chosen by either the windowing system or wxPython, depending on platform;
- :param `size`: the control size. A value of (-1, -1) indicates a default size,
- chosen by either the windowing system or wxPython, depending on platform;
- :param `style`: the window style.
- """
-
- wx.PyControl.__init__(self, parent, id, pos, size, style, name="AuiTabCtrl")
- AuiTabContainer.__init__(self, parent)
-
- self._click_pt = wx.Point(-1, -1)
- self._is_dragging = False
- self._hover_button = None
- self._pressed_button = None
- self._drag_image = None
- self._drag_img_offset = (0, 0)
- self._on_button = False
-
- self.Bind(wx.EVT_PAINT, self.OnPaint)
- self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
- self.Bind(wx.EVT_SIZE, self.OnSize)
- self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
- self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDClick)
- self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
- self.Bind(wx.EVT_MIDDLE_DOWN, self.OnMiddleDown)
- self.Bind(wx.EVT_MIDDLE_UP, self.OnMiddleUp)
- self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
- self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
- self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
- self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
- self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
- self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, self.OnCaptureLost)
- self.Bind(wx.EVT_MOTION, self.OnMotion)
- self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow)
- self.Bind(EVT_AUINOTEBOOK_BUTTON, self.OnButton)
-
-
- def IsDragging(self):
- """ Returns whether the user is dragging a tab with the mouse or not. """
-
- return self._is_dragging
-
-
- def GetDefaultBorder(self):
- """ Returns the default border style for L{AuiTabCtrl}. """
-
- return wx.BORDER_NONE
-
-
- def OnPaint(self, event):
- """
- Handles the ``wx.EVT_PAINT`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.PaintEvent` event to be processed.
- """
-
- dc = wx.PaintDC(self)
- dc.SetFont(self.GetFont())
-
- if self.GetPageCount() > 0:
- self.Render(dc, self)
-
-
- def OnEraseBackground(self, event):
- """
- Handles the ``wx.EVT_ERASE_BACKGROUND`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.EraseEvent` event to be processed.
-
- :note: This is intentionally empty, to reduce flicker.
- """
-
- pass
-
-
- def DoGetBestSize(self):
- """
- Gets the size which best suits the window: for a control, it would be the
- minimal size which doesn't truncate the control, for a panel - the same
- size as it would have after a call to `Fit()`.
-
- :note: Overridden from `wx.PyControl`.
- """
-
- return wx.Size(self._rect.width, self._rect.height)
-
-
- def OnSize(self, event):
- """
- Handles the ``wx.EVT_SIZE`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.SizeEvent` event to be processed.
- """
-
- s = event.GetSize()
- self.SetTabRect(wx.Rect(0, 0, s.GetWidth(), s.GetHeight()))
-
-
- def OnLeftDown(self, event):
- """
- Handles the ``wx.EVT_LEFT_DOWN`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- self.CaptureMouse()
- self._click_pt = wx.Point(-1, -1)
- self._is_dragging = False
- self._click_tab = None
- self._pressed_button = None
-
- wnd = self.TabHitTest(event.GetX(), event.GetY())
-
- if wnd is not None:
- new_selection = self.GetIdxFromWindow(wnd)
-
- # AuiNotebooks always want to receive this event
- # even if the tab is already active, because they may
- # have multiple tab controls
- if new_selection != self.GetActivePage() or isinstance(self.GetParent(), AuiNotebook):
-
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, self.GetId())
- e.SetSelection(new_selection)
- e.SetOldSelection(self.GetActivePage())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
- self._click_pt.x = event.GetX()
- self._click_pt.y = event.GetY()
- self._click_tab = wnd
- else:
- page_index = self.GetActivePage()
- if page_index != wx.NOT_FOUND:
- self.GetWindowFromIdx(page_index).SetFocus()
-
- if self._hover_button:
- self._pressed_button = self._hover_button
- self._pressed_button.cur_state = AUI_BUTTON_STATE_PRESSED
- self._on_button = True
- self.Refresh()
- self.Update()
-
-
- def OnCaptureLost(self, event):
- """
- Handles the ``wx.EVT_MOUSE_CAPTURE_LOST`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseCaptureLostEvent` event to be processed.
- """
-
- if self._is_dragging:
- self._is_dragging = False
- self._on_button = False
-
- if self._drag_image:
- self._drag_image.EndDrag()
- del self._drag_image
- self._drag_image = None
-
- event = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, self.GetId())
- event.SetSelection(self.GetIdxFromWindow(self._click_tab))
- event.SetOldSelection(event.GetSelection())
- event.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(event)
-
-
- def OnLeftUp(self, event):
- """
- Handles the ``wx.EVT_LEFT_UP`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- self._on_button = False
-
- if self._is_dragging:
-
- if self.HasCapture():
- self.ReleaseMouse()
-
- self._is_dragging = False
- if self._drag_image:
- self._drag_image.EndDrag()
- del self._drag_image
- self._drag_image = None
- self.GetParent().Refresh()
-
- evt = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, self.GetId())
- evt.SetSelection(self.GetIdxFromWindow(self._click_tab))
- evt.SetOldSelection(evt.GetSelection())
- evt.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(evt)
-
- return
-
- self.GetParent()._mgr.HideHint()
-
- if self.HasCapture():
- self.ReleaseMouse()
-
- if self._hover_button:
- self._pressed_button = self._hover_button
-
- if self._pressed_button:
-
- # make sure we're still clicking the button
- button = self.ButtonHitTest(event.GetX(), event.GetY())
-
- if button is None:
- return
-
- if button != self._pressed_button:
- self._pressed_button = None
- return
-
- self.Refresh()
- self.Update()
-
- if self._pressed_button.cur_state & AUI_BUTTON_STATE_DISABLED == 0:
-
- evt = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, self.GetId())
- evt.SetSelection(self.GetIdxFromWindow(self._click_tab))
- evt.SetInt(self._pressed_button.id)
- evt.SetEventObject(self)
- eventHandler = self.GetEventHandler()
-
- if eventHandler is not None:
- eventHandler.ProcessEvent(evt)
-
- self._pressed_button = None
-
- self._click_pt = wx.Point(-1, -1)
- self._is_dragging = False
- self._click_tab = None
-
-
- def OnMiddleUp(self, event):
- """
- Handles the ``wx.EVT_MIDDLE_UP`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- eventHandler = self.GetEventHandler()
- if not isinstance(eventHandler, AuiTabCtrl):
- event.Skip()
- return
-
- x, y = event.GetX(), event.GetY()
- wnd = self.TabHitTest(x, y)
-
- if wnd:
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, self.GetId())
- e.SetEventObject(self)
- e.SetSelection(self.GetIdxFromWindow(wnd))
- self.GetEventHandler().ProcessEvent(e)
- elif not self.ButtonHitTest(x, y):
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BG_MIDDLE_UP, self.GetId())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnMiddleDown(self, event):
- """
- Handles the ``wx.EVT_MIDDLE_DOWN`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- eventHandler = self.GetEventHandler()
- if not isinstance(eventHandler, AuiTabCtrl):
- event.Skip()
- return
-
- x, y = event.GetX(), event.GetY()
- wnd = self.TabHitTest(x, y)
-
- if wnd:
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, self.GetId())
- e.SetEventObject(self)
- e.SetSelection(self.GetIdxFromWindow(wnd))
- self.GetEventHandler().ProcessEvent(e)
- elif not self.ButtonHitTest(x, y):
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BG_MIDDLE_DOWN, self.GetId())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnRightUp(self, event):
- """
- Handles the ``wx.EVT_RIGHT_UP`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- x, y = event.GetX(), event.GetY()
- wnd = self.TabHitTest(x, y)
-
- if wnd:
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, self.GetId())
- e.SetEventObject(self)
- e.SetSelection(self.GetIdxFromWindow(wnd))
- self.GetEventHandler().ProcessEvent(e)
- elif not self.ButtonHitTest(x, y):
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BG_RIGHT_UP, self.GetId())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnRightDown(self, event):
- """
- Handles the ``wx.EVT_RIGHT_DOWN`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- x, y = event.GetX(), event.GetY()
- wnd = self.TabHitTest(x, y)
-
- if wnd:
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, self.GetId())
- e.SetEventObject(self)
- e.SetSelection(self.GetIdxFromWindow(wnd))
- self.GetEventHandler().ProcessEvent(e)
- elif not self.ButtonHitTest(x, y):
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BG_RIGHT_DOWN, self.GetId())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnLeftDClick(self, event):
- """
- Handles the ``wx.EVT_LEFT_DCLICK`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- x, y = event.GetX(), event.GetY()
- wnd = self.TabHitTest(x, y)
-
- if wnd:
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_DCLICK, self.GetId())
- e.SetEventObject(self)
- e.SetSelection(self.GetIdxFromWindow(wnd))
- self.GetEventHandler().ProcessEvent(e)
- elif not self.ButtonHitTest(x, y):
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, self.GetId())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnMotion(self, event):
- """
- Handles the ``wx.EVT_MOTION`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- pos = event.GetPosition()
-
- # check if the mouse is hovering above a button
-
- button = self.ButtonHitTest(pos.x, pos.y)
- wnd = self.TabHitTest(pos.x, pos.y)
-
- if wnd is not None:
- mouse_tab = self.GetIdxFromWindow(wnd)
- if not self._pages[mouse_tab].enabled:
- self._hover_button = None
- return
-
- if self._on_button:
- return
-
- if button:
-
- if self._hover_button and button != self._hover_button:
- self._hover_button.cur_state = AUI_BUTTON_STATE_NORMAL
- self._hover_button = None
- self.Refresh()
- self.Update()
-
- if button.cur_state != AUI_BUTTON_STATE_HOVER:
- button.cur_state = AUI_BUTTON_STATE_HOVER
- self.Refresh()
- self.Update()
- self._hover_button = button
- return
-
- else:
-
- if self._hover_button:
- self._hover_button.cur_state = AUI_BUTTON_STATE_NORMAL
- self._hover_button = None
- self.Refresh()
- self.Update()
-
- if not event.LeftIsDown() or self._click_pt == wx.Point(-1, -1):
- return
-
- if not self.HasCapture():
- return
-
- wnd = self.TabHitTest(pos.x, pos.y)
-
- if not self._is_dragging:
-
- drag_x_threshold = wx.SystemSettings.GetMetric(wx.SYS_DRAG_X)
- drag_y_threshold = wx.SystemSettings.GetMetric(wx.SYS_DRAG_Y)
-
- if abs(pos.x - self._click_pt.x) > drag_x_threshold or \
- abs(pos.y - self._click_pt.y) > drag_y_threshold:
-
- self._is_dragging = True
-
- if self._drag_image:
- self._drag_image.EndDrag()
- del self._drag_image
- self._drag_image = None
-
- if self._agwFlags & AUI_NB_DRAW_DND_TAB:
- # Create the custom draw image from the icons and the text of the item
- mouse_tab = self.GetIdxFromWindow(wnd)
- page = self._pages[mouse_tab]
- tab_button = self._tab_close_buttons[mouse_tab]
- self._drag_image = TabDragImage(self, page, tab_button.cur_state, self._art)
-
- if self._agwFlags & AUI_NB_TAB_FLOAT:
- self._drag_image.BeginDrag(wx.Point(0,0), self, fullScreen=True)
- else:
- self._drag_image.BeginDragBounded(wx.Point(0,0), self, self.GetParent())
-
- # Capture the mouse cursor position offset relative to
- # The tab image location
- self._drag_img_offset = (pos[0] - page.rect.x,
- pos[1] - page.rect.y)
-
- self._drag_image.Show()
-
- if not wnd:
- evt2 = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, self.GetId())
- evt2.SetSelection(self.GetIdxFromWindow(self._click_tab))
- evt2.SetOldSelection(evt2.GetSelection())
- evt2.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(evt2)
- if evt2.GetDispatched():
- return
-
- evt3 = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, self.GetId())
- evt3.SetSelection(self.GetIdxFromWindow(self._click_tab))
- evt3.SetOldSelection(evt3.GetSelection())
- evt3.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(evt3)
-
- if self._drag_image:
- # Apply the drag images offset
- pos -= self._drag_img_offset
- self._drag_image.Move(pos)
-
-
- def OnLeaveWindow(self, event):
- """
- Handles the ``wx.EVT_LEAVE_WINDOW`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.MouseEvent` event to be processed.
- """
-
- if self._hover_button:
- self._hover_button.cur_state = AUI_BUTTON_STATE_NORMAL
- self._hover_button = None
- self.Refresh()
- self.Update()
-
-
- def OnButton(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_BUTTON`` event for L{AuiTabCtrl}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- button = event.GetInt()
-
- if button == AUI_BUTTON_LEFT or button == AUI_BUTTON_RIGHT:
- if button == AUI_BUTTON_LEFT:
- if self.GetTabOffset() > 0:
-
- self.SetTabOffset(self.GetTabOffset()-1)
- self.Refresh()
- self.Update()
- else:
- self.SetTabOffset(self.GetTabOffset()+1)
- self.Refresh()
- self.Update()
-
- elif button == AUI_BUTTON_WINDOWLIST:
- idx = self.GetArtProvider().ShowDropDown(self, self._pages, self.GetActivePage())
-
- if idx != -1:
-
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, self.GetId())
- e.SetSelection(idx)
- e.SetOldSelection(self.GetActivePage())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
- else:
- event.Skip()
-
-
- def OnSetFocus(self, event):
- """
- Handles the ``wx.EVT_SET_FOCUS`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.FocusEvent` event to be processed.
- """
-
- self.Refresh()
-
-
- def OnKillFocus(self, event):
- """
- Handles the ``wx.EVT_KILL_FOCUS`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.FocusEvent` event to be processed.
- """
-
- self.Refresh()
-
-
- def OnKeyDown(self, event):
- """
- Handles the ``wx.EVT_KEY_DOWN`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.KeyEvent` event to be processed.
- """
-
- key = event.GetKeyCode()
- nb = self.GetParent()
-
- if key == wx.WXK_LEFT:
- nb.AdvanceSelection(False)
- self.SetFocus()
-
- elif key == wx.WXK_RIGHT:
- nb.AdvanceSelection(True)
- self.SetFocus()
-
- elif key == wx.WXK_HOME:
- newPage = 0
- nb.SetSelection(newPage)
- self.SetFocus()
-
- elif key == wx.WXK_END:
- newPage = nb.GetPageCount() - 1
- nb.SetSelection(newPage)
- self.SetFocus()
-
- elif key == wx.WXK_TAB:
- if not event.ControlDown():
- flags = 0
- if not event.ShiftDown(): flags |= wx.NavigationKeyEvent.IsForward
- if event.CmdDown(): flags |= wx.NavigationKeyEvent.WinChange
- self.Navigate(flags)
- else:
-
- if not nb or not isinstance(nb, AuiNotebook):
- event.Skip()
- return
-
- bForward = bWindowChange = 0
- if not event.ShiftDown(): bForward |= wx.NavigationKeyEvent.IsForward
- if event.CmdDown(): bWindowChange |= wx.NavigationKeyEvent.WinChange
-
- keyEvent = wx.NavigationKeyEvent()
- keyEvent.SetDirection(bForward)
- keyEvent.SetWindowChange(bWindowChange)
- keyEvent.SetFromTab(True)
- keyEvent.SetEventObject(nb)
-
- if not nb.GetEventHandler().ProcessEvent(keyEvent):
-
- # Not processed? Do an explicit tab into the page.
- win = self.GetWindowFromIdx(self.GetActivePage())
- if win:
- win.SetFocus()
-
- self.SetFocus()
-
- return
-
- else:
- event.Skip()
-
-
- def OnKeyDown2(self, event):
- """
- Deprecated.
-
- Handles the ``wx.EVT_KEY_DOWN`` event for L{AuiTabCtrl}.
-
- :param `event`: a `wx.KeyEvent` event to be processed.
-
- :warning: This method implementation is now deprecated. Refer to L{OnKeyDown}
- for the correct one.
- """
-
- if self.GetActivePage() == -1:
- event.Skip()
- return
-
- # We can't leave tab processing to the system on Windows, tabs and keys
- # get eaten by the system and not processed properly if we specify both
- # wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
- # we don't key arrow key events.
-
- key = event.GetKeyCode()
-
- if key == wx.WXK_NUMPAD_PAGEUP:
- key = wx.WXK_PAGEUP
- if key == wx.WXK_NUMPAD_PAGEDOWN:
- key = wx.WXK_PAGEDOWN
- if key == wx.WXK_NUMPAD_HOME:
- key = wx.WXK_HOME
- if key == wx.WXK_NUMPAD_END:
- key = wx.WXK_END
- if key == wx.WXK_NUMPAD_LEFT:
- key = wx.WXK_LEFT
- if key == wx.WXK_NUMPAD_RIGHT:
- key = wx.WXK_RIGHT
-
- if key == wx.WXK_TAB or key == wx.WXK_PAGEUP or key == wx.WXK_PAGEDOWN:
-
- bCtrlDown = event.ControlDown()
- bShiftDown = event.ShiftDown()
-
- bForward = (key == wx.WXK_TAB and not bShiftDown) or (key == wx.WXK_PAGEDOWN)
- bWindowChange = (key == wx.WXK_PAGEUP) or (key == wx.WXK_PAGEDOWN) or bCtrlDown
- bFromTab = (key == wx.WXK_TAB)
-
- nb = self.GetParent()
- if not nb or not isinstance(nb, AuiNotebook):
- event.Skip()
- return
-
- keyEvent = wx.NavigationKeyEvent()
- keyEvent.SetDirection(bForward)
- keyEvent.SetWindowChange(bWindowChange)
- keyEvent.SetFromTab(bFromTab)
- keyEvent.SetEventObject(nb)
-
- if not nb.GetEventHandler().ProcessEvent(keyEvent):
-
- # Not processed? Do an explicit tab into the page.
- win = self.GetWindowFromIdx(self.GetActivePage())
- if win:
- win.SetFocus()
-
- return
-
- if len(self._pages) < 2:
- event.Skip()
- return
-
- newPage = -1
-
- if self.GetLayoutDirection() == wx.Layout_RightToLeft:
- forwardKey = wx.WXK_LEFT
- backwardKey = wx.WXK_RIGHT
- else:
- forwardKey = wx.WXK_RIGHT
- backwardKey = wx.WXK_LEFT
-
- if key == forwardKey:
- if self.GetActivePage() == -1:
- newPage = 0
- elif self.GetActivePage() < len(self._pages) - 1:
- newPage = self.GetActivePage() + 1
-
- elif key == backwardKey:
- if self.GetActivePage() == -1:
- newPage = len(self._pages) - 1
- elif self.GetActivePage() > 0:
- newPage = self.GetActivePage() - 1
-
- elif key == wx.WXK_HOME:
- newPage = 0
-
- elif key == wx.WXK_END:
- newPage = len(self._pages) - 1
-
- else:
- event.Skip()
-
- if newPage != -1:
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, self.GetId())
- e.SetSelection(newPage)
- e.SetOldSelection(newPage)
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
- else:
- event.Skip()
-
-
-# ----------------------------------------------------------------------
-
-class TabFrame(wx.PyWindow):
- """
- TabFrame is an interesting case. It's important that all child pages
- of the multi-notebook control are all actually children of that control
- (and not grandchildren). TabFrame facilitates this. There is one
- instance of TabFrame for each tab control inside the multi-notebook.
-
- It's important to know that TabFrame is not a real window, but it merely
- used to capture the dimensions/positioning of the internal tab control and
- it's managed page windows.
- """
-
- def __init__(self, parent):
- """
- Default class constructor.
- Used internally, do not call it in your code!
- """
-
- pre = wx.PrePyWindow()
-
- self._tabs = None
- self._rect = wx.Rect(0, 0, 200, 200)
- self._tab_ctrl_height = 20
- self._tab_rect = wx.Rect()
- self._parent = parent
-
- self.PostCreate(pre)
-
-
- def SetTabCtrlHeight(self, h):
- """
- Sets the tab control height.
-
- :param `h`: the tab area height.
- """
-
- self._tab_ctrl_height = h
-
-
- def DoSetSize(self, x, y, width, height, flags=wx.SIZE_AUTO):
- """
- Sets the position and size of the window in pixels. The `flags`
- parameter indicates the interpretation of the other params if they are
- equal to -1.
-
- :param `x`: the window `x` position;
- :param `y`: the window `y` position;
- :param `width`: the window width;
- :param `height`: the window height;
- :param `flags`: may have one of this bit set:
-
- =================================== ======================================
- Size Flags Description
- =================================== ======================================
- ``wx.SIZE_AUTO`` A -1 indicates that a class-specific default should be used.
- ``wx.SIZE_AUTO_WIDTH`` A -1 indicates that a class-specific default should be used for the width.
- ``wx.SIZE_AUTO_HEIGHT`` A -1 indicates that a class-specific default should be used for the height.
- ``wx.SIZE_USE_EXISTING`` Existing dimensions should be used if -1 values are supplied.
- ``wx.SIZE_ALLOW_MINUS_ONE`` Allow dimensions of -1 and less to be interpreted as real dimensions, not default values.
- ``wx.SIZE_FORCE`` Normally, if the position and the size of the window are already the same as the parameters of this function, nothing is done. but with this flag a window resize may be forced even in this case (supported in wx 2.6.2 and later and only implemented for MSW and ignored elsewhere currently)
- =================================== ======================================
-
- :note: Overridden from `wx.PyControl`.
- """
-
- self._rect = wx.Rect(x, y, max(1, width), max(1, height))
- self.DoSizing()
-
-
- def DoGetSize(self):
- """
- Returns the window size.
-
- :note: Overridden from `wx.PyControl`.
- """
-
- return self._rect.width, self._rect.height
-
-
- def DoGetClientSize(self):
- """
- Returns the window client size.
-
- :note: Overridden from `wx.PyControl`.
- """
-
- return self._rect.width, self._rect.height
-
-
- def Show(self, show=True):
- """
- Shows/hides the window.
-
- :param `show`: ``True`` to show the window, ``False`` otherwise.
-
- :note: Overridden from `wx.PyControl`, this method always returns ``False`` as
- L{TabFrame} should never be phisically shown on screen.
- """
-
- return False
-
-
- def DoSizing(self):
- """ Does the actual sizing of the tab control. """
-
- if not self._tabs:
- return
-
- hideOnSingle = ((self._tabs.GetAGWFlags() & AUI_NB_HIDE_ON_SINGLE_TAB) and \
- self._tabs.GetPageCount() <= 1)
-
- if not hideOnSingle and not self._parent._hide_tabs:
- tab_height = self._tab_ctrl_height
-
- self._tab_rect = wx.Rect(self._rect.x, self._rect.y, self._rect.width, self._tab_ctrl_height)
-
- if self._tabs.GetAGWFlags() & AUI_NB_BOTTOM:
- self._tab_rect = wx.Rect(self._rect.x, self._rect.y + self._rect.height - tab_height,
- self._rect.width, tab_height)
- self._tabs.SetDimensions(self._rect.x, self._rect.y + self._rect.height - tab_height,
- self._rect.width, tab_height)
- self._tabs.SetTabRect(wx.Rect(0, 0, self._rect.width, tab_height))
-
- else:
-
- self._tab_rect = wx.Rect(self._rect.x, self._rect.y, self._rect.width, tab_height)
- self._tabs.SetDimensions(self._rect.x, self._rect.y, self._rect.width, tab_height)
- self._tabs.SetTabRect(wx.Rect(0, 0, self._rect.width, tab_height))
-
- # TODO: elif (GetAGWFlags() & AUI_NB_LEFT)
- # TODO: elif (GetAGWFlags() & AUI_NB_RIGHT)
-
- self._tabs.Refresh()
- self._tabs.Update()
-
- else:
-
- tab_height = 0
- self._tabs.SetDimensions(self._rect.x, self._rect.y, self._rect.width, tab_height)
- self._tabs.SetTabRect(wx.Rect(0, 0, self._rect.width, tab_height))
-
- pages = self._tabs.GetPages()
-
- for page in pages:
-
- height = self._rect.height - tab_height
-
- if height < 0:
- # avoid passing negative height to wx.Window.SetSize(), this
- # results in assert failures/GTK+ warnings
- height = 0
-
- if self._tabs.GetAGWFlags() & AUI_NB_BOTTOM:
- page.window.SetDimensions(self._rect.x, self._rect.y, self._rect.width, height)
-
- else:
- page.window.SetDimensions(self._rect.x, self._rect.y + tab_height,
- self._rect.width, height)
-
- # TODO: elif (GetAGWFlags() & AUI_NB_LEFT)
- # TODO: elif (GetAGWFlags() & AUI_NB_RIGHT)
-
- if repr(page.window.__class__).find("AuiMDIChildFrame") >= 0:
- page.window.ApplyMDIChildFrameRect()
-
-
- def Update(self):
- """
- Calling this method immediately repaints the invalidated area of the window
- and all of its children recursively while this would usually only happen when
- the flow of control returns to the event loop.
-
- :note: Notice that this function doesn't invalidate any area of the window so
- nothing happens if nothing has been invalidated (i.e. marked as requiring a redraw).
- Use `Refresh` first if you want to immediately redraw the window unconditionally.
-
- :note: Overridden from `wx.PyControl`.
- """
-
- # does nothing
- pass
-
-
-# ----------------------------------------------------------------------
-# -- AuiNotebook class implementation --
-
-class AuiNotebook(wx.PyPanel):
- """
- AuiNotebook is a notebook control which implements many features common in
- applications with dockable panes. Specifically, AuiNotebook implements functionality
- which allows the user to rearrange tab order via drag-and-drop, split the tab window
- into many different splitter configurations, and toggle through different themes to
- customize the control's look and feel.
-
- An effort has been made to try to maintain an API as similar to that of `wx.Notebook`.
-
- The default theme that is used is L{AuiDefaultTabArt}, which provides a modern, glossy
- look and feel. The theme can be changed by calling L{AuiNotebook.SetArtProvider}.
- """
-
- def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize,
- style=0, agwStyle=AUI_NB_DEFAULT_STYLE):
- """
- Default class constructor.
-
- :param `parent`: the L{AuiNotebook} parent;
- :param `id`: an identifier for the control: a value of -1 is taken to mean a default;
- :param `pos`: the control position. A value of (-1, -1) indicates a default position,
- chosen by either the windowing system or wxPython, depending on platform;
- :param `size`: the control size. A value of (-1, -1) indicates a default size,
- chosen by either the windowing system or wxPython, depending on platform;
- :param `style`: the underlying `wx.PyPanel` window style;
- :param `agwStyle`: the AGW-specific window style. This can be a combination of the following bits:
-
- ==================================== ==================================
- 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
- ==================================== ==================================
-
- Default value for `agwStyle` is:
- ``AUI_NB_DEFAULT_STYLE`` = ``AUI_NB_TOP`` | ``AUI_NB_TAB_SPLIT`` | ``AUI_NB_TAB_MOVE`` | ``AUI_NB_SCROLL_BUTTONS`` | ``AUI_NB_CLOSE_ON_ACTIVE_TAB`` | ``AUI_NB_MIDDLE_CLICK_CLOSE`` | ``AUI_NB_DRAW_DND_TAB``
-
- """
-
- self._curpage = -1
- self._tab_id_counter = AuiBaseTabCtrlId
- self._dummy_wnd = None
- self._hide_tabs = False
- self._sash_dclick_unsplit = False
- self._tab_ctrl_height = 20
- self._requested_bmp_size = wx.Size(-1, -1)
- self._requested_tabctrl_height = -1
- self._textCtrl = None
- self._tabBounds = (-1, -1)
-
- wx.PyPanel.__init__(self, parent, id, pos, size, style|wx.BORDER_NONE|wx.TAB_TRAVERSAL)
- self._mgr = framemanager.AuiManager()
- self._tabs = AuiTabContainer(self)
-
- self.InitNotebook(agwStyle)
-
-
- def GetTabContainer(self):
- """ Returns the instance of L{AuiTabContainer}. """
-
- return self._tabs
-
-
- def InitNotebook(self, agwStyle):
- """
- Contains common initialization code called by all constructors.
-
- :param `agwStyle`: the notebook style.
-
- :see: L{__init__}
- """
-
- self.SetName("AuiNotebook")
- self._agwFlags = agwStyle
-
- self._popupWin = None
- self._naviIcon = None
- self._imageList = None
- self._last_drag_x = 0
-
- 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.SetArtProvider(TA.AuiDefaultTabArt())
-
- self._dummy_wnd = wx.Window(self, wx.ID_ANY, wx.Point(0, 0), wx.Size(0, 0))
- self._dummy_wnd.SetSize((200, 200))
- self._dummy_wnd.Show(False)
-
- self._mgr.SetManagedWindow(self)
- self._mgr.SetAGWFlags(AUI_MGR_DEFAULT)
- self._mgr.SetDockSizeConstraint(1.0, 1.0) # no dock size constraint
-
- self._mgr.AddPane(self._dummy_wnd, framemanager.AuiPaneInfo().Name("dummy").Bottom().CaptionVisible(False).Show(False))
- self._mgr.Update()
-
- self.Bind(wx.EVT_SIZE, self.OnSize)
- self.Bind(wx.EVT_CHILD_FOCUS, self.OnChildFocusNotebook)
- self.Bind(EVT_AUINOTEBOOK_PAGE_CHANGING, self.OnTabClicked,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_BEGIN_DRAG, self.OnTabBeginDrag,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_END_DRAG, self.OnTabEndDrag,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_DRAG_MOTION, self.OnTabDragMotion,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_CANCEL_DRAG, self.OnTabCancelDrag,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_BUTTON, self.OnTabButton,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN, self.OnTabMiddleDown,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_TAB_MIDDLE_UP, self.OnTabMiddleUp,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_TAB_RIGHT_DOWN, self.OnTabRightDown,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_TAB_RIGHT_UP, self.OnTabRightUp,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_BG_DCLICK, self.OnTabBgDClick,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
- self.Bind(EVT_AUINOTEBOOK_TAB_DCLICK, self.OnTabDClick,
- id=AuiBaseTabCtrlId, id2=AuiBaseTabCtrlId+500)
-
- self.Bind(wx.EVT_NAVIGATION_KEY, self.OnNavigationKeyNotebook)
-
-
- def SetArtProvider(self, art):
- """
- Sets the art provider to be used by the notebook.
-
- :param `art`: an art provider.
- """
-
- self._tabs.SetArtProvider(art)
- self.UpdateTabCtrlHeight(force=True)
-
-
- def SavePerspective(self):
- """
- Saves the entire user interface layout into an encoded string, which can then
- be stored by the application (probably using `wx.Config`). When a perspective
- is restored using L{LoadPerspective}, the entire user interface will return
- to the state it was when the perspective was saved.
- """
-
- # Build list of panes/tabs
- tabs = ""
- all_panes = self._mgr.GetAllPanes()
-
- for pane in all_panes:
-
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
-
- if tabs:
- tabs += "|"
-
- tabs += pane.name + "="
-
- # add tab id's
- page_count = tabframe._tabs.GetPageCount()
-
- for p in xrange(page_count):
-
- page = tabframe._tabs.GetPage(p)
- page_idx = self._tabs.GetIdxFromWindow(page.window)
-
- if p:
- tabs += ","
-
- if p == tabframe._tabs.GetActivePage():
- tabs += "+"
- elif page_idx == self._curpage:
- tabs += "*"
-
- tabs += "%u"%page_idx
-
- tabs += "@"
-
- # Add frame perspective
- tabs += self._mgr.SavePerspective()
-
- return tabs
-
-
- def LoadPerspective(self, layout):
- """
- Loads a layout which was saved with L{SavePerspective}.
-
- :param `layout`: a string which contains a saved L{AuiNotebook} layout.
- """
-
- # Remove all tab ctrls (but still keep them in main index)
- tab_count = self._tabs.GetPageCount()
- for i in xrange(tab_count):
- wnd = self._tabs.GetWindowFromIdx(i)
-
- # find out which onscreen tab ctrl owns this tab
- ctrl, ctrl_idx = self.FindTab(wnd)
- if not ctrl:
- return False
-
- # remove the tab from ctrl
- if not ctrl.RemovePage(wnd):
- return False
-
- self.RemoveEmptyTabFrames()
-
- sel_page = 0
- tabs = layout[0:layout.index("@")]
- to_break1 = False
-
- while 1:
-
- if "|" not in tabs:
- to_break1 = True
- tab_part = tabs
- else:
- tab_part = tabs[0:tabs.index('|')]
-
- if "=" not in tab_part:
- # No pages in this perspective...
- return False
-
- # Get pane name
- pane_name = tab_part[0:tab_part.index("=")]
-
- # create a new tab frame
- new_tabs = TabFrame(self)
- self._tab_id_counter += 1
- new_tabs._tabs = AuiTabCtrl(self, self._tab_id_counter)
- new_tabs._tabs.SetArtProvider(self._tabs.GetArtProvider().Clone())
- new_tabs.SetTabCtrlHeight(self._tab_ctrl_height)
- new_tabs._tabs.SetAGWFlags(self._agwFlags)
- dest_tabs = new_tabs._tabs
-
- # create a pane info structure with the information
- # about where the pane should be added
- pane_info = framemanager.AuiPaneInfo().Name(pane_name).Bottom().CaptionVisible(False)
- self._mgr.AddPane(new_tabs, pane_info)
-
- # Get list of tab id's and move them to pane
- tab_list = tab_part[tab_part.index("=")+1:]
- to_break2, active_found = False, False
-
- while 1:
- if "," not in tab_list:
- to_break2 = True
- tab = tab_list
- else:
- tab = tab_list[0:tab_list.index(",")]
- tab_list = tab_list[tab_list.index(",")+1:]
-
- # Check if this page has an 'active' marker
- c = tab[0]
- if c in ['+', '*']:
- tab = tab[1:]
-
- tab_idx = int(tab)
- if tab_idx >= self.GetPageCount():
- to_break1 = True
- break
-
- # Move tab to pane
- page = self._tabs.GetPage(tab_idx)
- newpage_idx = dest_tabs.GetPageCount()
- dest_tabs.InsertPage(page.window, page, newpage_idx)
-
- if c == '+':
- dest_tabs.SetActivePage(newpage_idx)
- active_found = True
- elif c == '*':
- sel_page = tab_idx
-
- if to_break2:
- break
-
- if not active_found:
- dest_tabs.SetActivePage(0)
-
- new_tabs.DoSizing()
- dest_tabs.DoShowHide()
- dest_tabs.Refresh()
-
- if to_break1:
- break
-
- tabs = tabs[tabs.index('|')+1:]
-
- # Load the frame perspective
- frames = layout[layout.index('@')+1:]
- self._mgr.LoadPerspective(frames)
-
- # Force refresh of selection
- self._curpage = -1
- self.SetSelection(sel_page)
-
- return True
-
-
- def SetTabCtrlHeight(self, height):
- """
- Sets the tab height.
-
- By default, the tab control height is calculated by measuring the text
- height and bitmap sizes on the tab captions.
-
- Calling this method will override that calculation and set the tab control
- to the specified height parameter. A call to this method will override
- any call to L{SetUniformBitmapSize}. Specifying -1 as the height will
- return the control to its default auto-sizing behaviour.
-
- :param `height`: the tab control area height.
- """
-
- self._requested_tabctrl_height = height
-
- # if window is already initialized, recalculate the tab height
- if self._dummy_wnd:
- self.UpdateTabCtrlHeight()
-
-
- def SetUniformBitmapSize(self, size):
- """
- Ensures that all tabs will have the same height, even if some tabs
- don't have bitmaps. Passing ``wx.DefaultSize`` to this
- function will instruct the control to use dynamic tab height, which is
- the default behaviour. Under the default behaviour, when a tab with a
- large bitmap is added, the tab control's height will automatically
- increase to accommodate the larger bitmap.
-
- :param `size`: an instance of `wx.Size` specifying the tab bitmap size.
- """
-
- self._requested_bmp_size = wx.Size(*size)
-
- # if window is already initialized, recalculate the tab height
- if self._dummy_wnd:
- self.UpdateTabCtrlHeight()
-
-
- def UpdateTabCtrlHeight(self, force=False):
- """
- UpdateTabCtrlHeight() does the actual tab resizing. It's meant
- to be used interally.
-
- :param `force`: ``True`` to force the tab art to repaint.
- """
-
- # get the tab ctrl height we will use
- height = self.CalculateTabCtrlHeight()
-
- # if the tab control height needs to change, update
- # all of our tab controls with the new height
- if self._tab_ctrl_height != height or force:
- art = self._tabs.GetArtProvider()
-
- self._tab_ctrl_height = height
-
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
-
- if pane.name == "dummy":
- continue
-
- tab_frame = pane.window
- tabctrl = tab_frame._tabs
- tab_frame.SetTabCtrlHeight(self._tab_ctrl_height)
- tabctrl.SetArtProvider(art.Clone())
- tab_frame.DoSizing()
-
-
- def UpdateHintWindowSize(self):
- """ Updates the L{AuiManager} hint window size. """
-
- size = self.CalculateNewSplitSize()
-
- # the placeholder hint window should be set to this size
- info = self._mgr.GetPane("dummy")
-
- if info.IsOk():
- info.MinSize(size)
- info.BestSize(size)
- self._dummy_wnd.SetSize(size)
-
-
- def CalculateNewSplitSize(self):
- """ Calculates the size of the new split. """
-
- # count number of tab controls
- tab_ctrl_count = 0
- all_panes = self._mgr.GetAllPanes()
-
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tab_ctrl_count += 1
-
- # if there is only one tab control, the first split
- # should happen around the middle
- if tab_ctrl_count < 2:
- new_split_size = self.GetClientSize()
- new_split_size.x /= 2
- new_split_size.y /= 2
-
- else:
-
- # this is in place of a more complicated calculation
- # that needs to be implemented
- new_split_size = wx.Size(180, 180)
-
- return new_split_size
-
-
- def CalculateTabCtrlHeight(self):
- """ Calculates the tab control area height. """
-
- # if a fixed tab ctrl height is specified,
- # just return that instead of calculating a
- # tab height
- if self._requested_tabctrl_height != -1:
- return self._requested_tabctrl_height
-
- # find out new best tab height
- art = self._tabs.GetArtProvider()
-
- return art.GetBestTabCtrlSize(self, self._tabs.GetPages(), self._requested_bmp_size)
-
-
- def GetArtProvider(self):
- """ Returns the associated art provider. """
-
- return self._tabs.GetArtProvider()
-
-
- def SetAGWWindowStyleFlag(self, agwStyle):
- """
- Sets the AGW-specific style of the window.
-
- :param `agwStyle`: the new window style. This can be a combination of the following bits:
-
- ==================================== ==================================
- 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: Please note that some styles cannot be changed after the window
- creation and that `Refresh` might need to be be called after changing the
- others for the change to take place immediately.
-
- :todo: Implementation of flags ``AUI_NB_RIGHT`` and ``AUI_NB_LEFT``.
- """
-
- self._agwFlags = agwStyle
-
- # if the control is already initialized
- if self._mgr.GetManagedWindow() == self:
-
- # let all of the tab children know about the new style
-
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
- tabctrl = tabframe._tabs
- tabctrl.SetAGWFlags(self._agwFlags)
- tabframe.DoSizing()
- tabctrl.Refresh()
- tabctrl.Update()
-
-
- def GetAGWWindowStyleFlag(self):
- """
- Returns the AGW-specific style of the window.
-
- :see: L{SetAGWWindowStyleFlag} for a list of possible AGW-specific window styles.
- """
-
- return self._agwFlags
-
-
- def AddPage(self, page, caption, select=False, bitmap=wx.NullBitmap, disabled_bitmap=wx.NullBitmap, control=None):
- """
- Adds a page. If the `select` parameter is ``True``, calling this will generate a
- page change event.
-
- :param `page`: the page to be added;
- :param `caption`: specifies the text for the new page;
- :param `select`: specifies whether the page should be selected;
- :param `bitmap`: the `wx.Bitmap` to display in the enabled tab;
- :param `disabled_bitmap`: the `wx.Bitmap` to display in the disabled tab;
- :param `control`: a `wx.Window` instance inside a tab (or ``None``).
- """
-
- return self.InsertPage(self.GetPageCount(), page, caption, select, bitmap, disabled_bitmap, control)
-
-
- def InsertPage(self, page_idx, page, caption, select=False, bitmap=wx.NullBitmap, disabled_bitmap=wx.NullBitmap,
- control=None):
- """
- This is similar to L{AddPage}, but allows the ability to specify the insert location.
-
- :param `page_idx`: specifies the position for the new page;
- :param `page`: the page to be added;
- :param `caption`: specifies the text for the new page;
- :param `select`: specifies whether the page should be selected;
- :param `bitmap`: the `wx.Bitmap` to display in the enabled tab;
- :param `disabled_bitmap`: the `wx.Bitmap` to display in the disabled tab;
- :param `control`: a `wx.Window` instance inside a tab (or ``None``).
- """
-
- if not page:
- return False
-
- page.Reparent(self)
- info = AuiNotebookPage()
- info.window = page
- info.caption = caption
- info.bitmap = bitmap
- info.active = False
- info.control = control
-
- originalPaneMgr = framemanager.GetManager(page)
- if originalPaneMgr:
- originalPane = originalPaneMgr.GetPane(page)
-
- if originalPane:
- info.hasCloseButton = originalPane.HasCloseButton()
-
- if bitmap.IsOk() and not disabled_bitmap.IsOk():
- disabled_bitmap = MakeDisabledBitmap(bitmap)
- info.dis_bitmap = disabled_bitmap
-
- # if there are currently no tabs, the first added
- # tab must be active
- if self._tabs.GetPageCount() == 0:
- info.active = True
-
- self._tabs.InsertPage(page, info, page_idx)
-
- # if that was the first page added, even if
- # select is False, it must become the "current page"
- # (though no select events will be fired)
- if not select and self._tabs.GetPageCount() == 1:
- select = True
-
- active_tabctrl = self.GetActiveTabCtrl()
- if page_idx >= active_tabctrl.GetPageCount():
- active_tabctrl.AddPage(page, info)
- else:
- active_tabctrl.InsertPage(page, info, page_idx)
-
- force = False
- if control:
- force = True
- control.Reparent(active_tabctrl)
- control.Show()
-
- self.UpdateTabCtrlHeight(force=force)
- self.DoSizing()
- active_tabctrl.DoShowHide()
-
- # adjust selected index
- if self._curpage >= page_idx:
- self._curpage += 1
-
- if select:
- self.SetSelectionToWindow(page)
-
- return True
-
-
- def DeletePage(self, page_idx):
- """
- Deletes a page at the given index. Calling this method will generate a page
- change event.
-
- :param `page_idx`: the page index to be deleted.
-
- :note: L{DeletePage} removes a tab from the multi-notebook, and destroys the window as well.
-
- :see: L{RemovePage}
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- wnd = self._tabs.GetWindowFromIdx(page_idx)
- # hide the window in advance, as this will
- # prevent flicker
- wnd.Show(False)
-
- self.RemoveControlFromPage(page_idx)
-
- if not self.RemovePage(page_idx):
- return False
-
- wnd.Destroy()
-
- return True
-
-
- def RemovePage(self, page_idx):
- """
- Removes a page, without deleting the window pointer.
-
- :param `page_idx`: the page index to be removed.
-
- :note: L{RemovePage} removes a tab from the multi-notebook, but does not destroy the window.
-
- :see: L{DeletePage}
- """
-
- # save active window pointer
- active_wnd = None
- if self._curpage >= 0:
- active_wnd = self._tabs.GetWindowFromIdx(self._curpage)
-
- # save pointer of window being deleted
- wnd = self._tabs.GetWindowFromIdx(page_idx)
- new_active = None
-
- # make sure we found the page
- if not wnd:
- return False
-
- # find out which onscreen tab ctrl owns this tab
- ctrl, ctrl_idx = self.FindTab(wnd)
- if not ctrl:
- return False
-
- currentPage = ctrl.GetPage(ctrl_idx)
- is_curpage = (self._curpage == page_idx)
- is_active_in_split = currentPage.active
-
- # remove the tab from main catalog
- if not self._tabs.RemovePage(wnd):
- return False
-
- # remove the tab from the onscreen tab ctrl
- ctrl.RemovePage(wnd)
-
- if is_active_in_split:
-
- ctrl_new_page_count = ctrl.GetPageCount()
-
- if ctrl_idx >= ctrl_new_page_count:
- ctrl_idx = ctrl_new_page_count - 1
-
- if ctrl_idx >= 0 and ctrl_idx < ctrl.GetPageCount():
-
- ctrl_idx = self.FindNextActiveTab(ctrl_idx, ctrl)
-
- # set new page as active in the tab split
- ctrl.SetActivePage(ctrl_idx)
-
- # if the page deleted was the current page for the
- # entire tab control, then record the window
- # pointer of the new active page for activation
- if is_curpage:
- new_active = ctrl.GetWindowFromIdx(ctrl_idx)
-
- else:
-
- # we are not deleting the active page, so keep it the same
- new_active = active_wnd
-
- if not new_active:
-
- # we haven't yet found a new page to active,
- # so select the next page from the main tab
- # catalogue
-
- if 0 <= page_idx < self._tabs.GetPageCount():
- new_active = self._tabs.GetPage(page_idx).window
- if not new_active and self._tabs.GetPageCount() > 0:
- new_active = self._tabs.GetPage(0).window
-
- self.RemoveEmptyTabFrames()
-
- # set new active pane
- if new_active:
- if not self.IsBeingDeleted():
- self._curpage = -1
- self.SetSelectionToWindow(new_active)
- else:
- self._curpage = -1
- self._tabs.SetNoneActive()
-
- return True
-
-
- def FindNextActiveTab(self, ctrl_idx, ctrl):
- """
- Finds the next active tab (used mainly when L{AuiNotebook} has inactive/disabled
- tabs in it).
-
- :param `ctrl_idx`: the index of the first (most obvious) tab to check for active status;
- :param `ctrl`: an instance of L{AuiTabCtrl}.
- """
-
- if self.GetEnabled(ctrl_idx):
- return ctrl_idx
-
- for indx in xrange(ctrl_idx, ctrl.GetPageCount()):
- if self.GetEnabled(indx):
- return indx
-
- for indx in xrange(ctrl_idx, -1, -1):
- if self.GetEnabled(indx):
- return indx
-
- return 0
-
-
- def HideAllTabs(self, hidden=True):
- """
- Hides all tabs on the L{AuiNotebook} control.
-
- :param `hidden`: if ``True`` hides all tabs.
- """
-
- self._hide_tabs = hidden
-
-
- def SetSashDClickUnsplit(self, unsplit=True):
- """
- Sets whether to unsplit a splitted L{AuiNotebook} when double-clicking on a sash.
-
- :param `unsplit`: ``True`` to unsplit on sash double-clicking, ``False`` otherwise.
- """
-
- self._sash_dclick_unsplit = unsplit
-
-
- def GetSashDClickUnsplit(self):
- """
- Returns whether a splitted L{AuiNotebook} can be unsplitted by double-clicking
- on the splitter sash.
- """
-
- return self._sash_dclick_unsplit
-
-
- def SetMinMaxTabWidth(self, minTabWidth, maxTabWidth):
- """
- Sets the minimum and/or the maximum tab widths for L{AuiNotebook} when the
- ``AUI_NB_TAB_FIXED_WIDTH`` style is defined.
-
- Pass -1 to either `minTabWidth` or `maxTabWidth` to reset to the default tab
- width behaviour for L{AuiNotebook}.
-
- :param `minTabWidth`: the minimum allowed tab width, in pixels;
- :param `maxTabWidth`: the maximum allowed tab width, in pixels.
-
- :note: Minimum and maximum tabs widths are used only when the ``AUI_NB_TAB_FIXED_WIDTH``
- style is present.
- """
-
- if minTabWidth > maxTabWidth:
- raise Exception("Minimum tab width must be less or equal than maximum tab width")
-
- self._tabBounds = (minTabWidth, maxTabWidth)
- self.SetAGWWindowStyleFlag(self._agwFlags)
-
-
- def GetMinMaxTabWidth(self):
- """
- Returns the minimum and the maximum tab widths for L{AuiNotebook} when the
- ``AUI_NB_TAB_FIXED_WIDTH`` style is defined.
-
- :note: Minimum and maximum tabs widths are used only when the ``AUI_NB_TAB_FIXED_WIDTH``
- style is present.
-
- :see: L{SetMinMaxTabWidth} for more information.
- """
-
- return self._tabBounds
-
-
- def GetPageIndex(self, page_wnd):
- """
- Returns the page index for the specified window. If the window is not
- found in the notebook, ``wx.NOT_FOUND`` is returned.
- """
-
- return self._tabs.GetIdxFromWindow(page_wnd)
-
-
- def SetPageText(self, page_idx, text):
- """
- Sets the tab label for the page.
-
- :param `page_idx`: the page index;
- :param `text`: the new tab label.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- should_refresh = page_info.caption != text
- page_info.caption = text
-
- # update what's on screen
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- info = ctrl.GetPage(ctrl_idx)
- should_refresh = should_refresh or info.caption != text
- info.caption = text
-
- if should_refresh:
- ctrl.Refresh()
- ctrl.Update()
-
- self.UpdateTabCtrlHeight(force=True)
-
- return True
-
-
- def GetPageText(self, page_idx):
- """
- Returns the tab label for the page.
-
- :param `page_idx`: the page index.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return ""
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- return page_info.caption
-
-
- def SetPageBitmap(self, page_idx, bitmap):
- """
- Sets the tab bitmap for the page.
-
- :param `page_idx`: the page index;
- :param `bitmap`: an instance of `wx.Bitmap`.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- should_refresh = page_info.bitmap is not bitmap
- page_info.bitmap = bitmap
- if bitmap.IsOk() and not page_info.dis_bitmap.IsOk():
- page_info.dis_bitmap = MakeDisabledBitmap(bitmap)
-
- # tab height might have changed
- self.UpdateTabCtrlHeight()
-
- # update what's on screen
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- info = ctrl.GetPage(ctrl_idx)
- should_refresh = should_refresh or info.bitmap is not bitmap
- info.bitmap = bitmap
- info.dis_bitmap = page_info.dis_bitmap
- if should_refresh:
- ctrl.Refresh()
- ctrl.Update()
-
- return True
-
-
- def GetPageBitmap(self, page_idx):
- """
- Returns the tab bitmap for the page.
-
- :param `page_idx`: the page index.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return wx.NullBitmap
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- return page_info.bitmap
-
-
- def SetImageList(self, imageList):
- """
- Sets the image list for the L{AuiNotebook} control.
-
- :param `imageList`: an instance of `wx.ImageList`.
- """
-
- self._imageList = imageList
-
-
- def AssignImageList(self, imageList):
- """
- Sets the image list for the L{AuiNotebook} control.
-
- :param `imageList`: an instance of `wx.ImageList`.
- """
-
- self.SetImageList(imageList)
-
-
- def GetImageList(self):
- """ Returns the associated image list (if any). """
-
- return self._imageList
-
-
- def SetPageImage(self, page, image):
- """
- Sets the image index for the given page.
-
- :param `page`: the page index;
- :param `image`: an index into the image list which was set with L{SetImageList}.
- """
-
- if page >= self._tabs.GetPageCount():
- return False
-
- if not isinstance(image, types.IntType):
- raise Exception("The image parameter must be an integer, you passed " \
- "%s"%repr(image))
-
- if not self._imageList:
- raise Exception("To use SetPageImage you need to associate an image list " \
- "Using SetImageList or AssignImageList")
-
- if image >= self._imageList.GetImageCount():
- raise Exception("Invalid image index (%d), the image list contains only" \
- " (%d) bitmaps"%(image, self._imageList.GetImageCount()))
-
- if image == -1:
- self.SetPageBitmap(page, wx.NullBitmap)
- return
-
- bitmap = self._imageList.GetBitmap(image)
- self.SetPageBitmap(page, bitmap)
-
-
- def GetPageImage(self, page):
- """
- Returns the image index for the given page.
-
- :param `page`: the given page for which to retrieve the image index.
- """
-
- if page >= self._tabs.GetPageCount():
- return False
-
- bitmap = self.GetPageBitmap(page)
- for indx in xrange(self._imageList.GetImageCount()):
- imgListBmp = self._imageList.GetBitmap(indx)
- if imgListBmp == bitmap:
- return indx
-
- return wx.NOT_FOUND
-
-
- def SetPageTextColour(self, page_idx, colour):
- """
- Sets the tab text colour for the page.
-
- :param `page_idx`: the page index;
- :param `colour`: an instance of `wx.Colour`.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- should_refresh = page_info.text_colour != colour
- page_info.text_colour = colour
-
- # update what's on screen
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- info = ctrl.GetPage(ctrl_idx)
- should_refresh = should_refresh or info.text_colour != colour
- info.text_colour = page_info.text_colour
-
- if should_refresh:
- ctrl.Refresh()
- ctrl.Update()
-
- return True
-
-
- def GetPageTextColour(self, page_idx):
- """
- Returns the tab text colour for the page.
-
- :param `page_idx`: the page index.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return wx.NullColour
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- return page_info.text_colour
-
-
- def AddControlToPage(self, page_idx, control):
- """
- Adds a control inside a tab (not in the tab area).
-
- :param `page_idx`: the page index;
- :param `control`: an instance of `wx.Window`.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- page_info.control = control
-
- # tab height might have changed
- self.UpdateTabCtrlHeight(force=True)
-
- # update what's on screen
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- control.Reparent(ctrl)
-
- info = ctrl.GetPage(ctrl_idx)
- info.control = control
- ctrl.Refresh()
- ctrl.Update()
-
- return True
-
-
- def RemoveControlFromPage(self, page_idx):
- """
- Removes a control from a tab (not from the tab area).
-
- :param `page_idx`: the page index.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- page_info = self._tabs.GetPage(page_idx)
- if page_info.control is None:
- return False
-
- page_info.control.Destroy()
- page_info.control = None
-
- # tab height might have changed
- self.UpdateTabCtrlHeight(force=True)
-
- # update what's on screen
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- info = ctrl.GetPage(ctrl_idx)
- info.control = None
- ctrl.Refresh()
- ctrl.Update()
-
- return True
-
-
- def SetCloseButton(self, page_idx, hasCloseButton):
- """
- Sets whether a tab should display a close button or not.
-
- :param `page_idx`: the page index;
- :param `hasCloseButton`: ``True`` if the page displays a close button.
-
- :note: This can only be called if ``AUI_NB_CLOSE_ON_ALL_TABS`` is specified.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- if self._agwFlags & AUI_NB_CLOSE_ON_ALL_TABS == 0:
- raise Exception("SetCloseButton can only be used with AUI_NB_CLOSE_ON_ALL_TABS style.")
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- page_info.hasCloseButton = hasCloseButton
-
- # update what's on screen
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- info = ctrl.GetPage(ctrl_idx)
- info.hasCloseButton = page_info.hasCloseButton
- ctrl.Refresh()
- ctrl.Update()
-
- return True
-
-
- def HasCloseButton(self, page_idx):
- """
- Returns whether a tab displays a close button or not.
-
- :param `page_idx`: the page index.
-
- :note: This can only be called if ``AUI_NB_CLOSE_ON_ALL_TABS`` is specified.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- page_info = self._tabs.GetPage(page_idx)
- return page_info.hasCloseButton
-
-
- def GetSelection(self):
- """ Returns the index of the currently active page, or -1 if none was selected. """
-
- return self._curpage
-
-
- def GetCurrentPage(self):
- """ Returns the currently active page (not the index), or ``None`` if none was selected. """
-
- if self._curpage >= 0 and self._curpage < self._tabs.GetPageCount():
- return self.GetPage(self._curpage)
-
- return None
-
-
- def EnsureVisible(self, indx):
- """
- Ensures the input page index `indx` is visible.
-
- :param `indx`: the page index.
- """
-
- self._tabs.MakeTabVisible(indx, self)
-
-
- def SetSelection(self, new_page, force=False):
- """
- Sets the page selection. Calling this method will generate a page change event.
-
- :param `new_page`: the index of the new selection;
- :param `force`: whether to force the selection or not.
- """
- wnd = self._tabs.GetWindowFromIdx(new_page)
-
- #Update page access time
- self._tabs.GetPages()[new_page].access_time = datetime.datetime.now()
-
- if not wnd or not self.GetEnabled(new_page):
- return self._curpage
-
- # don't change the page unless necessary
- # however, clicking again on a tab should give it the focus.
- if new_page == self._curpage and not force:
-
- ctrl, ctrl_idx = self.FindTab(wnd)
- if wx.Window.FindFocus() != ctrl:
- ctrl.SetFocus()
-
- return self._curpage
-
- evt = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, self.GetId())
- evt.SetSelection(new_page)
- evt.SetOldSelection(self._curpage)
- evt.SetEventObject(self)
-
- if not self.GetEventHandler().ProcessEvent(evt) or evt.IsAllowed():
-
- old_curpage = self._curpage
- self._curpage = new_page
-
- # program allows the page change
- evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED)
- self.GetEventHandler().ProcessEvent(evt)
-
- if not evt.IsAllowed(): # event is no longer allowed after handler
- return self._curpage
-
- ctrl, ctrl_idx = self.FindTab(wnd)
-
- if ctrl:
- self._tabs.SetActivePage(wnd)
- ctrl.SetActivePage(ctrl_idx)
- self.DoSizing()
- ctrl.DoShowHide()
- ctrl.MakeTabVisible(ctrl_idx, ctrl)
-
- # set fonts
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabctrl = pane.window._tabs
- if tabctrl != ctrl:
- tabctrl.SetSelectedFont(self._normal_font)
- else:
- tabctrl.SetSelectedFont(self._selected_font)
-
- tabctrl.Refresh()
- tabctrl.Update()
-
- # Set the focus to the page if we're not currently focused on the tab.
- # This is Firefox-like behaviour.
- if wnd.IsShownOnScreen() and wx.Window.FindFocus() != ctrl:
- wnd.SetFocus()
-
- return old_curpage
-
- return self._curpage
-
-
- def SetSelectionToWindow(self, win):
- """
- Sets the selection based on the input window `win`.
-
- :param `win`: a `wx.Window` derived window.
- """
-
- idx = self._tabs.GetIdxFromWindow(win)
-
- if idx == wx.NOT_FOUND:
- raise Exception("invalid notebook page")
-
- if not self.GetEnabled(idx):
- return
-
- # since a tab was clicked, let the parent know that we received
- # the focus, even if we will assign that focus immediately
- # to the child tab in the SetSelection call below
- # (the child focus event will also let AuiManager, if any,
- # know that the notebook control has been activated)
-
- parent = self.GetParent()
- if parent:
- eventFocus = wx.ChildFocusEvent(self)
- parent.GetEventHandler().ProcessEvent(eventFocus)
-
- self.SetSelection(idx)
-
-
- def SetSelectionToPage(self, page):
- """
- Sets the selection based on the input page.
-
- :param `page`: an instance of L{AuiNotebookPage}.
- """
-
- self.SetSelectionToWindow(page.window)
-
-
- def GetPageCount(self):
- """ Returns the number of pages in the notebook. """
-
- return self._tabs.GetPageCount()
-
-
- def GetPage(self, page_idx):
- """
- Returns the page specified by the given index.
-
- :param `page_idx`: the page index.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- raise Exception("invalid notebook page")
-
- return self._tabs.GetWindowFromIdx(page_idx)
-
-
- def GetPageInfo(self, page_idx):
- """
- Returns the L{AuiNotebookPage} info structure specified by the given index.
-
- :param `page_idx`: the page index.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- raise Exception("invalid notebook page")
-
- return self._tabs.GetPage(page_idx)
-
-
- def GetEnabled(self, page_idx):
- """
- Returns whether the page specified by the index `page_idx` is enabled.
-
- :param `page_idx`: the page index.
- """
-
- return self._tabs.GetEnabled(page_idx)
-
-
- def EnableTab(self, page_idx, enable=True):
- """
- Enables/disables a page in the notebook.
-
- :param `page_idx`: the page index;
- :param `enable`: ``True`` to enable the page, ``False`` to disable it.
- """
-
- self._tabs.EnableTab(page_idx, enable)
- self.Refresh()
-
-
- def DoSizing(self):
- """ Performs all sizing operations in each tab control. """
-
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
- tabframe.DoSizing()
-
-
- def GetAuiManager(self):
- """ Returns the associated L{AuiManager}. """
-
- return self._mgr
-
-
- def GetActiveTabCtrl(self):
- """
- Returns the active tab control. It is called to determine which control
- gets new windows being added.
- """
-
- if self._curpage >= 0 and self._curpage < self._tabs.GetPageCount():
-
- # find the tab ctrl with the current page
- ctrl, idx = self.FindTab(self._tabs.GetPage(self._curpage).window)
- if ctrl:
- return ctrl
-
- # no current page, just find the first tab ctrl
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
- return tabframe._tabs
-
- # If there is no tabframe at all, create one
- tabframe = TabFrame(self)
- tabframe.SetTabCtrlHeight(self._tab_ctrl_height)
- self._tab_id_counter += 1
- tabframe._tabs = AuiTabCtrl(self, self._tab_id_counter)
-
- tabframe._tabs.SetAGWFlags(self._agwFlags)
- tabframe._tabs.SetArtProvider(self._tabs.GetArtProvider().Clone())
- self._mgr.AddPane(tabframe, framemanager.AuiPaneInfo().Center().CaptionVisible(False).
- PaneBorder((self._agwFlags & AUI_NB_SUB_NOTEBOOK) == 0))
-
- self._mgr.Update()
-
- return tabframe._tabs
-
-
- def FindTab(self, page):
- """
- Finds the tab control that currently contains the window as well
- as the index of the window in the tab control. It returns ``True`` if the
- window was found, otherwise ``False``.
-
- :param `page`: an instance of L{AuiNotebookPage}.
- """
-
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
-
- page_idx = tabframe._tabs.GetIdxFromWindow(page)
-
- if page_idx != -1:
-
- ctrl = tabframe._tabs
- idx = page_idx
- return ctrl, idx
-
- return None, wx.NOT_FOUND
-
-
- def Split(self, page, direction):
- """
- Performs a split operation programmatically.
-
- :param `page`: indicates the page that will be split off. This page will also become
- the active page after the split.
- :param `direction`: specifies where the pane should go, it should be one of the
- following: ``wx.TOP``, ``wx.BOTTOM``, ``wx.LEFT``, or ``wx.RIGHT``.
- """
-
- cli_size = self.GetClientSize()
-
- # get the page's window pointer
- wnd = self.GetPage(page)
- if not wnd:
- return
-
- # notebooks with 1 or less pages can't be split
- if self.GetPageCount() < 2:
- return
-
- # find out which tab control the page currently belongs to
-
- src_tabs, src_idx = self.FindTab(wnd)
- if not src_tabs:
- return
-
- # choose a split size
- if self.GetPageCount() > 2:
- split_size = self.CalculateNewSplitSize()
- else:
- # because there are two panes, always split them
- # equally
- split_size = self.GetClientSize()
- split_size.x /= 2
- split_size.y /= 2
-
- # create a new tab frame
- new_tabs = TabFrame(self)
- new_tabs._rect = wx.RectPS(wx.Point(0, 0), split_size)
- new_tabs.SetTabCtrlHeight(self._tab_ctrl_height)
- self._tab_id_counter += 1
- new_tabs._tabs = AuiTabCtrl(self, self._tab_id_counter)
-
- new_tabs._tabs.SetArtProvider(self._tabs.GetArtProvider().Clone())
- new_tabs._tabs.SetAGWFlags(self._agwFlags)
- dest_tabs = new_tabs._tabs
-
- page_info = src_tabs.GetPage(src_idx)
- if page_info.control:
- self.ReparentControl(page_info.control, dest_tabs)
-
- # create a pane info structure with the information
- # about where the pane should be added
- pane_info = framemanager.AuiPaneInfo().Bottom().CaptionVisible(False)
-
- if direction == wx.LEFT:
-
- pane_info.Left()
- mouse_pt = wx.Point(0, cli_size.y/2)
-
- elif direction == wx.RIGHT:
-
- pane_info.Right()
- mouse_pt = wx.Point(cli_size.x, cli_size.y/2)
-
- elif direction == wx.TOP:
-
- pane_info.Top()
- mouse_pt = wx.Point(cli_size.x/2, 0)
-
- elif direction == wx.BOTTOM:
-
- pane_info.Bottom()
- mouse_pt = wx.Point(cli_size.x/2, cli_size.y)
-
- self._mgr.AddPane(new_tabs, pane_info, mouse_pt)
- self._mgr.Update()
-
- # remove the page from the source tabs
- page_info.active = False
-
- src_tabs.RemovePage(page_info.window)
-
- if src_tabs.GetPageCount() > 0:
- src_tabs.SetActivePage(0)
- src_tabs.DoShowHide()
- src_tabs.Refresh()
-
- # add the page to the destination tabs
- dest_tabs.InsertPage(page_info.window, page_info, 0)
-
- if src_tabs.GetPageCount() == 0:
- self.RemoveEmptyTabFrames()
-
- self.DoSizing()
- dest_tabs.DoShowHide()
- dest_tabs.Refresh()
-
- # force the set selection function reset the selection
- self._curpage = -1
-
- # set the active page to the one we just split off
- self.SetSelectionToPage(page_info)
-
- self.UpdateHintWindowSize()
-
-
- def UnSplit(self):
- """ Restores original view after a tab split. """
-
- self.Freeze()
-
- # remember the tab now selected
- nowSelected = self.GetSelection()
- # select first tab as destination
- self.SetSelection(0)
- # iterate all other tabs
- for idx in xrange(1, self.GetPageCount()):
- # get win reference
- win = self.GetPage(idx)
- # get tab title
- title = self.GetPageText(idx)
- # get page bitmap
- bmp = self.GetPageBitmap(idx)
- # remove from notebook
- self.RemovePage(idx)
- # re-add in the same position so it will tab
- self.InsertPage(idx, win, title, False, bmp)
- # restore orignial selected tab
- self.SetSelection(nowSelected)
-
- self.Thaw()
-
-
- def ReparentControl(self, control, dest_tabs):
- """
- Reparents a control added inside a tab.
-
- :param `control`: an instance of `wx.Window`;
- :param `dest_tabs`: the destination L{AuiTabCtrl}.
- """
-
- control.Hide()
- control.Reparent(dest_tabs)
-
-
- def UnsplitDClick(self, part, sash_size, pos):
- """
- Unsplit the L{AuiNotebook} on sash double-click.
-
- :param `part`: an UI part representing the sash;
- :param `sash_size`: the sash size;
- :param `pos`: the double-click mouse position.
-
- :warning: Due to a bug on MSW, for disabled pages `wx.FindWindowAtPoint`
- returns the wrong window. See http://trac.wxwidgets.org/ticket/2942
- """
-
- if not self._sash_dclick_unsplit:
- # Unsplit not allowed
- return
-
- pos1 = wx.Point(*pos)
- pos2 = wx.Point(*pos)
- if part.orientation == wx.HORIZONTAL:
- pos1.y -= 2*sash_size
- pos2.y += 2*sash_size + self.GetTabCtrlHeight()
- elif part.orientation == wx.VERTICAL:
- pos1.x -= 2*sash_size
- pos2.x += 2*sash_size
- else:
- raise Exception("Invalid UI part orientation")
-
- pos1, pos2 = self.ClientToScreen(pos1), self.ClientToScreen(pos2)
- win1, win2 = wx.FindWindowAtPoint(pos1), wx.FindWindowAtPoint(pos2)
-
- if isinstance(win1, wx.ScrollBar):
- # Hopefully it will work
- pos1 = wx.Point(*pos)
- shift = wx.SystemSettings.GetMetric(wx.SYS_VSCROLL_X) + 2*(sash_size+1)
- if part.orientation == wx.HORIZONTAL:
- pos1.y -= shift
- else:
- pos1.x -= shift
-
- pos1 = self.ClientToScreen(pos1)
- win1 = wx.FindWindowAtPoint(pos1)
-
- if isinstance(win2, wx.ScrollBar):
- pos2 = wx.Point(*pos)
- shift = wx.SystemSettings.GetMetric(wx.SYS_VSCROLL_X) + 2*(sash_size+1)
- if part.orientation == wx.HORIZONTAL:
- pos2.y += shift
- else:
- pos2.x += shift
-
- pos2 = self.ClientToScreen(pos2)
- win2 = wx.FindWindowAtPoint(pos2)
-
- if not win1 or not win2:
- # How did we get here?
- return
-
- if isinstance(win1, AuiNotebook) or isinstance(win2, AuiNotebook):
- # This is a bug on MSW, for disabled pages wx.FindWindowAtPoint
- # returns the wrong window.
- # See http://trac.wxwidgets.org/ticket/2942
- return
-
- tab_frame1, tab_frame2 = self.GetTabFrameFromWindow(win1), self.GetTabFrameFromWindow(win2)
-
- if not tab_frame1 or not tab_frame2:
- return
-
- tab_ctrl_1, tab_ctrl_2 = tab_frame1._tabs, tab_frame2._tabs
-
- if tab_ctrl_1.GetPageCount() > tab_ctrl_2.GetPageCount():
- src_tabs = tab_ctrl_2
- dest_tabs = tab_ctrl_1
- else:
- src_tabs = tab_ctrl_1
- dest_tabs = tab_ctrl_2
-
- selection = -1
- page_count = dest_tabs.GetPageCount()
-
- for page in xrange(src_tabs.GetPageCount()-1, -1, -1):
- # remove the page from the source tabs
- page_info = src_tabs.GetPage(page)
- if page_info.active:
- selection = page_count + page
- src_tabs.RemovePage(page_info.window)
-
- # add the page to the destination tabs
- dest_tabs.AddPage(page_info.window, page_info)
- if page_info.control:
- self.ReparentControl(page_info.control, dest_tabs)
-
- self.RemoveEmptyTabFrames()
-
- dest_tabs.DoShowHide()
- self.DoSizing()
- dest_tabs.Refresh()
- self._mgr.Update()
- if selection > 0:
- wx.CallAfter(dest_tabs.MakeTabVisible, selection, self)
-
-
- def OnSize(self, event):
- """
- Handles the ``wx.EVT_SIZE`` event for L{AuiNotebook}.
-
- :param `event`: a `wx.SizeEvent` event to be processed.
- """
-
- self.UpdateHintWindowSize()
- event.Skip()
-
-
- def OnTabClicked(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_PAGE_CHANGING`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- if self._textCtrl is not None:
- self._textCtrl.StopEditing()
-
- ctrl = event.GetEventObject()
- assert ctrl != None
-
- wnd = ctrl.GetWindowFromIdx(event.GetSelection())
- assert wnd != None
-
- self.SetSelectionToWindow(wnd)
-
-
- def OnTabBgDClick(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_BG_DCLICK`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- if self._textCtrl is not None:
- self._textCtrl.StopEditing()
-
- # notify owner that the tabbar background has been double-clicked
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, self.GetId())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnTabDClick(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_TAB_DCLICK`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- # notify owner that the tabbar background has been double-clicked
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_DCLICK, self.GetId())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- if not self.IsRenamable(event.GetSelection()):
- return
-
- self.EditTab(event.GetSelection())
-
-
- def OnTabBeginDrag(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_BEGIN_DRAG`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- self._last_drag_x = 0
-
-
- def OnTabDragMotion(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_DRAG_MOTION`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- if self._textCtrl is not None:
- self._textCtrl.StopEditing()
-
- screen_pt = wx.GetMousePosition()
- client_pt = self.ScreenToClient(screen_pt)
- zero = wx.Point(0, 0)
-
- src_tabs = event.GetEventObject()
- dest_tabs = self.GetTabCtrlFromPoint(client_pt)
-
- if dest_tabs == src_tabs:
-
- # always hide the hint for inner-tabctrl drag
- self._mgr.HideHint()
-
- # if tab moving is not allowed, leave
- if not self._agwFlags & AUI_NB_TAB_MOVE:
- return
-
- pt = dest_tabs.ScreenToClient(screen_pt)
-
- # this is an inner-tab drag/reposition
- dest_location_tab = dest_tabs.TabHitTest(pt.x, pt.y)
-
- if dest_location_tab:
-
- src_idx = event.GetSelection()
- dest_idx = dest_tabs.GetIdxFromWindow(dest_location_tab)
-
- # prevent jumpy drag
- if (src_idx == dest_idx) or dest_idx == -1 or \
- (src_idx > dest_idx and self._last_drag_x <= pt.x) or \
- (src_idx < dest_idx and self._last_drag_x >= pt.x):
-
- self._last_drag_x = pt.x
- return
-
- src_tab = dest_tabs.GetWindowFromIdx(src_idx)
- dest_tabs.MovePage(src_tab, dest_idx)
- self._tabs.MovePage(self._tabs.GetPage(src_idx).window, dest_idx)
- dest_tabs.SetActivePage(dest_idx)
- dest_tabs.DoShowHide()
- dest_tabs.Refresh()
- self._last_drag_x = pt.x
-
- return
-
- # if external drag is allowed, check if the tab is being dragged
- # over a different AuiNotebook control
- if self._agwFlags & AUI_NB_TAB_EXTERNAL_MOVE:
-
- tab_ctrl = wx.FindWindowAtPoint(screen_pt)
-
- # if we aren't over any window, stop here
- if not tab_ctrl:
- if self._agwFlags & AUI_NB_TAB_FLOAT:
- if self.IsMouseWellOutsideWindow():
- hintRect = wx.RectPS(screen_pt, (400, 300))
- # Use CallAfter so we overwrite the hint that might be
- # shown by our superclass:
- wx.CallAfter(self._mgr.ShowHint, hintRect)
- return
-
- # make sure we are not over the hint window
- if not isinstance(tab_ctrl, wx.Frame):
- while tab_ctrl:
- if isinstance(tab_ctrl, AuiTabCtrl):
- break
-
- tab_ctrl = tab_ctrl.GetParent()
-
- if tab_ctrl:
- nb = tab_ctrl.GetParent()
-
- if nb != self:
-
- hint_rect = tab_ctrl.GetClientRect()
- hint_rect.x, hint_rect.y = tab_ctrl.ClientToScreenXY(hint_rect.x, hint_rect.y)
- self._mgr.ShowHint(hint_rect)
- return
-
- else:
-
- if not dest_tabs:
- # we are either over a hint window, or not over a tab
- # window, and there is no where to drag to, so exit
- return
-
- if self._agwFlags & AUI_NB_TAB_FLOAT:
- if self.IsMouseWellOutsideWindow():
- hintRect = wx.RectPS(screen_pt, (400, 300))
- # Use CallAfter so we overwrite the hint that might be
- # shown by our superclass:
- wx.CallAfter(self._mgr.ShowHint, hintRect)
- return
-
- # if there are less than two panes, split can't happen, so leave
- if self._tabs.GetPageCount() < 2:
- return
-
- # if tab moving is not allowed, leave
- if not self._agwFlags & AUI_NB_TAB_SPLIT:
- return
-
- if dest_tabs:
-
- hint_rect = dest_tabs.GetRect()
- hint_rect.x, hint_rect.y = self.ClientToScreenXY(hint_rect.x, hint_rect.y)
- self._mgr.ShowHint(hint_rect)
-
- else:
- rect = self._mgr.CalculateHintRect(self._dummy_wnd, client_pt, zero)
- if rect.IsEmpty():
- self._mgr.HideHint()
- return
-
- hit_wnd = wx.FindWindowAtPoint(screen_pt)
- if hit_wnd and not isinstance(hit_wnd, AuiNotebook):
- tab_frame = self.GetTabFrameFromWindow(hit_wnd)
- if tab_frame:
- hint_rect = wx.Rect(*tab_frame._rect)
- hint_rect.x, hint_rect.y = self.ClientToScreenXY(hint_rect.x, hint_rect.y)
- rect.Intersect(hint_rect)
- self._mgr.ShowHint(rect)
- else:
- self._mgr.DrawHintRect(self._dummy_wnd, client_pt, zero)
- else:
- self._mgr.DrawHintRect(self._dummy_wnd, client_pt, zero)
-
-
- def OnTabEndDrag(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_END_DRAG`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- self._mgr.HideHint()
-
- src_tabs = event.GetEventObject()
- if not src_tabs:
- raise Exception("no source object?")
-
- # get the mouse position, which will be used to determine the drop point
- mouse_screen_pt = wx.GetMousePosition()
- mouse_client_pt = self.ScreenToClient(mouse_screen_pt)
-
- # check for an external move
- if self._agwFlags & AUI_NB_TAB_EXTERNAL_MOVE:
- tab_ctrl = wx.FindWindowAtPoint(mouse_screen_pt)
-
- while tab_ctrl:
-
- if isinstance(tab_ctrl, AuiTabCtrl):
- break
-
- tab_ctrl = tab_ctrl.GetParent()
-
- if tab_ctrl:
-
- nb = tab_ctrl.GetParent()
-
- if nb != self:
-
- # find out from the destination control
- # if it's ok to drop this tab here
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, self.GetId())
- e.SetSelection(event.GetSelection())
- e.SetOldSelection(event.GetSelection())
- e.SetEventObject(self)
- e.SetDragSource(self)
- e.Veto() # dropping must be explicitly approved by control owner
-
- nb.GetEventHandler().ProcessEvent(e)
-
- if not e.IsAllowed():
-
- # no answer or negative answer
- self._mgr.HideHint()
- return
-
- # drop was allowed
- src_idx = event.GetSelection()
- src_page = src_tabs.GetWindowFromIdx(src_idx)
-
- # Check that it's not an impossible parent relationship
- p = nb
- while p and not p.IsTopLevel():
- if p == src_page:
- return
-
- p = p.GetParent()
-
- # get main index of the page
- main_idx = self._tabs.GetIdxFromWindow(src_page)
- if main_idx == wx.NOT_FOUND:
- raise Exception("no source page?")
-
- # make a copy of the page info
- page_info = self._tabs.GetPage(main_idx)
-
- # remove the page from the source notebook
- self.RemovePage(main_idx)
-
- # reparent the page
- src_page.Reparent(nb)
-
- # Reparent the control in a tab (if any)
- if page_info.control:
- self.ReparentControl(page_info.control, tab_ctrl)
-
- # find out the insert idx
- dest_tabs = tab_ctrl
- pt = dest_tabs.ScreenToClient(mouse_screen_pt)
-
- target = dest_tabs.TabHitTest(pt.x, pt.y)
- insert_idx = -1
- if target:
- insert_idx = dest_tabs.GetIdxFromWindow(target)
-
- # add the page to the new notebook
- if insert_idx == -1:
- insert_idx = dest_tabs.GetPageCount()
-
- dest_tabs.InsertPage(page_info.window, page_info, insert_idx)
- nb._tabs.AddPage(page_info.window, page_info)
-
- nb.DoSizing()
- dest_tabs.DoShowHide()
- dest_tabs.Refresh()
-
- # set the selection in the destination tab control
- nb.SetSelectionToPage(page_info)
-
- # notify owner that the tab has been dragged
- e2 = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, self.GetId())
- e2.SetSelection(event.GetSelection())
- e2.SetOldSelection(event.GetSelection())
- e2.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e2)
-
- # notify the target notebook that the tab has been dragged
- e3 = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, nb.GetId())
- e3.SetSelection(insert_idx)
- e3.SetOldSelection(insert_idx)
- e3.SetEventObject(nb)
- nb.GetEventHandler().ProcessEvent(e3)
-
- return
-
- if self._agwFlags & AUI_NB_TAB_FLOAT:
- self._mgr.HideHint()
- if self.IsMouseWellOutsideWindow():
- # Use CallAfter so we our superclass can deal with the event first
- wx.CallAfter(self.FloatPage, self.GetSelection())
- event.Skip()
- return
-
- # only perform a tab split if it's allowed
- dest_tabs = None
-
- if self._agwFlags & AUI_NB_TAB_SPLIT and self._tabs.GetPageCount() >= 2:
-
- # If the pointer is in an existing tab frame, do a tab insert
- hit_wnd = wx.FindWindowAtPoint(mouse_screen_pt)
- tab_frame = self.GetTabFrameFromTabCtrl(hit_wnd)
- insert_idx = -1
-
- if tab_frame:
-
- dest_tabs = tab_frame._tabs
-
- if dest_tabs == src_tabs:
- return
-
- pt = dest_tabs.ScreenToClient(mouse_screen_pt)
- target = dest_tabs.TabHitTest(pt.x, pt.y)
-
- if target:
- insert_idx = dest_tabs.GetIdxFromWindow(target)
-
- else:
-
- zero = wx.Point(0, 0)
- rect = self._mgr.CalculateHintRect(self._dummy_wnd, mouse_client_pt, zero)
-
- if rect.IsEmpty():
- # there is no suitable drop location here, exit out
- return
-
- # If there is no tabframe at all, create one
- new_tabs = TabFrame(self)
- new_tabs._rect = wx.RectPS(wx.Point(0, 0), self.CalculateNewSplitSize())
- new_tabs.SetTabCtrlHeight(self._tab_ctrl_height)
- self._tab_id_counter += 1
- new_tabs._tabs = AuiTabCtrl(self, self._tab_id_counter)
- new_tabs._tabs.SetArtProvider(self._tabs.GetArtProvider().Clone())
- new_tabs._tabs.SetAGWFlags(self._agwFlags)
-
- self._mgr.AddPane(new_tabs, framemanager.AuiPaneInfo().Bottom().CaptionVisible(False), mouse_client_pt)
- self._mgr.Update()
- dest_tabs = new_tabs._tabs
-
- # remove the page from the source tabs
- page_info = src_tabs.GetPage(event.GetSelection())
-
- if page_info.control:
- self.ReparentControl(page_info.control, dest_tabs)
-
- page_info.active = False
- src_tabs.RemovePage(page_info.window)
-
- if src_tabs.GetPageCount() > 0:
- src_tabs.SetActivePage(0)
- src_tabs.DoShowHide()
- src_tabs.Refresh()
-
- # add the page to the destination tabs
- if insert_idx == -1:
- insert_idx = dest_tabs.GetPageCount()
-
- dest_tabs.InsertPage(page_info.window, page_info, insert_idx)
-
- if src_tabs.GetPageCount() == 0:
- self.RemoveEmptyTabFrames()
-
- self.DoSizing()
- dest_tabs.DoShowHide()
- dest_tabs.Refresh()
-
- # force the set selection function reset the selection
- self._curpage = -1
-
- # set the active page to the one we just split off
- self.SetSelectionToPage(page_info)
-
- self.UpdateHintWindowSize()
-
- # notify owner that the tab has been dragged
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, self.GetId())
- e.SetSelection(event.GetSelection())
- e.SetOldSelection(event.GetSelection())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnTabCancelDrag(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_CANCEL_DRAG`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- self._mgr.HideHint()
-
- src_tabs = event.GetEventObject()
- if not src_tabs:
- raise Exception("no source object?")
-
-
- def IsMouseWellOutsideWindow(self):
- """ Returns whether the mouse is well outside the L{AuiNotebook} screen rectangle. """
-
- screen_rect = self.GetScreenRect()
- screen_rect.Inflate(50, 50)
-
- return not screen_rect.Contains(wx.GetMousePosition())
-
-
- def FloatPage(self, page_index):
- """
- Float the page in `page_index` by reparenting it to a floating frame.
-
- :param `page_index`: the index of the page to be floated.
-
- :warning: When the notebook is more or less full screen, tabs cannot be dragged far
- enough outside of the notebook to become floating pages.
- """
-
- root_manager = framemanager.GetManager(self)
- page_title = self.GetPageText(page_index)
- page_contents = self.GetPage(page_index)
- page_bitmap = self.GetPageBitmap(page_index)
- text_colour = self.GetPageTextColour(page_index)
- info = self.GetPageInfo(page_index)
-
- if root_manager and root_manager != self._mgr:
- root_manager = framemanager.GetManager(self)
-
- if hasattr(page_contents, "__floating_size__"):
- floating_size = wx.Size(*page_contents.__floating_size__)
- else:
- floating_size = page_contents.GetBestSize()
- if floating_size == wx.DefaultSize:
- floating_size = wx.Size(300, 200)
-
- page_contents.__page_index__ = page_index
- page_contents.__aui_notebook__ = self
- page_contents.__text_colour__ = text_colour
- page_contents.__control__ = info.control
-
- if info.control:
- info.control.Reparent(page_contents)
- info.control.Hide()
- info.control = None
-
- self.RemovePage(page_index)
- self.RemoveEmptyTabFrames()
-
- pane_info = framemanager.AuiPaneInfo().Float().FloatingPosition(wx.GetMousePosition()). \
- FloatingSize(floating_size).BestSize(floating_size).Name("__floating__%s"%page_title). \
- Caption(page_title).Icon(page_bitmap)
- root_manager.AddPane(page_contents, pane_info)
- root_manager.Bind(framemanager.EVT_AUI_PANE_CLOSE, self.OnCloseFloatingPage)
- self.GetActiveTabCtrl().DoShowHide()
- self.DoSizing()
- root_manager.Update()
-
- else:
- frame = wx.Frame(self, title=page_title,
- style=wx.DEFAULT_FRAME_STYLE|wx.FRAME_TOOL_WINDOW|
- wx.FRAME_FLOAT_ON_PARENT | wx.FRAME_NO_TASKBAR)
-
- if info.control:
- info.control.Reparent(frame)
- info.control.Hide()
-
- frame.bitmap = page_bitmap
- frame.page_index = page_index
- frame.text_colour = text_colour
- frame.control = info.control
- page_contents.Reparent(frame)
- frame.Bind(wx.EVT_CLOSE, self.OnCloseFloatingPage)
- frame.Move(wx.GetMousePosition())
- frame.Show()
- self.RemovePage(page_index)
-
- self.RemoveEmptyTabFrames()
-
- wx.CallAfter(self.RemoveEmptyTabFrames)
-
-
- def OnCloseFloatingPage(self, event):
- """
- Handles the ``wx.EVT_CLOSE`` event for a floating page in L{AuiNotebook}.
-
- :param `event`: a `wx.CloseEvent` event to be processed.
- """
-
- root_manager = framemanager.GetManager(self)
- if root_manager and root_manager != self._mgr:
- pane = event.pane
- if pane.name.startswith("__floating__"):
- self.ReDockPage(pane)
- return
-
- event.Skip()
- else:
- event.Skip()
- frame = event.GetEventObject()
- page_title = frame.GetTitle()
- page_contents = list(frame.GetChildren())[-1]
- page_contents.Reparent(self)
- self.InsertPage(frame.page_index, page_contents, page_title, select=True, bitmap=frame.bitmap, control=frame.control)
-
- if frame.control:
- src_tabs, idx = self.FindTab(page_contents)
- frame.control.Reparent(src_tabs)
- frame.control.Hide()
- frame.control = None
-
- self.SetPageTextColour(frame.page_index, frame.text_colour)
-
-
- def ReDockPage(self, pane):
- """
- Re-docks a floating L{AuiNotebook} tab in the original position, when possible.
-
- :param `pane`: an instance of L{framemanager.AuiPaneInfo}.
- """
-
- root_manager = framemanager.GetManager(self)
-
- pane.window.__floating_size__ = wx.Size(*pane.floating_size)
- page_index = pane.window.__page_index__
- text_colour = pane.window.__text_colour__
- control = pane.window.__control__
-
- root_manager.DetachPane(pane.window)
- self.InsertPage(page_index, pane.window, pane.caption, True, pane.icon, control=control)
-
- self.SetPageTextColour(page_index, text_colour)
- self.GetActiveTabCtrl().DoShowHide()
- self.DoSizing()
- if control:
- self.UpdateTabCtrlHeight(force=True)
-
- self._mgr.Update()
- root_manager.Update()
-
-
- def GetTabCtrlFromPoint(self, pt):
- """
- Returns the tab control at the specified point.
-
- :param `pt`: a `wx.Point` object.
- """
-
- # if we've just removed the last tab from the source
- # tab set, the remove the tab control completely
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
- if tabframe._tab_rect.Contains(pt):
- return tabframe._tabs
-
- return None
-
-
- def GetTabFrameFromTabCtrl(self, tab_ctrl):
- """
- Returns the tab frame associated with a tab control.
-
- :param `tab_ctrl`: an instance of L{AuiTabCtrl}.
- """
-
- # if we've just removed the last tab from the source
- # tab set, the remove the tab control completely
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
- if tabframe._tabs == tab_ctrl:
- return tabframe
-
- return None
-
-
- def GetTabFrameFromWindow(self, wnd):
- """
- Returns the tab frame associated with a window.
-
- :param `wnd`: an instance of `wx.Window`.
- """
-
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- tabframe = pane.window
- for page in tabframe._tabs.GetPages():
- if wnd == page.window:
- return tabframe
-
- return None
-
-
- def RemoveEmptyTabFrames(self):
- """ Removes all the empty tab frames. """
-
- # if we've just removed the last tab from the source
- # tab set, the remove the tab control completely
- all_panes = self._mgr.GetAllPanes()
-
- for indx in xrange(len(all_panes)-1, -1, -1):
- pane = all_panes[indx]
- if pane.name == "dummy":
- continue
-
- tab_frame = pane.window
- if tab_frame._tabs.GetPageCount() == 0:
- self._mgr.DetachPane(tab_frame)
- tab_frame._tabs.Destroy()
- tab_frame._tabs = None
- del tab_frame
-
- # check to see if there is still a center pane
- # if there isn't, make a frame the center pane
- first_good = None
- center_found = False
-
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
-
- if pane.dock_direction == AUI_DOCK_CENTRE:
- center_found = True
- if not first_good:
- first_good = pane.window
-
- if not center_found and first_good:
- self._mgr.GetPane(first_good).Centre()
-
- if not self.IsBeingDeleted():
- self._mgr.Update()
-
-
- def OnChildFocusNotebook(self, event):
- """
- Handles the ``wx.EVT_CHILD_FOCUS`` event for L{AuiNotebook}.
-
- :param `event`: a `wx.ChildFocusEvent` event to be processed.
- """
-
- # if we're dragging a tab, don't change the current selection.
- # This code prevents a bug that used to happen when the hint window
- # was hidden. In the bug, the focus would return to the notebook
- # child, which would then enter this handler and call
- # SetSelection, which is not desired turn tab dragging.
-
- event.Skip()
-
- all_panes = self._mgr.GetAllPanes()
- for pane in all_panes:
- if pane.name == "dummy":
- continue
- tabframe = pane.window
- if tabframe._tabs.IsDragging():
- return
-
-## # change the tab selection to the child
-## # which was focused
-## idx = self._tabs.GetIdxFromWindow(event.GetWindow())
-## if idx != -1 and idx != self._curpage:
-## self.SetSelection(idx)
-
-
- def SetNavigatorIcon(self, bmp):
- """
- Sets the icon used by the L{TabNavigatorWindow}.
-
- :param `bmp`: an instance of `wx.Bitmap`.
- """
-
- if isinstance(bmp, wx.Bitmap) and bmp.IsOk():
- # Make sure image is proper size
- if bmp.GetSize() != (16, 16):
- img = bmp.ConvertToImage()
- img.Rescale(16, 16, wx.IMAGE_QUALITY_HIGH)
- bmp = wx.BitmapFromImage(img)
- self._naviIcon = bmp
- else:
- raise TypeError, "SetNavigatorIcon requires a valid bitmap"
-
-
- def OnNavigationKeyNotebook(self, event):
- """
- Handles the ``wx.EVT_NAVIGATION_KEY`` event for L{AuiNotebook}.
-
- :param `event`: a `wx.NavigationKeyEvent` event to be processed.
- """
-
- if event.IsWindowChange():
- if self._agwFlags & AUI_NB_SMART_TABS:
- if not self._popupWin:
- self._popupWin = TabNavigatorWindow(self, self._naviIcon)
- self._popupWin.SetReturnCode(wx.ID_OK)
- self._popupWin.ShowModal()
- idx = self._popupWin.GetSelectedPage()
- self._popupWin.Destroy()
- self._popupWin = None
- # Need to do CallAfter so that the selection and its
- # associated events get processed outside the context of
- # this key event. Not doing so causes odd issues with the
- # window focus under certain use cases on Windows.
- wx.CallAfter(self.SetSelection, idx, True)
- else:
- # a dialog is already opened
- self._popupWin.OnNavigationKey(event)
- return
- else:
- # change pages
- # FIXME: the problem with this is that if we have a split notebook,
- # we selection may go all over the place.
- self.AdvanceSelection(event.GetDirection())
-
- else:
- # we get this event in 3 cases
- #
- # a) one of our pages might have generated it because the user TABbed
- # out from it in which case we should propagate the event upwards and
- # our parent will take care of setting the focus to prev/next sibling
- #
- # or
- #
- # b) the parent panel wants to give the focus to us so that we
- # forward it to our selected page. We can't deal with this in
- # OnSetFocus() because we don't know which direction the focus came
- # from in this case and so can't choose between setting the focus to
- # first or last panel child
- #
- # or
- #
- # c) we ourselves (see MSWTranslateMessage) generated the event
- #
- parent = self.GetParent()
-
- # the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
- isFromParent = event.GetEventObject() == parent
- isFromSelf = event.GetEventObject() == self
-
- if isFromParent or isFromSelf:
-
- # no, it doesn't come from child, case (b) or (c): forward to a
- # page but only if direction is backwards (TAB) or from ourselves,
- if self.GetSelection() != wx.NOT_FOUND and (not event.GetDirection() or isFromSelf):
-
- # so that the page knows that the event comes from it's parent
- # and is being propagated downwards
- event.SetEventObject(self)
-
- page = self.GetPage(self.GetSelection())
- if not page.GetEventHandler().ProcessEvent(event):
- page.SetFocus()
-
- #else: page manages focus inside it itself
-
- else: # otherwise set the focus to the notebook itself
-
- self.SetFocus()
-
- else:
-
- # send this event back for the 'wraparound' focus.
- winFocus = event.GetCurrentFocus()
-
- if winFocus:
- event.SetEventObject(self)
- winFocus.GetEventHandler().ProcessEvent(event)
-
-
- def OnTabButton(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_BUTTON`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- button_id = event.GetInt()
-
- if button_id == AUI_BUTTON_CLOSE:
-
- selection = event.GetSelection()
-
- if selection == -1:
-
- # if the close button is to the right, use the active
- # page selection to determine which page to close
- selection = tabs.GetActivePage()
-
- if selection == -1 or not tabs.GetEnabled(selection):
- return
-
- if selection != -1:
-
- close_wnd = tabs.GetWindowFromIdx(selection)
-
- if close_wnd.GetName() == "__fake__page__":
- # This is a notebook preview
- previous_active, page_status = close_wnd.__previousStatus
- for page, status in zip(tabs.GetPages(), page_status):
- page.enabled = status
-
- main_idx = self._tabs.GetIdxFromWindow(close_wnd)
- self.DeletePage(main_idx)
-
- if previous_active >= 0:
- tabs.SetActivePage(previous_active)
- page_count = tabs.GetPageCount()
- selection = -1
-
- for page in xrange(page_count):
- # remove the page from the source tabs
- page_info = tabs.GetPage(page)
- if page_info.active:
- selection = page
- break
-
- tabs.DoShowHide()
- self.DoSizing()
- tabs.Refresh()
-
- if selection >= 0:
- wx.CallAfter(tabs.MakeTabVisible, selection, self)
-
- # Don't fire the event
- return
-
- # ask owner if it's ok to close the tab
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, self.GetId())
- idx = self._tabs.GetIdxFromWindow(close_wnd)
- e.SetSelection(idx)
- e.SetOldSelection(event.GetSelection())
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
- if not e.IsAllowed():
- return
-
- if repr(close_wnd.__class__).find("AuiMDIChildFrame") >= 0:
- close_wnd.Close()
-
- else:
- main_idx = self._tabs.GetIdxFromWindow(close_wnd)
- self.DeletePage(main_idx)
-
- # notify owner that the tab has been closed
- e2 = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, self.GetId())
- e2.SetSelection(idx)
- e2.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e2)
-
- if self.GetPageCount() == 0:
- mgr = self.GetAuiManager()
- win = mgr.GetManagedWindow()
- win.SendSizeEvent()
-
-
- def OnTabMiddleDown(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- # patch event through to owner
- wnd = tabs.GetWindowFromIdx(event.GetSelection())
-
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, self.GetId())
- e.SetSelection(self._tabs.GetIdxFromWindow(wnd))
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnTabMiddleUp(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_TAB_MIDDLE_UP`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- # if the AUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
- # click should act like a tab close action. However, first
- # give the owner an opportunity to handle the middle up event
- # for custom action
-
- wnd = tabs.GetWindowFromIdx(event.GetSelection())
-
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, self.GetId())
- e.SetSelection(self._tabs.GetIdxFromWindow(wnd))
- e.SetEventObject(self)
- if self.GetEventHandler().ProcessEvent(e):
- return
- if not e.IsAllowed():
- return
-
- # check if we are supposed to close on middle-up
- if self._agwFlags & AUI_NB_MIDDLE_CLICK_CLOSE == 0:
- return
-
- # simulate the user pressing the close button on the tab
- event.SetInt(AUI_BUTTON_CLOSE)
- self.OnTabButton(event)
-
-
- def OnTabRightDown(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_TAB_RIGHT_DOWN`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- # patch event through to owner
- wnd = tabs.GetWindowFromIdx(event.GetSelection())
-
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, self.GetId())
- e.SetSelection(self._tabs.GetIdxFromWindow(wnd))
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def OnTabRightUp(self, event):
- """
- Handles the ``EVT_AUINOTEBOOK_TAB_RIGHT_UP`` event for L{AuiNotebook}.
-
- :param `event`: a L{AuiNotebookEvent} event to be processed.
- """
-
- tabs = event.GetEventObject()
- if not tabs.GetEnabled(event.GetSelection()):
- return
-
- # patch event through to owner
- wnd = tabs.GetWindowFromIdx(event.GetSelection())
-
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, self.GetId())
- e.SetSelection(self._tabs.GetIdxFromWindow(wnd))
- e.SetEventObject(self)
- self.GetEventHandler().ProcessEvent(e)
-
-
- def SetNormalFont(self, font):
- """
- Sets the normal font for drawing tab labels.
-
- :param `font`: a `wx.Font` object.
- """
-
- self._normal_font = font
- self.GetArtProvider().SetNormalFont(font)
-
-
- def SetSelectedFont(self, font):
- """
- Sets the selected tab font for drawing tab labels.
-
- :param `font`: a `wx.Font` object.
- """
-
- self._selected_font = font
- self.GetArtProvider().SetSelectedFont(font)
-
-
- def SetMeasuringFont(self, font):
- """
- Sets the font for calculating text measurements.
-
- :param `font`: a `wx.Font` object.
- """
-
- self.GetArtProvider().SetMeasuringFont(font)
-
-
- def SetFont(self, font):
- """
- Sets the tab font.
-
- :param `font`: a `wx.Font` object.
-
- :note: Overridden from `wx.PyPanel`.
- """
-
- wx.PyPanel.SetFont(self, font)
-
- selectedFont = wx.Font(font.GetPointSize(), font.GetFamily(),
- font.GetStyle(), wx.BOLD, font.GetUnderlined(),
- font.GetFaceName(), font.GetEncoding())
-
- self.SetNormalFont(font)
- self.SetSelectedFont(selectedFont)
- self.SetMeasuringFont(selectedFont)
-
- # Recalculate tab container size based on new font
- self.UpdateTabCtrlHeight(force=False)
- self.DoSizing()
-
- return True
-
-
- def GetTabCtrlHeight(self):
- """ Returns the tab control height. """
-
- return self._tab_ctrl_height
-
-
- def GetHeightForPageHeight(self, pageHeight):
- """
- Gets the height of the notebook for a given page height.
-
- :param `pageHeight`: the given page height.
- """
-
- self.UpdateTabCtrlHeight()
-
- tabCtrlHeight = self.GetTabCtrlHeight()
- decorHeight = 2
- return tabCtrlHeight + pageHeight + decorHeight
-
-
- def AdvanceSelection(self, forward=True, wrap=True):
- """
- Cycles through the tabs.
-
- :param `forward`: whether to advance forward or backward;
- :param `wrap`: ``True`` to return to the first tab if we reach the last tab.
-
- :note: The call to this function generates the page changing events.
- """
-
- tabCtrl = self.GetActiveTabCtrl()
- newPage = -1
-
- focusWin = tabCtrl.FindFocus()
- activePage = tabCtrl.GetActivePage()
- lenPages = len(tabCtrl.GetPages())
-
- if lenPages == 1:
- return False
-
- if forward:
- if lenPages > 1:
-
- if activePage == -1 or activePage == lenPages - 1:
- if not wrap:
- return False
-
- newPage = 0
-
- elif activePage < lenPages - 1:
- newPage = activePage + 1
-
- else:
-
- if lenPages > 1:
- if activePage == -1 or activePage == 0:
- if not wrap:
- return False
-
- newPage = lenPages - 1
-
- elif activePage > 0:
- newPage = activePage - 1
-
-
- if newPage != -1:
- if not self.GetEnabled(newPage):
- return False
-
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl.GetId())
- e.SetSelection(newPage)
- e.SetOldSelection(activePage)
- e.SetEventObject(tabCtrl)
- self.GetEventHandler().ProcessEvent(e)
-
-## if focusWin:
-## focusWin.SetFocus()
-
- return True
-
-
- def ShowWindowMenu(self):
- """
- Shows the window menu for the active tab control associated with this
- notebook, and returns ``True`` if a selection was made.
- """
-
- tabCtrl = self.GetActiveTabCtrl()
- idx = tabCtrl.GetArtProvider().ShowDropDown(tabCtrl, tabCtrl.GetPages(), tabCtrl.GetActivePage())
-
- if not self.GetEnabled(idx):
- return False
-
- if idx != -1:
- e = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl.GetId())
- e.SetSelection(idx)
- e.SetOldSelection(tabCtrl.GetActivePage())
- e.SetEventObject(tabCtrl)
- self.GetEventHandler().ProcessEvent(e)
-
- return True
-
- else:
-
- return False
-
-
- def AddTabAreaButton(self, id, location, normal_bitmap=wx.NullBitmap, disabled_bitmap=wx.NullBitmap):
- """
- Adds a button in the tab area.
-
- :param `id`: the button identifier. This can be one of the following:
-
- ============================== =================================
- Button Identifier Description
- ============================== =================================
- ``AUI_BUTTON_CLOSE`` Shows a close button on the tab area
- ``AUI_BUTTON_WINDOWLIST`` Shows a window list button on the tab area
- ``AUI_BUTTON_LEFT`` Shows a left button on the tab area
- ``AUI_BUTTON_RIGHT`` Shows a right button on the tab area
- ============================== =================================
-
- :param `location`: the button location. Can be ``wx.LEFT`` or ``wx.RIGHT``;
- :param `normal_bitmap`: the bitmap for an enabled tab;
- :param `disabled_bitmap`: the bitmap for a disabled tab.
- """
-
- active_tabctrl = self.GetActiveTabCtrl()
- active_tabctrl.AddButton(id, location, normal_bitmap, disabled_bitmap)
-
-
- def RemoveTabAreaButton(self, id):
- """
- Removes a button from the tab area.
-
- :param `id`: the button identifier. See L{AddTabAreaButton} for a list of button identifiers.
-
- :see: L{AddTabAreaButton}
- """
-
- active_tabctrl = self.GetActiveTabCtrl()
- active_tabctrl.RemoveButton(id)
-
-
- def HasMultiplePages(self):
- """
- This method should be overridden to return ``True`` if this window has multiple pages. All
- standard class with multiple pages such as `wx.Notebook`, `wx.Listbook` and `wx.Treebook`
- already override it to return ``True`` and user-defined classes with similar behaviour
- should do it as well to allow the library to handle such windows appropriately.
-
- :note: Overridden from `wx.PyPanel`.
- """
-
- return True
-
-
- def GetDefaultBorder(self):
- """ Returns the default border style for L{AuiNotebook}. """
-
- return wx.BORDER_NONE
-
-
- def NotebookPreview(self, thumbnail_size=200):
- """
- Generates a preview of all the pages in the notebook (MSW and GTK only).
-
- :param `thumbnail_size`: the maximum size of every page thumbnail.
-
- :note: this functionality is currently unavailable on wxMac.
- """
-
- if wx.Platform == "__WXMAC__":
- return False
-
- tabCtrl = self.GetActiveTabCtrl()
- activePage = tabCtrl.GetActivePage()
- pages = tabCtrl.GetPages()
-
- pageStatus, pageText = [], []
-
- for indx, page in enumerate(pages):
-
- pageStatus.append(page.enabled)
-
- if not page.enabled:
- continue
-
- self.SetSelectionToPage(page)
- pageText.append(page.caption)
-
- rect = page.window.GetScreenRect()
- bmp = RescaleScreenShot(TakeScreenShot(rect), thumbnail_size)
-
- page.enabled = False
- if indx == 0:
- il = wx.ImageList(bmp.GetWidth(), bmp.GetHeight(), True)
-
- il.Add(bmp)
-
- # create the list control
- listCtrl = wx.ListCtrl(self, style=wx.LC_ICON|wx.LC_AUTOARRANGE|wx.LC_HRULES|wx.LC_VRULES,
- name="__fake__page__")
-
- # assign the image list to it
- listCtrl.AssignImageList(il, wx.IMAGE_LIST_NORMAL)
- listCtrl.__previousStatus = [activePage, pageStatus]
-
- # create some items for the list
- for indx, text in enumerate(pageText):
- listCtrl.InsertImageStringItem(10000, text, indx)
-
- self.AddPage(listCtrl, "AuiNotebook Preview", True, bitmap=auinotebook_preview.GetBitmap(), disabled_bitmap=wx.NullBitmap)
- return True
-
-
- def SetRenamable(self, page_idx, renamable):
- """
- Sets whether a tab can be renamed via a left double-click or not.
-
- :param `page_idx`: the page index;
- :param `renamable`: ``True`` if the page can be renamed.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- # update our own tab catalog
- page_info = self._tabs.GetPage(page_idx)
- page_info.renamable = renamable
-
- # update what's on screen
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- info = ctrl.GetPage(ctrl_idx)
- info.renamable = page_info.renamable
-
- return True
-
-
- def IsRenamable(self, page_idx):
- """
- Returns whether a tab can be renamed or not.
-
- :param `page_idx`: the page index.
-
- :returns: ``True`` is a page can be renamed, ``False`` otherwise.
- """
-
- if page_idx >= self._tabs.GetPageCount():
- return False
-
- page_info = self._tabs.GetPage(page_idx)
- return page_info.renamable
-
-
- def OnRenameCancelled(self, page_index):
- """
- Called by L{TabTextCtrl}, to cancel the changes and to send the
- `EVT_AUINOTEBOOK_END_LABEL_EDIT` event.
-
- :param `page_index`: the page index in the notebook.
- """
-
- # let owner know that the edit was cancelled
- evt = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_END_LABEL_EDIT, self.GetId())
-
- evt.SetSelection(page_index)
- evt.SetEventObject(self)
- evt.SetLabel("")
- evt.SetEditCanceled(True)
- self.GetEventHandler().ProcessEvent(evt)
-
-
- def OnRenameAccept(self, page_index, value):
- """
- Called by L{TabTextCtrl}, to accept the changes and to send the
- `EVT_AUINOTEBOOK_END_LABEL_EDIT` event.
-
- :param `page_index`: the page index in the notebook;
- :param `value`: the new label for the tab.
- """
-
- evt = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_END_LABEL_EDIT, self.GetId())
- evt.SetSelection(page_index)
- evt.SetEventObject(self)
- evt.SetLabel(value)
- evt.SetEditCanceled(False)
-
- return not self.GetEventHandler().ProcessEvent(evt) or evt.IsAllowed()
-
-
- def ResetTextControl(self):
- """ Called by L{TabTextCtrl} when it marks itself for deletion. """
-
- if not self._textCtrl:
- return
-
- self._textCtrl.Destroy()
- self._textCtrl = None
-
- # tab height might have changed
- self.UpdateTabCtrlHeight(force=True)
-
-
- def EditTab(self, page_index):
- """
- Starts the editing of an item label, sending a `EVT_AUINOTEBOOK_BEGIN_LABEL_EDIT` event.
-
- :param `page_index`: the page index we want to edit.
- """
-
- if page_index >= self._tabs.GetPageCount():
- return False
-
- if not self.IsRenamable(page_index):
- return False
-
- page_info = self._tabs.GetPage(page_index)
- ctrl, ctrl_idx = self.FindTab(page_info.window)
- if not ctrl:
- return False
-
- evt = AuiNotebookEvent(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_LABEL_EDIT, self.GetId())
- evt.SetSelection(page_index)
- evt.SetEventObject(self)
- if self.GetEventHandler().ProcessEvent(evt) and not evt.IsAllowed():
- # vetoed by user
- return False
-
- if self._textCtrl is not None and page_info != self._textCtrl.item():
- self._textCtrl.StopEditing()
-
- self._textCtrl = TabTextCtrl(ctrl, page_info, page_index)
- self._textCtrl.SetFocus()
-
- return True
projects / iramuteq / blobdiff