wxPython/wx/py/shell.py

   1 """Shell is an interactive text control in which a user types in
   2 commands to be sent to the interpreter.  This particular shell is
   3 based on wxPython's wxStyledTextCtrl.
   4
   5 Sponsored by Orbtech - Your source for Python programming expertise."""
   6
   7 __author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
   8 __cvsid__ = "$Id$"
   9 __revision__ = "$Revision$"[11:-2]
  10
  11 import wx
  12 from wx import stc
  13
  14 import keyword
  15 import os
  16 import sys
  17 import time
  18
  19 from buffer import Buffer
  20 import dispatcher
  21 import editwindow
  22 import frame
  23 from pseudo import PseudoFileIn
  24 from pseudo import PseudoFileOut
  25 from pseudo import PseudoFileErr
  26 from version import VERSION
  27
  28 sys.ps3 = '<-- '  # Input prompt.
  29
  30 NAVKEYS = (wx.WXK_END, wx.WXK_LEFT, wx.WXK_RIGHT,
  31            wx.WXK_UP, wx.WXK_DOWN, wx.WXK_PRIOR, wx.WXK_NEXT)
  32
  33
  34 class ShellFrame(frame.Frame, frame.ShellFrameMixin):
  35     """Frame containing the shell component."""
  36
  37     name = 'Shell Frame'
  38     revision = __revision__
  39
  40     def __init__(self, parent=None, id=-1, title='PyShell',
  41                  pos=wx.DefaultPosition, size=wx.DefaultSize,
  42                  style=wx.DEFAULT_FRAME_STYLE, locals=None,
  43                  InterpClass=None,
  44                  config=None, dataDir=None,
  45                  *args, **kwds):
  46         """Create ShellFrame instance."""
  47         frame.Frame.__init__(self, parent, id, title, pos, size, style)
  48         frame.ShellFrameMixin.__init__(self, config, dataDir)
  49
  50         if size == wx.DefaultSize:
  51             self.SetSize((750, 525))
  52
  53         intro = 'PyShell %s - The Flakiest Python Shell' % VERSION
  54         self.SetStatusText(intro.replace('\n', ', '))
  55         self.shell = Shell(parent=self, id=-1, introText=intro,
  56                            locals=locals, InterpClass=InterpClass,
  57                            startupScript=self.startupScript,
  58                            execStartupScript=self.execStartupScript,
  59                            *args, **kwds)
  60
  61         # Override the shell so that status messages go to the status bar.
  62         self.shell.setStatusText = self.SetStatusText
  63
  64         self.shell.SetFocus()
  65         self.LoadSettings()
  66
  67
  68     def OnClose(self, event):
  69         """Event handler for closing."""
  70         # This isn't working the way I want, but I'll leave it for now.
  71         if self.shell.waiting:
  72             if event.CanVeto():
  73                 event.Veto(True)
  74         else:
  75             self.SaveSettings()
  76             self.shell.destroy()
  77             self.Destroy()
  78
  79     def OnAbout(self, event):
  80         """Display an About window."""
  81         title = 'About PyShell'
  82         text = 'PyShell %s\n\n' % VERSION + \
  83                'Yet another Python shell, only flakier.\n\n' + \
  84                'Half-baked by Patrick K. O\'Brien,\n' + \
  85                'the other half is still in the oven.\n\n' + \
  86                'Shell Revision: %s\n' % self.shell.revision + \
  87                'Interpreter Revision: %s\n\n' % self.shell.interp.revision + \
  88                'Platform: %s\n' % sys.platform + \
  89                'Python Version: %s\n' % sys.version.split()[0] + \
  90                'wxPython Version: %s\n' % wx.VERSION_STRING + \
  91                ('\t(%s)\n' % ", ".join(wx.PlatformInfo[1:]))
  92         dialog = wx.MessageDialog(self, text, title,
  93                                   wx.OK | wx.ICON_INFORMATION)
  94         dialog.ShowModal()
  95         dialog.Destroy()
  96
  97
  98     def OnHelp(self, event):
  99         """Show a help dialog."""
 100         frame.ShellFrameMixin.OnHelp(self, event)
 101
 102
 103     def LoadSettings(self):
 104         if self.config is not None:
 105             frame.ShellFrameMixin.LoadSettings(self)
 106             frame.Frame.LoadSettings(self, self.config)
 107             self.shell.LoadSettings(self.config)
 108
 109     def SaveSettings(self, force=False):
 110         if self.config is not None:
 111             frame.ShellFrameMixin.SaveSettings(self)
 112             if self.autoSaveSettings or force:
 113                 frame.Frame.SaveSettings(self, self.config)
 114                 self.shell.SaveSettings(self.config)
 115
 116     def DoSaveSettings(self):
 117         if self.config is not None:
 118             self.SaveSettings(force=True)
 119             self.config.Flush()
 120
 121
 122
 123
 124 HELP_TEXT = """\
 125 * Key bindings:
 126 Home              Go to the beginning of the command or line.
 127 Shift+Home        Select to the beginning of the command or line.
 128 Shift+End         Select to the end of the line.
 129 End               Go to the end of the line.
 130 Ctrl+C            Copy selected text, removing prompts.
 131 Ctrl+Shift+C      Copy selected text, retaining prompts.
 132 Alt+C             Copy to the clipboard, including prefixed prompts.
 133 Ctrl+X            Cut selected text.
 134 Ctrl+V            Paste from clipboard.
 135 Ctrl+Shift+V      Paste and run multiple commands from clipboard.
 136 Ctrl+Up Arrow     Retrieve Previous History item.
 137 Alt+P             Retrieve Previous History item.
 138 Ctrl+Down Arrow   Retrieve Next History item.
 139 Alt+N             Retrieve Next History item.
 140 Shift+Up Arrow    Insert Previous History item.
 141 Shift+Down Arrow  Insert Next History item.
 142 F8                Command-completion of History item.
 143                   (Type a few characters of a previous command and press F8.)
 144 Ctrl+Enter        Insert new line into multiline command.
 145 Ctrl+]            Increase font size.
 146 Ctrl+[            Decrease font size.
 147 Ctrl+=            Default font size.
 148 Ctrl-Space        Show Auto Completion.
 149 Ctrl-Alt-Space    Show Call Tip.
 150 Shift+Enter       Complete Text from History.
 151 Ctrl+F            Search
 152 F3                Search next
 153 Ctrl+H            "hide" lines containing selection / "unhide"
 154 F12               on/off "free-edit" mode
 155 """
 156
 157 class ShellFacade:
 158     """Simplified interface to all shell-related functionality.
 159
 160     This is a semi-transparent facade, in that all attributes of other
 161     are accessible, even though only some are visible to the user."""
 162
 163     name = 'Shell Interface'
 164     revision = __revision__
 165
 166     def __init__(self, other):
 167         """Create a ShellFacade instance."""
 168         d = self.__dict__
 169         d['other'] = other
 170         d['helpText'] = HELP_TEXT
 171         d['this'] = other.this
 172
 173     def help(self):
 174         """Display some useful information about how to use the shell."""
 175         self.write(self.helpText)
 176
 177     def __getattr__(self, name):
 178         if hasattr(self.other, name):
 179             return getattr(self.other, name)
 180         else:
 181             raise AttributeError, name
 182
 183     def __setattr__(self, name, value):
 184         if self.__dict__.has_key(name):
 185             self.__dict__[name] = value
 186         elif hasattr(self.other, name):
 187             setattr(self.other, name, value)
 188         else:
 189             raise AttributeError, name
 190
 191     def _getAttributeNames(self):
 192         """Return list of magic attributes to extend introspection."""
 193         list = [
 194             'about',
 195             'ask',
 196             'autoCallTip',
 197             'autoComplete',
 198             'autoCompleteAutoHide',
 199             'autoCompleteCaseInsensitive',
 200             'autoCompleteIncludeDouble',
 201             'autoCompleteIncludeMagic',
 202             'autoCompleteIncludeSingle',
 203             'callTipInsert',
 204             'clear',
 205             'pause',
 206             'prompt',
 207             'quit',
 208             'redirectStderr',
 209             'redirectStdin',
 210             'redirectStdout',
 211             'run',
 212             'runfile',
 213             'wrap',
 214             'zoom',
 215             ]
 216         list.sort()
 217         return list
 218
 219
 220
 221 class Shell(editwindow.EditWindow):
 222     """Shell based on StyledTextCtrl."""
 223
 224     name = 'Shell'
 225     revision = __revision__
 226
 227     def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
 228                  size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
 229                  introText='', locals=None, InterpClass=None,
 230                  startupScript=None, execStartupScript=True,
 231                  *args, **kwds):
 232         """Create Shell instance."""
 233         editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
 234         self.wrap()
 235         if locals is None:
 236             import __main__
 237             locals = __main__.__dict__
 238
 239         # Grab these so they can be restored by self.redirect* methods.
 240         self.stdin = sys.stdin
 241         self.stdout = sys.stdout
 242         self.stderr = sys.stderr
 243
 244         # Import a default interpreter class if one isn't provided.
 245         if InterpClass == None:
 246             from interpreter import Interpreter
 247         else:
 248             Interpreter = InterpClass
 249
 250         # Create a replacement for stdin.
 251         self.reader = PseudoFileIn(self.readline, self.readlines)
 252         self.reader.input = ''
 253         self.reader.isreading = False
 254
 255         # Set up the interpreter.
 256         self.interp = Interpreter(locals=locals,
 257                                   rawin=self.raw_input,
 258                                   stdin=self.reader,
 259                                   stdout=PseudoFileOut(self.writeOut),
 260                                   stderr=PseudoFileErr(self.writeErr),
 261                                   *args, **kwds)
 262
 263         # Set up the buffer.
 264         self.buffer = Buffer()
 265
 266         # Find out for which keycodes the interpreter will autocomplete.
 267         self.autoCompleteKeys = self.interp.getAutoCompleteKeys()
 268
 269         # Keep track of the last non-continuation prompt positions.
 270         self.promptPosStart = 0
 271         self.promptPosEnd = 0
 272
 273         # Keep track of multi-line commands.
 274         self.more = False
 275
 276         # Create the command history.  Commands are added into the
 277         # front of the list (ie. at index 0) as they are entered.
 278         # self.historyIndex is the current position in the history; it
 279         # gets incremented as you retrieve the previous command,
 280         # decremented as you retrieve the next, and reset when you hit
 281         # Enter.  self.historyIndex == -1 means you're on the current
 282         # command, not in the history.
 283         self.history = []
 284         self.historyIndex = -1
 285
 286         #seb add mode for "free edit"
 287         self.noteMode = 0
 288         self.MarkerDefine(0,stc.STC_MARK_ROUNDRECT)  # marker for hidden
 289         self.searchTxt = ""
 290
 291         # Assign handlers for keyboard events.
 292         self.Bind(wx.EVT_CHAR, self.OnChar)
 293         self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
 294
 295         # Assign handler for idle time.
 296         self.waiting = False
 297         self.Bind(wx.EVT_IDLE, self.OnIdle)
 298
 299         # Display the introductory banner information.
 300         self.showIntro(introText)
 301
 302         # Assign some pseudo keywords to the interpreter's namespace.
 303         self.setBuiltinKeywords()
 304
 305         # Add 'shell' to the interpreter's local namespace.
 306         self.setLocalShell()
 307
 308         ## NOTE:  See note at bottom of this file...
 309         ## #seb: File drag and drop
 310         ## self.SetDropTarget( FileDropTarget(self) )
 311
 312         # Do this last so the user has complete control over their
 313         # environment.  They can override anything they want.
 314         if execStartupScript:
 315             if startupScript is None:
 316                 startupScript = os.environ.get('PYTHONSTARTUP')
 317             self.execStartupScript(startupScript)
 318         else:
 319             self.prompt()
 320
 321         wx.CallAfter(self.ScrollToLine, 0)
 322
 323
 324     def clearHistory(self):
 325         self.history = []
 326         self.historyIndex = -1
 327         dispatcher.send(signal="Shell.clearHistory")
 328
 329
 330     def destroy(self):
 331         del self.interp
 332
 333     def setFocus(self):
 334         """Set focus to the shell."""
 335         self.SetFocus()
 336
 337     def OnIdle(self, event):
 338         """Free the CPU to do other things."""
 339         if self.waiting:
 340             time.sleep(0.05)
 341         event.Skip()
 342
 343     def showIntro(self, text=''):
 344         """Display introductory text in the shell."""
 345         if text:
 346             self.write(text)
 347         try:
 348             if self.interp.introText:
 349                 if text and not text.endswith(os.linesep):
 350                     self.write(os.linesep)
 351                 self.write(self.interp.introText)
 352         except AttributeError:
 353             pass
 354
 355     def setBuiltinKeywords(self):
 356         """Create pseudo keywords as part of builtins.
 357
 358         This sets "close", "exit" and "quit" to a helpful string.
 359         """
 360         import __builtin__
 361         __builtin__.close = __builtin__.exit = __builtin__.quit = \
 362             'Click on the close button to leave the application.'
 363
 364
 365     def quit(self):
 366         """Quit the application."""
 367         # XXX Good enough for now but later we want to send a close event.
 368         # In the close event handler we can make sure they want to
 369         # quit.  Other applications, like PythonCard, may choose to
 370         # hide rather than quit so we should just post the event and
 371         # let the surrounding app decide what it wants to do.
 372         self.write('Click on the close button to leave the application.')
 373
 374
 375     def setLocalShell(self):
 376         """Add 'shell' to locals as reference to ShellFacade instance."""
 377         self.interp.locals['shell'] = ShellFacade(other=self)
 378
 379
 380     def execStartupScript(self, startupScript):
 381         """Execute the user's PYTHONSTARTUP script if they have one."""
 382         if startupScript and os.path.isfile(startupScript):
 383             text = 'Startup script executed: ' + startupScript
 384             self.push('print %r; execfile(%r)' % (text, startupScript))
 385             self.interp.startupScript = startupScript
 386         else:
 387             self.push('')
 388
 389
 390     def about(self):
 391         """Display information about Py."""
 392         text = """
 393 Author: %r
 394 Py Version: %s
 395 Py Shell Revision: %s
 396 Py Interpreter Revision: %s
 397 Python Version: %s
 398 wxPython Version: %s
 399 wxPython PlatformInfo: %s
 400 Platform: %s""" % \
 401         (__author__, VERSION, self.revision, self.interp.revision,
 402          sys.version.split()[0], wx.VERSION_STRING, str(wx.PlatformInfo),
 403          sys.platform)
 404         self.write(text.strip())
 405
 406
 407     def OnChar(self, event):
 408         """Keypress event handler.
 409
 410         Only receives an event if OnKeyDown calls event.Skip() for the
 411         corresponding event."""
 412
 413         if self.noteMode:
 414             event.Skip()
 415             return
 416
 417         # Prevent modification of previously submitted
 418         # commands/responses.
 419         if not self.CanEdit():
 420             return
 421         key = event.GetKeyCode()
 422         currpos = self.GetCurrentPos()
 423         stoppos = self.promptPosEnd
 424         # Return (Enter) needs to be ignored in this handler.
 425         if key in [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]:
 426             pass
 427         elif key in self.autoCompleteKeys:
 428             # Usually the dot (period) key activates auto completion.
 429             # Get the command between the prompt and the cursor.  Add
 430             # the autocomplete character to the end of the command.
 431             if self.AutoCompActive():
 432                 self.AutoCompCancel()
 433             command = self.GetTextRange(stoppos, currpos) + chr(key)
 434             self.write(chr(key))
 435             if self.autoComplete:
 436                 self.autoCompleteShow(command)
 437         elif key == ord('('):
 438             # The left paren activates a call tip and cancels an
 439             # active auto completion.
 440             if self.AutoCompActive():
 441                 self.AutoCompCancel()
 442             # Get the command between the prompt and the cursor.  Add
 443             # the '(' to the end of the command.
 444             self.ReplaceSelection('')
 445             command = self.GetTextRange(stoppos, currpos) + '('
 446             self.write('(')
 447             self.autoCallTipShow(command, self.GetCurrentPos() == self.GetTextLength())
 448         else:
 449             # Allow the normal event handling to take place.
 450             event.Skip()
 451
 452
 453     def OnKeyDown(self, event):
 454         """Key down event handler."""
 455
 456         key = event.GetKeyCode()
 457         # If the auto-complete window is up let it do its thing.
 458         if self.AutoCompActive():
 459             event.Skip()
 460             return
 461
 462         # Prevent modification of previously submitted
 463         # commands/responses.
 464         controlDown = event.ControlDown()
 465         altDown = event.AltDown()
 466         shiftDown = event.ShiftDown()
 467         currpos = self.GetCurrentPos()
 468         endpos = self.GetTextLength()
 469         selecting = self.GetSelectionStart() != self.GetSelectionEnd()
 470
 471         if controlDown and shiftDown and key in (ord('F'), ord('f')):
 472             li = self.GetCurrentLine()
 473             m = self.MarkerGet(li)
 474             if m & 1<<0:
 475                 startP = self.PositionFromLine(li)
 476                 self.MarkerDelete(li, 0)
 477                 maxli = self.GetLineCount()
 478                 li += 1 # li stayed visible as header-line
 479                 li0 = li
 480                 while li<maxli and self.GetLineVisible(li) == 0:
 481                     li += 1
 482                 endP = self.GetLineEndPosition(li-1)
 483                 self.ShowLines(li0, li-1)
 484                 self.SetSelection( startP, endP ) # select reappearing text to allow "hide again"
 485                 return
 486             startP,endP = self.GetSelection()
 487             endP-=1
 488             startL,endL = self.LineFromPosition(startP), self.LineFromPosition(endP)
 489
 490             if endL == self.LineFromPosition(self.promptPosEnd): # never hide last prompt
 491                 endL -= 1
 492
 493             m = self.MarkerGet(startL)
 494             self.MarkerAdd(startL, 0)
 495             self.HideLines(startL+1,endL)
 496             self.SetCurrentPos( startP ) # to ensure caret stays visible !
 497
 498         if key == wx.WXK_F12: #seb
 499             if self.noteMode:
 500                 # self.promptPosStart not used anyway - or ?
 501                 self.promptPosEnd = self.PositionFromLine( self.GetLineCount()-1 ) + len(str(sys.ps1))
 502                 self.GotoLine(self.GetLineCount())
 503                 self.GotoPos(self.promptPosEnd)
 504                 self.prompt()  #make sure we have a prompt
 505                 self.SetCaretForeground("black")
 506                 self.SetCaretWidth(1)    #default
 507                 self.SetCaretPeriod(500) #default
 508             else:
 509                 self.SetCaretForeground("red")
 510                 self.SetCaretWidth(4)
 511                 self.SetCaretPeriod(0) #steady
 512
 513             self.noteMode = not self.noteMode
 514             return
 515         if self.noteMode:
 516             event.Skip()
 517             return
 518
 519         # Return (Enter) is used to submit a command to the
 520         # interpreter.
 521         if (not controlDown and not shiftDown and not altDown) and key in [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]:
 522             if self.CallTipActive():
 523                 self.CallTipCancel()
 524             self.processLine()
 525
 526         # Complete Text (from already typed words)
 527         elif shiftDown and key in [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]:
 528             self.OnShowCompHistory()
 529
 530         # Ctrl+Return (Ctrl+Enter) is used to insert a line break.
 531         elif controlDown and key in [wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER]:
 532             if self.CallTipActive():
 533                 self.CallTipCancel()
 534             if currpos == endpos:
 535                 self.processLine()
 536             else:
 537                 self.insertLineBreak()
 538
 539         # Let Ctrl-Alt-* get handled normally.
 540         elif controlDown and altDown:
 541             event.Skip()
 542
 543         # Clear the current, unexecuted command.
 544         elif key == wx.WXK_ESCAPE:
 545             if self.CallTipActive():
 546                 event.Skip()
 547             else:
 548                 self.clearCommand()
 549
 550         # Clear the current command
 551         elif key == wx.WXK_BACK and controlDown and shiftDown:
 552             self.clearCommand()
 553
 554         # Increase font size.
 555         elif controlDown and key in (ord(']'), wx.WXK_NUMPAD_ADD):
 556             dispatcher.send(signal='FontIncrease')
 557
 558         # Decrease font size.
 559         elif controlDown and key in (ord('['), wx.WXK_NUMPAD_SUBTRACT):
 560             dispatcher.send(signal='FontDecrease')
 561
 562         # Default font size.
 563         elif controlDown and key in (ord('='), wx.WXK_NUMPAD_DIVIDE):
 564             dispatcher.send(signal='FontDefault')
 565
 566         # Cut to the clipboard.
 567         elif (controlDown and key in (ord('X'), ord('x'))) \
 568                  or (shiftDown and key == wx.WXK_DELETE):
 569             self.Cut()
 570
 571         # Copy to the clipboard.
 572         elif controlDown and not shiftDown \
 573                  and key in (ord('C'), ord('c'), wx.WXK_INSERT):
 574             self.Copy()
 575
 576         # Copy to the clipboard, including prompts.
 577         elif controlDown and shiftDown \
 578                  and key in (ord('C'), ord('c'), wx.WXK_INSERT):
 579             self.CopyWithPrompts()
 580
 581         # Copy to the clipboard, including prefixed prompts.
 582         elif altDown and not controlDown \
 583                  and key in (ord('C'), ord('c'), wx.WXK_INSERT):
 584             self.CopyWithPromptsPrefixed()
 585
 586         # Home needs to be aware of the prompt.
 587         elif key == wx.WXK_HOME:
 588             home = self.promptPosEnd
 589             if currpos > home:
 590                 self.SetCurrentPos(home)
 591                 if not selecting and not shiftDown:
 592                     self.SetAnchor(home)
 593                     self.EnsureCaretVisible()
 594             else:
 595                 event.Skip()
 596
 597         #
 598         # The following handlers modify text, so we need to see if
 599         # there is a selection that includes text prior to the prompt.
 600         #
 601         # Don't modify a selection with text prior to the prompt.
 602         elif selecting and key not in NAVKEYS and not self.CanEdit():
 603             pass
 604
 605         # Paste from the clipboard.
 606         elif (controlDown and not shiftDown and key in (ord('V'), ord('v'))) \
 607                  or (shiftDown and not controlDown and key == wx.WXK_INSERT):
 608             self.Paste()
 609
 610         # manually invoke AutoComplete and Calltips
 611         elif controlDown and key == wx.WXK_SPACE:
 612             self.OnCallTipAutoCompleteManually(shiftDown)
 613
 614         # Paste from the clipboard, run commands.
 615         elif controlDown and shiftDown and key in (ord('V'), ord('v')):
 616             self.PasteAndRun()
 617
 618         # Replace with the previous command from the history buffer.
 619         elif (controlDown and key == wx.WXK_UP) \
 620                  or (altDown and key in (ord('P'), ord('p'))):
 621             self.OnHistoryReplace(step=+1)
 622
 623         # Replace with the next command from the history buffer.
 624         elif (controlDown and key == wx.WXK_DOWN) \
 625                  or (altDown and key in (ord('N'), ord('n'))):
 626             self.OnHistoryReplace(step=-1)
 627
 628         # Insert the previous command from the history buffer.
 629         elif (shiftDown and key == wx.WXK_UP) and self.CanEdit():
 630             self.OnHistoryInsert(step=+1)
 631
 632         # Insert the next command from the history buffer.
 633         elif (shiftDown and key == wx.WXK_DOWN) and self.CanEdit():
 634             self.OnHistoryInsert(step=-1)
 635
 636         # Search up the history for the text in front of the cursor.
 637         elif key == wx.WXK_F8:
 638             self.OnHistorySearch()
 639
 640         # Don't backspace over the latest non-continuation prompt.
 641         elif key == wx.WXK_BACK:
 642             if selecting and self.CanEdit():
 643                 event.Skip()
 644             elif currpos > self.promptPosEnd:
 645                 event.Skip()
 646
 647         # Only allow these keys after the latest prompt.
 648         elif key in (wx.WXK_TAB, wx.WXK_DELETE):
 649             if self.CanEdit():
 650                 event.Skip()
 651
 652         # Don't toggle between insert mode and overwrite mode.
 653         elif key == wx.WXK_INSERT:
 654             pass
 655
 656         # Don't allow line deletion.
 657         elif controlDown and key in (ord('L'), ord('l')):
 658             pass
 659
 660         # Don't allow line transposition.
 661         elif controlDown and key in (ord('T'), ord('t')):
 662             pass
 663
 664         # Basic navigation keys should work anywhere.
 665         elif key in NAVKEYS:
 666             event.Skip()
 667
 668         # Protect the readonly portion of the shell.
 669         elif not self.CanEdit():
 670             pass
 671
 672         else:
 673             event.Skip()
 674
 675
 676     def OnShowCompHistory(self):
 677         """Show possible autocompletion Words from already typed words."""
 678
 679         #copy from history
 680         his = self.history[:]
 681
 682         #put together in one string
 683         joined = " ".join (his)
 684         import re
 685
 686         #sort out only "good" words
 687         newlist = re.split("[ \.\[\]=}(\)\,0-9\"]", joined)
 688
 689         #length > 1 (mix out "trash")
 690         thlist = []
 691         for i in newlist:
 692             if len (i) > 1:
 693                 thlist.append (i)
 694
 695         #unique (no duplicate words
 696         #oneliner from german python forum => unique list
 697         unlist = [thlist[i] for i in xrange(len(thlist)) if thlist[i] not in thlist[:i]]
 698
 699         #sort lowercase
 700         unlist.sort(lambda a, b: cmp(a.lower(), b.lower()))
 701
 702         #this is more convenient, isn't it?
 703         self.AutoCompSetIgnoreCase(True)
 704
 705         #join again together in a string
 706         stringlist = " ".join(unlist)
 707
 708         #pos von 0 noch ausrechnen
 709
 710         #how big is the offset?
 711         cpos = self.GetCurrentPos() - 1
 712         while chr (self.GetCharAt (cpos)).isalnum():
 713             cpos -= 1
 714
 715         #the most important part
 716         self.AutoCompShow(self.GetCurrentPos() - cpos -1, stringlist)
 717
 718
 719     def clearCommand(self):
 720         """Delete the current, unexecuted command."""
 721         startpos = self.promptPosEnd
 722         endpos = self.GetTextLength()
 723         self.SetSelection(startpos, endpos)
 724         self.ReplaceSelection('')
 725         self.more = False
 726
 727     def OnHistoryReplace(self, step):
 728         """Replace with the previous/next command from the history buffer."""
 729         self.clearCommand()
 730         self.replaceFromHistory(step)
 731
 732     def replaceFromHistory(self, step):
 733         """Replace selection with command from the history buffer."""
 734         ps2 = str(sys.ps2)
 735         self.ReplaceSelection('')
 736         newindex = self.historyIndex + step
 737         if -1 <= newindex <= len(self.history):
 738             self.historyIndex = newindex
 739         if 0 <= newindex <= len(self.history)-1:
 740             command = self.history[self.historyIndex]
 741             command = command.replace('\n', os.linesep + ps2)
 742             self.ReplaceSelection(command)
 743
 744     def OnHistoryInsert(self, step):
 745         """Insert the previous/next command from the history buffer."""
 746         if not self.CanEdit():
 747             return
 748         startpos = self.GetCurrentPos()
 749         self.replaceFromHistory(step)
 750         endpos = self.GetCurrentPos()
 751         self.SetSelection(endpos, startpos)
 752
 753     def OnHistorySearch(self):
 754         """Search up the history buffer for the text in front of the cursor."""
 755         if not self.CanEdit():
 756             return
 757         startpos = self.GetCurrentPos()
 758         # The text up to the cursor is what we search for.
 759         numCharsAfterCursor = self.GetTextLength() - startpos
 760         searchText = self.getCommand(rstrip=False)
 761         if numCharsAfterCursor > 0:
 762             searchText = searchText[:-numCharsAfterCursor]
 763         if not searchText:
 764             return
 765         # Search upwards from the current history position and loop
 766         # back to the beginning if we don't find anything.
 767         if (self.historyIndex <= -1) \
 768         or (self.historyIndex >= len(self.history)-2):
 769             searchOrder = range(len(self.history))
 770         else:
 771             searchOrder = range(self.historyIndex+1, len(self.history)) + \
 772                           range(self.historyIndex)
 773         for i in searchOrder:
 774             command = self.history[i]
 775             if command[:len(searchText)] == searchText:
 776                 # Replace the current selection with the one we found.
 777                 self.ReplaceSelection(command[len(searchText):])
 778                 endpos = self.GetCurrentPos()
 779                 self.SetSelection(endpos, startpos)
 780                 # We've now warped into middle of the history.
 781                 self.historyIndex = i
 782                 break
 783
 784     def setStatusText(self, text):
 785         """Display status information."""
 786
 787         # This method will likely be replaced by the enclosing app to
 788         # do something more interesting, like write to a status bar.
 789         print text
 790
 791     def insertLineBreak(self):
 792         """Insert a new line break."""
 793         if self.CanEdit():
 794             self.write(os.linesep)
 795             self.more = True
 796             self.prompt()
 797
 798     def processLine(self):
 799         """Process the line of text at which the user hit Enter."""
 800
 801         # The user hit ENTER and we need to decide what to do. They
 802         # could be sitting on any line in the shell.
 803
 804         thepos = self.GetCurrentPos()
 805         startpos = self.promptPosEnd
 806         endpos = self.GetTextLength()
 807         ps2 = str(sys.ps2)
 808         # If they hit RETURN inside the current command, execute the
 809         # command.
 810         if self.CanEdit():
 811             self.SetCurrentPos(endpos)
 812             self.interp.more = False
 813             command = self.GetTextRange(startpos, endpos)
 814             lines = command.split(os.linesep + ps2)
 815             lines = [line.rstrip() for line in lines]
 816             command = '\n'.join(lines)
 817             if self.reader.isreading:
 818                 if not command:
 819                     # Match the behavior of the standard Python shell
 820                     # when the user hits return without entering a
 821                     # value.
 822                     command = '\n'
 823                 self.reader.input = command
 824                 self.write(os.linesep)
 825             else:
 826                 self.push(command)
 827                 wx.FutureCall(1, self.EnsureCaretVisible)
 828         # Or replace the current command with the other command.
 829         else:
 830             # If the line contains a command (even an invalid one).
 831             if self.getCommand(rstrip=False):
 832                 command = self.getMultilineCommand()
 833                 self.clearCommand()
 834                 self.write(command)
 835             # Otherwise, put the cursor back where we started.
 836             else:
 837                 self.SetCurrentPos(thepos)
 838                 self.SetAnchor(thepos)
 839
 840     def getMultilineCommand(self, rstrip=True):
 841         """Extract a multi-line command from the editor.
 842
 843         The command may not necessarily be valid Python syntax."""
 844         # XXX Need to extract real prompts here. Need to keep track of
 845         # the prompt every time a command is issued.
 846         ps1 = str(sys.ps1)
 847         ps1size = len(ps1)
 848         ps2 = str(sys.ps2)
 849         ps2size = len(ps2)
 850         # This is a total hack job, but it works.
 851         text = self.GetCurLine()[0]
 852         line = self.GetCurrentLine()
 853         while text[:ps2size] == ps2 and line > 0:
 854             line -= 1
 855             self.GotoLine(line)
 856             text = self.GetCurLine()[0]
 857         if text[:ps1size] == ps1:
 858             line = self.GetCurrentLine()
 859             self.GotoLine(line)
 860             startpos = self.GetCurrentPos() + ps1size
 861             line += 1
 862             self.GotoLine(line)
 863             while self.GetCurLine()[0][:ps2size] == ps2:
 864                 line += 1
 865                 self.GotoLine(line)
 866             stoppos = self.GetCurrentPos()
 867             command = self.GetTextRange(startpos, stoppos)
 868             command = command.replace(os.linesep + ps2, '\n')
 869             command = command.rstrip()
 870             command = command.replace('\n', os.linesep + ps2)
 871         else:
 872             command = ''
 873         if rstrip:
 874             command = command.rstrip()
 875         return command
 876
 877     def getCommand(self, text=None, rstrip=True):
 878         """Extract a command from text which may include a shell prompt.
 879
 880         The command may not necessarily be valid Python syntax."""
 881         if not text:
 882             text = self.GetCurLine()[0]
 883         # Strip the prompt off the front leaving just the command.
 884         command = self.lstripPrompt(text)
 885         if command == text:
 886             command = ''  # Real commands have prompts.
 887         if rstrip:
 888             command = command.rstrip()
 889         return command
 890
 891     def lstripPrompt(self, text):
 892         """Return text without a leading prompt."""
 893         ps1 = str(sys.ps1)
 894         ps1size = len(ps1)
 895         ps2 = str(sys.ps2)
 896         ps2size = len(ps2)
 897         # Strip the prompt off the front of text.
 898         if text[:ps1size] == ps1:
 899             text = text[ps1size:]
 900         elif text[:ps2size] == ps2:
 901             text = text[ps2size:]
 902         return text
 903
 904     def push(self, command, silent = False):
 905         """Send command to the interpreter for execution."""
 906         if not silent:
 907             self.write(os.linesep)
 908         busy = wx.BusyCursor()
 909         self.waiting = True
 910         self.more = self.interp.push(command)
 911         self.waiting = False
 912         del busy
 913         if not self.more:
 914             self.addHistory(command.rstrip())
 915         if not silent:
 916             self.prompt()
 917
 918     def addHistory(self, command):
 919         """Add command to the command history."""
 920         # Reset the history position.
 921         self.historyIndex = -1
 922         # Insert this command into the history, unless it's a blank
 923         # line or the same as the last command.
 924         if command != '' \
 925         and (len(self.history) == 0 or command != self.history[0]):
 926             self.history.insert(0, command)
 927             dispatcher.send(signal="Shell.addHistory", command=command)
 928
 929     def write(self, text):
 930         """Display text in the shell.
 931
 932         Replace line endings with OS-specific endings."""
 933         text = self.fixLineEndings(text)
 934         self.AddText(text)
 935         self.EnsureCaretVisible()
 936
 937     def fixLineEndings(self, text):
 938         """Return text with line endings replaced by OS-specific endings."""
 939         lines = text.split('\r\n')
 940         for l in range(len(lines)):
 941             chunks = lines[l].split('\r')
 942             for c in range(len(chunks)):
 943                 chunks[c] = os.linesep.join(chunks[c].split('\n'))
 944             lines[l] = os.linesep.join(chunks)
 945         text = os.linesep.join(lines)
 946         return text
 947
 948     def prompt(self):
 949         """Display proper prompt for the context: ps1, ps2 or ps3.
 950
 951         If this is a continuation line, autoindent as necessary."""
 952         isreading = self.reader.isreading
 953         skip = False
 954         if isreading:
 955             prompt = str(sys.ps3)
 956         elif self.more:
 957             prompt = str(sys.ps2)
 958         else:
 959             prompt = str(sys.ps1)
 960         pos = self.GetCurLine()[1]
 961         if pos > 0:
 962             if isreading:
 963                 skip = True
 964             else:
 965                 self.write(os.linesep)
 966         if not self.more:
 967             self.promptPosStart = self.GetCurrentPos()
 968         if not skip:
 969             self.write(prompt)
 970         if not self.more:
 971             self.promptPosEnd = self.GetCurrentPos()
 972             # Keep the undo feature from undoing previous responses.
 973             self.EmptyUndoBuffer()
 974         # XXX Add some autoindent magic here if more.
 975         if self.more:
 976             self.write(' '*4)  # Temporary hack indentation.
 977         self.EnsureCaretVisible()
 978         self.ScrollToColumn(0)
 979
 980     def readline(self):
 981         """Replacement for stdin.readline()."""
 982         input = ''
 983         reader = self.reader
 984         reader.isreading = True
 985         self.prompt()
 986         try:
 987             while not reader.input:
 988                 wx.YieldIfNeeded()
 989             input = reader.input
 990         finally:
 991             reader.input = ''
 992             reader.isreading = False
 993         input = str(input)  # In case of Unicode.
 994         return input
 995
 996     def readlines(self):
 997         """Replacement for stdin.readlines()."""
 998         lines = []
 999         while lines[-1:] != ['\n']:
1000             lines.append(self.readline())
1001         return lines
1002
1003     def raw_input(self, prompt=''):
1004         """Return string based on user input."""
1005         if prompt:
1006             self.write(prompt)
1007         return self.readline()
1008
1009     def ask(self, prompt='Please enter your response:'):
1010         """Get response from the user using a dialog box."""
1011         dialog = wx.TextEntryDialog(None, prompt,
1012                                     'Input Dialog (Raw)', '')
1013         try:
1014             if dialog.ShowModal() == wx.ID_OK:
1015                 text = dialog.GetValue()
1016                 return text
1017         finally:
1018             dialog.Destroy()
1019         return ''
1020
1021     def pause(self):
1022         """Halt execution pending a response from the user."""
1023         self.ask('Press enter to continue:')
1024
1025     def clear(self):
1026         """Delete all text from the shell."""
1027         self.ClearAll()
1028
1029     def run(self, command, prompt=True, verbose=True):
1030         """Execute command as if it was typed in directly.
1031         >>> shell.run('print "this"')
1032         >>> print "this"
1033         this
1034         >>>
1035         """
1036         # Go to the very bottom of the text.
1037         endpos = self.GetTextLength()
1038         self.SetCurrentPos(endpos)
1039         command = command.rstrip()
1040         if prompt: self.prompt()
1041         if verbose: self.write(command)
1042         self.push(command)
1043
1044     def runfile(self, filename):
1045         """Execute all commands in file as if they were typed into the
1046         shell."""
1047         file = open(filename)
1048         try:
1049             self.prompt()
1050             for command in file.readlines():
1051                 if command[:6] == 'shell.':
1052                     # Run shell methods silently.
1053                     self.run(command, prompt=False, verbose=False)
1054                 else:
1055                     self.run(command, prompt=False, verbose=True)
1056         finally:
1057             file.close()
1058
1059     def autoCompleteShow(self, command, offset = 0):
1060         """Display auto-completion popup list."""
1061         self.AutoCompSetAutoHide(self.autoCompleteAutoHide)
1062         self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive)
1063         list = self.interp.getAutoCompleteList(command,
1064                     includeMagic=self.autoCompleteIncludeMagic,
1065                     includeSingle=self.autoCompleteIncludeSingle,
1066                     includeDouble=self.autoCompleteIncludeDouble)
1067         if list:
1068             options = ' '.join(list)
1069             #offset = 0
1070             self.AutoCompShow(offset, options)
1071
1072     def autoCallTipShow(self, command, insertcalltip = True, forceCallTip = False):
1073         """Display argument spec and docstring in a popup window."""
1074         if self.CallTipActive():
1075             self.CallTipCancel()
1076         (name, argspec, tip) = self.interp.getCallTip(command)
1077         if tip:
1078             dispatcher.send(signal='Shell.calltip', sender=self, calltip=tip)
1079         if not self.autoCallTip and not forceCallTip:
1080             return
1081         if argspec and insertcalltip and self.callTipInsert:
1082             startpos = self.GetCurrentPos()
1083             self.write(argspec + ')')
1084             endpos = self.GetCurrentPos()
1085             self.SetSelection(endpos, startpos)
1086         if tip:
1087             curpos = self.GetCurrentPos()
1088             tippos = curpos - (len(name) + 1)
1089             fallback = curpos - self.GetColumn(curpos)
1090             # In case there isn't enough room, only go back to the
1091             # fallback.
1092             tippos = max(tippos, fallback)
1093             self.CallTipShow(tippos, tip)
1094
1095     def OnCallTipAutoCompleteManually (self, shiftDown):
1096         """AutoComplete and Calltips manually."""
1097         if self.AutoCompActive():
1098             self.AutoCompCancel()
1099         currpos = self.GetCurrentPos()
1100         stoppos = self.promptPosEnd
1101
1102         cpos = currpos
1103         #go back until '.' is found
1104         pointavailpos = -1
1105         while cpos >= stoppos:
1106             if self.GetCharAt(cpos) == ord ('.'):
1107                 pointavailpos = cpos
1108                 break
1109             cpos -= 1
1110
1111         #word from non whitespace until '.'
1112         if pointavailpos != -1:
1113             #look backward for first whitespace char
1114             textbehind = self.GetTextRange (pointavailpos + 1, currpos)
1115             pointavailpos += 1
1116
1117             if not shiftDown:
1118                 #call AutoComplete
1119                 stoppos = self.promptPosEnd
1120                 textbefore = self.GetTextRange(stoppos, pointavailpos)
1121                 self.autoCompleteShow(textbefore, len (textbehind))
1122             else:
1123                 #call CallTips
1124                 cpos = pointavailpos
1125                 begpos = -1
1126                 while cpos > stoppos:
1127                     if chr(self.GetCharAt(cpos)).isspace():
1128                         begpos = cpos
1129                         break
1130                     cpos -= 1
1131                 if begpos == -1:
1132                     begpos = cpos
1133                 ctips = self.GetTextRange (begpos, currpos)
1134                 ctindex = ctips.find ('(')
1135                 if ctindex != -1 and not self.CallTipActive():
1136                     #insert calltip, if current pos is '(', otherwise show it only
1137                     self.autoCallTipShow(ctips[:ctindex + 1],
1138                         self.GetCharAt(currpos - 1) == ord('(') and self.GetCurrentPos() == self.GetTextLength(),
1139                         True)
1140
1141
1142     def writeOut(self, text):
1143         """Replacement for stdout."""
1144         self.write(text)
1145
1146     def writeErr(self, text):
1147         """Replacement for stderr."""
1148         self.write(text)
1149
1150     def redirectStdin(self, redirect=True):
1151         """If redirect is true then sys.stdin will come from the shell."""
1152         if redirect:
1153             sys.stdin = self.reader
1154         else:
1155             sys.stdin = self.stdin
1156
1157     def redirectStdout(self, redirect=True):
1158         """If redirect is true then sys.stdout will go to the shell."""
1159         if redirect:
1160             sys.stdout = PseudoFileOut(self.writeOut)
1161         else:
1162             sys.stdout = self.stdout
1163
1164     def redirectStderr(self, redirect=True):
1165         """If redirect is true then sys.stderr will go to the shell."""
1166         if redirect:
1167             sys.stderr = PseudoFileErr(self.writeErr)
1168         else:
1169             sys.stderr = self.stderr
1170
1171     def CanCut(self):
1172         """Return true if text is selected and can be cut."""
1173         if self.GetSelectionStart() != self.GetSelectionEnd() \
1174                and self.GetSelectionStart() >= self.promptPosEnd \
1175                and self.GetSelectionEnd() >= self.promptPosEnd:
1176             return True
1177         else:
1178             return False
1179
1180     def CanPaste(self):
1181         """Return true if a paste should succeed."""
1182         if self.CanEdit() and editwindow.EditWindow.CanPaste(self):
1183             return True
1184         else:
1185             return False
1186
1187     def CanEdit(self):
1188         """Return true if editing should succeed."""
1189         if self.GetSelectionStart() != self.GetSelectionEnd():
1190             if self.GetSelectionStart() >= self.promptPosEnd \
1191                    and self.GetSelectionEnd() >= self.promptPosEnd:
1192                 return True
1193             else:
1194                 return False
1195         else:
1196             return self.GetCurrentPos() >= self.promptPosEnd
1197
1198     def Cut(self):
1199         """Remove selection and place it on the clipboard."""
1200         if self.CanCut() and self.CanCopy():
1201             if self.AutoCompActive():
1202                 self.AutoCompCancel()
1203             if self.CallTipActive():
1204                 self.CallTipCancel()
1205             self.Copy()
1206             self.ReplaceSelection('')
1207
1208     def Copy(self):
1209         """Copy selection and place it on the clipboard."""
1210         if self.CanCopy():
1211             ps1 = str(sys.ps1)
1212             ps2 = str(sys.ps2)
1213             command = self.GetSelectedText()
1214             command = command.replace(os.linesep + ps2, os.linesep)
1215             command = command.replace(os.linesep + ps1, os.linesep)
1216             command = self.lstripPrompt(text=command)
1217             data = wx.TextDataObject(command)
1218             self._clip(data)
1219
1220     def CopyWithPrompts(self):
1221         """Copy selection, including prompts, and place it on the clipboard."""
1222         if self.CanCopy():
1223             command = self.GetSelectedText()
1224             data = wx.TextDataObject(command)
1225             self._clip(data)
1226
1227     def CopyWithPromptsPrefixed(self):
1228         """Copy selection, including prompts prefixed with four
1229         spaces, and place it on the clipboard."""
1230         if self.CanCopy():
1231             command = self.GetSelectedText()
1232             spaces = ' ' * 4
1233             command = spaces + command.replace(os.linesep,
1234                                                os.linesep + spaces)
1235             data = wx.TextDataObject(command)
1236             self._clip(data)
1237
1238     def _clip(self, data):
1239         if wx.TheClipboard.Open():
1240             wx.TheClipboard.UsePrimarySelection(False)
1241             wx.TheClipboard.SetData(data)
1242             wx.TheClipboard.Flush()
1243             wx.TheClipboard.Close()
1244
1245     def Paste(self):
1246         """Replace selection with clipboard contents."""
1247         if self.CanPaste() and wx.TheClipboard.Open():
1248             ps2 = str(sys.ps2)
1249             if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
1250                 data = wx.TextDataObject()
1251                 if wx.TheClipboard.GetData(data):
1252                     self.ReplaceSelection('')
1253                     command = data.GetText()
1254                     command = command.rstrip()
1255                     command = self.fixLineEndings(command)
1256                     command = self.lstripPrompt(text=command)
1257                     command = command.replace(os.linesep + ps2, '\n')
1258                     command = command.replace(os.linesep, '\n')
1259                     command = command.replace('\n', os.linesep + ps2)
1260                     self.write(command)
1261             wx.TheClipboard.Close()
1262
1263
1264     def PasteAndRun(self):
1265         """Replace selection with clipboard contents, run commands."""
1266         text = ''
1267         if wx.TheClipboard.Open():
1268             if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)):
1269                 data = wx.TextDataObject()
1270                 if wx.TheClipboard.GetData(data):
1271                     text = data.GetText()
1272             wx.TheClipboard.Close()
1273         if text:
1274             self.Execute(text)
1275
1276
1277     def Execute(self, text):
1278         """Replace selection with text and run commands."""
1279         ps1 = str(sys.ps1)
1280         ps2 = str(sys.ps2)
1281         endpos = self.GetTextLength()
1282         self.SetCurrentPos(endpos)
1283         startpos = self.promptPosEnd
1284         self.SetSelection(startpos, endpos)
1285         self.ReplaceSelection('')
1286         text = text.lstrip()
1287         text = self.fixLineEndings(text)
1288         text = self.lstripPrompt(text)
1289         text = text.replace(os.linesep + ps1, '\n')
1290         text = text.replace(os.linesep + ps2, '\n')
1291         text = text.replace(os.linesep, '\n')
1292         lines = text.split('\n')
1293         commands = []
1294         command = ''
1295         for line in lines:
1296             if line.strip() == ps2.strip():
1297                 # If we are pasting from something like a
1298                 # web page that drops the trailing space
1299                 # from the ps2 prompt of a blank line.
1300                 line = ''
1301             lstrip = line.lstrip()
1302             if line.strip() != '' and lstrip == line and \
1303                     lstrip[:4] not in ['else','elif'] and \
1304                     lstrip[:6] != 'except':
1305                 # New command.
1306                 if command:
1307                     # Add the previous command to the list.
1308                     commands.append(command)
1309                 # Start a new command, which may be multiline.
1310                 command = line
1311             else:
1312                 # Multiline command. Add to the command.
1313                 command += '\n'
1314                 command += line
1315         commands.append(command)
1316         for command in commands:
1317             command = command.replace('\n', os.linesep + ps2)
1318             self.write(command)
1319             self.processLine()
1320
1321
1322     def wrap(self, wrap=True):
1323         """Sets whether text is word wrapped."""
1324         try:
1325             self.SetWrapMode(wrap)
1326         except AttributeError:
1327             return 'Wrapping is not available in this version.'
1328
1329     def zoom(self, points=0):
1330         """Set the zoom level.
1331
1332         This number of points is added to the size of all fonts.  It
1333         may be positive to magnify or negative to reduce."""
1334         self.SetZoom(points)
1335
1336
1337
1338     def LoadSettings(self, config):
1339         self.autoComplete              = config.ReadBool('Options/AutoComplete', True)
1340         self.autoCompleteIncludeMagic  = config.ReadBool('Options/AutoCompleteIncludeMagic', True)
1341         self.autoCompleteIncludeSingle = config.ReadBool('Options/AutoCompleteIncludeSingle', True)
1342         self.autoCompleteIncludeDouble = config.ReadBool('Options/AutoCompleteIncludeDouble', True)
1343
1344         self.autoCallTip = config.ReadBool('Options/AutoCallTip', True)
1345         self.callTipInsert = config.ReadBool('Options/CallTipInsert', True)
1346         self.SetWrapMode(config.ReadBool('View/WrapMode', True))
1347
1348         useAA = config.ReadBool('Options/UseAntiAliasing', self.GetUseAntiAliasing())
1349         self.SetUseAntiAliasing(useAA)
1350         self.lineNumbers = config.ReadBool('View/ShowLineNumbers', True)
1351         self.setDisplayLineNumbers (self.lineNumbers)
1352         zoom = config.ReadInt('View/Zoom/Shell', -99)
1353         if zoom != -99:
1354             self.SetZoom(zoom)
1355
1356
1357
1358     def SaveSettings(self, config):
1359         config.WriteBool('Options/AutoComplete', self.autoComplete)
1360         config.WriteBool('Options/AutoCompleteIncludeMagic', self.autoCompleteIncludeMagic)
1361         config.WriteBool('Options/AutoCompleteIncludeSingle', self.autoCompleteIncludeSingle)
1362         config.WriteBool('Options/AutoCompleteIncludeDouble', self.autoCompleteIncludeDouble)
1363         config.WriteBool('Options/AutoCallTip', self.autoCallTip)
1364         config.WriteBool('Options/CallTipInsert', self.callTipInsert)
1365         config.WriteBool('Options/UseAntiAliasing', self.GetUseAntiAliasing())
1366         config.WriteBool('View/WrapMode', self.GetWrapMode())
1367         config.WriteBool('View/ShowLineNumbers', self.lineNumbers)
1368         config.WriteInt('View/Zoom/Shell', self.GetZoom())
1369
1370
1371
1372 ## NOTE: The DnD of file names is disabled until I can figure out how
1373 ## best to still allow DnD of text.
1374
1375
1376 ## #seb : File drag and drop
1377 ## class FileDropTarget(wx.FileDropTarget):
1378 ##     def __init__(self, obj):
1379 ##         wx.FileDropTarget.__init__(self)
1380 ##         self.obj = obj
1381 ##     def OnDropFiles(self, x, y, filenames):
1382 ##         if len(filenames) == 1:
1383 ##             txt = 'r\"%s\"' % filenames[0]
1384 ##         else:
1385 ##             txt = '( '
1386 ##             for f in filenames:
1387 ##                 txt += 'r\"%s\" , ' % f
1388 ##             txt += ')'
1389 ##         self.obj.AppendText(txt)
1390 ##         pos = self.obj.GetCurrentPos()
1391 ##         self.obj.SetCurrentPos( pos )
1392 ##         self.obj.SetSelection( pos, pos )
1393
1394
1395
1396 ## class TextAndFileDropTarget(wx.DropTarget):
1397 ##     def __init__(self, shell):
1398 ##         wx.DropTarget.__init__(self)
1399 ##         self.shell = shell
1400 ##         self.compdo = wx.DataObjectComposite()
1401 ##         self.textdo = wx.TextDataObject()
1402 ##         self.filedo = wx.FileDataObject()
1403 ##         self.compdo.Add(self.textdo)
1404 ##         self.compdo.Add(self.filedo, True)
1405
1406 ##         self.SetDataObject(self.compdo)
1407
1408 ##     def OnDrop(self, x, y):
1409 ##         return True
1410
1411 ##     def OnData(self, x, y, result):
1412 ##         self.GetData()
1413 ##         if self.textdo.GetTextLength() > 1:
1414 ##             text = self.textdo.GetText()
1415 ##             # *** Do somethign with the dragged text here...
1416 ##             self.textdo.SetText('')
1417 ##         else:
1418 ##             filenames = str(self.filename.GetFilenames())
1419 ##             if len(filenames) == 1:
1420 ##                 txt = 'r\"%s\"' % filenames[0]
1421 ##             else:
1422 ##                 txt = '( '
1423 ##                 for f in filenames:
1424 ##                     txt += 'r\"%s\" , ' % f
1425 ##                 txt += ')'
1426 ##             self.shell.AppendText(txt)
1427 ##             pos = self.shell.GetCurrentPos()
1428 ##             self.shell.SetCurrentPos( pos )
1429 ##             self.shell.SetSelection( pos, pos )
1430
1431 ##         return result
1432