Python awt.Toolkit类代码示例

 def paintComponent(self, g2d):
     self.super__paintComponent(g2d)
     g2d.drawImage(self.surface, 0, 0, None)
     try:
         Toolkit.getDefaultToolkit().sync()
     except:
         pass

	def menuItemClicked(self, caption, messageInfo):
		msg = messageInfo[0]
		request = ''.join(map(chr, (msg.getRequest())))
		headers, body = request.split('\r\n\r\n')
		headers = dict(item.split(': ') for item in headers.split('\r\n')[1:])
		payload = ('python sqlmap.py -u "%s" --cookie="%s"' % (msg.getUrl(), headers['Cookie']))
		if body is not None and len(body) > 0: #query string is in body
			payload = '%s --data="%s"' % (payload, body)
		s = StringSelection(payload)
		Toolkit.getDefaultToolkit().getSystemClipboard().setContents(s,s) #put string on clipboard
		print(payload) #print string
		return

	def _build(self):
		#Grab first selected message, bail if none

		iRequestInfo = self._helpers.analyzeRequest(self.ctxMenuInvocation.getSelectedMessages()[0])
		self.body = ''.join(map(chr, self.ctxMenuInvocation.getSelectedMessages()[0].getRequest())).split('\r\n\r\n')[1]
		if iRequestInfo is None:
			return 
		
		#Build payload - add your static flags here, like -s or -i
		payload = ('curl -isk ') # % (msg.getUrl()))
		#Turn all headers into dictionary, remove BLACKLISTed ones
		headers = dict(item.split(': ') for item in iRequestInfo.getHeaders()[1:])
		headers = dict( (k,v) for k, v in headers.iteritems() if k not in self.BLACKLIST )
		#print('Whitelisted Headers:\n\t' + '\n\t'.join(headers))

		#om nom cookies
		cookies = [c for c in iRequestInfo.getParameters() if c.getType() == IParameter.PARAM_COOKIE]
		#print('Found Cookies:\n\t' + '\n\t'.join([('%s=%s' % (c.getName(), c.getValue())) for c in cookies]))


		#print('DEBUG: Dumping All Parms')
		#for p in iRequestInfo.getParameters(): print ('\t%s : %s - %d' % (p.getName(), p.getValue(), p.getType()))

		#Set other command line args
		self.OPTS['-X'] = iRequestInfo.getMethod() 
		self.OPTS['-b'] = '; '.join([('%s=%s' % (c.getName(), c.getValue())) for c in cookies])

		#Add all the headers to the payload
		for k,v in headers.iteritems(): payload += '-H \'%s: %s\' \\\n' % (k, v)

		#Invoke handlers to handle content type
		#print('content type: ' + str(iRequestInfo.getContentType()))
		reqType = iRequestInfo.getContentType()
		#print("Content Type Found: %d" % reqType)
		if reqType in self.fMap:
			#print('Invoking %s' % self.fMap[reqType].func_name)
			self.fMap[reqType](iRequestInfo)

		#Add all the OPTS to the payload
		for k,v, in self.OPTS.iteritems(): payload += ('%s \'%s\' \\\n' % (k, v))

		#Append URL to end of payload
		payload += '"%s"' % iRequestInfo.getUrl().toString()
		#Nasty - invocation of some java code to get the string on the clipboard
		s = StringSelection(payload)
		Toolkit.getDefaultToolkit().getSystemClipboard().setContents(s,s) #put string on clipboard
		print(payload) #print string

		self.OPTS = {}

def getScreenPanel():
    global mainScreen
    global scrPanel
    if not scrPanel:
        mainScreen = JButton()
        cursorImg = BufferedImage(16,16,BufferedImage.TYPE_INT_ARGB)
        blankCursor = Toolkit.getDefaultToolkit().createCustomCursor(cursorImg, Point(0,0), "blank cursor")
        mainScreen.setCursor(blankCursor)
        mainScreen.setPreferredSize(
                Dimension(700, 700))
        image = BufferedImage(700, 700, BufferedImage.TYPE_INT_ARGB)
        g = image.createGraphics()
        g.setColor(Color.BLACK)
        g.fillRect(0, 0, 700, 700)
        g.setColor(Color.WHITE)
        g.setFont(Font("Serif", Font.BOLD, 20))
        g.drawString("Move your mouse here to controlfocused device.", 50, 30)
        mainScreenImg = image
        mainScreen.setIcon(swing.ImageIcon(image))

        mouseListener = ScrMouseListener()
        mainScreen.addMouseListener(mouseListener)
        mainScreen.addMouseMotionListener(mouseListener)
        mainScreen.addMouseWheelListener(mouseListener)

        mainScreen.setFocusable(True)
        keyListener = ScrKeyListener()
        mainScreen.addKeyListener(keyListener)


        scrPanel = JPanel()
        scrPanel.setLayout(BoxLayout(scrPanel, BoxLayout.Y_AXIS))
        scrPanel.add(mainScreen)
        scrPanel.setFocusable(True)
    return scrPanel

    def __init__(self, controller):
        # Give reference to controller to delegate action response
        self.controller = controller

        # All window components apart from the menu will go in the JFrame's
        # content pane
        self.setLayout(BorderLayout())

        # Get key bindings configuration from settings
        key_strokes = self.controller.config['keystrokes']

        # Configure key bindings for undo/redo
        # First decide when key bindings can be triggered:
        condition = JComponent.WHEN_IN_FOCUSED_WINDOW

        # InputMap maps key strokes to actions in string format (e.g. 'undo')
        # ActionMap maps string actions (e.g. 'undo') with a custom
        # AbstractAction subclass.
        pane = self.getContentPane()
        for action, key in key_strokes.iteritems():
            key_stroke = KeyStroke.getKeyStroke(
                        getattr(KeyEvent, key),
                        Toolkit.getDefaultToolkit().getMenuShortcutKeyMask())
            pane.getInputMap(condition).put(key_stroke, action)
            pane.getActionMap().put(action, KeyStrokeAction(self, action))

    def pasteHelper(self):
        # import string
        # ugly work to get the text from the clipboard
        toolkit = Toolkit.getDefaultToolkit()
        clipboardContents = toolkit.getSystemClipboard().getContents(self)
        flavor = clipboardContents.getTransferDataFlavors()

        # flavor is an array of types of representations of data
        # we must find a string representation
        i = 0
        j = None
        for a in flavor:
            if clipboardContents.getTransferData(flavor[i]).__class__ == PyString:
                j = i
            i += 1

        if not j is None:
            clipboardText = clipboardContents.getTransferData(flavor[j])
            # split to remove anything after the newline, if it's multiline

            removeNewline = string.split(clipboardText, "\n")
            self.textToPaste = removeNewline[0]
        else:
            self.textToPaste = ""
            print "\a"

 def connectRecord(self, method):               
     class EventListener(AWTEventListener):
         def eventDispatched(listenerSelf, event):
             catchAll(self.handleEvent, event, method)
 
     eventListener = EventListener()
     eventMask = AWTEvent.WINDOW_EVENT_MASK
     util.runOnEventDispatchThread(Toolkit.getDefaultToolkit().addAWTEventListener, eventListener, eventMask)

 def startListening(self):        
     class PhysicalEventListener(AWTEventListener):
         def eventDispatched(listenerSelf, event):
             catchAll(self.handleEvent, event)
     
     self.eventListener = PhysicalEventListener()
     eventMask = AWTEvent.MOUSE_EVENT_MASK | AWTEvent.KEY_EVENT_MASK
     util.runOnEventDispatchThread(Toolkit.getDefaultToolkit().addAWTEventListener, self.eventListener, eventMask)

def getClipboardText():
    """Returns the clipboard contents. Returns None if the clipboard does not
       contain text.
    """
    contents = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(None)
    if contents.isDataFlavorSupported(DataFlavor.stringFlavor):
        return str(contents.getTransferData(DataFlavor.stringFlavor))
    return None

def _screenshot(name):
    name = name.replace("<","-").replace(">","-").replace(":","-").replace("|","-").replace("*","-").replace("\"","-").replace("/","-").replace("\\","-")
    from java.awt import Toolkit,Robot,Rectangle
    from javax.imageio import ImageIO
    from java.io import File  
    screenRect = Rectangle(Toolkit.getDefaultToolkit().getScreenSize())
    capture = Robot().createScreenCapture(screenRect)
    ImageIO.write(capture, "png", File(_UXTST_OUTPUT_PATH_ + name+".png"))

 def getClipboardText(self):
     clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
     contents = clipboard.getContents(None)
     gotText = (contents != None) and contents.isDataFlavorSupported(DataFlavor.stringFlavor)
     
     if gotText:
         return contents.getTransferData(DataFlavor.stringFlavor)
     else:
         return None

def getContentToPaste(forComponent):
    clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
    clipContents = clipboard.getContents(forComponent)

    for flavor in clipContents.getTransferDataFlavors():
        if DataFlavor.stringFlavor.equals(flavor):
            return clipContents.getTransferData(flavor)

    return None

 def editTextComponent(self, newValue, row, column):
     self.widget.runKeyword("typeIntoTableCell", row, column, newValue)
     # The above will press the Enter key and never release it, see
     # http://code.google.com/p/robotframework-swinglibrary/issues/detail?id=197
     # We work around this by releasing it ourselves...
     releaseEvent = KeyEvent(self.widget.widget,
                             KeyEvent.KEY_RELEASED, System.currentTimeMillis(),
                             0, KeyEvent.VK_ENTER)
     util.runOnEventDispatchThread(Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent, releaseEvent)

def main():
    load('bookshelf.conf')
    if config('LOCALE') is not None and config('LOCALE') != '':
        Locale.setDefault(Locale(config('LOCALE')))
    from window import BookshelfView
    from logic import Bookshelf
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName())
    view = BookshelfView(Bookshelf())
    screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    view.setLocation(screenSize.width/5,  screenSize.height/5)
    view.setVisible(1)

    def pasteAction(self, event=None):
        if self.inLastLine():
            clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
            clipboard.getContents(self.textpane)
            contents = clipboard.getData(DataFlavor.stringFlavor)

            lines = contents.splitlines()
            for i, line in enumerate(lines):
                self.insertText(line)
                if i < len(lines) - 1:
                    self.enterAction()