update docs/default config for qtconsole

IPython/config/profile/default/ipython_config.py

@@ -1,165 +1,183 b''
 # Get the config being loaded so we can set attributes on it
 c = get_config()
 
 #-----------------------------------------------------------------------------
 # Application-level options
 #-----------------------------------------------------------------------------
 
 # c.TerminalIPythonApp.display_banner = True
 
 # c.TerminalIPythonApp.classic = False
 
 # c.TerminalIPythonApp.nosep = True
 
 # If you still use multiple versions of IPytho on the same machine,
 # set this to True to suppress warnings about old configuration files
 # c.TerminalIPythonApp.ignore_old_config = False
 
 # Set this to determine the detail of what is logged at startup.
 # The default is 30 and possible values are 0,10,20,30,40,50.
 # c.Application.log_level = 20
 
 # This should be a list of importable Python modules that have an
 # load_ipython_extension(ip) method.  This method gets called when the extension
 # is loaded.  You can put your extensions anywhere they can be imported
 # but we add the extensions subdir of the ipython directory to sys.path
 # during extension loading, so you can put them there as well.
 # c.InteractiveShellApp.extensions = [
 #     'myextension'
 # ]
 
 # These lines are run in IPython in the user's namespace after extensions 
 # are loaded.  They can contain full IPython syntax with magics etc.
 # c.InteractiveShellApp.exec_lines = [
 #     'import numpy',
 #     'a = 10; b = 20',
 #     '1/0'
 # ]
 
 # These files are run in IPython in the user's namespace.  Files with a .py
 # extension need to be pure Python.  Files with a .ipy extension can have
 # custom IPython syntax (like magics, etc.).  
 # These files need to be in the cwd, the ipython_dir or be absolute paths.
 # c.InteractiveShellApp.exec_files = [
 #     'mycode.py',
 #     'fancy.ipy'
 # ]
 
 #-----------------------------------------------------------------------------
 # InteractiveShell options
 #-----------------------------------------------------------------------------
 
 # c.InteractiveShell.autocall = 1
 
 # c.TerminalInteractiveShell.autoedit_syntax = False
 
 # c.InteractiveShell.autoindent = True
 
 # c.InteractiveShell.automagic = False
 
 # c.TerminalInteractiveShell.banner1 = 'This if for overriding the default IPython banner'
  
 # c.TerminalInteractiveShell.banner2 = "This is for extra banner text"
 
 # c.InteractiveShell.cache_size = 1000
 
 # c.InteractiveShell.colors = 'LightBG'
 
 # c.InteractiveShell.color_info = True
 
 # c.TerminalInteractiveShell.confirm_exit = True
 
 # c.InteractiveShell.deep_reload = False
 
 # c.TerminalInteractiveShell.editor = 'nano'
 
 # c.InteractiveShell.logstart = True
 
 # c.InteractiveShell.logfile = u'ipython_log.py'
 
 # c.InteractiveShell.logappend = u'mylog.py'
 
 # c.InteractiveShell.object_info_string_level = 0
 
 # c.TerminalInteractiveShell.pager = 'less'
 
 # c.InteractiveShell.pdb = False
 
 # c.InteractiveShell.prompt_in1 = 'In [\#]: '
 # c.InteractiveShell.prompt_in2 = '   .\D.: '
 # c.InteractiveShell.prompt_out = 'Out[\#]: '
 # c.InteractiveShell.prompts_pad_left = True
 
 # c.InteractiveShell.quiet = False
 
 # c.InteractiveShell.history_length = 10000
 
 # Readline 
 # c.InteractiveShell.readline_use = True
 
 # be careful with meta-key ('\M-<x>') bindings, because
 # they conflict with 8-bit encodings (e.g. UTF8)
 
 # c.InteractiveShell.readline_parse_and_bind = [
 #     'tab: complete',
 #     '"\C-l": possible-completions',
 #     'set show-all-if-ambiguous on',
 #     '"\C-o": tab-insert',
 #     '"\C-r": reverse-search-history',
 #     '"\C-s": forward-search-history',
 #     '"\C-p": history-search-backward',
 #     '"\C-n": history-search-forward',
 #     '"\e[A": history-search-backward',
 #     '"\e[B": history-search-forward',
 #     '"\C-k": kill-line',
 #     '"\C-u": unix-line-discard',
 # ]
 # c.InteractiveShell.readline_remove_delims = '-/~'
 # c.InteractiveShell.readline_merge_completions = True
 # c.InteractiveShell.readline_omit__names = 0
 
 # c.TerminalInteractiveShell.screen_length = 0
 
 # c.InteractiveShell.separate_in = '\n'
 # c.InteractiveShell.separate_out = ''
 # c.InteractiveShell.separate_out2 = ''
 
 # c.TerminalInteractiveShell.term_title = False
 
 # c.InteractiveShell.wildcards_case_sensitive = True
 
 # c.InteractiveShell.xmode = 'Context'
 
 #-----------------------------------------------------------------------------
 # Formatter and display options
 #-----------------------------------------------------------------------------
 
 # c.PlainTextFormatter.pprint = True
 
 #-----------------------------------------------------------------------------
 # PrefilterManager options
 #-----------------------------------------------------------------------------
 
 # c.PrefilterManager.multi_line_specials = True
 
 #-----------------------------------------------------------------------------
 # AliasManager options
 #-----------------------------------------------------------------------------
 
 # Do this to disable all defaults
 # c.AliasManager.default_aliases = []
 
 # c.AliasManager.user_aliases = [
 #     ('foo', 'echo Hi')
 # ]
 
 #-----------------------------------------------------------------------------
 # HistoryManager options
 #-----------------------------------------------------------------------------
 
 # Enable logging output as well as input to the database.
 # c.HistoryManager.db_log_output = False
 
 # Only write to the database every n commands - this can save disk
 # access (and hence power) over the default of writing on every command.
 # c.HistoryManager.db_cache_size = 0
+
+#-----------------------------------------------------------------------------
+# QtConsole configuration
+#-----------------------------------------------------------------------------
+
+# set the preferred font and font size:
+# c.ConsoleWidget.font_family = "Anonymous Pro"
+# c.ConsoleWidget.font_size = 10
+
+# set the syntax-highlighting style:
+# c.IPythonWidget.syntax_style = 'perldoc'
+
+# Configure the prompts:
+# c.IPythonWidget.in_prompt = 'In [<span class="in-prompt-number">%i</span>]: '
+# c.IPythonWidget.out_prompt = 'Out[<span class="out-prompt-number">%i</span>]: '
+
+# set the editor - this must be a *GUI* editor, like notepad/gedit/TextMate
+# c.IPythonWidget.editor = 'mate -w'

IPython/frontend/qt/console/ipythonqt.py

@@ -1,372 +1,372 b''
 """ A minimal application using the Qt console-style IPython frontend.
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib imports
 import os
 import signal
 import sys
 
 # System library imports
 from IPython.external.qt import QtGui
 from pygments.styles import get_all_styles
 
 # Local imports
 from IPython.core.newapplication import ProfileDir, BaseIPythonApplication
 from IPython.frontend.qt.console.frontend_widget import FrontendWidget
 from IPython.frontend.qt.console.ipython_widget import IPythonWidget
 from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
 from IPython.frontend.qt.console import styles
 from IPython.frontend.qt.kernelmanager import QtKernelManager
 from IPython.utils.traitlets import (
     Dict, List, Unicode, Int, CaselessStrEnum, Bool, Any
 )
 from IPython.zmq.ipkernel import (
     flags as ipkernel_flags,
     aliases as ipkernel_aliases,
     IPKernelApp
 )
 from IPython.zmq.zmqshell import ZMQInteractiveShell
 
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class MainWindow(QtGui.QMainWindow):
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, app, frontend, existing=False, may_close=True):
         """ Create a MainWindow for the specified FrontendWidget.
         
         The app is passed as an argument to allow for different
         closing behavior depending on whether we are the Kernel's parent.
         
         If existing is True, then this Console does not own the Kernel.
         
         If may_close is True, then this Console is permitted to close the kernel
         """
         super(MainWindow, self).__init__()
         self._app = app
         self._frontend = frontend
         self._existing = existing
         if existing:
             self._may_close = may_close
         else:
             self._may_close = True
         self._frontend.exit_requested.connect(self.close)
         self.setCentralWidget(frontend)
     
     #---------------------------------------------------------------------------
     # QWidget interface
     #---------------------------------------------------------------------------
     
     def closeEvent(self, event):
         """ Close the window and the kernel (if necessary).
         
         This will prompt the user if they are finished with the kernel, and if
         so, closes the kernel cleanly. Alternatively, if the exit magic is used,
         it closes without prompt.
         """
         keepkernel = None #Use the prompt by default
         if hasattr(self._frontend,'_keep_kernel_on_exit'): #set by exit magic
             keepkernel = self._frontend._keep_kernel_on_exit
         
         kernel_manager = self._frontend.kernel_manager
         
         if keepkernel is None: #show prompt
             if kernel_manager and kernel_manager.channels_running:
                 title = self.window().windowTitle()
                 cancel = QtGui.QMessageBox.Cancel
                 okay = QtGui.QMessageBox.Ok
                 if self._may_close:
                     msg = "You are closing this Console window."
                     info = "Would you like to quit the Kernel and all attached Consoles as well?"
                     justthis = QtGui.QPushButton("&No, just this Console", self)
                     justthis.setShortcut('N')
                     closeall = QtGui.QPushButton("&Yes, quit everything", self)
                     closeall.setShortcut('Y')
                     box = QtGui.QMessageBox(QtGui.QMessageBox.Question,
                                             title, msg)
                     box.setInformativeText(info)
                     box.addButton(cancel)
                     box.addButton(justthis, QtGui.QMessageBox.NoRole)
                     box.addButton(closeall, QtGui.QMessageBox.YesRole)
                     box.setDefaultButton(closeall)
                     box.setEscapeButton(cancel)
                     reply = box.exec_()
                     if reply == 1: # close All
                         kernel_manager.shutdown_kernel()
                         #kernel_manager.stop_channels()
                         event.accept()
                     elif reply == 0: # close Console
                         if not self._existing:
                             # Have kernel: don't quit, just close the window
                             self._app.setQuitOnLastWindowClosed(False)
                             self.deleteLater()
                         event.accept()
                     else:
                         event.ignore()
                 else:
                     reply = QtGui.QMessageBox.question(self, title,
                         "Are you sure you want to close this Console?"+
                         "\nThe Kernel and other Consoles will remain active.",
                         okay|cancel,
                         defaultButton=okay
                         )
                     if reply == okay:
                         event.accept()
                     else:
                         event.ignore()
         elif keepkernel: #close console but leave kernel running (no prompt)
             if kernel_manager and kernel_manager.channels_running:
                 if not self._existing:
                     # I have the kernel: don't quit, just close the window
                     self._app.setQuitOnLastWindowClosed(False)
                 event.accept()
         else: #close console and kernel (no prompt)
             if kernel_manager and kernel_manager.channels_running:
                 kernel_manager.shutdown_kernel()
                 event.accept()
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(ipkernel_flags)
 
 flags.update({
     'existing' : ({'IPythonQtConsoleApp' : {'existing' : True}},
             "Connect to an existing kernel."),
     'pure' : ({'IPythonQtConsoleApp' : {'pure' : True}},
             "Use a pure Python kernel instead of an IPython kernel."),
     'plain' : ({'ConsoleWidget' : {'kind' : 'plain'}},
             "Disable rich text support."),
     'gui-completion' : ({'FrontendWidget' : {'gui_completion' : True}},
             "use a GUI widget for tab completion"),
 })
 
 qt_flags = ['existing', 'pure', 'plain', 'gui-completion']
 
 aliases = dict(ipkernel_aliases)
 
 aliases.update(dict(
     hb = 'IPythonQtConsoleApp.hb_port',
     shell = 'IPythonQtConsoleApp.shell_port',
     iopub = 'IPythonQtConsoleApp.iopub_port',
     stdin = 'IPythonQtConsoleApp.stdin_port',
     ip = 'IPythonQtConsoleApp.ip',
 
     plain = 'IPythonQtConsoleApp.plain',
     pure = 'IPythonQtConsoleApp.pure',
     gui_completion = 'FrontendWidget.gui_completion',
     style = 'IPythonWidget.syntax_style',
     stylesheet = 'IPythonQtConsoleApp.stylesheet',
     colors = 'ZMQInteractiveShell.colors',
 
     editor = 'IPythonWidget.editor',
     pi = 'IPythonWidget.in_prompt',
     po = 'IPythonWidget.out_prompt',
     si = 'IPythonWidget.input_sep',
     so = 'IPythonWidget.output_sep',
     so2 = 'IPythonWidget.output_sep2',
 ))
 
 #-----------------------------------------------------------------------------
 # IPythonQtConsole
 #-----------------------------------------------------------------------------
 
 class IPythonQtConsoleApp(BaseIPythonApplication):
     name = 'ipython-qtconsole'
     default_config_file_name='ipython_config.py'
     classes = [IPKernelApp, IPythonWidget, ZMQInteractiveShell, ProfileDir]
     flags = Dict(flags)
     aliases = Dict(aliases)
 
     kernel_argv = List(Unicode)
 
     # connection info:
     ip = Unicode(LOCALHOST, config=True,
         help="""Set the kernel\'s IP address [default localhost].
         If the IP address is something other than localhost, then
         Consoles on other machines will be able to connect
         to the Kernel, so be careful!"""
     )
     hb_port = Int(0, config=True,
         help="set the heartbeat port [default: random]")
     shell_port = Int(0, config=True,
         help="set the shell (XREP) port [default: random]")
     iopub_port = Int(0, config=True,
         help="set the iopub (PUB) port [default: random]")
     stdin_port = Int(0, config=True,
         help="set the stdin (XREQ) port [default: random]")
 
     existing = Bool(False, config=True,
         help="Whether to connect to an already running Kernel.")
 
     stylesheet = Unicode('', config=True,
         help="path to a custom CSS stylesheet")
 
     pure = Bool(False, config=True,
         help="Use a pure Python kernel instead of an IPython kernel.")
     plain = Bool(False, config=True,
-        help="Use a pure Python kernel instead of an IPython kernel.")
+        help="Use a plaintext widget instead of rich text (plain can't print/save).")
 
     def _pure_changed(self, name, old, new):
         kind = 'plain' if self.plain else 'rich'
         self.config.ConsoleWidget.kind = kind
         if self.pure:
             self.widget_factory = FrontendWidget
         elif self.plain:
             self.widget_factory = IPythonWidget
         else:
             self.widget_factory = RichIPythonWidget
 
     _plain_changed = _pure_changed
 
     # the factory for creating a widget
     widget_factory = Any(RichIPythonWidget)
 
     def parse_command_line(self, argv=None):
         super(IPythonQtConsoleApp, self).parse_command_line(argv)
         if argv is None:
             argv = sys.argv[1:]
 
         self.kernel_argv = list(argv) # copy
 
         # scrub frontend-specific flags
         for a in argv:
             if a.startswith('--') and a[2:] in qt_flags:
                 self.kernel_argv.remove(a)
 
     def init_kernel_manager(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # Create a KernelManager and start a kernel.
         self.kernel_manager = QtKernelManager(
                                 shell_address=(self.ip, self.shell_port),
                                 sub_address=(self.ip, self.iopub_port),
                                 stdin_address=(self.ip, self.stdin_port),
                                 hb_address=(self.ip, self.hb_port)
         )
         # start the kernel
         if not self.existing:
             kwargs = dict(ip=self.ip, ipython=not self.pure)
             kwargs['extra_arguments'] = self.kernel_argv
             self.kernel_manager.start_kernel(**kwargs)
         self.kernel_manager.start_channels()
 
 
     def init_qt_elements(self):
         # Create the widget.
         self.app = QtGui.QApplication([])
         local_kernel = (not self.existing) or self.ip in LOCAL_IPS
         self.widget = self.widget_factory(config=self.config,
                                         local_kernel=local_kernel)
         self.widget.kernel_manager = self.kernel_manager
         self.window = MainWindow(self.app, self.widget, self.existing,
                                 may_close=local_kernel)
         self.window.setWindowTitle('Python' if self.pure else 'IPython')
 
     def init_colors(self):
         """Configure the coloring of the widget"""
         # Note: This will be dramatically simplified when colors
         # are removed from the backend.
 
         if self.pure:
             # only IPythonWidget supports styling
             return
 
         # parse the colors arg down to current known labels
         try:
             colors = self.config.ZMQInteractiveShell.colors
         except AttributeError:
             colors = None
         try:
             style = self.config.IPythonWidget.colors
         except AttributeError:
             style = None
 
         # find the value for colors:
         if colors:
             colors=colors.lower()
             if colors in ('lightbg', 'light'):
                 colors='lightbg'
             elif colors in ('dark', 'linux'):
                 colors='linux'
             else:
                 colors='nocolor'
         elif style:
             if style=='bw':
                 colors='nocolor'
             elif styles.dark_style(style):
                 colors='linux'
             else:
                 colors='lightbg'
         else:
             colors=None
 
         # Configure the style.
         widget = self.widget
         if style:
             widget.style_sheet = styles.sheet_from_template(style, colors)
             widget.syntax_style = style
             widget._syntax_style_changed()
             widget._style_sheet_changed()
         elif colors:
             # use a default style
             widget.set_default_style(colors=colors)
         else:
             # this is redundant for now, but allows the widget's
             # defaults to change
             widget.set_default_style()
 
         if self.stylesheet:
             # we got an expicit stylesheet
             if os.path.isfile(self.stylesheet):
                 with open(self.stylesheet) as f:
                     sheet = f.read()
                 widget.style_sheet = sheet
                 widget._style_sheet_changed()
             else:
                 raise IOError("Stylesheet %r not found."%self.stylesheet)
 
     def initialize(self, argv=None):
         super(IPythonQtConsoleApp, self).initialize(argv)
         self.init_kernel_manager()
         self.init_qt_elements()
         self.init_colors()
 
     def start(self):
 
         # draw the window
         self.window.show()
 
         # Start the application main loop.
         self.app.exec_()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def main():
     app = IPythonQtConsoleApp()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     main()

docs/source/interactive/qtconsole.txt

@@ -1,219 +1,222 b''
 .. _qtconsole:
 
 =========================
 IPython as a QtGUI widget
 =========================
 
 We now have a version of IPython, using the new two-process :ref:`ZeroMQ Kernel <ipythonzmq>`,
 running in a PyQt_ GUI.
 
 Overview
 ========
 
 The Qt frontend has hand-coded emacs-style bindings for text navigation. This is not yet
 configurable.
 
 .. seealso:: 
 
     :ref:`The original IPython-Qt project description. <ipython_qt>`
     
 ``%loadpy``
 ===========
 
 The ``%loadpy`` magic has been added, just for the GUI frontend. It takes any python
 script (must end in '.py'), and pastes its contents as your next input, so you can edit it
 before executing. The script may be on your machine, but you can also specify a url, and
 it will download the script from the web. This is particularly useful for playing with
 examples from documentation, such as matplotlib.
 
 .. sourcecode:: ipython
 
     In [6]: %loadpy 
     http://matplotlib.sourceforge.net/plot_directive/mpl_examples/mplot3d/contour3d_demo.py
 
     In [7]: from mpl_toolkits.mplot3d import axes3d
        ...: import matplotlib.pyplot as plt
        ...: 
        ...: fig = plt.figure()
        ...: ax = fig.add_subplot(111, projection='3d')
        ...: X, Y, Z = axes3d.get_test_data(0.05)
        ...: cset = ax.contour(X, Y, Z)
        ...: ax.clabel(cset, fontsize=9, inline=1)
        ...: 
        ...: plt.show()
 
 Pylab
 =====
 
 One of the most exciting features of the new console is embedded matplotlib figures. You
 can use any standard matplotlib GUI backend (Except native MacOSX) to draw the figures,
 and since there is now a two-process model, there is no longer a conflict between user
 input and the drawing eventloop.
 
 .. image:: figs/besselj.png
     :width: 519px
 
 .. pastefig:
 
 :func:`pastefig`
 ****************
 
 An additional function, :func:`pastefig`, will be added to the global namespace if you
-specify the ``--pylab`` argument. This takes the active figures in matplotlib, and embeds
+specify the ``pylab`` argument. This takes the active figures in matplotlib, and embeds
 them in your document. This is especially useful for saving_ your work.
 
 .. _inline:
 
-``--pylab inline``
+``pylab=inline``
 ******************
 
 If you want to have all of your figures embedded in your session, instead of calling
-:func:`pastefig`, you can specify ``--pylab inline``, and each time you make a plot, it
+:func:`pastefig`, you can specify ``pylab=inline``, and each time you make a plot, it
 will show up in your document, as if you had called :func:`pastefig`.
 
 
 .. _saving:
 
 Saving and Printing
 ===================
 
 IPythonQt has the ability to save your current session, as either HTML or XHTML. If you
 have been using :func:`pastefig` or inline_ pylab, your figures will be PNG
 in HTML, or inlined as SVG in XHTML. PNG images have the option to be either in an
 external folder, as in many browsers' "Webpage, Complete" option, or inlined as well, for
 a larger, but more portable file.
 
 The widget also exposes the ability to print directly, via the default print shortcut or
 context menu.
 
 
 .. Note:: 
 
-    Saving is only available to richtext Qt widgets, so make sure you start ipqt with the
-    ``--rich`` flag, or with ``--pylab``, which always uses a richtext widget.
+    Saving is only available to richtext Qt widgets, which are used by default, but
+    if you pass the ``--plain`` flag, saving will not be available to you.
 
 
 See these examples of :download:`png/html<figs/jn.html>` and :download:`svg/xhtml
 <figs/jn.xhtml>` output. Note that syntax highlighting does not survive export. This is a known
 issue, and is being investigated.
 
 Colors and Highlighting
 =======================
 
 Terminal IPython has always had some coloring, but never syntax highlighting. There are a
-few simple color choices, specified by the ``--colors`` flag or ``%colors`` magic:
+few simple color choices, specified by the ``colors`` flag or ``%colors`` magic:
 
 * LightBG for light backgrounds
 * Linux for dark backgrounds
 * NoColor for a simple colorless terminal
 
-The Qt widget has full support for the ``--colors`` flag, but adds new, more intuitive
-aliases for the colors (the old names still work): dark=Linux, light=LightBG, bw=NoColor.
+The Qt widget has full support for the ``colors`` flag used in the terminal shell.
 
 The Qt widget, however, has full syntax highlighting as you type, handled by the
-`pygments`_ library. The ``--style`` argument exposes access to any style by name that can
-be found by pygments, and there are several already installed. The ``--colors`` argument,
+`pygments`_ library. The ``style`` argument exposes access to any style by name that can
+be found by pygments, and there are several already installed. The ``colors`` argument,
 if unspecified, will be guessed based on the chosen style. Similarly, there are default
-styles associated with each ``--colors`` option.
+styles associated with each ``colors`` option.
 
 
-Screenshot of ``ipython-qtconsole --colors dark``, which uses the 'monokai' theme by
+Screenshot of ``ipython-qtconsole colors=linux``, which uses the 'monokai' theme by
 default:
 
 .. image:: figs/colors_dark.png
     :width: 627px
     
 .. Note::
 
     Calling ``ipython-qtconsole -h`` will show all the style names that pygments can find
     on your system.
 
 You can also pass the filename of a custom CSS stylesheet, if you want to do your own
-coloring, via the ``--stylesheet`` argument.  The default LightBG stylesheet:
+coloring, via the ``stylesheet`` argument.  The default LightBG stylesheet:
 
 .. sourcecode:: css
 
     QPlainTextEdit, QTextEdit { background-color: white;
             color: black ;
             selection-background-color: #ccc}
     .error { color: red; }
     .in-prompt { color: navy; }
     .in-prompt-number { font-weight: bold; }
     .out-prompt { color: darkred; }
     .out-prompt-number { font-weight: bold; }
 
+Fonts
+=====
+
+The QtConsole has configurable via the ConsoleWidget. To change these, set the ``font_family``
+or ``font_size`` traits of the ConsoleWidget. For instance, to use 9pt Anonymous Pro::
+
+    $> ipython-qtconsole ConsoleWidget.font_family="Anonymous Pro" ConsoleWidget.font_size=9
+
 Process Management
 ==================
 
 With the two-process ZMQ model, the frontend does not block input during execution. This
 means that actions can be taken by the frontend while the Kernel is executing, or even
 after it crashes. The most basic such command is via 'Ctrl-.', which restarts the kernel.
 This can be done in the middle of a blocking execution. The frontend can also know, via a
 heartbeat mechanism, that the kernel has died. This means that the frontend can safely
 restart the kernel.
 
 Multiple Consoles
 *****************
 
 Since the Kernel listens on the network, multiple frontends can connect to it.  These
 do not have to all be qt frontends - any IPython frontend can connect and run code.
 When you start ipython-qtconsole, there will be an output line, like::
 
     To connect another client to this kernel, use:
-    -e --xreq 62109 --sub 62110 --rep 62111 --hb 62112
+    --external shell=62109 iopub=62110 stdin=62111 hb=62112
 
 Other frontends can connect to your kernel, and share in the execution. This is great for
 collaboration. The `-e` flag is for 'external'. Starting other consoles with that flag
 will not try to start their own, but rather connect to yours. Ultimately, you will not
 have to specify each port individually, but for now this copy-paste method is best.
 
 By default (for security reasons), the kernel only listens on localhost, so you can only
 connect multiple frontends to the kernel from your local machine. You can specify to
-listen on an external interface by specifying the ``--ip`` argument::
+listen on an external interface by specifying the ``ip`` argument::
 
-    $> ipython-qtconsole --ip 192.168.1.123
+    $> ipython-qtconsole ip=192.168.1.123
 
 If you specify the ip as 0.0.0.0, that refers to all interfaces, so any computer that can
 see yours can connect to the kernel.
 
 .. warning::
 
     Since the ZMQ code currently has no security, listening on an external-facing IP
     is dangerous.  You are giving any computer that can see you on the network the ability
     to issue arbitrary shell commands as you on your machine. Be very careful with this.
 
 
 Stopping Kernels and Consoles
 *****************************
 
 Since there can be many consoles per kernel, the shutdown mechanism and dialog are
 probably more complicated than you are used to. Since you don't always want to shutdown a
 kernel when you close a window, you are given the option to just close the console window
 or also close the Kernel and *all other windows*. Note that this only refers to all other
 *local* windows, as remote Consoles are not allowed to shutdown the kernel, and shutdowns
 do not close Remote consoles (to allow for saving, etc.).
 
 Rules:
 
     * Restarting the kernel automatically clears all *local* Consoles, and prompts remote
       Consoles about the reset.
     * Shutdown closes all *local* Consoles, and notifies remotes that
       the Kernel has been shutdown.
     * Remote Consoles may not restart or shutdown the kernel.
 
 
 Regressions
 ===========
 
 There are some features, where the qt console lags behind the Terminal frontend. We hope
 to have these fixed by 0.11 release.
 
-    * Configuration: The Qt frontend and ZMQ kernel are not yet hooked up to the IPython
-      configuration system
-    * History Persistence: Currently the history of a GUI session does
-      not persist between sessions.
     * !cmd input: Due to our use of pexpect, we cannot pass input to subprocesses launched
       using the '!' escape. (this will not be fixed).
 
 .. [PyQt] PyQt4 http://www.riverbankcomputing.co.uk/software/pyqt/download
 .. [pygments] Pygments http://pygments.org/