def _createToolbarItem(self, itemData):
itemIdentifier = itemData.get("itemIdentifier")
if itemIdentifier is None:
raise VanillaError("toolbar item data must contain a unique itemIdentifier string")
if itemIdentifier in self._toolbarItems:
raise VanillaError("toolbar itemIdentifier is not unique: %r" % itemIdentifier)
if itemIdentifier not in self._toolbarAllowedItemIdentifiers:
self._toolbarAllowedItemIdentifiers.append(itemIdentifier)
if itemData.get("visibleByDefault", True):
self._toolbarDefaultItemIdentifiers.append(itemIdentifier)
if itemIdentifier.startswith("NS"):
# no need to create an actual item for a standard Cocoa toolbar item
return
label = itemData.get("label")
paletteLabel = itemData.get("paletteLabel", label)
toolTip = itemData.get("toolTip", label)
imagePath = itemData.get("imagePath")
imageNamed = itemData.get("imageNamed")
imageObject = itemData.get("imageObject")
view = itemData.get("view")
callback = itemData.get("callback", None)
# create the NSImage if needed
if imagePath is not None:
image = NSImage.alloc().initWithContentsOfFile_(imagePath)
elif imageNamed is not None:
image = NSImage.imageNamed_(imageNamed)
elif imageObject is not None:
image = imageObject
else:
image = None
toolbarItem = NSToolbarItem.alloc().initWithItemIdentifier_(itemIdentifier)
toolbarItem.setLabel_(label)
toolbarItem.setPaletteLabel_(paletteLabel)
toolbarItem.setToolTip_(toolTip)
if image is not None:
toolbarItem.setImage_(image)
elif view is not None:
toolbarItem.setView_(view)
toolbarItem.setMinSize_(view.frame().size)
toolbarItem.setMaxSize_(view.frame().size)
if callback is not None:
target = VanillaCallbackWrapper(callback)
toolbarItem.setTarget_(target)
toolbarItem.setAction_("action:")
self._toolbarCallbackWrappers[itemIdentifier] = target
if itemData.get("selectable", False):
self._toolbarSelectableItemIdentifiers.append(itemIdentifier)
self._toolbarItems[itemIdentifier] = toolbarItem
def removeToolbarItem(self, itemIdentifier):
"""
Remove a toolbar item by his identifier.
**itemIdentifier** A unique string identifier for the removed item.
"""
if not hasattr(self, "_toolbarItems"):
raise VanillaError("window has not toolbar")
if itemIdentifier not in self._toolbarItems:
raise VanillaError("itemIdentifier %r not in toolbar" % itemIdentifier)
item = self._toolbarItems[itemIdentifier]
toolbarItems = self._window.toolbar().items()
if item in toolbarItems:
## it can happen a user changed the toolbar manually
index = toolbarItems.indexOfObject_(item)
self._window.toolbar().removeItemAtIndex_(index)
self._toolbarAllowedItemIdentifiers.remove(itemIdentifier)
self._toolbarDefaultItemIdentifiers.remove(itemIdentifier)
del self._toolbarItems[itemIdentifier]
def setDefaultButton(self, button):
"""
Set the default button in the window.
**button** will be bound to the Return and Enter keys.
"""
if not isinstance(button, VanillaBaseControl):
raise VanillaError("invalid object")
cell = button._nsObject.cell()
self._window.setDefaultButtonCell_(cell)
def setTickMarkPosition(self, value):
"""
Set the position of the tick marks on the slider.
For vertical sliders, the options are:
+---------+
| "left" |
+---------+
| "right" |
+---------+
For horizontal sliders, the options are:
+----------+
| "top" |
+----------+
| "bottom" |
+----------+
"""
# don't rely on self._nsObject.isVertical here
# because if this is called before the object
# has been added to an open window, the isVertical
# method is unable to determine horizontal or vertical
w, h = self._posSize[2:]
if w > h:
isVertical = False
else:
isVertical = True
if isVertical:
if value == "top" or value == "bottom":
raise VanillaError(
"vertical sliders can only position tick marks at 'left' or 'right'"
)
else:
if value == "left" or value == "right":
raise VanillaError(
"horizontal sliders can only position tick marks at 'top' or 'bottom'"
)
position = _tickPositionMap[value]
self._nsObject.setTickMarkPosition_(position)
def addToolbarItem(self, itemData, index=None):
"""
Add a toolbar item to the windows toolbar.
**itemData** item description with the same format as a toolbarItem description in `addToolbar`
**index** An interger, specifying the place to insert the toolbar itemIdentifier.
"""
if not hasattr(self, "_toolbarItems"):
raise VanillaError("window has not toolbar")
itemIdentifier = itemData.get("itemIdentifier")
self._createToolbarItem(itemData)
if itemData.get("visibleByDefault", True):
if index is not None:
self._toolbarDefaultItemIdentifiers.remove(itemIdentifier)
self._toolbarDefaultItemIdentifiers.insert(index, itemIdentifier)
index = self._toolbarDefaultItemIdentifiers.index(itemIdentifier)
self._window.toolbar().insertItemWithItemIdentifier_atIndex_(itemIdentifier, index)
def __init__(self, *args, **kwargs):
raise VanillaError(
"SplitView is not available because the RBSplitView framework cannot be found. Refer to the Vanilla documentation for details."
)