예제 #1
0
        public virtual void HandleDragFinish(object sender, MouseEventArgs e)
        {
            using (Handle.Host.Figure.DirtManager.BeginDirty()) {
                var moveDelta = (Size)e.Location - (Size)_startPoint;
                if (KeyUtil.IsControlPressed())
                {
                    _targets.HideFeedback(_moveRequest);
                    if (_targets.Editors.Any())
                    {
                        var target = _targets.Editors.First().Parent;

                        var cloneRequest = new CloneRequest(_targets.Editors);
                        cloneRequest.MoveDelta = moveDelta;

                        var cmd = target.PerformRequest(cloneRequest) as CloneCommand;
                        if (cmd != null && cmd.ClonedEditors != null)
                        {
                            var select = new SelectMultiCommand(cmd.ClonedEditors, SelectKind.True, true);
                            select.Execute();
                        }
                    }
                }
                else
                {
                    _moveRequest.MoveDelta = moveDelta;
                    _targets.HideFeedback(_moveRequest);
                    _targets.PerformCompositeRequest(_moveRequest, Handle.Host.Site.CommandExecutor);
                }
                Handle.Host.ShowFeedback(new HighlightRequest());
            }
        }
예제 #2
0
        protected virtual void HandleMouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (Host.Children.Any())
            {
                var cmd = new SelectMultiCommand(Host.Children, SelectKind.True, true);
                cmd.Execute();
            }


            /// デフォルト図形の作成
            //var facade = MemopadApplication.Instance;
            //var settings = facade.Settings;
            //var shapeId = settings.DefaultShapeId;

            //var form = (MemopadFormBase) Host.Site.EditorCanvas.TransientData[MemopadConsts.FormEditorTransientDataKey];
            //var reg = form.ToolRegistry;

            //var tool = reg.GetCreateNodeTool(shapeId);
            //tool.CreateNode(Handle.Host, e.Location);
        }
        private void InitMenuItems()
        {
            _cutInNewMemo        = new ToolStripMenuItem("切り出す(&C)");
            _cutInNewMemo.Click += (sender, e) => {
                using (var form = new CreateMemoForm()) {
                    form.Font      = _app.Theme.CaptionFont;
                    form.MemoTitle = "新しいノート";
                    if (form.ShowDialog() == DialogResult.OK)
                    {
                        var copied = Owner.Referer.Target.CopyBlocksAndInlines(Owner.Referer.Selection.Range);

                        _app.ShowMainForm();
                        _app.ActivateMainForm();
                        var info = _app.CreateMemo(form.MemoTitle);

                        if (form.OriginalModification == CreateMemoForm.OriginalModificationKind.Remove)
                        {
                            Owner.RemoveForward();
                        }
                        else if (form.OriginalModification == CreateMemoForm.OriginalModificationKind.ReplaceWithLink)
                        {
                            Owner.RemoveForward();
                            Owner.InsertLink(info.Title, new Link(UriUtil.GetUri(info)));
                            if (copied.Last() is BlockBreak)
                            {
                                Owner.InsertBlockBreak();
                            }
                        }

                        var pageContent = _app.MainForm.FindPageContent(info);
                        var canvas      = pageContent.EditorCanvas;
                        var caret       = canvas.Caret;
                        var loc         = CaretUtil.GetExpectedMemoTextPosition(caret.Position);
                        MemoEditorHelper.AddBlocksAndInlines(canvas.RootEditor.Children.First(), loc, copied, false);
                    }
                }
            };


            _splitThisParagraph        = new ToolStripMenuItem("この行で分割(&S)");
            _splitThisParagraph.Click += (sender, e) => {
                using (_editor.Site.CommandExecutor.BeginChain()) {
                    var referer = Owner.Referer;
                    var stext   = referer.Target;

                    var lineIndex = stext.GetLineIndex(referer.CaretIndex);
                    var lineStart = stext.GetLineStartCharIndex(lineIndex);
                    var flows     = stext.CopyBlocksAndInlines(lineStart);

                    var rect = Rectangle.Empty;
                    rect = _focus.Figure.GetCharRect(lineStart);

                    Owner.Selection.Range = Range.FromStartAndEnd(lineStart - 1, stext.Length - 2);
                    Owner.RemoveForward();
                    _editor.RequestFocus(FocusKind.Commit, null);

                    var loc        = new Point(_editor.Figure.Left, rect.Bottom + 16);
                    var memoEditor = _editor.Parent;
                    var created    = MemoEditorHelper.AddBlocksAndInlines(memoEditor, loc, flows, true);
                    created.RequestFocusCommit(true);
                }
            };

            _splitParagraphs        = new ToolStripMenuItem("段落ごとに分割(&P)");
            _splitParagraphs.Click += (sender, e) => {
                using (_editor.Figure.Root.DirtManager.BeginDirty())
                    using (_editor.Site.CommandExecutor.BeginChain()) {
                        var referer    = Owner.Referer;
                        var stext      = referer.Target;
                        var memoEditor = _editor.Parent;

                        var created  = default(IEditor);
                        var createds = new List <IEditor>();
                        var cTop     = _editor.Figure.Top;
                        foreach (var block in stext.Blocks)
                        {
                            var flows = new Flow[] { block.CloneDeeply() as Block, };
                            var loc   = new Point(_editor.Figure.Left, cTop);
                            created = MemoEditorHelper.AddBlocksAndInlines(memoEditor, loc, flows, true);
                            createds.Add(created);
                            cTop += created.Figure.Height + 16;
                        }
                        created.RequestFocusCommit(true);

                        _editor.RequestRemove();

                        var cmd = new SelectMultiCommand(createds, SelectKind.True, true);
                        cmd.Execute();
                    }
            };


            _openLink        = new ToolStripMenuItem("リンクを開く(&O)");
            _openLink.Click += (sender, e) => {
                var run = Owner.GetInlineAtCaretIndex() as Run;
                if (run != null && run.HasLink)
                {
                    LinkUtil.GoLink(run.Link);
                }
            };

            _removeLink        = new ToolStripMenuItem("リンクを削除(&R)");
            _removeLink.Click += (sender, e) => {
                Owner.UnsetLink();
            };

            _setLink        = new ToolStripMenuItem("リンクを設定(&L)");
            _setLink.Click += (sender, e) => {
                if (Owner.Selection.IsEmpty)
                {
                    var run = Owner.GetInlineAtCaretIndex() as Run;
                    if (run != null)
                    {
                        var oldUri = default(string);
                        if (run != null && run.HasLink)
                        {
                            oldUri = run.Link.Uri;
                        }

                        var oldText = run.Text;
                        var dialog  = new LinkSelectForm();
                        if (dialog.ShowDialog(_app.MainForm, oldUri, run.Text) == DialogResult.OK)
                        {
                            var uri     = dialog.Uri;
                            var newText = dialog.TitleText;
                            if (newText != oldText)
                            {
                                Owner.SetRunText(run, newText);
                            }
                            if (uri != oldUri)
                            {
                                Owner.SetLink(uri, null);
                            }
                        }
                    }
                }
                else
                {
                    var range   = Owner.Selection.Range;
                    var oldText = Owner.Referer.Target.Text.Substring(range.Offset, range.Length);

                    var dialog = new LinkSelectForm();
                    dialog.TitleTextTextBoxEnabled = false;
                    if (dialog.ShowDialog(_app.MainForm, null, oldText) == DialogResult.OK)
                    {
                        Owner.SetLink(dialog.Uri, null);
                    }
                }
            };


            _addComment        = new ToolStripMenuItem("コメントを追加(&C)");
            _addComment.Click += (sender, e) => {
                MemoEditorHelper.AddCommentForMemoText(Owner);
            };
        }
        // ------------------------------
        // private
        // ------------------------------
        private void SelectRange(int startRow, int startCol, int endRow, int endCol)
        {
            var parent    = Host.Parent;
            var tableData = GetParentTableData();

            var rstart = Math.Min(startRow, endRow);
            var cstart = Math.Min(startCol, endCol);
            var rend   = Math.Max(startRow, endRow);
            var cend   = Math.Max(startCol, endCol);

            /// マージを考慮してrstartなどを計算し直す
            var prstart = 0;
            var pcstart = 0;
            var prend   = 0;
            var pcend   = 0;

            /// 処理済みの範囲 (m == marked)
            var mrstart = 0;
            var mcstart = 0;
            var mrend   = 0;
            var mcend   = 0;

            do
            {
                prstart = rstart;
                pcstart = cstart;
                prend   = rend;
                pcend   = cend;

                for (int r = rstart, rlen = rend; r <= rlen; ++r)
                {
                    for (int c = cstart, clen = cend; c <= clen; ++c)
                    {
                        if (r >= mrstart && r <= mrend && c >= mcstart && c <= mcend)
                        {
                            continue;
                        }
                        var row  = tableData.Rows.ElementAt(r);
                        var cell = row.Cells.ElementAt(c);
                        if (cell.IsMerging)
                        {
                            rend = Math.Max(rend, r + cell.RowSpan - 1);
                            cend = Math.Max(cend, c + cell.ColumnSpan - 1);
                        }
                        if (cell.IsMerged)
                        {
                            var merging = cell.Merging;
                            var mr      = tableData.GetRowIndex(merging);
                            var mc      = tableData.GetColumnIndex(merging);
                            rstart = Math.Min(rstart, mr);
                            cstart = Math.Min(cstart, mc);
                            rend   = Math.Max(rend, mr + merging.RowSpan - 1);
                            cend   = Math.Max(cend, mc + merging.ColumnSpan - 1);
                        }
                    }
                }
                mrstart = prstart;
                mcstart = pcstart;
                mrend   = prend;
                mcend   = pcend;
            } while (rstart != prstart || cstart != pcstart || rend != prend || cend != pcend);

            /// 範囲内のeditorを集める
            var editors = new List <IEditor>();

            for (int r = rstart; r <= rend; ++r)
            {
                for (int c = cstart; c <= cend; ++c)
                {
                    var row    = tableData.Rows.ElementAt(r);
                    var cell   = row.Cells.ElementAt(c);
                    var editor = cell.Value.GetEditor();
                    if (editor != null)
                    {
                        editors.Add(editor);
                    }
                }
            }

            if (editors.Count > 0)
            {
                var cmd = new SelectMultiCommand(editors, SelectKind.True, true);
                Host.Site.CommandExecutor.Execute(cmd);
            }
        }