autokey-0.90.4/doc/scripting/redirect.html 0000664 0001750 0001750 00000002401 11724374236 017535 0 ustar chris chris Epydoc Redirect Page
Epydoc Auto-redirect page
When javascript is enabled, this page will redirect URLs of
the form redirect.html#dotted.name to the
documentation for the object with the given fully-qualified
dotted name.
autokey-0.90.4/doc/scripting/class-tree.html 0000664 0001750 0001750 00000014162 11744235773 020011 0 ustar chris chris
Class Hierarchy
dict:
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list.
lib.scripting.Store:
Allows persistent storage of values between invocations of the
script.
1# -*- coding: utf-8 -*- 2 3# Copyright (C) 2011 Chris Dekter 4# 5# This program is free software: you can redistribute it and/or modify 6# it under the terms of the GNU General Public License as published by 7# the Free Software Foundation, either version 3 of the License, or 8# (at your option) any later version. 9# 10# This program is distributed in the hope that it will be useful, 11# but WITHOUT ANY WARRANTY; without even the implied warranty of 12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13# GNU General Public License for more details. 14# 15# You should have received a copy of the GNU General Public License 16# along with this program. If not, see <http://www.gnu.org/licenses/>. 17 18importsubprocess,threading,time,re 19importcommon#, model, iomediator 20#if common.USING_QT: 21# from PyQt4.QtGui import QClipboard, QApplication 22#else: 23# from gi.repository import Gtk, Gdk 24
46""" 47 Send a keyboard event 48 49 Usage: C{keyboard.send_key(key, repeat=1)} 50 51 @param key: they key to be sent (e.g. "s" or "<enter>") 52 @param repeat: number of times to repeat the key event 53 """ 54forxinxrange(repeat): 55self.mediator.send_key(key.decode("utf-8")) 56self.mediator.flush()
59""" 60 Send a key down event 61 62 Usage: C{keyboard.press_key(key)} 63 64 The key will be treated as down until a matching release_key() is sent. 65 @param key: they key to be pressed (e.g. "s" or "<enter>") 66 """ 67self.mediator.press_key(key.decode("utf-8"))
70""" 71 Send a key up event 72 73 Usage: C{keyboard.release_key(key)} 74 75 If the specified key was not made down using press_key(), the event will be 76 ignored. 77 @param key: they key to be released (e.g. "s" or "<enter>") 78 """ 79self.mediator.release_key(key.decode("utf-8"))
82""" 83 Fake a keypress 84 85 Usage: C{keyboard.fake_keypress(key, repeat=1)} 86 87 Uses XTest to 'fake' a keypress. This is useful to send keypresses to some 88 applications which won't respond to keyboard.send_key() 89 90 @param key: they key to be sent (e.g. "s" or "<enter>") 91 @param repeat: number of times to repeat the key event 92 """ 93forxinxrange(repeat): 94self.mediator.fake_keypress(key.decode("utf-8"))
97""" 98 Wait for a keypress or key combination 99 100 Usage: C{keyboard.wait_for_keypress(self, key, modifiers=[], timeOut=10.0)} 101 102 Note: this function cannot be used to wait for modifier keys on their own 103 104 @param key: they key to wait for 105 @param modifiers: list of modifiers that should be pressed with the key 106 @param timeOut: maximum time, in seconds, to wait for the keypress to occur 107 """ 108w=iomediator.Waiter(key,modifiers,None,timeOut) 109w.wait()
120""" 121 Send a mouse click relative to the active window 122 123 Usage: C{mouse.click_relative(x, y, button)} 124 125 @param x: x-coordinate in pixels, relative to upper left corner of window 126 @param y: y-coordinate in pixels, relative to upper left corner of window 127 @param button: mouse button to simulate (left=1, middle=2, right=3) 128 """ 129self.mediator.send_mouse_click(x,y,button,True)
132""" 133 Send a mouse click relative to the current mouse position 134 135 Usage: C{mouse.click_relative_self(x, y, button)} 136 137 @param x: x-offset in pixels, relative to current mouse position 138 @param y: y-offset in pixels, relative to current mouse position 139 @param button: mouse button to simulate (left=1, middle=2, right=3) 140 """ 141self.mediator.send_mouse_click_relative(x,y,button)
144""" 145 Send a mouse click relative to the screen (absolute) 146 147 Usage: C{mouse.click_absolute(x, y, button)} 148 149 @param x: x-coordinate in pixels, relative to upper left corner of window 150 @param y: y-coordinate in pixels, relative to upper left corner of window 151 @param button: mouse button to simulate (left=1, middle=2, right=3) 152 """ 153self.mediator.send_mouse_click(x,y,button,False)
156""" 157 Wait for a mouse click 158 159 Usage: C{mouse.wait_for_click(self, button, timeOut=10.0)} 160 161 @param button: they mouse button click to wait for as a button number, 1-9 162 @param timeOut: maximum time, in seconds, to wait for the keypress to occur 163 """ 164button=int(button) 165w=iomediator.Waiter(None,None,button,timeOut) 166w.wait()
199""" 200 Store a global value 201 202 Usage: C{store.set_global_value(key, value)} 203 204 The value stored with this method will be available to all scripts. 205 """ 206Store.GLOBALS[key]=value
226""" 227 Provides a simple interface for the display of some basic dialogs to collect information from the user. 228 229 This version uses KDialog to integrate well with KDE. To pass additional arguments to KDialog that are 230 not specifically handled, use keyword arguments. For example, to pass the --geometry argument to KDialog 231 to specify the desired size of the dialog, pass C{geometry="700x400"} as one of the parameters. All 232 keyword arguments must be given as strings. 233 234 A note on exit codes: an exit code of 0 indicates that the user clicked OK. 235 """ 236
249""" 250 Show an information dialog 251 252 Usage: C{dialog.info_dialog(title="Information", message="", **kwargs)} 253 254 @param title: window title for the dialog 255 @param message: message displayed in the dialog 256 @return: a tuple containing the exit code and user input 257 @rtype: C{tuple(int, str)} 258 """ 259returnself.__runKdialog(title,["--msgbox",message],kwargs)
260
261-definput_dialog(self,title="Enter a value",message="Enter a value",default="",**kwargs):
262""" 263 Show an input dialog 264 265 Usage: C{dialog.input_dialog(title="Enter a value", message="Enter a value", default="", **kwargs)} 266 267 @param title: window title for the dialog 268 @param message: message displayed above the input box 269 @param default: default value for the input box 270 @return: a tuple containing the exit code and user input 271 @rtype: C{tuple(int, str)} 272 """ 273returnself.__runKdialog(title,["--inputbox",message,default],kwargs)
276""" 277 Show a password input dialog 278 279 Usage: C{dialog.password_dialog(title="Enter password", message="Enter password", **kwargs)} 280 281 @param title: window title for the dialog 282 @param message: message displayed above the password input box 283 @return: a tuple containing the exit code and user input 284 @rtype: C{tuple(int, str)} 285 """ 286returnself.__runKdialog(title,["--password",message],kwargs)
287
288-defcombo_menu(self,options,title="Choose an option",message="Choose an option",**kwargs):
289""" 290 Show a combobox menu 291 292 Usage: C{dialog.combo_menu(options, title="Choose an option", message="Choose an option", **kwargs)} 293 294 @param options: list of options (strings) for the dialog 295 @param title: window title for the dialog 296 @param message: message displayed above the combobox 297 @return: a tuple containing the exit code and user choice 298 @rtype: C{tuple(int, str)} 299 """ 300returnself.__runKdialog(title,["--combobox",message]+options,kwargs)
301
302-deflist_menu(self,options,title="Choose a value",message="Choose a value",default=None,**kwargs):
303""" 304 Show a single-selection list menu 305 306 Usage: C{dialog.list_menu(options, title="Choose a value", message="Choose a value", default=None, **kwargs)} 307 308 @param options: list of options (strings) for the dialog 309 @param title: window title for the dialog 310 @param message: message displayed above the list 311 @param default: default value to be selected 312 @return: a tuple containing the exit code and user choice 313 @rtype: C{tuple(int, str)} 314 """ 315 316choices=[] 317optionNum=0 318foroptioninoptions: 319choices.append(str(optionNum)) 320choices.append(option) 321ifoption==default: 322choices.append("on") 323else: 324choices.append("off") 325optionNum+=1 326 327retCode,result=self.__runKdialog(title,["--radiolist",message]+choices,kwargs) 328choice=options[int(result)] 329 330returnretCode,choice
331
332-deflist_menu_multi(self,options,title="Choose one or more values",message="Choose one or more values",defaults=[],**kwargs):
333""" 334 Show a multiple-selection list menu 335 336 Usage: C{dialog.list_menu_multi(options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs)} 337 338 @param options: list of options (strings) for the dialog 339 @param title: window title for the dialog 340 @param message: message displayed above the list 341 @param defaults: list of default values to be selected 342 @return: a tuple containing the exit code and user choice 343 @rtype: C{tuple(int, str)} 344 """ 345 346choices=[] 347optionNum=0 348foroptioninoptions: 349choices.append(str(optionNum)) 350choices.append(option) 351ifoptionindefaults: 352choices.append("on") 353else: 354choices.append("off") 355optionNum+=1 356 357retCode,output=self.__runKdialog(title,["--separate-output","--checklist",message]+choices,kwargs) 358results=output.split() 359 360choices=[] 361forindexinresults: 362choices.append(options[int(index)]) 363 364returnretCode,choices
367""" 368 Show an Open File dialog 369 370 Usage: C{dialog.open_file(title="Open File", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs)} 371 372 @param title: window title for the dialog 373 @param initialDir: starting directory for the file dialog 374 @param fileTypes: file type filter expression 375 @param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time 376 @return: a tuple containing the exit code and file path 377 @rtype: C{tuple(int, str)} 378 """ 379ifrememberAsisnotNone: 380returnself.__runKdialog(title,["--getopenfilename",initialDir,fileTypes,":"+rememberAs],kwargs) 381else: 382returnself.__runKdialog(title,["--getopenfilename",initialDir,fileTypes],kwargs)
385""" 386 Show a Save As dialog 387 388 Usage: C{dialog.save_file(title="Save As", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs)} 389 390 @param title: window title for the dialog 391 @param initialDir: starting directory for the file dialog 392 @param fileTypes: file type filter expression 393 @param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time 394 @return: a tuple containing the exit code and file path 395 @rtype: C{tuple(int, str)} 396 """ 397ifrememberAsisnotNone: 398returnself.__runKdialog(title,["--getsavefilename",initialDir,fileTypes,":"+rememberAs],kwargs) 399else: 400returnself.__runKdialog(title,["--getsavefilename",initialDir,fileTypes],kwargs)
403""" 404 Show a Directory Chooser dialog 405 406 Usage: C{dialog.choose_directory(title="Select Directory", initialDir="~", rememberAs=None, **kwargs)} 407 408 @param title: window title for the dialog 409 @param initialDir: starting directory for the directory chooser dialog 410 @param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time 411 @return: a tuple containing the exit code and chosen path 412 @rtype: C{tuple(int, str)} 413 """ 414ifrememberAsisnotNone: 415returnself.__runKdialog(title,["--getexistingdirectory",initialDir,":"+rememberAs],kwargs) 416else: 417returnself.__runKdialog(title,["--getexistingdirectory",initialDir],kwargs)
420""" 421 Show a Colour Chooser dialog 422 423 Usage: C{dialog.choose_colour(title="Select Colour")} 424 425 @param title: window title for the dialog 426 @return: a tuple containing the exit code and colour 427 @rtype: C{tuple(int, str)} 428 """ 429returnself.__runKdialog(title,["--getcolor"],kwargs)
430
431-defcalendar(self,title="Choose a date",format="%Y-%m-%d",date="today",**kwargs):
432""" 433 Show a calendar dialog 434 435 Usage: C{dialog.calendar_dialog(title="Choose a date", format="%Y-%m-%d", date="YYYY-MM-DD", **kwargs)} 436 437 Note: the format and date parameters are not currently used 438 439 @param title: window title for the dialog 440 @param format: format of date to be returned 441 @param date: initial date as YYYY-MM-DD, otherwise today 442 @return: a tuple containing the exit code and date 443 @rtype: C{tuple(int, str)} 444 """ 445returnself.__runKdialog(title,["--calendar"],kwargs)
454""" 455 Execute a shell command 456 457 Usage: C{system.exec_command(command, getOutput=True)} 458 459 Set getOutput to False if the command does not exit and return immediately. Otherwise 460 AutoKey will not respond to any hotkeys/abbreviations etc until the process started 461 by the command exits. 462 463 @param command: command to be executed (including any arguments) - e.g. "ls -l" 464 @param getOutput: whether to capture the (stdout) output of the command 465 @raise subprocess.CalledProcessError: if the command returns a non-zero exit code 466 """ 467ifgetOutput: 468p=subprocess.Popen(command,shell=True,bufsize=-1,stdout=subprocess.PIPE) 469retCode=p.wait() 470output=p.stdout.read()[:-1] 471ifretCode!=0: 472raisesubprocess.CalledProcessError(retCode,output) 473else: 474returnoutput 475else: 476subprocess.Popen(command,shell=True,bufsize=-1)
479""" 480 Create a file with contents 481 482 Usage: C{system.create_file(fileName, contents="")} 483 484 @param fileName: full path to the file to be created 485 @param contents: contents to insert into the file 486 """ 487f=open(fileName,"w") 488f.write(contents) 489f.close()
493""" 494 Provides a simple interface for the display of some basic dialogs to collect information from the user. 495 496 This version uses Zenity to integrate well with GNOME. To pass additional arguments to Zenity that are 497 not specifically handled, use keyword arguments. For example, to pass the --timeout argument to Zenity 498 pass C{timeout="15"} as one of the parameters. All keyword arguments must be given as strings. 499 500 A note on exit codes: an exit code of 0 indicates that the user clicked OK. 501 """ 502
515""" 516 Show an information dialog 517 518 Usage: C{dialog.info_dialog(title="Information", message="", **kwargs)} 519 520 @param title: window title for the dialog 521 @param message: message displayed in the dialog 522 @return: a tuple containing the exit code and user input 523 @rtype: C{tuple(int, str)} 524 """ 525returnself.__runZenity(title,["--info","--text",message],kwargs)
526
527-definput_dialog(self,title="Enter a value",message="Enter a value",default="",**kwargs):
528""" 529 Show an input dialog 530 531 Usage: C{dialog.input_dialog(title="Enter a value", message="Enter a value", default="", **kwargs)} 532 533 @param title: window title for the dialog 534 @param message: message displayed above the input box 535 @param default: default value for the input box 536 @return: a tuple containing the exit code and user input 537 @rtype: C{tuple(int, str)} 538 """ 539returnself.__runZenity(title,["--entry","--text",message,"--entry-text",default],kwargs)
542""" 543 Show a password input dialog 544 545 Usage: C{dialog.password_dialog(title="Enter password", message="Enter password")} 546 547 @param title: window title for the dialog 548 @param message: message displayed above the password input box 549 @return: a tuple containing the exit code and user input 550 @rtype: C{tuple(int, str)} 551 """ 552returnself.__runZenity(title,["--entry","--text",message,"--hide-text"],kwargs) 553 554#def combo_menu(self, options, title="Choose an option", message="Choose an option"): 555""" 556 Show a combobox menu - not supported by zenity 557 558 Usage: C{dialog.combo_menu(options, title="Choose an option", message="Choose an option")} 559 560 @param options: list of options (strings) for the dialog 561 @param title: window title for the dialog 562 @param message: message displayed above the combobox 563 """
566-deflist_menu(self,options,title="Choose a value",message="Choose a value",default=None,**kwargs):
567""" 568 Show a single-selection list menu 569 570 Usage: C{dialog.list_menu(options, title="Choose a value", message="Choose a value", default=None, **kwargs)} 571 572 @param options: list of options (strings) for the dialog 573 @param title: window title for the dialog 574 @param message: message displayed above the list 575 @param default: default value to be selected 576 @return: a tuple containing the exit code and user choice 577 @rtype: C{tuple(int, str)} 578 """ 579 580choices=[] 581#optionNum = 0 582foroptioninoptions: 583ifoption==default: 584choices.append("TRUE") 585else: 586choices.append("FALSE") 587 588#choices.append(str(optionNum)) 589choices.append(option) 590#optionNum += 1 591 592returnself.__runZenity(title,["--list","--radiolist","--text",message,"--column"," ","--column","Options"]+choices,kwargs)
593 594#return retCode, choice 595
596-deflist_menu_multi(self,options,title="Choose one or more values",message="Choose one or more values",defaults=[],**kwargs):
597""" 598 Show a multiple-selection list menu 599 600 Usage: C{dialog.list_menu_multi(options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs)} 601 602 @param options: list of options (strings) for the dialog 603 @param title: window title for the dialog 604 @param message: message displayed above the list 605 @param defaults: list of default values to be selected 606 @return: a tuple containing the exit code and user choice 607 @rtype: C{tuple(int, str)} 608 """ 609 610choices=[] 611#optionNum = 0 612foroptioninoptions: 613ifoptionindefaults: 614choices.append("TRUE") 615else: 616choices.append("FALSE") 617 618#choices.append(str(optionNum)) 619choices.append(option) 620#optionNum += 1 621 622retCode,output=self.__runZenity(title,["--list","--checklist","--text",message,"--column"," ","--column","Options"]+choices,kwargs) 623results=output.split('|') 624 625#choices = [] 626#for choice in results: 627# choices.append(choice) 628 629returnretCode,results
632""" 633 Show an Open File dialog 634 635 Usage: C{dialog.open_file(title="Open File", **kwargs)} 636 637 @param title: window title for the dialog 638 @return: a tuple containing the exit code and file path 639 @rtype: C{tuple(int, str)} 640 """ 641#if rememberAs is not None: 642# return self.__runZenity(title, ["--getopenfilename", initialDir, fileTypes, ":" + rememberAs]) 643#else: 644returnself.__runZenity(title,["--file-selection"],kwargs)
647""" 648 Show a Save As dialog 649 650 Usage: C{dialog.save_file(title="Save As", **kwargs)} 651 652 @param title: window title for the dialog 653 @return: a tuple containing the exit code and file path 654 @rtype: C{tuple(int, str)} 655 """ 656#if rememberAs is not None: 657# return self.__runZenity(title, ["--getsavefilename", initialDir, fileTypes, ":" + rememberAs]) 658#else: 659returnself.__runZenity(title,["--file-selection","--save"],kwargs)
686-defcalendar(self,title="Choose a date",format="%Y-%m-%d",date="today",**kwargs):
687""" 688 Show a calendar dialog 689 690 Usage: C{dialog.calendar_dialog(title="Choose a date", format="%Y-%m-%d", date="YYYY-MM-DD", **kwargs)} 691 692 @param title: window title for the dialog 693 @param format: format of date to be returned 694 @param date: initial date as YYYY-MM-DD, otherwise today 695 @return: a tuple containing the exit code and date 696 @rtype: C{tuple(int, str)} 697 """ 698ifre.match(r"[0-9]{4}-[0-9]{2}-[0-9]{2}",date): 699year=date[0:4] 700month=date[5:7] 701day=date[8:10] 702date_args=["--year="+year,"--month="+month,"--day="+day] 703else: 704date_args=[] 705returnself.__runZenity(title,["--calendar","--date-format="+format]+date_args,kwargs)
718""" 719 Copy text into the X selection 720 721 Usage: C{clipboard.fill_selection(contents)} 722 723 @param contents: string to be placed in the selection 724 """ 725self.__execAsync(self.__fillSelection,contents)
732""" 733 Read text from the X selection 734 735 Usage: C{clipboard.get_selection()} 736 737 @return: text contents of the mouse selection 738 @rtype: C{str} 739 """ 740self.__execAsync(self.__getSelection) 741returnunicode(self.text)
748""" 749 Copy text into the clipboard 750 751 Usage: C{clipboard.fill_clipboard(contents)} 752 753 @param contents: string to be placed in the selection 754 """ 755self.__execAsync(self.__fillClipboard,contents)
762""" 763 Read text from the clipboard 764 765 Usage: C{clipboard.get_clipboard()} 766 767 @return: text contents of the clipboard 768 @rtype: C{str} 769 """ 770self.__execAsync(self.__getClipboard) 771returnunicode(self.text)
794""" 795 Copy text into the X selection 796 797 Usage: C{clipboard.fill_selection(contents)} 798 799 @param contents: string to be placed in the selection 800 """ 801#self.__execAsync(self.__fillSelection, contents) 802self.__fillSelection(contents)
811""" 812 Read text from the X selection 813 814 Usage: C{clipboard.get_selection()} 815 816 @return: text contents of the mouse selection 817 @rtype: C{str} 818 @raise Exception: if no text was found in the selection 819 """ 820self.__execAsync(self.selection.request_text,self.__receive) 821ifself.textisnotNone: 822returnself.text.decode("utf-8") 823else: 824raiseException("No text found in X selection")
831""" 832 Copy text into the clipboard 833 834 Usage: C{clipboard.fill_clipboard(contents)} 835 836 @param contents: string to be placed in the selection 837 """ 838self.__fillClipboard(contents)
847""" 848 Read text from the clipboard 849 850 Usage: C{clipboard.get_clipboard()} 851 852 @return: text contents of the clipboard 853 @rtype: C{str} 854 @raise Exception: if no text was found on the clipboard 855 """ 856self.__execAsync(self.clipBoard.request_text,self.__receive) 857ifself.textisnotNone: 858returnself.text.decode("utf-8") 859else: 860raiseException("No text found on clipboard")
871""" 872 Basic window management using wmctrl 873 874 Note: in all cases where a window title is required (with the exception of wait_for_focus()), 875 two special values of window title are permitted: 876 877 :ACTIVE: - select the currently active window 878 :SELECT: - select the desired window by clicking on it 879 """ 880
885""" 886 Wait for window with the given title to have focus 887 888 Usage: C{window.wait_for_focus(title, timeOut=5)} 889 890 If the window becomes active, returns True. Otherwise, returns False if 891 the window has not become active by the time the timeout has elapsed. 892 893 @param title: title to match against (as a regular expression) 894 @param timeOut: period (seconds) to wait before giving up 895 @rtype: boolean 896 """ 897regex=re.compile(title) 898waited=0 899whilewaited<=timeOut: 900ifregex.match(self.mediator.interface.get_window_title()): 901returnTrue 902 903iftimeOut==0: 904break# zero length timeout, if not matched go straight to end 905 906time.sleep(0.3) 907waited+=0.3 908 909returnFalse
912""" 913 Wait for window with the given title to be created 914 915 Usage: C{window.wait_for_exist(title, timeOut=5)} 916 917 If the window is in existence, returns True. Otherwise, returns False if 918 the window has not been created by the time the timeout has elapsed. 919 920 @param title: title to match against (as a regular expression) 921 @param timeOut: period (seconds) to wait before giving up 922 @rtype: boolean 923 """ 924regex=re.compile(title) 925waited=0 926whilewaited<=timeOut: 927retCode,output=self.__runWmctrl(["-l"]) 928forlineinoutput.split('\n'): 929ifregex.match(line[14:].split(' ',1)[-1]): 930returnTrue 931 932iftimeOut==0: 933break# zero length timeout, if not matched go straight to end 934 935time.sleep(0.3) 936waited+=0.3 937 938returnFalse
941""" 942 Activate the specified window, giving it input focus 943 944 Usage: C{window.activate(title, switchDesktop=False, matchClass=False)} 945 946 If switchDesktop is False (default), the window will be moved to the current desktop 947 and activated. Otherwise, switch to the window's current desktop and activate it there. 948 949 @param title: window title to match against (as case-insensitive substring match) 950 @param switchDesktop: whether or not to switch to the window's current desktop 951 @param matchClass: if True, match on the window class instead of the title 952 """ 953ifswitchDesktop: 954args=["-a",title] 955else: 956args=["-R",title] 957ifmatchClass: 958args+=["-x"] 959self.__runWmctrl(args)
962""" 963 Close the specified window gracefully 964 965 Usage: C{window.close(title, matchClass=False)} 966 967 @param title: window title to match against (as case-insensitive substring match) 968 @param matchClass: if True, match on the window class instead of the title 969 """ 970ifmatchClass: 971self.__runWmctrl(["-c",title,"-x"]) 972else: 973self.__runWmctrl(["-c",title])
976""" 977 Resize and/or move the specified window 978 979 Usage: C{window.close(title, xOrigin=-1, yOrigin=-1, width=-1, height=-1, matchClass=False)} 980 981 Leaving and of the position/dimension values as the default (-1) will cause that 982 value to be left unmodified. 983 984 @param title: window title to match against (as case-insensitive substring match) 985 @param xOrigin: new x origin of the window (upper left corner) 986 @param yOrigin: new y origin of the window (upper left corner) 987 @param width: new width of the window 988 @param height: new height of the window 989 @param matchClass: if True, match on the window class instead of the title 990 """ 991mvArgs=["0",str(xOrigin),str(yOrigin),str(width),str(height)] 992ifmatchClass: 993xArgs=["-x"] 994else: 995xArgs=[] 996self.__runWmctrl(["-r",title,"-e",','.join(mvArgs)]+xArgs)
1000"""1001 Move the specified window to the given desktop10021003 Usage: C{window.move_to_desktop(title, deskNum, matchClass=False)}10041005 @param title: window title to match against (as case-insensitive substring match)1006 @param deskNum: desktop to move the window to (note: zero based)1007 @param matchClass: if True, match on the window class instead of the title1008 """1009ifmatchClass:1010xArgs=["-x"]1011else:1012xArgs=[]1013self.__runWmctrl(["-r",title,"-t",str(deskNum)]+xArgs)
1017"""1018 Switch to the specified desktop10191020 Usage: C{window.switch_desktop(deskNum)}10211022 @param deskNum: desktop to switch to (note: zero based)1023 """1024self.__runWmctrl(["-s",str(deskNum)])
1027"""1028 Set a property on the given window using the specified action10291030 Usage: C{window.set_property(title, action, prop, matchClass=False)}10311032 Allowable actions: C{add, remove, toggle}1033 Allowable properties: C{modal, sticky, maximized_vert, maximized_horz, shaded, skip_taskbar,1034 skip_pager, hidden, fullscreen, above}10351036 @param title: window title to match against (as case-insensitive substring match)1037 @param action: one of the actions listed above1038 @param prop: one of the properties listed above1039 @param matchClass: if True, match on the window class instead of the title1040 """1041ifmatchClass:1042xArgs=["-x"]1043else:1044xArgs=[]1045self.__runWmctrl(["-r",title,"-b"+action+','+prop]+xArgs)
1048"""1049 Get the geometry of the currently active window10501051 Usage: C{window.get_active_geometry()}10521053 @return: a 4-tuple containing the x-origin, y-origin, width and height of the window (in pixels)1054 @rtype: C{tuple(int, int, int, int)}1055 """1056active=self.mediator.interface.get_window_title()1057result,output=self.__runWmctrl(["-l","-G"])1058matchingLine=None1059forlineinoutput.split('\n'):1060ifactiveinline[34:].split(' ',1)[-1]:1061matchingLine=line10621063ifmatchingLineisnotNone:1064output=matchingLine.split()[2:6]1065returnmap(int,output)1066else:1067returnNone
1070"""1071 Get the visible title of the currently active window10721073 Usage: C{window.get_active_title()}10741075 @return: the visible title of the currentle active window1076 @rtype: C{str}1077 """1078returnself.mediator.interface.get_window_title()
1081"""1082 Get the class of the currently active window10831084 Usage: C{window.get_active_class()}10851086 @return: the class of the currentle active window1087 @rtype: C{str}1088 """1089returnself.mediator.interface.get_window_class()
1092p=subprocess.Popen(["wmctrl"]+args,stdout=subprocess.PIPE)1093retCode=p.wait()1094output=p.stdout.read()[:-1]# Drop trailing newline10951096return(retCode,output)
1100"""1101 Provides access to the internals of AutoKey.11021103 Note that any configuration changes made using this API while the configuration window1104 is open will not appear until it is closed and re-opened.1105 """1106
1114"""1115 Retrieve a folder by its title11161117 Usage: C{engine.get_folder(title)}11181119 Note that if more than one folder has the same title, only the first match will be1120 returned.1121 """1122forfolderinself.configManager.allFolders:1123iffolder.title==title:1124returnfolder1125returnNone
1128"""1129 Create a text phrase11301131 Usage: C{engine.create_phrase(folder, description, contents)}11321133 A new phrase with no abbreviation or hotkey is created in the specified folder11341135 @param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}1136 @param description: description for the phrase1137 @param contents: the expansion text1138 """1139self.monitor.suspend()1140p=model.Phrase(description,contents)1141folder.add_item(p)1142p.persist()1143self.monitor.unsuspend()1144self.configManager.config_altered(False)
1147"""1148 Create a text abbreviation11491150 Usage: C{engine.create_abbreviation(folder, description, abbr, contents)}11511152 When the given abbreviation is typed, it will be replaced with the given1153 text.11541155 @param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}1156 @param description: description for the phrase1157 @param abbr: the abbreviation that will trigger the expansion1158 @param contents: the expansion text1159 @raise Exception: if the specified abbreviation is not unique1160 """1161ifnotself.configManager.check_abbreviation_unique(abbr,None,None):1162raiseException("The specified abbreviation is already in use")11631164self.monitor.suspend()1165p=model.Phrase(description,contents)1166p.modes.append(model.TriggerMode.ABBREVIATION)1167p.abbreviations=[abbr]1168folder.add_item(p)1169p.persist()1170self.monitor.unsuspend()1171self.configManager.config_altered(False)
1174"""1175 Create a text hotkey11761177 Usage: C{engine.create_hotkey(folder, description, modifiers, key, contents)}11781179 When the given hotkey is pressed, it will be replaced with the given1180 text. Modifiers must be given as a list of strings, with the following1181 values permitted:11821183 <ctrl>1184 <alt>1185 <super>1186 <hyper>1187 <shift>11881189 The key must be an unshifted character (i.e. lowercase)11901191 @param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}1192 @param description: description for the phrase1193 @param modifiers: modifiers to use with the hotkey (as a list)1194 @param key: the hotkey1195 @param contents: the expansion text1196 @raise Exception: if the specified hotkey is not unique1197 """1198modifiers.sort()1199ifnotself.configManager.check_hotkey_unique(modifiers,key,None,None):1200raiseException("The specified hotkey and modifier combination is already in use")12011202self.monitor.suspend()1203p=model.Phrase(description,contents)1204p.modes.append(model.TriggerMode.HOTKEY)1205p.set_hotkey(modifiers,key)1206folder.add_item(p)1207p.persist()1208self.monitor.unsuspend()1209self.configManager.config_altered(False)
1212"""1213 Run an existing script using its description to look it up12141215 Usage: C{engine.run_script(description)}12161217 @param description: description of the script to run1218 @raise Exception: if the specified script does not exist1219 """1220targetScript=None1221foriteminself.configManager.allItems:1222ifitem.description==descriptionandisinstance(item,model.Script):1223targetScript=item12241225iftargetScriptisnotNone:1226self.runner.run_subscript(targetScript)1227else:1228raiseException("No script with description '%s' found"%description)
1231"""1232 Used internally by AutoKey for phrase macros1233 """1234self.__macroArgs=args["args"].split(',')12351236try:1237self.run_script(args["name"])1238exceptException,e:1239self.set_return_value("{ERROR: %s}"%str(e))
1242"""1243 Get the arguments supplied to the current script via its macro12441245 Usage: C{engine.get_macro_arguments()}12461247 @return: the arguments1248 @rtype: C{list(str())}1249 """1250returnself.__macroArgs
1253"""1254 Store a return value to be used by a phrase macro12551256 Usage: C{engine.set_return_value(val)}12571258 @param val: value to be stored1259 """1260self.__returnValue=val
lib.scripting.__package__ [hide private]
autokey-0.90.4/doc/scripting/epydoc.css 0000664 0001750 0001750 00000037227 11361556176 017063 0 ustar chris chris
/* Epydoc CSS Stylesheet
*
* This stylesheet can be used to customize the appearance of epydoc's
* HTML output.
*
*/
/* Default Colors & Styles
* - Set the default foreground & background color with 'body'; and
* link colors with 'a:link' and 'a:visited'.
* - Use bold for decision list terms.
* - The heading styles defined here are used for headings *within*
* docstring descriptions. All headings used by epydoc itself use
* either class='epydoc' or class='toc' (CSS styles for both
* defined below).
*/
body { background: #ffffff; color: #000000; }
p { margin-top: 0.5em; margin-bottom: 0.5em; }
a:link { color: #0000ff; }
a:visited { color: #204080; }
dt { font-weight: bold; }
h1 { font-size: +140%; font-style: italic;
font-weight: bold; }
h2 { font-size: +125%; font-style: italic;
font-weight: bold; }
h3 { font-size: +110%; font-style: italic;
font-weight: normal; }
code { font-size: 100%; }
/* N.B.: class, not pseudoclass */
a.link { font-family: monospace; }
/* Page Header & Footer
* - The standard page header consists of a navigation bar (with
* pointers to standard pages such as 'home' and 'trees'); a
* breadcrumbs list, which can be used to navigate to containing
* classes or modules; options links, to show/hide private
* variables and to show/hide frames; and a page title (using
*
). The page title may be followed by a link to the
* corresponding source code (using 'span.codelink').
* - The footer consists of a navigation bar, a timestamp, and a
* pointer to epydoc's homepage.
*/
h1.epydoc { margin: 0; font-size: +140%; font-weight: bold; }
h2.epydoc { font-size: +130%; font-weight: bold; }
h3.epydoc { font-size: +115%; font-weight: bold;
margin-top: 0.2em; }
td h3.epydoc { font-size: +115%; font-weight: bold;
margin-bottom: 0; }
table.navbar { background: #a0c0ff; color: #000000;
border: 2px groove #c0d0d0; }
table.navbar table { color: #000000; }
th.navbar-select { background: #70b0ff;
color: #000000; }
table.navbar a { text-decoration: none; }
table.navbar a:link { color: #0000ff; }
table.navbar a:visited { color: #204080; }
span.breadcrumbs { font-size: 85%; font-weight: bold; }
span.options { font-size: 70%; }
span.codelink { font-size: 85%; }
td.footer { font-size: 85%; }
/* Table Headers
* - Each summary table and details section begins with a 'header'
* row. This row contains a section title (marked by
* 'span.table-header') as well as a show/hide private link
* (marked by 'span.options', defined above).
* - Summary tables that contain user-defined groups mark those
* groups using 'group header' rows.
*/
td.table-header { background: #70b0ff; color: #000000;
border: 1px solid #608090; }
td.table-header table { color: #000000; }
td.table-header table a:link { color: #0000ff; }
td.table-header table a:visited { color: #204080; }
span.table-header { font-size: 120%; font-weight: bold; }
th.group-header { background: #c0e0f8; color: #000000;
text-align: left; font-style: italic;
font-size: 115%;
border: 1px solid #608090; }
/* Summary Tables (functions, variables, etc)
* - Each object is described by a single row of the table with
* two cells. The left cell gives the object's type, and is
* marked with 'code.summary-type'. The right cell gives the
* object's name and a summary description.
* - CSS styles for the table's header and group headers are
* defined above, under 'Table Headers'
*/
table.summary { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin-bottom: 0.5em; }
td.summary { border: 1px solid #608090; }
code.summary-type { font-size: 85%; }
table.summary a:link { color: #0000ff; }
table.summary a:visited { color: #204080; }
/* Details Tables (functions, variables, etc)
* - Each object is described in its own div.
* - A single-row summary table w/ table-header is used as
* a header for each details section (CSS style for table-header
* is defined above, under 'Table Headers').
*/
table.details { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin: .2em 0 0 0; }
table.details table { color: #000000; }
table.details a:link { color: #0000ff; }
table.details a:visited { color: #204080; }
/* Fields */
dl.fields { margin-left: 2em; margin-top: 1em;
margin-bottom: 1em; }
dl.fields dd ul { margin-left: 0em; padding-left: 0em; }
dl.fields dd ul li ul { margin-left: 2em; padding-left: 0em; }
div.fields { margin-left: 2em; }
div.fields p { margin-bottom: 0.5em; }
/* Index tables (identifier index, term index, etc)
* - link-index is used for indices containing lists of links
* (namely, the identifier index & term index).
* - index-where is used in link indices for the text indicating
* the container/source for each link.
* - metadata-index is used for indices containing metadata
* extracted from fields (namely, the bug index & todo index).
*/
table.link-index { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090; }
td.link-index { border-width: 0px; }
table.link-index a:link { color: #0000ff; }
table.link-index a:visited { color: #204080; }
span.index-where { font-size: 70%; }
table.metadata-index { border-collapse: collapse;
background: #e8f0f8; color: #000000;
border: 1px solid #608090;
margin: .2em 0 0 0; }
td.metadata-index { border-width: 1px; border-style: solid; }
table.metadata-index a:link { color: #0000ff; }
table.metadata-index a:visited { color: #204080; }
/* Function signatures
* - sig* is used for the signature in the details section.
* - .summary-sig* is used for the signature in the summary
* table, and when listing property accessor functions.
* */
.sig-name { color: #006080; }
.sig-arg { color: #008060; }
.sig-default { color: #602000; }
.summary-sig { font-family: monospace; }
.summary-sig-name { color: #006080; font-weight: bold; }
table.summary a.summary-sig-name:link
{ color: #006080; font-weight: bold; }
table.summary a.summary-sig-name:visited
{ color: #006080; font-weight: bold; }
.summary-sig-arg { color: #006040; }
.summary-sig-default { color: #501800; }
/* Subclass list
*/
ul.subclass-list { display: inline; }
ul.subclass-list li { display: inline; }
/* To render variables, classes etc. like functions */
table.summary .summary-name { color: #006080; font-weight: bold;
font-family: monospace; }
table.summary
a.summary-name:link { color: #006080; font-weight: bold;
font-family: monospace; }
table.summary
a.summary-name:visited { color: #006080; font-weight: bold;
font-family: monospace; }
/* Variable values
* - In the 'variable details' sections, each varaible's value is
* listed in a 'pre.variable' box. The width of this box is
* restricted to 80 chars; if the value's repr is longer than
* this it will be wrapped, using a backslash marked with
* class 'variable-linewrap'. If the value's repr is longer
* than 3 lines, the rest will be ellided; and an ellipsis
* marker ('...' marked with 'variable-ellipsis') will be used.
* - If the value is a string, its quote marks will be marked
* with 'variable-quote'.
* - If the variable is a regexp, it is syntax-highlighted using
* the re* CSS classes.
*/
pre.variable { padding: .5em; margin: 0;
background: #dce4ec; color: #000000;
border: 1px solid #708890; }
.variable-linewrap { color: #604000; font-weight: bold; }
.variable-ellipsis { color: #604000; font-weight: bold; }
.variable-quote { color: #604000; font-weight: bold; }
.variable-group { color: #008000; font-weight: bold; }
.variable-op { color: #604000; font-weight: bold; }
.variable-string { color: #006030; }
.variable-unknown { color: #a00000; font-weight: bold; }
.re { color: #000000; }
.re-char { color: #006030; }
.re-op { color: #600000; }
.re-group { color: #003060; }
.re-ref { color: #404040; }
/* Base tree
* - Used by class pages to display the base class hierarchy.
*/
pre.base-tree { font-size: 80%; margin: 0; }
/* Frames-based table of contents headers
* - Consists of two frames: one for selecting modules; and
* the other listing the contents of the selected module.
* - h1.toc is used for each frame's heading
* - h2.toc is used for subheadings within each frame.
*/
h1.toc { text-align: center; font-size: 105%;
margin: 0; font-weight: bold;
padding: 0; }
h2.toc { font-size: 100%; font-weight: bold;
margin: 0.5em 0 0 -0.3em; }
/* Syntax Highlighting for Source Code
* - doctest examples are displayed in a 'pre.py-doctest' block.
* If the example is in a details table entry, then it will use
* the colors specified by the 'table pre.py-doctest' line.
* - Source code listings are displayed in a 'pre.py-src' block.
* Each line is marked with 'span.py-line' (used to draw a line
* down the left margin, separating the code from the line
* numbers). Line numbers are displayed with 'span.py-lineno'.
* The expand/collapse block toggle button is displayed with
* 'a.py-toggle' (Note: the CSS style for 'a.py-toggle' should not
* modify the font size of the text.)
* - If a source code page is opened with an anchor, then the
* corresponding code block will be highlighted. The code
* block's header is highlighted with 'py-highlight-hdr'; and
* the code block's body is highlighted with 'py-highlight'.
* - The remaining py-* classes are used to perform syntax
* highlighting (py-string for string literals, py-name for names,
* etc.)
*/
pre.py-doctest { padding: .5em; margin: 1em;
background: #e8f0f8; color: #000000;
border: 1px solid #708890; }
table pre.py-doctest { background: #dce4ec;
color: #000000; }
pre.py-src { border: 2px solid #000000;
background: #f0f0f0; color: #000000; }
.py-line { border-left: 2px solid #000000;
margin-left: .2em; padding-left: .4em; }
.py-lineno { font-style: italic; font-size: 90%;
padding-left: .5em; }
a.py-toggle { text-decoration: none; }
div.py-highlight-hdr { border-top: 2px solid #000000;
border-bottom: 2px solid #000000;
background: #d8e8e8; }
div.py-highlight { border-bottom: 2px solid #000000;
background: #d0e0e0; }
.py-prompt { color: #005050; font-weight: bold;}
.py-more { color: #005050; font-weight: bold;}
.py-string { color: #006030; }
.py-comment { color: #003060; }
.py-keyword { color: #600000; }
.py-output { color: #404040; }
.py-name { color: #000050; }
.py-name:link { color: #000050 !important; }
.py-name:visited { color: #000050 !important; }
.py-number { color: #005000; }
.py-defname { color: #000060; font-weight: bold; }
.py-def-name { color: #000060; font-weight: bold; }
.py-base-class { color: #000060; }
.py-param { color: #000060; }
.py-docstring { color: #006030; }
.py-decorator { color: #804020; }
/* Use this if you don't want links to names underlined: */
/*a.py-name { text-decoration: none; }*/
/* Graphs & Diagrams
* - These CSS styles are used for graphs & diagrams generated using
* Graphviz dot. 'img.graph-without-title' is used for bare
* diagrams (to remove the border created by making the image
* clickable).
*/
img.graph-without-title { border: none; }
img.graph-with-title { border: 1px solid #000000; }
span.graph-title { font-weight: bold; }
span.graph-caption { }
/* General-purpose classes
* - 'p.indent-wrapped-lines' defines a paragraph whose first line
* is not indented, but whose subsequent lines are.
* - The 'nomargin-top' class is used to remove the top margin (e.g.
* from lists). The 'nomargin' class is used to remove both the
* top and bottom margin (but not the left or right margin --
* for lists, that would cause the bullets to disappear.)
*/
p.indent-wrapped-lines { padding: 0 0 0 7em; text-indent: -7em;
margin: 0; }
.nomargin-top { margin-top: 0; }
.nomargin { margin-top: 0; margin-bottom: 0; }
/* HTML Log */
div.log-block { padding: 0; margin: .5em 0 .5em 0;
background: #e8f0f8; color: #000000;
border: 1px solid #000000; }
div.log-error { padding: .1em .3em .1em .3em; margin: 4px;
background: #ffb0b0; color: #000000;
border: 1px solid #000000; }
div.log-warning { padding: .1em .3em .1em .3em; margin: 4px;
background: #ffffb0; color: #000000;
border: 1px solid #000000; }
div.log-info { padding: .1em .3em .1em .3em; margin: 4px;
background: #b0ffb0; color: #000000;
border: 1px solid #000000; }
h2.log-hdr { background: #70b0ff; color: #000000;
margin: 0; padding: 0em 0.5em 0em 0.5em;
border-bottom: 1px solid #000000; font-size: 110%; }
p.log { font-weight: bold; margin: .5em 0 .5em 0; }
tr.opt-changed { color: #000000; font-weight: bold; }
tr.opt-default { color: #606060; }
pre.log { margin: 0; padding: 0; padding-left: 1em; }
autokey-0.90.4/doc/scripting/index.html 0000664 0001750 0001750 00000001123 11361556017 017037 0 ustar chris chris
API Documentation
autokey-0.90.4/doc/scripting/lib.scripting.Keyboard-class.html 0000664 0001750 0001750 00000043000 11744235773 023351 0 ustar chris chris
lib.scripting.Keyboard
Provides a simple interface for the display of some basic dialogs to
collect information from the user.
This version uses KDialog to integrate well with KDE. To pass
additional arguments to KDialog that are not specifically handled, use
keyword arguments. For example, to pass the --geometry argument to
KDialog to specify the desired size of the dialog, pass
geometry="700x400" as one of the parameters. All
keyword arguments must be given as strings.
A note on exit codes: an exit code of 0 indicates that the user
clicked OK.
list_menu_multi(self,
options,
title='Choose one or more values',
message='Choose one or more values',
defaults=[],
**kwargs)
Show a multiple-selection list menu
When the given hotkey is pressed, it will be replaced with the given
text. Modifiers must be given as a list of strings, with the following
values permitted:
<ctrl> <alt> <super> <hyper> <shift>
The key must be an unshifted character (i.e. lowercase)
Parameters:
folder - folder to place the abbreviation in, retrieved using
engine.get_folder()
description - description for the phrase
modifiers - modifiers to use with the hotkey (as a list)
Provides a simple interface for the display of some basic dialogs to
collect information from the user.
This version uses Zenity to integrate well with GNOME. To pass
additional arguments to Zenity that are not specifically handled, use
keyword arguments. For example, to pass the --timeout argument to Zenity
pass timeout="15" as one of the parameters. All
keyword arguments must be given as strings.
A note on exit codes: an exit code of 0 indicates that the user
clicked OK.
list_menu_multi(self,
options,
title='Choose one or more values',
message='Choose one or more values',
defaults=[],
**kwargs)
Show a multiple-selection list menu
If switchDesktop is False (default), the window will be moved to the
current desktop and activated. Otherwise, switch to the window's current
desktop and activate it there.
Parameters:
title - window title to match against (as case-insensitive substring
match)
switchDesktop - whether or not to switch to the window's current desktop
matchClass - if True, match on the window class instead of the title
This document contains the API (Application Programming Interface)
documentation for this project. Documentation for the Python
objects defined by the project is divided into separate pages for each
package, module, and class. The API documentation also includes two
pages containing information about the project as a whole: a trees
page, and an index page.
Object Documentation
Each Package Documentation page contains:
A description of the package.
A list of the modules and sub-packages contained by the
package.
A summary of the classes defined by the package.
A summary of the functions defined by the package.
A summary of the variables defined by the package.
A detailed description of each function defined by the
package.
A detailed description of each variable defined by the
package.
Each Module Documentation page contains:
A description of the module.
A summary of the classes defined by the module.
A summary of the functions defined by the module.
A summary of the variables defined by the module.
A detailed description of each function defined by the
module.
A detailed description of each variable defined by the
module.
Each Class Documentation page contains:
A class inheritance diagram.
A list of known subclasses.
A description of the class.
A summary of the methods defined by the class.
A summary of the instance variables defined by the class.
A summary of the class (static) variables defined by the
class.
A detailed description of each method defined by the
class.
A detailed description of each instance variable defined by the
class.
A detailed description of each class (static) variable defined
by the class.
Project Documentation
The Trees page contains the module and class hierarchies:
The module hierarchy lists every package and module, with
modules grouped into packages. At the top level, and within each
package, modules and sub-packages are listed alphabetically.
The class hierarchy lists every class, grouped by base
class. If a class has more than one base class, then it will be
listed under each base class. At the top level, and under each base
class, classes are listed alphabetically.
The Index page contains indices of terms and
identifiers:
The term index lists every term indexed by any object's
documentation. For each term, the index provides links to each
place where the term is indexed.
The identifier index lists the (short) name of every package,
module, class, method, function, variable, and parameter. For each
identifier, the index provides a short description, and a link to
its documentation.
The Table of Contents
The table of contents occupies the two frames on the left side of
the window. The upper-left frame displays the project
contents, and the lower-left frame displays the module
contents:
Project Contents...
API Documentation Frame
Module Contents ...
The project contents frame contains a list of all packages
and modules that are defined by the project. Clicking on an entry
will display its contents in the module contents frame. Clicking on a
special entry, labeled "Everything," will display the contents of
the entire project.
The module contents frame contains a list of every
submodule, class, type, exception, function, and variable defined by a
module or package. Clicking on an entry will display its
documentation in the API documentation frame. Clicking on the name of
the module, at the top of the frame, will display the documentation
for the module itself.
The "frames" and "no frames" buttons below the top
navigation bar can be used to control whether the table of contents is
displayed or not.
The Navigation Bar
A navigation bar is located at the top and bottom of every page.
It indicates what type of page you are currently viewing, and allows
you to go to related pages. The following table describes the labels
on the navigation bar. Note that not some labels (such as
[Parent]) are not displayed on all pages.
Label
Highlighted when...
Links to...
[Parent]
(never highlighted)
the parent of the current package
[Package]
viewing a package
the package containing the current object
[Module]
viewing a module
the module containing the current object
[Class]
viewing a class
the class containing the current object
[Trees]
viewing the trees page
the trees page
[Index]
viewing the index page
the index page
[Help]
viewing the help page
the help page
The "show private" and "hide private" buttons below
the top navigation bar can be used to control whether documentation
for private objects is displayed. Private objects are usually defined
as objects whose (short) names begin with a single underscore, but do
not end with an underscore. For example, "_x",
"__pprint", and "epydoc.epytext._tokenize"
are private objects; but "re.sub",
"__init__", and "type_" are not. However,
if a module defines the "__all__" variable, then its
contents are used to decide which objects are private.
A timestamp below the bottom navigation bar indicates when each
page was last updated.
autokey-0.90.4/doc/scripting/epydoc.js 0000664 0001750 0001750 00000024525 11361570551 016675 0 ustar chris chris function toggle_private() {
// Search for any private/public links on this page. Store
// their old text in "cmd," so we will know what action to
// take; and change their text to the opposite action.
var cmd = "?";
var elts = document.getElementsByTagName("a");
for(var i=0; i... ";
elt.innerHTML = s;
}
}
function toggle(id) {
elt = document.getElementById(id+"-toggle");
if (elt.innerHTML == "-")
collapse(id);
else
expand(id);
return false;
}
function highlight(id) {
var elt = document.getElementById(id+"-def");
if (elt) elt.className = "py-highlight-hdr";
var elt = document.getElementById(id+"-expanded");
if (elt) elt.className = "py-highlight";
var elt = document.getElementById(id+"-collapsed");
if (elt) elt.className = "py-highlight";
}
function num_lines(s) {
var n = 1;
var pos = s.indexOf("\n");
while ( pos > 0) {
n += 1;
pos = s.indexOf("\n", pos+1);
}
return n;
}
// Collapse all blocks that mave more than `min_lines` lines.
function collapse_all(min_lines) {
var elts = document.getElementsByTagName("div");
for (var i=0; i 0)
if (elt.id.substring(split, elt.id.length) == "-expanded")
if (num_lines(elt.innerHTML) > min_lines)
collapse(elt.id.substring(0, split));
}
}
function expandto(href) {
var start = href.indexOf("#")+1;
if (start != 0 && start != href.length) {
if (href.substring(start, href.length) != "-") {
collapse_all(4);
pos = href.indexOf(".", start);
while (pos != -1) {
var id = href.substring(start, pos);
expand(id);
pos = href.indexOf(".", pos+1);
}
var id = href.substring(start, href.length);
expand(id);
highlight(id);
}
}
}
function kill_doclink(id) {
var parent = document.getElementById(id);
parent.removeChild(parent.childNodes.item(0));
}
function auto_kill_doclink(ev) {
if (!ev) var ev = window.event;
if (!this.contains(ev.toElement)) {
var parent = document.getElementById(this.parentID);
parent.removeChild(parent.childNodes.item(0));
}
}
function doclink(id, name, targets_id) {
var elt = document.getElementById(id);
// If we already opened the box, then destroy it.
// (This case should never occur, but leave it in just in case.)
if (elt.childNodes.length > 1) {
elt.removeChild(elt.childNodes.item(0));
}
else {
// The outer box: relative + inline positioning.
var box1 = document.createElement("div");
box1.style.position = "relative";
box1.style.display = "inline";
box1.style.top = 0;
box1.style.left = 0;
// A shadow for fun
var shadow = document.createElement("div");
shadow.style.position = "absolute";
shadow.style.left = "-1.3em";
shadow.style.top = "-1.3em";
shadow.style.background = "#404040";
// The inner box: absolute positioning.
var box2 = document.createElement("div");
box2.style.position = "relative";
box2.style.border = "1px solid #a0a0a0";
box2.style.left = "-.2em";
box2.style.top = "-.2em";
box2.style.background = "white";
box2.style.padding = ".3em .4em .3em .4em";
box2.style.fontStyle = "normal";
box2.onmouseout=auto_kill_doclink;
box2.parentID = id;
// Get the targets
var targets_elt = document.getElementById(targets_id);
var targets = targets_elt.getAttribute("targets");
var links = "";
target_list = targets.split(",");
for (var i=0; i" +
target[0] + "";
}
// Put it all together.
elt.insertBefore(box1, elt.childNodes.item(0));
//box1.appendChild(box2);
box1.appendChild(shadow);
shadow.appendChild(box2);
box2.innerHTML =
"Which "+name+" do you want to see documentation for?" +
"
";
}
return false;
}
function get_anchor() {
var href = location.href;
var start = href.indexOf("#")+1;
if ((start != 0) && (start != href.length))
return href.substring(start, href.length);
}
function redirect_url(dottedName) {
// Scan through each element of the "pages" list, and check
// if "name" matches with any of them.
for (var i=0; i-m" or "-c";
// extract the portion & compare it to dottedName.
var pagename = pages[i].substring(0, pages[i].length-2);
if (pagename == dottedName.substring(0,pagename.length)) {
// We've found a page that matches `dottedName`;
// construct its URL, using leftover `dottedName`
// content to form an anchor.
var pagetype = pages[i].charAt(pages[i].length-1);
var url = pagename + ((pagetype=="m")?"-module.html":
"-class.html");
if (dottedName.length > pagename.length)
url += "#" + dottedName.substring(pagename.length+1,
dottedName.length);
return url;
}
}
}
autokey-0.90.4/doc/scripting/lib.scripting.System-class.html 0000664 0001750 0001750 00000023173 11744235773 023106 0 ustar chris chris
lib.scripting.System
Set getOutput to False if the command does not exit and return
immediately. Otherwise AutoKey will not respond to any
hotkeys/abbreviations etc until the process started by the command
exits.
Parameters:
command - command to be executed (including any arguments) - e.g. "ls
-l"
getOutput - whether to capture the (stdout) output of the command
Raises:
subprocess.CalledProcessError - if the command returns a non-zero exit code
autokey-0.90.4/src/lib/macro.py 0000664 0001750 0001750 00000007756 11736014276 015327 0 ustar chris chris from iomediator import KEY_SPLIT_RE, Key
import common
if common.USING_QT:
from PyKDE4.kdecore import ki18n
from PyKDE4.kdeui import KMenu, KAction
from PyQt4.QtCore import SIGNAL
_ = ki18n
class MacroAction(KAction):
def __init__(self, menu, macro, callback):
KAction.__init__(self, macro.TITLE.toString(), menu)
self.macro = macro
self.callback = callback
self.connect(self, SIGNAL("triggered()"), self.on_triggered)
def on_triggered(self):
self.callback(self.macro)
else:
from gi.repository import Gtk
class MacroManager:
def __init__(self, engine):
self.macros = []
self.macros.append(ScriptMacro(engine))
self.macros.append(DateMacro())
self.macros.append(FileContentsMacro())
self.macros.append(CursorMacro())
def get_menu(self, callback, menu=None):
if common.USING_QT:
for macro in self.macros:
menu.addAction(MacroAction(menu, macro, callback))
else:
menu = Gtk.Menu()
for macro in self.macros:
menuItem = Gtk.MenuItem(macro.TITLE)
menuItem.connect("activate", callback, macro)
menu.append(menuItem)
menu.show_all()
return menu
def process_expansion(self, expansion):
parts = KEY_SPLIT_RE.split(expansion.string)
for macro in self.macros:
macro.process(parts)
expansion.string = ''.join(parts)
class AbstractMacro:
def get_token(self):
ret = "<%s" % self.ID
if len(self.ARGS) == 0:
ret += ">"
else:
for k, v in self.ARGS:
ret += " "
ret += k
ret += "="
ret += ">"
return ret
def _can_process(self, token):
if KEY_SPLIT_RE.match(token):
return token[1:-1].split(' ', 1)[0] == self.ID
else:
return False
def _get_args(self, token):
l = token[:-1].split(' ')
ret = {}
if len(l) > 1:
for arg in l[1:]:
key, val = arg.split('=', 1)
ret[key] = val
for k, v in self.ARGS:
if k not in ret:
raise Exception("Missing mandatory argument '%s' for macro '%s'" % (k, self.ID))
return ret
def process(self, parts):
for i in xrange(len(parts)):
if self._can_process(parts[i]):
self.do_process(parts, i)
class CursorMacro(AbstractMacro):
ID = "cursor"
TITLE = _("Position cursor")
ARGS = []
def do_process(self, parts, i):
try:
lefts = len(''.join(parts[i+1:]))
parts.append(Key.LEFT * lefts)
parts[i] = ''
except IndexError:
pass
class ScriptMacro(AbstractMacro):
ID = "script"
TITLE = _("Run script")
ARGS = [("name", _("Name")),
("args", _("Arguments (comma separated)"))]
def __init__(self, engine):
self.engine = engine
def do_process(self, parts, i):
args = self._get_args(parts[i])
self.engine.run_script_from_macro(args)
parts[i] = self.engine.get_return_value()
class DateMacro(AbstractMacro):
ID = "date"
TITLE = _("Insert date")
ARGS = [("format", _("Format"))]
def do_process(self, parts, i):
format = self._get_args(parts[i])["format"]
date = datetime.datetime.now().strftime(format)
parts[i] = date
class FileContentsMacro(AbstractMacro):
ID = "file"
TITLE = _("Insert file contents")
ARGS = [("name", _("File name"))]
def do_process(self, parts, i):
name = self._get_args(parts[i])["name"]
with open(name, "r") as inputFile:
parts[i] = inputFile.read()
autokey-0.90.4/src/lib/scripting.py 0000664 0001750 0001750 00000132204 11754436675 016226 0 ustar chris chris # -*- coding: utf-8 -*-
# Copyright (C) 2011 Chris Dekter
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
import subprocess, threading, time, re
import common, model, iomediator
if common.USING_QT:
from PyQt4.QtGui import QClipboard, QApplication
else:
from gi.repository import Gtk, Gdk
class Keyboard:
"""
Provides access to the keyboard for event generation.
"""
def __init__(self, mediator):
self.mediator = mediator
def send_keys(self, keyString):
"""
Send a sequence of keys via keyboard events
Usage: C{keyboard.send_keys(keyString)}
@param keyString: string of keys (including special keys) to send
"""
self.mediator.interface.begin_send()
self.mediator.send_string(keyString.decode("utf-8"))
self.mediator.interface.finish_send()
def send_key(self, key, repeat=1):
"""
Send a keyboard event
Usage: C{keyboard.send_key(key, repeat=1)}
@param key: they key to be sent (e.g. "s" or "")
@param repeat: number of times to repeat the key event
"""
for x in xrange(repeat):
self.mediator.send_key(key.decode("utf-8"))
self.mediator.flush()
def press_key(self, key):
"""
Send a key down event
Usage: C{keyboard.press_key(key)}
The key will be treated as down until a matching release_key() is sent.
@param key: they key to be pressed (e.g. "s" or "")
"""
self.mediator.press_key(key.decode("utf-8"))
def release_key(self, key):
"""
Send a key up event
Usage: C{keyboard.release_key(key)}
If the specified key was not made down using press_key(), the event will be
ignored.
@param key: they key to be released (e.g. "s" or "")
"""
self.mediator.release_key(key.decode("utf-8"))
def fake_keypress(self, key, repeat=1):
"""
Fake a keypress
Usage: C{keyboard.fake_keypress(key, repeat=1)}
Uses XTest to 'fake' a keypress. This is useful to send keypresses to some
applications which won't respond to keyboard.send_key()
@param key: they key to be sent (e.g. "s" or "")
@param repeat: number of times to repeat the key event
"""
for x in xrange(repeat):
self.mediator.fake_keypress(key.decode("utf-8"))
def wait_for_keypress(self, key, modifiers=[], timeOut=10.0):
"""
Wait for a keypress or key combination
Usage: C{keyboard.wait_for_keypress(self, key, modifiers=[], timeOut=10.0)}
Note: this function cannot be used to wait for modifier keys on their own
@param key: they key to wait for
@param modifiers: list of modifiers that should be pressed with the key
@param timeOut: maximum time, in seconds, to wait for the keypress to occur
"""
w = iomediator.Waiter(key, modifiers, None, timeOut)
w.wait()
class Mouse:
"""
Provides access to send mouse clicks
"""
def __init__(self, mediator):
self.mediator = mediator
def click_relative(self, x, y, button):
"""
Send a mouse click relative to the active window
Usage: C{mouse.click_relative(x, y, button)}
@param x: x-coordinate in pixels, relative to upper left corner of window
@param y: y-coordinate in pixels, relative to upper left corner of window
@param button: mouse button to simulate (left=1, middle=2, right=3)
"""
self.mediator.send_mouse_click(x, y, button, True)
def click_relative_self(self, x, y, button):
"""
Send a mouse click relative to the current mouse position
Usage: C{mouse.click_relative_self(x, y, button)}
@param x: x-offset in pixels, relative to current mouse position
@param y: y-offset in pixels, relative to current mouse position
@param button: mouse button to simulate (left=1, middle=2, right=3)
"""
self.mediator.send_mouse_click_relative(x, y, button)
def click_absolute(self, x, y, button):
"""
Send a mouse click relative to the screen (absolute)
Usage: C{mouse.click_absolute(x, y, button)}
@param x: x-coordinate in pixels, relative to upper left corner of window
@param y: y-coordinate in pixels, relative to upper left corner of window
@param button: mouse button to simulate (left=1, middle=2, right=3)
"""
self.mediator.send_mouse_click(x, y, button, False)
def wait_for_click(self, button, timeOut=10.0):
"""
Wait for a mouse click
Usage: C{mouse.wait_for_click(self, button, timeOut=10.0)}
@param button: they mouse button click to wait for as a button number, 1-9
@param timeOut: maximum time, in seconds, to wait for the keypress to occur
"""
button = int(button)
w = iomediator.Waiter(None, None, button, timeOut)
w.wait()
class Store(dict):
"""
Allows persistent storage of values between invocations of the script.
"""
def set_value(self, key, value):
"""
Store a value
Usage: C{store.set_value(key, value)}
"""
self[key] = value
def get_value(self, key):
"""
Get a value
Usage: C{store.get_value(key)}
"""
return self[key]
def remove_value(self, key):
"""
Remove a value
Usage: C{store.remove_value(key)}
"""
del self[key]
def set_global_value(self, key, value):
"""
Store a global value
Usage: C{store.set_global_value(key, value)}
The value stored with this method will be available to all scripts.
"""
Store.GLOBALS[key] = value
def get_global_value(self, key):
"""
Get a global value
Usage: C{store.get_global_value(key)}
"""
return self.GLOBALS[key]
def remove_global_value(self, key):
"""
Remove a global value
Usage: C{store.remove_global_value(key)}
"""
del self.GLOBALS[key]
class QtDialog:
"""
Provides a simple interface for the display of some basic dialogs to collect information from the user.
This version uses KDialog to integrate well with KDE. To pass additional arguments to KDialog that are
not specifically handled, use keyword arguments. For example, to pass the --geometry argument to KDialog
to specify the desired size of the dialog, pass C{geometry="700x400"} as one of the parameters. All
keyword arguments must be given as strings.
A note on exit codes: an exit code of 0 indicates that the user clicked OK.
"""
def __runKdialog(self, title, args, kwargs):
for k, v in kwargs.iteritems():
args.append("--" + k)
args.append(v)
p = subprocess.Popen(["kdialog", "--title", title] + args, stdout=subprocess.PIPE)
retCode = p.wait()
output = p.stdout.read()[:-1] # Drop trailing newline
return (retCode, output)
def info_dialog(self, title="Information", message="", **kwargs):
"""
Show an information dialog
Usage: C{dialog.info_dialog(title="Information", message="", **kwargs)}
@param title: window title for the dialog
@param message: message displayed in the dialog
@return: a tuple containing the exit code and user input
@rtype: C{tuple(int, str)}
"""
return self.__runKdialog(title, ["--msgbox", message], kwargs)
def input_dialog(self, title="Enter a value", message="Enter a value", default="", **kwargs):
"""
Show an input dialog
Usage: C{dialog.input_dialog(title="Enter a value", message="Enter a value", default="", **kwargs)}
@param title: window title for the dialog
@param message: message displayed above the input box
@param default: default value for the input box
@return: a tuple containing the exit code and user input
@rtype: C{tuple(int, str)}
"""
return self.__runKdialog(title, ["--inputbox", message, default], kwargs)
def password_dialog(self, title="Enter password", message="Enter password", **kwargs):
"""
Show a password input dialog
Usage: C{dialog.password_dialog(title="Enter password", message="Enter password", **kwargs)}
@param title: window title for the dialog
@param message: message displayed above the password input box
@return: a tuple containing the exit code and user input
@rtype: C{tuple(int, str)}
"""
return self.__runKdialog(title, ["--password", message], kwargs)
def combo_menu(self, options, title="Choose an option", message="Choose an option", **kwargs):
"""
Show a combobox menu
Usage: C{dialog.combo_menu(options, title="Choose an option", message="Choose an option", **kwargs)}
@param options: list of options (strings) for the dialog
@param title: window title for the dialog
@param message: message displayed above the combobox
@return: a tuple containing the exit code and user choice
@rtype: C{tuple(int, str)}
"""
return self.__runKdialog(title, ["--combobox", message] + options, kwargs)
def list_menu(self, options, title="Choose a value", message="Choose a value", default=None, **kwargs):
"""
Show a single-selection list menu
Usage: C{dialog.list_menu(options, title="Choose a value", message="Choose a value", default=None, **kwargs)}
@param options: list of options (strings) for the dialog
@param title: window title for the dialog
@param message: message displayed above the list
@param default: default value to be selected
@return: a tuple containing the exit code and user choice
@rtype: C{tuple(int, str)}
"""
choices = []
optionNum = 0
for option in options:
choices.append(str(optionNum))
choices.append(option)
if option == default:
choices.append("on")
else:
choices.append("off")
optionNum += 1
retCode, result = self.__runKdialog(title, ["--radiolist", message] + choices, kwargs)
choice = options[int(result)]
return retCode, choice
def list_menu_multi(self, options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs):
"""
Show a multiple-selection list menu
Usage: C{dialog.list_menu_multi(options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs)}
@param options: list of options (strings) for the dialog
@param title: window title for the dialog
@param message: message displayed above the list
@param defaults: list of default values to be selected
@return: a tuple containing the exit code and user choice
@rtype: C{tuple(int, str)}
"""
choices = []
optionNum = 0
for option in options:
choices.append(str(optionNum))
choices.append(option)
if option in defaults:
choices.append("on")
else:
choices.append("off")
optionNum += 1
retCode, output = self.__runKdialog(title, ["--separate-output", "--checklist", message] + choices, kwargs)
results = output.split()
choices = []
for index in results:
choices.append(options[int(index)])
return retCode, choices
def open_file(self, title="Open File", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs):
"""
Show an Open File dialog
Usage: C{dialog.open_file(title="Open File", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs)}
@param title: window title for the dialog
@param initialDir: starting directory for the file dialog
@param fileTypes: file type filter expression
@param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
@return: a tuple containing the exit code and file path
@rtype: C{tuple(int, str)}
"""
if rememberAs is not None:
return self.__runKdialog(title, ["--getopenfilename", initialDir, fileTypes, ":" + rememberAs], kwargs)
else:
return self.__runKdialog(title, ["--getopenfilename", initialDir, fileTypes], kwargs)
def save_file(self, title="Save As", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs):
"""
Show a Save As dialog
Usage: C{dialog.save_file(title="Save As", initialDir="~", fileTypes="*|All Files", rememberAs=None, **kwargs)}
@param title: window title for the dialog
@param initialDir: starting directory for the file dialog
@param fileTypes: file type filter expression
@param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
@return: a tuple containing the exit code and file path
@rtype: C{tuple(int, str)}
"""
if rememberAs is not None:
return self.__runKdialog(title, ["--getsavefilename", initialDir, fileTypes, ":" + rememberAs], kwargs)
else:
return self.__runKdialog(title, ["--getsavefilename", initialDir, fileTypes], kwargs)
def choose_directory(self, title="Select Directory", initialDir="~", rememberAs=None, **kwargs):
"""
Show a Directory Chooser dialog
Usage: C{dialog.choose_directory(title="Select Directory", initialDir="~", rememberAs=None, **kwargs)}
@param title: window title for the dialog
@param initialDir: starting directory for the directory chooser dialog
@param rememberAs: gives an ID to this file dialog, allowing it to open at the last used path next time
@return: a tuple containing the exit code and chosen path
@rtype: C{tuple(int, str)}
"""
if rememberAs is not None:
return self.__runKdialog(title, ["--getexistingdirectory", initialDir, ":" + rememberAs], kwargs)
else:
return self.__runKdialog(title, ["--getexistingdirectory", initialDir], kwargs)
def choose_colour(self, title="Select Colour", **kwargs):
"""
Show a Colour Chooser dialog
Usage: C{dialog.choose_colour(title="Select Colour")}
@param title: window title for the dialog
@return: a tuple containing the exit code and colour
@rtype: C{tuple(int, str)}
"""
return self.__runKdialog(title, ["--getcolor"], kwargs)
def calendar(self, title="Choose a date", format="%Y-%m-%d", date="today", **kwargs):
"""
Show a calendar dialog
Usage: C{dialog.calendar_dialog(title="Choose a date", format="%Y-%m-%d", date="YYYY-MM-DD", **kwargs)}
Note: the format and date parameters are not currently used
@param title: window title for the dialog
@param format: format of date to be returned
@param date: initial date as YYYY-MM-DD, otherwise today
@return: a tuple containing the exit code and date
@rtype: C{tuple(int, str)}
"""
return self.__runKdialog(title, ["--calendar"], kwargs)
class System:
"""
Simplified access to some system commands.
"""
def exec_command(self, command, getOutput=True):
"""
Execute a shell command
Usage: C{system.exec_command(command, getOutput=True)}
Set getOutput to False if the command does not exit and return immediately. Otherwise
AutoKey will not respond to any hotkeys/abbreviations etc until the process started
by the command exits.
@param command: command to be executed (including any arguments) - e.g. "ls -l"
@param getOutput: whether to capture the (stdout) output of the command
@raise subprocess.CalledProcessError: if the command returns a non-zero exit code
"""
if getOutput:
p = subprocess.Popen(command, shell=True, bufsize=-1, stdout=subprocess.PIPE)
retCode = p.wait()
output = p.stdout.read()[:-1]
if retCode != 0:
raise subprocess.CalledProcessError(retCode, output)
else:
return output
else:
subprocess.Popen(command, shell=True, bufsize=-1)
def create_file(self, fileName, contents=""):
"""
Create a file with contents
Usage: C{system.create_file(fileName, contents="")}
@param fileName: full path to the file to be created
@param contents: contents to insert into the file
"""
f = open(fileName, "w")
f.write(contents)
f.close()
class GtkDialog:
"""
Provides a simple interface for the display of some basic dialogs to collect information from the user.
This version uses Zenity to integrate well with GNOME. To pass additional arguments to Zenity that are
not specifically handled, use keyword arguments. For example, to pass the --timeout argument to Zenity
pass C{timeout="15"} as one of the parameters. All keyword arguments must be given as strings.
A note on exit codes: an exit code of 0 indicates that the user clicked OK.
"""
def __runZenity(self, title, args, kwargs):
for k, v in kwargs.iteritems():
args.append("--" + k)
args.append(v)
p = subprocess.Popen(["zenity", "--title", title] + args, stdout=subprocess.PIPE)
retCode = p.wait()
output = p.stdout.read()[:-1] # Drop trailing newline
return (retCode, output)
def info_dialog(self, title="Information", message="", **kwargs):
"""
Show an information dialog
Usage: C{dialog.info_dialog(title="Information", message="", **kwargs)}
@param title: window title for the dialog
@param message: message displayed in the dialog
@return: a tuple containing the exit code and user input
@rtype: C{tuple(int, str)}
"""
return self.__runZenity(title, ["--info", "--text", message], kwargs)
def input_dialog(self, title="Enter a value", message="Enter a value", default="", **kwargs):
"""
Show an input dialog
Usage: C{dialog.input_dialog(title="Enter a value", message="Enter a value", default="", **kwargs)}
@param title: window title for the dialog
@param message: message displayed above the input box
@param default: default value for the input box
@return: a tuple containing the exit code and user input
@rtype: C{tuple(int, str)}
"""
return self.__runZenity(title, ["--entry", "--text", message, "--entry-text", default], kwargs)
def password_dialog(self, title="Enter password", message="Enter password", **kwargs):
"""
Show a password input dialog
Usage: C{dialog.password_dialog(title="Enter password", message="Enter password")}
@param title: window title for the dialog
@param message: message displayed above the password input box
@return: a tuple containing the exit code and user input
@rtype: C{tuple(int, str)}
"""
return self.__runZenity(title, ["--entry", "--text", message, "--hide-text"], kwargs)
#def combo_menu(self, options, title="Choose an option", message="Choose an option"):
"""
Show a combobox menu - not supported by zenity
Usage: C{dialog.combo_menu(options, title="Choose an option", message="Choose an option")}
@param options: list of options (strings) for the dialog
@param title: window title for the dialog
@param message: message displayed above the combobox
"""
#return self.__runZenity(title, ["--combobox", message] + options)
def list_menu(self, options, title="Choose a value", message="Choose a value", default=None, **kwargs):
"""
Show a single-selection list menu
Usage: C{dialog.list_menu(options, title="Choose a value", message="Choose a value", default=None, **kwargs)}
@param options: list of options (strings) for the dialog
@param title: window title for the dialog
@param message: message displayed above the list
@param default: default value to be selected
@return: a tuple containing the exit code and user choice
@rtype: C{tuple(int, str)}
"""
choices = []
#optionNum = 0
for option in options:
if option == default:
choices.append("TRUE")
else:
choices.append("FALSE")
#choices.append(str(optionNum))
choices.append(option)
#optionNum += 1
return self.__runZenity(title, ["--list", "--radiolist", "--text", message, "--column", " ", "--column", "Options"] + choices, kwargs)
#return retCode, choice
def list_menu_multi(self, options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs):
"""
Show a multiple-selection list menu
Usage: C{dialog.list_menu_multi(options, title="Choose one or more values", message="Choose one or more values", defaults=[], **kwargs)}
@param options: list of options (strings) for the dialog
@param title: window title for the dialog
@param message: message displayed above the list
@param defaults: list of default values to be selected
@return: a tuple containing the exit code and user choice
@rtype: C{tuple(int, str)}
"""
choices = []
#optionNum = 0
for option in options:
if option in defaults:
choices.append("TRUE")
else:
choices.append("FALSE")
#choices.append(str(optionNum))
choices.append(option)
#optionNum += 1
retCode, output = self.__runZenity(title, ["--list", "--checklist", "--text", message, "--column", " ", "--column", "Options"] + choices, kwargs)
results = output.split('|')
#choices = []
#for choice in results:
# choices.append(choice)
return retCode, results
def open_file(self, title="Open File", **kwargs):
"""
Show an Open File dialog
Usage: C{dialog.open_file(title="Open File", **kwargs)}
@param title: window title for the dialog
@return: a tuple containing the exit code and file path
@rtype: C{tuple(int, str)}
"""
#if rememberAs is not None:
# return self.__runZenity(title, ["--getopenfilename", initialDir, fileTypes, ":" + rememberAs])
#else:
return self.__runZenity(title, ["--file-selection"], kwargs)
def save_file(self, title="Save As", **kwargs):
"""
Show a Save As dialog
Usage: C{dialog.save_file(title="Save As", **kwargs)}
@param title: window title for the dialog
@return: a tuple containing the exit code and file path
@rtype: C{tuple(int, str)}
"""
#if rememberAs is not None:
# return self.__runZenity(title, ["--getsavefilename", initialDir, fileTypes, ":" + rememberAs])
#else:
return self.__runZenity(title, ["--file-selection", "--save"], kwargs)
def choose_directory(self, title="Select Directory", initialDir="~", **kwargs):
"""
Show a Directory Chooser dialog
Usage: C{dialog.choose_directory(title="Select Directory", **kwargs)}
@param title: window title for the dialog
@return: a tuple containing the exit code and path
@rtype: C{tuple(int, str)}
"""
#if rememberAs is not None:
# return self.__runZenity(title, ["--getexistingdirectory", initialDir, ":" + rememberAs])
#else:
return self.__runZenity(title, ["--file-selection", "--directory"], kwargs)
#def choose_colour(self, title="Select Colour"):
"""
Show a Colour Chooser dialog - not supported by zenity
Usage: C{dialog.choose_colour(title="Select Colour")}
@param title: window title for the dialog
"""
#return self.__runZenity(title, ["--getcolor"])
def calendar(self, title="Choose a date", format="%Y-%m-%d", date="today", **kwargs):
"""
Show a calendar dialog
Usage: C{dialog.calendar_dialog(title="Choose a date", format="%Y-%m-%d", date="YYYY-MM-DD", **kwargs)}
@param title: window title for the dialog
@param format: format of date to be returned
@param date: initial date as YYYY-MM-DD, otherwise today
@return: a tuple containing the exit code and date
@rtype: C{tuple(int, str)}
"""
if re.match(r"[0-9]{4}-[0-9]{2}-[0-9]{2}", date):
year = date[0:4]
month = date[5:7]
day = date[8:10]
date_args = ["--year=" + year, "--month=" + month, "--day=" + day]
else:
date_args = []
return self.__runZenity(title, ["--calendar", "--date-format=" + format] + date_args, kwargs)
class QtClipboard:
"""
Read/write access to the X selection and clipboard - QT version
"""
def __init__(self, app):
self.clipBoard = QApplication.clipboard()
self.app = app
def fill_selection(self, contents):
"""
Copy text into the X selection
Usage: C{clipboard.fill_selection(contents)}
@param contents: string to be placed in the selection
"""
self.__execAsync(self.__fillSelection, contents)
def __fillSelection(self, string):
self.clipBoard.setText(string, QClipboard.Selection)
self.sem.release()
def get_selection(self):
"""
Read text from the X selection
Usage: C{clipboard.get_selection()}
@return: text contents of the mouse selection
@rtype: C{str}
"""
self.__execAsync(self.__getSelection)
return unicode(self.text)
def __getSelection(self):
self.text = self.clipBoard.text(QClipboard.Selection)
self.sem.release()
def fill_clipboard(self, contents):
"""
Copy text into the clipboard
Usage: C{clipboard.fill_clipboard(contents)}
@param contents: string to be placed in the selection
"""
self.__execAsync(self.__fillClipboard, contents)
def __fillClipboard(self, string):
self.clipBoard.setText(string, QClipboard.Clipboard)
self.sem.release()
def get_clipboard(self):
"""
Read text from the clipboard
Usage: C{clipboard.get_clipboard()}
@return: text contents of the clipboard
@rtype: C{str}
"""
self.__execAsync(self.__getClipboard)
return unicode(self.text)
def __getClipboard(self):
self.text = self.clipBoard.text(QClipboard.Clipboard)
self.sem.release()
def __execAsync(self, callback, *args):
self.sem = threading.Semaphore(0)
self.app.exec_in_main(callback, *args)
self.sem.acquire()
class GtkClipboard:
"""
Read/write access to the X selection and clipboard - GTK version
"""
def __init__(self, app):
self.clipBoard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
self.selection = Gtk.Clipboard.get(Gdk.SELECTION_PRIMARY)
self.app = app
def fill_selection(self, contents):
"""
Copy text into the X selection
Usage: C{clipboard.fill_selection(contents)}
@param contents: string to be placed in the selection
"""
#self.__execAsync(self.__fillSelection, contents)
self.__fillSelection(contents)
def __fillSelection(self, string):
Gdk.threads_enter()
self.selection.set_text(string.encode("utf-8"))
Gdk.threads_leave()
#self.sem.release()
def get_selection(self):
"""
Read text from the X selection
Usage: C{clipboard.get_selection()}
@return: text contents of the mouse selection
@rtype: C{str}
@raise Exception: if no text was found in the selection
"""
Gdk.threads_enter()
text = self.selection.wait_for_text()
Gdk.threads_leave()
if text is not None:
return text.decode("utf-8")
else:
raise Exception("No text found in X selection")
def fill_clipboard(self, contents):
"""
Copy text into the clipboard
Usage: C{clipboard.fill_clipboard(contents)}
@param contents: string to be placed in the selection
"""
Gdk.threads_enter()
self.clipBoard.set_text(contents.encode("utf-8"))
Gdk.threads_leave()
def get_clipboard(self):
"""
Read text from the clipboard
Usage: C{clipboard.get_clipboard()}
@return: text contents of the clipboard
@rtype: C{str}
@raise Exception: if no text was found on the clipboard
"""
Gdk.threads_enter()
text = self.clipBoard.wait_for_text()
Gdk.threads_leave()
if text is not None:
return text.decode("utf-8")
else:
raise Exception("No text found on clipboard")
class Window:
"""
Basic window management using wmctrl
Note: in all cases where a window title is required (with the exception of wait_for_focus()),
two special values of window title are permitted:
:ACTIVE: - select the currently active window
:SELECT: - select the desired window by clicking on it
"""
def __init__(self, mediator):
self.mediator = mediator
def wait_for_focus(self, title, timeOut=5):
"""
Wait for window with the given title to have focus
Usage: C{window.wait_for_focus(title, timeOut=5)}
If the window becomes active, returns True. Otherwise, returns False if
the window has not become active by the time the timeout has elapsed.
@param title: title to match against (as a regular expression)
@param timeOut: period (seconds) to wait before giving up
@rtype: boolean
"""
regex = re.compile(title)
waited = 0
while waited <= timeOut:
if regex.match(self.mediator.interface.get_window_title()):
return True
if timeOut == 0:
break # zero length timeout, if not matched go straight to end
time.sleep(0.3)
waited += 0.3
return False
def wait_for_exist(self, title, timeOut=5):
"""
Wait for window with the given title to be created
Usage: C{window.wait_for_exist(title, timeOut=5)}
If the window is in existence, returns True. Otherwise, returns False if
the window has not been created by the time the timeout has elapsed.
@param title: title to match against (as a regular expression)
@param timeOut: period (seconds) to wait before giving up
@rtype: boolean
"""
regex = re.compile(title)
waited = 0
while waited <= timeOut:
retCode, output = self.__runWmctrl(["-l"])
for line in output.split('\n'):
if regex.match(line[14:].split(' ', 1)[-1]):
return True
if timeOut == 0:
break # zero length timeout, if not matched go straight to end
time.sleep(0.3)
waited += 0.3
return False
def activate(self, title, switchDesktop=False, matchClass=False):
"""
Activate the specified window, giving it input focus
Usage: C{window.activate(title, switchDesktop=False, matchClass=False)}
If switchDesktop is False (default), the window will be moved to the current desktop
and activated. Otherwise, switch to the window's current desktop and activate it there.
@param title: window title to match against (as case-insensitive substring match)
@param switchDesktop: whether or not to switch to the window's current desktop
@param matchClass: if True, match on the window class instead of the title
"""
if switchDesktop:
args = ["-a", title]
else:
args = ["-R", title]
if matchClass:
args += ["-x"]
self.__runWmctrl(args)
def close(self, title, matchClass=False):
"""
Close the specified window gracefully
Usage: C{window.close(title, matchClass=False)}
@param title: window title to match against (as case-insensitive substring match)
@param matchClass: if True, match on the window class instead of the title
"""
if matchClass:
self.__runWmctrl(["-c", title, "-x"])
else:
self.__runWmctrl(["-c", title])
def resize_move(self, title, xOrigin=-1, yOrigin=-1, width=-1, height=-1, matchClass=False):
"""
Resize and/or move the specified window
Usage: C{window.close(title, xOrigin=-1, yOrigin=-1, width=-1, height=-1, matchClass=False)}
Leaving and of the position/dimension values as the default (-1) will cause that
value to be left unmodified.
@param title: window title to match against (as case-insensitive substring match)
@param xOrigin: new x origin of the window (upper left corner)
@param yOrigin: new y origin of the window (upper left corner)
@param width: new width of the window
@param height: new height of the window
@param matchClass: if True, match on the window class instead of the title
"""
mvArgs = ["0", str(xOrigin), str(yOrigin), str(width), str(height)]
if matchClass:
xArgs = ["-x"]
else:
xArgs = []
self.__runWmctrl(["-r", title, "-e", ','.join(mvArgs)] + xArgs)
def move_to_desktop(self, title, deskNum, matchClass=False):
"""
Move the specified window to the given desktop
Usage: C{window.move_to_desktop(title, deskNum, matchClass=False)}
@param title: window title to match against (as case-insensitive substring match)
@param deskNum: desktop to move the window to (note: zero based)
@param matchClass: if True, match on the window class instead of the title
"""
if matchClass:
xArgs = ["-x"]
else:
xArgs = []
self.__runWmctrl(["-r", title, "-t", str(deskNum)] + xArgs)
def switch_desktop(self, deskNum):
"""
Switch to the specified desktop
Usage: C{window.switch_desktop(deskNum)}
@param deskNum: desktop to switch to (note: zero based)
"""
self.__runWmctrl(["-s", str(deskNum)])
def set_property(self, title, action, prop, matchClass=False):
"""
Set a property on the given window using the specified action
Usage: C{window.set_property(title, action, prop, matchClass=False)}
Allowable actions: C{add, remove, toggle}
Allowable properties: C{modal, sticky, maximized_vert, maximized_horz, shaded, skip_taskbar,
skip_pager, hidden, fullscreen, above}
@param title: window title to match against (as case-insensitive substring match)
@param action: one of the actions listed above
@param prop: one of the properties listed above
@param matchClass: if True, match on the window class instead of the title
"""
if matchClass:
xArgs = ["-x"]
else:
xArgs = []
self.__runWmctrl(["-r", title, "-b" + action + ',' + prop] + xArgs)
def get_active_geometry(self):
"""
Get the geometry of the currently active window
Usage: C{window.get_active_geometry()}
@return: a 4-tuple containing the x-origin, y-origin, width and height of the window (in pixels)
@rtype: C{tuple(int, int, int, int)}
"""
active = self.mediator.interface.get_window_title()
result, output = self.__runWmctrl(["-l", "-G"])
matchingLine = None
for line in output.split('\n'):
if active in line[34:].split(' ', 1)[-1]:
matchingLine = line
if matchingLine is not None:
output = matchingLine.split()[2:6]
return map(int, output)
else:
return None
def get_active_title(self):
"""
Get the visible title of the currently active window
Usage: C{window.get_active_title()}
@return: the visible title of the currentle active window
@rtype: C{str}
"""
return self.mediator.interface.get_window_title()
def get_active_class(self):
"""
Get the class of the currently active window
Usage: C{window.get_active_class()}
@return: the class of the currentle active window
@rtype: C{str}
"""
return self.mediator.interface.get_window_class()
def __runWmctrl(self, args):
p = subprocess.Popen(["wmctrl"] + args, stdout=subprocess.PIPE)
retCode = p.wait()
output = p.stdout.read()[:-1] # Drop trailing newline
return (retCode, output)
class Engine:
"""
Provides access to the internals of AutoKey.
Note that any configuration changes made using this API while the configuration window
is open will not appear until it is closed and re-opened.
"""
def __init__(self, configManager, runner):
self.configManager = configManager
self.runner = runner
self.monitor = configManager.app.monitor
self.__returnValue = ''
def get_folder(self, title):
"""
Retrieve a folder by its title
Usage: C{engine.get_folder(title)}
Note that if more than one folder has the same title, only the first match will be
returned.
"""
for folder in self.configManager.allFolders:
if folder.title == title:
return folder
return None
def create_phrase(self, folder, description, contents):
"""
Create a text phrase
Usage: C{engine.create_phrase(folder, description, contents)}
A new phrase with no abbreviation or hotkey is created in the specified folder
@param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
@param description: description for the phrase
@param contents: the expansion text
"""
self.monitor.suspend()
p = model.Phrase(description, contents)
folder.add_item(p)
p.persist()
self.monitor.unsuspend()
self.configManager.config_altered(False)
def create_abbreviation(self, folder, description, abbr, contents):
"""
Create a text abbreviation
Usage: C{engine.create_abbreviation(folder, description, abbr, contents)}
When the given abbreviation is typed, it will be replaced with the given
text.
@param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
@param description: description for the phrase
@param abbr: the abbreviation that will trigger the expansion
@param contents: the expansion text
@raise Exception: if the specified abbreviation is not unique
"""
if not self.configManager.check_abbreviation_unique(abbr, None, None):
raise Exception("The specified abbreviation is already in use")
self.monitor.suspend()
p = model.Phrase(description, contents)
p.modes.append(model.TriggerMode.ABBREVIATION)
p.abbreviations = [abbr]
folder.add_item(p)
p.persist()
self.monitor.unsuspend()
self.configManager.config_altered(False)
def create_hotkey(self, folder, description, modifiers, key, contents):
"""
Create a text hotkey
Usage: C{engine.create_hotkey(folder, description, modifiers, key, contents)}
When the given hotkey is pressed, it will be replaced with the given
text. Modifiers must be given as a list of strings, with the following
values permitted:
The key must be an unshifted character (i.e. lowercase)
@param folder: folder to place the abbreviation in, retrieved using C{engine.get_folder()}
@param description: description for the phrase
@param modifiers: modifiers to use with the hotkey (as a list)
@param key: the hotkey
@param contents: the expansion text
@raise Exception: if the specified hotkey is not unique
"""
modifiers.sort()
if not self.configManager.check_hotkey_unique(modifiers, key, None, None):
raise Exception("The specified hotkey and modifier combination is already in use")
self.monitor.suspend()
p = model.Phrase(description, contents)
p.modes.append(model.TriggerMode.HOTKEY)
p.set_hotkey(modifiers, key)
folder.add_item(p)
p.persist()
self.monitor.unsuspend()
self.configManager.config_altered(False)
def run_script(self, description):
"""
Run an existing script using its description to look it up
Usage: C{engine.run_script(description)}
@param description: description of the script to run
@raise Exception: if the specified script does not exist
"""
targetScript = None
for item in self.configManager.allItems:
if item.description == description and isinstance(item, model.Script):
targetScript = item
if targetScript is not None:
self.runner.run_subscript(targetScript)
else:
raise Exception("No script with description '%s' found" % description)
def run_script_from_macro(self, args):
"""
Used internally by AutoKey for phrase macros
"""
self.__macroArgs = args["args"].split(',')
try:
self.run_script(args["name"])
except Exception, e:
self.set_return_value("{ERROR: %s}" % str(e))
def get_macro_arguments(self):
"""
Get the arguments supplied to the current script via its macro
Usage: C{engine.get_macro_arguments()}
@return: the arguments
@rtype: C{list(str())}
"""
return self.__macroArgs
def set_return_value(self, val):
"""
Store a return value to be used by a phrase macro
Usage: C{engine.set_return_value(val)}
@param val: value to be stored
"""
self.__returnValue = val
def get_return_value(self):
"""
Used internally by AutoKey for phrase macros
"""
ret = self.__returnValue
self.__returnValue = ''
return ret
autokey-0.90.4/src/lib/qtapp.py 0000664 0001750 0001750 00000027200 11744657710 015342 0 ustar chris chris #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (C) 2011 Chris Dekter
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
import common
common.USING_QT = True
import sys, traceback, os.path, signal, logging, logging.handlers, subprocess, Queue, time, dbus, dbus.mainloop.qt
from PyKDE4.kdecore import KCmdLineArgs, KCmdLineOptions, KAboutData, ki18n, i18n
from PyKDE4.kdeui import KMessageBox, KApplication
from PyQt4.QtCore import SIGNAL, Qt, QObject, QEvent
from PyQt4.QtGui import QCursor
import service, monitor
from qtui.notifier import Notifier
from qtui.popupmenu import PopupMenu
from qtui.configwindow import ConfigWindow
from configmanager import *
from common import *
PROGRAM_NAME = ki18n("AutoKey")
DESCRIPTION = ki18n("Desktop automation utility")
LICENSE = KAboutData.License_GPL_V3
COPYRIGHT = ki18n("(c) 2009-2012 Chris Dekter")
TEXT = ki18n("")
class Application:
"""
Main application class; starting and stopping of the application is controlled
from here, together with some interactions from the tray icon.
"""
def __init__(self):
aboutData = KAboutData(APP_NAME, CATALOG, PROGRAM_NAME, VERSION, DESCRIPTION,
LICENSE, COPYRIGHT, TEXT, HOMEPAGE, BUG_EMAIL)
aboutData.addAuthor(ki18n("Chris Dekter"), ki18n("Developer"), "cdekter@gmail.com", "")
aboutData.addAuthor(ki18n("Sam Peterson"), ki18n("Original developer"), "peabodyenator@gmail.com", "")
aboutData.setProgramIconName(common.ICON_FILE)
self.aboutData = aboutData
KCmdLineArgs.init(sys.argv, aboutData)
options = KCmdLineOptions()
options.add("l").add("verbose", ki18n("Enable verbose logging"))
options.add("c").add("configure", ki18n("Show the configuration window on startup"))
KCmdLineArgs.addCmdLineOptions(options)
args = KCmdLineArgs.parsedArgs()
self.app = KApplication()
try:
# Create configuration directory
if not os.path.exists(CONFIG_DIR):
os.makedirs(CONFIG_DIR)
# Initialise logger
rootLogger = logging.getLogger()
rootLogger.setLevel(logging.DEBUG)
if args.isSet("verbose"):
handler = logging.StreamHandler(sys.stdout)
else:
handler = logging.handlers.RotatingFileHandler(LOG_FILE,
maxBytes=MAX_LOG_SIZE, backupCount=MAX_LOG_COUNT)
handler.setLevel(logging.INFO)
handler.setFormatter(logging.Formatter(LOG_FORMAT))
rootLogger.addHandler(handler)
if self.__verifyNotRunning():
self.__createLockFile()
self.initialise(args.isSet("configure"))
except Exception, e:
self.show_error_dialog(i18n("Fatal error starting AutoKey.\n") + str(e))
logging.exception("Fatal error starting AutoKey: " + str(e))
sys.exit(1)
def __createLockFile(self):
f = open(LOCK_FILE, 'w')
f.write(str(os.getpid()))
f.close()
def __verifyNotRunning(self):
if os.path.exists(LOCK_FILE):
f = open(LOCK_FILE, 'r')
pid = f.read()
f.close()
# Check that the found PID is running and is autokey
p = subprocess.Popen(["ps", "-p", pid, "-o", "command"], stdout=subprocess.PIPE)
p.wait()
output = p.stdout.read()
if "autokey" in output:
logging.debug("AutoKey is already running as pid %s", pid)
bus = dbus.SessionBus()
try:
dbusService = bus.get_object("org.autokey.Service", "/AppService")
dbusService.show_configure(dbus_interface = "org.autokey.Service")
sys.exit(0)
except dbus.DBusException, e:
logging.exception("Error communicating with Dbus service")
self.show_error_dialog(i18n("AutoKey is already running as pid %1 but is not responding", pid), str(e))
sys.exit(1)
return True
def main(self):
self.app.exec_()
def initialise(self, configure):
logging.info("Initialising application")
self.monitor = monitor.FileMonitor(self)
self.configManager = get_config_manager(self)
self.service = service.Service(self)
self.serviceDisabled = False
# Initialise user code dir
if self.configManager.userCodeDir is not None:
sys.path.append(self.configManager.userCodeDir)
try:
self.service.start()
except Exception, e:
logging.exception("Error starting interface: " + str(e))
self.serviceDisabled = True
self.show_error_dialog(i18n("Error starting interface. Keyboard monitoring will be disabled.\n" +
"Check your system/configuration."), str(e))
self.notifier = Notifier(self)
self.configWindow = None
self.monitor.start()
dbus.mainloop.qt.DBusQtMainLoop(set_as_default=True)
self.dbusService = common.AppService(self)
if ConfigManager.SETTINGS[IS_FIRST_RUN] or configure:
ConfigManager.SETTINGS[IS_FIRST_RUN] = False
self.show_configure()
self.handler = CallbackEventHandler()
kbChangeFilter = KeyboardChangeFilter(self.service.mediator.interface)
self.app.installEventFilter(kbChangeFilter)
def init_global_hotkeys(self, configManager):
logging.info("Initialise global hotkeys")
configManager.toggleServiceHotkey.set_closure(self.toggle_service)
configManager.configHotkey.set_closure(self.show_configure_async)
def config_altered(self, persistGlobal):
self.configManager.config_altered(persistGlobal)
self.notifier.build_menu()
def hotkey_created(self, item):
logging.debug("Created hotkey: %r %s", item.modifiers, item.hotKey)
self.service.mediator.interface.grab_hotkey(item)
def hotkey_removed(self, item):
logging.debug("Removed hotkey: %r %s", item.modifiers, item.hotKey)
self.service.mediator.interface.ungrab_hotkey(item)
def path_created_or_modified(self, path):
time.sleep(0.5)
changed = self.configManager.path_created_or_modified(path)
if changed and self.configWindow is not None:
self.configWindow.config_modified()
def path_removed(self, path):
time.sleep(0.5)
changed = self.configManager.path_removed(path)
if changed and self.configWindow is not None:
self.configWindow.config_modified()
def unpause_service(self):
"""
Unpause the expansion service (start responding to keyboard and mouse events).
"""
self.service.unpause()
self.notifier.update_tool_tip()
def pause_service(self):
"""
Pause the expansion service (stop responding to keyboard and mouse events).
"""
self.service.pause()
self.notifier.update_tool_tip()
def toggle_service(self):
"""
Convenience method for toggling the expansion service on or off.
"""
if self.service.is_running():
self.pause_service()
else:
self.unpause_service()
def shutdown(self):
"""
Shut down the entire application.
"""
logging.info("Shutting down")
self.app.closeAllWindows()
self.notifier.hide_icon()
self.service.shutdown()
self.monitor.stop()
self.app.quit()
os.remove(LOCK_FILE)
logging.debug("All shutdown tasks complete... quitting")
def notify_error(self, message):
"""
Show an error notification popup.
@param message: Message to show in the popup
"""
self.exec_in_main(self.notifier.notify_error, message)
def update_notifier_visibility(self):
self.notifier.update_visible_status()
def show_configure(self):
"""
Show the configuration window, or deiconify (un-minimise) it if it's already open.
"""
logging.info("Displaying configuration window")
try:
self.configWindow.showNormal()
self.configWindow.activateWindow()
except:
self.configWindow = ConfigWindow(self)
self.configWindow.show()
def show_configure_async(self):
self.exec_in_main(self.show_configure)
def show_error_dialog(self, message, details=None):
"""
Convenience method for showing an error dialog.
"""
if details is None:
KMessageBox.error(None, message)
else:
KMessageBox.detailedError(None, message, details)
def show_script_error(self):
"""
Show the last script error (if any)
"""
if self.service.scriptRunner.error != '':
KMessageBox.information(None, self.service.scriptRunner.error, i18n("View Script Error Details"))
self.service.scriptRunner.error = ''
else:
KMessageBox.information(None, i18n("No error information available"), i18n("View Script Error Details"))
def show_popup_menu(self, folders=[], items=[], onDesktop=True, title=None):
self.exec_in_main(self.__createMenu, folders, items, onDesktop, title)
def hide_menu(self):
self.exec_in_main(self.menu.hide)
def __createMenu(self, folders, items, onDesktop, title):
self.menu = PopupMenu(self.service, folders, items, onDesktop, title)
self.menu.popup(QCursor.pos())
self.menu.setFocus()
def exec_in_main(self, callback, *args):
self.handler.postEventWithCallback(callback, *args)
class CallbackEventHandler(QObject):
def __init__(self):
QObject.__init__(self)
self.queue = Queue.Queue()
def customEvent(self, event):
while True:
try:
callback, args = self.queue.get_nowait()
except Queue.Empty:
break
try:
callback(*args)
except Exception:
logging.warn("callback event failed: %r %r", callback, args, exc_info=True)
def postEventWithCallback(self, callback, *args):
self.queue.put((callback, args))
app = KApplication.kApplication()
app.postEvent(self, QEvent(QEvent.User))
class KeyboardChangeFilter(QObject):
def __init__(self, interface):
QObject.__init__(self)
self.interface = interface
def eventFilter(self, obj, event):
if event.type() == QEvent.KeyboardLayoutChange:
self.interface.on_keys_changed()
return QObject.eventFilter(obj, event)
autokey-0.90.4/src/lib/gtkapp.py 0000664 0001750 0001750 00000024344 11747641110 015477 0 ustar chris chris # -*- coding: utf-8 -*-
# Copyright (C) 2011 Chris Dekter
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
import common
common.USING_QT = False
import sys, traceback, os.path, signal, logging, logging.handlers, subprocess, optparse, time
import gettext, dbus, dbus.service, dbus.mainloop.glib
from gi.repository import Gtk, Gdk, GObject, GLib
gettext.install("autokey")
import service, monitor
from gtkui.notifier import get_notifier
from gtkui.popupmenu import PopupMenu
from gtkui.configwindow import ConfigWindow
from configmanager import *
from common import *
PROGRAM_NAME = _("AutoKey")
DESCRIPTION = _("Desktop automation utility")
COPYRIGHT = _("(c) 2008-2011 Chris Dekter")
class Application:
"""
Main application class; starting and stopping of the application is controlled
from here, together with some interactions from the tray icon.
"""
def __init__(self):
GLib.threads_init()
Gdk.threads_init()
p = optparse.OptionParser()
p.add_option("-l", "--verbose", help="Enable verbose logging", action="store_true", default=False)
p.add_option("-c", "--configure", help="Show the configuration window on startup", action="store_true", default=False)
options, args = p.parse_args()
try:
# Create configuration directory
if not os.path.exists(CONFIG_DIR):
os.makedirs(CONFIG_DIR)
# Initialise logger
rootLogger = logging.getLogger()
if options.verbose:
rootLogger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
else:
rootLogger.setLevel(logging.INFO)
handler = logging.handlers.RotatingFileHandler(LOG_FILE,
maxBytes=MAX_LOG_SIZE, backupCount=MAX_LOG_COUNT)
handler.setFormatter(logging.Formatter(LOG_FORMAT))
rootLogger.addHandler(handler)
if self.__verifyNotRunning():
self.__createLockFile()
self.initialise(options.configure)
except Exception, e:
self.show_error_dialog(_("Fatal error starting AutoKey.\n") + str(e))
logging.exception("Fatal error starting AutoKey: " + str(e))
sys.exit(1)
def __createLockFile(self):
f = open(LOCK_FILE, 'w')
f.write(str(os.getpid()))
f.close()
def __verifyNotRunning(self):
if os.path.exists(LOCK_FILE):
f = open(LOCK_FILE, 'r')
pid = f.read()
f.close()
# Check that the found PID is running and is autokey
p = subprocess.Popen(["ps", "-p", pid, "-o", "command"], stdout=subprocess.PIPE)
p.wait()
output = p.stdout.read()
if "autokey" in output:
logging.debug("AutoKey is already running as pid %s", pid)
bus = dbus.SessionBus()
try:
dbusService = bus.get_object("org.autokey.Service", "/AppService")
dbusService.show_configure(dbus_interface = "org.autokey.Service")
sys.exit(0)
except dbus.DBusException, e:
logging.exception("Error communicating with Dbus service")
self.show_error_dialog(_("AutoKey is already running as pid %s but is not responding") % pid, str(e))
sys.exit(1)
return True
def main(self):
Gtk.main()
def initialise(self, configure):
logging.info("Initialising application")
self.monitor = monitor.FileMonitor(self)
self.configManager = get_config_manager(self)
self.service = service.Service(self)
self.serviceDisabled = False
# Initialise user code dir
if self.configManager.userCodeDir is not None:
sys.path.append(self.configManager.userCodeDir)
try:
self.service.start()
except Exception, e:
logging.exception("Error starting interface: " + str(e))
self.serviceDisabled = True
self.show_error_dialog(_("Error starting interface. Keyboard monitoring will be disabled.\n" +
"Check your system/configuration."), str(e))
self.notifier = get_notifier(self)
self.configWindow = None
self.monitor.start()
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
self.dbusService = common.AppService(self)
if configure: self.show_configure()
def init_global_hotkeys(self, configManager):
logging.info("Initialise global hotkeys")
configManager.toggleServiceHotkey.set_closure(self.toggle_service)
configManager.configHotkey.set_closure(self.show_configure_async)
def config_altered(self, persistGlobal):
self.configManager.config_altered(persistGlobal)
self.notifier.rebuild_menu()
def hotkey_created(self, item):
logging.debug("Created hotkey: %r %s", item.modifiers, item.hotKey)
self.service.mediator.interface.grab_hotkey(item)
def hotkey_removed(self, item):
logging.debug("Removed hotkey: %r %s", item.modifiers, item.hotKey)
self.service.mediator.interface.ungrab_hotkey(item)
def path_created_or_modified(self, path):
time.sleep(0.5)
changed = self.configManager.path_created_or_modified(path)
if changed and self.configWindow is not None:
self.configWindow.config_modified()
def path_removed(self, path):
time.sleep(0.5)
changed = self.configManager.path_removed(path)
if changed and self.configWindow is not None:
self.configWindow.config_modified()
def unpause_service(self):
"""
Unpause the expansion service (start responding to keyboard and mouse events).
"""
self.service.unpause()
self.notifier.update_tool_tip()
def pause_service(self):
"""
Pause the expansion service (stop responding to keyboard and mouse events).
"""
self.service.pause()
self.notifier.update_tool_tip()
def toggle_service(self):
"""
Convenience method for toggling the expansion service on or off.
"""
if self.service.is_running():
self.pause_service()
else:
self.unpause_service()
def shutdown(self):
"""
Shut down the entire application.
"""
if self.configWindow is not None:
if self.configWindow.promptToSave():
return
self.configWindow.hide()
self.notifier.hide_icon()
t = threading.Thread(target=self.__completeShutdown)
t.start()
def __completeShutdown(self):
logging.info("Shutting down")
self.service.shutdown()
self.monitor.stop()
Gdk.threads_enter()
Gtk.main_quit()
Gdk.threads_leave()
os.remove(LOCK_FILE)
logging.debug("All shutdown tasks complete... quitting")
def notify_error(self, message):
"""
Show an error notification popup.
@param message: Message to show in the popup
"""
self.notifier.notify_error(message)
def update_notifier_visibility(self):
self.notifier.update_visible_status()
def show_configure(self):
"""
Show the configuration window, or deiconify (un-minimise) it if it's already open.
"""
logging.info("Displaying configuration window")
if self.configWindow is None:
self.configWindow = ConfigWindow(self)
self.configWindow.show()
else:
self.configWindow.deiconify()
def show_configure_async(self):
Gdk.threads_enter()
self.show_configure()
Gdk.threads_leave()
def main(self):
logging.info("Entering main()")
Gdk.threads_enter()
Gtk.main()
Gdk.threads_leave()
def show_error_dialog(self, message, details=None):
"""
Convenience method for showing an error dialog.
"""
dlg = Gtk.MessageDialog(type=Gtk.MessageType.ERROR, buttons=Gtk.ButtonsType.OK,
message_format=message)
if details is not None:
dlg.format_secondary_text(details)
dlg.run()
dlg.destroy()
def show_script_error(self, parent):
"""
Show the last script error (if any)
"""
if self.service.scriptRunner.error != '':
dlg = Gtk.MessageDialog(type=Gtk.MessageType.INFO, buttons=Gtk.ButtonsType.OK,
message_format=self.service.scriptRunner.error)
self.service.scriptRunner.error = ''
else:
dlg = Gtk.MessageDialog(type=Gtk.MessageType.INFO, buttons=Gtk.ButtonsType.OK,
message_format=_("No error information available"))
dlg.set_title(_("View script error"))
dlg.set_transient_for(parent)
dlg.run()
dlg.destroy()
def show_popup_menu(self, folders=[], items=[], onDesktop=True, title=None):
self.menu = PopupMenu(self.service, folders, items, onDesktop, title)
self.menu.show_on_desktop()
def hide_menu(self):
self.menu.remove_from_desktop()
autokey-0.90.4/src/lib/monitor.py 0000664 0001750 0001750 00000010452 11661345307 015677 0 ustar chris chris #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (C) 2011 Chris Dekter
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
import threading, logging, os.path, time
from pyinotify import WatchManager, Notifier, EventsCodes, ProcessEvent
_logger = logging.getLogger("inotify")
m = EventsCodes.OP_FLAGS
MASK = m["IN_CREATE"]|m["IN_MODIFY"]|m["IN_DELETE"]|m["IN_MOVED_TO"]|m["IN_MOVED_FROM"]
class Processor(ProcessEvent):
def __init__(self, monitor, listener):
ProcessEvent.__init__(self)
self.listener = listener
self.monitor = monitor
def __getEventPath(self, event):
if event.name != '':
path = os.path.join(event.path, event.name)
else:
path = event.path
_logger.debug("Reporting %s event at %s", event.maskname, path)
return path
def process_IN_MOVED_TO(self, event):
path = self.__getEventPath(event)
if not self.monitor.is_suspended():
self.listener.path_created_or_modified(path)
def process_IN_CREATE(self, event):
path = self.__getEventPath(event)
if not self.monitor.is_suspended():
self.listener.path_created_or_modified(path)
def process_IN_MODIFY(self, event):
path = self.__getEventPath(event)
if not self.monitor.is_suspended():
self.listener.path_created_or_modified(path)
def process_IN_DELETE(self, event):
path = self.__getEventPath(event)
if not self.monitor.is_suspended():
self.listener.path_removed(path)
def process_IN_MOVED_FROM(self, event):
path = self.__getEventPath(event)
if not self.monitor.is_suspended():
self.listener.path_removed(path)
class FileMonitor(threading.Thread):
def __init__(self, listener):
threading.Thread.__init__(self)
self.__p = Processor(self, listener)
self.manager = WatchManager()
self.notifier = Notifier(self.manager, self.__p)
self.event = threading.Event()
self.setDaemon(True)
self.watches = []
#self.suspended = []
self.__isSuspended = False
def suspend(self):
self.__isSuspended = True
def unsuspend(self):
t = threading.Thread(target=self.__unsuspend)
t.start()
def __unsuspend(self):
time.sleep(1.5)
self.__isSuspended = False
for watch in self.watches:
if not os.path.exists(watch):
_logger.debug("Removed stale watch on %s", watch)
self.watches.remove(watch)
def is_suspended(self):
return self.__isSuspended
def has_watch(self, path):
return path in self.watches
def add_watch(self, path):
_logger.debug("Adding watch for %s", path)
self.manager.add_watch(path, MASK, self.__p)
self.watches.append(path)
def remove_watch(self, path):
_logger.debug("Removing watch for %s", path)
wd = self.manager.get_wd(path)
self.manager.rm_watch(wd, True)
self.watches.remove(path)
for i in range(len(self.watches)):
try:
if self.watches[i].startswith(path):
self.watches.remove(self.watches[i])
except IndexError:
break
def run(self):
while not self.event.isSet():
self.notifier.process_events()
if self.notifier.check_events(1000):
self.notifier.read_events()
_logger.info("Shutting down file monitor")
self.notifier.stop()
def stop(self):
self.event.set()
self.join()
autokey-0.90.4/src/lib/common.py 0000664 0001750 0001750 00000005050 11754440521 015473 0 ustar chris chris #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (C) 2011 Chris Dekter
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
import os.path, dbus.service
CONFIG_DIR = os.path.expanduser("~/.config/autokey")
LOCK_FILE = CONFIG_DIR + "/autokey.pid"
LOG_FILE = CONFIG_DIR + "/autokey.log"
MAX_LOG_SIZE = 5 * 1024 * 1024 # 5 megabytes
MAX_LOG_COUNT = 3
LOG_FORMAT = "%(asctime)s %(levelname)s - %(name)s - %(message)s"
APP_NAME = "autokey"
CATALOG = ""
VERSION = "0.90.4"
HOMEPAGE = "http://autokey.googlecode.com/"
BUG_EMAIL = "cdekter@gmail.com"
FAQ_URL = "http://code.google.com/p/autokey/wiki/FAQ"
API_URL = "http://autokey.googlecode.com/svn/trunk/doc/scripting/index.html"
HELP_URL = "http://code.google.com/p/autokey/w/list"
DONATE_URL = "https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=L333CPRZ6J8JC"
BUG_URL = "http://code.google.com/p/autokey/issues/entry"
ICON_FILE = "autokey"
ICON_FILE_NOTIFICATION = "autokey-status"
ICON_FILE_NOTIFICATION_DARK = "autokey-status-dark"
ICON_FILE_NOTIFICATION_ERROR = "autokey-status-error"
USING_QT = False
class AppService(dbus.service.Object):
def __init__(self, app):
busName = dbus.service.BusName('org.autokey.Service', bus=dbus.SessionBus())
dbus.service.Object.__init__(self, busName, "/AppService")
self.app = app
@dbus.service.method(dbus_interface='org.autokey.Service', in_signature='', out_signature='')
def show_configure(self):
self.app.show_configure()
@dbus.service.method(dbus_interface='org.autokey.Service', in_signature='s', out_signature='')
def run_script(self, name):
self.app.service.run_script(name)
@dbus.service.method(dbus_interface='org.autokey.Service', in_signature='s', out_signature='')
def run_phrase(self, name):
self.app.service.run_phrase(name)
@dbus.service.method(dbus_interface='org.autokey.Service', in_signature='s', out_signature='')
def run_folder(self, name):
self.app.service.run_folder(name)
autokey-0.90.4/src/lib/iomediator.py 0000664 0001750 0001750 00000040547 11754436675 016370 0 ustar chris chris # -*- coding: utf-8 -*-
# Copyright (C) 2011 Chris Dekter
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
X_RECORD_INTERFACE = "XRecord"
ATSPI_INTERFACE = "AT-SPI"
INTERFACES = [X_RECORD_INTERFACE, ATSPI_INTERFACE]
CURRENT_INTERFACE = None
# Key codes enumeration
class Key:
LEFT = ""
RIGHT = ""
UP = ""
DOWN = ""
BACKSPACE = ""
TAB = ""
ENTER = ""
SCROLL_LOCK = ""
PRINT_SCREEN = ""
PAUSE = ""
MENU = "