var Px = Cx.Point;

var p = Px(x,y);
p.x  p.y

p.set(x,y);   // Modify inplace
p.set(point); // p := point
p.clone();    // return Px(p)
p.isEqual(point);    // return p == point
p.isNear(point,eps); // return p ~= point
p.isZero();          // return x == 0 && y == 0
p.add(point);            // p += point
p.substract(point);      // p -= point
p.scalarMultiply(alpha); // p *= alpha
p.sm(alpha);             // Shortcut for scalarMultiply
p.translate(offset);      // p += offset, same as add
p.translate(dx,dy);       // x += dx, y += dy
p.translated(offset);
p.translated(dx,dy);
p.transform(transform);   // p := transform.apply(p)
p.transformed(transform); // return transform.apply(p)
p.toSVG();       // return 'x y'
p.toXmlString(); // return 'x y'
p.textualize();  // return 'x y'
p.toCore();      // return { X: x, Y: y }
p.norm2();         // return x2 + y2
p.norm();          // return sqrt( norm2 ) 
p.normalize();     // p := p.normalized()
p.normalized();    // return p / norm
p.perpendicular(); // return orthogonal vector
p.confined(bounds);
p.confined(lx,ly,hx,hy);
p.confine(bounds);
p.confine(lx,ly,hx,hy);
p.angle();     // return angle with respect to the x axis
p.angle_rad(); // return angle in radians

Px.areEqual(pa,pb);         // return pa == pb
Px.fromXmlString(cdlPoint); // 'x y' => Px
Px.fromCore(pointModel);    // {X,Y} => Px
Px.distance(pa,pb);  // return euclidean distance between points
Px.distance2(pa,pb); // return squared euclidean distance
  
Px.minus(p);                // return -p
Px.add(pa,pb);              // return pa + pb
Px.substract(pa,pb);        // return pa - pb
Px.scalarMultiply(p,alpha); // return p * alpha
Px.sm(p,alpha);             // Shortcut for Px.scalarMultiply 
Px.dotProduct(pa,pb);       // return pa * pb
Px.crossProductZ(pa,pb);    // return pa ^ pb
    
Px.interpolate(pa,pb,t); // return pa * t + pb * (1-t)
Px.isInsidePolygon(point,polygon);

var Mx = Cx.Matrix;

var m = Mx(s00,s01,s10,s11, dx,dy);
m.s00  m.s01  m.dx
m.s10  m.s11  m.dy

m.apply(point); // return m * point
m.apply(x,y);   // return m * Px(x,y)
m.clone(); // return Mx(m); 
m.isEqual(matrix); // return m == matrix
m.isNear(matrix,eps); // return m ~= matrix
m.isIdentity();
m.isAlmostIsotropic(); // Only rotation and isometric scaling 
m.appended(matrix); // return m * matrix
m.determinant(); // return s00 * s11 - s01 * s10
m.scaleFactor(); // return sqrt(abs(determinant)) 
m.angle(); // return rotation angle
   
m.invert();
m.inverted(); 
m.toCssString(unit);  // return 'matrix(s00,s01,s10,s11,dx unit,-dy unit)'
m.toMatrix22String(); // return 's00 s01 s10 s11'
m.toMatrixString();   // return 's00 s01 s10 s11 dx dy' 
m.textualize();       // return 's00 s01 s10 s11 dx dy' 
m.toCore();           // return { S00, S01, S10, S11, DX, DY }

// Only for matrix22
Mx.add(m1,m2);                   // return m1 + m2
Mx.substract(m1,m2);             // return m1 - m2
Mx.scalarMultiply(matrix,alpha); // return matrix * alpha

Mx.sm(matrix,alpha);             // scalarMultiply shortcut
Mx.multiply(ml,mr);              // return ml * mr
Mx.concat(m1,m2,m3,...);         // return m1 * m2 * m3 * ...
Mx.invert(matrix);               // return matrix ^ -1

Mx.translate(offset);               // return translation matrix
Mx.translate(dx, dy);               // return translation matrix
Mx.scale(sx, sy, deg);              // return scaling matrix
Mx.scaleFrom(point, sx, sy, deg);   // return scaling matrix
Mx.rotate(deg);                     // return rotation matrix
Mx.rotateAround(point, deg);        // retrun rotation matrix
Mx.shear(sx, sy, deg);              // return shear matrix
Mx.shearAround(point, sx, sy, deg); // return shear matrix
Mx.transformAround(point, matrix);  // return general matrix

Mx.stringToMatrix22(string); // 's00 s01 s10 s11' => Matrix
Mx.fromCore(m); return { S00, S01, S10, S11, DX, DY } => Matrix

var b = Cx.Bounds(lx, ly, hx, hy);
b.lx  b.ly  b.hx  b.hy

Cx.Bounds.fromBox(box);     // { x, y, width, height } => Cx.Bounds
Cx.Bounds.fromXmlString(s); // 'lx ly hx hy' => Cx.Bounds
Cx.Bounds.fromCore(m);      // { LX, LY, HX, HY } => Cx.Bounds

Cx.Bounds.ofPoints(points); // return points bounds
Cx.Bounds.ofPointsAfter(points,transform);
Cx.Bounds.ofThings(things); // return things bounds
Cx.Bounds.ofThingsAfter(things,transform);

Cx.Bounds.overlapPercentage(ba, bb)
Cx.Bounds.horizontalOverlapPercentage(ba, bb)
Cx.Bounds.areOverlapping(ba,bb)
Cx.Bounds.intersection(ba, bb)
Cx.Bounds.union(boundsArray)

var f = Cx.Frame(p0,p1,p2,p3);
f.p0  f.p1  f.p2  f.p3

f.clone();
f.isEqual(frame); // return f == frame
f.bounds();
f.center();
f.width();  // return distance(p0,p1)
f.height(); // return distance(p0,p3)
f.width2();  // return distance2(p0,p1)
f.height2(); // return distance2(p0,p3)
f.minSideLength2();
f.translate(dx,dy);
f.translated(dx,dy);
f.transform(t);
f.transformed(t);
f.interpolate(ax,ay);
f.toXmlString();
f.contains(point);
f.extend(olx,oly,ohx,ohy);
f.extended(olx,oly,ohx,ohy);
f.angle(); // p0 p1 angle

Cx.Frame.fromRect(x,y,width,height);
Cx.Frame.fromBounds(bounds)
Cx.Frame.around(center,width,height);

Cx.Frame.fromXmlString(s); // 'p0x p0y ... ' => Cx.Frame
Cx.Frame.areOverlapping(fa,fb);
Cx.Frame.overlapPercentage(fa,fb);

var contour = Cx.Contour({ offset: 10
                         , brush: { color: { rgb: 'FF0000', alpha: 0.5 } } });

var contour = Cx.Contour({ offset: 10
                         , brush: figure.brush() });

var figures = layer.figures();
for(var k=0, size=figures.length; k<size; ++k){
  var figure = figures[k];
  figure.translate(offset);
}

_.invoke( layer.figures(), 'translate', offset );

figures.remove(smallFigures);

var canvas = Cx.Canvas({ renderTo: domId });

canvas.zoomTo(zoom,center);
canvas.zoomBy(delta); // zoom += delta
canvas.zoomIn(factor);  // zoom *= factor
canvas.zoomOut(factor); // zoom /= factor
canvas.zoomAround(bounds,margin);
canvas.zoomToFit$(figures,margin);
canvas.zoomToFitPages$(margin);
canvas.center(bounds);
canvas.center$(figures);
canvas.bounds();

canvas.tool(); // return current tool
canvas.tool(tool); // stack a new tool
canvas.popTool(); // commit current tool

canvas.pages(i,a);
canvas.activeLayerFigures(i,a);
canvas.activePageFigures(i,a);
canvas.layers(i,a);
canvas.figures(i,a);
canvas.allFigures();
canvas.commit$();
canvas.revert$();
canvas.update$();
canvas.add(figures);
canvas.remove(figures);
canvas.replace(old,new);
  
canvas.backOne(figures);
canvas.toBack(figures);
canvas.forwardOne(figures);
canvas.toFront(figures);
canvas.saveCopy$(attrs);
canvas.save$(attrs);
canvas.addClipart$(clipart);
canvas.replaceClipart$(old,clipart);
canvas.autoCreateMultiPartText$(figures);
canvas.breakMultiPartText(text);
  
canvas.group(figures);
canvas.ungroup(figures);
canvas.extractPowerClipContents(figure);
canvas.addPowerClipContents(figure,content);
  
canvas.reshape$(figures,action);

canvas.selectAll();      // Shortcut for canvas.selectedFigures( doc.activeLayerFigures() )
canvas.clearSelection(); // Shortcut for canvas.selectedFigures().clear()
canvas.selectNext();     // Select next figure in z-order
canvas.keepSelection();  // Auto selection will not kick in for current transaction

// Returns a copy of the current zoom, offset, wireframe that can be stored to set back later
var s = canvas.state();
// Later...
canvas.state(s);

canvas.fill(context);
canvas.updateSize();
canvas.dispose();

canvas.render$();
canvas.contextFigures(i,a); // selection ? selectedFigures(i,a)
                            //           : doc.figures(i,a)
canvas.action(id,config);
canvas.showPagesSelector$();
canvas.figureAtPoint( docPoint );

if( canvas.canUndo() ) canvas.undo();
if( canvas.canRedo() ) canvas.redo();

canvas.annotate( figure, { message: 'Message', pen: ... } );
canvas.annotate( figures, { grouped: true, message: ... } );
canvas.annotate( function(figure){ }, { message: function(figure){}, ... });
canvas.annotate( function(figure){ }, function(figure){} );
canvas.annotate( function(figure){ }, function(figure){} );
canvas.unannotate( annotation );
canvas.clearAnnotations();

canvas.condition(name,function(figure){ return boolean; });
canvas.arrayCondition(name,function(figures){ return boolean; });

canvas.is(figure,condition...);
canvas.is$(figure,conditions...);

canvas.are(figures,conditions...);
canvas.are$(figures,conditions...);

canvas.only(figures,conditions...);
canvas.only$(figures,conditions...);

canvas.saveConditions();
canvas.restoreConditions();

var backgrondDocument = canvas.background();
// ... modify and commit$ like a normal document

Cx.Document.load$(id) .then(function(doc){ 
// doc is of type Cx3D.Document

doc.add(figures);

doc.islandsLayer(); // return active page islands layer
doc.designLayers(); // return active page design layers

doc.islandsLayer(page); // return page islands layer
doc.designLayers(page); // return page design layers

doc.isTextureIsland(figure);

doc.textureIslandBrush(figure,brush);

doc.copyDesignTo$(doc,{scaled:false}) .then( ...

doc.loadModel3D$() .then(function(model) { ...

Cx3D.Model.load$(id) .then(function(model){ ...

var model = Cx3D.Model.fromXml(xml);

var model = Cx3D.Model.fromXmlString(s);

model.createDocument3D$() .then(function(doc3D){ ...

var page = model.createCustomPage(name);

model.loadModelData3D$() .then(function(modelData){ ...

Cx3D.ModelData.load$(id) .then(function(modelData){ ...

var texture = Cx3D.ProductionTexture({ renderTo: domId });

texture.watch(canvas);

texture.dispose();
texture.updateSize();

var mv = Cx3D.ModelView({ renderTo: domId });

mv.modelData(modelData);

mv.watch(texture);

mv.dispose();
mv.image();
mv.updateSize();

mv.zoomToFront();
mv.zoomToBack();
mv.zoomToRight();
mv.zoomToLeft();

mv.zoomIn(scale);
mv.zoomOut(scale);

mv.rotateCameraRight(angle);
mv.rotateCameraLeft(angle);
mv.rotateCameraDown(angle);
mv.rotateCameraUp(angle);

mv.rotateModelRight(angle);
mv.rotateModelLeft(angle);
mv.rotateModelDown(angle);
mv.rotateModelUp(angle);

Cx3D.thumbnailImage$(config);

var preview = Cx3D.createPreview(domId,docId);

var doc = Cx.Document();

doc.pages(i,a);
doc.activePage();
doc.activePageIndex();
doc.releasePages(pages);

doc.layers(i,a);
doc.activeLayer();
doc.activeLayerIndex();
doc.releaseLayers(layers);

doc.figures(i,a);
doc.allFigures();

doc.backOne(figures);
doc.toBack(figures);
doc.forwardOne(figures);
doc.toFront(figures);
doc.autoCreateMultiPartText$(figures);
doc.breakMultiPartText(text);
  
doc.group(figures);
doc.ungroup(figures);
doc.extractPowerClipContents(figure);
doc.addPowerClipContents(figure,content);
  
doc.reshape$(figures,action);

doc.lock();
doc.unlock();
doc.commit$();
doc.revert$();
doc.update$();

doc.background();
doc.clone();
doc.toXmlString();

Cx.Document.load$(id) .then(function(doc){ ...
Cx.Pages.load$(id) .then(function(pages){ ...
Cx.Layers.load$(id) .then(function(layers){ ...
Cx.Document.fromXmlString(string);
Cx.Document.fromXml(node);

doc.saveCopy$();
doc.save$();
doc.isSaved();

if( doc.canUndo() )
  doc.undo();
  
if( doc.canRedo() )
  doc.redo();

doc.addClipart$(clipart) .then(...

doc.replaceClipart$(old, clipart) .then(...

f.clone();
f.toXml();
f.toXmlString();

f.lock();
f.commit$();
f.revert$();
f.update$();

f.invalidate();
f.invalidated();
f.processed();
f.currentlyProcessing();

f.translate(offset);
f.translate(dx,dy);
f.scaleFrom(point,sx,sy,deg);
f.rotateAround(point,angle);
f.shearAround(point,sx,sy,deg);
f.transform(matrix);
f.angle();
f.angle(angle,pivot);

f.rotate$(angle);
f.scale$(sx,sy);
f.mirrorX$();
f.mirrorY$();

f.align$(alignment,to,margin);
f.fit$(bounds,config);
f.setSize$({ width, height, locked, pin });

// Options 'nothing', 'bounds', 'center', 'width', 'frame', 'frameCenter', 'frameWidth':
f.modifyKeeping$(what,func);

f.setTaggedColors(tag,color);
f.setLabeledColors(label,color);
f.getColors();
f.replaceColor(oldColor,newColor,config);
f.uniqueColorZones(options);  
f.changeColorZone(zone,value);
    
f.getBrushes();
f.replaceBrush(oldBrush,newBrush);
f.uniqueBrushZones(options,zones);
f.changeBrushZone(zone,value);

f.extractPowerClipContents();

Cx.Figure.fromXml(node);
Cx.Figure.fromXmlString(string);

Cx.Figure.condition(name,function(figure){ return boolean });
Cx.Figure.arrayCondition(name,function(figures){ return boolean });

Cx.Figure.saveConditions();
Cx.Figure.restoreConditions();

var text = Cx.Text({
  text: 'Hello world!',
  fontSize: 50
});

text.isEmpty(); // return text == ''
text.isMultiPart(); // return textParts.length > 0

text.breakIntoParts(); // return Text Array equivalent to the text parts
text.addPowerClipContents(figures); // Add figures to the powerclip content

range.slice(text); // return text range
range.clone();
range.isEqual(other);

var part = Cx.TextPart({ textRange: range, ... text properties ... });

part.clone();

Cx.Figure.autoCreateMultiPartText$(figures) .then(function(multiPartText) { ...

var shape = Cx.Shape({
  polyregions: [...],
  brush:{ color:{ rgb: '000000' }}
});

shape.addPowerClipContents(figures);

var rectangle = Cx.Shape.Rectangle({
  bounds: Cx.Bounds(lx,ly,hx,hy)
, brush: brush, pen: pen
};

var rectangle = Cx.Shape.Rectangle({
  center: Px(0,0), width: 200, height: 100
, brush: brush, pen: pen
};

var polyline = Cx.Shape.Polyline({
  points: [...]
, brush: brush, pen: pen
});

var raster = Cx.Raster({ imageLink: '30305c17-ef10-4183-9c94-008f9a7c2d6b' });

raster.isMonochrome();

raster.globalDpi$();
raster.globalDpi_();

group.ungroupedFigures(); // return equivalent ungrouped figures
group.regroup(figures); // Add equivalent figures to the group
group.ungroup(figures); // return and remove figures ungrouping them
group.ungroup(); // return and remove all figures, leave the group empty

Cx.Group.create(figures); // Create group with equivalent figures

var proxy = Cx.ProxyGroup({ link: '...' });

figure.translate(10,0);
figure.rotateAround(figure.pin(),45);
figure.commit$();

figure.center$() .then(function(center){
figure.rotateAround(center,45);
figure.commit$();
});

figure.update$() .then(function(figure){
// ...
});

figure.update$() .then(function(figure){
var b = figure.bounds_();
var f = figure.frame_();
// ...
});

metrix$: function(){
  return this.update$() .then(function(figure){
  return figure.metrix_(); 
  }); 
}

figure.translate(x,y); // figure.translate(offset);
figure.scaleFrom(point,sx,sy [,deg]);
figure.rotateAround(point,angle);
figure.shearAround(point,sx,sy [,deg]);
figure.transform(matrix);

Cx.translate(figures, x,y); // Cx.translate(figures, offset);
Cx.scaleFrom(figures, point,sx,sy [,deg]);
Cx.rotateAround(figures, point,angle);
Cx.shearAround(figures, point,sx,sy [,deg]);
Cx.transform(figures, matrix);

figure.rotate$(angle);
figure.scale$(sx, sy);
figure.mirrorX$();
figure.mirrorY$();

Cx.rotate$(figures, angle);
Cx.scale$(figures, sx, sy);
Cx.mirrorX$(figures);
Cx.mirrorY$(figures);

figure.center$( to );
Cx.center$( figures, to );

figure.align$( alignment, to [, margin] );

Cx.align$( figures, alignment [, to, margin] );

Cx.groupedAlign$( figures, alignment, to [,margin] );

// Center figures in Canvas
Cx.center$( figures, canvas );
// Align figures to the top of the Canvas (respecting relative distances)
Cx.groupedAlign$( figures, 'Top', canvas );
// Align figures baselines
Cx.align$( figures, 'bottom' );

Cx.fit$(figures, to,{ locked:[bool], fit:['Max'/'Min'/'Mean'] });

// Fit figures to cover the Canvas visible area
Cx.fit$(figures, canvas);
// Fit figures to cover all the figures in the document
Cx.fit$(figures, doc.activePageFigures());

Cx.setSize$(figures, { width:[n], height:[n], locked:[bool], fit:['Max'/'Min'/'Mean'], pin:[point] });

// Set the width of the selected figures, preserving aspect ratio.
Cx.setSize$(canvas.selectedFigures(),{width:400})
// Set the width and height of the figures, preserving aspect ratio and area of the bounds.
Cx.setSize$(figures,{width:500,fit:'Mean'});
// Set width and height, do not preserve aspect ratio
Cx.setSize$(figures,{width:100,height:100,locked:false});

Cx.reshape$(figures,action) .then(function( newFigures ) {
  // ...

Cx.combine$(figures) .then(function( newFigure ){ ...
Cx.weld$(figures) .then(function( newFigure ){ ...
Cx.condense$(figures) .then(function( newFigure ){ ...
Cx.frontMinusBack$(figures) .then(function( newFigure ){ ...
Cx.backMinusFront$(figures) .then(function( newFigure ){ ...

Cx.forEachColor(figures,function(color){ ... },context);

var zones = Cx.uniqueColorZones(figures, { collapseTags:[bool] });

Cx.changeColorZone(figures, zone, newValue);

var map = function(color) { return newColor -or- color; };  
Cx.convertColors(figures, map);

Cx.colorAt$(figures, point).then( function(color) ) {
  // ...

figure.brush(brush);
doc.commit$();

Cx.Brush({ color: { rgb: '000000' } });

Cx.LinearGradientBrush({ from: Px(0.0,0.5), to: Px(1.0,0.5)
                       , gammaCorrection: true 
                       , positions: [ 0, 1 ]
                       , colors: [ { rgb: 'FFFFFF' }
                                 , { rgb: '000000' } ] });

Cx.RadialGradientBrush({ centerColor: { rgb: 'FFFFFF' }
                       , outerColors: [ { rgb: '000000' } ]
                       , positions: [ 0, 1 ]
                       , center: 0.5,0.5, radiuses: [1] )});

Cx.TextureBrush({ imageLink: '...', 
                , textureOffset: Px(0,0), targetOffset: Px(0,0)
                , matrix22: Mx(), transformMode: `Full`
                , clippingRect: Cx.Bounds(0,0,1,1) });

var pen = Cx.Pen({ width: 2, color: { rgb: color } });
figure.pen(pen);
doc.commit$();

Cx.Pen({ color: { rgb: '000000' }, width: 5
       , startCap: 'Flat', endCap: 'Flat'
       , dashCap: 'Flat', dashStyle: 'Solid'
       , lineJoin: 'Round', miterLimit: 10
       , behindFill: true });

var processes = figure.processes();
processes.add( process );

var process = Cx.Capital({ scaleX: 1.5, scaleY: 1.5, vAlignment: 'Middle', pattern: 'First' });

var process = Cx.BookEnd({ headSX: 1.2, headSY: 1.5, tailSX: 1.2, tailSY: 1.5
                         , hAlignment: 'Center', vAlignment: 'Bottom' });

var process = Cx.ClassicArc({ width: 1000, height: 400, from: 135, to: 45, dontRotate: false });

var process = Cx.FitEllipse({ height: 100, width: 500, rotation: 0, placement: 90
                            , mirror: false, inside: true, dontRotate: false, fit: 'None'});

var process = Cx.FitOnPath({ path: Cx.Curve(points,false)
                           , vPos: 'Over', hPos: 'Fixed_CenterTop', offset: 0
                           , distanceFromPath: 0, placeOnOtherSide: false 
                           , fwd: true, dontRotate: false, overhang: false });

var process = Cx.VerticalArch({ height: 100, width: 500, from: 160, to: 20 });

var process = Cx.Perspective({ hPoint: Px(1000, 0), vPoint: Px(0, 300) });

var process = Cx.FitEnvelope({ envelope: Cx.Envelope(curves)
                             , mode: 'Mixed'
                             , vPos: 'Stretched', hPos: 'Stretched'
                             , highResolution: false, keepLines: false
                             , addBearingX: false });

var process = Cx.Border({ dX: 20, dY: 30, gap: 10, separate: false });

var process = Cx.Contour({ pen: Cx.Pen({ width: 2, color:{ rgb: '0000FF' } })
                         , brush: Cx.Brush({ color:{ rgb: 'FF0000' } })
                         , offset: 5, steps: 1, inside: false, outside: true
                         , includeHoles: false, combine: false
                         , chamfer_D: 0.1, chamfer_L: 0.1 });

var process = Cx.PenContour({ pens: [
  Cx.Pen({ width: 5, color:{ rgb: 'FF0000' } })
, Cx.Pen({ width: 3, color:{ rgb: '0000FF' } })
]});

var process = Cx.Shadow({ pen: Cx.Pen({ width: 2, color:{ rgb: '0000FF' } })
                        , brush: Cx.Brush({ color:{ rgb: 'FF0000' } })
                        , offsetX: 5, offsetY: 5, gap: 10, simplify: false });

var gap = Cx.RasterShadowGap({ pen: Cx.Pen({ width: 1, color:{ rgb: 'FFFFFF' } })} });
var process = Cx.RasterShadow({ pen: Cx.Pen({ width: 2, color:{ rgb: '0000FF' } })
                              , brush: Cx.Brush({ color:{ rgb: 'FF0000' } })
                              , offsetX: 5, offsetY: 5
                              , gap: gap };

var process = Cx.Effect3d({ borderIntensity: 0.7, borderSize: 1.0, contourOffset: 1.0
                          , lightGap: 2.0, lightIntensity: 0.7, lightSize: 3.0, lightSource: 'Up'
                          , shadowIntensity: 0.35, shadowSizePercentage: 0.95
                          , slopeIntensity: 0.3, slopeSize: 1.5});

var process = Cx.Extrude3D({ pen: Cx.Pen({ width: 2, color:{ rgb: '0000FF' } })
                           , brush: Cx.Brush({ color:{ rgb: 'FF0000' } })
                           , depth: 10, vanishingPoint: Px(0,0)
                           , rotationX: 0, rotationY: 0, rotationZ: 0 });

var process = Cx.Split({ overlap: 0, pos: 0.5, turn: 0, gap: 10 });

Cx.rasterize$( figures, { dpi: 25.4 } )
.then( function( rasters ){
  // ...
});

Cx.vectorize$( rasters, {
  backColors : [ 'FFFFFF' ]
, foreColors : [ '000000', 'FF0000' ]
, regionResolution: 6
, fitToCurveResolution: 7
})
.then( function( vectorFigures ) {

Cx.cutOutline$( figures, { offset: 10 })
.then( function( cutOutlineFigures ) {
  // ...

var f  = Cx.findByType(figures,type);
var fs = Cx.filterByType(figures,type);

Cx.forEachText(figures, function(text){ ... }, context);
Cx.forEachShape(figures, function(shape){ ... }, context);
Cx.forEachRaster(figures, function(raster){ ... }, context);
Cx.forEachGroup(figures, function(group){ ... }, context);
Cx.forEachProxyGroup(figures, function(proxyGroup){ ... }, context);

var cs = Cx.cloneDeep(figures);

Cx.Figure.setupClientProperties({
    fabricType          : { type: 'string', def: 'Cotton' }
  , highQualityPrinting : { type: 'boolean', def: false, dropDef:true }
  // , ... other properties
});

// In the client code
// getter
var ft = figure.fabricType() ; 
// setter
figure.fabricType('Linen');

Cx.Global.configurationVariableName = enabled; // true-or-false