diff --git a/Docs/En/App/App.md b/Docs/En/App/App.md
new file mode 100644
index 0000000..0376566
--- /dev/null
+++ b/Docs/En/App/App.md
@@ -0,0 +1,90 @@
+LibCanvas.App
+=============
+
+`LibCanvas.App` is the framework for building interactive applications on LibCanvas.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "App"
+
+### Initialization
+
+```js
+var app = new LibCanvas.App (object settings)
+```
+
+Settings can contain the following parameters:
+
+* `appendTo` - the element to which you want to add the application. The default is `body`
+* `size` - dimensions of the application window, object LibCanvas.Size
+* `simple` - if `true`, then it will generate a simplified layout - from one canvas, but without the ability to create and shift layers
+
+#### Example
+
+```js
+var app = new App ({
+ appendTo: '#container',
+ size: new Size (800, 500)
+})
+```
+
+#### Normal layout for three layers:
+
+```html
+
+```
+
+#### Simplified layout (maximum one layer):
+
+```html
+
+```
+
+#### Resizing an application:
+
+Only the size of the application will change, the size of each layer will remain the same.
+
+```js
+app.container.size = new Size (1500, 1200);
+```
+
+
+### Methods
+
+#### createLayer
+
+```js
+LibCanvas.App.Layer createLayer (object settings)
+```
+
+Creates and returns a LibCanvas.App
+
+```js
+var layer = app.createLayer ({name: 'units'});
+```
+
+#### destroy
+
+```js
+LibCanvas.App destroy ()
+```
+
+Destroys the application
+
+```js
+app.destroy ();
+```
+
+#### zIndexCompare
+
+```js
+int zIndexCompare (LibCanvas.App.Element left, LibCanvas.App.Element right)
+```
+
+Compares the position of each of the elements and returns -1 if the left is higher, +1 if the right is higher and 0 if they are on the same level
\ No newline at end of file
diff --git a/Docs/En/App/Element.md b/Docs/En/App/Element.md
new file mode 100644
index 0000000..6b3ada4
--- /dev/null
+++ b/Docs/En/App/Element.md
@@ -0,0 +1,136 @@
+LibCanvas.App.Element
+=====================
+
+`LibCanvas.App.Element` - abstract class-framework for creating elements that will be drawn
+
+Unlike other LibCanvas classes, this is used exclusively through inheritance.
+Our tool is to override it and create our own methods in the class of the heir:
+
+```js
+
+atom.declare ('Unit', App.Element, {
+ renderTo: function (ctx, resources) {
+ ctx.fill (this.shape, 'red');
+ }
+});
+
+new Unit (layer, {
+ shape: new Circle (100, 100, 50)
+});
+
+```
+
+### Built-in methods and properties
+
+`atom.Events events` - an object that listens to events
+`atom.Settings settings` is an object with settings. Basic properties:
+* `zIndex` - the order in which the element is rendered
+* `shape` is a shape that indicates an element
+* `hidden` (* boolean *) - hides or displays an element. Hiding via `hidden` is preferable to just empty rendering, because then the element does not participate in the miscalculation of collisions and its previous location is not erased.
+
+#### `redraw`
+
+`LibCanvas.App.Element redraw ()`
+
+A method that tells the application that the item has changed.
+Attention! The method itself does not redraw anything, it just puts the element in the queue for rendering.
+The call element is very fast and can be repeated painlessly many times per frame
+The method context is bound to the element, so that it can be passed as a collab without losing the context
+
+```js
+animate (element, {
+ color: 'red',
+ onChange: element.redraw
+})
+```
+
+#### `destroy`
+
+`LibCanvas.App.Element destroy ()`
+
+Removes an element from the context (but does not untie mouse events if you were signed via mouseHandler!)
+The method context is bound to the element, so that it can be passed as a collab without losing the context
+
+```js
+destroyButton.onclick = element.destroy;
+```
+
+### Methods to Override
+
+#### renderTo
+
+```js
+void renderTo (LibCanvas.Context2D ctx, atom.Registry resources)
+```
+
+Render element in the context. Describe in this method only renderer, but not object changes!
+By implication, calls the renderTo method of the renderer property if there is or nothing does
+
+```js
+
+atom.declare ('Unit', App.Element, {
+ renderTo: function (ctx, resources) {
+ ctx.fill (this.shape, 'red');
+ ctx.stroke (this.shape, 'blue');
+ }
+});
+
+```
+
+#### configure
+
+```js
+void configure ()
+```
+
+Called immediately after construction. Used in the successors of `App.Element` instead of the constructor
+
+#### get currentBoundingShape
+
+Getter, which returns a figure describing the effect of an element on the context. By default - a rectangle, in which is enclosed the `shape` element
+
+#### isTriggerPoint
+
+```js
+boolean isTriggerPoint (Point point)
+```
+
+Determines whether the point is a trigger point for a mouse or other input device. In an instinctive way - it checks for belonging to `shape`
+
+#### onUpdate
+
+```js
+void onUpdate (int time)
+```
+
+If the layer has an invoke, each frame is called and serves to change the properties of the object according to the time.
+In the argument `time`, the time in milliseconds passed from the last frame is transmitted to correct and unbind the speed of the application from the FPS
+
+```js
+
+atom.declare ('Unit', App.Element, {
+ onUpdate: function (time) {
+ // rotate at 90 degrees per second
+ this.rotate ((90) .degree () * time / 1000);
+
+ // since changes occur every frame - always cause the drawing
+ this.redraw ();
+ }
+});
+```
+
+#### clearPrevious
+
+```js
+void clearPrevious (LibCanvas.Context2D ctx)
+```
+
+Clears the previous location of the element in ctx. By default - erases `this.previousBoundingShape`
+
+#### distanceMove
+
+```js
+void distanceMove (LibCanvas.Point point)
+```
+
+Shifts the element to the `point` distance. Used, for example, in `App.Draggable`.
\ No newline at end of file
diff --git a/Docs/En/App/Layer.md b/Docs/En/App/Layer.md
new file mode 100644
index 0000000..4cc6746
--- /dev/null
+++ b/Docs/En/App/Layer.md
@@ -0,0 +1,116 @@
+LibCanvas.App.Layer
+===================
+
+`LibCanvas.App.Layer` - a class for creating layers of the LibCanvas application
+
+### Initialization
+
+It is created only with the help of the method `LibCanvas.App # createLayer`:
+
+```js
+LibCanvas.App.Layer app.createLayer (object settings);
+```
+
+Settings can contain the following parameters:
+
+* `name` (* string *) - the name of the layer (needed only for debugging)
+* `zIndex` (* number *) - z-index layer
+* `invoke` (* boolean *) - is it necessary to call the `onUpdate` method on each object every frame (by default `false`)
+* "intersection" - when redrawing one of the elements, it is necessary to redraw the rest. Values:
+ * `auto` (by default) - only those necessary for correct rendering
+ * `manual` - no, none (for example, when you want to personally manage the redrawing)
+ * `all` - yes, all (for example, if it is cheaper than calculating all the intersections)
+ * `full` - erase the entire canvas and draw everything from scratch
+
+#### Example
+
+```js
+var layer = app.createLayer ({
+ name: 'units',
+ zIndex: 3,
+ invoke: true,
+ intersection: 'all'
+})
+```
+
+#### Resizing the layer
+
+Only the size of the specified layer will change. The size of the application and other layers will remain the same.
+Remember that changing the size of the layer will destroy all the rendered data, so you need to call `layer.redrawAll ()`
+
+```js
+layer.dom.size = new Size (1500, 1200);
+layer.redrawAll ()
+```
+
+### Properties
+
+#### ctx
+
+`2d-libcanvas` context of the canvas element of the layer
+
+```js
+layer.ctx.fillAll ('red')
+```
+
+### Methods
+
+#### stop
+
+```js
+LibCanvas.App.Layer stop ()
+```
+
+Stop drawing layer
+
+```js
+layer.stop ()
+```
+
+#### start
+
+```js
+LibCanvas.App.Layer start ()
+```
+
+Resume layer rendering
+
+```js
+layer.start ()
+```
+
+#### hide
+
+```js
+LibCanvas.App.Layer hide ()
+```
+
+Temporarily hide the layer
+
+```js
+layer.hide ()
+```
+
+#### show
+
+```js
+LibCanvas.App.Layer show ()
+```
+
+Re-show layer
+
+```js
+layer.show ()
+```
+
+#### redrawAll
+
+```js
+LibCanvas.App.Layer redrawAll ()
+```
+
+Redraws all layer elements
+
+```js
+layer.redrawAll ()
+```
\ No newline at end of file
diff --git a/Docs/En/App/Light/Light.md b/Docs/En/App/Light/Light.md
new file mode 100644
index 0000000..0de1e1a
--- /dev/null
+++ b/Docs/En/App/Light/Light.md
@@ -0,0 +1,75 @@
+LibCanvas.App.Light
+===================
+
+`LibCanvas.App.Light` - add-on above `LibCanvas.App` for a lighter and more accessible interface
+
+### Initialization
+
+```js
+var helper = new LibCanvas.App.Light (LibCanvas.Size size, object settings)
+```
+
+`size` - the size of the application
+
+Settings can contain the following parameters:
+
+* `mouse` - whether the mouse will be used (by default `true`)
+* `appendTo` - which element you want to attach the application to (default is `body`)
+
+#### Example
+
+```js
+var helper = new LibCanvas.App.Light (new Size (800, 500))
+```
+
+### Methods
+
+#### createVector
+
+```js
+App.Light.Vector createVector (LibCanvas.Shape shape, object settings)
+```
+
+Creates, adds to the application, and returns the App.Light.Vector element, which serves to draw geometric shapes in the application
+
+```js
+var vector = helper.createVector (new Circle (100, 100, 20));
+```
+
+#### createText
+
+```js
+App.Light.Text createText (LibCanvas.Shape shape, object style, object settings)
+```
+
+Creates, adds to the application, and returns an App.Light.Text element, which serves to draw text in the application
+The contents of `style` according to the interface of the method [Context2D.text] (https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Core/Context2D.md#%D0%9C%D0%B5%D1% 82% D0% BE% D0% B4-text)
+
+```js
+var text = helper.createText (
+ new Rectangle (0, 0, 100, 40),
+ {
+ text: 'Hello, World!',
+ bold: true
+ }
+);
+```
+
+#### createImage
+
+```js
+App.Light.Image createImage (LibCanvas.Shape shape, Image image, object settings)
+```
+
+Creates, adds to the application and returns the element App.Light.Image, which serves to draw pictures in the application
+
+```js
+
+atom.ImagePreloader.run ({logo: 'html5-logo.png'},
+ function (images) {
+ var element = helper.createImage (
+ new Rectangle (64, 64, 256, 256),
+ images.get ('logo')
+ );
+});
+```
\ No newline at end of file
diff --git a/Docs/En/App/MouseHandler.md b/Docs/En/App/MouseHandler.md
new file mode 100644
index 0000000..eae1719
--- /dev/null
+++ b/Docs/En/App/MouseHandler.md
@@ -0,0 +1,128 @@
+LibCanvas.App.MouseHandler
+==========================
+
+`LibCanvas.App.MouseHandler` - a class that is responsible for the relationship of the events of LibCanvas.Mouse and the objects LibCanvas.App.Element.
+
+### Initialization
+
+```js
+LibCanvas.App.MouseHandler (object settings);
+```
+
+Settings can contain the following parameters:
+
+* `app` (* LibCanvas.App *) is the application you need to listen to
+* `mouse` (* LibCanvas.Mouse *) is a LibCanvas.Mouse object that will notify you about mouse changes
+* `search` (* LibCanvas.App.ElementsMouseSearch *) - you can specify an alternative object that is responsible for finding a triggered element, can be used for optimization
+
+#### Example
+
+```js
+var app, mouse, mouseHandler;
+
+app = new LibCanvas.App ({size: new Size (300,200)});
+mouse = new LibCanvas.Mouse (app.container.bounds);
+mouseHandler = new LibCanvas.App.MouseHandler ({app: app, mouse: mouse});
+```
+
+The default search engine (LibCanvas.App.ElementsMouseSearch) checks the elements for triggering by calling `isTriggerPoint (Point)`
+
+### Developments
+
+After subscription, all items receive the following events:
+
+* click
+* dblclick
+* contextmenu
+* wheel
+* mousedown
+* mouseup
+* mouseout
+* mouseover
+* mousemove
+
+### Methods
+
+#### stop
+
+```js
+LibCanvas.App.MouseHandler stop ()
+```
+
+Stop processing mouse events
+
+```js
+mouseHandler.stop ()
+```
+
+#### start
+
+```js
+LibCanvas.App.MouseHandler start ()
+```
+
+Resume mouse event processing
+
+```js
+mouseHandler.start ()
+```
+
+#### subscribe
+
+```js
+LibCanvas.App.MouseHandler subscribe (LibCanvas.App.Element element)
+```
+
+Sign the item for mouse events.
+
+```js
+mouseHandler.subscribe (element);
+
+element.events.add ('click', function (e) {
+ console.log ('element caught mouse click', e);
+})
+```
+
+#### unsubscribe
+
+```js
+LibCanvas.App.MouseHandler unsubscribe (LibCanvas.App.Element element)
+```
+
+Deselect an element from mouse events. If the item was deleted from the application using the "destroy" method, the mouse event response will be activated automatically the first time the event is triggered (but not immediately after the destruction). Hidden through `hidden: true` elements still receive mouse events.
+
+```js
+mouseHandler.unsubscribe (element);
+// Element no longer catches mouse events
+```
+
+#### getOverElements
+
+```js
+LibCanvas.App.Element [] getOverElements ()
+```
+
+Get a list of items on which the mouse is located at the moment (in decreasing order of z-index)
+
+```js
+var overElements = mouseHandler.getOverElements ();
+overElements.invoke ('destroy');
+```
+
+#### fall
+
+```js
+LibCanvas.App.MouseHandler fall ()
+```
+
+Tells you to fail the mouse event. It is important to remember that if an element is subscribed to mouse events, it "blocks" all the items below. That is, when you click on it, events will not work on the elements under it, even if they also fall into the range of the mouse. If for some reason this behavior does not suit (the element should catch the events itself, but also do not block them for the elements that it covers), you can use "failing":
+
+```js
+mouseHandler.subscribe (element);
+
+element.events.add ('mousedown', function (e) {
+ console.log ('Mouse pressed over our element', e);
+ // But the element under it will also receive this event
+ mouseHandler.fall ();
+});
+```
\ No newline at end of file
diff --git a/Docs/En/Core/Canvas.md b/Docs/En/Core/Canvas.md
new file mode 100644
index 0000000..4c3ce72
--- /dev/null
+++ b/Docs/En/Core/Canvas.md
@@ -0,0 +1,86 @@
+Creating your own contexts
+=========================
+
+Improving the prototype HTMLCanvasElement makes it easy to create your own contexts with LibCanvas.
+It is enough to call `HTMLCanvasElement.addContext (name, ContextClass)`, where `ContextClass` is a class with a constructor that takes the first argument to a link to the canvas element.
+
+#### Example
+
+```js
+new function () {
+ var ContextClass = atom.declare ({
+ initialize: function (canvas) {
+ this.canvas = canvas;
+ this.ctx2d = canvas.getContext ('2d');
+ },
+ welcome: function () {
+ this.ctx2d.fillText ('Hello World', 0, 0);
+ }
+ });
+
+ HTMLCanvasElement.addContext ('2d-hello', ContextClass);
+}
+```
+
+#### Usage:
+
+```js
+var myContext = canvas.getContext ('2d-hello');
+myContext.welcome ();
+myContext.fillRect (0, 0, 10, 10); // Error
+```
+
+The standard context methods are not implemented, so `fillRect` will return an error.
+The easiest way to avoid this is to inherit from the context of LibCanvas.
+Note - we inherited the constructor from the parent `LibCanvas.Context2D`, so it's enough to implement the methods.
+
+#### Example
+
+```js
+new function () {
+ var HelloContextClass = atom.declare (LibCanvas.Context2D, {
+ welcome: function () {
+ return this.ctx2d.fillText ('Hello World', 0, 0);
+ }
+ });
+
+ HTMLCanvasElement.addContext ('2d-libcanvas-hello', HelloContextClass);
+}
+```
+
+#### Usage:
+
+```js
+var myContext = canvas.getContext ('2d-libcanvas-hello');
+myContext.welcome ();
+myContext.fillRect (0, 0, 10, 10); // Success
+```
+
+It is desirable in the title to indicate the hierarchy of contexts in descending order, through a dash.
+
+#### Canvas2DContext
+You can use the plugin `Canvas2DContext` to create your own context on the basis of native (with the most similar interface)
+
+```js
+new function () {
+ var HelloContextClass = atom.declare (LibCanvas.Canvas2DContext, {
+ welcome: function () {
+ return this.ctx2d.fillText ('Hello World', 0, 0);
+ }
+ });
+
+ HTMLCanvasElement.addContext ('2d-hello', HelloContextClass);
+}
+```
+
+#### Usage:
+
+```js
+var myContext = canvas.getContext ('2d-hello');
+myContext.welcome ();
+myContext.fillRect (0, 0, 10, 10); // Success
+```
+
+### Attention!
+It is highly recommended not to override the built-in browser contexts (which you can still get through the `getOriginalContext` method), since this will bring very unexpected behavior to the application.
+It is also not recommended to redefine the context of `2d-libcanvas`
\ No newline at end of file
diff --git a/Docs/En/Core/Context2D.md b/Docs/En/Core/Context2D.md
new file mode 100644
index 0000000..769fb78
--- /dev/null
+++ b/Docs/En/Core/Context2D.md
@@ -0,0 +1,580 @@
+LibCanvas.Context2D
+===================
+
+`LibCanvas.Context2D` is a considerably extended standard 2d-context, which can be obtained as follows:
+
+```js
+var context = canvas.getContext ('2d-libcanvas');
+// alternate syntax:
+var context = new LibCanvas.Context2D (canvas);
+```
+
+His main idea is all methods, if there is no other need to return a context reference for use in the chains of calls, the possibility of using named arguments and the use of LibCanvas objects.
+
+In addition, it provides many non-standard methods.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Context2D"
+
+## Properties
+
+### canvas (get)
+Reference to parent dom-element
+
+### width (get / set)
+Returns / changes the width of the canvas
+
+### height (get / set)
+Returns / changes the height of the canvas
+
+### size (get / set)
+Returns / changes the height of the canvas
+
+```js
+context.size = new Size (400, 250);
+```
+
+### rectangle (get)
+Returns a reference to a rectangle that matches the canvas dimensions
+It is highly not recommended to work directly with this object. If necessary, use a clone.
+
+#### Example
+
+```js
+if (context.rectangle.hasPoint (somePoint)) {
+ // The point is within the canvas
+ doSmth ();
+}
+
+// Change the Rectangle
+var clone = context.rectangle.clone ();
+
+clone.height /= 2;
+clone.width /= 2;
+
+context.fillAll (clone, 'red');
+```
+
+### shadow (get / set)
+Allows you to get / set the shadowOffsetX, shadowOffsetY, shadowBlur, and shadowColor properties in a laconic way
+
+#### Example
+
+```js
+context.shadow = '1 2 3 black';
+
+// Analog:
+context.shadowOffsetX = 1;
+context.shadowOffsetY = 2;
+context.shadowBlur = 3;
+context.shadowColor = 'black';
+```
+
+## The getClone method
+
+```js
+HTMLCanvasElement getClone (int width, int height)
+```
+
+Returns a canvas that is equal to the image and with the resized size, if width and height are specified
+It can be used to create a copy of the current layer, a small icon, etc.
+
+#### Example
+
+```js
+context.drawImage (context.getClone (64, 48));
+```
+
+## set method
+
+```js
+[this] set (object properties)
+[this] set (string propertyName, string propertyValue)
+```
+
+Specifies the canvas properties
+
+#### Example
+
+```js
+context
+.set ({
+ fillStyle: 'black',
+ strokeStyle: 'blue'
+})
+.set ('globalOpacity', 0.5);
+```
+
+## The get method
+
+```js
+string get (string propertyName)
+```
+
+Get property values
+
+#### Example
+
+```js
+context.get ('fillStyle');
+```
+
+## The fillAll method
+
+```js
+[this] fillAll ()
+[this] fillAll (string fillStyle)
+```
+
+Fills the entire canvas with fillStyle color or default color, if no argument is passed
+
+#### Example
+
+```js
+context.fillAll ('red');
+```
+
+## The strokeAll method
+
+```js
+[this] strokeAll ()
+[this] strokeAll (string strokeStyle)
+```
+
+Draws the whole canvas with strokeStyle color or default color, if no argument is passed
+
+#### Example
+
+```js
+context.strokeAll ('rgb (255, 245, 200)');
+```
+
+## The clearAll method
+
+```js
+[this] clearAll ()
+```
+
+Cleans the canvas
+
+#### Example
+
+```js
+context.clearAll ();
+```
+
+## The fill method
+
+```js
+[this] fill ()
+[this] fill (string fillStyle)
+[this] fill (Shape shape)
+[this] fill (Shape shape, string fillStyle)
+```
+
+Fills the shape or current path with fillStyle color or default color, if no argument is passed
+
+#### Example
+
+```js
+context.fill (new Circle (50, 50, 20), 'red');
+```
+
+## Method stroke
+
+```js
+[this] stroke ()
+[this] stroke (string fillStyle)
+[this] stroke (Shape shape)
+[this] stroke (Shape shape, string fillStyle)
+```
+
+Draws a shape or current path with strokeStyle color or default color, if no argument is passed
+
+#### Example
+
+```js
+context.stroke (new Circle (50, 50, 20), 'red');
+```
+
+## Method clear
+
+```js
+[this] clear (Shape shape)
+```
+
+Clears the shape passed by the first argument. (anti-aliasing - off!)
+
+## The fillRect method
+
+```js
+[this] fillRect (LibCanvas.Shapes.Rectangle rectangle)
+[this] fillRect (int fromX, int fromY, int width, int height)
+```
+
+## The strokeRect method
+
+```js
+[this] strokeRect (LibCanvas.Shapes.Rectangle rectangle)
+[this] strokeRect (int fromX, int fromY, int width, int height)
+```
+
+## The clearRect method
+
+```js
+[this] clearRect (LibCanvas.Shapes.Rectangle rectangle)
+[this] clearRect (int fromX, int fromY, int width, int height)
+```
+
+#### Example
+
+```js
+context.clear (new Circle (50, 50, 20));
+```
+
+## Methods save / restore
+
+```js
+[this] save ()
+```
+
+Saves the canvas settings to the stack
+
+```js
+[this] restore ()
+```
+
+Restores the last saved canvas settings
+
+#### Example
+
+```js
+context.set ({fillStyle: 'blue'});
+context.save ();
+context.set ({fillStyle: 'red'});
+context.fillAll (); // fill everything in red
+context.restore ();
+context.fillAll (); // fill everything in blue
+```
+
+# Create a path
+
+## The beginPath method
+
+```js
+[this] beginPath ()
+[this] beginPath (point)
+[this] beginPath (int x, int y)
+```
+
+Opens the path. If there are arguments, it calls the `moveTo` method
+
+## The closePath method
+
+```js
+[this] closePath ()
+[this] closePath (LibCanvas.Point point)
+[this] closePath (int x, int y)
+```
+
+Closes the path. If there are arguments, it calls the `lineTo` method
+
+## moveTo
+
+```js
+[this] moveTo (LibCanvas.Point point);
+[this] moveTo (int x, int y);
+```
+
+Moves the path pointer to the point
+
+## The lineTo method
+
+```js
+[this] lineTo (LibCanvas.Point point);
+[this] lineTo (int x, int y);
+```
+
+Puts the line to the point
+
+## Method arc
+
+```js
+[this] lineTo (object params);
+```
+
+Make an arc
+
+#### Options
+
+`circle` (* LibCanvas.Shapes.Circle *) - the circle on which you want to draw an arc
+
+`angle` (* object *) is the angle that the arc draws. Two of three parameters are required:
+
+* `start` (* int *) - where the arc begins (in radians)
+* `end` (* int *) - where the arc ends (in radians)
+* `size` (* int *) - the size of the arc (in radians)
+
+If an array of two elements is transferred, it is assumed that the first is start, and the second is end
+
+`anticlockwise` or `acw` - if specified in true, then the direction of movement is counter-clockwise
+
+#### Example
+
+```js
+context.arc ({
+ circle: new LibCanvas.Shapes.Circle (50, 50, 25),
+ angle: [(30) .degree (), (60) .degree ()]
+});
+```
+
+## The curveTo method
+
+```js
+[this] curveTo (object params);
+```
+
+Draws the Bezier curve on the control points.
+
+#### Options
+
+`to` (* LibCanvas.Point *) - where to plot the curve
+
+`point` (* LibCanvas.Point [] *) - an array of control points. Maybe two, one or not.
+
+#### Example
+
+```js
+context.curveTo ({
+ to: [100, 100],
+ points: [
+ [80, 30],
+ [20, 90]
+ ]
+});
+```
+// is equivalent to
+
+```js
+context.bezierCurveTo (80, 30, 20, 90, 100, 100);
+```
+
+## The isPointInPath method
+
+```js
+boolean isPointInPath (LibCanvas.Point point);
+boolean isPointInPath (int x, int y);
+```
+
+Checks if the given point is within the painted path
+
+#### Example
+
+```js
+context.isPointInPath ([15, 20]);
+```
+
+## The clip method
+
+```js
+[this] clip ();
+[this] clip (LibCanvas.Shape shape);
+```
+
+Limits drawing to canvas by a certain area.
+If the `shape` argument is not passed, the current path will be used
+
+#### Example
+
+```js
+// everything outside the circle will not be reflected
+context.clip (new Circle (100, 100, 50));
+context.fillRect (100, 100, 100, 100);
+```
+
+## Rotate method
+
+```js
+[this] rotate (number angle);
+[this] rotate (number angle, LibCanvas.Point pivot);
+```
+
+## The translate method
+
+```js
+[this] translate (LibCanvas.Point point)
+[this] translate (LibCanvas.Point point, boolean reverse)
+[this] translate (int x, int y)
+```
+
+## Method text
+
+```js
+[this] text (object params)
+```
+
+#### Options
+
+`text` (* string *)
+
+`color` (* string *)
+
+`stroke` (* bool, default = false *) if the parameter = true, then canvas.fillStyle () calls canvas.strokeStyle,
+that is, the "text stroke" mode is turned on, while the text itself remains transparent. If you want to draw text,
+and stroke the text, you must first call the text method with stroke = true, and then again with stroke = false.
+
+`lineWidth` (* int *) specifies the thickness of the stroke stroke line for stroke = true, while carefully checking
+result - some browsers render strokes of complex letters (w, m, n, etc) with artifacts and, probably, have to play
+with stroke width / text size
+
+`wrap` (* string *) no | normal
+
+`to` (* LibCanvas.Shapes.Rectangle *) by default calls this.getFullRectangle
+
+`align` (* string *) center | left | right
+
+`size` (* int, default = 16 *)
+
+`weight` (* string *) bold | normal
+
+`style` (* string *) italic | normal
+
+`family` (* string *, default = sans-serif)
+
+`lineHeight` (* int *)
+
+`overflow` (* string *, default = visible) hidden | visible
+
+`padding` (* int | int [] *, default = 0) [topBottom, leftRight]
+
+`shadow` (* string *) turns on the mode of shadow rendering for text. The format is as in canvas: `` shadowOffsetX, shadowOffsetY, shadowBlur, shadowColor'.
+For example: `shadow: '0 -1 3 # 616161'`. Do not forget to specify the color with the '#' character, Chrome will show it, but there are no other browsers :).
+
+## The drawImage method
+
+```js
+[this] drawImage (element image)
+[this] drawImage (object params)
+```
+
+#### Options
+
+Only one of the `from`, `center`, `draw` options is required
+
+`image` (* element *) the image you are about to draw
+
+`from` (* LibCanvas.Point *) is the top left point from which to draw the picture
+
+`center` (* LibCanvas.Point *) is the center point from which to draw the picture
+
+`draw` (* LibCanvas.Shapes.Rectangle *) The rectangle in which to draw the picture. The image is scaled to the size of the polygon.
+
+`crop` (* LibCanvas.Shapes.Rectangle *) is a rectangle that points to the part of the image you want to cut (applies only when using draw)
+
+`angle` (* int *) the angle of the picture in radians
+
+`scale` (* LibCanvas.Point *) resize the picture. Can be used to reflect images vertically or horizontally
+
+The principle is simple - if there is a `draw` and `crop`, then `crop` to the picture is first applied, then it is placed according to `from | center | draw`, then it rotates around the center at an angle angle clockwise and so is drawn.
+
+#### Example
+
+```js
+context.drawImage ({
+ image: this.image,
+ center: this.position,
+ angle: this.angle
+});
+
+context.drawImage ({
+ image: canvas,
+ crop: [100, 100, 50, 50],
+ draw: [250, 250, 50, 50]
+});
+
+context.drawImage ({
+ image: this.image,
+ from: this.from,
+ scale: new Point (-1, 1) // flipX
+});
+```
+
+## ProjectiveImage method
+###### testing
+
+```js
+[this] projectiveImage (object params)
+```
+
+## The getPixel method
+
+```js
+[this] getPixel (LibCanvas.Point point)
+```
+
+Returns the pixel color value at the point point in the format {r: [0, 255], g: [0, 255], b: [0, 255], a: [0, 1]}
+You can pass the argument to the Color constructor.
+
+#### Example
+
+```js
+mouse.events.add ('click', function () {
+ var pixel = ctx.getPixel (mouse.point);
+ trace (new atom.Color (pixel));
+});
+
+mouse.events.add ('click', function () {
+ var pixel = ctx.getPixel (mouse.point);
+
+ pixel.a> 0.1?
+ alert ('Pixel is visible'):
+ alert ('Pixel is invisible');
+});
+```
+
+## The createGradient method
+
+```js
+[RadialGradient] createGradient (Circle from, Circle to, Object colors)
+[LinearGradient] createGradient (Point from, Point to, Object colors)
+[LinearGradient] createGradient (Rectangle rect, Object colors)
+```
+
+Creates and returns a radial or linear gradient with the stop colors specified in colors
+
+```js
+context.createGradient (context.rectangle, {
+ '0.0': 'red',
+ '0.5': 'blue',
+ '1.0': 'green'
+});
+
+context.createGradient (
+ new Circle (50, 50, 10),
+ new Circle (50, 50, 20), {
+ '0.0': 'red',
+ '0.5': 'blue',
+ '1.0': 'green'
+});
+```
+
+## The createRectangleGradient method
+
+//// todo
+
+# The following methods repeat the methods from the original context:
+ * scale
+ * transform
+ * setTransform
+ * fillText
+ * strokeText
+ * measureText
+ * createImageData
+ * putImageData
+ * getImageData
+ * getPixels
+ * createLinearGradient
+ * createRadialGradient
+ * createPattern
+ * drawWindow
\ No newline at end of file
diff --git a/Docs/En/Core/LibCanvas.md b/Docs/En/Core/LibCanvas.md
new file mode 100644
index 0000000..b2b91da
--- /dev/null
+++ b/Docs/En/Core/LibCanvas.md
@@ -0,0 +1,48 @@
+LibCanvas
+=========
+
+`LibCanvas` is a global object that is the root of the library namespace. It contains several static methods
+
+
+## Static method extract
+
+```js
+object LibCanvas.extract (object to = window)
+```
+
+Allows you to extract some LibCanvas classes to the global namespace (or to a local object) for a shorter record
+
+#### Example
+
+```js
+// Standard approach:
+var circle = new LibCanvas.Shapes.Circle (100, 100, 20);
+
+// Extract to local variable
+var LC = LibCanvas.extract ({});
+var circle = new LC.Circle (100, 100, 20);
+
+// Extract to the global namespace:
+LibCanvas.extract ();
+var circle = new Circle (100, 100, 20);
+```
+
+## Static buffer
+
+```js
+canvasElement LibCanvas.buffer (int width, int height, bool withCtx)
+canvasElement LibCanvas.buffer (LibCanvas.Size size, bool withCtx)
+```
+
+Creates and returns a Canvas element of size width * height.
+If withCtx is true, then the element's `ctx` property will be equal to the context '2d-libcanvas'
+
+
+#### Example
+
+```js
+var buffer = LibCanvas.buffer (100, 100, true);
+buffer.ctx.fillAll ('black');
+
+libcanvas.ctx.drawImage (buffer, 10, 10);
+```
\ No newline at end of file
diff --git a/Docs/En/Core/Mouse.md b/Docs/En/Core/Mouse.md
new file mode 100644
index 0000000..62e39f9
--- /dev/null
+++ b/Docs/En/Core/Mouse.md
@@ -0,0 +1,83 @@
+LibCanvas.Mouse
+===============
+
+`LibCanvas.Mouse` provides an interface for transparent mouse control
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Mouse"
+
+## Static properties
+
+#### method prevent
+
+Can use to silence the mouse event by default:
+
+```js
+window.onclick = Mouse.prevent;
+```
+
+#### method getOffset
+
+```js
+LibCanvas.Point getOffset (MouseEvent e, DOMElement element)
+```
+
+Determines the position of the mouse relative to the element
+
+```js
+var offset = Mouse.getOffset (event, canvas);
+```
+
+#### method addWheelDelta
+
+```js
+MouseEvent addWheelDelta (MouseEvent e)
+```
+
+Adds the cross-browser property `delta` to the event object, which indicates the direction of movement of the mouse wheel
+
+## Creating an instance of LibCanvas.Mouse
+
+The first argument is an element whose events should be listened to.
+
+```js
+var mouse = new LibCanvas.Mouse (myCanvas);
+```
+
+## Properties
+
+`point` - `LibCanvas.Point`, with the current coordinates of the mouse relative to the beginning of the element
+
+`previous` - `LibCanvas.Point`, the previous coordinates of the mouse relative to the beginning of the element
+
+`delta` - `LibCanvas.Point`, the last offset of the coordinates of the mouse
+
+`events` - the object `atom.Events`
+
+## Developments
+
+* click
+* dblclick
+* contextmenu
+* wheel
+* over
+* out
+* down
+* up
+* move
+
+#### Example
+
+```js
+mouse.events.add ('click', function (event, mouse) {
+ // draw a circle with a radius of 10 pixels at the click point:
+ canvas.ctx.fill (
+ new Circle (mouse.point, 10)
+ );
+});
+```
+
+#### Features
+
+The `wheel` event has an additional property `delta`, which is indicated by the direction of movement of the wheel - "-1" or "1".
\ No newline at end of file
diff --git a/Docs/En/Core/Point.md b/Docs/En/Core/Point.md
new file mode 100644
index 0000000..d217f56
--- /dev/null
+++ b/Docs/En/Core/Point.md
@@ -0,0 +1,283 @@
+LibCanvas.Point
+===============
+
+`LibCanvas.Point` is one of the bases in the LibCanvas library. It builds many calculations, simple figures, drawing the result.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Point"
+
+## Creating an instance of LibCanvas.Point
+You can create an instance of the class `LibCanvas.Point` in one of the following ways:
+
+```js
+var xCoord = 15, yCoord = 20;
+
+// passing coordinates to the constructor
+var point = new LibCanvas.Point (xCoord, yCoord);
+
+// array of coordinates
+var point = new LibCanvas.Point ([xCoord, yCoord]);
+
+// coordinate object
+var point = new LibCanvas.Point ({x: xCoord, y: yCoord});
+
+// Another LibCanvas.Point object
+var point = new LibCanvas.Point (anotherPoint);
+
+// which is equivalent to
+var point = anotherPoint.clone ();
+
+// after using LibCanvas.extract ():
+var point = new Point (xCoord, yCoord);
+```
+
+## The equals method
+
+```js
+boolean equals (LibCanvas.Point to, int accuracy)
+```
+
+The method compares two points not by reference
+
+#### argument `accuracy`
+
+If specified, it means the number of characters, with the accuracy of which the points will be compared (for inaccurate comparison)
+
+#### Example
+
+```js
+var bar = new LibCanvas.Point (15, 15);
+var foo = new LibCanvas.Point (15, 15);
+
+trace (bar == foo); // false
+trace (bar.equals (foo)); // true
+```
+
+#### Example of accuracy
+
+```js
+var bar = new LibCanvas.Point (12.88888324, 15.1111127);
+var foo = new LibCanvas.Point (12.88888115, 15.1111093);
+
+console.log (bar == foo); // false
+console.log (bar.equals (foo)); // false
+console.log (bar.equals (foo, 8)); // false
+console.log (bar.equals (foo, 4)); // true
+```
+
+## The clone method
+
+```js
+LibCanvas.Point clone ()
+```
+
+Returns a point with the same coordinates
+
+#### Example
+
+```js
+var point = new LibCanvas.Point (15, 15);
+var clone = point.clone ();
+console.log (point == clone); // false
+console.log (point.equals (clone)); // true
+```
+
+## The move method
+
+```js
+LibCanvas.Point move (LibCanvas.Point distance, boolean reverse = false)
+```
+
+#### Example
+
+```js
+var point = new LibCanvas.Point (10, 10);
+var distance = new LibCanvas.Point (5, -3);
+
+point.move (distance, false); // Point (15, 7)
+point.move (distance, true); // Point (5, 13)
+```
+
+#### Returns `this`
+
+## moveTo
+
+```js
+LibCanvas.Point moveTo (LibCanvas.Point point)
+```
+
+#### Example
+
+```js
+var start = new LibCanvas.Point (100, 100);
+var finish = new LibCanvas.Point (800, 800);
+// just move point to end
+start.moveTo (finish);
+```
+
+#### Returns `this`
+
+## angleTo method
+
+```js
+int angleTo (LibCanvas.Point point)
+```
+
+#### Example
+
+```js
+var pO = new LibCanvas.Point (10, 10);
+var pA = new LibCanvas.Point (15, 15);
+
+var angle = pA.angleTo (pO); // 0.785 (in radians)
+angle.getDegree () == 45; // in degrees
+```
+
+## DistanceTo method
+
+```js
+int distanceTo (LibCanvas.Point point)
+```
+
+#### Example
+
+```js
+var pO = new LibCanvas.Point (10, 10);
+var pA = new LibCanvas.Point (15, 15);
+
+pA.distanceTo (pO); // 7.071
+```
+
+## diff
+
+```js
+LibCanvas.Point diff (LibCanvas.Point point)
+```
+
+This method means roughly the following:
+how much you need to move the point, so that it is in place of the one that is passed by the first argument
+
+#### Example
+
+```js
+var pO = new LibCanvas.Point (10, 10);
+var pA = new LibCanvas.Point (15, 18);
+
+pA.diff (pO); // Point (-5, -8)
+```
+
+## Rotate method
+
+```js
+LibCanvas.Point rotate (int angle, LibCanvas.Point pivot = {x: 0, y: 0})
+```
+
+Undo a point by angle degrees around the axis pivot
+
+#### Example
+
+```js
+var pO = new LibCanvas.Point (10, 10);
+var pA = new LibCanvas.Point (20, 10);
+
+pA.rotate ((90) .degree (), pO); // Point (10, 20)
+```
+
+#### Returns `this`
+
+## Method scale
+
+```js
+LibCanvas.Point scale (int power, LibCanvas.Point pivot = Point (0, 0))
+```
+
+Increases the distance from the `pivot` point in `power` times
+
+#### Example
+
+```js
+var pO = new LibCanvas.Point (10, 10);
+var pA = new LibCanvas.Point (20, 15);
+pA.scale (2, pO); // Point (30, 20)
+```
+
+#### Returns `this`
+
+## Method getNeighbour
+
+```js
+LibCanvas.Point scale (string direction)
+```
+
+Returns the next point.
+
+#### argument `direction`
+can take one of the following values:
+
+`t` - returns a point from the top
+
+`r` - returns the point to the right
+
+`b` - returns a point from below
+
+`l` - returns a point on the left
+
+`tl` - returns a point from top to left
+
+`tr` - returns a point from the top to the right
+
+`bl` - returns a point from the bottom to the left
+
+`br` - returns a point from the bottom to the right
+
+#### Example
+
+```js
+var pA = new LibCanvas.Point (15, 15);
+pA.getNeighbor ('t'); // Point (15, 14)
+pA.getNeighbour ('bl'); // Point (14, 16)
+```
+
+## ToObject Method
+
+```js
+Object toObject ()
+```
+
+Returns a hash with the coordinates of the point
+
+#### Example
+
+```js
+var bar = new LibCanvas.Point (12, 15);
+var foo = bar.toObject ();
+// similar to foo = {x: 12, y: 15}
+```
+
+## method checkDistanceTo
+
+```js
+boolean checkDistanceTo (Point point, number distance, boolean equals = false)
+```
+
+Checks that the distance to the point is less than `distance` or is equal to, if `equals = true`.
+The method is a faster analogue of the verification via `distanceTo`:
+
+#### Example
+
+```js
+// Distance is 5
+var foo = new LibCanvas.Point (12, 15);
+var bar = new LibCanvas.Point (16, 18);
+
+// Strict check
+foo.checkDistanceTo (bar, 5); // false
+// analog:
+foo.distanceTo (bar) <5 // false
+
+// Nondestructive check
+foo.checkDistanceTo (bar, 5, true); // false
+// analog:
+foo.distanceTo (bar) <= 5 // true
+```
\ No newline at end of file
diff --git a/Docs/En/Core/Point3D.md b/Docs/En/Core/Point3D.md
new file mode 100644
index 0000000..ab8d254
--- /dev/null
+++ b/Docs/En/Core/Point3D.md
@@ -0,0 +1,175 @@
+LibCanvas.Point3D
+=================
+
+`LibCanvas.Point3D` is a class that describes a point in three-dimensional space.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Point3D"
+
+## Creating an instance of LibCanvas.Point3D
+
+
+You can create an instance of the class `LibCanvas.Point` in one of the following ways:
+
+```js
+var xCoord = 15, yCoord = 20, zCoord = 25;
+
+// passing coordinates to the constructor
+var point = new LibCanvas.Point3D (xCoord, yCoord, zCoord);
+
+// array of coordinates
+var point = new LibCanvas.Point3D ([xCoord, yCoord, zCoord]);
+
+// coordinate object
+var point = new LibCanvas.Point3D ({x: xCoord, y: yCoord, z: zCoord});
+
+// Another LibCanvas.Point3D object
+var point = new LibCanvas.Point3D (anotherPoint);
+
+// which is equivalent to
+var point = anotherPoint.clone ();
+
+// after using LibCanvas.extract ():
+var point = new Point3D (xCoord, yCoord, zCoord);
+```
+
+## The equals method
+
+```js
+boolean equals (LibCanvas.Point3D to, int accuracy)
+```
+
+The method compares two points not by reference
+
+#### argument `accuracy`
+
+If specified, it means the number of characters, with the accuracy of which the points will be compared (for inaccurate comparison)
+
+#### Example
+
+```js
+var bar = new LibCanvas.Point3D (15, 15, 10);
+var foo = new LibCanvas.Point3D (15, 15, 10);
+
+trace (bar == foo); // false
+trace (bar.equals (foo)); // true
+```
+
+#### Example of accuracy
+
+```js
+var bar = new LibCanvas.Point3D (7, 12.88888324, 15.1111127);
+var foo = new LibCanvas.Point3D (7, 12.88888115, 15.1111093);
+
+console.log (bar == foo); // false
+console.log (bar.equals (foo)); // false
+console.log (bar.equals (foo, 8)); // false
+console.log (bar.equals (foo, 4)); // true
+```
+
+## The clone method
+
+```js
+LibCanvas.Point3D clone ()
+```
+
+Returns a point with the same coordinates
+
+#### Example
+
+```js
+var point = new LibCanvas.Point3D (15, 15, 10);
+var clone = point.clone ();
+console.log (point == clone); // false
+console.log (point.equals (clone)); // true
+```
+
+## The move method
+
+```js
+LibCanvas.Point move (LibCanvas.Point point3d)
+```
+
+#### Example
+
+```js
+var point = new LibCanvas.Point3D (10, 10, 10);
+var distance = new LibCanvas.Point3D (5, -3, 1);
+
+point.move (distance); // Point3D (15, 7, 11)
+```
+
+## diff
+
+```js
+LibCanvas.Point3D diff (LibCanvas.Point3D point)
+```
+
+This method means roughly the following:
+how much you need to move the point, so that it is in place of the one that is passed by the first argument
+
+#### Example
+
+```js
+var pO = new LibCanvas.Point3D (10, 10, 7);
+var pA = new LibCanvas.Point3D (15, 18, 7);
+
+pA.diff (pO); // Point3D (-5, -8, 0)
+```
+
+## The map method
+
+```js
+LibCanvas.Point3D map (callback, context)
+```
+
+Changes the point values according to the callback result
+
+#### Example
+
+```js
+var point = new LibCanvas.Point3D (1, 2, 3);
+
+point.map (function (value, coord, point) {
+ return value * value;
+});
+
+atom.trace (point); // Point3D (1, 4, 9)
+```
+
+## The add method
+
+```js
+LibCanvas.Point3D add (value)
+```
+
+Increase the value of all the coordinates of the point on `value`
+
+#### Example
+
+```js
+var point = new LibCanvas.Point3D (1, 2, 3);
+
+point.add (5);
+
+atom.trace (point); // Point3D (6, 7, 8)
+```
+
+## The mul method
+
+```js
+LibCanvas.Point3D mul (value)
+```
+
+Multiply the value of all point coordinates by `value`
+
+#### Example
+
+```js
+var point = new LibCanvas.Point3D (1, 2, 3);
+
+point.mul (5);
+
+atom.trace (point); // Point3D (5, 10, 15)
+```
\ No newline at end of file
diff --git a/Docs/En/Core/Size.md b/Docs/En/Core/Size.md
new file mode 100644
index 0000000..e8903aa
--- /dev/null
+++ b/Docs/En/Core/Size.md
@@ -0,0 +1,12 @@
+LibCanvas.Size
+==============
+
+`LibCanvas.Size` is an extension of `LibCanvas.Point`, it has the same properties, but `width` is an alias for `x`, and `height` is an alias for `y`.
+
+```js
+var size = new LibCanvas.Size ({width: 15, height: 35});
+```
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Size"
\ No newline at end of file
diff --git a/Docs/En/Engines/Hex/Projection.md b/Docs/En/Engines/Hex/Projection.md
new file mode 100644
index 0000000..32468df
--- /dev/null
+++ b/Docs/En/Engines/Hex/Projection.md
@@ -0,0 +1,259 @@
+Engines.Hex.Projection
+=====================
+
+Provides an easy way to transform rgb-hex coordinates into 2-d coordinates and back.
+Note that rgb-coordinates for hex-grid representation are a powerful, unambiguous and fast solution.
+At first it may seem less familiar than usual x-y coordinates, but after work everything will change.
+
+#### Coordinates
+
+When navigating the map, the coordinates change as follows:
+
+* `g + 1, b-1` - go up
+* `g-1, b + 1` - down
+* `r-1, g + 1` - left-up
+* `r-1, b + 1` - left-down
+* `r + 1, b-1` - right-up
+* `r + 1, g-1` - right-down
+
+The basic rule is that the sum of the three coordinates must be zero, that is:
+
+```js
+r + g + b = 0
+```
+
+! [Example of a grid of coordinates] (https://raw.github.com/theshock/libcanvas/master/Docs/Ru/Engines/Hex/hex-coords.png)
+
+#### Cell Size
+
+The size of each hex is given by three parameters:
+
+* `baseLength` - width of the main side
+* `hexHeight` - hex height
+* `chordLength` - width of the side triangle
+
+! [Hex dimensions] (https://raw.github.com/theshock/libcanvas/master/Docs/Ru/Engines/Hex/hex-sizes.png)
+
+If it is necessary to obtain an equilateral hex with a side length K, we get the following values:
+
+```js
+baseLength = K
+chordLength = K * sin (30) = K / 2
+hexHeight = K * cos (30) * 2 = K * 1.732
+```
+
+For example:
+
+```js
+baseLength = 56
+chordLength = 28
+hexHeight = 97
+```
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "HexEngine.Projection"
+
+### Initialization
+
+```js
+var projection = new HexEngine.Projection (object settings)
+```
+
+Settings can contain the following parameters:
+
+* Dimensions of hex (described above):
+* `baseLength`
+* `chordLength`
+* `hexHeight`
+* `start` - the point to be considered as the center of the hex [0: 0: 0]
+
+If `chordLength == null` or `hexHeight == null`, then they are computed from `baseLength` to create an equilateral polygon.
+
+### Methods
+
+#### isZero
+
+```js
+bool isZero (int [] coordinates)
+```
+
+Checks whether coordinates are coordinates of the central hex ([0,0,0])
+
+```js
+projection.isZero ([0, 0, 0]); // true
+projection.isZero ([- 1, -1, 2]); // false
+```
+
+#### rgbToPoint
+
+```js
+Point rgbToPoint (int [] coordinates)
+```
+
+Returns the center of the hex from the array of its rgb-coordinates. Can be used, for example, to place a unit on the center of the hex on the canvas
+
+```js
+var center = projection.rgbToPoint ([0, 0, 0]);
+var center = projection.rgbToPoint ([5, 2, -7]);
+```
+
+
+#### pointToRgb
+
+```js
+int [] rgbToPoint (Point point)
+```
+
+Returns the rgb-coordinates of the hex according to the point `point`. The point can be anywhere in the hex, not necessarily in the center. It can be used, for example, to find out over which hex the mouse is located:
+
+```js
+var coordArray = projection.pointToRgb (new Point (100, 50));
+
+// Track which hex the mouse is on:
+var trace = atom.trace ();
+
+mouse.events.add ('move', function () {
+trace.value = projection.pointToRgb (mouse.point);
+});
+```
+
+#### createPolygon
+
+```js
+Polygon createPolygon (Point center)
+```
+
+Returns a polygon of six points that describes the hex. Can be used for vector rendering of hex on the canvas:
+
+```js
+var centerPoint = projection.rgbToPoint ([1, -1, 0]);
+var polygon = projection.createPolygon (centerPolygon);
+
+ctx.fill (polygon, 'white');
+ctx.stroke (polygon, 'black');
+```
+
+#### sizes
+
+```js
+HexEngine.Projection.Sizes sizes (Number padding = 0);
+```
+
+Returns the object `HexEngine.Projection.Sizes`
+
+```js
+var sizes = projection.sizes ();
+```
+
+HexEngine.Projection.Sizes
+===========================
+
+An object that is designed to determine the dimensions of a hexagonal map according to its parameters and hex coordinates. It is important that the map can be asymmetric. It is created only using the `HexProjection.Sizes # sizes` method.
+
+```js
+var sizes = projection.sizes ();
+```
+
+#### add
+
+```js
+HexEngine.Projection.Sizes add (int [] coordinates)
+```
+
+Adds coordinates to the map
+
+```js
+sizes
+.add ([0, 0, 0])
+.add ([1, -1, 0])
+.add ([1, 0, -1])
+.add ([-1, 1, 0])
+.add ([-1, 0, 1])
+.add ([0, 1, -1])
+.add ([0, -1, 1])
+.add ([0, -2, 2])
+```
+
+#### size
+
+```js
+Size size ()
+```
+
+Returns the size of the canvas needed to hold the map including the `padding` indents.
+
+```js
+var size = sizes.size ();
+```
+
+#### center
+
+```js
+Point center ()
+```
+
+Returns an arrangement of zero hex at which the map fits perfectly into the dimensions returned by the `size`
+
+```js
+var center = sizes.center ();
+```
+
+Sharing
+========================
+
+What if we need to create a canvas of minimal size, but at the same time, so that the hexagonal map fits into it exactly? It's very simple:
+
+```js
+// We have a list of hexes that need to be drawn:
+var hexes = [
+ [0, 0, 0],
+ [1, -1, 0],
+ [1, 0, -1],
+ [-1, 1, 0],
+ [-1, 0, 1],
+ [0, 1, -1],
+ [0, -1, 1],
+ [0, -2, 2],
+ [1, -2, 1],
+ [2, -2, 0]
+];
+
+// create a projection of the required size, the center is not specified
+var projection = new HexEngine.Projection ({
+ baseLength: 40,
+ chordLength: 20,
+ hexHeight: 50
+});
+
+// Create a size object and add all hexes to it:
+// The offset from the map boundaries will be 8
+var sizes = projection.sizes (8);
+hexes.forEach (function (coord) {
+ sizes.add (coord);
+});
+
+// Now we can set the coordinates of the zero hex:
+projection.settings.set ({start: sizes.center ()});
+
+// Create a buffer of the required size, to which we will draw our hexes:
+var buffer = LibCanvas.buffer (sizes.size (), true);
+
+// Draw hexes:
+hexes.forEach (function (coord) {
+ var poly = projection.createPolygon (
+ projection.rgbToPoint (coord)
+ );
+
+ // We want to see which hex is central
+ var fillColor = projection.isZero (coord)
+ ? 'white'
+ : ['red', 'green', 'blue'].random
+
+ buffer.ctx.fill (poly, fillColor);
+ buffer.ctx.stroke (poly, 'white');
+});
+
+// display the buffer:
+atom.dom (buffer) .appendTo ('body');
+```
\ No newline at end of file
diff --git a/Docs/En/Engines/Hex/hex-coords.png b/Docs/En/Engines/Hex/hex-coords.png
new file mode 100644
index 0000000..195719d
Binary files /dev/null and b/Docs/En/Engines/Hex/hex-coords.png differ
diff --git a/Docs/En/Engines/Hex/hex-sizes.png b/Docs/En/Engines/Hex/hex-sizes.png
new file mode 100644
index 0000000..f4c14e4
Binary files /dev/null and b/Docs/En/Engines/Hex/hex-sizes.png differ
diff --git a/Docs/En/Engines/Isometric/Projection.md b/Docs/En/Engines/Isometric/Projection.md
new file mode 100644
index 0000000..198adb9
--- /dev/null
+++ b/Docs/En/Engines/Isometric/Projection.md
@@ -0,0 +1,156 @@
+Engines.Hex.Isometric
+=====================
+
+Library for working with isometric projection of 3d coordinates.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "IsometricEngine"
+
+IsometricEngine.Projection
+==========================
+
+It is an easy possibility to translate coordinates from 3d-coordinates in space into isometric 2d-coordinates and back.
+
+#### Coordinates
+
+Coordinates are broadcast very simply. A positive shift along the X axis shifts the point up and to the right, and a positive shift along the Y axis - down-right. A positive shift along the Z axis moves the point exactly upwards.
+
+! [Isometric map] (https://raw.github.com/theshock/libcanvas/master/Docs/Ru/Engines/Isometric/iso.png)
+
+#### The pixel size
+
+There are different approaches to the transformation of pixels. Correct isometric projection requires an angle of 30 degrees, but often in computer games a more acute angle is used, so that the cell's proportions are 2: 1. The value of "factor" corresponds to this value:
+
+```js
+factor: new Point3D (0.866, 0.5, 0.866) // the correct projection
+factor: new Point3D (1, 0.5, 1) // proportional projection
+```
+
+The first value is responsible for the width of the pixel in the X coordinate, the second - for the width of the pixel in the Y coordinate, the third - for the height of the Z coordinate.
+
+You can also proportionally change the pixel by setting the `size`
+
+The `start` option is required to specify the start coordinates (where the pixel [0; 0; 0] is located).
+
+Example:
+
+```js
+var projection = new IsometricEngine.Projection ({
+ factor: new Point3D (1, 0.5, 1), // the map will be proportional
+ size: 2, // increment the pixels twice
+ start: new Point (100, 100) // the grid begins with a slight indent
+});
+```
+
+### Methods
+
+#### toIsometric
+
+```js
+Point toIsometric (Point3D point3d)
+```
+
+Translates the coordinates of a point from three-dimensional in space to two-dimensional on the screen. Used, for example, when drawing.
+
+```js
+var playersCoord = [
+ new Point3D (100, 50, 10),
+ new Point3D (80, 20, 0),
+ new Point3D (20, 130, 4)
+];
+
+playersCoord.forEach (function (coord3d) {
+ ctx.fill (new Circle (
+ projection.toIsometric (coord3d), 10
+ ));
+});
+```
+
+#### to3D
+
+```js
+Point3D to3D (Point point3d [, int z = 0])
+```
+
+Translates the coordinates of a point from two-dimensional on the screen into three-dimensional in space. Can be used to determine the coordinate of the field when the mouse is clicked. Because it is impossible to determine at what height the current point is located - you can use an optional argument.
+
+```js
+mouse.events.add ('click', function (e) {
+ var mapCoord = projection.to3d (mouse.point);
+
+ atom.trace (mapCoord);
+});
+```
+
+#### Example
+
+```js
+atom.dom (function () {
+ function point (x, y, z) {
+ return projection.toIsometric (new Point3D (x, y, z));
+ }
+
+ function createColor (x, y) {
+ // Color will be calculated dynamically
+ // atom.Color will make sure that we do not get out of bounds
+ // If you move along the X axis, the cell will be redder
+ // If you move along the Y axis, the cell will be less green
+ // As the difference between X and Y increases, the cell will lose its blue
+ // Bottom line: left cell - green, right - pink, bottom - blue, upper - yellow
+ return new atom.Color (128 + 24 * x, 255 - 24 * y, 128-24 * (x-y)). toString ();
+ }
+
+ function drawPoly (x, y) {
+ // create a polygon from 4 neighboring points. The height in the example is always zero
+ var poly = new Polygon (
+ point (x + 0, y + 0,0),
+ point (x + 0, y + 1.0),
+ point (x + 1, y + 1.0),
+ point (x + 1, y + 0,0)
+ );
+
+ buffer.ctx
+ .fill (poly, createColor (x, y))
+ .stroke (poly);
+
+ buffer.ctx.fillText (x + '/' + y, poly.center);
+ }
+
+ function drawMap (width, height) {
+ var x, y;
+ for (x = 0; x cell.point.y)? 'red': 'blue';
+
+ ctx.fill (cell.rectangle, color);
+ }
+});
+```
+
+#### countSize
+
+```js
+Size countSize ()
+```
+
+Calculate the size of the tile field in pixels according to the field size, cell size and indentation
+
+```js
+var canvas = LibCanvas.buffer (engine.countSize (), true)
+```
+
+#### refresh
+
+```js
+TileEngine refresh (Context2D ctx, Point translate = null)
+```
+
+Redraw the cells that have changed since the last refresh.
+Before the first drawing, the all-cells are considered to have changed
+If necessary, you can set the offset of the image
+
+```js
+engine.refresh (canvas.ctx, new Point (100, 100))
+```
+
+#### getCellByIndex
+
+```js
+TileEngine.Cell getCellByIndex (Point point)
+```
+
+Return the cell to the corresponding coordinates of the field
+
+```js
+engine.getCellByIndex (new Point (3, 1))
+```
+
+#### getCellByPoint
+
+```js
+TileEngine.Cell getCellByPoint (Point point)
+```
+
+Return the cell to the corresponding coordinates in pixels
+
+```js
+engine.getCellByPoint (new Point (743, 351))
+```
\ No newline at end of file
diff --git a/Docs/En/Plugins/Animation/Animation.md b/Docs/En/Plugins/Animation/Animation.md
new file mode 100644
index 0000000..e23c5e7
--- /dev/null
+++ b/Docs/En/Plugins/Animation/Animation.md
@@ -0,0 +1,125 @@
+Plugins.Animation
+=================
+
+Class for creating one case of animation playback based on the `Plugins.Animation.Sheet` prototype
+
+### Initialization
+
+```js
+new Animation (object settings)
+```
+
+Settings can contain the following parameters:
+
+* `sheet` (* Animation.Sheet *) - the prototype of animation
+
+```js
+animation = new Animation ({
+ sheet: this.animationSheet,
+ onUpdate: this.redraw,
+ onStop: this.destroy,
+});
+```
+
+### Developments
+
+`update` - is called when an animation frame is switched or when an animation is launched
+
+`stop` - it is called when the animation ends with the last frame or when forced by the `stop` method
+
+### Methods
+
+#### stop
+
+```js
+Animation stop ();
+```
+
+Stop animation
+
+```js
+animation.stop ();
+```
+
+#### run
+
+```js
+Animation run ();
+```
+
+Start the animation first.
+
+```js
+animation.run ();
+```
+
+#### synchronize
+
+```js
+Animation synchronize ();
+```
+
+Synchronize the start of the animation with another animation.
+
+```js
+fooAnimation.synchronize (coreAnimation);
+barAnimation.synchronize (coreAnimation);
+
+coreAnimation.run ();
+
+// fooAnimation.startTime == barAnimation.startTime == coreAnimation.startTime
+```
+
+#### get
+
+```js
+Animation get ();
+```
+
+Get the current animation frame or `null` if the animation is stopped, has run out or is not running.
+
+```js
+var frame = animation.get ();
+```
+
+### A complex example based on LibCanvas.App
+
+```js
+
+/ ** @class ExplosionLauncher * /
+atom.declare ('ExplosionLauncher', {
+ initialize: function (layer, images) {
+ this.layer = layer;
+
+ this.animationSheet = new Animation.Sheet ({
+ frames: new Animation.Frames (images.get ('explosion'), 50, 50),
+ delay: 40
+ })
+ },
+
+ explode: function (coordinates) {
+ new Explosion (this.layer, {
+ sheet: this.animationSheet,
+ shape: new Circle (coordinates, 50)
+ });
+ }
+});
+
+/ ** @class Explosion * /
+atom.declare ('Explosion', App.Element, {
+ configure: function () {
+ this.animation = new Animation ({
+ sheet: this.settings.get ('sheet'),
+ onUpdate: this.redraw,
+ onStop: this.destroy,
+ });
+ },
+
+ renderTo: function (ctx) {
+ ctx.drawImage ({
+ image: this.animation.get (),
+ center: this.shape.center
+ });
+ }
+});
+```
\ No newline at end of file
diff --git a/Docs/En/Plugins/Animation/Frames.md b/Docs/En/Plugins/Animation/Frames.md
new file mode 100644
index 0000000..04f73d6
--- /dev/null
+++ b/Docs/En/Plugins/Animation/Frames.md
@@ -0,0 +1,44 @@
+Plugins.Animation.Frames
+========================
+
+A class that is used to "cut" pictures from one tile picture.
+Typically, animation frames are similar to each other and it makes sense to put them together into a single image like css-sprites.
+Let's say you have an animation frame width of 50 pixels, a height of 40, 15 frames. You can draw them in three rows in a picture size of 250 * 120.
+
+! [An example of cutting animation frames] (https://raw.github.com/theshock/libcanvas/master/Docs/Ru/Plugins/Animation/frames-demo.png)
+
+### Initialization
+
+```js
+new Animation.Frames (Image image, int width = null, int height = null)
+```
+
+* `image` (* Image *) - source image for cutting
+* `width` (* int *) - the width of the frame. Equal to the width of the picture, if `null`
+* `height` (* int *) - the height of the frame. The height of the picture is equal, if `null`
+
+
+```js
+var frames = new Animation.Frames (images.get ('ship'), 100);
+```
+
+### Methods
+
+`get length` - number of frames in the array
+
+```js
+console.log (frames.length);
+```
+
+
+#### get
+
+```js
+canvasElement get (int index);
+```
+
+Returns the picture-frame, part of the original picture.
+
+```js
+var frame = frames.get (5);
+```
\ No newline at end of file
diff --git a/Docs/En/Plugins/Animation/Image.md b/Docs/En/Plugins/Animation/Image.md
new file mode 100644
index 0000000..7b182a9
--- /dev/null
+++ b/Docs/En/Plugins/Animation/Image.md
@@ -0,0 +1,23 @@
+Plugins.Animation.Element
+=========================
+
+The class that is used to create a picture-animation for insertion into a dom-tree
+
+```js
+atom.dom Animation.Image.element (Animation animation);
+atom.dom Animation.Image.element (Animation.Sheet sheet);
+```
+
+### Example
+
+```js
+function appendAnimatedLogoTo (targetElement) {
+ var logoSheet = new Animation.Sheet ({
+ frames: new Animation.Frames (images.get ('logo'), 50, 50),
+ delay: 40,
+ looped: true
+ });
+
+ Animation.Image.element (logoSheet) .appendTo (targetElement);
+}
+```
\ No newline at end of file
diff --git a/Docs/En/Plugins/Animation/Sheet.md b/Docs/En/Plugins/Animation/Sheet.md
new file mode 100644
index 0000000..c59268e
--- /dev/null
+++ b/Docs/En/Plugins/Animation/Sheet.md
@@ -0,0 +1,27 @@
+Plugins.Animation.Sheet
+=======================
+
+A class for describing the animation, its prototype from which all objects will be repelled.
+Describes the delay between frames, their fixation and the order of playback. It is a technical class whose entities are used only for passing settings to the animation class.
+
+### Initialization
+
+```js
+new Animation.Sheet (object settings)
+```
+
+Settings can contain the following parameters:
+
+* `frames` (* Animation.Frames *) - the list of source frames to be combined into an animation
+* `delay` (* int *) - the delay between frames in milliseconds
+* `looped` (* bool *) - whether the animation is looped or ends with the after frame
+* `sequence` (* int [] *) - the order of frames (by default - from the first to the last frame of the animation)
+
+```js
+new Animation.Sheet ({
+ frames: new Animation.Frames (sourceImage),
+ delay: 40,
+ looped: true,
+ sequence: [0,1,1,2,1,2,2,3,4,5,4,5]
+})
+```
\ No newline at end of file
diff --git a/Docs/En/Plugins/Animation/frames-demo.png b/Docs/En/Plugins/Animation/frames-demo.png
new file mode 100644
index 0000000..188ee88
Binary files /dev/null and b/Docs/En/Plugins/Animation/frames-demo.png differ
diff --git a/Docs/En/Plugins/Curve/Curve.md b/Docs/En/Plugins/Curve/Curve.md
new file mode 100644
index 0000000..90569ad
--- /dev/null
+++ b/Docs/En/Plugins/Curve/Curve.md
@@ -0,0 +1,60 @@
+Plugins.Curve
+=============
+
+The mathematical basis for the Bezier Curves. Can be used to create motion animations along the way and for other purposes.
+
+### Initialization
+
+```js
+// Quadratic curve, one control point
+var curve = new LibCanvas.Plugins.Curve ({
+ from: new Point (100, 100),
+ to: new Point (200, 300),
+ points: [
+ new Point (200, 100)
+ ]
+});
+
+// Qubic curve, two control points
+var curve = new LibCanvas.Plugins.Curve ({
+ from: new Point (100, 100),
+ to: new Point (200, 300),
+ points: [
+ new Point (200, 100),
+ new Point (100, 200),
+ ]
+});
+```
+
+* `from` (* LibCanvas.Point *) - the starting point of the curve
+* `to` (* LibCanvas.Point *) - the end point of the curve
+* `points` (* LibCanvas.Point [] *) - an array of control points of the curve
+
+### Methods
+
+#### getPoint
+
+```js
+LibCanvas.Point getPoint (float t)
+```
+
+`t` is a number between 0 and 1. Returns the coordinates of a point of a line.
+
+
+```js
+var point = curve.getPoint (0.45)
+```
+
+
+#### getAngle
+
+```js
+float getAngle (float t)
+```
+
+`t` is a number between 0 and 1. Returns the angle of the curve at the appropriate place
+
+
+```js
+var angle = curve.getAngle (0.45)
+```
\ No newline at end of file
diff --git a/Docs/En/Plugins/Curve/Curves.md b/Docs/En/Plugins/Curve/Curves.md
new file mode 100644
index 0000000..4369018
--- /dev/null
+++ b/Docs/En/Plugins/Curve/Curves.md
@@ -0,0 +1,45 @@
+Plugins.Curves
+==============
+
+Drawing bezier curves with dynamic width and color. Extends the built-in Context2D object ('2d-libcanvas'), providing a convenient method `drawCurve`
+
+! [libcanvas curves example] (https://raw.github.com/theshock/libcanvas/master/Docs/Ru/Plugins/curves.png)
+
+### Initialization
+
+```js
+Context2D drawCurve (object params)
+```
+
+* `from` (* Point *) - the starting point of the curve
+* `to` (* Point *) - the end point of the curve
+* `points` (* Point [] *) - an array of control points. Can contain 0, 1 or 2 points
+* `inverted` (* Boolean *) - adds" ribbon "(see screenshot above)
+* `gradient` (* object *) - describes a smooth change in the color of the curve
+* `from` (* string *) - initial color
+* `to` (* string *) - the final color
+* `fn` (* string *) - color change function (see [atom.Transition] (https://github.com/theshock/atomjs/blob/master/Docs/En/Declare/Transition.md))
+* `width` (* object *) - describes a smooth change in the color of the curve
+* `from` (* number *) - initial width
+* `to` (* number *) - initial width
+* `fn` (* string *) - the function of changing the width (see [atom.Transition] (https://github.com/theshock/atomjs/blob/master/Docs/En/Declare/Transition.md))
+
+```js
+
+ctx.drawCurve ({
+ from: new Point (100, 250),
+ to: new Point (200, 100),
+ points: [new Point (100, 100), new Point (250, 250)],
+ inverted: true,
+ gradient: {
+ from: '# ff0',
+ to: '# f00',
+ fn: 'linear'
+ },
+ width: {
+ from: 30,
+ to: 1,
+ fn: 'sine-in'
+ }
+});
+```
\ No newline at end of file
diff --git a/Docs/En/Plugins/Curve/curves.png b/Docs/En/Plugins/Curve/curves.png
new file mode 100644
index 0000000..1d3ad3c
Binary files /dev/null and b/Docs/En/Plugins/Curve/curves.png differ
diff --git a/Docs/En/Shapes/Circle.md b/Docs/En/Shapes/Circle.md
new file mode 100644
index 0000000..0bf2308
--- /dev/null
+++ b/Docs/En/Shapes/Circle.md
@@ -0,0 +1,210 @@
+Circle
+======
+`LibCanvas.Shapes.Circle` is a class that describes a simple geometric figure "circle"
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Circle"
+
+## Creating an instance of LibCanvas.Shapes.Circle
+
+```js
+var circle = new LibCanvas.Shapes.Circle (centerX, centerY, radius);
+
+var circle = new LibCanvas.Shapes.Circle (centerPoint, radius);
+
+var circle = new LibCanvas.Shapes.circle ({
+ center: centerPoint,
+ radius: toPoint
+});
+```
+
+Do not forget about passing objects by reference:
+
+```js
+var circle = new LibCanvas.Shapes.Circle (point, 10);
+circle.center.x = 100;
+alert (point.x); // 100
+```
+
+If necessary, this behavior can be avoided by passing a point clone
+
+```js
+var circle = new LibCanvas.Shapes.Circle (center.clone (), radius);
+```
+
+## HasPoint Method
+
+```js
+bool hasPoint (LibCanvas.Point point);
+```
+
+Returns true if the point is inside the circle
+
+#### Example
+
+```js
+var circle = new LibCanvas.Shapes.Circle ({
+ center: [25, 25],
+ radius: 15
+});
+circle.hasPoint (new Point (22, 24)); // true
+circle.hasPoint (new Point (88, 88)); // false
+```
+
+## The move method
+
+```js
+LibCanvas.Shapes.Center move (LibCanvas.Point distance, bool reverse);
+```
+
+Calls the move method at the center
+
+#### Example
+
+```js
+var circle = new LibCanvas.Shapes.Circle ({
+ center: [25, 25],
+ radius: 15
+});
+circle.move ({x: 2, y: 3});
+// circle.center == Point (27, 28)
+```
+
+#### Returns `this`
+
+## The intersect method
+
+```js
+bool intersect (LibCanvas.Shape shape);
+```
+
+Checks the intersection of two figures. Exact if `shape` is a circle and through boundingRectangle if `shape` is another shape.
+
+#### Example
+
+```js
+var circleA = new Circle (25, 25, 15);
+var circleB = new Circle (30, 30, 10);
+circleA.intersect (circleB); // true
+```
+
+## Method scale
+
+```js
+Circle scale (number power, LibCanvas.Point pivot);
+```
+
+Increases the circle in `power` times relative to the point `pivot` or relative to the center of the circle
+
+#### Example
+
+```js
+var circle = new Circle (30, 30, 10);
+
+circle.scale (2);
+
+// Increase the circle twice:
+//
+// var circle = new Circle (30, 30, 20);
+```
+
+#### Returns `this`
+
+
+## The draw method
+
+```js
+Circle draw (LibCanvas.Context2D ctx, String type);
+```
+
+Draws a circle to the context using the current settings
+
+#### argument `type`
+Method of rendering. It can take the values `fill`, `stroke`, `clear`
+
+#### Example
+
+```js
+var circle = new Circle (100, 100, 20);
+
+var ctx = canvasElem
+.getContext ('2d-libcanvas')
+.set ({
+ 'fillStyle': 'red',
+ 'strokeStyle': 'black'
+});
+// Fill the circle with the red in the context
+circle.draw (ctx, 'fill');
+// Circle the circle in the context
+circle.draw (ctx, 'stroke');
+```
+
+But this method is recommended to be used only if for some reason the following is not available:
+
+```js
+var ctx = canvasElem
+.getContext ('2d-libcanvas')
+.fill (circle, 'red')
+.stroke (circle, 'black');
+```
+
+#### Returns `this`
+
+## The processPath method
+
+```js
+Circle processPath (LibCanvas.Context2D ctx, bool noWrap = false)
+```
+
+Passes the path using `ctx.arc`
+
+#### the argument `noWrap`
+if specified in false (by default), then frames with `beginPath`, `endPath`
+
+#### Example
+
+```js
+new Circle (100, 150, 30) .processPath (ctx);
+
+// is equivalent to:
+
+ctx
+.beginPath ()
+.arc (100, 150, 30, 0, Math.PI * 2, false)
+.closePath ();
+```
+
+## The clone method
+
+```js
+Circle clone ()
+```
+
+Returns a new circle with the same radius and cloned center
+
+#### Example
+
+```js
+var circle = new Circle (100, 150, 30);
+
+var circleClone = circle.clone ();
+```
+
+## The equals method
+
+```js
+Circle equals (Circle circle)
+```
+
+Checks if two circles are equal
+
+#### Example
+
+```js
+var circleA = new Circle (100, 150, 30);
+var circleB = new Circle (100, 150, 30);
+
+console.log (circleA == circleB); // false
+console.log (circleA.equals (circleB)); // true
+```
\ No newline at end of file
diff --git a/Docs/En/Shapes/Ellipse.md b/Docs/En/Shapes/Ellipse.md
new file mode 100644
index 0000000..d590ba0
--- /dev/null
+++ b/Docs/En/Shapes/Ellipse.md
@@ -0,0 +1,29 @@
+LibCanvas.Shapes.Ellipse
+========================
+
+`Ellipse` is the heir of the figure` Rectangle`. Draws an ellipse in the rectangle described by the `from` and `to` points
+
+```js
+var ellipse = new Ellipse ({from: [10, 10], to: [100, 50]});
+```
+
+[Usage Example] (http://libcanvas.github.com/shapes/ellipse.html)
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Ellipse"
+
+## Properties
+
+### angle
+Angle of rotation of the ellipse. Essence - an ellipse inscribed in a rectangle, and then deployed around the center to the property `angle`
+
+## Rotate method
+
+```js
+LibCanvas.Shapes.Ellipse rotate (int degree)
+```
+
+Rotates the ellipse to `degree` around the center.
+
+#### Returns `this`
\ No newline at end of file
diff --git a/Docs/En/Shapes/Line.md b/Docs/En/Shapes/Line.md
new file mode 100644
index 0000000..cef555d
--- /dev/null
+++ b/Docs/En/Shapes/Line.md
@@ -0,0 +1,207 @@
+LibCanvas.Shapes.Line
+=====================
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Line"
+
+## Creating an instance of LibCanvas.Shapes.Line
+
+```js
+// two points LibCanvas.Point - where and where
+var line = new LibCanvas.Shapes.Line (fromPoint, toPoint);
+
+// the parameter object
+var line = new LibCanvas.Shapes.Line ({
+ from: fromPoint,
+ to: toPoint
+});
+```
+
+Do not forget that points are passed by reference, because if you declared line through two points, when you change the point inside the line, the original points will also change.
+
+```js
+var line = new Line (fromPoint, toPoint);
+line.from.x = 100;
+alert (fromPoint.x); // 100
+```
+
+If necessary, this behavior can be avoided by passing point clones
+
+```js
+var line = new LibCanvas.Shapes.Line (fromPoint.clone (), toPoint.clone ());
+```
+
+Or cloning the line:
+
+```js
+var line = new LibCanvas.Shapes.Line (fromPoint, toPoint) .clone ();
+```
+
+## Properties
+
+### length (get)
+Get the length of the line
+
+### center (get)
+Creates a new point with coordinates that correspond to the center of the line
+
+```js
+var line = new Line ({
+ from: [10, 10],
+ to: [20, 20]
+});
+line.center; // Point (15, 15)
+```
+
+## HasPoint Method
+
+```js
+bool hasPoint (LibCanvas.Point point);
+```
+
+Returns true if the point is on the line
+
+#### Example
+
+```js
+var line = new LibCanvas.Shapes.Line ({
+ from: [4, 4],
+ to: [8, 8]
+});
+line.hasPoint ([6, 6]); // true
+line.hasPoint ([2, 5]); // false
+```
+
+## The move method
+
+```js
+LibCanvas.Shapes.Line move (LibCanvas.Point distance, bool reverse);
+```
+
+Calls the move method of both points
+
+#### Example
+
+```js
+var line = new LibCanvas.Shapes.Line ({
+from: [4, 4],
+to: [8, 8]
+});
+line.move ({x: 2, y: 3});
+// line.from == Point (6, 7)
+// line.to == Point (10, 11)
+```
+
+#### Returns `this`
+
+## The processPath method
+
+```js
+LibCanvas.Context2D processPath (LibCanvas.Context2D ctx, bool noWrap = false)
+```
+
+Paves the way with the help from the `from` point using `ctx.moveTo` to the `to` point using `ctx.lineTo`
+
+#### the argument `noWrap`
+if specified in false (by default), then frames with beginPath, endPath
+
+#### Example
+
+```js
+LibCanvas.Shapes.Line ({
+ from: [4, 4],
+ to: [8, 8]
+}).processPath(ctx);
+
+// is equivalent to c:
+ctx.beginPath ()
+ .moveTo (4, 4) // line.from
+ .lineTo (8, 8) // line.to
+ .closePath ();
+```
+
+#### Returns `this`
+
+## The perpendicular method
+
+```js
+LibCanvas.Point perpendicular (LibCanvas.Point point)
+```
+
+Returns the perpendicular of the point `point` to the current line
+
+#### Example
+
+```js
+var line = new LibCanvas.Shapes.Line ([0,3], [4,0]);
+var point = new LibCanvas.Point (0, 0);
+
+line.perpendicular (point); // Point (1.44, 1.92)
+```
+
+## The intersect method
+
+```js
+bool intersect (LibCanvas.Shapes.Line line)
+LibCanvas.Point intersect (LibCanvas.Shapes.Line line, true)
+```
+
+Determines the intersection of a line with another line. If the `point` parameter is `true`, then the intersection point or `null` will return, if it is not present, `true` or `false` will return.
+
+```js
+var first = new Line ([10, 10], [20, 20]);
+var second = new Line ([10, 20], [20, 10]);
+
+trace (first.intersect (second)); // true
+trace (first.intersect (second, true)); // Point (15, 15)
+```
+
+## DistanceTo method
+
+```js
+Number distanceTo (LibCanvas.Point point, boolean asInfinitiveLine)
+```
+
+Specifies the distance between the line and the point `point`. If `asInfinitiveLine = true`, then the line will be considered an infinite straight line, otherwise - a line.
+
+```js
+var line = new Line (10, 10, 20, 20),
+ point = new Point (41, 40);
+
+line.distanceTo (point); // 29
+line.distanceTo (point, true); // 0.7071
+```
+
+## The equals method
+
+```js
+bool equals (LibCanvas.Shapes.Line line, int accuracy)
+```
+
+Compare line points using the LibCanvas.Point.equals method
+
+
+```js
+var foo = new LibCanvas.Shapes.Line (15, 20, 10, 5);
+var bar = new LibCanvas.Shapes.Line (15, 20, 10, 5);
+
+trace (bar == foo); // false
+trace (bar.equals (foo)); // true
+```
+
+## The clone method
+
+```js
+LibCanvas.Shapes.Line clone ()
+```
+
+Returns a line with the same coordinates
+
+```js
+var line = new LibCanvas.Shapes.Line (15, 20, 10, 5);
+var clone = line.clone ();
+
+trace (line == clone); // false
+trace (line.equals (clone)); // true
+```
\ No newline at end of file
diff --git a/Docs/En/Shapes/Path.md b/Docs/En/Shapes/Path.md
new file mode 100644
index 0000000..362f960
--- /dev/null
+++ b/Docs/En/Shapes/Path.md
@@ -0,0 +1,280 @@
+Path
+====
+
+`LibCanvas.Shapes.Path` - used to create shapes based on Bezier curves.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Path"
+
+## Creating an instance of LibCanvas.Shapes.Path
+
+```js
+var polygon = new LibCanvas.Shapes.Path ();
+```
+
+#### Example
+
+```js
+var path = new Path ();
+```
+
+## get length
+
+Returns the number of steps in the path:
+
+#### Example
+
+```js
+pathFrom = new Point (150, 200);
+
+path = new Path ()
+ .moveTo (pathFrom)
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo (pathFrom, [220, 220]);
+
+console.log (path.length); // 4
+```
+
+## Description of the path steps
+
+### moveTo
+
+```js
+Path moveTo (LibCanvas.Point point);
+```
+
+Add a move step to the point `point`
+
+#### Example
+
+```js
+path.moveTo (new Point (100, 150));
+```
+
+### lineTo
+
+```js
+Path lineTo (LibCanvas.Point point);
+```
+
+Draw a line to the point `point`
+
+#### Example
+
+```js
+path.lineTo (new Point (100, 150));
+```
+
+### curveTo
+
+```js
+Path curveTo (LibCanvas.Point point, LibCanvas.Point cp1, LibCanvas.Point cp2 = null);
+```
+
+Draw a curved line to the point `point`
+
+#### Example
+
+```js
+// Quadratic curve
+path.curveTo (new Point (100, 150), new Point (50, 50));
+// Cubic curve
+path.curveTo (new Point (100, 150), new Point (50, 50), new Point (80, 40));
+```
+
+## HasPoint Method
+
+```js
+bool hasPoint (LibCanvas.Point point);
+```
+
+Returns true if the point is inside the path
+
+#### Example
+
+```js
+pathFrom = new Point (150, 200);
+
+path = new Path ()
+ .moveTo (pathFrom)
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo (pathFrom, [220, 220]);
+
+path.hasPoint (new Point (160, 200)); // true
+path.hasPoint (new Point (666, 200)); // false
+```
+
+## The move method
+
+```js
+Path move (LibCanvas.Point distance, bool reverse);
+```
+
+Calls the move method on all waypoints. If the point repeats several times, it moves only once
+
+#### Example
+
+```js
+pathFrom = new Point (150, 200);
+
+path = new Path ()
+ .moveTo (pathFrom)
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo (pathFrom, [220, 220]);
+
+path.move (new Point (42, 13));
+```
+
+#### Returns `this`
+
+## Rotate method
+
+```js
+Path rotate (number angle, LibCanvas.Point pivot);
+```
+Rotates the path around the `pivot` point to the `angle` radian.
+
+#### Example
+
+```js
+pathFrom = new Point (150, 200);
+
+path = new Path ()
+ .moveTo (pathFrom)
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo (pathFrom, [220, 220]);
+
+// rotate the path around the center
+path.rotate ((6) .degree (), path.center);
+```
+
+#### Returns `this`
+
+## Method scale
+
+```js
+Path scale (number power, LibCanvas.Point pivot);
+```
+
+Increases the path in `power` times relative to the point `pivot`
+
+#### Example
+
+```js
+pathFrom = new Point (150, 200);
+
+path = new Path ()
+ .moveTo (pathFrom)
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo (pathFrom, [220, 220]);
+
+// Skived the way twice:
+path.scale (0.5, path.center);
+```
+
+#### Returns `this`
+
+
+## The draw method
+
+```js
+Path draw (LibCanvas.Context2D ctx, String type);
+```
+
+Draws the path to the context using the current settings
+
+#### argument `type`
+Method of rendering. It can take the values `fill`, `stroke`, `clear`
+
+#### Example
+
+```js
+pathFrom = new Point (150, 200);
+
+path = new Path ()
+ .moveTo (pathFrom)
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo (pathFrom, [220, 220]);
+
+var ctx = canvasElem
+ .getContext ('2d-libcanvas')
+ .set ({
+ 'fillStyle': 'red',
+ 'strokeStyle': 'black'
+});
+// Fill in the red polygon in the context
+path.draw (ctx, 'fill');
+// Circle the black polygon in context
+path.draw (ctx, 'stroke');
+```
+
+But this method is recommended to be used only if for some reason the following is not available:
+
+```js
+var ctx = canvasElem
+ .getContext ('2d-libcanvas')
+ .fill (path, 'red')
+ .stroke (path, 'black');
+```
+
+#### Returns `this`
+
+## The processPath method
+
+```js
+Path processPath (LibCanvas.Context2D ctx, bool noWrap = false)
+```
+
+Passes the path using `ctx.moveTo`, `ctx.lineTo`, `ctx.curveTo`
+
+#### the argument `noWrap`
+if specified in false (by default), then frames with `beginPath`, `endPath`
+
+#### Example
+
+```js
+path = new Path ()
+ .moveTo ([150, 200])
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo ([150, 200], [220, 220])
+ .processPath (ctx);
+
+// is equivalent to:
+
+ctx.beginPath ()
+ .moveTo ([150, 200])
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo ([150, 200], [220, 220])
+ .closePath ();
+```
+
+## The clone method
+
+```js
+Path clone ()
+```
+
+Returns a new path with declined dots
+
+#### Example
+
+```js
+path = new Path ()
+ .moveTo ([150, 200])
+ .curveTo ([300, 200], [250, 150])
+ .curveTo ([200, 280], [290, 250])
+ .curveTo ([150, 200], [220, 220]);
+
+var pathClone = path.clone ();
+```
+
+Attention! If in the original path several points refer to one object, then in the new path, the clone, these will be different, unrelated points objects.
\ No newline at end of file
diff --git a/Docs/En/Shapes/Polygon.md b/Docs/En/Shapes/Polygon.md
new file mode 100644
index 0000000..2355a33
--- /dev/null
+++ b/Docs/En/Shapes/Polygon.md
@@ -0,0 +1,325 @@
+Polygon
+=======
+
+`LibCanvas.Shapes.Polygon` - describes a polygon through a set of points.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Polygon"
+
+## Creating an instance of LibCanvas.Shapes.Polygon
+
+```js
+var polygon = new LibCanvas.Shapes.Polygon (pointsArray);
+```
+
+#### Example
+
+```js
+var polygon = new Polygon ([
+ [120, 30],
+ [200, 10],
+ [240, 120],
+ [150, 150],
+ [100, 100]
+]);
+
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+```
+
+## get length
+
+Returns the number of polygon points:
+
+#### Example
+
+```js
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+
+console.log (triangle.length); // 3
+```
+
+## get center
+
+Returns the center of the polygon:
+
+#### Example
+
+```js
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+
+console.log (triangle.center); // Point (340, 330);
+```
+
+## The get method
+
+```js
+LibCanvas.Point get (int index);
+```
+
+Returns the polygon point
+
+#### Example
+
+```js
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+triangle.get (2); // Point (300, 400)
+```
+
+## HasPoint Method
+
+```js
+bool hasPoint (LibCanvas.Point point);
+```
+
+Returns true if the point is inside the polygon
+
+#### Example
+
+```js
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+triangle.hasPoint (new Point (305, 305)); // true
+triangle.hasPoint (new Point (188, 212)); // false
+```
+
+## The move method
+
+```js
+Polygon move (LibCanvas.Point distance, bool reverse);
+```
+
+Calls the move method on all polygon points
+
+#### Example
+
+```js
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+triangle.move (new Point (42, 13));
+```
+
+#### Returns `this`
+
+## Rotate method
+
+```js
+Polygon rotate (number angle, LibCanvas.Point pivot);
+```
+
+Rotates the polygon around the `pivot` point to the `angle` radian.
+
+#### Example
+
+```js
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+
+// rotate the triangle around the center
+triangle.rotate ((6) .degree (), triangle.center);
+
+// rotate the triangle around one of the vertices
+triangle.rotate ((6) .degree (), triangle.get (0));
+```
+
+#### Returns `this`
+
+## Method scale
+
+```js
+Polygon scale (number power, LibCanvas.Point pivot);
+```
+
+Increases the polygon in `power` times relative to the point `pivot`
+
+#### Example
+
+```js
+var triangle = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+
+triangle.scale (0.5, triangle.center);
+
+// Duplicate the polygon twice:
+//
+// Polygon (
+// Point (320, 315),
+// Point (370, 315),
+// Point (330, 360)
+// );
+```
+
+#### Returns `this`
+
+
+## The draw method
+
+```js
+Polygon draw (LibCanvas.Context2D ctx, String type);
+```
+
+Draws a polygon in the context using the current settings
+
+#### argument `type`
+Method of rendering. It can take the values `fill`, `stroke`, `clear`
+
+#### Example
+
+```js
+var poly = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+
+var ctx = canvasElem
+ .getContext ('2d-libcanvas')
+ .set ({
+ 'fillStyle': 'red',
+ 'strokeStyle': 'black'
+});
+
+// Fill in the red polygon in the context
+poly.draw (ctx, 'fill');
+// Circle the black polygon in context
+poly.draw (ctx, 'stroke');
+```
+
+But this method is recommended to be used only if for some reason the following is not available:
+
+```js
+var ctx = canvasElem
+ .getContext ('2d-libcanvas')
+ .fill (poly, 'red')
+ .stroke (poly, 'black');
+```
+
+#### Returns `this`
+
+## The processPath method
+
+```js
+LibCanvas.Shapes.Polygon processPath (LibCanvas.Context2D ctx, bool noWrap = false)
+```
+
+Passes the path using `ctx.moveTo`, `ctx.lineTo` starting from the first point clockwise
+
+#### the argument `noWrap`
+if specified in false (by default), then frames with `beginPath`, `endPath`
+
+#### Example
+
+```js
+var poly = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+poly.processPath (ctx);
+
+// is equivalent to:
+
+ctx
+.beginPath ()
+ .moveTo (new Point (300, 300))
+ .lineTo (new Point (400, 300))
+ .lineTo (new Point (320, 390))
+ .closePath ();
+```
+
+## The invoke method
+
+```js
+LibCanvas.Shapes.Polygon invoke (string method, mixed args [..])
+```
+
+Calls the method method at all polygon points with parameters from the remaining arguments of the function
+
+#### Example
+
+```js
+var poly = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+// Round all the coordinates
+poly.invoke ('map', function (value) {
+ return Math.round (value);
+});
+```
+
+#### Returns `this`
+
+## The clone method
+
+```js
+LibCanvas.Shapes.Polygon clone ()
+```
+
+Returns a new polygon with slanted dots
+
+#### Example
+
+```js
+var poly = new Polygon ([
+ new Point (299.6, 300.3),
+ new Point (400.2, 300.4),
+ new Point (319.8, 390.1)
+]);
+
+var polyClone = poly.clone ();
+```
+
+## The intersect method
+
+```js
+LibCanvas.Shapes.Polygon intersect (shape)
+```
+
+Checks whether the shape `shape` intersects the current polygon. Polygons compare through the intersection of lines, the remaining figures - through the intersection of `boundingShape`
+
+#### Example
+
+```js
+var poly1 = new Polygon ([
+ new Point (300, 300),
+ new Point (400, 300),
+ new Point (320, 390)
+]);
+var poly2 = new Polygon ([
+ new Point (250, 250),
+ new Point (350, 300),
+ new Point (300, 400)
+]);
+
+console.log (poly1.intersect (poly2)); // true
+```
\ No newline at end of file
diff --git a/Docs/En/Shapes/Rectangle.md b/Docs/En/Shapes/Rectangle.md
new file mode 100644
index 0000000..2690d97
--- /dev/null
+++ b/Docs/En/Shapes/Rectangle.md
@@ -0,0 +1,312 @@
+LibCanvas.Shapes.Rectangle
+==========================
+
+`LibCanvas.Shapes.Rectangle` - the basic figure in LibCanvas, which is used including in the canvas drawing (for example in `ctx.drawImage`)
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "Rectangle"
+
+## Creating an instance of LibCanvas.Shapes.Rectangle
+
+```js
+// coordinates of the first point and dimensions
+var rect = new LibCanvas.Shapes.Rectangle (xFromCoord, yFromCoord, width, height);
+
+// two points LibCanvas.Point - where and where
+var rect = new LibCanvas.Shapes.Rectangle (fromPoint, toPoint);
+
+// point LibCanvas.Point - where and the size of LibCanvas.Size
+var rect = new LibCanvas.Shapes.Rectangle (fromPoint, size);
+
+// parameter object (there must be two any arguments of three, for example, from and size)
+var rect = new LibCanvas.Shapes.Rectangle ({
+ from: fromPoint,
+ to: toPoint,
+ size: size
+});
+
+// Alternative way - through the center and size:
+var rect = new LibCanvas.Shapes.Rectangle ({
+ center: new Point (80, 95),
+ size: new Size (20, 10)
+}); // == new Rectangle (70, 90, 20, 10);
+
+```
+
+You can experiment with the kind of arguments LibCanvas is very flexible and will adjust to what you are writing. But be careful with this:
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle (
+ new LibCanvas.Point (5, 10),
+ new LibCanvas.Size (15, 20);
+);
+
+var rect = new LibCanvas.Shapes.Rectangle ({
+ from: [5, 10],
+ size: {
+ width: 15,
+ height: 20
+ }
+});
+
+var rect = new LibCanvas.Shapes.Rectangle ({
+ to: new LibCanvas.Point (20, 30),
+ size: [15, 20]
+});
+```
+
+Do not forget that the points are passed by reference, because if you declared a rectangle through two points, when you change the point inside the rectangle, the original points will also change. With this effect, you can do many useful tricks
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle (fromPoint, toPoint);
+rect.from.x = 100;
+atom.trace (fromPoint.x); // 100
+```
+
+If necessary, this behavior can be avoided by passing point clones
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle (fromPoint.clone (), toPoint.clone ());
+```
+
+Or cloning the rectal:
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle (fromPoint, toPoint).clone ();
+```
+
+## Properties
+
+### width (set / get)
+Get the width of the rectangle or change (by moving the point to in the x coordinate)
+
+### height (set / get)
+Get the width of the rectangle or change (by moving the point to in the y coordinate)
+
+### bottomLeft (get)
+Creates a new point with coordinates that correspond to the lower-left corner of the rectangle
+
+### topRight (get)
+Creates a new point with coordinates that correspond to the right upper corner of the rectangle
+
+### center (get)
+Creates a new point with coordinates that correspond to the center of the rectangle
+
+### size (set / get)
+Get / set the height and width of the rectangle in the format {width, height}
+
+## HasPoint Method
+
+```js
+bool hasPoint (LibCanvas.Point point, int padding);
+```
+
+Returns true if the point is inside or on the boundary of a rectangle
+
+#### argument `padding`
+
+Allows for indentation from the border
+
+#### Example
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle ({
+ from: [4, 4],
+ to: [10, 10]
+});
+
+rect.hasPoint ([6, 6]); // true
+rect.hasPoint ([2, 2]); // false
+rect.hasPoint ([3, 3], 2); // false
+```
+
+## The align method
+
+```js
+LibCanvas.Shapes.Rectangle align (LibCanvas.Shapes.Rectangle rect, string sides);
+```
+
+Aligns a rectangle relative to another rectangle. sides can contain top / middle / bottom or left / center / right
+
+```js
+// center the rectangle relative to the canvas
+context.fill (rectangle.align (context.rectangle, 'center middle'), 'red');
+```
+
+## The move method
+
+```js
+LibCanvas.Shapes.Rectangle move (LibCanvas.Point distance, bool reverse);
+```
+
+Calls the move method of both points
+
+#### Example
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle ({
+ from: [4, 4],
+ to: [8, 8]
+});
+rect.move ({x: 2, y: 3});
+// rect.from == Point (6, 7)
+// rect.to == Point (10, 11)
+```
+
+#### Returns `this`
+
+## The draw method
+
+```js
+LibCanvas.Shapes.Rectangle draw (LibCanvas.Context2D ctx, String type);
+```
+
+Draws a rectangle to the context using the current settings
+
+#### argument `type`
+Method of rendering. It can take the values `fill`,` stroke`, `clear`
+
+#### Example
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle (10, 10, 5, 5);
+var ctx = canvasElem
+ .getContext ('2d-libcanvas')
+ .set ({
+ 'fillStyle': 'red',
+ 'strokeStyle': 'black'
+ });
+
+// Fill in the red rectangle in the context
+rect.draw (ctx, 'fill');
+// Circle the black rectangle in context
+rect.draw (ctx, 'stroke');
+```
+
+But this method is recommended to be used only if for some reason the following is not available:
+
+```js
+var ctx = canvasElem
+ .getContext ('2d-libcanvas')
+ .fill (rect, 'red')
+ .stroke (rect, 'black');
+```
+
+## moveTo
+
+```js
+LibCanvas.Shapes.Rectangle moveTo (LibCanvas.Shapes.Rectangle rect)
+```
+
+Moves the current rectangle so that it becomes equal to the rectangle passed by the argument
+
+```js
+var Rectangle = LibCanvas.Shapes.Rectangle;
+var rectFrom = new Rectangle ({
+ from: [10, 10],
+ to: [20, 20]
+});
+
+var rectTo = new Rectangle ({
+ from: [15, 15],
+ to: [25, 25]
+});
+
+rectFrom.moveTo (rectTo);
+
+rectFrom.from; // Point (15, 15);
+rectFrom.to; // Point (25, 25);
+```
+
+#### Returns `this`
+
+## The processPath method
+
+```js
+LibCanvas.Shapes.Rectangle processPath (LibCanvas.Context2D ctx, bool noWrap = false)
+```
+.
+Passes the path using `ctx.moveTo`, `ctx.lineTo` starting from the `from` point clockwise
+
+#### the argument `noWrap`
+if specified in false (by default), then frames with beginPath, endPath
+
+#### Example
+
+```js
+LibCanvas.Shapes.Rectangle ({
+ from: [4, 5],
+ to: [8, 9]
+}). processPath (ctx);
+
+// is equivalent to c:
+ctx.beginPath ()
+ .moveTo (4, 5) // rect.from
+ .lineTo (4, 9) // topRight
+ .lineTo (8, 9) // rect.to
+ .lineTo (8, 5) // bottomLeft
+ .lineTo (4, 5) // rect.from
+ .closePath ();
+```
+
+## The getRandomPoint method
+
+```js
+LibCanvas.Point getRandomPoint (int margin = 0);
+```
+
+Returns a random point inside the rectangle
+
+#### argument `margin`
+if specified, the dot will be returned with indents
+
+#### Examples
+
+```js
+var rect = LibCanvas.Shapes.Rectangle ({
+ from: [10, 10],
+ to: [90, 90]
+});
+
+// Return a random point whose coordinates are between 10 and 90
+rect.getRandomPoint (); // for example Point (53, 87)
+
+// Returns a random point whose coordinates are between 40 (10 + 30) and 60 (90-30)
+rect.getRandomPoint (30); // for example Point (49, 43)
+
+// Return a random point whose coordinates are between -20 (10-30) and 120 (90 + 30)
+rect.getRandomPoint (-30); // for example Point (96, -5)
+```
+
+## The equals method
+
+```js
+bool equals (LibCanvas.Shapes.Rectangle rect, int accuracy)
+```
+
+Compares polygon points using the LibCanvas.Point.equals method
+
+```js
+var foo = new LibCanvas.Shapes.Rectangle (15, 20, 10, 5);
+var bar = new LibCanvas.Shapes.Rectangle (15, 20, 10, 5);
+
+trace (bar == foo); // false
+trace (bar.equals (foo)); // true
+```
+
+## The clone method
+
+```js
+LibCanvas.Shapes.Rectangle clone ()
+```
+
+Returns a rectangle with the same coordinates
+
+```js
+var rect = new LibCanvas.Shapes.Rectangle (15, 20, 10, 5);
+var clone = rect.clone ();
+
+trace (rect == clone); // false
+trace (rect.equals (clone)); // true
+```
\ No newline at end of file
diff --git a/Docs/En/Shapes/RoundedRectangle.md b/Docs/En/Shapes/RoundedRectangle.md
new file mode 100644
index 0000000..62eed0d
--- /dev/null
+++ b/Docs/En/Shapes/RoundedRectangle.md
@@ -0,0 +1,27 @@
+LibCanvas.Shapes.RoundedRectangle
+=================================
+
+`RoundedRectangle` - the heir of the figure `Rectangle`, differs rounded corners. Completely repeats the parent interface.
+
+#### Global
+
+After calling LibCanvas.extract (), you can use the short alias "RoundedRectangle"
+
+## Properties
+
+### radius (set / get)
+radius of curvature of corners
+
+## setRadius
+
+```js
+LibCanvas.Shapes.RoundedRectangle setRadius (int radius);
+```
+
+Sets the radius of the shape. Just a handy alias for `shape.radius = radius`.
+
+```js
+var roundedRectangle = new RoundedRectangle (20, 20, 50, 60) .setRadius (5);
+```
+
+#### Returns `this`
\ No newline at end of file
diff --git a/README-RU.md b/README-RU.md
new file mode 100644
index 0000000..2762335
--- /dev/null
+++ b/README-RU.md
@@ -0,0 +1,67 @@
+## LibCanvas Javascript Framework
+
+*LibCanvas* is a free javascript library, based on [AtomJS framework](https://github.com/theshock/atomjs) and available under [LGPL](http://www.gnu.org/copyleft/lgpl.html)/[MIT](http://opensource.org/licenses/mit-license.php) License.
+
+#### [Examples](http://libcanvas.github.com/)
+
+Current objectives of the project:
+
+* Full documentation
+
+For consultation, write to shocksilien@gmail.com
+
+## Возможности LibCanvas
+
+LibCanvas - библиотека для создания интерактивных приложений и игр на html5. Основные возможности:
+
+* [Расширенный 2D Context](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Core/Context2D.md):
+ * Method chaining
+ * Фигуры в качестве аргументов
+ * Дополнительные методы
+ * Именованные аргументы
+
+* [Геометрия](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/Shapes)
+ * [Действия с точками](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Core/Point.md)
+ * Изменения фигуры
+ * Пересечения
+ * Базовые математические операции
+
+
+* [Фреймворк LibCanvas.App](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/App)
+ * Отрисовка только изменившихся частей холста
+ * События мыши
+ * Draggable/Droppable
+ * Слои, внутренний zIndex
+ * Быстрое смещение слоёв
+
+
+* Игровые движки
+ * [Тайловый](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Tile/)
+ * [Изометрический](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Isometric/Projection.md)
+ * [Гексагональный](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Hex/Projection.md)
+
+
+* Дополнительные возможности (плагины)
+ * [Спрайтовые анимации](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/Plugins/Animation)
+ * [Математическая модель кривых Безье](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Plugins/Curve.md) (для построения путей)
+ * [Кривые с динамической шириной и цветом](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Plugins/Curves.md)
+ * Спрайтовые шрифты
+ * Рендеринг текстуры в проекции
+
+## Интеграция
+
+* [Gem для Ruby on Rails](https://github.com/tanraya/libcanvas-rails)
+
+## Переход на новую версию
+
+21 декабря 2012-ого года была публично переведена в "master" главной ветка "declare".
+
+Предыдущая версия всё ещё доступна [в ветке previous](https://github.com/theshock/libcanvas/tree/previous), но больше не разрабатывается.
+
+Основные изменения в новой версии:
+
+* Основательно переписан код, убраны основные баги архитектуры и неочевидные вещи
+* Повышена производительность основных компонентов библиотеки
+* Более не требуется расширение прототипов. Оно всё ещё поддерживается, но теперь полностью на совести пользователя - библиотека не требует расширенных при помощи atom прототипов
+* Используется atom.declare вместо atom.Class в целях повышения производительности и облечения дебага
+
diff --git a/README.md b/README.md
index 1c901af..9a03ad6 100644
--- a/README.md
+++ b/README.md
@@ -7,62 +7,60 @@
Current objectives of the project:
* Full documentation
-* Translation to English
For consultation, write to shocksilien@gmail.com
-## Возможности LibCanvas
+## Features of LibCanvas
-LibCanvas - библиотека для создания интерактивных приложений и игр на html5. Основные возможности:
+LibCanvas is a library for creating interactive applications and games on html5. Main features:
-* [Расширенный 2D Context](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Core/Context2D.md):
- * Method chaining
- * Фигуры в качестве аргументов
- * Дополнительные методы
- * Именованные аргументы
+* [Advanced 2D Context](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Core/Context2D.md):
+ * Method chaining
+ * Figures as arguments
+ * Additional methods
+ * Named arguments
-* [Геометрия](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/Shapes)
- * [Действия с точками](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Core/Point.md)
- * Изменения фигуры
- * Пересечения
- * Базовые математические операции
+* [Geometry](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/Shapes)
+ * [Actions with points](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Core/Point.md)
+ * Changing the shape
+ * Intersections
+ * Basic mathematical operations
-* [Фреймворк LibCanvas.App](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/App)
- * Отрисовка только изменившихся частей холста
- * События мыши
- * Draggable/Droppable
- * Слои, внутренний zIndex
- * Быстрое смещение слоёв
+* [LibCanvas.App Framework](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/App)
+ * Drawing only the changed parts of the canvas
+ * Mouse events
+ * Draggable / Droppable
+ * Layers, internal zIndex
+ * Fast layer displacement
-* Игровые движки
- * [Тайловый](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Tile/)
- * [Изометрический](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Isometric/Projection.md)
- * [Гексагональный](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Hex/Projection.md)
+* Game engines
+ * [Cache](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Tile/)
+ * [Isometric](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Isometric/Projection.md)
+ * [Hexagonal](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Engines/Hex/Projection.md)
-* Дополнительные возможности (плагины)
- * [Спрайтовые анимации](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/Plugins/Animation)
- * [Математическая модель кривых Безье](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Plugins/Curve.md) (для построения путей)
- * [Кривые с динамической шириной и цветом](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Plugins/Curves.md)
- * Спрайтовые шрифты
- * Рендеринг текстуры в проекции
+* Additional features (plugins)
+ * [Sprite animations](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/Plugins/Animation)
+ * [Mathematical model of Bezier curves](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Plugins/Curve.md) (for building paths)
+ * [Curves with dynamic width and color](https://github.com/theshock/libcanvas/blob/master/Docs/Ru/Plugins/Curves.md)
+ * Sprite fonts
+ * Rendering texture in projection
-## Интеграция
+## Integration
-* [Gem для Ruby on Rails](https://github.com/tanraya/libcanvas-rails)
+* [Gem for Ruby on Rails](https://github.com/tanraya/libcanvas-rails)
-## Переход на новую версию
+## Switching to the new version
-21 декабря 2012-ого года была публично переведена в "master" главной ветка "declare".
+On December 21, 2012, the main branch "declare" was publicly translated into "master".
-Предыдущая версия всё ещё доступна [в ветке previous](https://github.com/theshock/libcanvas/tree/previous), но больше не разрабатывается.
+The previous version is still available [in the previous branch](https://github.com/theshock/libcanvas/tree/previous), but is no longer being developed.
-Основные изменения в новой версии:
-
-* Основательно переписан код, убраны основные баги архитектуры и неочевидные вещи
-* Повышена производительность основных компонентов библиотеки
-* Более не требуется расширение прототипов. Оно всё ещё поддерживается, но теперь полностью на совести пользователя - библиотека не требует расширенных при помощи atom прототипов
-* Используется atom.declare вместо atom.Class в целях повышения производительности и облечения дебага
+Major changes in the new version:
+* Completely rewritten code, removed the main architecture bugs and non-obvious things
+* Improved performance of the main components of the library
+* No longer requires prototype expansion. It is still supported, but now completely on the conscience of the user - the library does not require atom-extended prototypes
+* Used atom.declare instead of atom.Class in order to improve performance and investment debug
\ No newline at end of file