python-qt4-4.10.4+dfsg.orig/ 0000755 0000000 0000000 00000000000 12310607732 014204 5 ustar root root python-qt4-4.10.4+dfsg.orig/elementtree/ 0000755 0000000 0000000 00000000000 12310607732 016515 5 ustar root root python-qt4-4.10.4+dfsg.orig/elementtree/__init__.py 0000644 0000000 0000000 00000002723 12310607732 020632 0 ustar root root # $Id: __init__.py 1821 2004-06-03 16:57:49Z fredrik $
# elementtree package
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2004 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------
python-qt4-4.10.4+dfsg.orig/elementtree/ElementPath.py 0000644 0000000 0000000 00000013502 12310607732 021276 0 ustar root root #
# ElementTree
# $Id: ElementPath.py 1858 2004-06-17 21:31:41Z Fredrik $
#
# limited xpath support for element trees
#
# history:
# 2003-05-23 fl created
# 2003-05-28 fl added support for // etc
# 2003-08-27 fl fixed parsing of periods in element names
#
# Copyright (c) 2003-2004 by Fredrik Lundh. All rights reserved.
#
# fredrik@pythonware.com
# http://www.pythonware.com
#
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2004 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------
##
# Implementation module for XPath support. There's usually no reason
# to import this module directly; the ElementTree does this for
# you, if needed.
##
import re
xpath_tokenizer = re.compile(
"(::|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/:\[\]\(\)@=\s]+)|\s+"
).findall
class xpath_descendant_or_self:
pass
##
# Wrapper for a compiled XPath.
class Path:
##
# Create an Path instance from an XPath expression.
def __init__(self, path):
tokens = xpath_tokenizer(path)
# the current version supports 'path/path'-style expressions only
self.path = []
self.tag = None
if tokens and tokens[0][0] == "/":
raise SyntaxError("cannot use absolute path on element")
while tokens:
op, tag = tokens.pop(0)
if tag or op == "*":
self.path.append(tag or op)
elif op == ".":
pass
elif op == "/":
self.path.append(xpath_descendant_or_self())
continue
else:
raise SyntaxError("unsupported path syntax (%s)" % op)
if tokens:
op, tag = tokens.pop(0)
if op != "/":
raise SyntaxError(
"expected path separator (%s)" % (op or tag)
)
if self.path and isinstance(self.path[-1], xpath_descendant_or_self):
raise SyntaxError("path cannot end with //")
if len(self.path) == 1 and isinstance(self.path[0], type("")):
self.tag = self.path[0]
##
# Find first matching object.
def find(self, element):
tag = self.tag
if tag is None:
nodeset = self.findall(element)
if not nodeset:
return None
return nodeset[0]
for elem in element:
if elem.tag == tag:
return elem
return None
##
# Find text for first matching object.
def findtext(self, element, default=None):
tag = self.tag
if tag is None:
nodeset = self.findall(element)
if not nodeset:
return default
return nodeset[0].text or ""
for elem in element:
if elem.tag == tag:
return elem.text or ""
return default
##
# Find all matching objects.
def findall(self, element):
nodeset = [element]
index = 0
while 1:
try:
path = self.path[index]
index = index + 1
except IndexError:
return nodeset
set = []
if isinstance(path, xpath_descendant_or_self):
try:
tag = self.path[index]
if not isinstance(tag, type("")):
tag = None
else:
index = index + 1
except IndexError:
tag = None # invalid path
for node in nodeset:
new = list(node.getiterator(tag))
if new and new[0] is node:
set.extend(new[1:])
else:
set.extend(new)
else:
for node in nodeset:
for node in node:
if path == "*" or node.tag == path:
set.append(node)
if not set:
return []
nodeset = set
_cache = {}
##
# (Internal) Compile path.
def _compile(path):
p = _cache.get(path)
if p is not None:
return p
p = Path(path)
if len(_cache) >= 100:
_cache.clear()
_cache[path] = p
return p
##
# Find first matching object.
def find(element, path):
return _compile(path).find(element)
##
# Find text for first matching object.
def findtext(element, path, default=None):
return _compile(path).findtext(element, default)
##
# Find all matching objects.
def findall(element, path):
return _compile(path).findall(element)
python-qt4-4.10.4+dfsg.orig/elementtree/ElementTree.py 0000644 0000000 0000000 00000117666 12310607732 021321 0 ustar root root #
# ElementTree
# $Id: ElementTree.py 2326 2005-03-17 07:45:21Z fredrik $
#
# light-weight XML support for Python 1.5.2 and later.
#
# history:
# 2001-10-20 fl created (from various sources)
# 2001-11-01 fl return root from parse method
# 2002-02-16 fl sort attributes in lexical order
# 2002-04-06 fl TreeBuilder refactoring, added PythonDoc markup
# 2002-05-01 fl finished TreeBuilder refactoring
# 2002-07-14 fl added basic namespace support to ElementTree.write
# 2002-07-25 fl added QName attribute support
# 2002-10-20 fl fixed encoding in write
# 2002-11-24 fl changed default encoding to ascii; fixed attribute encoding
# 2002-11-27 fl accept file objects or file names for parse/write
# 2002-12-04 fl moved XMLTreeBuilder back to this module
# 2003-01-11 fl fixed entity encoding glitch for us-ascii
# 2003-02-13 fl added XML literal factory
# 2003-02-21 fl added ProcessingInstruction/PI factory
# 2003-05-11 fl added tostring/fromstring helpers
# 2003-05-26 fl added ElementPath support
# 2003-07-05 fl added makeelement factory method
# 2003-07-28 fl added more well-known namespace prefixes
# 2003-08-15 fl fixed typo in ElementTree.findtext (Thomas Dartsch)
# 2003-09-04 fl fall back on emulator if ElementPath is not installed
# 2003-10-31 fl markup updates
# 2003-11-15 fl fixed nested namespace bug
# 2004-03-28 fl added XMLID helper
# 2004-06-02 fl added default support to findtext
# 2004-06-08 fl fixed encoding of non-ascii element/attribute names
# 2004-08-23 fl take advantage of post-2.1 expat features
# 2005-02-01 fl added iterparse implementation
# 2005-03-02 fl fixed iterparse support for pre-2.2 versions
#
# Copyright (c) 1999-2005 by Fredrik Lundh. All rights reserved.
#
# fredrik@pythonware.com
# http://www.pythonware.com
#
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2005 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------
__all__ = [
# public symbols
"Comment",
"dump",
"Element", "ElementTree",
"fromstring",
"iselement", "iterparse",
"parse",
"PI", "ProcessingInstruction",
"QName",
"SubElement",
"tostring",
"TreeBuilder",
"VERSION", "XML",
"XMLTreeBuilder",
]
##
# The Element type is a flexible container object, designed to
# store hierarchical data structures in memory. The type can be
# described as a cross between a list and a dictionary.
#
# Each element has a number of properties associated with it:
#
#
a tag. This is a string identifying what kind of data
# this element represents (the element type, in other words).
#
a number of attributes, stored in a Python dictionary.
#
a text string.
#
an optional tail string.
#
a number of child elements, stored in a Python sequence
#
#
# To create an element instance, use the {@link #Element} or {@link
# #SubElement} factory functions.
#
# The {@link #ElementTree} class can be used to wrap an element
# structure, and convert it from and to XML.
##
import string, sys, re
class _SimpleElementPath:
# emulate pre-1.2 find/findtext/findall behaviour
def find(self, element, tag):
for elem in element:
if elem.tag == tag:
return elem
return None
def findtext(self, element, tag, default=None):
for elem in element:
if elem.tag == tag:
return elem.text or ""
return default
def findall(self, element, tag):
if tag[:3] == ".//":
return element.getiterator(tag[3:])
result = []
for elem in element:
if elem.tag == tag:
result.append(elem)
return result
try:
import ElementPath
except ImportError:
# FIXME: issue warning in this case?
ElementPath = _SimpleElementPath()
# TODO: add support for custom namespace resolvers/default namespaces
# TODO: add improved support for incremental parsing
VERSION = "1.2.6"
##
# Internal element class. This class defines the Element interface,
# and provides a reference implementation of this interface.
#
# You should not create instances of this class directly. Use the
# appropriate factory functions instead, such as {@link #Element}
# and {@link #SubElement}.
#
# @see Element
# @see SubElement
# @see Comment
# @see ProcessingInstruction
class _ElementInterface:
# text...tail
##
# (Attribute) Element tag.
tag = None
##
# (Attribute) Element attribute dictionary. Where possible, use
# {@link #_ElementInterface.get},
# {@link #_ElementInterface.set},
# {@link #_ElementInterface.keys}, and
# {@link #_ElementInterface.items} to access
# element attributes.
attrib = None
##
# (Attribute) Text before first subelement. This is either a
# string or the value None, if there was no text.
text = None
##
# (Attribute) Text after this element's end tag, but before the
# next sibling element's start tag. This is either a string or
# the value None, if there was no text.
tail = None # text after end tag, if any
def __init__(self, tag, attrib):
self.tag = tag
self.attrib = attrib
self._children = []
def __repr__(self):
return "" % (self.tag, id(self))
##
# Creates a new element object of the same type as this element.
#
# @param tag Element tag.
# @param attrib Element attributes, given as a dictionary.
# @return A new element instance.
def makeelement(self, tag, attrib):
return Element(tag, attrib)
##
# Returns the number of subelements.
#
# @return The number of subelements.
def __len__(self):
return len(self._children)
##
# Returns the given subelement.
#
# @param index What subelement to return.
# @return The given subelement.
# @exception IndexError If the given element does not exist.
def __getitem__(self, index):
return self._children[index]
##
# Replaces the given subelement.
#
# @param index What subelement to replace.
# @param element The new element value.
# @exception IndexError If the given element does not exist.
# @exception AssertionError If element is not a valid object.
def __setitem__(self, index, element):
assert iselement(element)
self._children[index] = element
##
# Deletes the given subelement.
#
# @param index What subelement to delete.
# @exception IndexError If the given element does not exist.
def __delitem__(self, index):
del self._children[index]
##
# Returns a list containing subelements in the given range.
#
# @param start The first subelement to return.
# @param stop The first subelement that shouldn't be returned.
# @return A sequence object containing subelements.
def __getslice__(self, start, stop):
return self._children[start:stop]
##
# Replaces a number of subelements with elements from a sequence.
#
# @param start The first subelement to replace.
# @param stop The first subelement that shouldn't be replaced.
# @param elements A sequence object with zero or more elements.
# @exception AssertionError If a sequence member is not a valid object.
def __setslice__(self, start, stop, elements):
for element in elements:
assert iselement(element)
self._children[start:stop] = list(elements)
##
# Deletes a number of subelements.
#
# @param start The first subelement to delete.
# @param stop The first subelement to leave in there.
def __delslice__(self, start, stop):
del self._children[start:stop]
##
# Adds a subelement to the end of this element.
#
# @param element The element to add.
# @exception AssertionError If a sequence member is not a valid object.
def append(self, element):
assert iselement(element)
self._children.append(element)
##
# Inserts a subelement at the given position in this element.
#
# @param index Where to insert the new subelement.
# @exception AssertionError If the element is not a valid object.
def insert(self, index, element):
assert iselement(element)
self._children.insert(index, element)
##
# Removes a matching subelement. Unlike the find methods,
# this method compares elements based on identity, not on tag
# value or contents.
#
# @param element What element to remove.
# @exception ValueError If a matching element could not be found.
# @exception AssertionError If the element is not a valid object.
def remove(self, element):
assert iselement(element)
self._children.remove(element)
##
# Returns all subelements. The elements are returned in document
# order.
#
# @return A list of subelements.
# @defreturn list of Element instances
def getchildren(self):
return self._children
##
# Finds the first matching subelement, by tag name or path.
#
# @param path What element to look for.
# @return The first matching element, or None if no element was found.
# @defreturn Element or None
def find(self, path):
return ElementPath.find(self, path)
##
# Finds text for the first matching subelement, by tag name or path.
#
# @param path What element to look for.
# @param default What to return if the element was not found.
# @return The text content of the first matching element, or the
# default value no element was found. Note that if the element
# has is found, but has no text content, this method returns an
# empty string.
# @defreturn string
def findtext(self, path, default=None):
return ElementPath.findtext(self, path, default)
##
# Finds all matching subelements, by tag name or path.
#
# @param path What element to look for.
# @return A list or iterator containing all matching elements,
# in document order.
# @defreturn list of Element instances
def findall(self, path):
return ElementPath.findall(self, path)
##
# Resets an element. This function removes all subelements, clears
# all attributes, and sets the text and tail attributes to None.
def clear(self):
self.attrib.clear()
self._children = []
self.text = self.tail = None
##
# Gets an element attribute.
#
# @param key What attribute to look for.
# @param default What to return if the attribute was not found.
# @return The attribute value, or the default value, if the
# attribute was not found.
# @defreturn string or None
def get(self, key, default=None):
return self.attrib.get(key, default)
##
# Sets an element attribute.
#
# @param key What attribute to set.
# @param value The attribute value.
def set(self, key, value):
self.attrib[key] = value
##
# Gets a list of attribute names. The names are returned in an
# arbitrary order (just like for an ordinary Python dictionary).
#
# @return A list of element attribute names.
# @defreturn list of strings
def keys(self):
return self.attrib.keys()
##
# Gets element attributes, as a sequence. The attributes are
# returned in an arbitrary order.
#
# @return A list of (name, value) tuples for all attributes.
# @defreturn list of (string, string) tuples
def items(self):
return self.attrib.items()
##
# Creates a tree iterator. The iterator loops over this element
# and all subelements, in document order, and returns all elements
# with a matching tag.
#
# If the tree structure is modified during iteration, the result
# is undefined.
#
# @param tag What tags to look for (default is to return all elements).
# @return A list or iterator containing all the matching elements.
# @defreturn list or iterator
def getiterator(self, tag=None):
nodes = []
if tag == "*":
tag = None
if tag is None or self.tag == tag:
nodes.append(self)
for node in self._children:
nodes.extend(node.getiterator(tag))
return nodes
# compatibility
_Element = _ElementInterface
##
# Element factory. This function returns an object implementing the
# standard Element interface. The exact class or type of that object
# is implementation dependent, but it will always be compatible with
# the {@link #_ElementInterface} class in this module.
#
# The element name, attribute names, and attribute values can be
# either 8-bit ASCII strings or Unicode strings.
#
# @param tag The element name.
# @param attrib An optional dictionary, containing element attributes.
# @param **extra Additional attributes, given as keyword arguments.
# @return An element instance.
# @defreturn Element
def Element(tag, attrib={}, **extra):
attrib = attrib.copy()
attrib.update(extra)
return _ElementInterface(tag, attrib)
##
# Subelement factory. This function creates an element instance, and
# appends it to an existing element.
#
# The element name, attribute names, and attribute values can be
# either 8-bit ASCII strings or Unicode strings.
#
# @param parent The parent element.
# @param tag The subelement name.
# @param attrib An optional dictionary, containing element attributes.
# @param **extra Additional attributes, given as keyword arguments.
# @return An element instance.
# @defreturn Element
def SubElement(parent, tag, attrib={}, **extra):
attrib = attrib.copy()
attrib.update(extra)
element = parent.makeelement(tag, attrib)
parent.append(element)
return element
##
# Comment element factory. This factory function creates a special
# element that will be serialized as an XML comment.
#
# The comment string can be either an 8-bit ASCII string or a Unicode
# string.
#
# @param text A string containing the comment string.
# @return An element instance, representing a comment.
# @defreturn Element
def Comment(text=None):
element = Element(Comment)
element.text = text
return element
##
# PI element factory. This factory function creates a special element
# that will be serialized as an XML processing instruction.
#
# @param target A string containing the PI target.
# @param text A string containing the PI contents, if any.
# @return An element instance, representing a PI.
# @defreturn Element
def ProcessingInstruction(target, text=None):
element = Element(ProcessingInstruction)
element.text = target
if text:
element.text = element.text + " " + text
return element
PI = ProcessingInstruction
##
# QName wrapper. This can be used to wrap a QName attribute value, in
# order to get proper namespace handling on output.
#
# @param text A string containing the QName value, in the form {uri}local,
# or, if the tag argument is given, the URI part of a QName.
# @param tag Optional tag. If given, the first argument is interpreted as
# an URI, and this argument is interpreted as a local name.
# @return An opaque object, representing the QName.
class QName:
def __init__(self, text_or_uri, tag=None):
if tag:
text_or_uri = "{%s}%s" % (text_or_uri, tag)
self.text = text_or_uri
def __str__(self):
return self.text
def __hash__(self):
return hash(self.text)
def __cmp__(self, other):
if isinstance(other, QName):
return cmp(self.text, other.text)
return cmp(self.text, other)
##
# ElementTree wrapper class. This class represents an entire element
# hierarchy, and adds some extra support for serialization to and from
# standard XML.
#
# @param element Optional root element.
# @keyparam file Optional file handle or name. If given, the
# tree is initialized with the contents of this XML file.
class ElementTree:
def __init__(self, element=None, file=None):
assert element is None or iselement(element)
self._root = element # first node
if file:
self.parse(file)
##
# Gets the root element for this tree.
#
# @return An element instance.
# @defreturn Element
def getroot(self):
return self._root
##
# Replaces the root element for this tree. This discards the
# current contents of the tree, and replaces it with the given
# element. Use with care.
#
# @param element An element instance.
def _setroot(self, element):
assert iselement(element)
self._root = element
##
# Loads an external XML document into this element tree.
#
# @param source A file name or file object.
# @param parser An optional parser instance. If not given, the
# standard {@link XMLTreeBuilder} parser is used.
# @return The document root element.
# @defreturn Element
def parse(self, source, parser=None):
if not hasattr(source, "read"):
source = open(source, "rb")
if not parser:
parser = XMLTreeBuilder()
while 1:
data = source.read(32768)
if not data:
break
parser.feed(data)
self._root = parser.close()
return self._root
##
# Creates a tree iterator for the root element. The iterator loops
# over all elements in this tree, in document order.
#
# @param tag What tags to look for (default is to return all elements)
# @return An iterator.
# @defreturn iterator
def getiterator(self, tag=None):
assert self._root is not None
return self._root.getiterator(tag)
##
# Finds the first toplevel element with given tag.
# Same as getroot().find(path).
#
# @param path What element to look for.
# @return The first matching element, or None if no element was found.
# @defreturn Element or None
def find(self, path):
assert self._root is not None
if path[:1] == "/":
path = "." + path
return self._root.find(path)
##
# Finds the element text for the first toplevel element with given
# tag. Same as getroot().findtext(path).
#
# @param path What toplevel element to look for.
# @param default What to return if the element was not found.
# @return The text content of the first matching element, or the
# default value no element was found. Note that if the element
# has is found, but has no text content, this method returns an
# empty string.
# @defreturn string
def findtext(self, path, default=None):
assert self._root is not None
if path[:1] == "/":
path = "." + path
return self._root.findtext(path, default)
##
# Finds all toplevel elements with the given tag.
# Same as getroot().findall(path).
#
# @param path What element to look for.
# @return A list or iterator containing all matching elements,
# in document order.
# @defreturn list of Element instances
def findall(self, path):
assert self._root is not None
if path[:1] == "/":
path = "." + path
return self._root.findall(path)
##
# Writes the element tree to a file, as XML.
#
# @param file A file name, or a file object opened for writing.
# @param encoding Optional output encoding (default is US-ASCII).
def write(self, file, encoding="us-ascii"):
assert self._root is not None
if not hasattr(file, "write"):
file = open(file, "wb")
if not encoding:
encoding = "us-ascii"
elif encoding != "utf-8" and encoding != "us-ascii":
file.write("\n" % encoding)
self._write(file, self._root, encoding, {})
def _write(self, file, node, encoding, namespaces):
# write XML to file
tag = node.tag
if tag is Comment:
file.write("" % _escape_cdata(node.text, encoding))
elif tag is ProcessingInstruction:
file.write("" % _escape_cdata(node.text, encoding))
else:
items = node.items()
xmlns_items = [] # new namespaces in this scope
try:
if isinstance(tag, QName) or tag[:1] == "{":
tag, xmlns = fixtag(tag, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(tag)
file.write("<" + _encode(tag, encoding))
if items or xmlns_items:
items.sort() # lexical order
for k, v in items:
try:
if isinstance(k, QName) or k[:1] == "{":
k, xmlns = fixtag(k, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(k)
try:
if isinstance(v, QName):
v, xmlns = fixtag(v, namespaces)
if xmlns: xmlns_items.append(xmlns)
except TypeError:
_raise_serialization_error(v)
file.write(" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
for k, v in xmlns_items:
file.write(" %s=\"%s\"" % (_encode(k, encoding),
_escape_attrib(v, encoding)))
if node.text or len(node):
file.write(">")
if node.text:
file.write(_escape_cdata(node.text, encoding))
for n in node:
self._write(file, n, encoding, namespaces)
file.write("")
else:
file.write(" />")
for k, v in xmlns_items:
del namespaces[v]
if node.tail:
file.write(_escape_cdata(node.tail, encoding))
# --------------------------------------------------------------------
# helpers
##
# Checks if an object appears to be a valid element object.
#
# @param An element instance.
# @return A true value if this is an element object.
# @defreturn flag
def iselement(element):
# FIXME: not sure about this; might be a better idea to look
# for tag/attrib/text attributes
return isinstance(element, _ElementInterface) or hasattr(element, "tag")
##
# Writes an element tree or element structure to sys.stdout. This
# function should be used for debugging only.
#
# The exact output format is implementation dependent. In this
# version, it's written as an ordinary XML file.
#
# @param elem An element tree or an individual element.
def dump(elem):
# debugging
if not isinstance(elem, ElementTree):
elem = ElementTree(elem)
elem.write(sys.stdout)
tail = elem.getroot().tail
if not tail or tail[-1] != "\n":
sys.stdout.write("\n")
def _encode(s, encoding):
try:
return s.encode(encoding)
except AttributeError:
return s # 1.5.2: assume the string uses the right encoding
if sys.version[:3] == "1.5":
_escape = re.compile(r"[&<>\"\x80-\xff]+") # 1.5.2
else:
_escape = re.compile(eval(r'u"[&<>\"\u0080-\uffff]+"'))
_escape_map = {
"&": "&",
"<": "<",
">": ">",
'"': """,
}
_namespace_map = {
# "well-known" namespace prefixes
"http://www.w3.org/XML/1998/namespace": "xml",
"http://www.w3.org/1999/xhtml": "html",
"http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
"http://schemas.xmlsoap.org/wsdl/": "wsdl",
}
def _raise_serialization_error(text):
raise TypeError(
"cannot serialize %r (type %s)" % (text, type(text).__name__)
)
def _encode_entity(text, pattern=_escape):
# map reserved and non-ascii characters to numerical entities
def escape_entities(m, map=_escape_map):
out = []
append = out.append
for char in m.group():
text = map.get(char)
if text is None:
text = "&#%d;" % ord(char)
append(text)
return string.join(out, "")
try:
return _encode(pattern.sub(escape_entities, text), "ascii")
except TypeError:
_raise_serialization_error(text)
#
# the following functions assume an ascii-compatible encoding
# (or "utf-16")
def _escape_cdata(text, encoding=None, replace=string.replace):
# escape character data
try:
if encoding:
try:
text = _encode(text, encoding)
except UnicodeError:
return _encode_entity(text)
text = replace(text, "&", "&")
text = replace(text, "<", "<")
text = replace(text, ">", ">")
return text
except (TypeError, AttributeError):
_raise_serialization_error(text)
def _escape_attrib(text, encoding=None, replace=string.replace):
# escape attribute value
try:
if encoding:
try:
text = _encode(text, encoding)
except UnicodeError:
return _encode_entity(text)
text = replace(text, "&", "&")
text = replace(text, "'", "'") # FIXME: overkill
text = replace(text, "\"", """)
text = replace(text, "<", "<")
text = replace(text, ">", ">")
return text
except (TypeError, AttributeError):
_raise_serialization_error(text)
def fixtag(tag, namespaces):
# given a decorated tag (of the form {uri}tag), return prefixed
# tag and namespace declaration, if any
if isinstance(tag, QName):
tag = tag.text
namespace_uri, tag = string.split(tag[1:], "}", 1)
prefix = namespaces.get(namespace_uri)
if prefix is None:
prefix = _namespace_map.get(namespace_uri)
if prefix is None:
prefix = "ns%d" % len(namespaces)
namespaces[namespace_uri] = prefix
if prefix == "xml":
xmlns = None
else:
xmlns = ("xmlns:%s" % prefix, namespace_uri)
else:
xmlns = None
return "%s:%s" % (prefix, tag), xmlns
##
# Parses an XML document into an element tree.
#
# @param source A filename or file object containing XML data.
# @param parser An optional parser instance. If not given, the
# standard {@link XMLTreeBuilder} parser is used.
# @return An ElementTree instance
def parse(source, parser=None):
tree = ElementTree()
tree.parse(source, parser)
return tree
##
# Parses an XML document into an element tree incrementally, and reports
# what's going on to the user.
#
# @param source A filename or file object containing XML data.
# @param events A list of events to report back. If omitted, only "end"
# events are reported.
# @return A (event, elem) iterator.
class iterparse:
def __init__(self, source, events=None):
if not hasattr(source, "read"):
source = open(source, "rb")
self._file = source
self._events = []
self._index = 0
self.root = self._root = None
self._parser = XMLTreeBuilder()
# wire up the parser for event reporting
parser = self._parser._parser
append = self._events.append
if events is None:
events = ["end"]
for event in events:
if event == "start":
try:
parser.ordered_attributes = 1
parser.specified_attributes = 1
def handler(tag, attrib_in, event=event, append=append,
start=self._parser._start_list):
append((event, start(tag, attrib_in)))
parser.StartElementHandler = handler
except AttributeError:
def handler(tag, attrib_in, event=event, append=append,
start=self._parser._start):
append((event, start(tag, attrib_in)))
parser.StartElementHandler = handler
elif event == "end":
def handler(tag, event=event, append=append,
end=self._parser._end):
append((event, end(tag)))
parser.EndElementHandler = handler
elif event == "start-ns":
def handler(prefix, uri, event=event, append=append):
try:
uri = _encode(uri, "ascii")
except UnicodeError:
pass
append((event, (prefix or "", uri)))
parser.StartNamespaceDeclHandler = handler
elif event == "end-ns":
def handler(prefix, event=event, append=append):
append((event, None))
parser.EndNamespaceDeclHandler = handler
def next(self):
while 1:
try:
item = self._events[self._index]
except IndexError:
if self._parser is None:
self.root = self._root
try:
raise StopIteration
except NameError:
raise IndexError
# load event buffer
del self._events[:]
self._index = 0
data = self._file.read(16384)
if data:
self._parser.feed(data)
else:
self._root = self._parser.close()
self._parser = None
else:
self._index = self._index + 1
return item
try:
iter
def __iter__(self):
return self
except NameError:
def __getitem__(self, index):
return self.next()
##
# Parses an XML document from a string constant. This function can
# be used to embed "XML literals" in Python code.
#
# @param source A string containing XML data.
# @return An Element instance.
# @defreturn Element
def XML(text):
parser = XMLTreeBuilder()
parser.feed(text)
return parser.close()
##
# Parses an XML document from a string constant, and also returns
# a dictionary which maps from element id:s to elements.
#
# @param source A string containing XML data.
# @return A tuple containing an Element instance and a dictionary.
# @defreturn (Element, dictionary)
def XMLID(text):
parser = XMLTreeBuilder()
parser.feed(text)
tree = parser.close()
ids = {}
for elem in tree.getiterator():
id = elem.get("id")
if id:
ids[id] = elem
return tree, ids
##
# Parses an XML document from a string constant. Same as {@link #XML}.
#
# @def fromstring(text)
# @param source A string containing XML data.
# @return An Element instance.
# @defreturn Element
fromstring = XML
##
# Generates a string representation of an XML element, including all
# subelements.
#
# @param element An Element instance.
# @return An encoded string containing the XML data.
# @defreturn string
def tostring(element, encoding=None):
class dummy:
pass
data = []
file = dummy()
file.write = data.append
ElementTree(element).write(file, encoding)
return string.join(data, "")
##
# Generic element structure builder. This builder converts a sequence
# of {@link #TreeBuilder.start}, {@link #TreeBuilder.data}, and {@link
# #TreeBuilder.end} method calls to a well-formed element structure.
#
# You can use this class to build an element structure using a custom XML
# parser, or a parser for some other XML-like format.
#
# @param element_factory Optional element factory. This factory
# is called to create new Element instances, as necessary.
class TreeBuilder:
def __init__(self, element_factory=None):
self._data = [] # data collector
self._elem = [] # element stack
self._last = None # last element
self._tail = None # true if we're after an end tag
if element_factory is None:
element_factory = _ElementInterface
self._factory = element_factory
##
# Flushes the parser buffers, and returns the toplevel documen
# element.
#
# @return An Element instance.
# @defreturn Element
def close(self):
assert len(self._elem) == 0, "missing end tags"
assert self._last != None, "missing toplevel element"
return self._last
def _flush(self):
if self._data:
if self._last is not None:
text = string.join(self._data, "")
if self._tail:
assert self._last.tail is None, "internal error (tail)"
self._last.tail = text
else:
assert self._last.text is None, "internal error (text)"
self._last.text = text
self._data = []
##
# Adds text to the current element.
#
# @param data A string. This should be either an 8-bit string
# containing ASCII text, or a Unicode string.
def data(self, data):
self._data.append(data)
##
# Opens a new element.
#
# @param tag The element name.
# @param attrib A dictionary containing element attributes.
# @return The opened element.
# @defreturn Element
def start(self, tag, attrs):
self._flush()
self._last = elem = self._factory(tag, attrs)
if self._elem:
self._elem[-1].append(elem)
self._elem.append(elem)
self._tail = 0
return elem
##
# Closes the current element.
#
# @param tag The element name.
# @return The closed element.
# @defreturn Element
def end(self, tag):
self._flush()
self._last = self._elem.pop()
assert self._last.tag == tag,\
"end tag mismatch (expected %s, got %s)" % (
self._last.tag, tag)
self._tail = 1
return self._last
##
# Element structure builder for XML source data, based on the
# expat parser.
#
# @keyparam target Target object. If omitted, the builder uses an
# instance of the standard {@link #TreeBuilder} class.
# @keyparam html Predefine HTML entities. This flag is not supported
# by the current implementation.
# @see #ElementTree
# @see #TreeBuilder
class XMLTreeBuilder:
def __init__(self, html=0, target=None):
try:
from xml.parsers import expat
except ImportError:
raise ImportError(
"No module named expat; use SimpleXMLTreeBuilder instead"
)
self._parser = parser = expat.ParserCreate(None, "}")
if target is None:
target = TreeBuilder()
self._target = target
self._names = {} # name memo cache
# callbacks
parser.DefaultHandlerExpand = self._default
parser.StartElementHandler = self._start
parser.EndElementHandler = self._end
parser.CharacterDataHandler = self._data
# let expat do the buffering, if supported
try:
self._parser.buffer_text = 1
except AttributeError:
pass
# use new-style attribute handling, if supported
try:
self._parser.ordered_attributes = 1
self._parser.specified_attributes = 1
parser.StartElementHandler = self._start_list
except AttributeError:
pass
encoding = None
if not parser.returns_unicode:
encoding = "utf-8"
# target.xml(encoding, None)
self._doctype = None
self.entity = {}
def _fixtext(self, text):
# convert text string to ascii, if possible
try:
return _encode(text, "ascii")
except UnicodeError:
return text
def _fixname(self, key):
# expand qname, and convert name string to ascii, if possible
try:
name = self._names[key]
except KeyError:
name = key
if "}" in name:
name = "{" + name
self._names[key] = name = self._fixtext(name)
return name
def _start(self, tag, attrib_in):
fixname = self._fixname
tag = fixname(tag)
attrib = {}
for key, value in attrib_in.items():
attrib[fixname(key)] = self._fixtext(value)
return self._target.start(tag, attrib)
def _start_list(self, tag, attrib_in):
fixname = self._fixname
tag = fixname(tag)
attrib = {}
if attrib_in:
for i in range(0, len(attrib_in), 2):
attrib[fixname(attrib_in[i])] = self._fixtext(attrib_in[i+1])
return self._target.start(tag, attrib)
def _data(self, text):
return self._target.data(self._fixtext(text))
def _end(self, tag):
return self._target.end(self._fixname(tag))
def _default(self, text):
prefix = text[:1]
if prefix == "&":
# deal with undefined entities
try:
self._target.data(self.entity[text[1:-1]])
except KeyError:
from xml.parsers import expat
raise expat.error(
"undefined entity %s: line %d, column %d" %
(text, self._parser.ErrorLineNumber,
self._parser.ErrorColumnNumber)
)
elif prefix == "<" and text[:9] == "":
self._doctype = None
return
text = string.strip(text)
if not text:
return
self._doctype.append(text)
n = len(self._doctype)
if n > 2:
type = self._doctype[1]
if type == "PUBLIC" and n == 4:
name, type, pubid, system = self._doctype
elif type == "SYSTEM" and n == 3:
name, type, system = self._doctype
pubid = None
else:
return
if pubid:
pubid = pubid[1:-1]
self.doctype(name, pubid, system[1:-1])
self._doctype = None
##
# Handles a doctype declaration.
#
# @param name Doctype name.
# @param pubid Public identifier.
# @param system System identifier.
def doctype(self, name, pubid, system):
pass
##
# Feeds data to the parser.
#
# @param data Encoded data.
def feed(self, data):
self._parser.Parse(data, 0)
##
# Finishes feeding data to the parser.
#
# @return An element structure.
# @defreturn Element
def close(self):
self._parser.Parse("", 1) # end of data
tree = self._target.close()
del self._target, self._parser # get rid of circular references
return tree
python-qt4-4.10.4+dfsg.orig/contrib/ 0000755 0000000 0000000 00000000000 12310607704 015643 5 ustar root root python-qt4-4.10.4+dfsg.orig/contrib/sandbox/ 0000755 0000000 0000000 00000000000 12310607704 017301 5 ustar root root python-qt4-4.10.4+dfsg.orig/contrib/sandbox/sandbox.pyw 0000755 0000000 0000000 00000573262 12310607704 021522 0 ustar root root #!/usr/bin/env python
from __future__ import division
from __future__ import with_statement
import base64
import os
import re
import sys
from PyQt4.QtCore import (PYQT_VERSION_STR, QByteArray, QDir, QEvent,
QFile, QFileInfo, QIODevice, QPoint, QProcess, QRegExp,
QSettings, QString, QT_VERSION_STR, QTextStream, QThread,
QTimer, QUrl, QVariant, Qt, SIGNAL)
from PyQt4.QtGui import (QAction, QApplication, QButtonGroup, QCheckBox,
QColor, QColorDialog, QComboBox, QCursor, QDesktopServices,
QDialog, QDialogButtonBox, QFileDialog, QFont, QFontComboBox,
QFontMetrics, QGridLayout, QHBoxLayout, QIcon, QInputDialog,
QKeySequence, QLabel, QLineEdit, QListWidget, QMainWindow,
QMessageBox, QPixmap, QPushButton, QRadioButton,
QRegExpValidator, QShortcut, QSpinBox, QSplitter,
QSyntaxHighlighter, QTabWidget, QTextBrowser, QTextCharFormat,
QTextCursor, QTextDocument, QTextEdit, QToolTip, QVBoxLayout,
QWidget)
__version__ = "0.9.9"
__license__ = """\
Copyright (c) 2007-9 Mark Summerfield. All rights reserved.
This program is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the Free
Software Foundation, version 2 of the License, or version 3 of the
License or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
without any warranty; without even the implied warranty of
merchantability or fitness for a particular purpose.
See the GNU General Public
License for more details."""
MAC = "qt_mac_set_native_menubar" in dir()
KEYWORDS = ["and", "as", "assert", "break", "class", "continue", "def",
"del", "elif", "else", "except", "exec", "finally", "for", "from",
"global", "if", "import", "in", "is", "lambda", "not", "or",
"pass", "print", "raise", "return", "try", "while", "with",
"yield"]
BUILTINS = ["abs", "all", "any", "basestring", "bool", "callable", "chr",
"classmethod", "cmp", "compile", "complex", "delattr", "dict",
"dir", "divmod", "enumerate", "eval", "execfile", "exit", "file",
"filter", "float", "frozenset", "getattr", "globals", "hasattr",
"hex", "id", "int", "isinstance", "issubclass", "iter", "len",
"list", "locals", "long", "map", "max", "min", "object", "oct",
"open", "ord", "pow", "property", "range", "reduce", "repr",
"reversed", "round", "set", "setattr", "slice", "sorted",
"staticmethod", "str", "sum", "super", "tuple", "type", "unichr",
"unicode", "vars", "xrange", "zip"]
CONSTANTS = ["False", "True", "None", "NotImplemented", "Ellipsis"]
MODULES = dict([(key, False) for key in ("array", "bisect", "bsddb",
"bz2", "codecs", "collections", "copy", "datetime", "decimal",
"functools", "getopt", "gzip", "heapq", "itertools", "math",
"optparse", "os", "os.path", "pickle", "cPickle", "random",
"re", "string", "StringIO", "cStringIO", "struct", "subprocess",
"sys", "tarfile", "time", "unicodedata", "weakref", "zipfile",
"QAxContainer", "QtAssistant", "QtCore", "QtDesigner", "QtGui",
"QtNetwork", "QtOpenGL", "QtSql", "QtSvg", "QtTest", "QtXml")])
TIMEOUT = 5000
ICONS = {}
PIXMAPS = {}
Config = {}
CAT = {} # Completions And Tooltips
MIN_COMPLETION_LEN = 3
MAX_TOOLTIP_LEN = 1000
FROM_IMPORT_RE = re.compile(r"from\s+([\w.]+)\s+import\s+(.*)")
WORDS = set()
WORD_RE = re.compile(r"[\W+.]")
MIN_WORD_LEN = 3
MAX_WORD_LEN = 64
CATABLE_LINE_RE = QRegExp(r"\b(?:import|def|class)\s+")
CLASS_OR_DEF_RE = re.compile(r"(class|def) ([^\W(:]+)[:(]")
def trimQString(qstr, trimText):
while qstr.startsWith(trimText):
qstr = qstr.mid(len(trimText))
while qstr.endsWith(trimText):
qstr.chop(len(trimText))
return qstr
def loadConfig():
def setDefaultString(name, default):
value = settings.value(name).toString()
if value.isEmpty():
value = default
Config[name] = value
settings = QSettings()
for name in ("window", "shell"):
Config["%swidth" % name] = settings.value("%swidth" % name,
QVariant(QApplication.desktop()
.availableGeometry().width() / 2)).toInt()[0]
Config["%sheight" % name] = settings.value("%sheight" % name,
QVariant(QApplication.desktop()
.availableGeometry().height() / 2)).toInt()[0]
Config["%sy" % name] = settings.value("%sy" % name,
QVariant(0)).toInt()[0]
Config["toolbars"] = settings.value("toolbars").toByteArray()
Config["splitter"] = settings.value("splitter").toByteArray()
Config["shellx"] = settings.value("shellx",
QVariant(0)).toInt()[0]
Config["windowx"] = settings.value("windowx",
QVariant(QApplication.desktop()
.availableGeometry().width() / 2)).toInt()[0]
Config["remembergeometry"] = settings.value("remembergeometry",
QVariant(True)).toBool()
Config["startwithshell"] = settings.value("startwithshell",
QVariant(True)).toBool()
Config["showwindowinfo"] = settings.value("showwindowinfo",
QVariant(True)).toBool()
setDefaultString("shellstartup", """\
from __future__ import division
import codecs
import sys
sys.stdin = codecs.getreader("UTF8")(sys.stdin)
sys.stdout = codecs.getwriter("UTF8")(sys.stdout)""")
setDefaultString("newfile", """\
#!/usr/bin/env python
from __future__ import division
import sys
""")
Config["backupsuffix"] = settings.value("backupsuffix",
QVariant(".bak")).toString()
setDefaultString("beforeinput", "#>>>")
setDefaultString("beforeoutput", "#---")
Config["cwd"] = settings.value("cwd", QVariant(".")).toString()
Config["tooltipsize"] = settings.value("tooltipsize",
QVariant(150)).toInt()[0]
Config["maxlinestoscan"] = settings.value("maxlinestoscan",
QVariant(5000)).toInt()[0]
Config["pythondocpath"] = settings.value("pythondocpath",
QVariant("http://docs.python.org")).toString()
Config["autohidefinddialog"] = settings.value("autohidefinddialog",
QVariant(True)).toBool()
Config["findcasesensitive"] = settings.value("findcasesensitive",
QVariant(False)).toBool()
Config["findwholewords"] = settings.value("findwholewords",
QVariant(False)).toBool()
Config["tabwidth"] = settings.value("tabwidth",
QVariant(4)).toInt()[0]
Config["fontfamily"] = settings.value("fontfamily",
QVariant("Bitstream Vera Sans Mono")).toString()
Config["fontsize"] = settings.value("fontsize",
QVariant(10)).toInt()[0]
for name, color, bold, italic in (
("normal", "#000000", False, False),
("keyword", "#000080", True, False),
("builtin", "#0000A0", False, False),
("constant", "#0000C0", False, False),
("decorator", "#0000E0", False, False),
("comment", "#007F00", False, True),
("string", "#808000", False, False),
("number", "#924900", False, False),
("error", "#FF0000", False, False),
("pyqt", "#50621A", False, False)):
Config["%sfontcolor" % name] = settings.value(
"%sfontcolor" % name, QVariant(color)).toString()
Config["%sfontbold" % name] = settings.value(
"%sfontbold" % name, QVariant(bold)).toBool()
Config["%sfontitalic" % name] = settings.value(
"%sfontitalic" % name, QVariant(italic)).toBool()
def saveConfig():
settings = QSettings()
for key, value in Config.items():
settings.setValue(key, QVariant(value))
def checkForCAT(line):
# We can't use CAT to keep track of which modules we have processed.
# This is because if the user does "import os", one of the names we
# will get is "os.path", which then goes into CAT; so if later the
# user did "import os.path", the name "os.path" will already be in
# CAT (from the "import os") and wouldn't be looked for. So we keep
# a separate dictionary of modules that we've done in MODULES.
line = line.strip()
if line.startswith("import "):
line = line[len("import "):]
for mname in [mname.strip() for mname in line.split(",")]:
if not MODULES.get(mname, False):
# We have not done this one
_updateCAT(mname)
else:
match = FROM_IMPORT_RE.match(line)
if match:
if match.group(1) == "__future__" or not match.group(2):
return
for name in [x for x in
match.group(2).replace(",", " ").split()]:
mname = "%s.%s" % (match.group(1), name)
if not MODULES.get(mname, False):
# We have not done this one
_updateCAT(mname)
i = mname.rfind(".")
while i > -1:
mname = mname[:i]
if not MODULES.get(mname, False):
# We have not done this one
_updateCAT(mname)
i = mname.rfind(".")
else:
for word in WORD_RE.split(line):
if (not word or
len(word) < MIN_WORD_LEN or
len(word) > MAX_WORD_LEN or
word in CAT or word in WORDS):
continue
WORDS.add(word)
def _updateCAT(mname):
try:
MODULES[mname] = True
CAT.setdefault(mname, {})
WORDS.discard(mname)
module = __import__(mname)
components = []
if "." in mname:
for component in mname.split(".")[1:]:
module = getattr(module, component)
components.append(component)
for aname in dir(module):
if aname.startswith("_"):
continue
fullname = "%s.%s" % (mname, aname)
CAT.setdefault(fullname, "")
WORDS.discard(fullname)
CAT.setdefault(aname, "")
WORDS.discard(aname)
for component in components:
CAT.setdefault("%s.%s" % (component, aname), "")
WORDS.discard("%s.%s" % (component, aname))
# PyQt4 classes don't have docstrings
if not mname.startswith(("Qt", "PyQt4")):
try:
tip = eval("sys.modules['%s'].%s.__doc__" % (
mname, aname))
if tip is not None:
tip = (tip[:MAX_TOOLTIP_LEN].strip()
.replace("\n\n", "
"))
CAT[fullname] = tip
if CAT[aname] == "": # First one (i.e., builtin)
CAT[aname] = tip # wins
for component in components: # Last one wins
CAT["%s.%s" % (component, aname)] = tip
except:
pass
try:
for bname in eval("dir(sys.modules['%s'].%s)" % (
mname, aname)):
if bname.startswith("_"):
continue
cname = "%s.%s" % (fullname, bname)
CAT.setdefault(cname, "")
WORDS.discard(cname)
# PyQt4 classes don't have docstrings
if not mname.startswith(("Qt", "PyQt4")):
tip = None
try:
tip = eval(
"sys.modules['%s'].%s.%s.__doc__" % (
mname, aname, bname))
except:
pass
if tip is None:
try:
tip = eval(
"sys.modules['%s'].%s.__doc__" % (
mname, aname))
except:
pass
if tip is not None:
tip = (tip[:MAX_TOOLTIP_LEN].strip()
.replace("\n\n", "
"))
CAT[cname] = tip
except:
pass
except:
pass
class HelpForm(QDialog):
def __init__(self, parent=None):
super(HelpForm, self).__init__(parent)
self.setAttribute(Qt.WA_GroupLeader)
self.setAttribute(Qt.WA_DeleteOnClose)
browser = QTextBrowser()
browser.setOpenExternalLinks(True)
browser.setHtml( # TODO Improve
u"""
This online help provides a brief introduction to Sandbox's completion
and Find and Replace dialog, followed by some useful online links, and
finishing with a summary of its key bindings. It is well worth pulling
down the menus and seeing what options are available since they are
almost all self-explanatory.
Word completion is achieved using Ctrl+P or by pressing Tab.
A tooltip will appear when you enter (, if one is available.
Completion and tooltips are available for Python's built-ins, and also for
any module that gets imported, whether as part of the start-up (see the
File\N{RIGHTWARDS ARROW}Configure dialog's At Startup tab), or that are
imported in the Shell, or that are mentioned in import statements in any
files that are opened. (This makes loading a file with lots of imports, or
writing an import command in the shell, take a tiny bit longer than it
would otherwise do.) The completion also tries to include your own
identifiers. Also, classes, methods, and functions are added to the Goto
menu. The number of lines that are scanned for completions, tooltips,
and for the Goto menu is specified in the
File\N{RIGHTWARDS ARROW}Configure dialog's General tab's Max Lines to Scan
spinbox.
When you click Find or Replace in the Find and Replace
dialog, the action will take place and the dialog will close. You can
then do further finds and replaces using Edit\N{RIGHTWARDS ARROW}Find
Again or Edit\N{RIGHTWARDS ARROW}Replace Again (or using
the keyboard shortcuts shown in the menu). If you prefer to have the
Find and Replace dialog visible and use its buttons instead, go to the
File\N{RIGHTWARDS ARROW}Configure dialog's General tab, and uncheck
Automatically Hide the Find and Replace dialog.
Ctrl+\N{UPWARDS ARROW} In the shell, copy the previous command
from the command history to the input window. In editor windows, move to
the previous line in the line history.
\N{DOWNWARDS ARROW} Move the cursor down one line
Ctrl+\N{DOWNWARDS ARROW} In the shell, copy the next command
from the command history to the input window. In editor windows, move to
the next line in the line history.
\N{LEFTWARDS ARROW} Move the cursor left one character
Ctrl+\N{LEFTWARDS ARROW} Move the cursor left one word
\N{RIGHTWARDS ARROW} Move the cursor right one character
Ctrl+\N{RIGHTWARDS ARROW} Move the cursor right one word
Ctrl+] Indent the selected text (or the current line) by %d
spaces
Ctrl+[ Unindent the selected text (or the current line) by %d
spaces
Ctrl+A Select all the text
Backspace Delete the character to the left of the cursor
Ctrl+C Copy the selected text to the clipboard
Delete Delete the character to the right of the cursor
End Move the cursor to the end of the line
Ctrl+End Move the cursor to the end of the file
Ctrl+Enter Execute the input window's code, or execute the
current file. If executing a file and it is a console application, the
output is shown in a separate window which can be closed by pressing
Esc. (This is the same as pressing F5.)
Ctrl+F Pop up the Find and Replace dialog
F3 Find the next occurrence of the find text; if there is none,
pop up the Find and Replace dialog.
Shift+F3 Find the next occurrence of word at the cursor; the
search is case sensitive and whole words only.
F5 Execute the input window's code, or execute the current
file. If executing a file and it is a console application, the
output is shown in a separate window which can be closed by pressing
Esc. (This is the same as pressing Ctrl+Enter.)
Ctrl+H Launch Python's documentation in a web browser
Home Move the cursor to the beginning of the line
Ctrl+Home Move the cursor to the beginning of the file
Ctrl+K Delete to the end of the line
Ctrl+L Pop up the Goto Line dialog
Ctrl+M Go to the matching ([{< or >}]). The matcher looks
at the character preceding the cursor, and if it is a match character the
cursor moves so that the matched character precedes the cursor. If no
suitable character is preceding the cursor, but there is a suitable
character following the cursor, the cursor will advance one character (so
that the match character now precedes it), and works as just described.
(In other words the matching is after\N{LEFT RIGHT ARROW}after.)
Ctrl+N Open a new editor window
Ctrl+O Open a file open dialog to open a Python file
Ctrl+Shift+O Open the file at the cursor. This works for
import statements since Sandbox is smart enough to look for
foo.py if the cursor is on foo. It also works for standard modules, because
if foo.py is not found in the current file's directory, sys.path
is searched.
Ctrl+P and Tab Pop up a list of possible completions for
the current word. Use the up and down arrow keys and the page up and page
up keys (or the mouse) to navigate; click Enter to accept a
completion or Esc to cancel.
PageUp Move up one screen
PageDown Move down one screen
Ctrl+Q Terminate Sandbox; prompting to save any unsaved changes
for every editor window for which this is necessary. If the user cancels
any save unsaved changes message box, Sandbox will not terminate.
Ctrl+R Replace the next occurrence of the find text; if there is
none, pop up the Find and Replace dialog.
Ctrl+S Save the current file
Ctrl+V Paste the clipboard's text
Ctrl+W Close the current file; prompting to save any unsaved
changes if necessary
Ctrl+X Cut the selected text to the clipboard
Ctrl+Z Undo the last editing action
Ctrl+Shift+Z Redo the last editing action
Hold down Shift when pressing movement keys to select the text moved
over.
Press Esc to close this window.
""" % (Config["tabwidth"], Config["tabwidth"]))
layout = QVBoxLayout()
layout.setMargin(0)
layout.addWidget(browser)
self.setLayout(layout)
self.resize(500, 500)
QShortcut(QKeySequence("Escape"), self, self.close)
self.setWindowTitle("Sandbox - Help")
class FindForm(QDialog):
def __init__(self, parent=None):
super(FindForm, self).__init__(parent)
self.findEdit = QComboBox()
self.findEdit.setDuplicatesEnabled(False)
self.findEdit.setEditable(True)
findLabel = QLabel("Find wha&t:")
findLabel.setBuddy(self.findEdit)
self.replaceEdit = QComboBox()
self.replaceEdit.setDuplicatesEnabled(False)
self.replaceEdit.setEditable(True)
replaceLabel = QLabel("Replace w&ith:")
replaceLabel.setBuddy(self.replaceEdit)
self.caseSensitiveCheckBox = QCheckBox("&Case sensitive")
self.caseSensitiveCheckBox.setChecked(Config["findcasesensitive"])
self.wholeWordsCheckBox = QCheckBox("&Whole words only")
self.wholeWordsCheckBox.setChecked(Config["findwholewords"])
buttonBox = QDialogButtonBox()
self.findButton = buttonBox.addButton("&Find",
QDialogButtonBox.ActionRole)
self.replaceButton = buttonBox.addButton("&Replace",
QDialogButtonBox.ActionRole)
buttonBox.addButton(QDialogButtonBox.Close)
if not MAC:
self.caseSensitiveCheckBox.setFocusPolicy(Qt.NoFocus)
self.wholeWordsCheckBox.setFocusPolicy(Qt.NoFocus)
buttonBox.setFocusPolicy(Qt.NoFocus)
grid = QGridLayout()
grid.addWidget(findLabel, 0, 0)
grid.addWidget(self.findEdit, 0, 1)
grid.addWidget(replaceLabel, 1, 0)
grid.addWidget(self.replaceEdit, 1, 1)
layout = QVBoxLayout()
layout.addLayout(grid)
hbox = QHBoxLayout()
hbox.addWidget(self.caseSensitiveCheckBox)
hbox.addWidget(self.wholeWordsCheckBox)
hbox.addStretch()
layout.addLayout(hbox)
layout.addWidget(buttonBox)
self.setLayout(layout)
self.connect(self.findEdit,
SIGNAL("editTextChanged(QString)"), self.updateUi)
self.connect(self.findButton, SIGNAL("clicked()"),
self.findClicked)
self.connect(self.replaceButton, SIGNAL("clicked()"),
self.replaceClicked)
self.connect(buttonBox, SIGNAL("rejected()"), self.reject)
self.updateUi()
self.setWindowTitle("Sandbox - Find and Replace")
def findClicked(self):
self.emit(SIGNAL("find"), self.findEdit.currentText(),
self.caseSensitiveCheckBox.isChecked(),
self.wholeWordsCheckBox.isChecked())
if Config["autohidefinddialog"]:
self.hide()
def replaceClicked(self):
self.emit(SIGNAL("replace"), self.findEdit.currentText(),
self.replaceEdit.currentText(),
self.caseSensitiveCheckBox.isChecked(),
self.wholeWordsCheckBox.isChecked())
if Config["autohidefinddialog"]:
self.hide()
def updateUi(self):
enable = not self.findEdit.currentText().isEmpty()
self.findButton.setEnabled(enable)
self.replaceButton.setEnabled(enable)
class PythonHighlighter(QSyntaxHighlighter):
Rules = []
Formats = {}
def __init__(self, parent=None):
super(PythonHighlighter, self).__init__(parent)
self.initializeFormats()
PythonHighlighter.Rules.append((QRegExp(
"|".join([r"\b%s\b" % keyword for keyword in KEYWORDS])),
"keyword"))
PythonHighlighter.Rules.append((QRegExp(
"|".join([r"\b%s\b" % builtin for builtin in BUILTINS])),
"builtin"))
PythonHighlighter.Rules.append((QRegExp(
"|".join([r"\b%s\b" % constant
for constant in CONSTANTS])), "constant"))
PythonHighlighter.Rules.append((QRegExp(
r"\b[+-]?[0-9]+[lL]?\b"
r"|\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b"
r"|\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b"),
"number"))
PythonHighlighter.Rules.append((QRegExp(
r"\bPyQt4\b|\bQt?[A-Z][a-z]\w+\b"), "pyqt"))
PythonHighlighter.Rules.append((QRegExp(r"\b@\w+\b"),
"decorator"))
stringRe = QRegExp(r"""(?:'[^']*'|"[^"]*")""")
stringRe.setMinimal(True)
PythonHighlighter.Rules.append((stringRe, "string"))
self.stringRe = QRegExp(r"""(:?"["]".*"["]"|'''.*''')""")
self.stringRe.setMinimal(True)
PythonHighlighter.Rules.append((self.stringRe, "string"))
self.tripleSingleRe = QRegExp(r"""'''(?!")""")
self.tripleDoubleRe = QRegExp(r'''"""(?!')''')
@staticmethod
def initializeFormats():
baseFormat = QTextCharFormat()
baseFormat.setFontFamily(Config["fontfamily"])
baseFormat.setFontPointSize(Config["fontsize"])
for name in ("normal", "keyword", "builtin", "constant",
"decorator", "comment", "string", "number", "error",
"pyqt"):
format = QTextCharFormat(baseFormat)
format.setForeground(
QColor(Config["%sfontcolor" % name]))
if Config["%sfontbold" % name]:
format.setFontWeight(QFont.Bold)
format.setFontItalic(Config["%sfontitalic" % name])
PythonHighlighter.Formats[name] = format
def highlightBlock(self, text):
NORMAL, TRIPLESINGLE, TRIPLEDOUBLE, ERROR = range(4)
textLength = text.length()
prevState = self.previousBlockState()
self.setFormat(0, textLength,
PythonHighlighter.Formats["normal"])
if text.startsWith("Traceback") or text.startsWith("Error: "):
self.setCurrentBlockState(ERROR)
self.setFormat(0, textLength,
PythonHighlighter.Formats["error"])
return
if (prevState == ERROR and
not (text.startsWith(sys.ps1) or text.startsWith("#"))):
self.setCurrentBlockState(ERROR)
self.setFormat(0, textLength,
PythonHighlighter.Formats["error"])
return
for regex, format in PythonHighlighter.Rules:
i = regex.indexIn(text)
while i >= 0:
length = regex.matchedLength()
self.setFormat(i, length,
PythonHighlighter.Formats[format])
i = regex.indexIn(text, i + length)
# Slow but good quality highlighting for comments. For more
# speed, comment this out and add the following to __init__:
# PythonHighlighter.Rules.append((QRegExp(r"#.*"), "comment"))
if text.isEmpty():
pass
elif text[0] == "#":
self.setFormat(0, text.length(),
PythonHighlighter.Formats["comment"])
else:
stack = []
for i, c in enumerate(text):
if c in ('"', "'"):
if stack and stack[-1] == c:
stack.pop()
else:
stack.append(c)
elif c == "#" and len(stack) == 0:
self.setFormat(i, text.length(),
PythonHighlighter.Formats["comment"])
break
self.setCurrentBlockState(NORMAL)
if self.stringRe.indexIn(text) != -1:
return
# This is fooled by triple quotes inside single quoted strings
for i, state in ((self.tripleSingleRe.indexIn(text),
TRIPLESINGLE),
(self.tripleDoubleRe.indexIn(text),
TRIPLEDOUBLE)):
if self.previousBlockState() == state:
if i == -1:
i = text.length()
self.setCurrentBlockState(state)
self.setFormat(0, i + 3,
PythonHighlighter.Formats["string"])
elif i > -1:
self.setCurrentBlockState(state)
self.setFormat(i, text.length(),
PythonHighlighter.Formats["string"])
def rehighlight(self):
QApplication.setOverrideCursor(QCursor(
Qt.WaitCursor))
QSyntaxHighlighter.rehighlight(self)
QApplication.restoreOverrideCursor()
class TextView(QTextEdit):
def __init__(self, parent=None):
super(QTextEdit, self).__init__(parent)
self.setAcceptRichText(False)
font = QFont(Config["fontfamily"], Config["fontsize"])
self.setFont(font)
self.textcharformat = QTextCharFormat()
self.textcharformat.setFont(font)
def currentWord(self, cursor=None):
if cursor is None:
cursor = self.textCursor()
cursor.movePosition(QTextCursor.StartOfWord)
cursor.movePosition(QTextCursor.EndOfWord,
QTextCursor.KeepAnchor)
return cursor.selectedText()
def currentLine(self):
cursor = self.textCursor()
cursor.movePosition(QTextCursor.StartOfLine)
cursor.movePosition(QTextCursor.EndOfLine,
QTextCursor.KeepAnchor)
return cursor.selectedText()
def lastNonEmptyLine(self):
cursor = self.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.movePosition(QTextCursor.StartOfLine,
QTextCursor.KeepAnchor)
if cursor.selectedText().isEmpty():
cursor.movePosition(QTextCursor.PreviousCharacter,
QTextCursor.KeepAnchor)
cursor.movePosition(QTextCursor.StartOfLine,
QTextCursor.KeepAnchor)
text = cursor.selectedText()
if not text.isEmpty():
while text.endsWith("\n"):
text.chop(1)
while text.endsWith(u"\u2029"):
text.chop(1)
return text
def lastLine(self):
cursor = self.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.movePosition(QTextCursor.StartOfLine,
QTextCursor.KeepAnchor)
return cursor.selectedText()
class TextEdit(TextView):
COMPLETION_X_OFFSET = None
def __init__(self, parent=None):
super(TextEdit, self).__init__(parent)
self.setLineWrapMode(QTextEdit.NoWrap)
self.indent = 0
self.completionListWidget = None
self.prefix = ""
self.classes = set()
self.defs = set()
if TextEdit.COMPLETION_X_OFFSET is None:
TextEdit.COMPLETION_X_OFFSET = QFontMetrics(
self.font()).width("x")
def checkForClassOrDef(self, line):
match = CLASS_OR_DEF_RE.search(line)
if match:
if not match.group(2).startswith("__"):
if match.group(1) == "class":
self.classes.add(match.group(2))
else:
self.defs.add(match.group(2))
def event(self, event):
tabwidth = Config["tabwidth"]
tooltipsize = Config["tooltipsize"]
indent = " " * tabwidth
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Backspace:
line = self.currentLine()
if len(line) >= tabwidth and line.endsWith(indent):
userCursor = self.textCursor()
for _ in range(tabwidth):
userCursor.deletePreviousChar()
self.indent = max(0, self.indent - 1)
return True
elif event.key() == Qt.Key_Tab:
if not self.tabChangesFocus():
cursor = self.textCursor()
cursor.movePosition(
QTextCursor.PreviousCharacter,
QTextCursor.KeepAnchor)
if cursor.selectedText().trimmed().isEmpty():
cursor = self.textCursor()
cursor.insertText(indent)
else:
self.complete()
return True
# else leave for base class to handle
elif event.key() == Qt.Key_ParenLeft:
cursor = self.textCursor()
cursor.movePosition(QTextCursor.StartOfLine,
QTextCursor.KeepAnchor)
name = unicode(cursor.selectedText().section(" ", -1))
tip = CAT.get(name)
if tip is not None:
rect = self.cursorRect()
point = self.mapToGlobal(QPoint(rect.x(),
rect.y()))
if len(tip) > tooltipsize:
tip = tip[:tooltipsize] + " ..."
QToolTip.showText(point, tip)
elif event.key() in (Qt.Key_Enter,
Qt.Key_Return):
userCursor = self.textCursor()
cursor = QTextCursor(userCursor)
cursor.movePosition(QTextCursor.End)
insert = "\n"
cursor = QTextCursor(userCursor)
cursor.movePosition(QTextCursor.StartOfLine)
cursor.movePosition(QTextCursor.EndOfLine,
QTextCursor.KeepAnchor)
line = cursor.selectedText()
uline = unicode(line)
checkForCAT(uline)
self.checkForClassOrDef(uline)
if line.endsWith(":") or line.endsWith("\\"):
for c in line:
if c == " ":
insert += " "
else:
break
insert += indent
self.indent += 1
elif line.startsWith(indent):
for c in line:
if c == " ":
insert += " "
else:
break
userCursor.insertText(insert)
return True
elif event.key() in (Qt.Key_Up, Qt.Key_Down,
Qt.Key_PageUp, Qt.Key_PageDown):
cursor = self.textCursor()
cursor.movePosition(QTextCursor.StartOfLine)
cursor.movePosition(QTextCursor.EndOfLine,
QTextCursor.KeepAnchor)
line = cursor.selectedText()
checkForCAT(unicode(line))
# Fall through to let the base class handle the movement
return QTextEdit.event(self, event)
def complete(self):
def getWords(prefix):
return [word for word in list(CAT.keys() + list(WORDS))
if len(word) >= MIN_COMPLETION_LEN and
word.startswith(prefix)]
cursor = self.textCursor()
cursor.movePosition(QTextCursor.StartOfLine,
QTextCursor.KeepAnchor)
self.prefix = cursor.selectedText().section(" ", -1)
if self.prefix.isEmpty():
return
pos = self.prefix.length() - 1
while (self.prefix.at(pos).isLetterOrNumber() or
self.prefix[pos] == ".") and pos >= 0:
pos -= 1
if pos > 0:
self.prefix = self.prefix.mid(pos + 1)
if self.prefix.isEmpty():
return
words = getWords(self.prefix)
while not words and self.prefix.contains("."):
self.prefix = self.prefix.mid(self.prefix.indexIn(".") + 1)
words = getWords(self.prefix)
if not words:
return
if len(words) > 15:
length = len(self.prefix)
words = [word for word in words if "." not in word[length:]]
firsttime = False
if self.completionListWidget is None:
self.completionListWidget = QListWidget(self)
self.completionListWidget.setWindowFlags(Qt.Popup)
QShortcut(QKeySequence("Escape"),
self.completionListWidget,
self.completionListWidget.close)
self.connect(self.completionListWidget,
SIGNAL("itemActivated(QListWidgetItem*)"),
self.userCompleted)
firsttime = True
self.completionListWidget.clear()
self.completionListWidget.addItems(sorted(words))
self.completionListWidget.setCurrentItem(
self.completionListWidget.item(len(words) // 2))
self.completionListWidget.scrollTo(
self.completionListWidget.currentIndex(),
QListWidget.PositionAtCenter)
rect = self.cursorRect()
point = self.mapToGlobal(QPoint(rect.x(), rect.y()))
if not firsttime:
screenRect = (QApplication.desktop()
.availableGeometry(self))
xDiff = screenRect.width() - (point.x() +
self.completionListWidget.width())
if xDiff < 0:
point.setX(point.x() + xDiff)
yDiff = screenRect.height() - (point.y() +
self.completionListWidget.height())
if yDiff < 0:
point.setY(point.y() + yDiff)
point.setX(point.x() + TextEdit.COMPLETION_X_OFFSET)
self.completionListWidget.move(point)
self.completionListWidget.show()
def userCompleted(self):
extra = (self.completionListWidget.currentItem().text()
.mid(len(self.prefix)))
if not extra.isEmpty():
cursor = self.textCursor()
cursor.insertText(extra)
self.completionListWidget.close()
def gotoLine(self):
cursor = self.textCursor()
lino, ok = QInputDialog.getInteger(self,
"Sandbox - Goto Line",
"Goto line:", cursor.blockNumber() + 1,
1, self.document().blockCount())
if ok:
cursor.movePosition(QTextCursor.Start)
cursor.movePosition(QTextCursor.Down,
QTextCursor.MoveAnchor, lino - 1)
self.setTextCursor(cursor)
self.ensureCursorVisible()
def gotoMatching(self):
# move the cursor to the matching ()[]<>{} or do nothing
OPEN = "([<{"
CLOSE = ")]>}"
cursor = self.textCursor()
cursor.movePosition(QTextCursor.PreviousCharacter,
QTextCursor.KeepAnchor)
c = unicode(cursor.selectedText())
if c not in OPEN + CLOSE:
cursor = self.textCursor()
cursor.movePosition(QTextCursor.NextCharacter,
QTextCursor.KeepAnchor)
c = unicode(cursor.selectedText())
if c in OPEN + CLOSE:
self.setTextCursor(cursor)
else:
return
i = OPEN.find(c)
if i > -1:
movement = QTextCursor.NextCharacter
stack = 0
target = CLOSE[i]
else:
i = CLOSE.find(c)
if i == -1:
return
movement = QTextCursor.PreviousCharacter
stack = -1
target = OPEN[i]
cursor = self.textCursor()
while (not (movement == QTextCursor.NextCharacter and
cursor.atEnd()) and
not (movement == QTextCursor.PreviousCharacter and
cursor.atStart())):
cursor.clearSelection()
cursor.movePosition(movement, QTextCursor.KeepAnchor)
x = unicode(cursor.selectedText())
if not x:
break
if x == c:
stack += 1
elif x == target:
if stack == 0:
cursor.clearSelection()
if movement == QTextCursor.PreviousCharacter:
cursor.movePosition(
QTextCursor.NextCharacter)
self.setTextCursor(cursor)
break
else:
stack -= 1
def indentRegion(self):
self._walkTheLines(True, " " * Config["tabwidth"])
def unindentRegion(self):
self._walkTheLines(False, " " * Config["tabwidth"])
def commentRegion(self):
self._walkTheLines(True, "# ")
def uncommentRegion(self):
self._walkTheLines(False, "# ")
def _walkTheLines(self, insert, text):
userCursor = self.textCursor()
userCursor.beginEditBlock()
start = userCursor.position()
end = userCursor.anchor()
if start > end:
start, end = end, start
block = self.document().findBlock(start)
while block.isValid():
cursor = QTextCursor(block)
cursor.movePosition(QTextCursor.StartOfBlock)
if insert:
cursor.insertText(text)
else:
cursor.movePosition(QTextCursor.NextCharacter,
QTextCursor.KeepAnchor, len(text))
if cursor.selectedText() == text:
cursor.removeSelectedText()
block = block.next()
if block.position() > end:
break
userCursor.endEditBlock()
class ShellWidget(QSplitter):
# Cannot offer a stop command since sending ^C or Del to the
# interpreter does nothing. Alternative would be to use
# code.InteractiveInterpreter but I prefer the real thing.
def __init__(self, parent=None):
super(ShellWidget, self).__init__(Qt.Vertical, parent)
self.history = []
self.historyIndex = -1
self.output = TextView()
self.output.setUndoRedoEnabled(False)
self.output.setReadOnly(True)
self.output.setTextInteractionFlags(
Qt.TextSelectableByMouse|
Qt.TextSelectableByKeyboard)
self.connect(self.output, SIGNAL("textChanged()"),
self.keepOutputVisible)
self.outputHighlighter = PythonHighlighter(self.output.document())
self.input = TextEdit()
self.inputHighlighter = PythonHighlighter(self.input.document())
self.addWidget(self.output)
self.addWidget(self.input)
QWidget.setTabOrder(self.input, self.output)
self.process = None
self.restartProcess()
QShortcut(QKeySequence("F6"), self, self.changeFocus)
self.setWindowTitle("Sandbox - Shell")
def restartProcess(self):
firsttime = False
if self.process is not None:
self.endProcess()
self.output.append("%s RESTARTED %s\n" % ("#" * 20, "#" * 20))
else:
firsttime = True
self.useSeparators = False
self.starting = True
self.inTraceback = False
self.inError = False
self.process = QProcess(self)
cwd = Config["cwd"]
if not cwd.isEmpty() and cwd != ".":
self.process.setWorkingDirectory(cwd)
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.connect(self.process, SIGNAL("readyRead()"),
self.readFromPython)
self.process.start(sys.executable, ["-i"])
self.process.waitForStarted()
startup = Config.get("shellstartup")[:]
if startup is not None:
for line in startup.split("\n"):
QTimer.singleShot(0,
lambda line=line:
self.writeToPython(QString(line + "\n")))
QTimer.singleShot(0,
lambda line=line: checkForCAT(unicode(line)))
QTimer.singleShot(0, lambda firsttime=firsttime:
self.setUseSeparators(firsttime=firsttime))
def setUseSeparators(self, on=True, firsttime=False):
self.useSeparators = on
if firsttime and Config["showwindowinfo"]:
self.output.append("# This is the Python output window.")
self.output.append("# Enter Python expressions and "
"definitions in the input window below, ")
self.output.append("# then press F5 (or Ctrl+Enter) to "
"execute.")
self.output.append(u"""\
# Use Tab or Ctrl+P for completion (which also works in editor windows),
# and Ctrl+\u2191 and Ctrl+\u2193 for the command history.\n
""")
self.outputHighlighter.rehighlight()
def endProcess(self):
if self.process is not None and self.process.state():
self.process.write(QByteArray("\x04"))
self.process.close()
self.process.terminate()
QThread.msleep(100)
if self.process.state():
self.process.kill()
self.process = None
def changeFocus(self):
if self.input.hasFocus():
self.output.setFocus()
else:
self.input.setFocus()
def keepOutputVisible(self):
self.output.moveCursor(QTextCursor.End)
self.output.ensureCursorVisible()
def writeSeparator(self, cursor, separator):
if not self.useSeparators:
return
cursor.movePosition(QTextCursor.End)
while True:
cursor.movePosition(QTextCursor.PreviousCharacter,
QTextCursor.KeepAnchor)
if cursor.selectedText() == "\n":
cursor.deleteChar()
else:
break
cursor.insertText("\n%s\n" % separator,
self.output.textcharformat)
def readFromPython(self):
beforeoutput = Config["beforeoutput"]
beforeinput = Config["beforeinput"]
cursor = self.output.textCursor()
doneSeparator = False
bytes = QByteArray()
while self.process.bytesAvailable():
bytes += self.process.readAll()
lines = QString.fromUtf8(bytes.data()).split("\n")
for line in lines:
if line.endsWith(sys.ps1):
self.inTraceback = False
self.inError = False
line = trimQString(line, sys.ps1)
line = trimQString(line, sys.ps2)
if line.isEmpty():
continue
if line.startsWith("Traceback"):
self.inTraceback = True
if line.startsWith(' File "'):
self.inError = True
if self.inError:
line.replace("", "").prepend("Error: ")
if not line.endsWith("\n"):
line.append("\n")
if (not doneSeparator and
not self.starting and
not self.inTraceback):
self.writeSeparator(cursor, beforeoutput)
doneSeparator = True
cursor = self.output.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertText(line, self.output.textcharformat)
if (not self.inTraceback and
self.output.lastNonEmptyLine() != beforeinput):
# Gives cleaner output, but it is slow!
self.output.setPlainText(self.output.toPlainText().replace(
"%s\n%s\n" % (beforeinput, beforeoutput), ""))
self.writeSeparator(cursor, beforeinput)
def writeToPython(self, text):
cursor = self.output.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertText(text, self.output.textcharformat)
text.append("\n\n")
self.process.write(text.toUtf8())
self.process.waitForBytesWritten(-1)
self.input.clear()
def execute(self):
self.starting = False
text = self.input.toPlainText().trimmed()
if text.isEmpty():
text = QString("")
elif not text.contains("\n"):
checkForCAT(unicode(text))
# TODO special case help()
if text == "license()":
text.prepend("license.MAXLINES = 9999;")
else:
self.history.append(text)
self.historyIndex = len(self.history)
text.append("\n")
self.writeToPython(text)
def undo(self):
self.input.undo()
def redo(self):
self.input.redo()
def copy(self):
if self.input.hasFocus():
self.input.copy()
else:
self.output.copy()
def cut(self):
if self.input.hasFocus():
self.input.cut()
else:
self.output.cut()
def paste(self):
if self.input.hasFocus():
self.input.paste()
else:
self.output.paste()
def selectAll(self):
if self.input.hasFocus():
self.input.selectAll()
else:
self.output.selectAll()
def complete(self):
self.input.complete()
def gotoMatching(self):
self.input.gotoMatching()
def clearOutput(self):
self.output.clear()
def showPrevious(self):
if -1 < self.historyIndex - 1 < len(self.history):
self.historyIndex = max(0, self.historyIndex - 1)
self.input.setText(self.history[self.historyIndex])
self.input.setFocus()
def showNext(self):
if -1 < self.historyIndex + 1 < len(self.history):
self.historyIndex = min(len(self.history),
self.historyIndex + 1)
self.input.setText(self.history[self.historyIndex])
elif self.historyIndex+1 == len(self.history):
self.historyIndex = len(self.history)
self.input.clear()
self.input.setFocus()
class EditWidget(TextEdit):
def __init__(self, parent=None):
super(EditWidget, self).__init__(parent)
self.highlighter = PythonHighlighter(self.document())
self.findForm = None
self.process = None
self.results = None
self.args = ""
self.history = [0]
self.historyIndex = 0
self.movingInHistory = False
self.connect(self, SIGNAL("cursorPositionChanged()"),
self._updateHistory)
def _updateHistory(self):
if not self.movingInHistory:
lino = self.textCursor().blockNumber()
if lino != self.history[-1]:
self.historyIndex = len(self.history)
self.history.append(lino)
def gotoPrevious(self):
self.movingInHistory = True
self.historyIndex = max(0, self.historyIndex - 1)
self._gotoHistory()
self.movingInHistory = False
def gotoNext(self):
self.movingInHistory = True
self.historyIndex = min(len(self.history) - 1,
self.historyIndex + 1)
self._gotoHistory()
self.movingInHistory = False
def _gotoHistory(self):
cursor = self.textCursor()
cursor.movePosition(QTextCursor.Start)
cursor.movePosition(QTextCursor.Down,
QTextCursor.MoveAnchor,
self.history[self.historyIndex])
self.setTextCursor(cursor)
self.ensureCursorVisible()
def findText(self):
if self.findForm is None:
self.findForm = FindForm(self)
self.connect(self.findForm, SIGNAL("find"),
self.findClicked)
self.connect(self.findForm, SIGNAL("replace"),
self.replaceClicked)
self.findForm.show()
self.findForm.activateWindow()
self.findForm.raise_()
def findClicked(self, findText, caseSensitive, wholeWords):
flags = QTextDocument.FindFlags()
if caseSensitive:
flags |= QTextDocument.FindCaseSensitively
if wholeWords:
flags |= QTextDocument.FindWholeWords
cursor = self.document().find(findText, self.textCursor(), flags)
if not cursor.isNull():
self.setTextCursor(cursor)
else:
self.parent().statusBar().showMessage(
"'%s' not found" % findText, TIMEOUT)
return cursor
def findNext(self):
if (self.findForm is None or
self.findForm.findEdit.currentText().isEmpty()):
self.findText()
else:
self.findClicked(self.findForm.findEdit.currentText(),
self.findForm.caseSensitiveCheckBox.isChecked(),
self.findForm.wholeWordsCheckBox.isChecked())
def findWordAt(self):
word = self.currentWord()
if not word.isEmpty():
self.findClicked(word, True, True)
def replaceClicked(self, findText, replaceText, caseSensitive,
wholeWords):
cursor = self.findClicked(self.findForm.findEdit.currentText(),
self.findForm.caseSensitiveCheckBox.isChecked(),
self.findForm.wholeWordsCheckBox.isChecked())
if cursor.isNull():
return
cursor.beginEditBlock()
start = min(cursor.anchor(), cursor.position())
cursor.removeSelectedText()
cursor.insertText(replaceText)
cursor.setPosition(start)
cursor.setPosition(start + replaceText.length(),
QTextCursor.KeepAnchor)
cursor.endEditBlock()
self.setTextCursor(cursor)
def replaceNext(self):
if (self.findForm is None or
self.findForm.findEdit.currentText().isEmpty()):
self.findText()
else:
self.replaceClicked(self.findForm.findEdit.currentText(),
self.findForm.replaceEdit.currentText(),
self.findForm.caseSensitiveCheckBox.isChecked(),
self.findForm.wholeWordsCheckBox.isChecked())
def setArgs(self):
args, ok = QInputDialog.getText(self,
"Sandbox - Set Arguments",
"Command line arguments:",
QLineEdit.Normal, self.args)
self.args = ""
if ok:
self.args = unicode(args)
def execute(self):
filename = self.parent().filename
if (self.document().isModified() and
(QMessageBox.question(self,
"Sandbox - Unsaved Changes",
"Save unsaved changes in %s before executing?" %
filename,
QMessageBox.Yes|QMessageBox.No) ==
QMessageBox.Yes)):
self.parent().fileSave()
if self.results is None:
self.results = TextView()
self.results.setUndoRedoEnabled(False)
self.results.setReadOnly(True)
self.results.setTextInteractionFlags(
Qt.TextSelectableByMouse|
Qt.TextSelectableByKeyboard)
fm = QFontMetrics(self.font())
# TODO Make the default width & height configurable
self.results.resize(fm.width("X") * 80, fm.height() * 25)
self.connect(self.results, SIGNAL("textChanged()"),
self.keepResultsVisible)
QShortcut(QKeySequence("Escape"), self.results,
self.results.close)
else:
self.results.clear()
self.results.setWindowTitle("Sandbox - %s %s [Running]" % (
QFileInfo(filename).fileName(),
" ".join(self.args.split())))
self.process = QProcess(self)
cwd = Config["cwd"]
if not cwd.isEmpty() and cwd != ".":
self.process.setWorkingDirectory(cwd)
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.connect(self.process, SIGNAL("readyRead()"),
self.readResults)
self.process.start(sys.executable, [filename] + self.args.split())
self.process.waitForStarted()
def readResults(self):
self.results.show()
self.results.activateWindow()
self.results.raise_()
bytes = QByteArray()
while self.process.bytesAvailable():
bytes += self.process.readAll()
self.results.append(QString.fromUtf8(bytes.data()))
def keepResultsVisible(self):
self.results.moveCursor(QTextCursor.End)
self.results.ensureCursorVisible()
def closeEvent(self, event):
self.stop()
event.accept()
def stop(self):
if self.process is not None and self.process.state():
self.process.terminate()
QThread.msleep(100)
if self.process.state():
self.process.kill()
self.results.setWindowTitle(self.results.windowTitle().replace(
"[Running]", "[Stopped]"))
def raiseResultsWindow(self):
if self.results is not None:
self.results.activateWindow()
self.results.raise_()
class ConfigForm(QDialog):
def __init__(self, parent=None):
super(ConfigForm, self).__init__(parent)
self.highlightingChanged = False
fm = QFontMetrics(self.font())
monofont = QFont(Config["fontfamily"], Config["fontsize"])
pixmap = QPixmap(16, 16)
self.colors = {}
self.boldCheckBoxes = {}
self.italicCheckBoxes = {}
self.completionCheckBoxes = {}
self.editors = {}
generalWidget = QWidget()
self.rememberGeometryCheckBox = QCheckBox(
"&Remember Geometry")
self.rememberGeometryCheckBox.setToolTip("
Check this to make "
"Sandbox remember the size and position of the Shell "
"window and one Editor window")
self.rememberGeometryCheckBox.setChecked(
Config["remembergeometry"])
self.editorWindowRadioButton = QRadioButton(
"Start With Editor &Window")
self.shellWindowRadioButton = QRadioButton(
"Start With &Shell Window")
startWithButtonGroup = QButtonGroup(self)
startWithButtonGroup.setExclusive(True)
startWithButtonGroup.addButton(self.editorWindowRadioButton)
startWithButtonGroup.addButton(self.shellWindowRadioButton)
startwithshell = Config["startwithshell"]
self.shellWindowRadioButton.setChecked(startwithshell)
self.editorWindowRadioButton.setChecked(not startwithshell)
self.autoHideFindDlgCheckBox = QCheckBox(
"Automati&cally Hide the Find and Replace dialog")
self.autoHideFindDlgCheckBox.setToolTip("
If checked, when you "
"press Find or Replace the dialog will be hidden; "
"further finds and replaces can be done through the Edit "
"menu (which lists the keyboard shortcuts). Uncheck this "
"if you prefer the dialog to stay visible and to click "
"its buttons")
self.autoHideFindDlgCheckBox.setChecked(
Config["autohidefinddialog"])
self.backupLineEdit = QLineEdit(Config["backupsuffix"])
self.backupLineEdit.setToolTip("
If nonempty, a backup will be "
"kept with the given suffix. If empty, no backup will be "
"made.")
regex = QRegExp(r"[~.].*")
self.backupLineEdit.setValidator(QRegExpValidator(regex,
self))
self.backupLineEdit.setFont(monofont)
backupLabel = QLabel("&Backup suffix:")
backupLabel.setBuddy(self.backupLineEdit)
regex = QRegExp(r"#.*")
self.inputLineEdit = QLineEdit(Config["beforeinput"])
self.inputLineEdit.setValidator(QRegExpValidator(regex,
self))
self.inputLineEdit.setInputMask("\#" + "x" * 40)
self.inputLineEdit.setFont(monofont)
inputPromptLabel = QLabel("&Input Prompt:")
inputPromptLabel.setBuddy(self.inputLineEdit)
self.outputLineEdit = QLineEdit(Config["beforeoutput"])
self.outputLineEdit.setValidator(QRegExpValidator(regex,
self))
self.outputLineEdit.setInputMask("\#" + "x" * 40)
self.outputLineEdit.setFont(monofont)
outputPromptLabel = QLabel("&Output Prompt:")
outputPromptLabel.setBuddy(self.outputLineEdit)
self.cwdLineEdit = QLineEdit(Config["cwd"])
cwdLabel = QLabel("Working &Directory:")
cwdLabel.setBuddy(self.cwdLineEdit)
self.showWindowInfoCheckBox = QCheckBox(
"Show Window Information at Start&up")
self.showWindowInfoCheckBox.setToolTip("
The maximum lines to "
"scan for function, method, and class names, and for "
"imports when a file is loaded. This is used for "
"setting up completions and tooltips and for the Goto "
"class and Goto def submenus. It can be slow for large "
"files.")
maxLinesSizeLabel = QLabel("&Max. Lines to Scan:")
maxLinesSizeLabel.setBuddy(self.maxLinesSizeSpinBox)
self.docPathLineEdit = QLineEdit(Config["pythondocpath"])
self.docPathLineEdit.setToolTip('
Enter your preferred location '
'(web address or path on local hard drive) of Python '
'documentation to be shown when selecting "Python '
'Documentation" from the Help menu.')
docPathButton = QPushButton("...")
docPathButton.setToolTip("Open file dialog to choose path")
self.connect(docPathButton, SIGNAL("clicked()"),
self.setDocPath)
docPathLabel = QLabel("P&ython Documentation:")
docPathLabel.setBuddy(self.docPathLineEdit)
minWidth = 0
for label in (backupLabel, inputPromptLabel, outputPromptLabel,
cwdLabel, tooltipSizeLabel, maxLinesSizeLabel,
docPathLabel):
minWidth = max(minWidth, fm.width(label.text()))
for label in (backupLabel, inputPromptLabel, outputPromptLabel,
cwdLabel, tooltipSizeLabel, maxLinesSizeLabel,
docPathLabel):
label.setMinimumWidth(minWidth)
vbox = QVBoxLayout()
vbox.addWidget(self.rememberGeometryCheckBox)
hbox = QHBoxLayout()
hbox.addWidget(self.editorWindowRadioButton)
hbox.addWidget(self.shellWindowRadioButton)
hbox.addStretch()
vbox.addLayout(hbox)
vbox.addWidget(self.autoHideFindDlgCheckBox)
hbox = QHBoxLayout()
hbox.addWidget(backupLabel)
hbox.addWidget(self.backupLineEdit)
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
hbox.addWidget(inputPromptLabel)
hbox.addWidget(self.inputLineEdit)
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
hbox.addWidget(outputPromptLabel)
hbox.addWidget(self.outputLineEdit)
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
hbox.addWidget(cwdLabel)
hbox.addWidget(self.cwdLineEdit)
vbox.addLayout(hbox)
vbox.addWidget(self.showWindowInfoCheckBox)
hbox = QHBoxLayout()
hbox.addWidget(tooltipSizeLabel)
hbox.addWidget(self.toolTipSizeSpinBox)
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
hbox.addWidget(maxLinesSizeLabel)
hbox.addWidget(self.maxLinesSizeSpinBox)
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
hbox.addWidget(docPathLabel)
hbox.addWidget(self.docPathLineEdit)
hbox.addWidget(docPathButton)
vbox.addLayout(hbox)
vbox.addStretch()
generalWidget.setLayout(vbox)
highlightingWidget = QWidget()
self.tabWidthSpinBox = QSpinBox()
self.tabWidthSpinBox.setAlignment(Qt.AlignVCenter|
Qt.AlignRight)
self.tabWidthSpinBox.setRange(2, 20)
self.tabWidthSpinBox.setSuffix(" spaces")
self.tabWidthSpinBox.setValue(Config["tabwidth"])
tabWidthLabel = QLabel("&Tab width:")
tabWidthLabel.setBuddy(self.tabWidthSpinBox)
self.fontComboBox = QFontComboBox()
self.fontComboBox.setCurrentFont(monofont)
fontLabel = QLabel("&Font:")
fontLabel.setBuddy(self.fontComboBox)
self.fontSpinBox = QSpinBox()
self.fontSpinBox.setAlignment(Qt.AlignVCenter|
Qt.AlignRight)
self.fontSpinBox.setRange(6, 20)
self.fontSpinBox.setSuffix(" pt")
self.fontSpinBox.setValue(Config["fontsize"])
vbox = QVBoxLayout()
hbox = QHBoxLayout()
hbox.addWidget(tabWidthLabel)
hbox.addWidget(self.tabWidthSpinBox)
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
hbox.addWidget(fontLabel)
hbox.addWidget(self.fontComboBox)
hbox.addWidget(self.fontSpinBox)
hbox.addStretch()
vbox.addLayout(hbox)
minWidth = 0
minButtonWidth = 0
count = 1
labels = []
buttons = []
for name, labelText in (("normal", "Normal:"),
("keyword", "Keywords:"), ("builtin", "Builtins:"),
("constant", "Constants:"), ("decorator", "Decorators:"),
("comment", "Comments:"), ("string", "Strings:"),
("number", "Numbers:"), ("error", "Errors:"),
("pyqt", "PyQt:")):
label = QLabel(labelText)
minWidth = max(minWidth, fm.width(label.text()))
labels.append(label)
boldCheckBox = QCheckBox("Bold")
boldCheckBox.setChecked(Config["%sfontbold" % name])
self.boldCheckBoxes[name] = boldCheckBox
italicCheckBox = QCheckBox("Italic")
italicCheckBox.setChecked(Config["%sfontitalic" % name])
self.italicCheckBoxes[name] = italicCheckBox
self.colors[name] = [Config["%sfontcolor" % name], None]
pixmap.fill(QColor(self.colors[name][0]))
if count <= 9:
colorButton = QPushButton("&%d Color..." % count)
count += 1
elif name == "pyqt":
colorButton = QPushButton("&Q Color...")
else:
colorButton = QPushButton("Color...")
minButtonWidth = max(minButtonWidth,
10 + pixmap.width() + fm.width(colorButton.text()))
buttons.append(colorButton)
colorButton.setIcon(QIcon(pixmap))
self.colors[name][1] = colorButton
hbox = QHBoxLayout()
hbox.addWidget(label)
hbox.addWidget(boldCheckBox)
hbox.addWidget(italicCheckBox)
hbox.addWidget(colorButton)
hbox.addStretch()
vbox.addLayout(hbox)
self.connect(colorButton, SIGNAL("clicked()"),
lambda name=name: self.setColor(name))
for label in labels:
label.setMinimumWidth(minWidth)
for button in buttons:
button.setMinimumWidth(minButtonWidth)
vbox.addStretch()
highlightingWidget.setLayout(vbox)
tabWidget = QTabWidget()
tabWidget.addTab(generalWidget, "&General")
tabWidget.addTab(highlightingWidget, "&Highlighting")
for name, label, msg in (
("newfile", "On &New File",
"The text here is automatically "
"inserted into new files. It may be convenient to add "
"your standard imports and copyright notice here."),
("shellstartup", "&At Startup",
"Sandbox executes the lines above "
"whenever the Python interpreter is started. "
"Use them to add convenience, e.g. "
"from math import *; import re; "
"etc. "
"Changes made here only take "
"effect when Sandbox is next run."
"The codecs and sys imports, "
"and the other codecs lines should not be changed "
"unless you are an expert.")):
editor = TextEdit()
editor.setPlainText(Config[name])
editor.setTabChangesFocus(True)
PythonHighlighter(editor.document())
vbox = QVBoxLayout()
vbox.addWidget(editor, 1)
vbox.addWidget(QLabel(msg))
widget = QWidget()
widget.setLayout(vbox)
tabWidget.addTab(widget, label)
self.editors[name] = editor
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|
QDialogButtonBox.Cancel)
layout = QVBoxLayout()
layout.addWidget(tabWidget)
layout.addWidget(buttonBox)
self.setLayout(layout)
self.connect(buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(buttonBox, SIGNAL("rejected()"), self.reject)
self.setWindowTitle("Sandbox - Configure")
def updateUi(self):
pass # TODO validation, e.g., valid shellstartup, etc.
def setDocPath(self):
path = QFileDialog.getOpenFileName(self,
"Sandbox - Open File", self.docPathLineEdit.text())
if not path.isEmpty():
self.docPathLineEdit.setText(path)
def setColor(self, which):
color = QColorDialog.getColor(
QColor(self.colors[which][0]), self)
if color is not None:
self.colors[which][0] = color.name()
pixmap = QPixmap(16, 16)
pixmap.fill(QColor(color.name()))
self.colors[which][1].setIcon(QIcon(pixmap))
def accept(self):
Config["remembergeometry"] = (self.rememberGeometryCheckBox
.isChecked())
Config["showwindowinfo"] = self.showWindowInfoCheckBox.isChecked()
Config["startwithshell"] = self.shellWindowRadioButton.isChecked()
Config["autohidefinddialog"] = (self.autoHideFindDlgCheckBox
.isChecked())
Config["backupsuffix"] = self.backupLineEdit.text()
Config["beforeinput"] = self.inputLineEdit.text()
Config["beforeoutput"] = self.outputLineEdit.text()
Config["cwd"] = self.cwdLineEdit.text()
for name in ("shellstartup", "newfile"):
Config[name] = unicode(self.editors[name].toPlainText())
Config["tabwidth"] = self.tabWidthSpinBox.value()
Config["tooltipsize"] = self.toolTipSizeSpinBox.value()
Config["maxlinestoscan"] = self.maxLinesSizeSpinBox.value()
Config["pythondocpath"] = self.docPathLineEdit.text()
family = self.fontComboBox.currentFont().family()
if Config["fontfamily"] != family:
self.highlightingChanged = True
Config["fontfamily"] = family
size = self.fontSpinBox.value()
if Config["fontsize"] != size:
self.highlightingChanged = True
Config["fontsize"] = size
for name in ("normal", "keyword", "builtin", "constant",
"decorator", "comment", "string", "number", "error",
"pyqt"):
bold = self.boldCheckBoxes[name].isChecked()
if Config["%sfontbold" % name] != bold:
self.highlightingChanged = True
Config["%sfontbold" % name] = bold
italic = self.italicCheckBoxes[name].isChecked()
if Config["%sfontitalic" % name] != italic:
self.highlightingChanged = True
Config["%sfontitalic" % name] = italic
color = self.colors[name][0]
if Config["%sfontcolor" % name] != color:
self.highlightingChanged = True
Config["%sfontcolor" % name] = color
QDialog.accept(self)
class MainWindow(QMainWindow):
NextId = 1
Instances = set()
Shell = None
Toolbars = {}
def __init__(self, filename=QString(), isShell=False,
parent=None):
super(MainWindow, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
MainWindow.Instances.add(self)
self.setWindowTitle("Sandbox[*]")
if isShell:
self.editor = ShellWidget()
MainWindow.Shell = self
else:
self.editor = EditWidget()
self.setCentralWidget(self.editor)
fileNewAction = self.createAction("&New File", self.fileNew,
QKeySequence.New, "filenew", "Create a Python file")
if not isShell:
fileNewShellAction = self.createAction("Sh&ell",
self.fileNewShell, icon="filenew",
tip="Create a new (or go to the existing) Shell")
fileOpenAction = self.createAction("&Open...", self.fileOpen,
QKeySequence.Open, "fileopen",
"Open an existing Python file")
# TODO
# fileOpenRecentAction = self.createAction("&Open Recent",
# self.fileOpenRecent, icon="fileopen",
# tip="Open an existing Python file")
if not isShell:
fileOpenAtAction = self.createAction(
"Open &File at Cursor", self.fileOpenAt,
"Ctrl+Shift+O", "fileopen",
"Open the file whose name is at the cursor position")
fileSaveAction = self.createAction("&Save", self.fileSave,
QKeySequence.Save, "filesave", "Save the file")
fileSaveAsAction = self.createAction("Save &As...",
self.fileSaveAs, icon="filesaveas",
tip="Save the file using a new filename")
fileSaveAllAction = self.createAction("Save A&ll",
self.fileSaveAll, icon="filesaveall",
tip="Save all the files")
fileConfigureAction = self.createAction("Config&ure...",
self.fileConfigure, icon="fileconfigure",
tip="Configure Sandbox")
fileCloseAction = self.createAction("&Close", self.close,
QKeySequence.Close, "fileclose",
"Close this Python editor")
fileQuitAction = self.createAction("&Quit", self.fileQuit,
"Ctrl+Q", "filequit", "Close the application")
editUndoAction = self.createAction("&Undo", self.editor.undo,
QKeySequence.Undo, "editundo",
"Undo the last editing action")
editRedoAction = self.createAction("&Redo", self.editor.redo,
QKeySequence.Redo, "editredo",
"Redo the last editing action")
editCopyAction = self.createAction("&Copy", self.editor.copy,
QKeySequence.Copy, "editcopy",
"Copy text to the clipboard")
editCutAction = self.createAction("Cu&t", self.editor.cut,
QKeySequence.Cut, "editcut",
"Cut text to the clipboard")
editPasteAction = self.createAction("&Paste",
self.editor.paste, QKeySequence.Paste, "editpaste",
"Paste in the clipboard's text")
editSelectAllAction = self.createAction("Select &All",
self.editor.selectAll, QKeySequence.SelectAll,
"editselectall", "Select all the editor's text")
editCompleteAction = self.createAction("Com&plete",
self.editor.complete, "Ctrl+P", "editcomplete",
"Complete the word (can also use Tab)")
if isShell:
editClearOutputAction = self.createAction("Clear &Output",
self.editor.clearOutput, icon="editclear",
tip="Clear the output text")
else:
editFindAction = self.createAction("&Find...",
self.editor.findText, QKeySequence.Find,
"editfind", "Find the given text")
editFindNextAction = self.createAction("Find &Next",
self.editor.findNext, QKeySequence.FindNext,
"editfindnext",
"Find the next occurrence of the given text")
editFindWordAtAction = self.createAction(
"Find &Word at Cursor", self.editor.findWordAt,
"Shift+F3", "editfindnext",
"Find the next occurrence of the word at the cursor")
editReplaceNextAction = self.createAction("R&eplace Next",
self.editor.replaceNext, QKeySequence.Replace,
"editreplace",
"Replace the next occurrence of the given text")
editIndentRegionAction = self.createAction("&Indent Region",
self.editor.indentRegion, "Ctrl+]", "editindent",
"Indent the selected text or the current line")
editUnindentRegionAction = self.createAction(
"Unin&dent Region", self.editor.unindentRegion,
"Ctrl+[", "editunindent",
"Unindent the selected text or the current line")
editCommentRegionAction = self.createAction("C&omment Region",
self.editor.commentRegion, icon="editcomment",
tip=("Comment out the selected text or the "
"current line"))
editUncommentRegionAction = self.createAction(
"Uncomment Re&gion", self.editor.uncommentRegion,
icon="edituncomment",
tip="Uncomment the selected text or the current line")
actionRunAction = self.createAction("E&xecute",
self.editor.execute, None, "actionrun",
"Execute the input window's code or run the current file")
actionRunAction.setShortcuts([QKeySequence("F5"),
QKeySequence("Ctrl+Enter"),
QKeySequence("Ctrl+Return")])
if not isShell:
actionSetArgsAction = self.createAction("Set &arguments...",
self.editor.setArgs, icon="actionsetargs",
tip="Set the command line arguments")
actionStopAction = self.createAction("&Stop",
self.editor.stop, icon="actionstop",
tip="Forcibly stop the application")
else:
actionRestartAction = self.createAction("Restart &Python",
self.editor.restartProcess, icon="actionrestart",
tip="Stop the interpreter and start a new one")
actionShowPrevAction = self.createAction(
"Show Previous Command", self.editor.showPrevious,
"Ctrl+Up", "previous",
("Show the previous command ready for editing "
"and running"))
actionShowNextAction = self.createAction(
"Show Next Command", self.editor.showNext,
"Ctrl+Down", "next",
("Show the next command ready for editing "
"and running"))
helpHelpAction = self.createAction("&Help", self.helpHelp,
QKeySequence.HelpContents, icon="helphelp",
tip="Online help")
helpPydocAction = self.createAction("&Python Documentation",
self.helpPydoc, "Ctrl+H", "docs",
tip="Open Python Documentation in a Web Browser")
helpAboutAction = self.createAction("&About", self.helpAbout,
icon="icon", tip="About Sandbox")
fileMenu = self.menuBar().addMenu("&File")
self.addActions(fileMenu, (fileNewAction,))
if not isShell:
self.addActions(fileMenu, (fileNewShellAction,))
self.addActions(fileMenu, (fileOpenAction,
# fileOpenRecentAction # TODO
))
if not isShell:
self.addActions(fileMenu, (fileOpenAtAction, fileSaveAction,
fileSaveAsAction))
self.addActions(fileMenu, (fileSaveAllAction, None,
fileConfigureAction, None, fileCloseAction,
fileQuitAction))
editMenu = self.menuBar().addMenu("&Edit")
self.addActions(editMenu, (editUndoAction, editRedoAction, None,
editCopyAction, editCutAction, editPasteAction,
editSelectAllAction, None, editCompleteAction))
if isShell:
self.addActions(editMenu, (None, editClearOutputAction,))
else:
self.addActions(editMenu, (None, editFindAction,
editFindNextAction, editFindWordAtAction,
editReplaceNextAction, None, editIndentRegionAction,
editUnindentRegionAction, editCommentRegionAction,
editUncommentRegionAction))
self.gotoMenu = self.menuBar().addMenu("&Goto")
self.connect(self.gotoMenu, SIGNAL("aboutToShow()"),
self.updateGotoMenu)
actionMenu = self.menuBar().addMenu("&Action")
self.addActions(actionMenu, (actionRunAction,))
if not isShell:
self.addActions(actionMenu, (actionSetArgsAction,
actionStopAction))
else:
self.addActions(actionMenu, (actionRestartAction, None,
actionShowPrevAction, actionShowNextAction))
viewMenu = self.menuBar().addMenu("&View")
self.windowMenu = self.menuBar().addMenu("&Window")
self.connect(self.windowMenu, SIGNAL("aboutToShow()"),
self.updateWindowMenu)
helpMenu = self.menuBar().addMenu("&Help")
self.addActions(helpMenu, (helpHelpAction, helpPydocAction,
helpAboutAction))
self.fileToolbar = self.addToolBar("File Toolbar")
self.fileToolbar.setObjectName("FileToolbar")
MainWindow.Toolbars[self.fileToolbar] = None
self.addActions(self.fileToolbar, (fileNewAction, fileOpenAction))
if not isShell:
self.addActions(self.fileToolbar, (fileSaveAction,))
self.editToolbar = self.addToolBar("Edit Toolbar")
self.editToolbar.setObjectName("EditToolbar")
MainWindow.Toolbars[self.editToolbar] = None
self.addActions(self.editToolbar, (editUndoAction, editRedoAction,
None, editCopyAction, editCutAction, editPasteAction))
if not isShell:
self.addActions(self.editToolbar, (None, editFindAction,
editFindNextAction, editReplaceNextAction, None,
editIndentRegionAction, editUnindentRegionAction,
editCommentRegionAction, editUncommentRegionAction))
self.actionToolbar = self.addToolBar("Action Toolbar")
self.actionToolbar.setObjectName("ActionToolbar")
MainWindow.Toolbars[self.actionToolbar] = None
self.addActions(self.actionToolbar, (actionRunAction,))
if not isShell:
self.addActions(self.actionToolbar, (actionStopAction,))
else:
self.addActions(self.actionToolbar, (actionRestartAction, None,
actionShowPrevAction, actionShowNextAction))
for toolbar in (self.fileToolbar, self.editToolbar,
self.actionToolbar):
action = viewMenu.addAction("&%s" % toolbar.windowTitle())
self.connect(action, SIGNAL("toggled(bool)"),
self.toggleToolbars)
action.setCheckable(True)
MainWindow.Toolbars[toolbar] = action
self.connect(self, SIGNAL("destroyed(QObject*)"),
MainWindow.updateInstances)
if not isShell:
status = self.statusBar()
status.setSizeGripEnabled(False)
status.showMessage("Ready", 5000)
self.columnCountLabel = QLabel("(empty)")
status.addPermanentWidget(self.columnCountLabel)
self.lineCountLabel = QLabel("(empty)")
status.addPermanentWidget(self.lineCountLabel)
self.connect(self.editor,
SIGNAL("cursorPositionChanged()"),
self.updateIndicators)
self.connect(self.editor.document(),
SIGNAL("blockCountChanged(int)"),
self.updateIndicators)
if Config["remembergeometry"]:
if isShell:
self.resize(Config["shellwidth"], Config["shellheight"])
self.move(Config["shellx"], Config["shelly"])
else:
self.resize(Config["windowwidth"],
Config["windowheight"])
if int(isShell) + len(MainWindow.Instances) <= 2:
self.move(Config["windowx"], Config["windowy"])
self.restoreState(Config["toolbars"])
self.filename = QString(".")
if isShell:
self.editor.restoreState(Config["splitter"])
self.setWindowTitle("Sandbox - Shell")
else:
self.filename = filename
if self.filename.isEmpty():
self.filename = QString("unnamed%d.py" %
MainWindow.NextId)
MainWindow.NextId += 1
self.editor.setText(Config["newfile"])
self.editor.moveCursor(QTextCursor.End)
self.editor.document().setModified(False)
self.setWindowModified(False)
self.setWindowTitle("Sandbox - %s[*]" % self.filename)
else:
self.loadFile()
self.connect(self.editor, SIGNAL("textChanged()"),
self.updateDirty)
self.updateGotoMenu()
QTimer.singleShot(0, self.updateToolbars)
@staticmethod
def updateInstances(qobj):
MainWindow.Instances = set([window for window
in MainWindow.Instances if isAlive(window)])
if MainWindow.Shell is not None and not isAlive(MainWindow.Shell):
MainWindow.Shell = None
def createAction(self, text, slot=None, shortcut=None, icon=None,
tip=None, checkable=False, signal="triggered()"):
action = QAction(text, self)
if icon is not None:
action.setIcon(getIcon("%s.png" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
def addActions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def updateDirty(self):
self.setWindowModified(self.editor.document().isModified())
def updateIndicators(self):
lines = self.editor.document().blockCount()
cursor = self.editor.textCursor()
self.columnCountLabel.setText("Column %d" % (
cursor.columnNumber() + 1))
if lines == 0:
text = "(empty)"
else:
text = "Line %d of %d" % (cursor.blockNumber() + 1, lines)
self.lineCountLabel.setText(text)
def updateToolbars(self):
for toolbar, action in MainWindow.Toolbars.items():
action.setChecked(toolbar.isVisible())
def toggleToolbars(self, on):
title = self.sender().text()
for toolbar, action in MainWindow.Toolbars.items():
if action.text() == title:
toolbar.setVisible(on)
action.setChecked(on)
def closeEvent(self, event):
if self == MainWindow.Shell:
self.editor.endProcess()
if Config["remembergeometry"]:
Config["shellwidth"] = self.width()
Config["shellheight"] = self.height()
Config["shellx"] = self.x()
Config["shelly"] = self.y()
Config["splitter"] = self.editor.saveState()
else:
if self.editor.document().isModified():
reply = QMessageBox.question(self,
"Sandbox - Unsaved Changes",
"Save unsaved changes in %s" % self.filename,
QMessageBox.Save|QMessageBox.Discard|
QMessageBox.Cancel)
if reply == QMessageBox.Save:
self.fileSave()
elif reply == QMessageBox.Cancel:
event.ignore()
return
# else accept and discard
if Config["remembergeometry"]:
Config["windowwidth"] = self.width()
Config["windowheight"] = self.height()
Config["windowx"] = self.x()
Config["windowy"] = self.y()
if self.editor.findForm is not None:
Config["findcasesensitive"] = (self.editor.findForm
.caseSensitiveCheckBox.isChecked())
Config["findwholewords"] = (self.editor.findForm
.wholeWordsCheckBox.isChecked())
Config["toolbars"] = self.saveState()
del MainWindow.Toolbars[self.fileToolbar]
del MainWindow.Toolbars[self.editToolbar]
del MainWindow.Toolbars[self.actionToolbar]
event.accept()
def fileConfigure(self):
form = ConfigForm(self)
if form.exec_():
# Should only do this if the highlighting was actually
# changed since it is computationally expensive.
if form.highlightingChanged:
font = QFont(Config["fontfamily"],
Config["fontsize"])
textcharformat = QTextCharFormat()
textcharformat.setFont(font)
PythonHighlighter.initializeFormats()
for window in MainWindow.Instances:
if isAlive(window):
if window == MainWindow.Shell:
window.editor.input.setFont(font)
window.editor.input.textcharformat = (
textcharformat)
window.editor.inputHighlighter.rehighlight()
window.editor.output.setFont(font)
window.editor.output.textcharformat = (
textcharformat)
window.editor.outputHighlighter.rehighlight()
else:
window.statusBar().showMessage(
"Rehighlighting...")
window.editor.setFont(font)
window.editor.textcharformat = textcharformat
window.editor.highlighter.rehighlight()
window.statusBar().clearMessage()
saveConfig()
def fileQuit(self):
QApplication.closeAllWindows()
shell = MainWindow.Shell
if shell is not None:
shell.editor.endProcess()
def fileNew(self):
MainWindow().show()
def fileNewShell(self):
if MainWindow.Shell is not None and isAlive(MainWindow.Shell):
MainWindow.Shell.activateWindow()
MainWindow.Shell.raise_()
else:
MainWindow(isShell=True).show()
def fileOpen(self):
if not self.filename.isEmpty():
path = QFileInfo(self.filename).path()
else:
path = "."
filename = QFileDialog.getOpenFileName(self,
"Sandbox - Open File", path,
"Python files (*.py *.pyw)\nAny file (*)")
if not filename.isEmpty():
# To prevent opening the same file twice
for window in MainWindow.Instances:
if isAlive(window) and window != MainWindow.Shell:
if window.filename == filename:
window.activateWindow()
window.raise_()
return
if (MainWindow.Shell != self and
not self.editor.document().isModified() and
self.filename.startsWith("unnamed")):
self.filename = filename
self.loadFile()
else:
MainWindow(filename).show()
def loadFile(self):
# File loading is slow due to reading CAT data and highlighting,
# but mostly due to the former. If you load one PyQt4 app, it
# will be slow, but subsequent ones will be quick becaue all the
# CAT data will have been gathered already.
QApplication.setOverrideCursor(QCursor(
Qt.WaitCursor))
fh = None
try:
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.ReadOnly):
raise IOError, unicode(fh.errorString())
stream = QTextStream(fh)
stream.setCodec("UTF-8")
text = stream.readAll()
self.editor.setPlainText(text)
self.editor.document().setModified(False)
# Get function, method, and class names for completion;
# get imports for CAT.
for i, line in enumerate(text.split("\n")): # This is slow!
if i >= Config["maxlinestoscan"]:
break
if CATABLE_LINE_RE.indexIn(line) > -1:
uline = unicode(line)
checkForCAT(uline)
self.editor.checkForClassOrDef(uline)
except (IOError, OSError), e:
QMessageBox.warning(self, "Sandbox - Load Error",
"Failed to load %s: %s" % (self.filename, e))
finally:
if fh is not None:
fh.close()
QApplication.restoreOverrideCursor()
self.editor.document().setModified(False)
self.setWindowModified(False)
self.setWindowTitle("Sandbox - %s[*]" %
QFileInfo(self.filename).fileName())
def fileOpenRecent(self):
print "fileOpenRecent" # TODO
def fileOpenAt(self):
filename = self.editor.currentWord()
if filename in ("py", "pyw"):
cursor = self.editor.textCursor()
cursor.movePosition(QTextCursor.PreviousWord)
filename = self.editor.currentWord(cursor) + "." + filename
if filename.isEmpty():
return
filename = unicode(filename)
dir = os.path.dirname(unicode(QDir(
self.filename).absolutePath()))
candidates = [filename, os.path.join(dir, filename)]
if not filename.endswith((".py", ".pyw")):
filename += ".py"
candidates.append(filename)
candidates.append(os.path.join(dir, filename))
for path in sys.path:
candidates.append(os.path.join(path, filename))
for candidate in candidates:
if QFile.exists(candidate):
QApplication.setOverrideCursor(QCursor(
Qt.WaitCursor))
MainWindow(QString(candidate)).show()
QApplication.restoreOverrideCursor()
break
else:
self.statusBar().showMessage("'%s' not found" % filename,
TIMEOUT)
def fileSave(self):
if self.filename.startsWith("unnamed"):
return self.fileSaveAs()
if (not Config["backupsuffix"].isEmpty() and
QFile.exists(self.filename)):
backup = self.filename + Config["backupsuffix"]
ok = True
if QFile.exists(backup):
ok = QFile.remove(backup)
if not ok:
QMessageBox.information(self,
"Sandbox - Save Warning",
"Failed to remove the old backup %s")
if ok:
# Must use copy rather than rename to preserve file
# permissions; could use rename on Windows though
if not QFile.copy(self.filename, backup):
QMessageBox.information(self,
"Sandbox - Save Warning",
"Failed to save a backup %s")
fh = None
try:
try:
fh = QFile(self.filename)
if not fh.open(QIODevice.WriteOnly):
raise IOError, unicode(fh.errorString())
stream = QTextStream(fh)
stream.setCodec("UTF-8")
stream << self.editor.toPlainText()
self.editor.document().setModified(False)
self.setWindowModified(False)
self.setWindowTitle("Sandbox - %s[*]" %
QFileInfo(self.filename).fileName())
self.statusBar().showMessage("Saved %s" % self.filename,
TIMEOUT)
except (IOError, OSError), e:
QMessageBox.warning(self, "Sandbox - Save Error",
"Failed to save %s: %s" % (self.filename, e))
finally:
if fh is not None:
fh.close()
return True
def fileSaveAs(self):
filename = QFileDialog.getSaveFileName(self,
"Sandbox - Save File As",
self.filename, "Python files (*.py *.pyw)")
if not filename.isEmpty():
self.filename = filename
return self.fileSave()
return False
def fileSaveAll(self):
count = 0
for window in MainWindow.Instances:
if (isAlive(window) and window != MainWindow.Shell and
window.editor.document().isModified()):
if window.fileSave():
count += 1
self.statusBar().showMessage("Saved %d of %d files" % (
count, len(MainWindow.Instances) -
int(MainWindow.Shell is not None)), 5000)
def updateGotoMenu(self):
self.gotoMenu.clear()
isShell = self == MainWindow.Shell
self.gotoMenu.addAction(self.createAction("&Matching",
self.editor.gotoMatching, "Ctrl+M", "gotomatching",
"Move the cursor to the matching parenthesis"))
if not isShell:
self.gotoMenu.addAction(self.createAction("&Line...",
self.editor.gotoLine, "Ctrl+L", "gotoline",
"Move the cursor to the given line"))
self.gotoMenu.addAction(self.createAction(
"&Previous position", self.editor.gotoPrevious,
"Ctrl+Up", "previous", "Move the cursor to the "
"previous line in the line history"))
self.gotoMenu.addAction(self.createAction(
"&Next position", self.editor.gotoNext,
"Ctrl+Down", "next", "Move the cursor to the "
"next line in the line history"))
if self.editor.classes or self.editor.defs:
self.gotoMenu.addSeparator()
if self.editor.classes:
i = 1
classMenu = self.gotoMenu.addMenu(
getIcon("forward.png"), "&class")
for text in sorted(self.editor.classes,
key=unicode.lower):
action = classMenu.addAction(text,
self.gotoClassOrDef)
accel = ""
if i < 10:
accel = "&%d " % i
elif i < 36:
accel = "&%c " % chr(i + ord("@") - 9)
action.setText("%s%s" % (accel, text))
action.setToolTip(text) # Stash class name
action.setData(QVariant(0))
action.setIcon(getIcon("forward.png"))
i += 1
if self.editor.defs:
i = 1
defMenu = self.gotoMenu.addMenu(getIcon("forward.png"),
"&def")
for text in sorted(self.editor.defs,
key=unicode.lower):
action = defMenu.addAction(text,
self.gotoClassOrDef)
accel = ""
if i < 10:
accel = "&%d " % i
elif i < 36:
accel = "&%c " % chr(i + ord("@") - 9)
action.setText("%s%s" % (accel, text))
action.setToolTip(text) # Stash def name
action.setData(QVariant(1))
action.setIcon(getIcon("forward.png"))
i += 1
def gotoClassOrDef(self):
action = self.sender()
if not isinstance(action, QAction):
return
if action.data().toInt()[0] == 0:
text = "class "
else:
text = "def "
text += action.toolTip() # Retrieve class or def name
if not self.editor.find(text,
QTextDocument.FindCaseSensitively):
if not self.editor.find(text,
QTextDocument.FindCaseSensitively|
QTextDocument.FindBackward):
self.statusBar().showMessage("'%s' not found" % text,
TIMEOUT)
if text.startsWith("def"):
self.editor.defs.discard(unicode(action.toolTip()))
else:
self.editor.classes.discard(unicode(action.toolTip()))
def updateWindowMenu(self):
self.windowMenu.clear()
shell = MainWindow.Shell
if shell is not None and isAlive(shell):
action = self.windowMenu.addAction("&Shell", self.raiseWindow)
action.setData(QVariant(long(id(shell))))
action.setIcon(getIcon("icon.png"))
if (hasattr(self.editor, "results") and
self.editor.results is not None and
self.editor.results.isVisible()):
action = self.windowMenu.addAction("&Results",
self.editor.raiseResultsWindow)
action.setIcon(getIcon("window.png"))
i = 1
menu = self.windowMenu
for window in MainWindow.Instances:
if window != shell and isAlive(window):
text = (window.windowTitle().replace("Sandbox - ", "")
.replace("[*]", ""))
if i == 10:
self.windowMenu.addSeparator()
menu = menu.addMenu("&More")
accel = ""
if i < 10:
accel = "&%d " % i
elif i < 36:
accel = "&%c " % chr(i + ord("@") - 9)
text = "%s%s" % (accel, text)
i += 1
action = menu.addAction(text, self.raiseWindow)
action.setData(QVariant(long(id(window))))
action.setIcon(getIcon("window.png"))
def raiseWindow(self):
action = self.sender()
if not isinstance(action, QAction):
return
windowId = action.data().toLongLong()[0]
for window in MainWindow.Instances:
if isAlive(window) and id(window) == windowId:
window.activateWindow()
window.raise_()
break
def helpHelp(self):
HelpForm(self).show()
def helpPydoc(self):
if not QDesktopServices.openUrl(
QUrl(Config["pythondocpath"])):
QMessageBox.warning(self, "Sandbox - Error",
"Could not start web browser")
def helpAbout(self):
iconLabel = QLabel()
icon = getPixmap("icon.png")
iconLabel.setPixmap(icon)
nameLabel = QLabel(" "
"Sandbox")
versionLabel = QLabel(""
"Python %s on %s PyQt %s - Qt %s "
"Sandbox %s" % (
sys.version[:sys.version.find(" ")], sys.platform,
PYQT_VERSION_STR, QT_VERSION_STR,
__version__))
aboutLabel = QTextBrowser()
aboutLabel.setOpenExternalLinks(True)
aboutLabel.setHtml("""\
Sandbox provides facilities for learning and experimenting with Python,
and for creating and editing Python files. It is designed to be easy to
learn and use, and to provide a PyQt-based alternative to IDLE.
(If you need a full-featured IDE, with support for debugging, we suggest
you use eric4.)
If you want to learn more about Python GUI programming with PyQt (the
GUI library used by Sandbox), you might like to buy my book, Rapid GUI
Programming with Python and Qt, ISBN: 0132354187.
I hope you find it useful!
-- Mark Summerfield,
mark@qtrac.eu""")
thanksLabel = QTextBrowser()
thanksLabel.setOpenExternalLinks(True)
thanksLabel.setHtml("""
0.9.9 Updated with David Boddie's patch to account for a
change in PyQt's behavior
0.9.8 Fixed a bug in the syntax highlighting.
0.9.7 Changed the import style. Fixed a syntax highlighting
bug reported by Gerald Senarclens de Grancy.
0.9.6 Minor code tidying up. Now GPL 2 or 3 or later.
0.9.5 No changes; done due to a problem with PyPI.
0.9.4 Added the ability to open the Python Documentation in
a web browser: all the relevant code was provided by Benno Dielmann.
Also optimized the comment highlighting slightly.
0.9.3 Improved the syntax highlighting for comments at the
cost of a little speed.
0.9.2 The input is no longer executed when Enter is pressed
on a blank line; this makes it possible to enter blank lines for the
sake of neatness. To execute, press F5 or Ctrl+Enter or Ctrl+Return. This
change was suggested by Benno Dielmann, who also provided bug fixes for
the command history and for the Find dialog's Close button.
0.9.1 Changed to GPL 2 since GPL 3 isn't compatible with the
GPL 2 libraries that Sandbox depends on; now any file can be opened with
file open.
0.9.0 You can now execute files (and set their command line
arguments), and stop them if necessary. The Find dialog now remembers
previous find and replace texts.
0.8.1 Removed Todo tab; now keep todos as comments at the
end. Improved completion behaviour.
0.8.0 Improved Goto submenus and Window menu and submenu.
Implemented Find Word at Cursor.
0.7.2 Changed a couple of default values. Implemented Open File
at Cursor.
0.7.1 Fixed subtle bug in Goto class and def regex. If a class
or def is not found (i.e., it has been deleted or renamed), it is now
removed from the Goto menu.
0.7.0 Implemented Goto menu, including Goto class and Goto
def submenus. Fixed subtle bug in Goto Matching.
0.6.3 Added key bindings to online help. Improved Goto Matching
and completions. Implemented Ctrl+\N{UPWARDS ARROW} and
Ctrl+\N{DOWNWARDS ARROW} to move to the previous and next lines in the line
history. Switched off line wrapping for the input window and for editors.
0.6.2 Added Changes tab to the about box. The shell now uses the
Python executable in sys.executable, i.e., the Python that was
used to run Sandbox. (This is useful for those with multiple Pythons
installed.)
"))
except:
pass
for name in MODULES.keys():
CAT[name] = None
if len(sys.argv) > 1:
args = sys.argv[1:]
if args[0] in ("-h", "--help"):
args.pop(0)
print """usage: sandbox.pyw [-n|filenames]
-n or --new means start with new file
filenames means start with the given files (which must have .py or .pyw
suffixes); otherwise starts with new file or Python shell
depending on configuration
Sandbox requires Python 2.5 and PyQt 4.2 (or later versions)
For more information run the program and click
Help->About and Help->Help"""
return
if args and args[0] in ("-n", "--new"):
args.pop(0)
MainWindow().show()
dir = QDir()
for fname in args:
if fname.endswith((".py", ".pyw")):
MainWindow(dir.cleanPath(
dir.absoluteFilePath((fname)))).show()
if not MainWindow.Instances:
MainWindow(isShell=Config["startwithshell"]).show()
app.exec_()
saveConfig()
main()
### Ideas for improvements ##############################################
#
# - Make Indent & Unindent smarter, i.e., Indent should insert _up to_
# tabwidth spaces to make the number of leading spaces an exact multiple
# of tabwidth. Similarly, Unindent should remove _up to_ tabwidth
# spaces on the same basis
# - Recent files handling
# - Add tooltips to all ConfigForm editing widgets & improve validation
# - Add tooltips to all main window actions that don't have any.
# - Goto menu. Use submenus to reflect the structure of the code, i.e.,
# classes
# Class1
# Method1
# Method2
# functions
# Func1
# Func2
# InnerFuncA
# This should be doable when reading, but trickier to maintain when
# users add or change classes and defs since the right "parent" must be
# found, and the name put in the right place in the tree
# - Robustness? catch exceptions better, etc.
# - Help? Handle help() in the shell?
# - Tools menu? (modeless delete on close dialogs); e.g.,
# Regular Expression Editor (similar to the one I wrote as an
# example for TT); support multiple syntaxes, e.g., re, glob,
# (fnmatch?), QRegExp, and QRegExp wildcard
# - i18n? use a custom dictionary-like function and keep all
# translations in this same file; or embed .qm files in base64?
# - Autosave? If not zero auto saves every N seconds to
# .sb$.self.filename. On close the .sb$. file is deleted after the
# save. On open, if a .sb$. file exists, rename it self.filename#1 (or
# 2 or whatever to make it unique) and then give a warning to the user
# that they may wish to diff against it. So we don't do recover as
# such.
# - Make keyboard shortcuts customisable? (apart from the standard ones)
python-qt4-4.10.4+dfsg.orig/contrib/sandbox/README 0000644 0000000 0000000 00000002550 12310607704 020163 0 ustar root root Sandbox
=======
Sandbox provides facilities for learning and experimenting with Python,
and for creating and editing Python files.
It is designed to be easy to learn and use, and to provide a PyQt-based
alternative to IDLE. (If you need a full-featured IDE, with support for
debugging, we suggest you use eric4
(http://www.die-offenbachs.de/eric/index.html)
Sandbox requires Python 2.5 and PyQt 4.2 (or later versions).
Installation is easy since Sandbox is supplied as a single Python file.
On Unix-like systems you may need to set sandbox.pyw to have execute
permission and to put it (or a soft-link to it) in your PATH. For
Windows, double-click to start it. You can always create a convenient
shortcut to it if you find yourself using it quite often.
Sandbox's home page is http://www.qtrac.eu/sandbox.html.
Copyright (c) 2007 Mark Summerfield. All rights reserved.
This program is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your
option) any later version.
This program is distributed in the hope that it will be useful, but
without any warranty; without even the implied warranty of
merchantability or fitness for a particular purpose. See the GNU General
Public License (http://www.gnu.org/licenses/) for more details.
python-qt4-4.10.4+dfsg.orig/contrib/pymodeltest/ 0000755 0000000 0000000 00000000000 12310607704 020214 5 ustar root root python-qt4-4.10.4+dfsg.orig/contrib/pymodeltest/modeltest.py 0000644 0000000 0000000 00000051147 12310607704 022576 0 ustar root root #############################################################################
##
## Copyright (C) 2007 Trolltech ASA. All rights reserved.
##
## This file is part of the Qt Concurrent project on Trolltech Labs.
##
## This file may be used under the terms of the GNU General Public
## License version 2.0 as published by the Free Software Foundation
## and appearing in the file LICENSE.GPL included in the packaging of
## this file. Please review the following information to ensure GNU
## General Public Licensing requirements will be met:
## http://www.trolltech.com/products/qt/opensource.html
##
## If you are unsure which license is appropriate for your use, please
## review the following information:
## http://www.trolltech.com/products/qt/licensing.html or contact the
## sales department at sales@trolltech.com.
##
## This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
## WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
##
#############################################################################
import sip
from PyQt4 import QtCore, QtGui
class ModelTest(QtCore.QObject):
def __init__(self, _model, parent):
"""
Connect to all of the models signals, Whenever anything happens recheck everything.
"""
QtCore.QObject.__init__(self,parent)
self._model = _model
self.model = sip.cast(_model, QtCore.QAbstractItemModel)
self.insert = []
self.remove = []
self.changing = []
self.fetchingMore = False
assert(self.model)
self.connect(self.model, QtCore.SIGNAL("columnsAboutToBeInserted(const QModelIndex&, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("columnsAboutToBeRemoved(const QModelIndex&, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("columnsInserted(const QModelIndex&, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("columnsRemoved(const QModelIndex&, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("dataChanged(const QModelIndex&, const QModelIndex&)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("headerDataChanged(Qt::Orientation, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("layoutAboutToBeChanged()"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("layoutChanged()"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("modelReset()"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("rowsAboutToBeInserted(const QModelIndex&, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("rowsAboutToBeRemoved(const QModelIndex&, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("rowsInserted(const QModelIndex&, int, int)"), self.runAllTests)
self.connect(self.model, QtCore.SIGNAL("rowsRemoved(const QModelIndex&, int, int)"), self.runAllTests)
# Special checks for inserting/removing
self.connect(self.model, QtCore.SIGNAL("layoutAboutToBeChanged()"), self.layoutAboutToBeChanged )
self.connect(self.model, QtCore.SIGNAL("layoutChanged()"), self.layoutChanged )
self.connect(self.model, QtCore.SIGNAL("rowsAboutToBeInserted(const QModelIndex&, int, int)"), self.rowsAboutToBeInserted)
self.connect(self.model, QtCore.SIGNAL("rowsAboutToBeRemoved(const QModelIndex&, int, int)"), self.rowsAboutToBeRemoved)
self.connect(self.model, QtCore.SIGNAL("rowsInserted(const QModelIndex&, int, int)"), self.rowsInserted)
self.connect(self.model, QtCore.SIGNAL("rowsRemoved(const QModelIndex&, int, int)"), self.rowsRemoved)
self.runAllTests()
def nonDestructiveBasicTest(self):
"""
nonDestructiveBasicTest tries to call a number of the basic functions (not all)
to make sure the model doesn't outright segfault, testing the functions that makes sense.
"""
assert(self.model.buddy(QtCore.QModelIndex()) == QtCore.QModelIndex())
self.model.canFetchMore(QtCore.QModelIndex())
assert(self.model.columnCount(QtCore.QModelIndex()) >= 0)
assert(self.model.data(QtCore.QModelIndex(), QtCore.Qt.DisplayRole) == QtCore.QVariant())
self.fetchingMore = True
self.model.fetchMore(QtCore.QModelIndex())
self.fetchingMore = False
flags = self.model.flags(QtCore.QModelIndex())
assert( int(flags & QtCore.Qt.ItemIsEnabled) == QtCore.Qt.ItemIsEnabled or int(flags & QtCore.Qt.ItemIsEnabled ) == 0 )
self.model.hasChildren(QtCore.QModelIndex())
self.model.hasIndex(0,0)
self.model.headerData(0,QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole)
self.model.index(0,0, QtCore.QModelIndex())
self.model.itemData(QtCore.QModelIndex())
cache = QtCore.QVariant()
self.model.match(QtCore.QModelIndex(), -1, cache)
self.model.mimeTypes()
assert(self.model.parent(QtCore.QModelIndex()) == QtCore.QModelIndex())
assert(self.model.rowCount(QtCore.QModelIndex()) >= 0)
variant = QtCore.QVariant()
self.model.setData(QtCore.QModelIndex(), variant, -1)
self.model.setHeaderData(-1, QtCore.Qt.Horizontal, QtCore.QVariant())
self.model.setHeaderData(0, QtCore.Qt.Horizontal, QtCore.QVariant())
self.model.setHeaderData(999999, QtCore.Qt.Horizontal, QtCore.QVariant())
self.model.sibling(0,0,QtCore.QModelIndex())
self.model.span(QtCore.QModelIndex())
self.model.supportedDropActions()
def rowCount(self):
"""
Tests self.model's implementation of QtCore.QAbstractItemModel::rowCount() and hasChildren()
self.models that are dynamically populated are not as fully tested here.
"""
# check top row
topindex = self.model.index(0,0,QtCore.QModelIndex())
rows = self.model.rowCount(topindex)
assert(rows >= 0)
if rows > 0:
assert(self.model.hasChildren(topindex) == True )
secondlvl = self.model.index(0,0,topindex)
if secondlvl.isValid():
# check a row count where parent is valid
rows = self.model.rowCount(secondlvl)
assert(rows >= 0)
if rows > 0:
assert(self.model.hasChildren(secondlvl) == True)
# The self.models rowCount() is tested more extensively in checkChildren,
# but this catches the big mistakes
def columnCount(self):
"""
Tests self.model's implementation of QtCore.QAbstractItemModel::columnCount() and hasChildren()
"""
# check top row
topidx = self.model.index(0,0,QtCore.QModelIndex())
assert(self.model.columnCount(topidx) >= 0)
# check a column count where parent is valid
childidx = self.model.index(0,0,topidx)
if childidx.isValid() :
assert(self.model.columnCount(childidx) >= 0)
# columnCount() is tested more extensively in checkChildren,
# but this catches the big mistakes
def hasIndex(self):
"""
Tests self.model's implementation of QtCore.QAbstractItemModel::hasIndex()
"""
# Make sure that invalid values returns an invalid index
assert(self.model.hasIndex(-2,-2) == False)
assert(self.model.hasIndex(-2,0) == False)
assert(self.model.hasIndex(0,-2) == False)
rows = self.model.rowCount(QtCore.QModelIndex())
cols = self.model.columnCount(QtCore.QModelIndex())
# check out of bounds
assert(self.model.hasIndex(rows,cols) == False)
assert(self.model.hasIndex(rows+1,cols+1) == False)
if rows > 0:
assert(self.model.hasIndex(0,0) == True)
# hasIndex() is tested more extensively in checkChildren()
# but this catches the big mistakes
def index(self):
"""
Tests self.model's implementation of QtCore.QAbstractItemModel::index()
"""
# Make sure that invalid values returns an invalid index
assert(self.model.index(-2,-2, QtCore.QModelIndex()) == QtCore.QModelIndex())
assert(self.model.index(-2,0, QtCore.QModelIndex()) == QtCore.QModelIndex())
assert(self.model.index(0,-2, QtCore.QModelIndex()) == QtCore.QModelIndex())
rows = self.model.rowCount(QtCore.QModelIndex())
cols = self.model.columnCount(QtCore.QModelIndex())
if rows == 0:
return
# Catch off by one errors
assert(self.model.index(rows,cols, QtCore.QModelIndex()) == QtCore.QModelIndex())
assert(self.model.index(0,0, QtCore.QModelIndex()).isValid() == True)
# Make sure that the same index is *always* returned
a = self.model.index(0,0, QtCore.QModelIndex())
b = self.model.index(0,0, QtCore.QModelIndex())
assert(a==b)
# index() is tested more extensively in checkChildren()
# but this catches the big mistakes
def parent(self):
"""
Tests self.model's implementation of QtCore.QAbstractItemModel::parent()
"""
# Make sure the self.model wont crash and will return an invalid QtCore.QModelIndex
# when asked for the parent of an invalid index
assert(self.model.parent(QtCore.QModelIndex()) == QtCore.QModelIndex())
if self.model.rowCount(QtCore.QModelIndex()) == 0:
return;
# Column 0 | Column 1 |
# QtCore.Qself.modelIndex() | |
# \- topidx | topidx1 |
# \- childix | childidx1 |
# Common error test #1, make sure that a top level index has a parent
# that is an invalid QtCore.Qself.modelIndex
topidx = self.model.index(0,0,QtCore.QModelIndex())
assert(self.model.parent(topidx) == QtCore.QModelIndex())
# Common error test #2, make sure that a second level index has a parent
# that is the first level index
if self.model.rowCount(topidx) > 0 :
childidx = self.model.index(0,0,topidx)
assert(self.model.parent(childidx) == topidx)
# Common error test #3, the second column should NOT have the same children
# as the first column in a row
# Usually the second column shouldn't have children
topidx1 = self.model.index(0,1,QtCore.QModelIndex())
if self.model.rowCount(topidx1) > 0:
childidx = self.model.index(0,0,topidx)
childidx1 = self.model.index(0,0,topidx1)
assert(childidx != childidx1)
# Full test, walk n levels deep through the self.model making sure that all
# parent's children correctly specify their parent
self.checkChildren(QtCore.QModelIndex())
def data(self):
"""
Tests self.model's implementation of QtCore.QAbstractItemModel::data()
"""
# Invalid index should return an invalid qvariant
assert( not self.model.data(QtCore.QModelIndex(), QtCore.Qt.DisplayRole).isValid())
if self.model.rowCount(QtCore.QModelIndex()) == 0:
return
# A valid index should have a valid QtCore.QVariant data
assert( self.model.index(0,0, QtCore.QModelIndex()).isValid())
# shouldn't be able to set data on an invalid index
assert( self.model.setData( QtCore.QModelIndex(), QtCore.QVariant("foo"), QtCore.Qt.DisplayRole) == False)
# General Purpose roles that should return a QString
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.ToolTipRole)
if variant.isValid():
assert( variant.canConvert( QtCore.QVariant.String ) )
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.StatusTipRole)
if variant.isValid():
assert( variant.canConvert( QtCore.QVariant.String ) )
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.WhatsThisRole)
if variant.isValid():
assert( variant.canConvert( QtCore.QVariant.String ) )
# General Purpose roles that should return a QSize
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.SizeHintRole)
if variant.isValid():
assert( variant.canConvert( QtCore.QVariant.Size ) )
# General Purpose roles that should return a QFont
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.FontRole)
if variant.isValid():
assert( variant.canConvert( QtCore.QVariant.Font ) )
# Check that the alignment is one we know about
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.TextAlignmentRole)
if variant.isValid():
alignment = variant.toInt()[0]
assert( alignment == (alignment & int(QtCore.Qt.AlignHorizontal_Mask | QtCore.Qt.AlignVertical_Mask)))
# General Purpose roles that should return a QColor
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.BackgroundColorRole)
if variant.isValid():
assert( variant.canConvert( QtCore.QVariant.Color ) )
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.TextColorRole)
if variant.isValid():
assert( variant.canConvert( QtCore.QVariant.Color ) )
# Check that the "check state" is one we know about.
variant = self.model.data(self.model.index(0,0,QtCore.QModelIndex()), QtCore.Qt.CheckStateRole)
if variant.isValid():
state = variant.toInt()[0]
assert( state == QtCore.Qt.Unchecked or
state == QtCore.Qt.PartiallyChecked or
state == QtCore.Qt.Checked )
def runAllTests(self):
if self.fetchingMore:
return
self.nonDestructiveBasicTest()
self.rowCount()
self.columnCount()
self.hasIndex()
self.index()
self.parent()
self.data()
def rowsAboutToBeInserted(self, parent, start, end):
"""
Store what is about to be inserted to make sure it actually happens
"""
c = {}
c['parent'] = parent
c['oldSize'] = self.model.rowCount(parent)
c['last'] = self.model.data(self.model.index(start-1, 0, parent))
c['next'] = self.model.data(self.model.index(start, 0, parent))
self.insert.append(c)
def rowsInserted(self, parent, start, end):
"""
Confirm that what was said was going to happen actually did
"""
c = self.insert.pop()
assert(c['parent'] == parent)
assert(c['oldSize'] + (end - start + 1) == self.model.rowCount(parent))
assert(c['last'] == self.model.data(self.model.index(start-1, 0, c['parent'])))
# if c['next'] != self.model.data(self.model.index(end+1, 0, c['parent'])):
# qDebug << start << end
# for i in range(0, self.model.rowCount(QtCore.QModelIndex())):
# qDebug << self.model.index(i, 0).data().toString()
# qDebug() << c['next'] << self.model.data(self.model.index(end+1, 0, c['parent']))
assert(c['next'] == self.model.data(self.model.index(end+1, 0, c['parent'])))
def rowsAboutToBeRemoved(self, parent, start, end):
"""
Store what is about to be inserted to make sure it actually happens
"""
c = {}
c['parent'] = parent
c['oldSize'] = self.model.rowCount(parent)
c['last'] = self.model.data(self.model.index(start-1, 0, parent))
c['next'] = self.model.data(self.model.index(end+1, 0, parent))
self.remove.append(c)
def rowsRemoved(self, parent, start, end):
"""
Confirm that what was said was going to happen actually did
"""
c = self.remove.pop()
assert(c['parent'] == parent)
assert(c['oldSize'] - (end - start + 1) == self.model.rowCount(parent))
assert(c['last'] == self.model.data(self.model.index(start-1, 0, c['parent'])))
assert(c['next'] == self.model.data(self.model.index(start, 0, c['parent'])))
def layoutAboutToBeChanged(self):
for i in range(0, max(0, min(self.model.rowCount(), 100))):
self.changing.append(QtCore.QPersistentModelIndex(self.model.index(i, 0)))
def layoutChanged(self):
for c in self.changing:
assert(c == self.model.index(c.row(), c.column(), c.parent()))
self.changing = []
def checkChildren(self, parent, depth = 0):
"""
Called from parent() test.
A self.model that returns an index of parent X should also return X when asking
for the parent of the index
This recursive function does pretty extensive testing on the whole self.model in an
effort to catch edge cases.
This function assumes that rowCount(QtCore.QModelIndex()), columnCount(QtCore.QModelIndex()) and index() already work.
If they have a bug it will point it out, but the above tests should have already
found the basic bugs because it is easier to figure out the problem in
those tests then this one
"""
# First just try walking back up the tree.
p = parent;
while p.isValid():
p = p.parent()
#For self.models that are dynamically populated
if self.model.canFetchMore( parent ):
self.fetchingMore = True
self.model.fetchMore(parent)
self.fetchingMore = False
rows = self.model.rowCount(parent)
cols = self.model.columnCount(parent)
if rows > 0:
assert(self.model.hasChildren(parent))
# Some further testing against rows(), columns, and hasChildren()
assert( rows >= 0 )
assert( cols >= 0 )
if rows > 0:
assert(self.model.hasChildren(parent) == True)
# qDebug() << "parent:" << self.model.data(parent).toString() << "rows:" << rows
# << "columns:" << cols << "parent column:" << parent.column()
assert( self.model.hasIndex( rows+1, 0, parent) == False)
for r in range(0,rows):
if self.model.canFetchMore(parent):
self.fetchingMore = True
self.model.fetchMore(parent)
self.fetchingMore = False
assert(self.model.hasIndex(r,cols+1,parent) == False)
for c in range(0,cols):
assert(self.model.hasIndex(r,c,parent))
index = self.model.index(r,c,parent)
# rowCount(QtCore.QModelIndex()) and columnCount(QtCore.QModelIndex()) said that it existed...
assert(index.isValid() == True)
# index() should always return the same index when called twice in a row
modIdx = self.model.index(r,c,parent)
assert(index == modIdx)
# Make sure we get the same index if we request it twice in a row
a = self.model.index(r,c,parent)
b = self.model.index(r,c,parent)
assert( a == b )
# Some basic checking on the index that is returned
assert( index.model() == self._model )
assert( index.row() == r )
assert( index.column() == c )
# While you can technically return a QtCore.QVariant usually this is a sign
# if an bug in data() Disable if this really is ok in your self.model
assert( self.model.data(index, QtCore.Qt.DisplayRole).isValid() == True )
#if the next test fails here is some somehwat useful debug you play with
# if self.model.parent(index) != parent:
# qDebug() << r << c << depth << self.model.data(index).toString()
# << self.model.data(parent).toString()
# qDebug() << index << parent << self.model.parent(index)
# # And a view that you can even use to show the self.model
# # view = QtGui.QTreeView()
# # view.setself.model(model)
# # view.show()
#
# Check that we can get back our real parent
p = self.model.parent( index )
assert( self.model.parent( index ) == parent )
# recursively go down the children
if self.model.hasChildren(index) and depth < 10:
# qDebug() << r << c << "hasChildren" << self.model.rowCount(index)
self.checkChildren(index, ++depth)
#else:
# if depth >= 10:
# qDebug() << "checked 10 deep"
# Make sure that after testing the children that the index doesn't change
newIdx = self.model.index(r,c,parent)
assert(index == newIdx)
python-qt4-4.10.4+dfsg.orig/contrib/pymodeltest/README 0000644 0000000 0000000 00000002552 12310607704 021100 0 ustar root root ModelTest provides a way to check for common errors in implementations of http://doc.trolltech.com/4/qabstractitemmodel.html.
ModelTest continuously checks a model as it changes, helping to verify the state and catching many common errors the moment they show up such as:
Verifing X number of rows have been inserted in the correct place after the signal rowsAboutToBeInserted() says X rows will be inserted.
The parent of the first index of the first row is a QModelIndex()
Calling index() twice in a row with the same values will return the same QModelIndex
If rowCount() says there are X number of rows, model test will verify that is true.
Many possible off by one bugs
hasChildren() returns true if rowCount() is greater then zero.
The QGraphicsDropShadowEffect class provides a drop shadow
effect.
A drop shadow effect renders the source with a drop shadow. The
color of the drop shadow can be modified using the setColor()
function. The drop shadow offset can be modified using the setOffset()
function and the blur radius of the drop shadow can be changed with
the setBlurRadius()
function.
By default, the drop shadow is a semi-transparent dark gray
(QColor(63, 63, 63, 180)) shadow, blurred
with a radius of 1 at an offset of 8 pixels towards the lower
right. The drop shadow offset is specified in device
coordinates.
The QPictureIO class contains parameters for loading and saving
pictures.
QPictureIO contains a QIODevice
object that is used for picture data I/O. The programmer can
install new picture file formats in addition to those that Qt
provides.
Defines a picture I/O handler for the picture format called
format, which is recognized using the regular expression
defined in header, read using readPicture and written
using writePicture.
flags is a string of single-character flags for this
format. The only flag defined currently is T (upper case), so the
only legal value for flags are "T" and the empty string. The
"T" flag means that the picture file is a text file, and Qt should
treat all newline conventions as equivalent. (XPM files and some
PPM files are text files for example.)
format is used to select a handler to write a QPicture; header is used to select a
handler to read an picture file.
If readPicture is a null pointer, the QPictureIO will not be able
to read pictures in format. If writePicture is a null
pointer, the QPictureIO will not be able to write pictures in
format. If both are null, the QPictureIO object is valid but useless.
Example:
void readSVG(QPictureIO*picture)
{
// read the picture using the picture->ioDevice()
}
void writeSVG(QPictureIO*picture)
{
// write the picture using the picture->ioDevice()
}
// add the SVG picture handler// ...
Before the regular expression test, all the 0 bytes in the file
header are converted to 1 bytes. This is done because when Qt was
ASCII-based, QRegExp could not handle 0
bytes in strings.
The regexp is only applied on the first 14 bytes of the
file.
(Note that if one handlerIO supports writing a format and
another supports reading it, Qt supports both reading and writing.
If two handlers support the same operation, Qt chooses one
arbitrarily.)
Returns a string that specifies the picture format of the
picture read from IO device d, or 0 if the device cannot be
read or if the format is not recognized.
Make sure that d is at the right position in the device
(for example, at the beginning of the file).
Sets the gamma value at which the picture will be viewed to
gamma. If the picture format stores a gamma value for which
the picture is intended to be used, then this setting will be used
to modify the picture. Setting to 0.0 will disable gamma correction
(i.e. any specification in the file will be ignored).
Sets the picture's parameter string to parameters. This
is for picture handlers that require special parameters.
Although the current picture formats supported by Qt ignore the
parameters string, it may be used in future extensions or by
contributions (for example, JPEG).
Writes an picture to an IO device and returns true if the
picture was successfully written; otherwise returns false.
Before writing an picture you must set an IO device or a file
name. If both an IO device and a file name have been set, the IO
device will be used.
The picture will be written using the specified picture
format.
Example:
QPictureIO iio;
QPicture picture;
QPainter painter(&picture);
painter.drawPixmap(0,0, pixmap);
iio.setPicture(picture);
iio.setFileName("vegeburger.pic");
iio.setFormat("PIC");
if (iio.write())
returntrue; // returned true if written successfully
The QMutex class provides access serialization between
threads.
The purpose of a QMutex is to protect an object, data structure
or section of code so that only one thread can access it at a time
(this is similar to the Java synchronized keyword). It is
usually best to use a mutex with a QMutexLocker since this makes it easy to
ensure that locking and unlocking are performed consistently.
For example, say there is a method that prints a message to the
user on two lines:
int number =6;
void method1()
{
number *=5;
number /=4;
}
void method2()
{
number *=3;
number /=2;
}
If these two methods are called in succession, the following
happens:
// method1()
number *=5; // number is now 30
number /=4; // number is now 7// method2()
number *=3; // number is now 21
number /=2; // number is now 10
If these two methods are called simultaneously from two threads
then the following sequence could result:
// Thread 1 calls method1()
number *=5; // number is now 30// Thread 2 calls method2().//// Most likely Thread 1 has been put to sleep by the operating// system to allow Thread 2 to run.
number *=3; // number is now 90
number /=2; // number is now 45// Thread 1 finishes executing.
number /=4; // number is now 11, instead of 10
If we add a mutex, we should get the result we want:
QMutex mutex;
int number =6;
void method1()
{
mutex.lock();
number *=5;
number /=4;
mutex.unlock();
}
void method2()
{
mutex.lock();
number *=3;
number /=2;
mutex.unlock();
}
Then only one thread can modify number at any given
time and the result is correct. This is a trivial example, of
course, but applies to any other case where things need to happen
in a particular sequence.
When you call lock() in a thread,
other threads that try to call lock() in the same place will block until
the thread that got the lock calls unlock(). A non-blocking alternative to
lock() is tryLock().
Type Documentation
QMutex.RecursionMode
Constant
Value
Description
QMutex.Recursive
1
In this mode, a thread can lock the same mutex
multiple times and the mutex won't be unlocked until a
corresponding number of unlock()
calls have been made.
QMutex.NonRecursive
0
In this mode, a thread may only lock a mutex
once.
Constructs a new mutex. The mutex is created in an unlocked
state.
If mode is QMutex.Recursive, a thread
can lock the same mutex multiple times and the mutex won't be
unlocked until a corresponding number of unlock() calls have been made. The default
is QMutex.NonRecursive.
Locks the mutex. If another thread has locked the mutex then
this call will block until that thread has unlocked it.
Calling this function multiple times on the same mutex from the
same thread is allowed if this mutex is a recursive mutex. If this mutex
is a non-recursive
mutex, this function will dead-lock when the mutex is
locked recursively.
Attempts to lock the mutex. If the lock was obtained, this
function returns true. If another thread has locked the mutex, this
function returns false immediately.
If the lock was obtained, the mutex must be unlocked with
unlock() before another thread can
successfully lock it.
Calling this function multiple times on the same mutex from the
same thread is allowed if this mutex is a recursive mutex. If this mutex
is a non-recursive
mutex, this function will always return false when
attempting to lock the mutex recursively.
Attempts to lock the mutex. This function returns true if the
lock was obtained; otherwise it returns false. If another thread
has locked the mutex, this function will wait for at most
timeout milliseconds for the mutex to become available.
Note: Passing a negative number as the timeout is
equivalent to calling lock(), i.e.
this function will wait forever until mutex can be locked if
timeout is negative.
If the lock was obtained, the mutex must be unlocked with
unlock() before another thread can
successfully lock it.
Calling this function multiple times on the same mutex from the
same thread is allowed if this mutex is a recursive mutex. If this mutex
is a non-recursive
mutex, this function will always return false when
attempting to lock the mutex recursively.
Unlocks the mutex. Attempting to unlock a mutex in a different
thread to the one that locked it results in an error. Unlocking a
mutex that is not locked results in undefined behavior.
The QDesignerFormWindowInterface class allows you to query and
manipulate form windows appearing in Qt Designer's workspace.
QDesignerFormWindowInterface provides information about the
associated form window as well as allowing its properties to be
altered. The interface is not intended to be instantiated directly,
but to provide access to Qt Designer's current form windows
controlled by Qt Designer's form window
manager.
But in addition, you can access any of the current form windows
through Qt Designer's form window manager: Use the QDesignerFormEditorInterface.formWindowManager()
function to retrieve an interface to the manager. Once you have
this interface, you have access to all of Qt Designer's
current form windows through the QDesignerFormWindowManagerInterface.formWindow()
function. For example:
QList<QDesignerFormWindowInterface*> forms;
QDesignerFormWindowInterface*formWindow;
QDesignerFormWindowManagerInterface*manager = formEditor->formWindowManager();
for (int i =0; i < manager->formWindowCount(); i++) {
formWindow = manager->formWindow(i);
forms.append(formWindow);
}
Once you have the form window, you can query its properties. For
example, a plain custom widget plugin is managed by Qt
Designer only at its top level, i.e. none of its child widgets
can be resized in Qt Designer's workspace. But
QDesignerFormWindowInterface provides you with functions that
enables you to control whether a widget should be managed by Qt
Designer, or not:
if (formWindow->isManaged(myWidget))
formWindow->manageWidget(myWidget->childWidget);
The interface provides you with functions and slots allowing you
to alter most of this information as well. The exception is the
directory storing the form window. Finally, there is several
signals associated with changes to the information mentioned above
and to the form window in general.
Type Documentation
QDesignerFormWindowInterface.FeatureFlag
This enum describes the features that are available and can be
controlled by the form window interface. These values are used when
querying the form window to determine which features it
supports:
Constant
Value
Description
QDesignerFormWindowInterface.EditFeature
0x01
Form editing
QDesignerFormWindowInterface.GridFeature
0x02
Grid display and snap-to-grid facilities for
editing
QDesignerFormWindowInterface.TabOrderFeature
0x04
Tab order management
QDesignerFormWindowInterface.DefaultFeature
EditFeature | GridFeature
Support for default features (form editing and
grid)
The Feature type is a typedef for QFlags<FeatureFlag>. It stores an OR
combination of FeatureFlag values.
This method is also a Qt slot with the C++ signature void clearSelection(bool = 1).
This method is abstract and should be reimplemented in any sub-class.
Clears the current selection in the form window. If
update is true, the emitSelectionChanged()
function is called, emitting the selectionChanged()
signal.
This method is abstract and should be reimplemented in any sub-class.
Returns the export macro associated with the form currently
being displayed in the window. The export macro is used when the
form is compiled to create a widget plugin.
This method is abstract and should be reimplemented in any sub-class.
Returns a combination of the features provided by the form
window associated with the interface. The value returned can be
tested against the Feature
enum values to determine which features are supported by the
window.
This method is abstract and should be reimplemented in any sub-class.
Returns a list of the header files that will be included in the
form window's associated UI file.
Header files may be local, i.e. relative to the project's
directory, "mywidget.h", or global, i.e. part of Qt or the
compilers standard libraries: <QtGui/QWidget>.
This method is also a Qt slot with the C++ signature void setDirty(bool).
This method is abstract and should be reimplemented in any sub-class.
If dirty is true, the form window is marked as dirty,
meaning that it is modified but not saved. If dirty is
false, the form window is considered to be unmodified.
This method is abstract and should be reimplemented in any sub-class.
Sets the form window's export macro to exportMacro. The
export macro is used when building a widget plugin to export the
form's interface to other components.
This method is also a Qt slot with the C++ signature void setGrid(const QPoint&).
This method is abstract and should be reimplemented in any sub-class.
Sets the grid size for the form window to the point specified by
grid. In this function, the coordinates in the QPoint are used to specify the dimensions of a
rectangle in the grid.
This method is abstract and should be reimplemented in any sub-class.
Sets the header files that will be included in the form window's
associated UI file to the specified includeHints.
Header files may be local, i.e. relative to the project's
directory, "mywidget.h", or global, i.e. part of Qt or the
compilers standard libraries: <QtGui/QWidget>.
This method is abstract and should be reimplemented in any sub-class.
Sets the margin and spacing for the form's
layout.
The default layout properties will be replaced by the
corresponding layout functions when uic generates code for
the form, that is, if the functions are specified. This is useful
when different environments requires different layouts for the same
form.
This signal is emitted whenever a widget on the form is about to
become unmanaged. When this signal is emitted, the specified
widget is still managed, and a widgetUnmanaged()
signal will follow, indicating when it is no longer managed.
This signal is emitted whenever an object (such as an action or
a QButtonGroup) is removed from the
form. The object that was removed is specified by
object.
This function was introduced in Qt 4.5.
void resourceFilesChanged ()
This is the default overload of this signal.
This signal is emitted whenever the list of resource files used
by the form changes.
The QtTest module provides functions for unit testing PyQt applications.
To import the module use, for example, the following statement:
from PyQt4 import QtTest
PyQt does not include the full Qt unit test framework. Instead it assumes
that the standard Python unit test framework will be used. Therefore, only
those functions that simulate user interaction with a GUI are implemented.
