Basic Load in Maya 2014 PySide Achieved

The basic load works with the UI loading and being correctly parented to
the Maya Window. However, all the relative referencing to the UI images
has failed, since the execution seems to think that the current directory
is complete different...

Therefore implementing fuller paths to the image locations using the
directory for __file__. This might not be the neatest way of doing it!

This commit is with the basic UI loading, but the images failing. Can
roll back to here if a more cunning plan is formulated.
Creation Menus Icons now Loading (CSS path fix) but not working

The fix had to occur in the validImageFile method of the DragItemButton
series in Widgets. Before the paths were relatives referenced from the
current directory, which was where the code was. Maya has it own idea of
the current directory, so the __file__ variable was brought into play.

This kicks up loads of \ on windows, which you are apparently able to
convert to / for the CSS paths using elegant os.path and posixpath
methods. Bollocks to that, it doesnt work, so it currently works with nice
direct strong replacement for \ and /
Selection Filter Icons loaded, but now need Adjusting

These icons were again relatively referenced in the main FaceBase_Launch
file. Now they a self.imagePath has been added to get the directory for
these images using __file__ and this attribute has been added to the file
paths so the images can be found.
File paths tweaks for css, face loading and saving

In PySide, most filedialogues seem to return a tuple, rather just the
string to the directory or file. The tuple has the wanted path as the
first element, so I have run around just making sure that we look at the
first element.
Tweaks made to remove .toPointF() since PySide doesnt have it
Resaved all icons with proper transparency and Maya Colours
Merge branch 'iconFixBranch' into runInMaya2014Branch
Tidying of Guide Marker Bounding Rectangle and moving of number

Reducing Bounding rectangle to be as small as possible so the most
intuitive seleciton occurs. In order to do this, the number has also been
adjusted from the bottom right, up to right of center so the bounding box
is not larger than it needs to be
Merge branch 'guideMarkerBranch' into runInMaya2014Branch
Adding basic Structire for Data Processing

New file added called dataProcessing.py

The structure is that there is a DataProcessor() class that is
responsible for pooling all the interesting data changes that occur.

The DataProcessor collects all the little DataBundles(). These bundles
are little bundles of information that are attached to each Node and
SuperNode. They register the positional changes and translate that into
outputting a useful float data value that we can then attach out to
anything we want.

At the moment this is just a basic implementation to pass the
DataProcessor down to the node level. Now build by testing and activating
functionality
Tweak to fix constructor for SuperGroup to Include DataProcesing
DataBundles now active and reporting data on basic position Changes

The DataBundles and now created and attached to the node when the node is
created. This is done internally in the node when it is created and the
dataProcessor is passed to the constructor
(self.dataProcessor.attachBundle(node))

The additional code has been inserted in the itemChanged() method for the
node and superNode to update the dataBundle given the new position. The
result is the setX() and setY() methods that are called and spit out a
useful float value for each axis.

Currently constraint Items are not considered at all, that needs to be
implemeted next to manage the float output to be scaled appropriately to
the regions of the constraint Items.

Have to check that the superNode Item which inherits the Node Item is not
processing data twice in the itemChanged() method
SuperNode was calling twice. Corrected.

The SuperNode now simply falls back on the inherited call of the Node
Class, so the dataBundle processing is performed for it.
Good progress on Constraint Ellipse callibration for DataBundles

calibrateDataBundle() method has been added to the ConstraintEllipse, and
this will be added to all other constraint Items. This sets the maxX,
minX, maxY, minY of the dataBundle to align with the shape of the
constraintItem. When the constraint Item is created this method is called
in the ControlPin setConstraintItem method.

It is also called in the redraw() method of the constraintItem itself so
dataBundle calibration is updated whenever the constraintItem shape is
adjusted
DataBundles now work for all 3 Constraint Types

Same theory as was applied to ConstraintEllipse is now working for
ConstraintRect and ConstraintLine, the only differences are the setup of
the calibrateDataBundle() method that is adjusted for the appropriate
shape of each item
Tweak to movement of Nodes and GuideMarkers

Movement of these GraphicsItems are now updated, so that on
MousePressEvent, then position of the item is snapped centrally to the
mouse cursor positions, so you are dragging the item around directly from
its centre.

Nodes had their MousePressEvent extended. PinTie is also updated in this
method.

GuideMarkers had to have the MousePressEvent methods implemented solely
for this purpose
Merge branch 'controlItemPositionBranch' into addDataProcessorBranch
Converted RigControls Folder into a package that can be imported

To do this the FaceBase_Launch File was renamed to __innit__.py. The
appropriate add/rm was done in git, and now the python paths were updated
in userSetup.py for the Maya 2014 setup.

All this now means a "import RigControls" will now launch the UI
smoothly...
Merge branch 'packageConversionBranch' into addDataProcessorBranch
Added Scene Control Builder with basic checks for Unique Name

Still need to update the checker if the user tries to build a new Scene
Controller when one is already registered...

Also need to add ability to assign Scene Controller if a node already
exists that is uitable