Пример #1
1
        /// <summary>
        /// Construct ReoGrid Control.
        /// </summary>
        public ReoGridEditor()
        {
            InitializeComponent();

            NewDocumentOnLoad = true;

            SuspendLayout();
            isUIUpdating = true;

            fontToolStripComboBox.Text = ReoGridControl.DefaultStyle.FontName;

            fontSizeToolStripComboBox.Text = ReoGridControl.DefaultStyle.FontSize.ToString();
            fontSizeToolStripComboBox.Items.AddRange(FontToolkit.FontSizeList.Select(f => (object)f).ToArray());

            backColorPickerToolStripButton.CloseOnClick = true;
            borderColorPickToolStripItem.CloseOnClick = true;
            textColorPickToolStripItem.CloseOnClick = true;

            zoomToolStripDropDownButton.Text = "100%";

            isUIUpdating = false;
            ResumeLayout();

            grid.SelectionRangeChanged += grid_SelectionRangeChanged;
            grid.SelectionModeChanged += (s, e) => UpdateSelectionModeAndStyle();
            grid.SelectionStyleChanged += (s, e) => UpdateSelectionModeAndStyle();
            grid.SelectionForwardDirectionChanged += (s, e) => UpdateSelectionForwardDirection();
            selModeNoneToolStripMenuItem.Click += (s, e) => grid.SelectionMode = ReoGridSelectionMode.None;
            selModeCellToolStripMenuItem.Click += (s, e) => grid.SelectionMode = ReoGridSelectionMode.Cell;
            selModeRangeToolStripMenuItem.Click += (s, e) => grid.SelectionMode = ReoGridSelectionMode.Range;
            selStyleNoneToolStripMenuItem.Click += (s, e) => grid.SelectionStyle = ReoGridSelectionStyle.None;
            selStyleDefaultToolStripMenuItem.Click += (s, e) => grid.SelectionStyle = ReoGridSelectionStyle.Default;
            selStyleFocusRectToolStripMenuItem.Click += (s, e) => grid.SelectionStyle = ReoGridSelectionStyle.FocusRect;
            selDirRightToolStripMenuItem.Click += (s, e) => grid.SelectionForwardDirection = SelectionForwardDirection.Right;
            selDirDownToolStripMenuItem.Click += (s, e) => grid.SelectionForwardDirection = SelectionForwardDirection.Down;

            grid.GridScaled += (ss, ee) => zoomToolStripDropDownButton.Text = grid.ScaleFactor * 100 + "%";
            zoomToolStripDropDownButton.TextChanged += zoomToolStripDropDownButton_TextChanged;

            undoToolStripButton.Click += Undo;
            redoToolStripButton.Click += Redo;
            undoToolStripMenuItem.Click += Undo;
            redoToolStripMenuItem.Click += Redo;

            mergeRangeToolStripMenuItem.Click += MergeSelectionRange;
            cellMergeToolStripButton.Click += MergeSelectionRange;
            unmergeRangeToolStripMenuItem.Click += UnmergeSelectionRange;
            unmergeRangeToolStripButton.Click += UnmergeSelectionRange;
            mergeCellsToolStripMenuItem.Click += MergeSelectionRange;
            unmergeCellsToolStripMenuItem.Click += UnmergeSelectionRange;
            formatCellsToolStripMenuItem.Click += formatCellToolStripMenuItem_Click;
            resizeToolStripMenuItem.Click += resizeToolStripMenuItem_Click;
            textWrapToolStripButton.Click += textWrapToolStripButton_Click;

            grid.ActionPerformed += (s, e) => UpdateMenuAndToolStripsWhenAction(s, e);
            grid.Undid += (s, e) => UpdateMenuAndToolStripsWhenAction(s, e);
            grid.Redid += (s, e) => UpdateMenuAndToolStripsWhenAction(s, e);
            grid.Resetted += (s, e) => statusToolStripStatusLabel.Text = string.Empty;

            rowHeightToolStripMenuItem.Click += (s, e) =>
            {
                using (SetWidthOrHeightForm rowHeightForm = new SetWidthOrHeightForm(ChangeWidthOrHeight.Height))
                {
                    rowHeightForm.Value = grid.GetRowHeight(grid.SelectionRange.Row);
                    if (rowHeightForm.ShowDialog() == DialogResult.OK)
                    {
                        grid.DoAction(new RGSetRowsHeightAction(grid.SelectionRange.Row,
                            grid.SelectionRange.Rows, (ushort)rowHeightForm.Value));
                    }
                }
            };

            columnWidthToolStripMenuItem.Click += (s, e) =>
            {
                using (SetWidthOrHeightForm colWidthForm = new SetWidthOrHeightForm(ChangeWidthOrHeight.Width))
                {
                    colWidthForm.Value = grid.GetColumnWidth(grid.SelectionRange.Col);
                    if (colWidthForm.ShowDialog() == DialogResult.OK)
                    {
                        grid.DoAction(new RGSetColsWidthAction(grid.SelectionRange.Col,
                            grid.SelectionRange.Cols, (ushort)colWidthForm.Value));
                    }
                }
            };

            exportAsHtmlToolStripMenuItem.Click += (s, e) =>
            {
                using (SaveFileDialog sfd = new SaveFileDialog())
                {
                    sfd.Filter="HTML File(*.html;*.htm)|*.html;*.htm";
                    sfd.FileName="Exported ReoGrid";
                    if (sfd.ShowDialog() == DialogResult.OK)
                    {
                        using (FileStream fs = new FileStream(sfd.FileName, FileMode.Create))
                        {
                            grid.ExportAsHTML(fs);
                        }

                        Process.Start(sfd.FileName);
                    }
                }
            };

            editXMLToolStripMenuItem.Click += (s, e) =>
            {
                string filepath = null;

                if (string.IsNullOrEmpty(this.CurrentFilePath))
                {
                    if (string.IsNullOrEmpty(currentTempFilePath))
                    {
                        currentTempFilePath = Path.Combine(Path.GetTempPath(),
                            Path.GetFileNameWithoutExtension(Path.GetTempFileName()) + ".txt");
                        filepath = currentTempFilePath;
                    }
                }
                else
                {
                    if (MessageBox.Show("Editor will save current file, continue?",
                        "Edit XML", MessageBoxButtons.OKCancel, MessageBoxIcon.Question)
                        == System.Windows.Forms.DialogResult.Cancel)
                    {
                        return;
                    }

                    filepath = this.CurrentFilePath;
                }

                using (var fs = new FileStream(filepath, FileMode.Create, FileAccess.Write))
                {
                    grid.Save(fs);
                }

                Process p = Process.Start("notepad.exe", filepath);
                p.WaitForExit();

                if (p.ExitCode == 0)
                {
                    grid.Load(filepath);
                }
            };

            saveAsToolStripMenuItem.Click += (s, e) =>
            {
                string newFilepath = null;

                using (SaveFileDialog sfd = new SaveFileDialog())
                {
                    sfd.Filter = "ReoGrid XML Format(*.rgf;*.xml)|*.rgf;*.xml|All Files(*.*)|*.*";
                    if (sfd.ShowDialog(this) == DialogResult.OK)
                    {
                        newFilepath = sfd.FileName;
                    }
                }

                if (!string.IsNullOrEmpty(newFilepath))
                {
                    SaveFile(newFilepath);
                }
            };

            groupRowsToolStripMenuItem.Click += groupRowsToolStripMenuItem_Click;
            groupRowsToolStripMenuItem1.Click += groupRowsToolStripMenuItem_Click;
            ungroupRowsToolStripMenuItem.Click += ungroupRowsToolStripMenuItem_Click;
            ungroupRowsToolStripMenuItem1.Click += ungroupRowsToolStripMenuItem_Click;
            ungroupAllRowsToolStripMenuItem.Click += ungroupAllRowsToolStripMenuItem_Click;
            ungroupAllRowsToolStripMenuItem1.Click += ungroupAllRowsToolStripMenuItem_Click;

            groupColumnsToolStripMenuItem.Click += groupColumnsToolStripMenuItem_Click;
            groupColumnsToolStripMenuItem1.Click += groupColumnsToolStripMenuItem_Click;
            ungroupColumnsToolStripMenuItem.Click += ungroupColumnsToolStripMenuItem_Click;
            ungroupColumnsToolStripMenuItem1.Click += ungroupColumnsToolStripMenuItem_Click;
            ungroupAllColumnsToolStripMenuItem.Click += ungroupAllColumnsToolStripMenuItem_Click;
            ungroupAllColumnsToolStripMenuItem1.Click += ungroupAllColumnsToolStripMenuItem_Click;

            hideRowsToolStripMenuItem.Click += hideRowToolStripMenuItem_Click;
            unhideRowsToolStripMenuItem.Click += unhideRowsToolStripMenuItem_Click;

            hideColumnsToolStripMenuItem.Click += hideColumnsToolStripMenuItem_Click;
            unhideColumnsToolStripMenuItem.Click += unhideColumnsToolStripMenuItem_Click;

            #if EX_SCRIPT
            scriptEditorToolStripMenuItem.Click += (s, e) =>
            {
                if (scriptEditor == null || scriptEditor.IsDisposed)
                {
                    scriptEditor = new ReoScriptEditor();
                    scriptEditor.Srm = grid.Srm;

                    // copy script form editor to control once script compiled
                    scriptEditor.ScriptCompiled += (ss, ee) =>
                    {
                        grid.Script = scriptEditor.Script;
                    };
                }

                scriptEditor.Show();
                if (grid.Script == null)
                {
                    grid.Script = Resources._default;
                }

                scriptEditor.Script = grid.Script;

                scriptEditor.Disposed += (ss, ee) => grid.Script = scriptEditor.Script;
            };

            runFunctionToolStripMenuItem.Click += (s, e) =>
            {
                using (var runFuncForm = new RunFunctionForm())
                {
                    Cursor = Cursors.WaitCursor;

                    if (grid.Srm != null && grid.Script != null)
                    {
                        var compiledScript = grid.Srm.Compile(grid.Script);
                        runFuncForm.Srm = grid.Srm;
                        runFuncForm.Script = compiledScript;
                    }

                    Cursor = Cursors.Default;

                    runFuncForm.ShowDialog(this);
                }
            };

            #else // EX_SCRIPT

            //scriptToolStripMenuItem.Visible = false;
            scriptEditorToolStripMenuItem.Click += (s, e) =>
            {
              MessageBox.Show("Script execution is not supported by this edition.", Application.ProductName);
            };
            #endif

            #if DEBUG
            #region Debug Validation Events
            grid.RowInserted += (s, e) => _Debug_Auto_Validate_All();
            grid.ColInserted += (s, e) => _Debug_Auto_Validate_All();
            grid.RowDeleted += (s, e) => _Debug_Auto_Validate_All();
            grid.ColDeleted += (s, e) => _Debug_Auto_Validate_All();
            grid.RangeMerged += (s, e) => _Debug_Auto_Validate_All();
            grid.RangeUnmerged += (s, e) => _Debug_Auto_Validate_All(e.Range);
            grid.Undid += (s, e) => _Debug_Auto_Validate_All();
            grid.Redid += (s, e) => _Debug_Auto_Validate_All();
            grid.AfterPaste += (s, e) => _Debug_Auto_Validate_All();

            showDebugInfoToolStripMenuItem.Click += (s, e) =>
            {
                showDebugFormToolStripButton.PerformClick();
                showDebugInfoToolStripMenuItem.Checked = showDebugFormToolStripButton.Checked;
            };

            validateBorderSpanToolStripMenuItem.Click += (s, e) => _Debug_Validate_BorderSpan(true);
            validateMergedRangeToolStripMenuItem.Click += (s, e) => _Debug_Validate_Merged_Cell(true);
            validateAllToolStripMenuItem.Click += (s, e) => _Debug_Validate_All(true);
            #endregion
            #endif // DEBUG
        }
Пример #2
0
 private void linkLabel2_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
 {
     using (ReoScriptEditor editor = new ReoScriptEditor())
     {
         editor.ShowDialog();
     }
 }
Пример #3
0
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            var editor = new ReoScriptEditor();

            editor.Srm.WorkMode = ReoScript.MachineWorkMode.Full;

            Application.Run(editor);
        }
Пример #4
0
 private void ShowScript(byte[] buf, bool directAccess)
 {
     using (ReoScriptEditor editor = new ReoScriptEditor())
     {
         using (StreamReader sr = new StreamReader(new MemoryStream(buf)))
         {
             if (directAccess)
             {
                 editor.Srm.WorkMode |= Unvell.ReoScript.MachineWorkMode.AllowDirectAccess
                                        | Unvell.ReoScript.MachineWorkMode.AllowCLREventBind
                                        | Unvell.ReoScript.MachineWorkMode.AllowImportTypeInScript;
             }
             editor.Script = sr.ReadToEnd();
         }
         editor.ShowDialog();
     }
 }
Пример #5
0
        public void LoadFile(string path)
        {
            this.CurrentFilePath = null;
            if (grid.Load(path))
            {
                this.Text = System.IO.Path.GetFileName(path) + " - ReoGrid Editor";
                showGridToolStripMenuItem.Checked = grid.HasSettings(ReoGridSettings.View_ShowGridLine);
                ShowStatus(string.Empty);
                this.CurrentFilePath = path;
                this.currentTempFilePath = null;

            #if EX_SCRIPT
                // check whether grid contains any scripts
                if (!string.IsNullOrEmpty(grid.Script))
                {
                    if (MessageBox.Show("The document contains macro and executable script. Do you want to run the script now?",
                        "Executable Script", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        if (scriptEditor == null)
                        {
                            scriptEditor = new ReoScriptEditor()
                            {
                                Script = grid.Script,
                                Srm = grid.Srm,
                            };
                        }

                        // run init script
                        grid.RunScript();

                        // show script editor window
                        if (!scriptEditor.Visible)
                        {
                            scriptEditor.Show();
                        }
                    }
                }
            #endif
            }
        }