def construct_rofi_menu(self):
"""Creates the Rofi menu"""
rofi_menu = Menu()
self.launch_menu_item = rofi_menu.Append(NewId(),
'&Launch Modi\tCtrl+t',
'Launch any available modi')
self.Append(rofi_menu, '&Rofi')
def __init__(self, parent, title):
Frame.__init__(self, parent, title=title, size=(500, 400))
self.setup_xmlrpc_server()
self.completed = False
# Create the notebook
self.notebook = Notebook(self, style=NB_MULTILINE)
# Setting up the menu
file_menu = Menu()
exit_item = file_menu.Append(ID_EXIT, '&Exit...', 'Exit Settings Window')
self.Bind(EVT_MENU, self.prepare_for_exit, exit_item)
menu_bar = MenuBar()
menu_bar.Append(file_menu, '&File')
self.SetMenuBar(menu_bar)
alpha = settings.SETTINGS.keys()
alpha.sort()
self.fields = []
for top in alpha:
self.make_page(top)
self.CenterOnScreen()
self.Show()
self.Bind(EVT_CLOSE, self.xmlrpc_kill)
def start_server():
while not self.server_quit:
self.server.handle_request()
Timer(0.5, start_server).start()
Timer(300, self.xmlrpc_kill).start()
def _createApplicationMenuBar(self):
menuBar: MenuBar = MenuBar()
fileMenu: Menu = Menu()
helpMenu: Menu = Menu()
fileMenu.Append(ID_PREFERENCES, 'Configure',
'Configure Application IDs')
fileMenu.AppendSeparator()
fileMenu.Append(ID_EXIT, '&Quit', "Quit Application")
helpMenu.Append(ApplicationFrame.HELP_MENU_ID, "&MiniHelp",
"Simple Help")
helpMenu.AppendSeparator()
helpMenu.Append(ID_ABOUT, '&About', 'Tell you about me')
menuBar.Append(fileMenu, 'File')
menuBar.Append(helpMenu, 'Help')
self.SetMenuBar(menuBar)
self.Bind(EVT_MENU, self._onMiniHelp, id=ApplicationFrame.HELP_MENU_ID)
self.Bind(EVT_MENU, self._onConfigure, id=ID_PREFERENCES)
self.Bind(EVT_MENU, self._onAbout, id=ID_ABOUT)
self.Bind(EVT_MENU, self.Close, id=ID_EXIT)
def __init__(self, parent, title, server):
Frame.__init__(self, parent, title=title, size=(500, 400))
global SETTINGS_FRAME
SETTINGS_FRAME = self
self.server = server
self.setup_xmlrpc_server()
self.completed = False
self.notebook = Notebook(self, style=NB_MULTILINE)
file_menu = Menu()
self.next_page = file_menu.Append(ID_ANY, '&Next page\tRAWCTRL+TAB',
'Next page')
self.prev_page = file_menu.Append(ID_ANY,
'&Prev page\tRAWCTRL+SHIFT+TAB',
'Prev page')
self.Bind(EVT_MENU, self.OnTab, self.next_page)
self.Bind(EVT_MENU, self.OnTab, self.prev_page)
exit_item = file_menu.Append(ID_EXIT, '&Exit...',
'Exit Settings Window')
self.Bind(EVT_MENU, self.prepare_for_exit, exit_item)
menu_bar = MenuBar()
menu_bar.Append(file_menu, '&File')
self.SetMenuBar(menu_bar)
self.fields = []
for top in sorted(settings.SETTINGS.keys()): # pylint: disable=no-member
self.make_page(top)
self.CenterOnScreen()
self.Show()
self.Bind(EVT_ON_KILL, self.OnKill)
self.Bind(EVT_ON_COMPLETE, self.OnComplete)
self.Bind(EVT_CLOSE, self.xmlrpc_kill)
self.expiration = threading.Timer(300, self.xmlrpc_kill)
self.expiration.start()
def create_popup_menu(self):
menu = Menu()
self.create_menu_item(menu, self.translate("open", self.lang), self.left_click)
menu.AppendSeparator()
self.create_menu_item(menu, self.translate("copy_address", self.lang), self.copy_address)
menu.AppendSeparator()
self.create_menu_item(menu, self.translate("exit", self.lang), self.on_exit)
return menu
def __init__(self, data):
Menu.__init__(self)
self.__id_and_item_data = self.__get_ids_and_item_data(data)
self.__text_and_item_data = dict([(d.text, d) for d in self.__id_and_item_data.values()])
self.__create_menu(data)
self._bind_evt_menu(self.__on_menu_click)
def register_menu(self, menu: wx.Menu):
def _get_callback(plugin):
return lambda _: self.callbacks[plugin]()
sorted_plugins = sorted(self.plugins, key=lambda p: p.metadata.name)
for plugin in sorted_plugins:
item = menu.Append(wx.ID_ANY, plugin.metadata.name)
menu.Bind(wx.EVT_MENU, _get_callback(plugin), item)
def __init__(self, parent):
Menu.__init__(self)
self.parent = parent
self.statusbartoggler = self.Append(ITEM_CHECK,'Show StatusBar', 'Show Statusbar', kind=ITEM_CHECK)
self.Check(self.statusbartoggler.GetId(), True)
self.Bind(EVT_MENU, self.onToggleStatusBar, self.statusbartoggler)
def construct_prefs_menu(self):
"""Creates the preferences menu"""
prefs_menu = Menu()
self.backup_on_menu_item = prefs_menu.Append(
NewId(), 'Backup pre save',
'Backs up the existing config before saving', ITEM_CHECK)
self.backup_on_menu_item.Check(True)
prefs_menu.AppendSubMenu(self.construct_docs_menu(), '&Docs')
self.Append(prefs_menu, '&Preferences')
def format_menu(self, obj: Menu):
"""Formats Menu info"""
lines = [
"Menu:",
self.Fmt('class', obj.__class__),
self.Fmt('bases', obj.__class__.__bases__),
self.Fmt('module', inspect.getmodule(obj)),
self.Fmt('style', obj.GetStyle()),
self.Fmt('title', obj.GetTitle())]
return lines
def config_menu(self):
'''Here we configure the main windows menu'''
menu_bar = MenuBar()
file_menu = Menu()
self.file_item = file_menu.Append(wx.ID_EXIT, 'Quit',
'Quit application')
menu_bar.Append(file_menu, '&File')
self.SetMenuBar(menu_bar)
self.Bind(wx.EVT_MENU, self.OnQuit, self.file_item)
def __init__(self, data):
Menu.__init__(self)
self.__id_and_item_data = self.__get_ids_and_item_data(data)
self.__text_and_item_data = dict([
(d.text, d) for d in self.__id_and_item_data.values()
])
self.__create_menu(data)
self._bind_evt_menu(self.__on_menu_click)
def __init__(self, parent, ID, title):
Frame.__init__(self, parent, ID, title, DefaultPosition, Size(300, 200))
menu = Menu()
menu.Append(ID_EXIT, "E&xit", "Terminate the program")
menuBar = MenuBar()
menuBar.Append(menu, "&File")
self.SetMenuBar(menuBar)
EVT_MENU(self, ID_EXIT, self.DoExit)
# make sure reactor.stop() is used to stop event loop:
EVT_CLOSE(self, lambda evt: reactor.stop())
def _initializeAddHierarchySubMenu(self, mnuEdit: Menu) -> Menu:
sub: Menu = Menu()
sub.Append(SharedIdentifiers.ID_MNU_ADD_PYUT_HIERARCHY, _("&Pyut"),
_("Add the UML Diagram of Pyut"))
sub.Append(SharedIdentifiers.ID_MNU_ADD_OGL_HIERARCHY, _("&Ogl"),
_("Add the UML Diagram of Pyut - Ogl"))
mnuEdit.Append(NewIdRef(), _('Add Hierarchy'), sub)
return mnuEdit
def __build_menu(self, menu_data):
from wx import Menu, NewId
menu = Menu()
for each_item in menu_data:
if len(each_item) == 2:
label = each_item[0]
sub_menu = self.__build_menu(each_item[1])
menu.AppendMenu(NewId(), label, sub_menu)
else:
self.__menu_item(menu, *each_item)
return menu
def _initializeErrorViewSubMenu(self, mnuEdit: Menu) -> Menu:
sub: Menu = Menu()
sub.Append(SharedIdentifiers.ID_MENU_GRAPHIC_ERROR_VIEW,
'&Graphic Error View', 'Test graphical error view')
sub.Append(SharedIdentifiers.ID_MENU_TEXT_ERROR_VIEW,
'&Text Error View', 'Test text error view')
sub.Append(SharedIdentifiers.ID_MENU_RAISE_ERROR_VIEW,
'&Exception Error View', 'Test raising exception')
mnuEdit.Append(NewIdRef(), _('Show Error View'), sub)
return mnuEdit
def __init__(self, app: App):
super(Frame, self).__init__(None)
self.editor = TextCtrl(self, 101, style=TE_MULTILINE)
self.stat: StatusBar = self.CreateStatusBar()
self.stat.SetFieldsCount(2)
self.stat.SetStatusWidths([-1, -5])
self.SetTitle(f"{BASETITLE} - *Untitled*")
self.SetSize(720, 540)
self.File: str = None
self.changed = False
menubar: MenuBar = MenuBar()
edit_menu: Menu = Menu()
file_menu: Menu = Menu()
edit_menu.Append(1, "&Preview\tCtrl+P")
edit_menu.Append(2, "Post")
edit_menu.AppendSeparator()
edit_menu.Append(7, "&Ruby\tCtrl+R")
edit_menu.Append(9, "&Dotmarks\tCtrl+Shift+D")
edit_menu.Append(8, "&Paragraph\tCtrl+Space")
file_menu.Append(3, "&New\tCtrl+N")
file_menu.Append(4, "&Open\tCtrl+Shift+O")
file_menu.AppendSeparator()
file_menu.Append(5, "&Save as\tCtrl+Shift+S")
file_menu.Append(6, "&Save\tCtrl+S")
menubar.Append(file_menu, "&File")
menubar.Append(edit_menu, "&Edit")
self.SetMenuBar(menubar)
self.Bind(EVT_MENU, self.Preview, id=1)
self.Bind(EVT_MENU, self.Post, id=2)
self.Bind(EVT_MENU, self.New, id=3)
self.Bind(EVT_MENU, self.Open, id=4)
self.Bind(EVT_MENU, self.SaveAs, id=5)
self.Bind(EVT_MENU, self.Save, id=6)
self.Bind(EVT_MENU, self.SetRuby, id=7)
self.Bind(EVT_MENU, self.SetParagraphSpaces, id=8)
self.Bind(EVT_MENU, self.Dotmarks, id=9)
self.pvframe = HideFrame(None, -1, "プレビュー")
self.pvctrl: WebView = WebView.New(self.pvframe)
self.pvctrl.SetCanFocus(False)
self.pvframe.SetCanFocus(False)
self.Bind(EVT_TEXT, self.Reload, id=101)
app.SetTopWindow(self)
self.application = app
self.Show()
def construct_docs_menu(self):
"""Constructs the docs menu"""
docs_menu = Menu()
self.help_values_menu_item = docs_menu.Append(
NewId(),
'rofi --help',
'Show or hide pertinent rofi --help info',
ITEM_CHECK,
)
self.help_values_menu_item.Check(True)
self.man_values_menu_item = docs_menu.Append(
NewId(), 'man rofi', 'Show or hide pertinent man rofi info',
ITEM_CHECK)
self.man_values_menu_item.Check(True)
return docs_menu
def __init__(self, parent):
Menu.__init__(self)
self.parent = parent
self.connect = self.Append(ID_HOME, "C&onnect", "Open Connection To DB")
self.settings = self.Append(ID_PREFERENCES, "S&ettings", "Adjust Program Settings")
self.about = self.Append(ID_ABOUT, "&About","Information about this program")
self.AppendSeparator()
self.exit = self.Append(ID_EXIT,"E&xit"," Terminate the program")
self.Bind(EVT_MENU, self.onConnect, self.connect)
self.Bind(EVT_MENU, self.onSettings, self.settings)
self.Bind(EVT_MENU, self.onAbout, self.about)
self.Bind(EVT_MENU, self.onExit, self.exit)
def __init__(self, parent):
Menu.__init__(self)
self.parent = parent
men1 = MenuItem(self, 1, "Copy Address")
self.Append(men1)
self.Bind(EVT_MENU, self.parent.copy_account, men1)
men2 = MenuItem(self, 2, "Open block explorer")
self.Append(men2)
self.Bind(EVT_MENU, self.parent.open_explorer, men2)
men3 = MenuItem(self, 3, "Open in wallet")
self.Append(men3)
self.Bind(EVT_MENU, self.parent.open_wallet, men3)
def create_menu_item(
parent: wx.Window,
menu: wx.Menu,
text: str,
tooltip: str = '',
icon_image: Optional[Image.Image] = None,
id: int = wx.ID_ANY,
callback: Optional[Callable] = None,
):
"""Create menu item
The tooltip is actually not visible, menu items with tooltips are not
supported by WxWidgets.
"""
menu_item = wx.MenuItem(menu, id, text, helpString=tooltip)
if icon_image:
bitmap = image_to_bitmap(icon_image)
menu_item.SetBitmap(bitmap)
menu.Append(menu_item)
if callback:
parent.Bind(wx.EVT_MENU,
partial(on_menu_item, callback=callback),
id=id)
else:
menu_item.Enable(False)
return menu_item
def _createMenu(self) -> Menu:
menu: Menu = Menu()
increaseItem: MenuItem = menu.Append(
ID_MENU_INCREASE_SIZE, _('Increase Size'),
_('Increase Text Size by 2 points'))
decreaseItem: MenuItem = menu.Append(
ID_MENU_DECREASE_SIZE, _('Decrease Size'),
_('Decrease Text Size by 2 points'))
incBmp: Bitmap = IncreaseTextSize.GetBitmap()
increaseItem.SetBitmap(incBmp)
decBmp: Bitmap = DecreaseTextSize.GetBitmap()
decreaseItem.SetBitmap(decBmp)
boldItem: MenuItem = menu.AppendCheckItem(ID_MENU_BOLD_TEXT,
item=_('Bold Text'),
help=_('Set text to bold'))
italicizedItem: MenuItem = menu.AppendCheckItem(
ID_MENU_ITALIC_TEXT,
item=_('Italicize Text'),
help=_('Set text to italics'))
if self.pyutText.isBold is True:
boldItem.Check(check=True)
if self.pyutText.isItalicized is True:
italicizedItem.Check(check=True)
menu.Bind(EVT_MENU, self._onChangeTextSize, id=ID_MENU_INCREASE_SIZE)
menu.Bind(EVT_MENU, self._onChangeTextSize, id=ID_MENU_DECREASE_SIZE)
menu.Bind(EVT_MENU, self._onToggleBold, id=ID_MENU_BOLD_TEXT)
menu.Bind(EVT_MENU, self._onToggleItalicize, id=ID_MENU_ITALIC_TEXT)
return menu
def __popupProjectDocumentMenu(self):
if self.__documentPopupMenu is None:
self.logger.info(f'Create the document popup menu')
[editDocumentNameMenuID,
removeDocumentMenuID] = PyutUtils.assignID(2)
popupMenu: Menu = Menu('Actions')
popupMenu.AppendSeparator()
popupMenu.Append(editDocumentNameMenuID, 'Edit Document Name',
'Change document name', ITEM_NORMAL)
popupMenu.Append(removeDocumentMenuID, 'Remove Document',
'Delete it', ITEM_NORMAL)
popupMenu.Bind(EVT_MENU,
self.__onEditDocumentName,
id=editDocumentNameMenuID)
popupMenu.Bind(EVT_MENU,
self.__onRemoveDocument,
id=removeDocumentMenuID)
self.__documentPopupMenu = popupMenu
self.logger.info(f'Current Document: `{self.getCurrentDocument()}`')
self.__parent.PopupMenu(self.__documentPopupMenu)
def __makeSubMenuEntry(self, subMenu: Menu, wxId: int, pluginName: str,
callback: Callable) -> Menu:
subMenu.Append(wxId, pluginName)
self._containingFrame.Bind(EVT_MENU, callback, id=wxId)
return subMenu
def OnRightDown(self, event: MouseEvent):
"""
Handle right-clicks on our UML LineShape- Override base handler; It does nothing
Args:
event:
"""
menu: Menu = Menu()
menu.Append(MENU_ADD_BEND, _('Add Bend'), _('Add Bend at right click point'))
menu.Append(MENU_REMOVE_BEND, _('Remove Bend'), _('Remove Bend closest to click point'))
menu.Append(MENU_TOGGLE_SPLINE, _('Toggle Spline'), _('Best with at least one bend'))
if len(self._controls) == 0:
bendItem: MenuItem = menu.FindItemById(MENU_REMOVE_BEND)
bendItem.Enable(enable=False)
x: int = event.GetX()
y: int = event.GetY()
clickPoint: Tuple[int, int] = (x, y)
OglLink.clsLogger.debug(f'OglLink - {clickPoint=}')
# I hate lambdas -- humberto
menu.Bind(EVT_MENU, lambda evt, data=clickPoint: self._onMenuItemSelected(evt, data))
frame = self._diagram.GetPanel()
frame.PopupMenu(menu, x, y)
def __create_menu(self, data):
for text, func in data:
if type(func) in (list, tuple):
submenu = Menu()
for _text, _ in func:
_id = self.__text_and_item_data[_text].id
sitem = MenuItem(submenu, _id, _text)
submenu.AppendItem(sitem)
self.AppendSubMenu(submenu, text)
else:
if text == self.SEPARATOR_TEXT:
self.AppendSeparator()
else:
data = self.__text_and_item_data[text]
item = MenuItem(self, data.id, text)
self.AppendItem(item)
def append_menu_items(self, menu: wx.Menu, default: Enum):
for name, value in self.__names_and_values:
self.__menu_items[value] = menu.Append(wx.ID_ANY,
name,
kind=wx.ITEM_RADIO)
if value == default:
self.__menu_items[value].Check(True)
def OnRightDown(self, event: MouseEvent):
"""
Callback for right clicks
"""
pyutObject: PyutClass = cast(PyutClass, self.pyutObject)
menu: Menu = Menu()
menu.Append(MENU_TOGGLE_STEREOTYPE, _("Toggle stereotype display"),
_("Set stereotype display on or off"), True)
item = menu.FindItemById(MENU_TOGGLE_STEREOTYPE)
item.Check(pyutObject.getShowStereotype())
menu.Append(MENU_TOGGLE_FIELDS, _("Toggle fields display"),
_("Set fields display on or off"), True)
item = menu.FindItemById(MENU_TOGGLE_FIELDS)
item.Check(pyutObject.showFields)
menu.Append(MENU_TOGGLE_METHODS, _("Toggle methods display"),
_("Set methods display on or off "), True)
item = menu.FindItemById(MENU_TOGGLE_METHODS)
item.Check(pyutObject.showMethods)
menu.Append(MENU_TOGGLE_METHOD_PARAMETERS,
_("Toggle parameter display"),
_("Set parameter display on or off"), True)
itemToggleParameters: MenuItem = menu.FindItemById(
MENU_TOGGLE_METHOD_PARAMETERS)
displayParameters: PyutDisplayParameters = self.pyutObject.displayParameters
self._initializeTriStateDisplayParametersMenuItem(
displayParameters, itemToggleParameters)
menu.Append(MENU_FIT_FIELDS, _("Fit Fields"),
_("Fit to see all class fields"))
menu.Append(MENU_CUT_SHAPE, _("Cut shape"), _("Cut this shape"))
menu.Append(MENU_IMPLEMENT_INTERFACE, _('Implement Interface'),
_('Use Existing interface or create new one'))
frame = self._diagram.GetPanel()
# Callback
menu.Bind(EVT_MENU, self.OnMenuClick, id=MENU_TOGGLE_STEREOTYPE)
menu.Bind(EVT_MENU, self.OnMenuClick, id=MENU_TOGGLE_FIELDS)
menu.Bind(EVT_MENU, self.OnMenuClick, id=MENU_TOGGLE_METHODS)
menu.Bind(EVT_MENU, self.OnMenuClick, id=MENU_FIT_FIELDS)
menu.Bind(EVT_MENU, self.OnMenuClick, id=MENU_CUT_SHAPE)
menu.Bind(EVT_MENU, self.OnMenuClick, id=MENU_IMPLEMENT_INTERFACE)
menu.Bind(EVT_MENU,
self.onDisplayParametersClick,
id=MENU_TOGGLE_METHOD_PARAMETERS)
x: int = event.GetX()
y: int = event.GetY()
self.logger.debug(f'OglClass - x,y: {x},{y}')
frame.PopupMenu(menu, x, y)
def _makeRecentlyOpenedMenu(self):
sub: Menu = Menu()
index = 0
for index in range(index, self._prefs.getNbLOF()):
# self.fileMenu.Append(self.lastOpenedFilesID[index], "&" + str(index + 1) + " -")
lofAgain: str = f"&{str(index + 1)} -"
sub.Append(self.lastOpenedFilesID[index], lofAgain)
return sub
def __popupProjectMenu(self):
self._mediator.resetStatusText()
if self.__projectPopupMenu is None:
self.logger.info(f'Create the project popup menu')
[closeProjectMenuID] = PyutUtils.assignID(1)
popupMenu: Menu = Menu('Actions')
popupMenu.AppendSeparator()
popupMenu.Append(closeProjectMenuID, 'Close Project', 'Remove project from tree', ITEM_NORMAL)
popupMenu.Bind(EVT_MENU, self.__onCloseProject, id=closeProjectMenuID)
self.__projectPopupMenu = popupMenu
self.logger.info(f'currentProject: `{self._currentProject}`')
self.__parent.PopupMenu(self.__projectPopupMenu)
def __init__(self, frame: Frame, callbackMap: SharedTypes.CallbackMap, lastOpenFilesID):
from org.pyut.plugins.PluginManager import PluginManager # Plugin Manager should not be in plugins directory
self._containingFrame: Frame = frame
self._callbackMap: SharedTypes.CallbackMap = callbackMap
self.lastOpenedFilesID = lastOpenFilesID
self.logger: Logger = getLogger(__name__)
self._prefs: PyutPreferences = PyutPreferences()
self.plugMgr: PluginManager = PluginManager()
self._mnuFile: Menu = Menu()
self._plugins: SharedTypes.PluginMap = cast(SharedTypes.PluginMap, {}) # To store the plugins
self._toolboxesID: SharedTypes.ToolboxIdMap = cast(SharedTypes.ToolboxIdMap, {}) # Association toolbox id
def construct_file_menu(self):
"""Constructs the file menu"""
file_menu = Menu()
self.open_menu_item = file_menu.Append(ID_OPEN, '&Open File\tCtrl+o')
self.refresh_menu_item = file_menu.Append(NewId(),
'&Refresh Config\tCtrl+r')
self.refresh_menu_item.Enable(False)
self.restore_menu_item = file_menu.Append(NewId(),
'Restore Backup Config')
self.restore_menu_item.Enable(False)
self.save_as_menu_item = file_menu.Append(ID_SAVEAS,
'Save As\tCtrl+Shift+s')
self.save_menu_item = file_menu.Append(ID_SAVE, '&Save\tCtrl+s')
self.exit_menu_item = file_menu.Append(ID_EXIT, 'E&xit\tCtrl+w')
self.Append(file_menu, '&File')
def makeToolsMenu(self):
"""
Make the tools submenu.
"""
plugs = self.plugMgr.getToolPlugins()
nb = len(plugs)
if nb == 0:
return None
sub: Menu = Menu()
cb: SharedTypes.CallbackMap = self._callbackMap
for i in range(nb):
wxId = NewId()
obj = plugs[i](None, None)
sub.Append(wxId, obj.getMenuTitle())
self._containingFrame.Bind(EVT_MENU, cb[ActionCallbackType.TOOL_PLUGIN], id=wxId)
self.plugins[wxId] = plugs[i]
return sub
