diff --git a/apps/pdfeditor/main/app/controller/DocumentHolder.js b/apps/pdfeditor/main/app/controller/DocumentHolder.js
index 13f3f20b70..63a5ed2ae1 100644
--- a/apps/pdfeditor/main/app/controller/DocumentHolder.js
+++ b/apps/pdfeditor/main/app/controller/DocumentHolder.js
@@ -281,6 +281,59 @@ define([
                     }, this));
                 }
  */
+                view.menuParaCopy.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuParaPaste.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuParaCut.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuImgCopy.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuImgPaste.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuImgCut.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuTableCopy.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuTablePaste.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuTableCut.on('click', _.bind(me.onCutCopyPaste, me));
+                view.menuAddHyperlinkPara.on('click', _.bind(me.addHyperlink, me));
+                view.menuAddHyperlinkTable.on('click', _.bind(me.addHyperlink, me));
+                view.menuEditHyperlinkPara.on('click', _.bind(me.editHyperlink, me));
+                view.menuEditHyperlinkTable.on('click', _.bind(me.editHyperlink, me));
+                view.menuRemoveHyperlinkPara.on('click', _.bind(me.removeHyperlink, me));
+                view.menuRemoveHyperlinkTable.on('click', _.bind(me.removeHyperlink, me));
+                // view.menuChartEdit.on('click', _.bind(me.editChartClick, me, undefined));
+                view.menuImgSaveAsPicture.on('click', _.bind(me.saveAsPicture, me));
+                view.menuTableSaveAsPicture.on('click', _.bind(me.saveAsPicture, me));
+                view.menuAddCommentPara.on('click', _.bind(me.addComment, me));
+                view.menuAddCommentTable.on('click', _.bind(me.addComment, me));
+                view.menuAddCommentImg.on('click', _.bind(me.addComment, me));
+                view.mnuTableMerge.on('click', _.bind(me.onTableMerge, me));
+                view.mnuTableSplit.on('click', _.bind(me.onTableSplit, me));
+                view.menuTableCellAlign.menu.on('item:click', _.bind(me.tableCellsVAlign, me));
+                view.menuTableDistRows.on('click', _.bind(me.onTableDistRows, me));
+                view.menuTableDistCols.on('click', _.bind(me.onTableDistCols, me));
+                view.menuTableAdvanced.on('click', _.bind(me.onTableAdvanced, me));
+                view.menuImageAdvanced.on('click', _.bind(me.onImageAdvanced, me));
+                view.menuImgOriginalSize.on('click', _.bind(me.onImgOriginalSize, me));
+                view.menuImgShapeRotate.menu.items[0].on('click', _.bind(me.onImgRotate, me));
+                view.menuImgShapeRotate.menu.items[1].on('click', _.bind(me.onImgRotate, me));
+                view.menuImgShapeRotate.menu.items[3].on('click', _.bind(me.onImgFlip, me));
+                view.menuImgShapeRotate.menu.items[4].on('click', _.bind(me.onImgFlip, me));
+                view.menuImgCrop.menu.on('item:click', _.bind(me.onImgCrop, me));
+                view.menuImgEditPoints.on('click', _.bind(me.onImgEditPoints, me));
+                view.menuShapeAdvanced.on('click', _.bind(me.onShapeAdvanced, me));
+                view.menuParagraphAdvanced.on('click', _.bind(me.onParagraphAdvanced, me));
+                // view.menuChartAdvanced.on('click', _.bind(me.onChartAdvanced, me));
+                view.mnuGroupImg.on('click', _.bind(me.onGroupImg, me));
+                view.mnuUnGroupImg.on('click', _.bind(me.onUnGroupImg, me));
+                view.mnuArrangeFront.on('click', _.bind(me.onArrangeFront, me));
+                view.mnuArrangeBack.on('click', _.bind(me.onArrangeBack, me));
+                view.mnuArrangeForward.on('click', _.bind(me.onArrangeForward, me));
+                view.mnuArrangeBackward.on('click', _.bind(me.onArrangeBackward, me));
+                view.menuImgShapeAlign.menu.on('item:click', _.bind(me.onImgShapeAlign, me));
+                view.menuParagraphVAlign.menu.on('item:click', _.bind(me.onParagraphVAlign, me));
+                view.menuParagraphDirection.menu.on('item:click', _.bind(me.onParagraphDirection, me));
+                view.menuTableSelectText.menu.on('item:click', _.bind(me.tableSelectText, me));
+                view.menuTableInsertText.menu.on('item:click', _.bind(me.tableInsertText, me));
+                view.menuTableDeleteText.menu.on('item:click', _.bind(me.tableDeleteText, me));
+                view.menuTableEquationSettings.menu.on('item:click', _.bind(me.convertEquation, me));
+                view.menuParagraphEquation.menu.on('item:click', _.bind(me.convertEquation, me));
+
             }
         },
 
@@ -338,12 +391,66 @@ define([
         },
 
         fillPDFEditMenuProps: function(selectedElements) {
-            // if (!selectedElements || !_.isArray(selectedElements)) return;
-
             var documentHolder = this.documentHolder;
             if (!documentHolder.editPDFModeMenu)
                 documentHolder.createDelayedElementsPDFEditor();
-            return {menu_to_show: documentHolder.editPDFModeMenu, menu_props: {}};
+
+            if (!selectedElements || !_.isArray(selectedElements) || selectedElements.length<1)
+                return {menu_to_show: documentHolder.editPDFModeMenu, menu_props: {}}
+
+            var me = this,
+                menu_props = {},
+                menu_to_show = null;
+            _.each(selectedElements, function(element, index) {
+                var elType  = element.get_ObjectType(),
+                    elValue = element.get_ObjectValue();
+
+                if (Asc.c_oAscTypeSelectElement.Image == elType) {
+                    menu_to_show = documentHolder.pictureMenu;
+                    menu_props.imgProps = {};
+                    menu_props.imgProps.value = elValue;
+                    menu_props.imgProps.locked = (elValue) ? elValue.get_Locked() : false;
+                } else if (Asc.c_oAscTypeSelectElement.Table == elType) {
+                    menu_to_show = documentHolder.tableMenu;
+                    menu_props.tableProps = {};
+                    menu_props.tableProps.value = elValue;
+                    menu_props.tableProps.locked = (elValue) ? elValue.get_Locked() : false;
+                } else if (Asc.c_oAscTypeSelectElement.Hyperlink == elType) {
+                    menu_props.hyperProps = {};
+                    menu_props.hyperProps.value = elValue;
+                } else if (Asc.c_oAscTypeSelectElement.Shape == elType) { // shape
+                    menu_to_show = documentHolder.pictureMenu;
+                    menu_props.shapeProps = {};
+                    menu_props.shapeProps.value = elValue;
+                    menu_props.shapeProps.locked = (elValue) ? elValue.get_Locked() : false;
+                    if (elValue.get_FromChart())
+                        menu_props.shapeProps.isChart = true;
+                }
+                // else if (Asc.c_oAscTypeSelectElement.Chart == elType) {
+                //     menu_to_show = documentHolder.pictureMenu;
+                //     menu_props.chartProps = {};
+                //     menu_props.chartProps.value = elValue;
+                //     menu_props.chartProps.locked = (elValue) ? elValue.get_Locked() : false;
+                // }
+                else if (Asc.c_oAscTypeSelectElement.Paragraph == elType) {
+                    menu_props.paraProps = {};
+                    menu_props.paraProps.value = elValue;
+                    menu_props.paraProps.locked = (elValue) ? elValue.get_Locked() : false;
+                    if ((menu_props.shapeProps && menu_props.shapeProps.value || menu_props.chartProps && menu_props.chartProps.value) && // text in shape, need to show paragraph menu with vertical align
+                        _.isUndefined(menu_props.tableProps))
+                        menu_to_show = documentHolder.textMenu;
+                } else if (Asc.c_oAscTypeSelectElement.Math == elType) {
+                    menu_props.mathProps = {};
+                    menu_props.mathProps.value = elValue;
+                    documentHolder._currentMathObj = elValue;
+                }
+            });
+            if (menu_to_show === null) {
+                if (!_.isUndefined(menu_props.paraProps))
+                    menu_to_show = documentHolder.textMenu;
+            }
+
+            return {menu_to_show: menu_to_show, menu_props: menu_props};
         },
 
         applyEditorMode: function() {
@@ -351,6 +458,8 @@ define([
                 this.documentHolder.createDelayedElementsPDFEditor();
                 this.api.asc_registerCallback('asc_onShowMathTrack',            _.bind(this.onShowMathTrack, this));
                 this.api.asc_registerCallback('asc_onHideMathTrack',            _.bind(this.onHideMathTrack, this));
+                this.api.asc_registerCallback('asc_onDialogAddHyperlink',       _.bind(this.onDialogAddHyperlink, this));
+                this.api.asc_registerCallback('asc_ChangeCropState',            _.bind(this.onChangeCropState, this));
             }
         },
 
@@ -425,6 +534,24 @@ define([
                     }
                 }
             }
+            if (this.mode && this.mode.isPDFEdit) {
+                var i = -1,
+                    in_equation = false,
+                    locked = false;
+                while (++i < selectedElements.length) {
+                    var type = selectedElements[i].get_ObjectType();
+                    if (type === Asc.c_oAscTypeSelectElement.Math) {
+                        in_equation = true;
+                    } else if (type === Asc.c_oAscTypeSelectElement.Paragraph) {
+                        var value = selectedElements[i].get_ObjectValue();
+                        value && (locked = locked || value.get_Locked());
+                    }
+                }
+                if (in_equation) {
+                    this._state.equationLocked = locked;
+                    this.disableEquationBar();
+                }
+            }
         },
 
         handleDocumentWheel: function(event) {
@@ -626,6 +753,66 @@ define([
             }
         },
 
+        onDialogAddHyperlink: function() {
+            var win, props, text;
+            var me = this;
+            if (me.api && me.mode.isEdit && !me._isDisabled && !PDFE.getController('LeftMenu').leftMenu.menuFile.isVisible()){
+                var handlerDlg = function(dlg, result) {
+                    if (result == 'ok') {
+                        props = dlg.getSettings();
+                        (text!==false)
+                            ? me.api.add_Hyperlink(props)
+                            : me.api.change_Hyperlink(props);
+                    }
+
+                    me.editComplete();
+                };
+
+                text = me.api.can_AddHyperlink();
+
+                var _arr = [];
+                for (var i=0; i<me.api.getCountPages(); i++) {
+                    _arr.push({
+                        displayValue: i+1,
+                        value: i
+                    });
+                }
+                if (text !== false) {
+                    win = new PDFE.Views.HyperlinkSettingsDialog({
+                        api: me.api,
+                        appOptions: me.mode,
+                        handler: handlerDlg,
+                        slides: _arr
+                    });
+
+                    props = new Asc.CHyperlinkProperty();
+                    props.put_Text(text);
+
+                    win.show();
+                    win.setSettings(props);
+                } else {
+                    var selectedElements = me.api.getSelectedElements();
+                    if (selectedElements && _.isArray(selectedElements)){
+                        _.each(selectedElements, function(el, i) {
+                            if (selectedElements[i].get_ObjectType() == Asc.c_oAscTypeSelectElement.Hyperlink)
+                                props = selectedElements[i].get_ObjectValue();
+                        });
+                    }
+                    if (props) {
+                        win = new PDFE.Views.HyperlinkSettingsDialog({
+                            api: me.api,
+                            appOptions: me.mode,
+                            handler: handlerDlg,
+                            slides: _arr
+                        });
+                        win.show();
+                        win.setSettings(props);
+                    }
+                }
+            }
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Add Hyperlink');
+        },
+
         onShowForeignCursorLabel: function(UserId, X, Y, color) {
             if (!this.isUserVisible(UserId)) return;
 
@@ -1649,6 +1836,530 @@ define([
             }
         },
 
+        equationCallback: function(eqProps) {
+            if (eqProps) {
+                var eqObj;
+                switch (eqProps.type) {
+                    case Asc.c_oAscMathInterfaceType.Accent:
+                        eqObj = new CMathMenuAccent();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.BorderBox:
+                        eqObj = new CMathMenuBorderBox();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Box:
+                        eqObj = new CMathMenuBox();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Bar:
+                        eqObj = new CMathMenuBar();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Script:
+                        eqObj = new CMathMenuScript();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Fraction:
+                        eqObj = new CMathMenuFraction();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Limit:
+                        eqObj = new CMathMenuLimit();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Matrix:
+                        eqObj = new CMathMenuMatrix();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.EqArray:
+                        eqObj = new CMathMenuEqArray();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.LargeOperator:
+                        eqObj = new CMathMenuNary();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Delimiter:
+                        eqObj = new CMathMenuDelimiter();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.GroupChar:
+                        eqObj = new CMathMenuGroupCharacter();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Radical:
+                        eqObj = new CMathMenuRadical();
+                        break;
+                    case Asc.c_oAscMathInterfaceType.Common:
+                        eqObj = new CMathMenuBase();
+                        break;
+                }
+                if (eqObj) {
+                    eqObj[eqProps.callback](eqProps.value);
+                    this.api.asc_SetMathProps(eqObj);
+                }
+            }
+            this.editComplete();
+        },
+
+        onChangeCropState: function(state) {
+            this.documentHolder.menuImgCrop && this.documentHolder.menuImgCrop.menu.items[0].setChecked(state, true);
+        },
+
+        addHyperlink: function(item){
+            var win, me = this;
+            if (me.api) {
+                var _arr = [];
+                for (var i=0; i<me.api.getCountPages(); i++) {
+                    _arr.push({
+                        displayValue: i+1,
+                        value: i
+                    });
+                }
+                win = new PDFE.Views.HyperlinkSettingsDialog({
+                    api: me.api,
+                    appOptions: me.mode,
+                    handler: function(dlg, result) {
+                        if (result == 'ok') {
+                            me.api.add_Hyperlink(dlg.getSettings());
+                        }
+                        me.editComplete();
+                    },
+                    slides: _arr
+                });
+
+                win.show();
+                win.setSettings(item.hyperProps.value);
+
+                Common.component.Analytics.trackEvent('DocumentHolder', 'Add Hyperlink');
+            }
+        },
+
+        editHyperlink: function(item, e){
+            var win, me = this;
+            if (me.api){
+                var _arr = [];
+                for (var i=0; i<me.api.getCountPages(); i++) {
+                    _arr.push({
+                        displayValue: i+1,
+                        value: i
+                    });
+                }
+                win = new PDFE.Views.HyperlinkSettingsDialog({
+                    api: me.api,
+                    appOptions: me.mode,
+                    handler: function(dlg, result) {
+                        if (result == 'ok') {
+                            me.api.change_Hyperlink(win.getSettings());
+                        }
+                        me.editComplete();
+                    },
+                    slides: _arr
+                });
+                win.show();
+                win.setSettings(item.hyperProps.value);
+
+                Common.component.Analytics.trackEvent('DocumentHolder', 'Edit Hyperlink');
+            }
+        },
+
+        removeHyperlink: function(item) {
+            if (this.api){
+                this.api.remove_Hyperlink();
+            }
+
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Remove Hyperlink');
+        },
+
+        onInsertImageUrl: function(placeholder, obj, x, y) {
+            var me = this;
+            (new Common.Views.ImageFromUrlDialog({
+                handler: function(result, value) {
+                    if (result == 'ok') {
+                        if (me.api) {
+                            var checkUrl = value.replace(/ /g, '');
+                            if (!_.isEmpty(checkUrl)) {
+                                var props = new Asc.asc_CImgProperty();
+                                props.put_ImageUrl(checkUrl);
+                                me.api.ImgApply(props, obj);
+                            }
+                        }
+                    }
+                    me.editComplete();
+                }
+            })).show();
+        },
+
+        onImgReplace: function(menu, item, e) {
+            var me = this;
+            if (item.value==1) {
+                me.onInsertImageUrl(false);
+            } else if (item.value==2) {
+                Common.NotificationCenter.trigger('storage:image-load', 'change');
+            } else {
+                setTimeout(function(){
+                    me.api.ChangeImageFromFile();
+                }, 10);
+            }
+        },
+
+        onTableMerge: function () {
+            this.api && this.api.MergeCells();
+        },
+
+        onTableSplit: function () {
+            var me = this;
+            if (me.api) {
+                (new Common.Views.InsertTableDialog({
+                    split: true,
+                    handler: function(result, value) {
+                        if (result == 'ok') {
+                            if (me.api) {
+                                me.api.SplitCell(value.columns, value.rows);
+                            }
+                            Common.component.Analytics.trackEvent('DocumentHolder', 'Table Split');
+                        }
+                        me.editComplete();
+                    }
+                })).show();
+            }
+        },
+
+        tableCellsVAlign: function(menu, item, e) {
+            if (this.api) {
+                var properties = new Asc.CTableProp();
+                properties.put_CellsVAlign(item.value);
+                this.api.tblApply(properties);
+            }
+
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Table Cell Align');
+        },
+
+        onTableDistRows: function () {
+            this.api && this.api.asc_DistributeTableCells(false);
+            this.editComplete();
+        },
+
+        onTableDistCols: function () {
+            this.api && this.api.asc_DistributeTableCells(true);
+            this.editComplete();
+        },
+
+        onTableAdvanced: function(item, e){
+            var me = this;
+            if (me.api) {
+                var selectedElements = me.api.getSelectedElements();
+
+                if (selectedElements && selectedElements.length > 0){
+                    var elType, elValue;
+                    for (var i = selectedElements.length - 1; i >= 0; i--) {
+                        elType  = selectedElements[i].get_ObjectType();
+                        elValue = selectedElements[i].get_ObjectValue();
+
+                        if (Asc.c_oAscTypeSelectElement.Table == elType) {
+                            (new PDFE.Views.TableSettingsAdvanced(
+                                {
+                                    tableProps: elValue,
+                                    slideSize: {width: me.api.get_PageWidth(), height: me.api.get_PageHeight()},
+                                    handler: function(result, value) {
+                                        if (result == 'ok') {
+                                            if (me.api) {
+                                                me.api.tblApply(value.tableProps);
+                                            }
+                                        }
+                                        me.editComplete();
+                                        Common.component.Analytics.trackEvent('DocumentHolder', 'Table Settings Advanced');
+                                    }
+                                })).show();
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+
+        onImageAdvanced: function(item) {
+            var me = this;
+            if (me.api){
+                var selectedElements = me.api.getSelectedElements();
+                if (selectedElements && selectedElements.length>0){
+                    var elType, elValue;
+
+                    for (var i = selectedElements.length - 1; i >= 0; i--) {
+                        elType  = selectedElements[i].get_ObjectType();
+                        elValue = selectedElements[i].get_ObjectValue();
+
+                        if (Asc.c_oAscTypeSelectElement.Image == elType) {
+                            var imgsizeOriginal;
+
+                            if (!me.documentHolder.menuImgOriginalSize.isDisabled()) {
+                                imgsizeOriginal = me.api.get_OriginalSizeImage();
+                                if (imgsizeOriginal)
+                                    imgsizeOriginal = {width:imgsizeOriginal.get_ImageWidth(), height:imgsizeOriginal.get_ImageHeight()};
+                            }
+
+                            (new PDFE.Views.ImageSettingsAdvanced(
+                                {
+                                    imageProps: elValue,
+                                    sizeOriginal: imgsizeOriginal,
+                                    slideSize: {width: me.api.get_PageWidth(), height: me.api.get_PageHeight()},
+                                    handler: function(result, value) {
+                                        if (result == 'ok') {
+                                            if (me.api) {
+                                                me.api.ImgApply(value.imageProps);
+                                            }
+                                        }
+                                        me.editComplete();
+                                        Common.component.Analytics.trackEvent('DocumentHolder', 'Image Settings Advanced');
+                                    }
+                                })).show();
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+
+        onImgOriginalSize: function(item){
+            var me = this;
+            if (me.api){
+                var originalImageSize = me.api.get_OriginalSizeImage();
+
+                if (originalImageSize) {
+                    var properties = new Asc.asc_CImgProperty();
+
+                    properties.put_Width(originalImageSize.get_ImageWidth());
+                    properties.put_Height(originalImageSize.get_ImageHeight());
+                    properties.put_ResetCrop(true);
+                    properties.put_Rot(0);
+                    me.api.ImgApply(properties);
+                }
+
+                me.editComplete();
+                Common.component.Analytics.trackEvent('DocumentHolder', 'Set Image Original Size');
+            }
+        },
+
+        onImgRotate: function(item) {
+            var properties = new Asc.asc_CShapeProperty();
+            properties.asc_putRotAdd((item.value==1 ? 90 : 270) * 3.14159265358979 / 180);
+            this.api.ShapeApply(properties);
+            this.editComplete();
+        },
+
+        onImgFlip: function(item) {
+            var properties = new Asc.asc_CShapeProperty();
+            if (item.value==1)
+                properties.asc_putFlipHInvert(true);
+            else
+                properties.asc_putFlipVInvert(true);
+            this.api.ShapeApply(properties);
+            this.editComplete();
+        },
+
+        onImgCrop: function(menu, item) {
+            if (item.value == 1) {
+                this.api.asc_cropFill();
+            } else if (item.value == 2) {
+                this.api.asc_cropFit();
+            } else {
+                item.checked ? this.api.asc_startEditCrop() : this.api.asc_endEditCrop();
+            }
+            this.editComplete();
+        },
+
+        onImgEditPoints: function(item) {
+            this.api && this.api.asc_editPointsGeometry();
+        },
+
+        onShapeAdvanced: function(item) {
+            var me = this;
+            if (me.api){
+                var selectedElements = me.api.getSelectedElements();
+                if (selectedElements && selectedElements.length>0){
+                    var elType, elValue;
+                    for (var i = selectedElements.length - 1; i >= 0; i--) {
+                        elType = selectedElements[i].get_ObjectType();
+                        elValue = selectedElements[i].get_ObjectValue();
+                        if (Asc.c_oAscTypeSelectElement.Shape == elType) {
+                            (new PDFE.Views.ShapeSettingsAdvanced(
+                                {
+                                    shapeProps: elValue,
+                                    slideSize: {width: me.api.get_PageWidth(), height: me.api.get_PageHeight()},
+                                    handler: function(result, value) {
+                                        if (result == 'ok') {
+                                            if (me.api) {
+                                                me.api.ShapeApply(value.shapeProps);
+                                            }
+                                        }
+                                        me.editComplete();
+                                        Common.component.Analytics.trackEvent('DocumentHolder', 'Image Shape Advanced');
+                                    }
+                                })).show();
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+
+        onParagraphAdvanced: function(item) {
+            var me = this;
+            if (me.api){
+                var selectedElements = me.api.getSelectedElements();
+
+                if (selectedElements && selectedElements.length > 0){
+                    var elType, elValue;
+                    for (var i = selectedElements.length - 1; i >= 0; i--) {
+                        elType  = selectedElements[i].get_ObjectType();
+                        elValue = selectedElements[i].get_ObjectValue();
+
+                        if (Asc.c_oAscTypeSelectElement.Paragraph == elType) {
+                            (new PDFE.Views.ParagraphSettingsAdvanced(
+                                {
+                                    paragraphProps: elValue,
+                                    api: me.api,
+                                    handler: function(result, value) {
+                                        if (result == 'ok') {
+                                            if (me.api) {
+                                                me.api.paraApply(value.paragraphProps);
+                                            }
+                                        }
+                                        me.editComplete();
+                                        Common.component.Analytics.trackEvent('DocumentHolder', 'Image Paragraph Advanced');
+                                    }
+                                })).show();
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+
+        onGroupImg: function(item) {
+            this.api && this.api.groupShapes();
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Group Image');
+        },
+
+        onUnGroupImg: function(item) {
+            this.api && this.api.unGroupShapes();
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'UnGroup Image');
+        },
+
+        onArrangeFront: function(item) {
+            this.api && this.api.shapes_bringToFront();
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Bring To Front');
+        },
+
+        onArrangeBack: function(item) {
+            this.api && this.api.shapes_bringToBack();
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Bring To Back');
+        },
+
+        onArrangeForward: function(item) {
+            this.api && this.api.shapes_bringForward();
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Send Forward');
+        },
+
+        onArrangeBackward: function(item) {
+            this.api && this.api.shapes_bringBackward();
+            this.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Send Backward');
+        },
+
+        onImgShapeAlign: function (menu, item) {
+            var me = this;
+            if (me.api) {
+                var value = me.api.asc_getSelectedDrawingObjectsCount()<2 || Common.Utils.InternalSettings.get("pe-align-to-slide");
+                value = value ? Asc.c_oAscObjectsAlignType.Slide : Asc.c_oAscObjectsAlignType.Selected;
+                if (item.value < 6) {
+                    me.api.put_ShapesAlign(item.value, value);
+                    Common.component.Analytics.trackEvent('DocumentHolder', 'Shape Align');
+                } else if (item.value == 6) {
+                    me.api.DistributeHorizontally(value);
+                    Common.component.Analytics.trackEvent('DocumentHolder', 'Distribute Horizontally');
+                } else if (item.value == 7){
+                    me.api.DistributeVertically(value);
+                    Common.component.Analytics.trackEvent('DocumentHolder', 'Distribute Vertically');
+                }
+                me.editComplete();
+            }
+        },
+
+        onParagraphVAlign: function (menu, item) {
+            var me = this;
+            if (me.api) {
+                var properties = new Asc.asc_CShapeProperty();
+                properties.put_VerticalTextAlign(item.value);
+
+                me.api.ShapeApply(properties);
+            }
+
+            me.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Text Vertical Align');
+        },
+
+        onParagraphDirection: function(menu, item) {
+            var me = this;
+            if (me.api) {
+                var properties = new Asc.asc_CShapeProperty();
+                properties.put_Vert(item.options.direction);
+                me.api.ShapeApply(properties);
+            }
+            me.editComplete();
+            Common.component.Analytics.trackEvent('DocumentHolder', 'Text Direction');
+        },
+
+        tableSelectText: function(menu, item) {
+            if (this.api) {
+                switch (item.value) {
+                    case 0:
+                        this.api.selectRow();
+                        break;
+                    case 1:
+                        this.api.selectColumn();
+                        break;
+                    case 2:
+                        this.api.selectCell();
+                        break;
+                    case 3:
+                        this.api.selectTable();
+                        break;
+                }
+            }
+        },
+
+        tableInsertText: function(menu, item) {
+            if (this.api) {
+                switch (item.value) {
+                    case 0:
+                        this.api.addColumnLeft();
+                        break;
+                    case 1:
+                        this.api.addColumnRight();
+                        break;
+                    case 2:
+                        this.api.addRowAbove();
+                        break;
+                    case 3:
+                        this.api.addRowBelow();
+                        break;
+                }
+            }
+        },
+
+        tableDeleteText: function(menu, item) {
+            if (this.api) {
+                switch (item.value) {
+                    case 0:
+                        this.api.remRow();
+                        break;
+                    case 1:
+                        this.api.remColumn();
+                        break;
+                    case 2:
+                        this.api.remTable();
+                        break;
+                }
+            }
+        },
+
         editComplete: function() {
             this.documentHolder && this.documentHolder.fireEvent('editcomplete', this.documentHolder);
         }
diff --git a/apps/pdfeditor/main/app/view/DocumentHolder.js b/apps/pdfeditor/main/app/view/DocumentHolder.js
index d44ac08a76..50f84b750d 100644
--- a/apps/pdfeditor/main/app/view/DocumentHolder.js
+++ b/apps/pdfeditor/main/app/view/DocumentHolder.js
@@ -159,6 +159,996 @@ define([
                 if (!isFromInputControl) me.fireEvent('editcomplete', me);
             });
 
+            // Table
+            me.mnuTableMerge = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-merge-cells',
+                caption     : me.mergeCellsText
+            });
+
+            me.mnuTableSplit = new Common.UI.MenuItem({
+                caption     : me.splitCellsText
+            });
+
+            me.menuTableCellAlign = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-align-top',
+                caption  : me.cellAlignText,
+                menu    : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        me.menuTableCellTop = new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-align-top',
+                            caption     : me.textShapeAlignTop,
+                            checkable   : true,
+                            checkmark   : false,
+                            toggleGroup : 'popuptablecellalign',
+                            value       : Asc.c_oAscVertAlignJc.Top
+                        }),
+                        me.menuTableCellCenter = new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-align-middle',
+                            caption     : me.textShapeAlignMiddle,
+                            checkable   : true,
+                            checkmark   : false,
+                            toggleGroup : 'popuptablecellalign',
+                            value       : Asc.c_oAscVertAlignJc.Center
+                        }),
+                        me.menuTableCellBottom = new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-align-bottom',
+                            caption     : me.textShapeAlignBottom,
+                            checkable   : true,
+                            checkmark   : false,
+                            toggleGroup : 'popuptablecellalign',
+                            value       : Asc.c_oAscVertAlignJc.Bottom
+                        })
+                    ]
+                })
+            });
+
+            me.menuTableSaveAsPicture = new Common.UI.MenuItem({
+                caption     : me.textSaveAsPicture
+            });
+
+            var menuTableSaveAsPictureSeparator = new Common.UI.MenuItem({
+                caption     : '--'
+            });
+
+            me.menuTableDistRows = new Common.UI.MenuItem({
+                caption : me.textDistributeRows
+            });
+
+            me.menuTableDistCols = new Common.UI.MenuItem({
+                caption : me.textDistributeCols
+            });
+
+            me.menuTableSelectText = new Common.UI.MenuItem({
+                caption     : me.selectText,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        new Common.UI.MenuItem({
+                            caption     : me.rowText,
+                            value: 0
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.columnText,
+                            value: 1
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.cellText,
+                            value: 2
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.tableText,
+                            value: 3
+                        })
+                    ]
+                })
+            });
+
+            me.menuTableInsertText = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-addcell',
+                caption     : me.insertText,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    style   : 'width: 100px',
+                    items   : [
+                        new Common.UI.MenuItem({
+                            caption: me.insertColumnLeftText,
+                            value: 0
+                        }),
+                        new Common.UI.MenuItem({
+                            caption: me.insertColumnRightText,
+                            value: 1
+                        }),
+                        new Common.UI.MenuItem({
+                            caption: me.insertRowAboveText,
+                            value: 2
+                        }),
+                        new Common.UI.MenuItem({
+                            caption: me.insertRowBelowText,
+                            value: 3
+                        })
+                    ]
+                })
+            });
+
+            me.menuTableDeleteText = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-delcell',
+                caption     : me.deleteText,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        new Common.UI.MenuItem({
+                            caption     : me.rowText,
+                            value: 0
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.columnText,
+                            value: 1
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.tableText,
+                            value: 2
+                        })
+                    ]
+                })
+            });
+
+            me.menuTableAdvanced = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-menu-table',
+                caption     : me.advancedTableText
+            });
+
+            var menuTableSettingsSeparator = new Common.UI.MenuItem({
+                caption : '--'
+            });
+
+            me.menuAddHyperlinkTable = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-inserthyperlink',
+                caption     : me.hyperlinkText
+            });
+
+            me.menuEditHyperlinkTable = new Common.UI.MenuItem({
+                caption     : me.editHyperlinkText
+            });
+
+            me.menuRemoveHyperlinkTable = new Common.UI.MenuItem({
+                caption     : me.removeHyperlinkText
+            });
+
+            var menuHyperlinkTable = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-inserthyperlink',
+                caption     : me.hyperlinkText,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        me.menuEditHyperlinkTable,
+                        me.menuRemoveHyperlinkTable
+                    ]
+                })
+            });
+
+            var menuHyperlinkSeparator = new Common.UI.MenuItem({
+                caption     : '--'
+            });
+
+            me.menuAddCommentTable = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-add-comment',
+                caption     : me.addCommentText
+            });
+            me.menuAddCommentTable.hide();
+
+            me.menuTableCopy = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-copy',
+                caption : me.textCopy,
+                value : 'copy'
+            });
+
+            me.menuTablePaste = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-paste',
+                caption : me.textPaste,
+                value : 'paste'
+            });
+
+            me.menuTableCut = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-cut',
+                caption : me.textCut,
+                value : 'cut'
+            });
+
+            var menuTableEquationSeparator = new Common.UI.MenuItem({
+                caption     : '--'
+            });
+
+            var menuTableEquationSettingsSeparator = new Common.UI.MenuItem({
+                caption     : '--'
+            });
+
+            me.menuTableEquationSettings = new Common.UI.MenuItem({
+                caption     : me.advancedEquationText,
+                iconCls     : 'menu__icon btn-equation',
+                menu        : me.createEquationMenu('popuptableeqinput', 'tl-tr')
+            });
+
+            me.tableMenu = new Common.UI.Menu({
+                cls: 'shifted-right',
+                restoreHeightAndTop: true,
+                scrollToCheckedItem: false,
+                initMenu: function(value){
+                    // table properties
+                    if (_.isUndefined(value.tableProps))
+                        return;
+
+                    var isEquation= (value.mathProps && value.mathProps.value);
+                    for (var i = 4; i < 16; i++) {
+                        me.tableMenu.items[i].setVisible(!isEquation);
+                    }
+
+                    var align = value.tableProps.value.get_CellsVAlign();
+                    var cls = '';
+                    switch (align) {
+                        case Asc.c_oAscVertAlignJc.Top:
+                            cls = 'menu__icon btn-align-top';
+                            break;
+                        case Asc.c_oAscVertAlignJc.Center:
+                            cls = 'menu__icon btn-align-middle';
+                            break;
+                        case Asc.c_oAscVertAlignJc.Bottom:
+                            cls = 'menu__icon btn-align-bottom';
+                            break;
+                    }
+                    me.menuTableCellAlign.setIconCls(cls);
+                    me.menuTableCellTop.setChecked(align == Asc.c_oAscVertAlignJc.Top);
+                    me.menuTableCellCenter.setChecked(align == Asc.c_oAscVertAlignJc.Center);
+                    me.menuTableCellBottom.setChecked(align == Asc.c_oAscVertAlignJc.Bottom);
+
+                    if (me.api) {
+                        me.mnuTableMerge.setDisabled(value.tableProps.locked || !me.api.CheckBeforeMergeCells());
+                        me.mnuTableSplit.setDisabled(value.tableProps.locked || !me.api.CheckBeforeSplitCells());
+                    }
+                    me.menuTableDistRows.setDisabled(value.tableProps.locked);
+                    me.menuTableDistCols.setDisabled(value.tableProps.locked);
+
+                    me.tableMenu.items[5].setDisabled(value.tableProps.locked);
+                    me.tableMenu.items[6].setDisabled(value.tableProps.locked);
+
+                    me.menuTableCellAlign.setDisabled(value.tableProps.locked);
+
+                    me.menuTableSaveAsPicture.setVisible(!isEquation);
+                    menuTableSaveAsPictureSeparator.setVisible(!isEquation);
+
+                    me.menuTableAdvanced.setVisible(!isEquation);
+                    me.menuTableAdvanced.setDisabled(value.tableProps.locked);
+                    menuTableSettingsSeparator.setVisible(me.menuTableAdvanced.isVisible());
+
+                    var cancopy = me.api && me.api.can_CopyCut();
+                    me.menuTableCopy.setDisabled(!cancopy);
+                    me.menuTableCut.setDisabled(value.tableProps.locked || !cancopy);
+                    me.menuTablePaste.setDisabled(value.tableProps.locked);
+
+                    // hyperlink properties
+                    var text = null;
+
+                    if (me.api) {
+                        text = me.api.can_AddHyperlink();
+                    }
+
+                    me.menuAddHyperlinkTable.setVisible(!_.isUndefined(value.paraProps) && _.isUndefined(value.hyperProps) && text!==false);
+                    menuHyperlinkTable.setVisible(!_.isUndefined(value.paraProps) && !_.isUndefined(value.hyperProps));
+                    menuHyperlinkSeparator.setVisible(me.menuAddHyperlinkTable.isVisible() || menuHyperlinkTable.isVisible());
+
+                    me.menuEditHyperlinkTable.hyperProps = value.hyperProps;
+
+                    if (text!==false) {
+                        me.menuAddHyperlinkTable.hyperProps = {};
+                        me.menuAddHyperlinkTable.hyperProps.value = new Asc.CHyperlinkProperty();
+                        me.menuAddHyperlinkTable.hyperProps.value.put_Text(text);
+                    }
+                    if (!_.isUndefined(value.paraProps)) {
+                        me.menuAddHyperlinkTable.setDisabled(value.paraProps.locked);
+                        menuHyperlinkTable.setDisabled(value.paraProps.locked);
+                        me._currentParaObjDisabled = value.paraProps.locked;
+                    }
+
+                    me.menuAddCommentTable.setVisible(me.mode && me.mode.canComments);
+                    menuHyperlinkSeparator.setVisible(menuHyperlinkSeparator.isVisible() || me.menuAddCommentTable.isVisible());
+
+                    //equation menu
+                    var eqlen = 0;
+                    if (isEquation) {
+                        eqlen = me.addEquationMenu(false, 4);
+                    } else
+                        me.clearEquationMenu(false, 4);
+
+                    menuTableEquationSeparator.setVisible(eqlen>0);
+                    me.menuTableEquationSettings.setVisible(isEquation);
+                    menuTableEquationSettingsSeparator.setVisible(isEquation);
+                    if (isEquation) {
+                        var eq = me.api.asc_GetMathInputType(),
+                            isEqToolbarHide = Common.Utils.InternalSettings.get('pdfe-equation-toolbar-hide');
+
+                        me.menuTableEquationSettings.menu.items[5].setChecked(eq===Asc.c_oAscMathInputType.Unicode);
+                        me.menuTableEquationSettings.menu.items[6].setChecked(eq===Asc.c_oAscMathInputType.LaTeX);
+                        me.menuTableEquationSettings.menu.items[8].options.isToolbarHide = isEqToolbarHide;
+                        me.menuTableEquationSettings.menu.items[8].setCaption(isEqToolbarHide ? me.showEqToolbar : me.hideEqToolbar);
+                    }
+                },
+                items: [
+                    me.menuTableCut,                //0
+                    me.menuTableCopy,               //1
+                    me.menuTablePaste,              //2
+                    { caption: '--' },              //3
+                    me.menuTableSelectText,         //4
+                    me.menuTableInsertText,         //5
+                    me.menuTableDeleteText,         //6
+                    { caption: '--' },              //7
+                    me.mnuTableMerge,               //8
+                    me.mnuTableSplit,               //9
+                    { caption: '--' },              //10
+                    me.menuTableDistRows,           //11
+                    me.menuTableDistCols,           //12
+                    { caption: '--' },              //13
+                    me.menuTableCellAlign,          //14
+                    { caption: '--'},               //15
+                    menuTableEquationSeparator,     //16
+                    me.menuTableSaveAsPicture,      //17
+                    menuTableSaveAsPictureSeparator,//18
+                    me.menuTableAdvanced,           //19
+                    menuTableSettingsSeparator,     //20
+                    me.menuTableEquationSettings,           //21
+                    menuTableEquationSettingsSeparator,     //22
+                    /** coauthoring begin **/
+                    me.menuAddCommentTable,         //23
+                    /** coauthoring end **/
+                    me.menuAddHyperlinkTable,       //24
+                    menuHyperlinkTable,             //25
+                    menuHyperlinkSeparator         //26
+                ]
+            }).on('hide:after', function(menu, e, isFromInputControl) {
+                me.clearCustomItems(menu);
+                me.currentMenu = null;
+                if (me.suppressEditComplete) {
+                    me.suppressEditComplete = false;
+                    return;
+                }
+
+                if (!isFromInputControl) me.fireEvent('editcomplete', me);
+            });
+
+            // Image
+            me.menuImageAdvanced = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-menu-image',
+                caption     : me.advancedImageText
+            });
+
+            me.menuShapeAdvanced = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-menu-shape',
+                caption     : me.advancedShapeText
+            });
+
+            var menuAdvancedSettingsSeparator = new Common.UI.MenuItem({
+                caption : '--'
+            });
+
+            me.mnuGroupImg = new Common.UI.MenuItem({
+                caption     : this.txtGroup,
+                iconCls     : 'menu__icon btn-shape-group'
+            });
+
+            me.mnuUnGroupImg = new Common.UI.MenuItem({
+                caption     : this.txtUngroup,
+                iconCls     : 'menu__icon btn-shape-ungroup'
+            });
+
+            me.mnuArrangeFront = new Common.UI.MenuItem({
+                caption     : this.textArrangeFront,
+                iconCls     : 'menu__icon btn-arrange-front'
+            });
+
+            me.mnuArrangeBack = new Common.UI.MenuItem({
+                caption     : this.textArrangeBack,
+                iconCls     : 'menu__icon btn-arrange-back'
+            });
+
+            me.mnuArrangeForward = new Common.UI.MenuItem({
+                caption     : this.textArrangeForward,
+                iconCls     : 'menu__icon btn-arrange-forward'
+            });
+
+            me.mnuArrangeBackward = new Common.UI.MenuItem({
+                caption     : this.textArrangeBackward,
+                iconCls     : 'menu__icon btn-arrange-backward'
+            });
+
+            var menuImgShapeArrange = new Common.UI.MenuItem({
+                caption     : me.txtArrange,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        me.mnuArrangeFront,
+                        me.mnuArrangeBack,
+                        me.mnuArrangeForward,
+                        me.mnuArrangeBackward,
+                        {caption: '--'},
+                        me.mnuGroupImg,
+                        me.mnuUnGroupImg
+                    ]
+                })
+            });
+
+            me.menuImgShapeAlign = new Common.UI.MenuItem({
+                caption     : me.txtAlign,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        new Common.UI.MenuItem({
+                            caption     : me.textShapeAlignLeft,
+                            iconCls     : 'menu__icon btn-shape-align-left',
+                            value       : Asc.c_oAscAlignShapeType.ALIGN_LEFT
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.textShapeAlignCenter,
+                            iconCls     : 'menu__icon btn-shape-align-center',
+                            value       : Asc.c_oAscAlignShapeType.ALIGN_CENTER
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.textShapeAlignRight,
+                            iconCls     : 'menu__icon btn-shape-align-right',
+                            value       : Asc.c_oAscAlignShapeType.ALIGN_RIGHT
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.textShapeAlignTop,
+                            iconCls     : 'menu__icon btn-shape-align-top',
+                            value       : Asc.c_oAscAlignShapeType.ALIGN_TOP
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.textShapeAlignMiddle,
+                            iconCls     : 'menu__icon btn-shape-align-middle',
+                            value       : Asc.c_oAscAlignShapeType.ALIGN_MIDDLE
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.textShapeAlignBottom,
+                            iconCls     : 'menu__icon btn-shape-align-bottom',
+                            value       : Asc.c_oAscAlignShapeType.ALIGN_BOTTOM
+                        }),
+                        {caption    : '--'},
+                        new Common.UI.MenuItem({
+                            caption     : me.txtDistribHor,
+                            iconCls     : 'menu__icon btn-shape-distribute-hor',
+                            value       : 6
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : me.txtDistribVert,
+                            iconCls     : 'menu__icon btn-shape-distribute-vert',
+                            value       : 7
+                        })
+                    ]
+                })
+            });
+
+            var menuImgShapeSeparator = new Common.UI.MenuItem({
+                caption     : '--'
+            });
+
+            me.menuImgOriginalSize = new Common.UI.MenuItem({
+                caption     : me.originalSizeText
+            });
+
+            me.menuImgReplace = new Common.UI.MenuItem({
+                caption     : me.textReplace,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        new Common.UI.MenuItem({
+                            caption     : this.textFromFile,
+                            value: 0
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : this.textFromUrl,
+                            value: 1
+                        }),
+                        new Common.UI.MenuItem({
+                            caption     : this.textFromStorage,
+                            value: 2
+                        })
+                    ]
+                })
+            });
+
+            me.menuImgShapeRotate = new Common.UI.MenuItem({
+                caption     : me.textRotate,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-rotate-90',
+                            caption: me.textRotate90,
+                            value  : 1
+                        }),
+                        new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-rotate-270',
+                            caption: me.textRotate270,
+                            value  : 0
+                        }),
+                        { caption: '--' },
+                        new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-flip-hor',
+                            caption: me.textFlipH,
+                            value  : 1
+                        }),
+                        new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-flip-vert',
+                            caption: me.textFlipV,
+                            value  : 0
+                        })
+                    ]
+                })
+            });
+
+            me.menuImgCrop = new Common.UI.MenuItem({
+                caption     : me.textCrop,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        new Common.UI.MenuItem({
+                            caption: me.textCrop,
+                            checkable: true,
+                            allowDepress: true,
+                            value  : 0
+                        }),
+                        new Common.UI.MenuItem({
+                            caption: me.textCropFill,
+                            value  : 1
+                        }),
+                        new Common.UI.MenuItem({
+                            caption: me.textCropFit,
+                            value  : 2
+                        })
+                    ]
+                })
+            });
+
+            me.menuImgSaveAsPicture = new Common.UI.MenuItem({
+                caption     : me.textSaveAsPicture
+            });
+
+            var menuImgSaveAsPictureSeparator = new Common.UI.MenuItem({
+                caption     : '--'
+            });
+
+            me.menuAddCommentImg = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-add-comment',
+                caption     : me.addCommentText
+            });
+            me.menuAddCommentImg.hide();
+
+            me.menuImgCopy = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-copy',
+                caption : me.textCopy,
+                value : 'copy'
+            });
+
+            me.menuImgPaste = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-paste',
+                caption : me.textPaste,
+                value : 'paste'
+            });
+
+            me.menuImgCut = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-cut',
+                caption : me.textCut,
+                value : 'cut'
+            });
+
+            me.menuImgEditPoints = new Common.UI.MenuItem({
+                caption: me.textEditPoints
+            });
+
+            me.pictureMenu = new Common.UI.Menu({
+                cls: 'shifted-right',
+                restoreHeightAndTop: true,
+                scrollToCheckedItem: false,
+                initMenu: function(value){
+                    if (me.api) {
+                        me.mnuUnGroupImg.setDisabled(!me.api.canUnGroup());
+                        me.mnuGroupImg.setDisabled(!me.api.canGroup());
+                    }
+
+                    var isimage = (_.isUndefined(value.shapeProps) || value.shapeProps.value.get_FromImage()) && _.isUndefined(value.chartProps),
+                        imgdisabled = (value.imgProps!==undefined && value.imgProps.locked),
+                        shapedisabled = (value.shapeProps!==undefined && value.shapeProps.locked),
+                        chartdisabled = (value.chartProps!==undefined && value.chartProps.locked),
+                        disabled = imgdisabled || shapedisabled || chartdisabled,
+                        pluginGuid = (value.imgProps) ? value.imgProps.value.asc_getPluginGuid() : null,
+                        inSmartartInternal = value.shapeProps && value.shapeProps.value.get_FromSmartArtInternal();
+
+                    me.mnuArrangeFront.setDisabled(inSmartartInternal);
+                    me.mnuArrangeBack.setDisabled(inSmartartInternal);
+                    me.mnuArrangeForward.setDisabled(inSmartartInternal);
+                    me.mnuArrangeBackward.setDisabled(inSmartartInternal);
+
+                    me.menuImgShapeRotate.setVisible(_.isUndefined(value.chartProps) && (pluginGuid===null || pluginGuid===undefined));
+                    if (me.menuImgShapeRotate.isVisible()) {
+                        me.menuImgShapeRotate.setDisabled(disabled || (value.shapeProps && value.shapeProps.value.get_FromSmartArt()));
+                        me.menuImgShapeRotate.menu.items[3].setDisabled(inSmartartInternal);
+                        me.menuImgShapeRotate.menu.items[4].setDisabled(inSmartartInternal);
+                    }
+
+                    // image properties
+                    me.menuImgOriginalSize.setVisible(isimage);
+                    if (me.menuImgOriginalSize.isVisible())
+                        me.menuImgOriginalSize.setDisabled(disabled || _.isNull(value.imgProps.value.get_ImageUrl()) || _.isUndefined(value.imgProps.value.get_ImageUrl()));
+
+                    me.menuImgReplace.setVisible(isimage && (pluginGuid===null || pluginGuid===undefined));
+                    if (me.menuImgReplace.isVisible())
+                        me.menuImgReplace.setDisabled(disabled || pluginGuid===null);
+                    me.menuImgReplace.menu.items[2].setVisible(me.mode.canRequestInsertImage || me.mode.fileChoiceUrl && me.mode.fileChoiceUrl.indexOf("{documentType}")>-1);
+
+                    me.menuImgCrop.setVisible(me.api.asc_canEditCrop());
+                    if (me.menuImgCrop.isVisible())
+                        me.menuImgCrop.setDisabled(disabled);
+
+                    var canEditPoints = me.api && me.api.asc_canEditGeometry();
+                    me.menuImgEditPoints.setVisible(canEditPoints);
+                    canEditPoints && me.menuImgEditPoints.setDisabled(disabled);
+
+                    me.menuImageAdvanced.setVisible(isimage);
+                    me.menuShapeAdvanced.setVisible(_.isUndefined(value.imgProps)   && _.isUndefined(value.chartProps));
+                    // me.menuChartEdit.setVisible(_.isUndefined(value.imgProps) && !_.isUndefined(value.chartProps) && (_.isUndefined(value.shapeProps) || value.shapeProps.isChart));
+                    // me.menuChartAdvanced.setVisible(_.isUndefined(value.imgProps) && !_.isUndefined(value.chartProps) && (_.isUndefined(value.shapeProps) || value.shapeProps.isChart));
+                    menuImgShapeSeparator.setVisible(me.menuImageAdvanced.isVisible() || me.menuShapeAdvanced.isVisible() || /*me.menuChartEdit.isVisible() || */me.menuChartAdvanced.isVisible());
+                    menuAdvancedSettingsSeparator.setVisible(
+                        me.menuImgCrop.isVisible() || me.menuImgOriginalSize.isVisible() ||
+                        me.menuImgReplace.isVisible() || me.menuImageAdvanced.isVisible() ||
+                        me.menuImgEditPoints.isVisible() || me.menuShapeAdvanced.isVisible() /*||
+                        me.menuChartEdit.isVisible() || me.menuChartAdvanced.isVisible()*/
+                    );
+
+                    /** coauthoring begin **/
+                    me.menuAddCommentImg.setVisible(me.mode && me.mode.canComments);
+                    /** coauthoring end **/
+                    me.menuImgShapeAlign.setDisabled(disabled);
+                    if (!disabled) {
+                        var objcount = me.api.asc_getSelectedDrawingObjectsCount(),
+                            slide_checked = Common.Utils.InternalSettings.get("pdfe-align-to-slide") || false;
+                        me.menuImgShapeAlign.menu.items[7].setDisabled(objcount==2 && !slide_checked);
+                        me.menuImgShapeAlign.menu.items[8].setDisabled(objcount==2 && !slide_checked);
+                    }
+                    me.menuImageAdvanced.setDisabled(disabled);
+                    me.menuShapeAdvanced.setDisabled(disabled);
+                    // me.menuChartAdvanced.setDisabled(disabled);
+                    // if (me.menuChartEdit.isVisible())
+                    //     me.menuChartEdit.setDisabled(disabled);
+
+                    var cancopy = me.api && me.api.can_CopyCut();
+                    me.menuImgCopy.setDisabled(!cancopy);
+                    me.menuImgCut.setDisabled(disabled || !cancopy);
+                    me.menuImgPaste.setDisabled(disabled);
+                    menuImgShapeArrange.setDisabled(disabled);
+                    me.menuAddToLayoutImg.setDisabled(disabled);
+                },
+                items: [
+                    me.menuImgCut,
+                    me.menuImgCopy,
+                    me.menuImgPaste,
+                    { caption: '--' },              //Separator
+                    menuImgShapeArrange,
+                    me.menuImgShapeAlign,
+                    me.menuImgShapeRotate,
+                    menuImgShapeSeparator,          //Separator
+                    me.menuImgSaveAsPicture,
+                    menuImgSaveAsPictureSeparator,     //Separator
+                    me.menuImgCrop,
+                    me.menuImgOriginalSize,
+                    me.menuImgReplace,
+                    me.menuImageAdvanced,
+                    me.menuImgEditPoints,
+                    me.menuShapeAdvanced,
+                    // me.menuChartEdit,
+                    // me.menuChartAdvanced,
+                    menuAdvancedSettingsSeparator,  //Separator
+                    /** coauthoring begin **/
+                    me.menuAddCommentImg
+                ]
+            }).on('hide:after', function(menu, e, isFromInputControl) {
+                me.clearCustomItems(menu);
+                me.currentMenu = null;
+                if (me.suppressEditComplete) {
+                    me.suppressEditComplete = false;
+                    return;
+                }
+
+                if (!isFromInputControl) me.fireEvent('editcomplete', me);
+            });
+
+            // Paragraph
+            me.menuParagraphAdvanced = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-paragraph',
+                caption     : me.advancedParagraphText
+            });
+
+            var menuCommentParaSeparator = new Common.UI.MenuItem({
+                caption : '--'
+            });
+
+            me.menuAddHyperlinkPara = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-inserthyperlink',
+                caption : me.hyperlinkText
+            });
+
+            me.menuEditHyperlinkPara = new Common.UI.MenuItem({
+                caption : me.editHyperlinkText
+            });
+
+            me.menuRemoveHyperlinkPara = new Common.UI.MenuItem({
+                caption : me.removeHyperlinkText
+            });
+
+            var menuHyperlinkPara = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-inserthyperlink',
+                caption     : me.hyperlinkText,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        me.menuEditHyperlinkPara,
+                        me.menuRemoveHyperlinkPara
+                    ]
+                })
+            });
+
+            me.menuParagraphVAlign = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-align-top',
+                caption     : me.vertAlignText,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items: [
+                        me.menuParagraphTop = new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-align-top',
+                            caption     : me.textShapeAlignTop,
+                            checkable   : true,
+                            checkmark   : false,
+                            toggleGroup : 'popupparagraphvalign',
+                            value       : Asc.c_oAscVAlign.Top
+                        }),
+                        me.menuParagraphCenter = new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-align-middle',
+                            caption     : me.textShapeAlignMiddle,
+                            checkable   : true,
+                            checkmark   : false,
+                            toggleGroup : 'popupparagraphvalign',
+                            value       : Asc.c_oAscVAlign.Center
+                        }),
+                        me.menuParagraphBottom = new Common.UI.MenuItem({
+                            iconCls: 'menu__icon btn-align-bottom',
+                            caption     : me.textShapeAlignBottom,
+                            checkable   : true,
+                            checkmark   : false,
+                            toggleGroup : 'popupparagraphvalign',
+                            value       : Asc.c_oAscVAlign.Bottom
+                        })
+                    ]
+                })
+            });
+
+            me.menuParagraphDirection = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-text-orient-hor',
+                caption     : me.directionText,
+                menu        : new Common.UI.Menu({
+                    cls: 'shifted-right',
+                    menuAlign: 'tl-tr',
+                    items   : [
+                        me.menuParagraphDirectH = new Common.UI.MenuItem({
+                            caption     : me.directHText,
+                            iconCls     : 'menu__icon btn-text-orient-hor',
+                            checkable   : true,
+                            checkmark   : false,
+                            checked     : false,
+                            toggleGroup : 'popupparagraphdirect',
+                            direction      : Asc.c_oAscVertDrawingText.normal
+                        }),
+                        me.menuParagraphDirect90 = new Common.UI.MenuItem({
+                            caption     : me.direct90Text,
+                            iconCls     : 'menu__icon btn-text-orient-rdown',
+                            checkable   : true,
+                            checkmark   : false,
+                            checked     : false,
+                            toggleGroup : 'popupparagraphdirect',
+                            direction      : Asc.c_oAscVertDrawingText.vert
+                        }),
+                        me.menuParagraphDirect270 = new Common.UI.MenuItem({
+                            caption     : me.direct270Text,
+                            iconCls     : 'menu__icon btn-text-orient-rup',
+                            checkable   : true,
+                            checkmark   : false,
+                            checked     : false,
+                            toggleGroup : 'popupparagraphdirect',
+                            direction      : Asc.c_oAscVertDrawingText.vert270
+                        })
+                    ]
+                })
+            });
+
+            me.menuAddCommentPara = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-add-comment',
+                caption     : me.addCommentText
+            });
+            me.menuAddCommentPara.hide();
+
+            me.menuParaCopy = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-copy',
+                caption : me.textCopy,
+                value : 'copy'
+            });
+
+            me.menuParaPaste = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-paste',
+                caption : me.textPaste,
+                value : 'paste'
+            });
+
+            me.menuParaCut = new Common.UI.MenuItem({
+                iconCls: 'menu__icon btn-cut',
+                caption : me.textCut,
+                value : 'cut'
+            });
+
+            var menuEquationSeparator = new Common.UI.MenuItem({
+                caption     : '--'
+            });
+
+            me.menuParagraphEquation = new Common.UI.MenuItem({
+                caption     : me.advancedEquationText,
+                iconCls     : 'menu__icon btn-equation',
+                menu        : me.createEquationMenu('popupparaeqinput', 'tl-tr')
+            });
+
+            me.textMenu = new Common.UI.Menu({
+                cls: 'shifted-right',
+                scrollToCheckedItem: false,
+                initMenu: function(value){
+                    var isInShape = (value.shapeProps && !_.isNull(value.shapeProps.value));
+                    var isInChart = (value.chartProps && !_.isNull(value.chartProps.value));
+
+                    var disabled = (value.paraProps!==undefined  && value.paraProps.locked) ||
+                        (isInShape && value.shapeProps.locked);
+                    var isEquation= (value.mathProps && value.mathProps.value);
+                    me._currentParaObjDisabled = disabled;
+
+                    me.menuParagraphVAlign.setVisible(isInShape && !isInChart && !isEquation); // после того, как заголовок можно будет растягивать по вертикали, вернуть "|| isInChart" !!
+                    me.menuParagraphDirection.setVisible(isInShape && !isInChart && !isEquation); // после того, как заголовок можно будет растягивать по вертикали, вернуть "|| isInChart" !!
+                    if (isInShape || isInChart) {
+                        var align = value.shapeProps.value.get_VerticalTextAlign();
+                        var cls = '';
+                        switch (align) {
+                            case Asc.c_oAscVAlign.Top:
+                                cls = 'menu__icon btn-align-top';
+                                break;
+                            case Asc.c_oAscVAlign.Center:
+                                cls = 'menu__icon btn-align-middle';
+                                break;
+                            case Asc.c_oAscVAlign.Bottom:
+                                cls = 'menu__icon btn-align-bottom';
+                                break;
+                        }
+                        me.menuParagraphVAlign.setIconCls(cls);
+                        me.menuParagraphTop.setChecked(align == Asc.c_oAscVAlign.Top);
+                        me.menuParagraphCenter.setChecked(align == Asc.c_oAscVAlign.Center);
+                        me.menuParagraphBottom.setChecked(align == Asc.c_oAscVAlign.Bottom);
+
+                        var dir = value.shapeProps.value.get_Vert();
+                        cls = '';
+                        switch (dir) {
+                            case Asc.c_oAscVertDrawingText.normal:
+                                cls = 'menu__icon btn-text-orient-hor';
+                                break;
+                            case Asc.c_oAscVertDrawingText.vert:
+                                cls = 'menu__icon btn-text-orient-rdown';
+                                break;
+                            case Asc.c_oAscVertDrawingText.vert270:
+                                cls = 'menu__icon btn-text-orient-rup';
+                                break;
+                        }
+                        me.menuParagraphDirection.setIconCls(cls);
+                        me.menuParagraphDirectH.setChecked(dir == Asc.c_oAscVertDrawingText.normal);
+                        me.menuParagraphDirect90.setChecked(dir == Asc.c_oAscVertDrawingText.vert);
+                        me.menuParagraphDirect270.setChecked(dir == Asc.c_oAscVertDrawingText.vert270);
+                    } else {
+                        me.menuParagraphVAlign.setIconCls('');
+                        me.menuParagraphDirection.setIconCls('');
+                    }
+                    me.menuParagraphVAlign.setDisabled(disabled);
+                    me.menuParagraphDirection.setDisabled(disabled);
+
+                    var text = null;
+
+                    if (me.api) {
+                        text = me.api.can_AddHyperlink();
+                    }
+
+                    me.menuAddHyperlinkPara.setVisible(value.hyperProps===undefined && text!==false);
+                    menuHyperlinkPara.setVisible(value.hyperProps!==undefined);
+
+                    me.menuEditHyperlinkPara.hyperProps = value.hyperProps;
+
+                    if (text!==false) {
+                        me.menuAddHyperlinkPara.hyperProps = {};
+                        me.menuAddHyperlinkPara.hyperProps.value = new Asc.CHyperlinkProperty();
+                        me.menuAddHyperlinkPara.hyperProps.value.put_Text(text);
+                    }
+
+                    /** coauthoring begin **/
+                    me.menuAddCommentPara.setVisible(me.mode && me.mode.canComments);
+                    /** coauthoring end **/
+
+                    menuCommentParaSeparator.setVisible(/** coauthoring begin **/ me.menuAddCommentPara.isVisible() || /** coauthoring end **/ me.menuAddHyperlinkPara.isVisible() || menuHyperlinkPara.isVisible());
+                    me.menuAddHyperlinkPara.setDisabled(disabled);
+                    menuHyperlinkPara.setDisabled(disabled);
+
+                    me.menuParagraphAdvanced.setDisabled(disabled);
+                    var cancopy = me.api && me.api.can_CopyCut();
+                    me.menuParaCopy.setDisabled(!cancopy);
+                    me.menuParaCut.setDisabled(disabled || !cancopy);
+                    me.menuParaPaste.setDisabled(disabled);
+
+                    //equation menu
+                    var eqlen = 0;
+                    if (isEquation) {
+                        eqlen = me.addEquationMenu(true, 4);
+                    } else
+                        me.clearEquationMenu(true, 4);
+                    menuEquationSeparator.setVisible(isEquation && eqlen>0);
+
+                    me.menuParagraphEquation.setVisible(isEquation);
+                    me.menuParagraphEquation.setDisabled(disabled);
+                    if (isEquation) {
+                        var eq = me.api.asc_GetMathInputType(),
+                            isEqToolbarHide = Common.Utils.InternalSettings.get('pdfe-equation-toolbar-hide');
+
+                        me.menuParagraphEquation.menu.items[5].setChecked(eq===Asc.c_oAscMathInputType.Unicode);
+                        me.menuParagraphEquation.menu.items[6].setChecked(eq===Asc.c_oAscMathInputType.LaTeX);
+                        me.menuParagraphEquation.menu.items[8].options.isToolbarHide = isEqToolbarHide;
+                        me.menuParagraphEquation.menu.items[8].setCaption(isEqToolbarHide ? me.showEqToolbar : me.hideEqToolbar);
+                    }
+                },
+                items: [
+                    me.menuParaCut,
+                    me.menuParaCopy,
+                    me.menuParaPaste,
+                    menuEquationSeparator,
+                    { caption: '--' },
+                    me.menuParagraphVAlign,
+                    me.menuParagraphDirection,
+                    me.menuParagraphAdvanced,
+                    me.menuParagraphEquation,
+                    menuCommentParaSeparator,
+                    /** coauthoring begin **/
+                    me.menuAddCommentPara,
+                    /** coauthoring end **/
+                    me.menuAddHyperlinkPara,
+                    menuHyperlinkPara
+                ]
+            }).on('hide:after', function(menu, e, isFromInputControl) {
+                me.clearCustomItems(menu);
+                me.currentMenu = null;
+                if (me.suppressEditComplete) {
+                    me.suppressEditComplete = false;
+                    return;
+                }
+
+                if (!isFromInputControl) me.fireEvent('editcomplete', me);
+            });
+
             this.fireEvent('createdelayedelements', [this, 'edit']);
         },
 
@@ -292,6 +1282,581 @@ define([
             });
         },
 
+        initEquationMenu: function() {
+            var me = this;
+            if (!me._currentMathObj) return;
+            var type = me._currentMathObj.get_Type(),
+                value = me._currentMathObj,
+                mnu, arr = [];
+
+            switch (type) {
+                case Asc.c_oAscMathInterfaceType.Accent:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtRemoveAccentChar,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'remove_AccentCharacter'}
+                    });
+                    arr.push(mnu);
+                    break;
+                case Asc.c_oAscMathInterfaceType.BorderBox:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtBorderProps,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        menu        : new Common.UI.Menu({
+                            cls: 'shifted-right',
+                            menuAlign: 'tl-tr',
+                            items   : [
+                                {
+                                    caption: value.get_HideTop() ? me.txtAddTop : me.txtHideTop,
+                                    equationProps: {type: type, callback: 'put_HideTop', value: !value.get_HideTop()}
+                                },
+                                {
+                                    caption: value.get_HideBottom() ? me.txtAddBottom : me.txtHideBottom,
+                                    equationProps: {type: type, callback: 'put_HideBottom', value: !value.get_HideBottom()}
+                                },
+                                {
+                                    caption: value.get_HideLeft() ? me.txtAddLeft : me.txtHideLeft,
+                                    equationProps: {type: type, callback: 'put_HideLeft', value: !value.get_HideLeft()}
+                                },
+                                {
+                                    caption: value.get_HideRight() ? me.txtAddRight : me.txtHideRight,
+                                    equationProps: {type: type, callback: 'put_HideRight', value: !value.get_HideRight()}
+                                },
+                                {
+                                    caption: value.get_HideHor() ? me.txtAddHor : me.txtHideHor,
+                                    equationProps: {type: type, callback: 'put_HideHor', value: !value.get_HideHor()}
+                                },
+                                {
+                                    caption: value.get_HideVer() ? me.txtAddVer : me.txtHideVer,
+                                    equationProps: {type: type, callback: 'put_HideVer', value: !value.get_HideVer()}
+                                },
+                                {
+                                    caption: value.get_HideTopLTR() ? me.txtAddLT : me.txtHideLT,
+                                    equationProps: {type: type, callback: 'put_HideTopLTR', value: !value.get_HideTopLTR()}
+                                },
+                                {
+                                    caption: value.get_HideTopRTL() ? me.txtAddLB : me.txtHideLB,
+                                    equationProps: {type: type, callback: 'put_HideTopRTL', value: !value.get_HideTopRTL()}
+                                }
+                            ]
+                        })
+                    });
+                    arr.push(mnu);
+                    break;
+                case Asc.c_oAscMathInterfaceType.Bar:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtRemoveBar,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'remove_Bar'}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : (value.get_Pos()==Asc.c_oAscMathInterfaceBarPos.Top) ? me.txtUnderbar : me.txtOverbar,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'put_Pos', value: (value.get_Pos()==Asc.c_oAscMathInterfaceBarPos.Top) ? Asc.c_oAscMathInterfaceBarPos.Bottom : Asc.c_oAscMathInterfaceBarPos.Top}
+                    });
+                    arr.push(mnu);
+                    break;
+                case Asc.c_oAscMathInterfaceType.Script:
+                    var scripttype = value.get_ScriptType();
+                    if (scripttype == Asc.c_oAscMathInterfaceScript.PreSubSup) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : me.txtScriptsAfter,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_ScriptType', value: Asc.c_oAscMathInterfaceScript.SubSup}
+                        });
+                        arr.push(mnu);
+                        mnu = new Common.UI.MenuItem({
+                            caption     : me.txtRemScripts,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_ScriptType', value: Asc.c_oAscMathInterfaceScript.None}
+                        });
+                        arr.push(mnu);
+                    } else {
+                        if (scripttype == Asc.c_oAscMathInterfaceScript.SubSup) {
+                            mnu = new Common.UI.MenuItem({
+                                caption     : me.txtScriptsBefore,
+                                equation    : true,
+                                disabled    : me._currentParaObjDisabled,
+                                equationProps: {type: type, callback: 'put_ScriptType', value: Asc.c_oAscMathInterfaceScript.PreSubSup}
+                            });
+                            arr.push(mnu);
+                        }
+                        if (scripttype == Asc.c_oAscMathInterfaceScript.SubSup || scripttype == Asc.c_oAscMathInterfaceScript.Sub ) {
+                            mnu = new Common.UI.MenuItem({
+                                caption     : me.txtRemSubscript,
+                                equation    : true,
+                                disabled    : me._currentParaObjDisabled,
+                                equationProps: {type: type, callback: 'put_ScriptType', value: (scripttype == Asc.c_oAscMathInterfaceScript.SubSup) ? Asc.c_oAscMathInterfaceScript.Sup : Asc.c_oAscMathInterfaceScript.None }
+                            });
+                            arr.push(mnu);
+                        }
+                        if (scripttype == Asc.c_oAscMathInterfaceScript.SubSup || scripttype == Asc.c_oAscMathInterfaceScript.Sup ) {
+                            mnu = new Common.UI.MenuItem({
+                                caption     : me.txtRemSuperscript,
+                                equation    : true,
+                                disabled    : me._currentParaObjDisabled,
+                                equationProps: {type: type, callback: 'put_ScriptType', value: (scripttype == Asc.c_oAscMathInterfaceScript.SubSup) ? Asc.c_oAscMathInterfaceScript.Sub : Asc.c_oAscMathInterfaceScript.None }
+                            });
+                            arr.push(mnu);
+                        }
+                    }
+                    break;
+                case Asc.c_oAscMathInterfaceType.Fraction:
+                    var fraction = value.get_FractionType();
+                    if (fraction==Asc.c_oAscMathInterfaceFraction.Skewed || fraction==Asc.c_oAscMathInterfaceFraction.Linear) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : me.txtFractionStacked,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_FractionType', value: Asc.c_oAscMathInterfaceFraction.Bar}
+                        });
+                        arr.push(mnu);
+                    }
+                    if (fraction==Asc.c_oAscMathInterfaceFraction.Bar || fraction==Asc.c_oAscMathInterfaceFraction.Linear) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : me.txtFractionSkewed,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_FractionType', value: Asc.c_oAscMathInterfaceFraction.Skewed}
+                        });
+                        arr.push(mnu);
+                    }
+                    if (fraction==Asc.c_oAscMathInterfaceFraction.Bar || fraction==Asc.c_oAscMathInterfaceFraction.Skewed) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : me.txtFractionLinear,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_FractionType', value: Asc.c_oAscMathInterfaceFraction.Linear}
+                        });
+                        arr.push(mnu);
+                    }
+                    if (fraction==Asc.c_oAscMathInterfaceFraction.Bar || fraction==Asc.c_oAscMathInterfaceFraction.NoBar) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : (fraction==Asc.c_oAscMathInterfaceFraction.Bar) ? me.txtRemFractionBar : me.txtAddFractionBar,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_FractionType', value: (fraction==Asc.c_oAscMathInterfaceFraction.Bar) ? Asc.c_oAscMathInterfaceFraction.NoBar : Asc.c_oAscMathInterfaceFraction.Bar}
+                        });
+                        arr.push(mnu);
+                    }
+                    break;
+                case Asc.c_oAscMathInterfaceType.Limit:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : (value.get_Pos()==Asc.c_oAscMathInterfaceLimitPos.Top) ? me.txtLimitUnder : me.txtLimitOver,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'put_Pos', value: (value.get_Pos()==Asc.c_oAscMathInterfaceLimitPos.Top) ? Asc.c_oAscMathInterfaceLimitPos.Bottom : Asc.c_oAscMathInterfaceLimitPos.Top}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtRemLimit,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'put_Pos', value: Asc.c_oAscMathInterfaceLimitPos.None}
+                    });
+                    arr.push(mnu);
+                    break;
+                case Asc.c_oAscMathInterfaceType.Matrix:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : value.get_HidePlaceholder() ? me.txtShowPlaceholder : me.txtHidePlaceholder,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'put_HidePlaceholder', value: !value.get_HidePlaceholder()}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.insertText,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        menu        : new Common.UI.Menu({
+                            cls: 'shifted-right',
+                            menuAlign: 'tl-tr',
+                            items   : [
+                                {
+                                    caption: me.insertRowAboveText,
+                                    equationProps: {type: type, callback: 'insert_MatrixRow', value: true}
+                                },
+                                {
+                                    caption: me.insertRowBelowText,
+                                    equationProps: {type: type, callback: 'insert_MatrixRow', value: false}
+                                },
+                                {
+                                    caption: me.insertColumnLeftText,
+                                    equationProps: {type: type, callback: 'insert_MatrixColumn', value: true}
+                                },
+                                {
+                                    caption: me.insertColumnRightText,
+                                    equationProps: {type: type, callback: 'insert_MatrixColumn', value: false}
+                                }
+                            ]
+                        })
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.deleteText,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        menu        : new Common.UI.Menu({
+                            cls: 'shifted-right',
+                            menuAlign: 'tl-tr',
+                            items   : [
+                                {
+                                    caption: me.deleteRowText,
+                                    equationProps: {type: type, callback: 'delete_MatrixRow'}
+                                },
+                                {
+                                    caption: me.deleteColumnText,
+                                    equationProps: {type: type, callback: 'delete_MatrixColumn'}
+                                }
+                            ]
+                        })
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtMatrixAlign,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        menu        : new Common.UI.Menu({
+                            cls: 'shifted-right',
+                            menuAlign: 'tl-tr',
+                            items   : [
+                                {
+                                    caption: me.txtTop,
+                                    checkable   : true,
+                                    checked     : (value.get_MatrixAlign()==Asc.c_oAscMathInterfaceMatrixMatrixAlign.Top),
+                                    equationProps: {type: type, callback: 'put_MatrixAlign', value: Asc.c_oAscMathInterfaceMatrixMatrixAlign.Top}
+                                },
+                                {
+                                    caption: me.centerText,
+                                    checkable   : true,
+                                    checked     : (value.get_MatrixAlign()==Asc.c_oAscMathInterfaceMatrixMatrixAlign.Center),
+                                    equationProps: {type: type, callback: 'put_MatrixAlign', value: Asc.c_oAscMathInterfaceMatrixMatrixAlign.Center}
+                                },
+                                {
+                                    caption: me.txtBottom,
+                                    checkable   : true,
+                                    checked     : (value.get_MatrixAlign()==Asc.c_oAscMathInterfaceMatrixMatrixAlign.Bottom),
+                                    equationProps: {type: type, callback: 'put_MatrixAlign', value: Asc.c_oAscMathInterfaceMatrixMatrixAlign.Bottom}
+                                }
+                            ]
+                        })
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtColumnAlign,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        menu        : new Common.UI.Menu({
+                            cls: 'shifted-right',
+                            menuAlign: 'tl-tr',
+                            items   : [
+                                {
+                                    caption: me.leftText,
+                                    checkable   : true,
+                                    checked     : (value.get_ColumnAlign()==Asc.c_oAscMathInterfaceMatrixColumnAlign.Left),
+                                    equationProps: {type: type, callback: 'put_ColumnAlign', value: Asc.c_oAscMathInterfaceMatrixColumnAlign.Left}
+                                },
+                                {
+                                    caption: me.centerText,
+                                    checkable   : true,
+                                    checked     : (value.get_ColumnAlign()==Asc.c_oAscMathInterfaceMatrixColumnAlign.Center),
+                                    equationProps: {type: type, callback: 'put_ColumnAlign', value: Asc.c_oAscMathInterfaceMatrixColumnAlign.Center}
+                                },
+                                {
+                                    caption: me.rightText,
+                                    checkable   : true,
+                                    checked     : (value.get_ColumnAlign()==Asc.c_oAscMathInterfaceMatrixColumnAlign.Right),
+                                    equationProps: {type: type, callback: 'put_ColumnAlign', value: Asc.c_oAscMathInterfaceMatrixColumnAlign.Right}
+                                }
+                            ]
+                        })
+                    });
+                    arr.push(mnu);
+                    break;
+                case Asc.c_oAscMathInterfaceType.EqArray:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtInsertEqBefore,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'insert_Equation', value: true}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtInsertEqAfter,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'insert_Equation', value: false}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtDeleteEq,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'delete_Equation'}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.alignmentText,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        menu        : new Common.UI.Menu({
+                            cls: 'shifted-right',
+                            menuAlign: 'tl-tr',
+                            items   : [
+                                {
+                                    caption: me.txtTop,
+                                    checkable   : true,
+                                    checked     : (value.get_Align()==Asc.c_oAscMathInterfaceEqArrayAlign.Top),
+                                    equationProps: {type: type, callback: 'put_Align', value: Asc.c_oAscMathInterfaceEqArrayAlign.Top}
+                                },
+                                {
+                                    caption: me.centerText,
+                                    checkable   : true,
+                                    checked     : (value.get_Align()==Asc.c_oAscMathInterfaceEqArrayAlign.Center),
+                                    equationProps: {type: type, callback: 'put_Align', value: Asc.c_oAscMathInterfaceEqArrayAlign.Center}
+                                },
+                                {
+                                    caption: me.txtBottom,
+                                    checkable   : true,
+                                    checked     : (value.get_Align()==Asc.c_oAscMathInterfaceEqArrayAlign.Bottom),
+                                    equationProps: {type: type, callback: 'put_Align', value: Asc.c_oAscMathInterfaceEqArrayAlign.Bottom}
+                                }
+                            ]
+                        })
+                    });
+                    arr.push(mnu);
+                    break;
+                case Asc.c_oAscMathInterfaceType.LargeOperator:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtLimitChange,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'put_LimitLocation', value: (value.get_LimitLocation() == Asc.c_oAscMathInterfaceNaryLimitLocation.UndOvr) ? Asc.c_oAscMathInterfaceNaryLimitLocation.SubSup : Asc.c_oAscMathInterfaceNaryLimitLocation.UndOvr}
+                    });
+                    arr.push(mnu);
+                    if (value.get_HideUpper() !== undefined) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : value.get_HideUpper() ? me.txtShowTopLimit : me.txtHideTopLimit,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_HideUpper', value: !value.get_HideUpper()}
+                        });
+                        arr.push(mnu);
+                    }
+                    if (value.get_HideLower() !== undefined) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : value.get_HideLower() ? me.txtShowBottomLimit : me.txtHideBottomLimit,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_HideLower', value: !value.get_HideLower()}
+                        });
+                        arr.push(mnu);
+                    }
+                    break;
+                case Asc.c_oAscMathInterfaceType.Delimiter:
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtInsertArgBefore,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'insert_DelimiterArgument', value: true}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtInsertArgAfter,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'insert_DelimiterArgument', value: false}
+                    });
+                    arr.push(mnu);
+                    if (value.can_DeleteArgument()) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : me.txtDeleteArg,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'delete_DelimiterArgument'}
+                        });
+                        arr.push(mnu);
+                    }
+                    mnu = new Common.UI.MenuItem({
+                        caption     : value.has_Separators() ? me.txtDeleteCharsAndSeparators : me.txtDeleteChars,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'remove_DelimiterCharacters'}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : value.get_HideOpeningBracket() ? me.txtShowOpenBracket : me.txtHideOpenBracket,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'put_HideOpeningBracket', value: !value.get_HideOpeningBracket()}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : value.get_HideClosingBracket() ? me.txtShowCloseBracket : me.txtHideCloseBracket,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'put_HideClosingBracket', value: !value.get_HideClosingBracket()}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtStretchBrackets,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        checkable   : true,
+                        checked     : value.get_StretchBrackets(),
+                        equationProps: {type: type, callback: 'put_StretchBrackets', value: !value.get_StretchBrackets()}
+                    });
+                    arr.push(mnu);
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtMatchBrackets,
+                        equation    : true,
+                        disabled    : (!value.get_StretchBrackets() || me._currentParaObjDisabled),
+                        checkable   : true,
+                        checked     : value.get_StretchBrackets() && value.get_MatchBrackets(),
+                        equationProps: {type: type, callback: 'put_MatchBrackets', value: !value.get_MatchBrackets()}
+                    });
+                    arr.push(mnu);
+                    break;
+                case Asc.c_oAscMathInterfaceType.GroupChar:
+                    if (value.can_ChangePos()) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : (value.get_Pos()==Asc.c_oAscMathInterfaceGroupCharPos.Top) ? me.txtGroupCharUnder : me.txtGroupCharOver,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_Pos', value: (value.get_Pos()==Asc.c_oAscMathInterfaceGroupCharPos.Top) ? Asc.c_oAscMathInterfaceGroupCharPos.Bottom : Asc.c_oAscMathInterfaceGroupCharPos.Top}
+                        });
+                        arr.push(mnu);
+                        mnu = new Common.UI.MenuItem({
+                            caption     : me.txtDeleteGroupChar,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_Pos', value: Asc.c_oAscMathInterfaceGroupCharPos.None}
+                        });
+                        arr.push(mnu);
+                    }
+                    break;
+                case Asc.c_oAscMathInterfaceType.Radical:
+                    if (value.get_HideDegree() !== undefined) {
+                        mnu = new Common.UI.MenuItem({
+                            caption     : value.get_HideDegree() ? me.txtShowDegree : me.txtHideDegree,
+                            equation    : true,
+                            disabled    : me._currentParaObjDisabled,
+                            equationProps: {type: type, callback: 'put_HideDegree', value: !value.get_HideDegree()}
+                        });
+                        arr.push(mnu);
+                    }
+                    mnu = new Common.UI.MenuItem({
+                        caption     : me.txtDeleteRadical,
+                        equation    : true,
+                        disabled    : me._currentParaObjDisabled,
+                        equationProps: {type: type, callback: 'remove_Radical'}
+                    });
+                    arr.push(mnu);
+                    break;
+            }
+            if (value.can_IncreaseArgumentSize()) {
+                mnu = new Common.UI.MenuItem({
+                    caption     : me.txtIncreaseArg,
+                    equation    : true,
+                    disabled    : me._currentParaObjDisabled,
+                    equationProps: {type: type, callback: 'increase_ArgumentSize'}
+                });
+                arr.push(mnu);
+            }
+            if (value.can_DecreaseArgumentSize()) {
+                mnu = new Common.UI.MenuItem({
+                    caption     : me.txtDecreaseArg,
+                    equation    : true,
+                    disabled    : me._currentParaObjDisabled,
+                    equationProps: {type: type, callback: 'decrease_ArgumentSize'}
+                });
+                arr.push(mnu);
+            }
+            if (value.can_InsertManualBreak()) {
+                mnu = new Common.UI.MenuItem({
+                    caption     : me.txtInsertBreak,
+                    equation    : true,
+                    disabled    : me._currentParaObjDisabled,
+                    equationProps: {type: type, callback: 'insert_ManualBreak'}
+                });
+                arr.push(mnu);
+            }
+            if (value.can_DeleteManualBreak()) {
+                mnu = new Common.UI.MenuItem({
+                    caption     : me.txtDeleteBreak,
+                    equation    : true,
+                    disabled    : me._currentParaObjDisabled,
+                    equationProps: {type: type, callback: 'delete_ManualBreak'}
+                });
+                arr.push(mnu);
+            }
+            if (value.can_AlignToCharacter()) {
+                mnu = new Common.UI.MenuItem({
+                    caption     : me.txtAlignToChar,
+                    equation    : true,
+                    disabled    : me._currentParaObjDisabled,
+                    equationProps: {type: type, callback: 'align_ToCharacter'}
+                });
+                arr.push(mnu);
+            }
+            return arr;
+        },
+
+        addEquationMenu: function(isParagraph, insertIdx) {
+            var me = this;
+            if (_.isUndefined(isParagraph)) {
+                isParagraph = me.textMenu.isVisible();
+            }
+
+            me.clearEquationMenu(isParagraph, insertIdx);
+
+            var equationMenu = (isParagraph) ? me.textMenu : me.tableMenu,
+                menuItems = me.initEquationMenu();
+
+            if (menuItems.length > 0) {
+                _.each(menuItems, function(menuItem, index) {
+                    if (menuItem.menu) {
+                        _.each(menuItem.menu.items, function(item) {
+                            item.on('click', _.bind(me.equationCallback, me, item.options.equationProps));
+                        });
+                    } else
+                        menuItem.on('click', _.bind(me.equationCallback, me, menuItem.options.equationProps));
+                    equationMenu.insertItem(insertIdx, menuItem);
+                    insertIdx++;
+                });
+            }
+            return menuItems.length;
+        },
+
+        equationCallback: function(eqProps) {
+            this.fireEvent('equation:callback', [eqProps]);
+        },
+
+        clearEquationMenu: function(isParagraph, insertIdx) {
+            var me = this;
+            var equationMenu = (isParagraph) ? me.textMenu : me.tableMenu;
+            for (var i = insertIdx; i < equationMenu.items.length; i++) {
+                if (equationMenu.items[i].options.equation) {
+                    if (equationMenu.items[i].menu) {
+                        _.each(equationMenu.items[i].menu.items, function(item) {
+                            item.off('click');
+                        });
+                    } else
+                        equationMenu.items[i].off('click');
+                    equationMenu.removeItem(equationMenu.items[i]);
+                    i--;
+                } else
+                    break;
+            }
+        },
+
         updateCustomItems: function(menu, data) {
             if (!menu || !data || data.length<1) return;
 
@@ -452,7 +2017,151 @@ define([
         allLinearText: 'All - Linear',
         hideEqToolbar: 'Hide Equation Toolbar',
         showEqToolbar: 'Show Equation Toolbar',
-
+        insertRowAboveText      : 'Row Above',
+        insertRowBelowText      : 'Row Below',
+        insertColumnLeftText    : 'Column Left',
+        insertColumnRightText   : 'Column Right',
+        deleteText              : 'Delete',
+        deleteRowText           : 'Delete Row',
+        deleteColumnText        : 'Delete Column',
+        deleteTableText         : 'Delete Table',
+        mergeCellsText          : 'Merge Cells',
+        splitCellsText          : 'Split Cell...',
+        splitCellTitleText      : 'Split Cell',
+        originalSizeText        : 'Actual Size',
+        advancedImageText       : 'Image Advanced Settings',
+        hyperlinkText           : 'Hyperlink',
+        editHyperlinkText       : 'Edit Hyperlink',
+        removeHyperlinkText     : 'Remove Hyperlink',
+        txtPressLink            : 'Press {0} and click link',
+        selectText              : 'Select',
+        insertRowText           : 'Insert Row',
+        insertColumnText        : 'Insert Column',
+        rowText                 : 'Row',
+        columnText              : 'Column',
+        cellText                : 'Cell',
+        tableText               : 'Table',
+        aboveText               : 'Above',
+        belowText               : 'Below',
+        advancedTableText       : 'Table Advanced Settings',
+        txtSelectAll            : 'Select All',
+        textShapeAlignLeft      : 'Align Left',
+        textShapeAlignRight     : 'Align Right',
+        textShapeAlignCenter    : 'Align Center',
+        textShapeAlignTop       : 'Align Top',
+        textShapeAlignBottom    : 'Align Bottom',
+        textShapeAlignMiddle    : 'Align Middle',
+        textArrangeFront        : 'Bring To Front',
+        textArrangeBack         : 'Send To Back',
+        textArrangeForward      : 'Bring Forward',
+        textArrangeBackward     : 'Send Backward',
+        txtGroup                : 'Group',
+        txtUngroup              : 'Ungroup',
+        txtArrange              : 'Arrange',
+        txtAlign                : 'Align',
+        txtDistribHor           : 'Distribute Horizontally',
+        txtDistribVert          : 'Distribute Vertically',
+        cellAlignText           : 'Cell Vertical Alignment',
+        advancedShapeText       : 'Shape Advanced Settings',
+        textSaveAsPicture       : 'Save as picture',
+        vertAlignText           : 'Vertical Alignment',
+        advancedParagraphText   : 'Text Advanced Settings',
+        insertText: 'Insert',
+        directionText: 'Text Direction',
+        directHText: 'Horizontal',
+        direct90Text: 'Rotate Text Down',
+        direct270Text: 'Rotate Text Up',
+        txtRemoveAccentChar: 'Remove accent character',
+        txtBorderProps: 'Borders property',
+        txtHideTop: 'Hide top border',
+        txtHideBottom: 'Hide bottom border',
+        txtHideLeft: 'Hide left border',
+        txtHideRight: 'Hide right border',
+        txtHideHor: 'Hide horizontal line',
+        txtHideVer: 'Hide vertical line',
+        txtHideLT: 'Hide left top line',
+        txtHideLB: 'Hide left bottom line',
+        txtAddTop: 'Add top border',
+        txtAddBottom: 'Add bottom border',
+        txtAddLeft: 'Add left border',
+        txtAddRight: 'Add right border',
+        txtAddHor: 'Add horizontal line',
+        txtAddVer: 'Add vertical line',
+        txtAddLT: 'Add left top line',
+        txtAddLB: 'Add left bottom line',
+        txtRemoveBar: 'Remove bar',
+        txtOverbar: 'Bar over text',
+        txtUnderbar: 'Bar under text',
+        txtRemScripts: 'Remove scripts',
+        txtRemSubscript: 'Remove subscript',
+        txtRemSuperscript: 'Remove superscript',
+        txtScriptsAfter: 'Scripts after text',
+        txtScriptsBefore: 'Scripts before text',
+        txtFractionStacked: 'Change to stacked fraction',
+        txtFractionSkewed: 'Change to skewed fraction',
+        txtFractionLinear: 'Change to linear fraction',
+        txtRemFractionBar: 'Remove fraction bar',
+        txtAddFractionBar: 'Add fraction bar',
+        txtRemLimit: 'Remove limit',
+        txtLimitOver: 'Limit over text',
+        txtLimitUnder: 'Limit under text',
+        txtHidePlaceholder: 'Hide placeholder',
+        txtShowPlaceholder: 'Show placeholder',
+        txtMatrixAlign: 'Matrix alignment',
+        txtColumnAlign: 'Column alignment',
+        txtTop: 'Top',
+        txtBottom: 'Bottom',
+        txtInsertEqBefore: 'Insert equation before',
+        txtInsertEqAfter: 'Insert equation after',
+        txtDeleteEq: 'Delete equation',
+        txtLimitChange: 'Change limits location',
+        txtHideTopLimit: 'Hide top limit',
+        txtShowTopLimit: 'Show top limit',
+        txtHideBottomLimit: 'Hide bottom limit',
+        txtShowBottomLimit: 'Show bottom limit',
+        txtInsertArgBefore: 'Insert argument before',
+        txtInsertArgAfter: 'Insert argument after',
+        txtDeleteArg: 'Delete argument',
+        txtHideOpenBracket: 'Hide opening bracket',
+        txtShowOpenBracket: 'Show opening bracket',
+        txtHideCloseBracket: 'Hide closing bracket',
+        txtShowCloseBracket: 'Show closing bracket',
+        txtStretchBrackets: 'Stretch brackets',
+        txtMatchBrackets: 'Match brackets to argument height',
+        txtGroupCharOver: 'Char over text',
+        txtGroupCharUnder: 'Char under text',
+        txtDeleteGroupChar: 'Delete char',
+        txtHideDegree: 'Hide degree',
+        txtShowDegree: 'Show degree',
+        txtIncreaseArg: 'Increase argument size',
+        txtDecreaseArg: 'Decrease argument size',
+        txtInsertBreak: 'Insert manual break',
+        txtDeleteBreak: 'Delete manual break',
+        txtAlignToChar: 'Align to character',
+        txtDeleteRadical: 'Delete radical',
+        txtDeleteChars: 'Delete enclosing characters',
+        txtDeleteCharsAndSeparators: 'Delete enclosing characters and separators',
+        alignmentText: 'Alignment',
+        leftText: 'Left',
+        rightText: 'Right',
+        centerText: 'Center',
+        textDistributeRows: 'Distribute rows',
+        textDistributeCols: 'Distribute columns',
+        textReplace:    'Replace image',
+        textFromUrl:    'From URL',
+        textFromFile:   'From File',
+        textRotate270: 'Rotate 90° Counterclockwise',
+        textRotate90: 'Rotate 90° Clockwise',
+        textFlipV: 'Flip Vertically',
+        textFlipH: 'Flip Horizontally',
+        textRotate: 'Rotate',
+        textCrop: 'Crop',
+        textCropFill: 'Fill',
+        textCropFit: 'Fit',
+        textFromStorage: 'From Storage',
+        textEditPoints: 'Edit Points',
+        txtInsImage: 'Insert image from File',
+        txtInsImageUrl: 'Insert image from URL'
 
     }, PDFE.Views.DocumentHolder || {}));
 });
\ No newline at end of file