Beispiel #1
0
def createAction(callback,
                 name,
                 description=None,
                 menu=None,
                 mnemonic=None,
                 accelerator=None,
                 toolBar=None,
                 menuItemType="standard"):
    action = CallbackAction(callback, name, description)
    if menu:
        if menuItemType == "standard":
            menuItem = JMenuItem(action)
        elif menuItemType == "checkbox":
            menuItem = JCheckBoxMenuItem(action)
        elif menuItemType == "radiobutton":
            menuItem = JRadioButtonMenuItem(action)
        else:
            internal_error("unsupported menu item type %s" % ` menuItemType `)
            menuItem = JMenuItem(action)
        if mnemonic:
            menuItem.setMnemonic(mnemonic)
        if accelerator:
            menuItem.setAccelerator(
                KeyStroke.getKeyStroke(ord(accelerator), Event.CTRL_MASK, 0))
        menu.add(menuItem)
        action.setMenuItem(menuItem)
    if toolBar:
        toolbarButton = JButton(action)
        toolBar.add(toolbarButton)
    return action
def DisplayStreetTable (collection):
    columns=list(
        (
            ("Name","name"),
            )
        )
    tm= ObjectTableModel(collection,columns)
    frame = MyFrame("Street Table")
    frame.setSize(800, 1200)
    frame.setLayout(BorderLayout())
    table = JTable(tm)
    table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS)
    header = table.getTableHeader()
    header.setUpdateTableInRealTime(True)
    header.setReorderingAllowed(True);
    scrollPane = JScrollPane()
    scrollPane.getViewport().setView((table))
#    copyButton = JButton('Merge') #,actionPerformed=self.noAction
#    frame.add(copyButton)

    listener=MyListener(table)
    table.addMouseListener(listener)
    table.addKeyListener(listener)

    menubar = JMenuBar()
    file = JMenu("Edit")
    file.setMnemonic(KeyEvent.VK_E)

    lookup = JMenuItem("Lookup",actionPerformed=frame.LookupEvent)
    lookup.setMnemonic(KeyEvent.VK_L)

    file.add(lookup)


    menubar.add(file)



    frame.setJMenuBar(menubar)

    frame.add(scrollPane)


    frame.pack();
    frame.setSize(frame.getPreferredSize());
    frame.show()
Beispiel #3
0
    def createItems(self, menuItems):
        items = []

        #Refer to MenuView's menuItems dictionary where each menu item has an
        #array of two elements, the first is the key event and the second is the
        #action asigned to the menu item
        def getMethod(name):
            return menuItems[name][1]

        def getKeyEvent(name):
            return menuItems[name][0]

        for name, keyEvent in menuItems.items():
            item = JMenuItem(name, actionPerformed =
                             getattr(self.menuView.controller, getMethod(name)))
            item.setMnemonic(getKeyEvent(name))
            items.append(item)

        return items
Beispiel #4
0
    def createItems(self, menuItems):
        items = []

        # Refer to MenuView's menuItems dictionary where each menu item has an
        # array of two elements, the first is the key event and the second is
        # the action asigned to the menu item
        def getMethod(name):
            return menuItems[name][1]

        def getKeyEvent(name):
            return menuItems[name][0]

        for name, keyEvent in menuItems.items():
            actionPerformed = getattr(self.menuView.controller,
                                      getMethod(name))
            item = JMenuItem(name, actionPerformed=actionPerformed)
            item.setMnemonic(getKeyEvent(name))
            items.append(item)

        return items
def createAction(callback, name, description=None, menu=None, mnemonic=None, accelerator=None, toolBar=None, menuItemType="standard"):
    action = CallbackAction(callback, name, description)
    if menu:
        if menuItemType == "standard":
            menuItem = JMenuItem(action)
        elif menuItemType == "checkbox":
            menuItem = JCheckBoxMenuItem(action)
        elif menuItemType == "radiobutton":
            menuItem = JRadioButtonMenuItem(action)
        else:
            internal_error("unsupported menu item type %s" % `menuItemType`)
            menuItem = JMenuItem(action)
        if mnemonic:
            menuItem.setMnemonic(mnemonic)
        if accelerator:
            menuItem.setAccelerator(KeyStroke.getKeyStroke(ord(accelerator), Event.CTRL_MASK, 0))
        menu.add(menuItem)
        action.setMenuItem(menuItem)
    if toolBar:
        toolbarButton = JButton(action)
        toolBar.add(toolbarButton)
    return action
	def __init__(self, windowManager, commandConsoleFactory, subject, windowTitle):
		self._windowManager = windowManager





		self.onCloseRequestListener = None



		# EDIT MENU

		transferActionListener = _TransferActionListener()

		editMenu = JMenu( 'Edit' )

		if Platform.getPlatform() is Platform.MAC:
			command_key_mask = ActionEvent.META_MASK
		else:
			command_key_mask = ActionEvent.CTRL_MASK;

		self.__editUndoItem = JMenuItem( 'Undo' )
		undoAction = _action( 'undo', self.__onUndo )
		self.__editUndoItem.setActionCommand( undoAction.getValue( Action.NAME ) )
		self.__editUndoItem.addActionListener( undoAction )
		self.__editUndoItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Z, command_key_mask ) )
		self.__editUndoItem.setMnemonic( KeyEvent.VK_U )
		editMenu.add( self.__editUndoItem )

		self.__editRedoItem = JMenuItem( 'Redo' )
		redoAction = _action( 'redo', self.__onRedo )
		self.__editRedoItem.setActionCommand( redoAction.getValue( Action.NAME ) )
		self.__editRedoItem.addActionListener( redoAction )
		self.__editRedoItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_Y, command_key_mask ) )
		self.__editRedoItem.setMnemonic( KeyEvent.VK_R )
		editMenu.add( self.__editRedoItem )

		editMenu.addSeparator()

		editCutItem = JMenuItem( 'Cut' )
		editCutItem.setActionCommand( TransferHandler.getCutAction().getValue( Action.NAME ) )
		editCutItem.addActionListener( transferActionListener )
		editCutItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_X, command_key_mask ) )
		editCutItem.setMnemonic( KeyEvent.VK_T )
		editMenu.add( editCutItem )

		editCopyItem = JMenuItem( 'Copy' )
		editCopyItem.setActionCommand( TransferHandler.getCopyAction().getValue( Action.NAME ) )
		editCopyItem.addActionListener( transferActionListener )
		editCopyItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_C, command_key_mask ) )
		editCopyItem.setMnemonic( KeyEvent.VK_C )
		editMenu.add( editCopyItem )

		editPasteItem = JMenuItem( 'Paste' )
		editPasteItem.setActionCommand( TransferHandler.getPasteAction().getValue( Action.NAME ) )
		editPasteItem.addActionListener( transferActionListener )
		editPasteItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_V, command_key_mask ) )
		editPasteItem.setMnemonic( KeyEvent.VK_P )
		editMenu.add( editPasteItem )

		editMenu.addSeparator()

		self.__showUndoHistoryItem = JMenuItem( 'Show undo history' )
		self.__showUndoHistoryItem.addActionListener( _action( 'Show undo history', self.__onShowUndoHistory ) )
		editMenu.add( self.__showUndoHistoryItem )




		# HELP MENU

		helpMenu = JMenu( 'Help' )

		helpToggleTooltipHighlightsItem = JMenuItem( 'Toggle tooltip highlights' )
		toggleTooltipHighlightsAction = _action( 'Toggle tooltip highlights', self.__onToggleTooltipHighlights )
		helpToggleTooltipHighlightsItem.setActionCommand( toggleTooltipHighlightsAction.getValue( Action.NAME ) )
		helpToggleTooltipHighlightsItem.addActionListener( toggleTooltipHighlightsAction )
		helpToggleTooltipHighlightsItem.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_F2, 0 ) )
		helpMenu.add( helpToggleTooltipHighlightsItem )

		helpMenu.add( _action( 'Show all tip boxes', self.__onShowAllTipBoxes ) )


		# MENU BAR

		menuBar = JMenuBar()
		menuBar.add( editMenu )
		menuBar.add( helpMenu )




		# BROWSER

		# Initialise here, as the browser listener may invoke methods upon the browser's creation
		class _BrowserListener (TabbedBrowser.TabbedBrowserListener):
			def createNewBrowserWindow(_self, subject):
				self._onOpenNewWindow( subject )

			def onTabbledBrowserChangePage(_self, browser):
				pass


		def inspectFragment(fragment, sourceElement, triggeringEvent):
			return self._windowManager.world.inspectFragment( fragment, sourceElement, triggeringEvent )



		def onChangeHistoryChanged(history):
			self.__refreshChangeHistoryControls( history )

		self._browser = TabbedBrowser( self._windowManager.world.rootSubject, subject, inspectFragment, _BrowserListener(), commandConsoleFactory )
		self._browser.getComponent().setPreferredSize( Dimension( 800, 600 ) )
		changeHistory = self._browser.getChangeHistory()
		self._browser.getChangeHistory().addChangeHistoryListener(onChangeHistoryChanged)





		# MAIN PANEL

		windowPanel = JPanel()
		windowPanel.setLayout( BoxLayout( windowPanel, BoxLayout.Y_AXIS ) )
		windowPanel.add( self._browser.getComponent() )




		# WINDOW

		class _WindowLister (WindowListener):
			def windowActivated(listenerSelf, event):
				pass

			def windowClosed(listenerSelf, event):
				pass

			def windowClosing(listenerSelf, event):
				if self.onCloseRequestListener is not None:
					self.onCloseRequestListener( self )

			def windowDeactivated(listenerSelf, event):
				pass

			def windowDeiconified(listenerSelf, event):
				pass

			def windowIconified(listenerSelf, event):
				pass

			def windowOpened(listenerSelf, event):
				pass


		self.__frame = JFrame( windowTitle )

		self.__frame.setJMenuBar( menuBar )

		self.__frame.add( windowPanel )
		self.__frame.addWindowListener( _WindowLister() )
		self.__frame.setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE )

		self.__frame.pack()


		# Cause command history controls to refresh
		self.__refreshChangeHistoryControls( None )