| """Easy to use dialogs. |
| |
| Message(msg) -- display a message and an OK button. |
| AskString(prompt, default) -- ask for a string, display OK and Cancel buttons. |
| AskPassword(prompt, default) -- like AskString(), but shows text as bullets. |
| AskYesNoCancel(question, default) -- display a question and Yes, No and Cancel buttons. |
| GetArgv(optionlist, commandlist) -- fill a sys.argv-like list using a dialog |
| AskFileForOpen(...) -- Ask the user for an existing file |
| AskFileForSave(...) -- Ask the user for an output file |
| AskFolder(...) -- Ask the user to select a folder |
| bar = Progress(label, maxvalue) -- Display a progress bar |
| bar.set(value) -- Set value |
| bar.inc( *amount ) -- increment value by amount (default=1) |
| bar.label( *newlabel ) -- get or set text label. |
| |
| More documentation in each function. |
| This module uses DLOG resources 260 and on. |
| Based upon STDWIN dialogs with the same names and functions. |
| """ |
| |
| from warnings import warnpy3k |
| warnpy3k("In 3.x, the EasyDialogs module is removed.", stacklevel=2) |
| |
| from Carbon.Dlg import GetNewDialog, SetDialogItemText, GetDialogItemText, ModalDialog |
| from Carbon import Qd |
| from Carbon import QuickDraw |
| from Carbon import Dialogs |
| from Carbon import Windows |
| from Carbon import Dlg,Win,Evt,Events # sdm7g |
| from Carbon import Ctl |
| from Carbon import Controls |
| from Carbon import Menu |
| from Carbon import AE |
| import Nav |
| import MacOS |
| import string |
| from Carbon.ControlAccessor import * # Also import Controls constants |
| import Carbon.File |
| import macresource |
| import os |
| import sys |
| |
| __all__ = ['Message', 'AskString', 'AskPassword', 'AskYesNoCancel', |
| 'GetArgv', 'AskFileForOpen', 'AskFileForSave', 'AskFolder', |
| 'ProgressBar'] |
| |
| _initialized = 0 |
| |
| def _initialize(): |
| global _initialized |
| if _initialized: return |
| macresource.need("DLOG", 260, "dialogs.rsrc", __name__) |
| |
| def _interact(): |
| """Make sure the application is in the foreground""" |
| AE.AEInteractWithUser(50000000) |
| |
| def cr2lf(text): |
| if '\r' in text: |
| text = string.join(string.split(text, '\r'), '\n') |
| return text |
| |
| def lf2cr(text): |
| if '\n' in text: |
| text = string.join(string.split(text, '\n'), '\r') |
| if len(text) > 253: |
| text = text[:253] + '\311' |
| return text |
| |
| def Message(msg, id=260, ok=None): |
| """Display a MESSAGE string. |
| |
| Return when the user clicks the OK button or presses Return. |
| |
| The MESSAGE string can be at most 255 characters long. |
| """ |
| _initialize() |
| _interact() |
| d = GetNewDialog(id, -1) |
| if not d: |
| print "EasyDialogs: Can't get DLOG resource with id =", id, " (missing resource file?)" |
| return |
| h = d.GetDialogItemAsControl(2) |
| SetDialogItemText(h, lf2cr(msg)) |
| if ok is not None: |
| h = d.GetDialogItemAsControl(1) |
| h.SetControlTitle(ok) |
| d.SetDialogDefaultItem(1) |
| d.AutoSizeDialog() |
| d.GetDialogWindow().ShowWindow() |
| while 1: |
| n = ModalDialog(None) |
| if n == 1: |
| return |
| |
| |
| def AskString(prompt, default = "", id=261, ok=None, cancel=None): |
| """Display a PROMPT string and a text entry field with a DEFAULT string. |
| |
| Return the contents of the text entry field when the user clicks the |
| OK button or presses Return. |
| Return None when the user clicks the Cancel button. |
| |
| If omitted, DEFAULT is empty. |
| |
| The PROMPT and DEFAULT strings, as well as the return value, |
| can be at most 255 characters long. |
| """ |
| |
| _initialize() |
| _interact() |
| d = GetNewDialog(id, -1) |
| if not d: |
| print "EasyDialogs: Can't get DLOG resource with id =", id, " (missing resource file?)" |
| return |
| h = d.GetDialogItemAsControl(3) |
| SetDialogItemText(h, lf2cr(prompt)) |
| h = d.GetDialogItemAsControl(4) |
| SetDialogItemText(h, lf2cr(default)) |
| d.SelectDialogItemText(4, 0, 999) |
| # d.SetDialogItem(4, 0, 255) |
| if ok is not None: |
| h = d.GetDialogItemAsControl(1) |
| h.SetControlTitle(ok) |
| if cancel is not None: |
| h = d.GetDialogItemAsControl(2) |
| h.SetControlTitle(cancel) |
| d.SetDialogDefaultItem(1) |
| d.SetDialogCancelItem(2) |
| d.AutoSizeDialog() |
| d.GetDialogWindow().ShowWindow() |
| while 1: |
| n = ModalDialog(None) |
| if n == 1: |
| h = d.GetDialogItemAsControl(4) |
| return cr2lf(GetDialogItemText(h)) |
| if n == 2: return None |
| |
| def AskPassword(prompt, default='', id=264, ok=None, cancel=None): |
| """Display a PROMPT string and a text entry field with a DEFAULT string. |
| The string is displayed as bullets only. |
| |
| Return the contents of the text entry field when the user clicks the |
| OK button or presses Return. |
| Return None when the user clicks the Cancel button. |
| |
| If omitted, DEFAULT is empty. |
| |
| The PROMPT and DEFAULT strings, as well as the return value, |
| can be at most 255 characters long. |
| """ |
| _initialize() |
| _interact() |
| d = GetNewDialog(id, -1) |
| if not d: |
| print "EasyDialogs: Can't get DLOG resource with id =", id, " (missing resource file?)" |
| return |
| h = d.GetDialogItemAsControl(3) |
| SetDialogItemText(h, lf2cr(prompt)) |
| pwd = d.GetDialogItemAsControl(4) |
| bullets = '\245'*len(default) |
| ## SetControlData(pwd, kControlEditTextPart, kControlEditTextTextTag, bullets) |
| SetControlData(pwd, kControlEditTextPart, kControlEditTextPasswordTag, default) |
| d.SelectDialogItemText(4, 0, 999) |
| Ctl.SetKeyboardFocus(d.GetDialogWindow(), pwd, kControlEditTextPart) |
| if ok is not None: |
| h = d.GetDialogItemAsControl(1) |
| h.SetControlTitle(ok) |
| if cancel is not None: |
| h = d.GetDialogItemAsControl(2) |
| h.SetControlTitle(cancel) |
| d.SetDialogDefaultItem(Dialogs.ok) |
| d.SetDialogCancelItem(Dialogs.cancel) |
| d.AutoSizeDialog() |
| d.GetDialogWindow().ShowWindow() |
| while 1: |
| n = ModalDialog(None) |
| if n == 1: |
| h = d.GetDialogItemAsControl(4) |
| return cr2lf(GetControlData(pwd, kControlEditTextPart, kControlEditTextPasswordTag)) |
| if n == 2: return None |
| |
| def AskYesNoCancel(question, default = 0, yes=None, no=None, cancel=None, id=262): |
| """Display a QUESTION string which can be answered with Yes or No. |
| |
| Return 1 when the user clicks the Yes button. |
| Return 0 when the user clicks the No button. |
| Return -1 when the user clicks the Cancel button. |
| |
| When the user presses Return, the DEFAULT value is returned. |
| If omitted, this is 0 (No). |
| |
| The QUESTION string can be at most 255 characters. |
| """ |
| |
| _initialize() |
| _interact() |
| d = GetNewDialog(id, -1) |
| if not d: |
| print "EasyDialogs: Can't get DLOG resource with id =", id, " (missing resource file?)" |
| return |
| # Button assignments: |
| # 1 = default (invisible) |
| # 2 = Yes |
| # 3 = No |
| # 4 = Cancel |
| # The question string is item 5 |
| h = d.GetDialogItemAsControl(5) |
| SetDialogItemText(h, lf2cr(question)) |
| if yes is not None: |
| if yes == '': |
| d.HideDialogItem(2) |
| else: |
| h = d.GetDialogItemAsControl(2) |
| h.SetControlTitle(yes) |
| if no is not None: |
| if no == '': |
| d.HideDialogItem(3) |
| else: |
| h = d.GetDialogItemAsControl(3) |
| h.SetControlTitle(no) |
| if cancel is not None: |
| if cancel == '': |
| d.HideDialogItem(4) |
| else: |
| h = d.GetDialogItemAsControl(4) |
| h.SetControlTitle(cancel) |
| d.SetDialogCancelItem(4) |
| if default == 1: |
| d.SetDialogDefaultItem(2) |
| elif default == 0: |
| d.SetDialogDefaultItem(3) |
| elif default == -1: |
| d.SetDialogDefaultItem(4) |
| d.AutoSizeDialog() |
| d.GetDialogWindow().ShowWindow() |
| while 1: |
| n = ModalDialog(None) |
| if n == 1: return default |
| if n == 2: return 1 |
| if n == 3: return 0 |
| if n == 4: return -1 |
| |
| |
| |
| # The deprecated Carbon QuickDraw APIs are no longer available as of |
| # OS X 10.8. Raise an ImportError here in that case so that callers |
| # of EasyDialogs, like BuildApplet, will do the right thing. |
| |
| try: |
| screenbounds = Qd.GetQDGlobalsScreenBits().bounds |
| except AttributeError: |
| raise ImportError("QuickDraw APIs not available") |
| |
| screenbounds = screenbounds[0]+4, screenbounds[1]+4, \ |
| screenbounds[2]-4, screenbounds[3]-4 |
| |
| kControlProgressBarIndeterminateTag = 'inde' # from Controls.py |
| |
| |
| class ProgressBar: |
| def __init__(self, title="Working...", maxval=0, label="", id=263): |
| self.w = None |
| self.d = None |
| _initialize() |
| self.d = GetNewDialog(id, -1) |
| self.w = self.d.GetDialogWindow() |
| self.label(label) |
| self.title(title) |
| self.set(0, maxval) |
| self.d.AutoSizeDialog() |
| self.w.ShowWindow() |
| self.d.DrawDialog() |
| |
| def __del__(self): |
| if self.w: |
| self.w.BringToFront() |
| self.w.HideWindow() |
| del self.w |
| del self.d |
| |
| def title(self, newstr=""): |
| """title(text) - Set title of progress window""" |
| self.w.BringToFront() |
| self.w.SetWTitle(newstr) |
| |
| def label(self, *newstr): |
| """label(text) - Set text in progress box""" |
| self.w.BringToFront() |
| if newstr: |
| self._label = lf2cr(newstr[0]) |
| text_h = self.d.GetDialogItemAsControl(2) |
| SetDialogItemText(text_h, self._label) |
| |
| def _update(self, value): |
| maxval = self.maxval |
| if maxval == 0: # an indeterminate bar |
| Ctl.IdleControls(self.w) # spin the barber pole |
| else: # a determinate bar |
| if maxval > 32767: |
| value = int(value/(maxval/32767.0)) |
| maxval = 32767 |
| maxval = int(maxval) |
| value = int(value) |
| progbar = self.d.GetDialogItemAsControl(3) |
| progbar.SetControlMaximum(maxval) |
| progbar.SetControlValue(value) # set the bar length |
| |
| # Test for cancel button |
| ready, ev = Evt.WaitNextEvent( Events.mDownMask, 1 ) |
| if ready : |
| what,msg,when,where,mod = ev |
| part = Win.FindWindow(where)[0] |
| if Dlg.IsDialogEvent(ev): |
| ds = Dlg.DialogSelect(ev) |
| if ds[0] and ds[1] == self.d and ds[-1] == 1: |
| self.w.HideWindow() |
| self.w = None |
| self.d = None |
| raise KeyboardInterrupt, ev |
| else: |
| if part == 4: # inDrag |
| self.w.DragWindow(where, screenbounds) |
| else: |
| MacOS.HandleEvent(ev) |
| |
| |
| def set(self, value, max=None): |
| """set(value) - Set progress bar position""" |
| if max is not None: |
| self.maxval = max |
| bar = self.d.GetDialogItemAsControl(3) |
| if max <= 0: # indeterminate bar |
| bar.SetControlData(0,kControlProgressBarIndeterminateTag,'\x01') |
| else: # determinate bar |
| bar.SetControlData(0,kControlProgressBarIndeterminateTag,'\x00') |
| if value < 0: |
| value = 0 |
| elif value > self.maxval: |
| value = self.maxval |
| self.curval = value |
| self._update(value) |
| |
| def inc(self, n=1): |
| """inc(amt) - Increment progress bar position""" |
| self.set(self.curval + n) |
| |
| ARGV_ID=265 |
| ARGV_ITEM_OK=1 |
| ARGV_ITEM_CANCEL=2 |
| ARGV_OPTION_GROUP=3 |
| ARGV_OPTION_EXPLAIN=4 |
| ARGV_OPTION_VALUE=5 |
| ARGV_OPTION_ADD=6 |
| ARGV_COMMAND_GROUP=7 |
| ARGV_COMMAND_EXPLAIN=8 |
| ARGV_COMMAND_ADD=9 |
| ARGV_ADD_OLDFILE=10 |
| ARGV_ADD_NEWFILE=11 |
| ARGV_ADD_FOLDER=12 |
| ARGV_CMDLINE_GROUP=13 |
| ARGV_CMDLINE_DATA=14 |
| |
| ##def _myModalDialog(d): |
| ## while 1: |
| ## ready, ev = Evt.WaitNextEvent(0xffff, -1) |
| ## print 'DBG: WNE', ready, ev |
| ## if ready : |
| ## what,msg,when,where,mod = ev |
| ## part, window = Win.FindWindow(where) |
| ## if Dlg.IsDialogEvent(ev): |
| ## didit, dlgdone, itemdone = Dlg.DialogSelect(ev) |
| ## print 'DBG: DialogSelect', didit, dlgdone, itemdone, d |
| ## if didit and dlgdone == d: |
| ## return itemdone |
| ## elif window == d.GetDialogWindow(): |
| ## d.GetDialogWindow().SelectWindow() |
| ## if part == 4: # inDrag |
| ## d.DragWindow(where, screenbounds) |
| ## else: |
| ## MacOS.HandleEvent(ev) |
| ## else: |
| ## MacOS.HandleEvent(ev) |
| ## |
| def _setmenu(control, items): |
| mhandle = control.GetControlData_Handle(Controls.kControlMenuPart, |
| Controls.kControlPopupButtonMenuHandleTag) |
| menu = Menu.as_Menu(mhandle) |
| for item in items: |
| if type(item) == type(()): |
| label = item[0] |
| else: |
| label = item |
| if label[-1] == '=' or label[-1] == ':': |
| label = label[:-1] |
| menu.AppendMenu(label) |
| ## mhandle, mid = menu.getpopupinfo() |
| ## control.SetControlData_Handle(Controls.kControlMenuPart, |
| ## Controls.kControlPopupButtonMenuHandleTag, mhandle) |
| control.SetControlMinimum(1) |
| control.SetControlMaximum(len(items)+1) |
| |
| def _selectoption(d, optionlist, idx): |
| if idx < 0 or idx >= len(optionlist): |
| MacOS.SysBeep() |
| return |
| option = optionlist[idx] |
| if type(option) == type(()): |
| if len(option) == 4: |
| help = option[2] |
| elif len(option) > 1: |
| help = option[-1] |
| else: |
| help = '' |
| else: |
| help = '' |
| h = d.GetDialogItemAsControl(ARGV_OPTION_EXPLAIN) |
| if help and len(help) > 250: |
| help = help[:250] + '...' |
| Dlg.SetDialogItemText(h, help) |
| hasvalue = 0 |
| if type(option) == type(()): |
| label = option[0] |
| else: |
| label = option |
| if label[-1] == '=' or label[-1] == ':': |
| hasvalue = 1 |
| h = d.GetDialogItemAsControl(ARGV_OPTION_VALUE) |
| Dlg.SetDialogItemText(h, '') |
| if hasvalue: |
| d.ShowDialogItem(ARGV_OPTION_VALUE) |
| d.SelectDialogItemText(ARGV_OPTION_VALUE, 0, 0) |
| else: |
| d.HideDialogItem(ARGV_OPTION_VALUE) |
| |
| |
| def GetArgv(optionlist=None, commandlist=None, addoldfile=1, addnewfile=1, addfolder=1, id=ARGV_ID): |
| _initialize() |
| _interact() |
| d = GetNewDialog(id, -1) |
| if not d: |
| print "EasyDialogs: Can't get DLOG resource with id =", id, " (missing resource file?)" |
| return |
| # h = d.GetDialogItemAsControl(3) |
| # SetDialogItemText(h, lf2cr(prompt)) |
| # h = d.GetDialogItemAsControl(4) |
| # SetDialogItemText(h, lf2cr(default)) |
| # d.SelectDialogItemText(4, 0, 999) |
| # d.SetDialogItem(4, 0, 255) |
| if optionlist: |
| _setmenu(d.GetDialogItemAsControl(ARGV_OPTION_GROUP), optionlist) |
| _selectoption(d, optionlist, 0) |
| else: |
| d.GetDialogItemAsControl(ARGV_OPTION_GROUP).DeactivateControl() |
| if commandlist: |
| _setmenu(d.GetDialogItemAsControl(ARGV_COMMAND_GROUP), commandlist) |
| if type(commandlist[0]) == type(()) and len(commandlist[0]) > 1: |
| help = commandlist[0][-1] |
| h = d.GetDialogItemAsControl(ARGV_COMMAND_EXPLAIN) |
| Dlg.SetDialogItemText(h, help) |
| else: |
| d.GetDialogItemAsControl(ARGV_COMMAND_GROUP).DeactivateControl() |
| if not addoldfile: |
| d.GetDialogItemAsControl(ARGV_ADD_OLDFILE).DeactivateControl() |
| if not addnewfile: |
| d.GetDialogItemAsControl(ARGV_ADD_NEWFILE).DeactivateControl() |
| if not addfolder: |
| d.GetDialogItemAsControl(ARGV_ADD_FOLDER).DeactivateControl() |
| d.SetDialogDefaultItem(ARGV_ITEM_OK) |
| d.SetDialogCancelItem(ARGV_ITEM_CANCEL) |
| d.GetDialogWindow().ShowWindow() |
| d.DrawDialog() |
| if hasattr(MacOS, 'SchedParams'): |
| appsw = MacOS.SchedParams(1, 0) |
| try: |
| while 1: |
| stringstoadd = [] |
| n = ModalDialog(None) |
| if n == ARGV_ITEM_OK: |
| break |
| elif n == ARGV_ITEM_CANCEL: |
| raise SystemExit |
| elif n == ARGV_OPTION_GROUP: |
| idx = d.GetDialogItemAsControl(ARGV_OPTION_GROUP).GetControlValue()-1 |
| _selectoption(d, optionlist, idx) |
| elif n == ARGV_OPTION_VALUE: |
| pass |
| elif n == ARGV_OPTION_ADD: |
| idx = d.GetDialogItemAsControl(ARGV_OPTION_GROUP).GetControlValue()-1 |
| if 0 <= idx < len(optionlist): |
| option = optionlist[idx] |
| if type(option) == type(()): |
| option = option[0] |
| if option[-1] == '=' or option[-1] == ':': |
| option = option[:-1] |
| h = d.GetDialogItemAsControl(ARGV_OPTION_VALUE) |
| value = Dlg.GetDialogItemText(h) |
| else: |
| value = '' |
| if len(option) == 1: |
| stringtoadd = '-' + option |
| else: |
| stringtoadd = '--' + option |
| stringstoadd = [stringtoadd] |
| if value: |
| stringstoadd.append(value) |
| else: |
| MacOS.SysBeep() |
| elif n == ARGV_COMMAND_GROUP: |
| idx = d.GetDialogItemAsControl(ARGV_COMMAND_GROUP).GetControlValue()-1 |
| if 0 <= idx < len(commandlist) and type(commandlist[idx]) == type(()) and \ |
| len(commandlist[idx]) > 1: |
| help = commandlist[idx][-1] |
| h = d.GetDialogItemAsControl(ARGV_COMMAND_EXPLAIN) |
| Dlg.SetDialogItemText(h, help) |
| elif n == ARGV_COMMAND_ADD: |
| idx = d.GetDialogItemAsControl(ARGV_COMMAND_GROUP).GetControlValue()-1 |
| if 0 <= idx < len(commandlist): |
| command = commandlist[idx] |
| if type(command) == type(()): |
| command = command[0] |
| stringstoadd = [command] |
| else: |
| MacOS.SysBeep() |
| elif n == ARGV_ADD_OLDFILE: |
| pathname = AskFileForOpen() |
| if pathname: |
| stringstoadd = [pathname] |
| elif n == ARGV_ADD_NEWFILE: |
| pathname = AskFileForSave() |
| if pathname: |
| stringstoadd = [pathname] |
| elif n == ARGV_ADD_FOLDER: |
| pathname = AskFolder() |
| if pathname: |
| stringstoadd = [pathname] |
| elif n == ARGV_CMDLINE_DATA: |
| pass # Nothing to do |
| else: |
| raise RuntimeError, "Unknown dialog item %d"%n |
| |
| for stringtoadd in stringstoadd: |
| if '"' in stringtoadd or "'" in stringtoadd or " " in stringtoadd: |
| stringtoadd = repr(stringtoadd) |
| h = d.GetDialogItemAsControl(ARGV_CMDLINE_DATA) |
| oldstr = GetDialogItemText(h) |
| if oldstr and oldstr[-1] != ' ': |
| oldstr = oldstr + ' ' |
| oldstr = oldstr + stringtoadd |
| if oldstr[-1] != ' ': |
| oldstr = oldstr + ' ' |
| SetDialogItemText(h, oldstr) |
| d.SelectDialogItemText(ARGV_CMDLINE_DATA, 0x7fff, 0x7fff) |
| h = d.GetDialogItemAsControl(ARGV_CMDLINE_DATA) |
| oldstr = GetDialogItemText(h) |
| tmplist = string.split(oldstr) |
| newlist = [] |
| while tmplist: |
| item = tmplist[0] |
| del tmplist[0] |
| if item[0] == '"': |
| while item[-1] != '"': |
| if not tmplist: |
| raise RuntimeError, "Unterminated quoted argument" |
| item = item + ' ' + tmplist[0] |
| del tmplist[0] |
| item = item[1:-1] |
| if item[0] == "'": |
| while item[-1] != "'": |
| if not tmplist: |
| raise RuntimeError, "Unterminated quoted argument" |
| item = item + ' ' + tmplist[0] |
| del tmplist[0] |
| item = item[1:-1] |
| newlist.append(item) |
| return newlist |
| finally: |
| if hasattr(MacOS, 'SchedParams'): |
| MacOS.SchedParams(*appsw) |
| del d |
| |
| def _process_Nav_args(dftflags, **args): |
| import Carbon.AppleEvents |
| import Carbon.AE |
| import Carbon.File |
| for k in args.keys(): |
| if args[k] is None: |
| del args[k] |
| # Set some defaults, and modify some arguments |
| if 'dialogOptionFlags' not in args: |
| args['dialogOptionFlags'] = dftflags |
| if 'defaultLocation' in args and \ |
| not isinstance(args['defaultLocation'], Carbon.AE.AEDesc): |
| defaultLocation = args['defaultLocation'] |
| if isinstance(defaultLocation, Carbon.File.FSSpec): |
| args['defaultLocation'] = Carbon.AE.AECreateDesc( |
| Carbon.AppleEvents.typeFSS, defaultLocation.data) |
| else: |
| if not isinstance(defaultLocation, Carbon.File.FSRef): |
| defaultLocation = Carbon.File.FSRef(defaultLocation) |
| args['defaultLocation'] = Carbon.AE.AECreateDesc( |
| Carbon.AppleEvents.typeFSRef, defaultLocation.data) |
| if 'typeList' in args and not isinstance(args['typeList'], Carbon.Res.ResourceType): |
| typeList = args['typeList'][:] |
| # Workaround for OSX typeless files: |
| if 'TEXT' in typeList and not '\0\0\0\0' in typeList: |
| typeList = typeList + ('\0\0\0\0',) |
| data = 'Pyth' + struct.pack("hh", 0, len(typeList)) |
| for type in typeList: |
| data = data+type |
| args['typeList'] = Carbon.Res.Handle(data) |
| tpwanted = str |
| if 'wanted' in args: |
| tpwanted = args['wanted'] |
| del args['wanted'] |
| return args, tpwanted |
| |
| def _dummy_Nav_eventproc(msg, data): |
| pass |
| |
| _default_Nav_eventproc = _dummy_Nav_eventproc |
| |
| def SetDefaultEventProc(proc): |
| global _default_Nav_eventproc |
| rv = _default_Nav_eventproc |
| if proc is None: |
| proc = _dummy_Nav_eventproc |
| _default_Nav_eventproc = proc |
| return rv |
| |
| def AskFileForOpen( |
| message=None, |
| typeList=None, |
| # From here on the order is not documented |
| version=None, |
| defaultLocation=None, |
| dialogOptionFlags=None, |
| location=None, |
| clientName=None, |
| windowTitle=None, |
| actionButtonLabel=None, |
| cancelButtonLabel=None, |
| preferenceKey=None, |
| popupExtension=None, |
| eventProc=_dummy_Nav_eventproc, |
| previewProc=None, |
| filterProc=None, |
| wanted=None, |
| multiple=None): |
| """Display a dialog asking the user for a file to open. |
| |
| wanted is the return type wanted: FSSpec, FSRef, unicode or string (default) |
| the other arguments can be looked up in Apple's Navigation Services documentation""" |
| |
| default_flags = 0x56 # Or 0xe4? |
| args, tpwanted = _process_Nav_args(default_flags, version=version, |
| defaultLocation=defaultLocation, dialogOptionFlags=dialogOptionFlags, |
| location=location,clientName=clientName,windowTitle=windowTitle, |
| actionButtonLabel=actionButtonLabel,cancelButtonLabel=cancelButtonLabel, |
| message=message,preferenceKey=preferenceKey, |
| popupExtension=popupExtension,eventProc=eventProc,previewProc=previewProc, |
| filterProc=filterProc,typeList=typeList,wanted=wanted,multiple=multiple) |
| _interact() |
| try: |
| rr = Nav.NavChooseFile(args) |
| good = 1 |
| except Nav.error, arg: |
| if arg[0] != -128: # userCancelledErr |
| raise Nav.error, arg |
| return None |
| if not rr.validRecord or not rr.selection: |
| return None |
| if issubclass(tpwanted, Carbon.File.FSRef): |
| return tpwanted(rr.selection_fsr[0]) |
| if issubclass(tpwanted, Carbon.File.FSSpec): |
| return tpwanted(rr.selection[0]) |
| if issubclass(tpwanted, str): |
| return tpwanted(rr.selection_fsr[0].as_pathname()) |
| if issubclass(tpwanted, unicode): |
| return tpwanted(rr.selection_fsr[0].as_pathname(), 'utf8') |
| raise TypeError, "Unknown value for argument 'wanted': %s" % repr(tpwanted) |
| |
| def AskFileForSave( |
| message=None, |
| savedFileName=None, |
| # From here on the order is not documented |
| version=None, |
| defaultLocation=None, |
| dialogOptionFlags=None, |
| location=None, |
| clientName=None, |
| windowTitle=None, |
| actionButtonLabel=None, |
| cancelButtonLabel=None, |
| preferenceKey=None, |
| popupExtension=None, |
| eventProc=_dummy_Nav_eventproc, |
| fileType=None, |
| fileCreator=None, |
| wanted=None, |
| multiple=None): |
| """Display a dialog asking the user for a filename to save to. |
| |
| wanted is the return type wanted: FSSpec, FSRef, unicode or string (default) |
| the other arguments can be looked up in Apple's Navigation Services documentation""" |
| |
| |
| default_flags = 0x07 |
| args, tpwanted = _process_Nav_args(default_flags, version=version, |
| defaultLocation=defaultLocation, dialogOptionFlags=dialogOptionFlags, |
| location=location,clientName=clientName,windowTitle=windowTitle, |
| actionButtonLabel=actionButtonLabel,cancelButtonLabel=cancelButtonLabel, |
| savedFileName=savedFileName,message=message,preferenceKey=preferenceKey, |
| popupExtension=popupExtension,eventProc=eventProc,fileType=fileType, |
| fileCreator=fileCreator,wanted=wanted,multiple=multiple) |
| _interact() |
| try: |
| rr = Nav.NavPutFile(args) |
| good = 1 |
| except Nav.error, arg: |
| if arg[0] != -128: # userCancelledErr |
| raise Nav.error, arg |
| return None |
| if not rr.validRecord or not rr.selection: |
| return None |
| if issubclass(tpwanted, Carbon.File.FSRef): |
| raise TypeError, "Cannot pass wanted=FSRef to AskFileForSave" |
| if issubclass(tpwanted, Carbon.File.FSSpec): |
| return tpwanted(rr.selection[0]) |
| if issubclass(tpwanted, (str, unicode)): |
| # This is gross, and probably incorrect too |
| vrefnum, dirid, name = rr.selection[0].as_tuple() |
| pardir_fss = Carbon.File.FSSpec((vrefnum, dirid, '')) |
| pardir_fsr = Carbon.File.FSRef(pardir_fss) |
| pardir_path = pardir_fsr.FSRefMakePath() # This is utf-8 |
| name_utf8 = unicode(name, 'macroman').encode('utf8') |
| fullpath = os.path.join(pardir_path, name_utf8) |
| if issubclass(tpwanted, unicode): |
| return unicode(fullpath, 'utf8') |
| return tpwanted(fullpath) |
| raise TypeError, "Unknown value for argument 'wanted': %s" % repr(tpwanted) |
| |
| def AskFolder( |
| message=None, |
| # From here on the order is not documented |
| version=None, |
| defaultLocation=None, |
| dialogOptionFlags=None, |
| location=None, |
| clientName=None, |
| windowTitle=None, |
| actionButtonLabel=None, |
| cancelButtonLabel=None, |
| preferenceKey=None, |
| popupExtension=None, |
| eventProc=_dummy_Nav_eventproc, |
| filterProc=None, |
| wanted=None, |
| multiple=None): |
| """Display a dialog asking the user for select a folder. |
| |
| wanted is the return type wanted: FSSpec, FSRef, unicode or string (default) |
| the other arguments can be looked up in Apple's Navigation Services documentation""" |
| |
| default_flags = 0x17 |
| args, tpwanted = _process_Nav_args(default_flags, version=version, |
| defaultLocation=defaultLocation, dialogOptionFlags=dialogOptionFlags, |
| location=location,clientName=clientName,windowTitle=windowTitle, |
| actionButtonLabel=actionButtonLabel,cancelButtonLabel=cancelButtonLabel, |
| message=message,preferenceKey=preferenceKey, |
| popupExtension=popupExtension,eventProc=eventProc,filterProc=filterProc, |
| wanted=wanted,multiple=multiple) |
| _interact() |
| try: |
| rr = Nav.NavChooseFolder(args) |
| good = 1 |
| except Nav.error, arg: |
| if arg[0] != -128: # userCancelledErr |
| raise Nav.error, arg |
| return None |
| if not rr.validRecord or not rr.selection: |
| return None |
| if issubclass(tpwanted, Carbon.File.FSRef): |
| return tpwanted(rr.selection_fsr[0]) |
| if issubclass(tpwanted, Carbon.File.FSSpec): |
| return tpwanted(rr.selection[0]) |
| if issubclass(tpwanted, str): |
| return tpwanted(rr.selection_fsr[0].as_pathname()) |
| if issubclass(tpwanted, unicode): |
| return tpwanted(rr.selection_fsr[0].as_pathname(), 'utf8') |
| raise TypeError, "Unknown value for argument 'wanted': %s" % repr(tpwanted) |
| |
| |
| def test(): |
| import time |
| |
| Message("Testing EasyDialogs.") |
| optionlist = (('v', 'Verbose'), ('verbose', 'Verbose as long option'), |
| ('flags=', 'Valued option'), ('f:', 'Short valued option')) |
| commandlist = (('start', 'Start something'), ('stop', 'Stop something')) |
| argv = GetArgv(optionlist=optionlist, commandlist=commandlist, addoldfile=0) |
| Message("Command line: %s"%' '.join(argv)) |
| for i in range(len(argv)): |
| print 'arg[%d] = %r' % (i, argv[i]) |
| ok = AskYesNoCancel("Do you want to proceed?") |
| ok = AskYesNoCancel("Do you want to identify?", yes="Identify", no="No") |
| if ok > 0: |
| s = AskString("Enter your first name", "Joe") |
| s2 = AskPassword("Okay %s, tell us your nickname"%s, s, cancel="None") |
| if not s2: |
| Message("%s has no secret nickname"%s) |
| else: |
| Message("Hello everybody!!\nThe secret nickname of %s is %s!!!"%(s, s2)) |
| else: |
| s = 'Anonymous' |
| rv = AskFileForOpen(message="Gimme a file, %s"%s, wanted=Carbon.File.FSSpec) |
| Message("rv: %s"%rv) |
| rv = AskFileForSave(wanted=Carbon.File.FSRef, savedFileName="%s.txt"%s) |
| Message("rv.as_pathname: %s"%rv.as_pathname()) |
| rv = AskFolder() |
| Message("Folder name: %s"%rv) |
| text = ( "Working Hard...", "Hardly Working..." , |
| "So far, so good!", "Keep on truckin'" ) |
| bar = ProgressBar("Progress, progress...", 0, label="Ramping up...") |
| try: |
| if hasattr(MacOS, 'SchedParams'): |
| appsw = MacOS.SchedParams(1, 0) |
| for i in xrange(20): |
| bar.inc() |
| time.sleep(0.05) |
| bar.set(0,100) |
| for i in xrange(100): |
| bar.set(i) |
| time.sleep(0.05) |
| if i % 10 == 0: |
| bar.label(text[(i/10) % 4]) |
| bar.label("Done.") |
| time.sleep(1.0) # give'em a chance to see "Done." |
| finally: |
| del bar |
| if hasattr(MacOS, 'SchedParams'): |
| MacOS.SchedParams(*appsw) |
| |
| if __name__ == '__main__': |
| try: |
| test() |
| except KeyboardInterrupt: |
| Message("Operation Canceled.") |