doc updates

documentation/source/images.rst

@@ -18,7 +18,7 @@ If the data is 3D (time, x, y), then a time axis will be shown with a slider tha
 There are a few other methods for displaying images as well:
    
 * The :class:`~pyqtgraph.ImageView` class can also be instantiated directly and embedded in Qt applications.
-* Instances of :class:`~pyqtgraph.ImageItem` can be used inside a GraphicsView.
+* Instances of :class:`~pyqtgraph.ImageItem` can be used inside a :class:`ViewBox <pyqtgraph.ViewBox>` or :class:`GraphicsView <pyqtgraph.GraphicsView>`.
 * For higher performance, use :class:`~pyqtgraph.RawImageWidget`.
 
 Any of these classes are acceptable for displaying video by calling setImage() to display a new frame. To increase performance, the image processing system uses scipy.weave to produce compiled libraries. If your computer has a compiler available, weave will automatically attempt to build the libraries it needs on demand. If this fails, then the slower pure-python methods will be used instead. 

documentation/source/index.rst

@@ -18,7 +18,6 @@ Contents:
     images
     style
     region_of_interest
-    graphicswindow
     parametertree
     internals
     apireference

documentation/source/parametertree.rst

@@ -1,7 +1,41 @@
 Rapid GUI prototyping
 =====================
 
- - parametertree
- - dockarea
- - flowchart
- - canvas
+[Just an overview; documentation is not complete yet]
+
+Pyqtgraph offers several powerful features which are commonly used in engineering and scientific applications.
+
+Parameter Trees
+---------------
+
+The parameter tree system provides a widget displaying a tree of modifiable values similar to those used in most GUI editor applications. This allows a large number of variables to be controlled by the user with relatively little programming effort. The system also provides separation between the data being controlled and the user interface controlling it (model/view architecture). Parameters may be grouped/nested to any depth and custom parameter types can be built by subclassing from Parameter and ParameterItem.
+
+See the parametertree example for more information.
+
+
+Visual Programming Flowcharts
+-----------------------------
+
+Pyqtgraph's flowcharts provide a visual programming environment similar in concept to LabView--functional modules are added to a flowchart and connected by wires to define a more complex and arbitrarily configurable algorithm. A small number of predefined modules (called Nodes) are included with pyqtgraph, but most flowchart developers will want to define their own library of Nodes. At their core, the Nodes are little more than 1) a Python function 2) a list of input/output terminals, and 3) an optional widget providing a control panel for the Node. Nodes may transmit/receive any type of Python object via their terminals.
+
+One major limitation of flowcharts is that there is no mechanism for looping within a flowchart. (however individual Nodes may contain loops (they may contain any Python code at all), and an entire flowchart may be executed from within a loop). 
+
+There are two distinct modes of executing the code in a flowchart:
+    
+1. Provide data to the input terminals of the flowchart. This method is slower and will provide a graphical representation of the data as it passes through the flowchart. This is useful for debugging as it allows the user to inspect the data at each terminal and see where exceptions occurred within the flowchart.
+2. Call Flowchart.process. This method does not update the displayed state of the flowchart and only retains the state of each terminal as long as it is needed. Additionally, Nodes which do not contribute to the output values of the flowchart (such as plotting nodes) are ignored. This mode allows for faster processing of large data sets and avoids memory issues which can occur if doo much data is present in the flowchart at once (e.g., when processing image data through several stages). 
+
+See the flowchart example for more information.
+
+Graphical Canvas
+----------------
+
+The Canvas is a system designed to allow the user to add/remove items to a 2D canvas similar to most vector graphics applications. Items can be translated/scaled/rotated and each item may define its own custom control interface.
+
+
+Dockable Widgets
+----------------
+
+The dockarea system allows the design of user interfaces which can be rearranged by the user at runtime. Docks can be moved, resized, stacked, and torn out of the main window. This is similar in principle to the docking system built into Qt, but offers a more deterministic dock placement API (in Qt it is very difficult to programatically generate complex dock arrangements). Additionally, Qt's docks are designed to be used as small panels around the outer edge of a window. Pyqtgraph's docks were created with the notion that the entire window (or any portion of it) would consist of dockable components.
+
+

documentation/source/region_of_interest.rst

@@ -1,19 +1,23 @@
-Region-of-interest controls
-===========================
+Interactive Data Selection Controls
+===================================
 
-Slicing Multidimensional Data
------------------------------
+Pyqtgraph includes graphics items which allow the user to select and mark regions of data.
 
 Linear Selection and Marking
 ----------------------------
 
+Two classes allow marking and selecting 1-dimensional data: :class:`LinearRegionItem <pyqtgraph.LinearRegionItem>` and :class:`InfiniteLine <pyqtgraph.InfiniteLine>`. The first class, :class:`LinearRegionItem <pyqtgraph.LinearRegionItem>`, may be added to any ViewBox or PlotItem to mark either a horizontal or vertical region. The region can be dragged and its bounding edges can be moved independently. The second class, :class:`InfiniteLine <pyqtgraph.InfiniteLine>`, is usually used to mark a specific position along the x or y axis. These may be dragged by the user.
+
+
 2D Selection and Marking
 ------------------------
 
+To select a 2D region from an image, pyqtgraph uses the :class:`ROI <pyqtgraph.ROI>` class or any of its subclasses. By default, :class:`ROI <pyqtgraph.ROI>` simply displays a rectangle which can be moved by the user to mark a specific region (most often this will be a region of an image, but this is not required). To allow the ROI to be resized or rotated, there are several methods for adding handles (:func:`addScaleHandle <pyqtgraph.ROI.addScaleHandle>`, :func:`addRotateHandle <pyqtgraph.ROI.addRotateHandle>`, etc.) which can be dragged by the user. These handles may be placed at any location relative to the ROI and may scale/rotate the ROI around any arbitrary center point. There are several ROI subclasses with a variety of shapes and modes of interaction.
+
+To automatically extract a region of image data using an ROI and an ImageItem, use :func:`ROI.getArrayRegion <pyqtgraph.ROI.getArrayRegion>`. ROI classes use the :func:`affineSlice <pyqtgraph.affineSlice>` function to perform this extraction.
+
+ROI can also be used as a control for moving/rotating/scaling items in a scene similar to most vetctor graphics editing applications.
+
+See the ROITypes example for more information.
 
 
-
-- translate / rotate / scale
-- highly configurable control handles
-- automated data slicing
-- linearregion, infiniteline

graphicsItems/ViewBox/ViewBox.py

@@ -27,6 +27,8 @@ class ChildGroup(ItemGroup):
 
 class ViewBox(GraphicsWidget):
     """
+    **Bases:** :class:`GraphicsWidget <pyqtgraph.GraphicsWidget>`
+    
     Box that allows internal scaling/panning of children by mouse drag. 
     This class is usually created automatically as part of a :class:`PlotItem <pyqtgraph.PlotItem>` or :class:`Canvas <pyqtgraph.canvas.Canvas>` or with :func:`GraphicsLayout.addViewBox() <pyqtgraph.GraphicsLayout.addViewBox>`.