private void _saveAsSmartFolderButton_Click(object sender, EventArgs e)
{
using (var dialog = new QueryHolderEditForm()) {
var smartFolder = MemoFactory.CreateTransientSmartFolder();
smartFolder.Name = "新しいスマートフォルダ";
smartFolder.Query = GetQuery();
dialog.QueryHolder = smartFolder;
if (dialog.ShowDialog(_facade.MainForm) == DialogResult.OK)
{
/// これをやっておかないと一度もRootがExpand()されていない場合，
/// 2つノードが作成されてしまう。
/// 理由は未調査。
_facade.MainForm.WorkspaceView.WorkspaceTree.SmartFolderTreePresenter.Root.Expand();
_facade.Container.Persist(dialog.QueryHolder.Query);
_facade.Container.Persist(dialog.QueryHolder);
_facade.MainForm.ShowWorkspaceView();
ClearConditions();
UpdateQuery();
_facade.MainForm.WorkspaceView.WorkspaceTree.SmartFolderTreePresenter.SelectNode(dialog.QueryHolder);
_facade.MainForm.WorkspaceView.WorkspaceTree.Select();
}
}
}
private static CreateNodeCommand GetAddImageCommand(IEditor editor, Point location, Image img)
{
using (editor.Figure.DirtManager.BeginDirty()) {
if (img == null)
{
return(null);
}
var codec = ImageUtil.GetCodec(img);
if (codec == null)
{
codec = ImageUtil.GetCodec(ImageFormat.Png);
}
using (var encoderParams = ImageUtil.CreateEncoderParameters(100L)) {
var imgFilePath = GetNewImageFilePath();
img.Save(imgFilePath, codec, encoderParams);
var desc = new FileImageDescription(Path.GetFileName(imgFilePath));
var req = new CreateNodeRequest();
req.ModelFactory = new DelegatingModelFactory <MemoImage>(
() => {
var ret = MemoFactory.CreateImage();
ret.Image = desc;
return(ret);
}
);
req.Bounds = new Rectangle(location, new Size(img.Width, img.Height));
req.AdjustSizeToGrid = false;
return(editor.GetCommand(req) as CreateNodeCommand);
}
}
}
public virtual MemoTableCell AddCell()
{
var ret = MemoFactory.CreateTableCell();
_cells.Add(ret);
return(ret);
}
public virtual void RemoveColumnAt(int index)
{
Contract.Requires(index >= 0 && index < _columns.Count);
var removedCells = new List <MemoTableCell>();
var column = _columns[index];
_columns.RemoveAt(index);
foreach (var row in _rows)
{
removedCells.Add(row.Cells.ElementAt(index));
row.RemoveCellAt(index);
}
for (int i = index, len = _columns.Count; i < len; ++i)
{
var col = _columns[i];
--col.ColumnIndex;
}
--_columnCount;
OnPropertyRemoved(this, "Columns", column, index);
foreach (var cell in removedCells)
{
MemoFactory.Remove(cell);
}
}
public virtual MemoTableCell InsertCell(int index)
{
Contract.Requires(index >= 0 && index <= _cells.Count);
var ret = MemoFactory.CreateTableCell();
InsertCell(index, ret);
return(ret);
}
public virtual void RemoveRowAt(int index)
{
Contract.Requires(index >= 0 && index < _rows.Count);
var row = _rows[index];
_rows.RemoveAt(index);
--_rowCount;
OnPropertyRemoved(this, "Rows", row, index);
MemoFactory.Remove(row);
}
public virtual MemoTableRow InsertRow(int index)
{
var ret = MemoFactory.CreateTableRow();
for (int i = 0; i < _columnCount; ++i)
{
ret.AddCell();
}
InsertRow(index, ret);
return(ret);
}
public virtual MemoTableRow AddRow()
{
var ret = MemoFactory.CreateTableRow();
for (int i = 0; i < _columnCount; ++i)
{
ret.AddCell();
}
_rows.Add(ret);
++_rowCount;
OnPropertyAdded(this, "Rows", ret, _rowCount - 1);
return(ret);
}
// ========================================
// constructor
// ========================================
public MemoTable ParseCsv(string csv)
{
if (StringUtil.IsNullOrWhitespace(csv))
{
return(null);
}
/// Excelでコピーした場合，
/// 最後に\0が付いているので取り除いておく
if (csv[csv.Length - 1] == '\0')
{
csv = csv.Remove(csv.Length - 1);
}
var ret = MemoFactory.CreateTable();
try {
using (var reader = new CsvReader(new StringReader(csv), false)) {
reader.MissingFieldAction = MissingFieldAction.ReplaceByEmpty;
var colCount = reader.FieldCount;
for (int i = 0; i < colCount; ++i)
{
ret.AddColumn();
}
while (reader.ReadNextRecord())
{
var row = ret.AddRow();
for (int i = 0; i < colCount; ++i)
{
var stext = new StyledText.Core.StyledText();
stext.Font = MemopadApplication.Instance.Settings.GetDefaultMemoTextFont();
var referer = new StyledTextReferer(stext, null, null, null, null);
referer.InsertText(reader[i], false);
var cell = row.Cells.ElementAt(i);
cell.StyledText = stext;
}
}
}
} catch (Exception e) {
Logger.Warn("Parse csv failed.", e);
MemopadApplication.Instance.Container.Remove(ret);
return(null);
}
return(ret);
}
private void _saveAsSmartFilterButton_Click(object sender, EventArgs e)
{
using (var dialog = new QueryHolderEditForm()) {
var smartFilter = MemoFactory.CreateTransientSmartFilter();
smartFilter.Name = "新しいスマートフィルタ";
smartFilter.Query = GetQuery();
dialog.QueryHolder = smartFilter;
if (dialog.ShowDialog(_facade.MainForm) == DialogResult.OK)
{
_facade.Container.Persist(dialog.QueryHolder.Query);
_facade.Container.Persist(dialog.QueryHolder);
ClearConditions();
UpdateQuery();
}
}
}
private void _createSmartFilterToolStripButton_Click(object sender, EventArgs e)
{
using (var dialog = new QueryHolderEditForm()) {
var app = MemopadApplication.Instance;
var filter = MemoFactory.CreateTransientSmartFilter();
filter.Query = MemoFactory.CreateTransientQuery();
filter.Name = "新しいスマートフィルタ";
dialog.QueryHolder = filter;
if (dialog.ShowDialog(app.MainForm) == DialogResult.OK)
{
app.Container.Persist(dialog.QueryHolder.Query);
app.Container.Persist(dialog.QueryHolder);
UpdateSmartFilterListBox();
UpdateToolStrip();
}
}
}
public static void AddCommentForMemoText(StyledTextFocus focus)
{
if (!(focus.Host.Model is MemoText))
{
return;
}
var editor = focus.Host;
var memoEditor = editor.Parent;
editor.Site.Caret.Hide();
var charRect = focus.Figure.GetCharRect(focus.Referer.CaretIndex);
var loc = new Point(focus.Figure.Right + 80, charRect.Top);
editor.RequestFocusCommit(true);
/// テキスト作成
var created = MemoEditorHelper.AddText(memoEditor, loc, "(コメント)", false);
var createdText = (MemoText)created.Model;
var createdFocus = (StyledTextFocus)created.Focus;
createdText.IsSticky = true;
/// コメント線作成
var cmd = new CreateCommentCommand(
memoEditor,
new DelegatingModelFactory <MemoAnchorReference>(
() => {
var ret = MemoFactory.CreateAnchorReference();
return(ret);
}
),
new [] { created.Figure.Location + new Size(1, 1), charRect.Location + new Size(1, 1), },
created,
focus.Host
);
editor.Site.CommandExecutor.Execute(cmd);
editor.Site.Caret.Show();
created.RequestSelect(SelectKind.True, true);
createdFocus.SelectAll();
}
private void AddFreehand(
SelectorCategory cate,
Image image,
string text,
int width,
Color color
)
{
AddTool(
cate,
image,
text,
new FreehandTool(
null,
new DelegatingModelFactory <MemoFreehand>(
() => MemoFactory.CreateFreehand()
),
width,
color
)
);
}
public void CreateSmartFolder()
{
using (var dialog = new QueryHolderEditForm()) {
var smartFolder = MemoFactory.CreateTransientSmartFolder();
smartFolder.Query = MemoFactory.CreateTransientQuery();
smartFolder.Name = "新しいスマートフォルダ";
smartFolder.Query = smartFolder.Query;
dialog.QueryHolder = smartFolder;
if (dialog.ShowDialog(_facade.MainForm) == DialogResult.OK)
{
/// これをやっておかないと一度もRootがExpand()されていない場合，
/// 2つノードが作成されてしまう。
/// 理由は未調査。
_root.Expand();
//_facade.MainForm.WorkspaceView.WorkspaceTree.SmartFolderTreePresenter.Root.Expand();
_facade.Container.Persist(dialog.QueryHolder.Query);
_facade.Container.Persist(dialog.QueryHolder);
SelectNode(dialog.QueryHolder);
}
}
}
public static IEnumerable <IEditor> AddFile(IEditor target, Point location, string filePath, bool embed, bool useCommandExecutor, bool arrange)
{
var isFile = File.Exists(filePath);
var isDirectory = Directory.Exists(filePath);
if (isFile || isDirectory)
{
var fileName = Path.GetFileName(filePath);
var path = filePath;
var embeddedId = "";
if (!isFile && !isDirectory)
{
MessageBox.Show("ファイルが見つかりませんでした。", "ファイルエラー");
return(EmptyEditors);
}
/// 埋め込む場合はEmbeddedFileRootにコピー
if (embed && isFile)
{
embeddedId = Guid.NewGuid().ToString();
path = Path.Combine(embeddedId, fileName);
var fullPath = Path.Combine(MemopadConsts.EmbeddedFileRoot, path);
try {
PathUtil.EnsureDirectoryExists(Path.GetDirectoryName(fullPath));
File.Copy(filePath, fullPath);
} catch {
Logger.Warn("File copy failed. source=" + filePath + ",target=" + fullPath);
if (Directory.Exists(fullPath))
{
Directory.Delete(Path.GetDirectoryName(fullPath), true);
}
MessageBox.Show("ファイルのコピーに失敗しました。", "ファイルコピーエラー");
}
}
var bounds = new Rectangle(location, new Size(1, 1));
var modelFactory = new DelegatingModelFactory <MemoFile>(
() => {
var ret = MemoFactory.CreateFile();
ret.Name = fileName;
ret.Path = path;
ret.IsEmbedded = embed && isFile;
ret.EmbeddedId = embeddedId;
return(ret);
}
);
if (useCommandExecutor && arrange)
{
target.Site.CommandExecutor.BeginChain();
}
var existingEditorBounds = default(Rectangle[]);
if (arrange)
{
existingEditorBounds = target.Children.Select(e => e.Figure.Bounds).ToArray();
}
var req = new CreateNodeRequest();
req.ModelFactory = modelFactory;
req.Bounds = bounds;
req.AdjustSizeToGrid = true;
var cmd = target.GetCommand(req) as CreateNodeCommand;
var sizeCmd = new DelegatingCommand(
() => {
var node = cmd.CreatedEditor.Figure as INode;
if (node != null)
{
node.AdjustSize();
}
},
() => {
cmd.CreatedEditor.Figure.Bounds = bounds;
}
);
var chain = cmd.Chain(sizeCmd);
if (useCommandExecutor)
{
target.Site.CommandExecutor.Execute(chain);
}
else
{
chain.Execute();
}
if (arrange)
{
var newLoc = RectUtil.GetPreferredLocation(
cmd.CreatedEditor.Figure.Bounds,
existingEditorBounds,
target.Root.Figure.Right,
MemopadConsts.DefaultCaretPosition.X,
MemopadConsts.DefaultCaretPosition.Y
);
var move = new ChangeBoundsCommand(
cmd.CreatedEditor,
(Size)newLoc - (Size)cmd.CreatedEditor.Figure.Location,
Size.Empty,
Directions.None,
new [] { cmd.CreatedEditor }
);
if (useCommandExecutor)
{
target.Site.CommandExecutor.Execute(move);
}
else
{
move.Execute();
}
if (useCommandExecutor)
{
target.Site.CommandExecutor.EndChain();
}
}
return(new[] { cmd.CreatedEditor });
}
return(EmptyEditors);
}
public static IEnumerable <IEditor> AddMetafile(IEditor editor, Point location, Metafile meta, bool useCommandExecutor, bool arrange)
{
using (editor.Figure.DirtManager.BeginDirty())
using (var mem = new MemoryStream()) {
if (useCommandExecutor && arrange)
{
editor.Site.CommandExecutor.BeginChain();
}
var existingEditorBounds = default(Rectangle[]);
if (arrange)
{
existingEditorBounds = editor.Children.Select(e => e.Figure.Bounds).ToArray();
}
using (var bmp = new Bitmap(1, 1))
using (var bmpg = Graphics.FromImage(bmp)) {
var hdc = bmpg.GetHdc();
using (var mf = new Metafile(mem, hdc)) {
bmpg.ReleaseHdc(hdc);
using (var g = Graphics.FromImage(mf)) {
g.DrawImage(meta, Point.Empty);
}
}
}
var imgFilePath = GetNewImageFilePath();
File.WriteAllBytes(imgFilePath, mem.GetBuffer());
var desc = new FileImageDescription(Path.GetFileName(imgFilePath));
var req = new CreateNodeRequest();
req.ModelFactory = new DelegatingModelFactory <MemoImage>(
() => {
var ret = MemoFactory.CreateImage();
ret.Image = desc;
return(ret);
}
);
req.Bounds = new Rectangle(location, meta.Size);
req.AdjustSizeToGrid = false;
var cmd = editor.GetCommand(req) as CreateNodeCommand;
if (useCommandExecutor)
{
editor.Site.CommandExecutor.Execute(cmd);
}
else
{
cmd.Execute();
}
meta.Dispose();
if (arrange)
{
var newLoc = RectUtil.GetPreferredLocation(
cmd.CreatedEditor.Figure.Bounds,
existingEditorBounds,
editor.Root.Figure.Right,
MemopadConsts.DefaultCaretPosition.X,
MemopadConsts.DefaultCaretPosition.Y
);
var move = new ChangeBoundsCommand(
cmd.CreatedEditor,
(Size)newLoc - (Size)cmd.CreatedEditor.Figure.Location,
Size.Empty,
Directions.None,
new [] { cmd.CreatedEditor }
);
if (useCommandExecutor)
{
editor.Site.CommandExecutor.Execute(move);
}
else
{
move.Execute();
}
if (useCommandExecutor)
{
editor.Site.CommandExecutor.EndChain();
}
}
return(new[] { cmd.CreatedEditor });
}
}
// ------------------------------
// private
// ------------------------------
//private static ImageCodecInfo GetCodec(ImageFormat format) {
// var codecs = ImageCodecInfo.GetImageDecoders();
// foreach (var codec in codecs) {
// if (codec.FormatID == format.Guid) {
// return codec;
// }
// }
// return null;
//}
//private static ImageCodecInfo GetCodec(Image image) {
// var codecs = ImageCodecInfo.GetImageDecoders();
// foreach (var codec in codecs) {
// if (codec.FormatID == image.RawFormat.Guid) {
// return codec;
// }
// }
// return null;
//}
private static IEditor AddTextBase(IEditor editor, Point location, Action <StyledTextFocus> insert, bool useCommandExecutor)
{
using (editor.Figure.DirtManager.BeginDirty()) {
if (editor.Site.FocusManager.FocusedEditor != null)
{
editor.Site.FocusManager.FocusedEditor.RequestFocusCommit(true);
}
var req = new CreateNodeRequest();
{
req.ModelFactory = new DelegatingModelFactory <MemoText>(
() => {
var ret = MemoFactory.CreateText();
var defaultFont = MemopadApplication.Instance.Settings.GetDefaultMemoTextFont();
if (defaultFont != null)
{
ret.StyledText.Font = defaultFont;
}
return(ret);
}
);
//req.Bounds = new Rectangle(location + MemopadConsts.MemoTextFirstCharDelta, new Size(40, 8));
req.Bounds = new Rectangle(location, new Size(40, 8));
req.AdjustSizeToGrid = true;
}
var cmd = editor.GetCommand(req) as CreateNodeCommand;
if (useCommandExecutor)
{
editor.Site.CommandExecutor.Execute(cmd);
}
else
{
cmd.Execute();
}
/// focus commit commandがこのcreate node commandとマージされるようにしておく
//cmd.MergeJudge = next => {
// var focusCmd = next as FocusCommand;
// if (focusCmd == null) {
// return false;
// }
// return focusCmd.Value == FocusKind.Commit;
// //next is FocusCommand;
//};
if (cmd != null && cmd.CreatedEditor != null)
{
var canvasSize = editor.Site.EditorCanvas.ClientSize;
var maxWidth = 0;
var defaultMaxWidth = MemopadApplication.Instance.WindowSettings.MemoTextDefaultMaxWidth;
if (defaultMaxWidth <= 50)
{
maxWidth = Math.Max((int)(canvasSize.Width * 0.9) - location.X, (int)(canvasSize.Width * 0.5));
}
else
{
maxWidth = defaultMaxWidth;
}
var maxSize = new Size(maxWidth, int.MaxValue);
((INode)cmd.CreatedEditor.Figure).MaxSize = maxSize;
cmd.CreatedEditor.RequestFocus(FocusKind.Begin, location);
var focus = editor.Site.FocusManager.Focus as StyledTextFocus;
insert(focus);
// 1文字目と2文字目が入れ替わってしまう
//cmd.CreatedEditor.RequestFocusCommit(true);
//cmd.CreatedEditor.RequestFocus(FocusKind.Begin, location);
}
return(cmd.CreatedEditor);
}
}
private void ParseTable(HtmlNode node)
{
if (Logger.IsDebugEnabled)
{
Logger.Debug(string.Format("table: {0}, {1}", node.Name, node.InnerText));
}
/// 一時的に退避
var para = _currentParagraph;
var stext = _currentStyledText;
var inBlockQuote = _indent;
var contexts = new Stack <ParserContext>(_contexts);
_currentStyledText = null;
_currentParagraph = null;
_indent = false;
_contexts = new Stack <ParserContext>();
var hasError = false;
if (_currentTable == null)
{
_currentTable = MemoFactory.CreateTable();
_isFirstRow = true;
try {
ParseTableContent(node);
} catch (Exception e) {
Logger.Warn("Parse table error.", e);
MemopadApplication.Instance.Container.Remove(_currentTable);
_currentTable = null;
hasError = true;
}
}
else
{
/// 入れ子tableはInnerTextを貼りつけておくだけ
ParseText(GetInnerText(node), null, true);
return;
}
_currentParagraph = para;
_currentStyledText = stext;
_indent = inBlockQuote;
_contexts = new Stack <ParserContext>(contexts);
if (hasError)
{
/// 失敗したらInnerTextを貼りつけておくだけ
ParseText(GetInnerText(node), null, true);
}
if (_currentTable != null && (_currentTable.RowCount == 0 || _currentTable.ColumnCount == 0))
{
MemopadApplication.Instance.Container.Remove(_currentTable);
return;
}
if (_currentParagraph != null && !_currentParagraph.IsEmpty)
{
if (_currentStyledText == null)
{
_currentStyledText = CreateStyledText(_currentParagraph);
}
else
{
_currentStyledText.Add(_currentParagraph);
}
}
_currentParagraph = null;
if (_currentStyledText != null)
{
_result.Add(_currentStyledText);
_currentStyledText = null;
}
if (_currentTable != null)
{
_result.Add(_currentTable);
_currentTable = null;
}
}
public MemoQuery GetQuery()
{
var ret = MemoFactory.CreateTransientQuery();
ret.Condition = _searchTextBox == null? "": _searchTextBox.Text;
ret.Title = _titleTextBox.Text;
if (
!_tagTextBox.IsUntaggedChecked &&
(_tagTextBox.CheckedTags == null || !_tagTextBox.CheckedTags.Any())
)
{
ret.NarrowByTagIds = false;
}
else
{
ret.NarrowByTagIds = true;
ret.NoTag = _tagTextBox.IsUntaggedChecked;
foreach (var tag in _tagTextBox.CheckedTags)
{
ret.AddTagId(_facade.Container.GetId(tag));
}
ret.TagCompoundKind = _tagTextBox.IsAnyChecked ? MemoConditionCompoundKind.Any : MemoConditionCompoundKind.All;
}
if (_markTextBox.CheckedMarkKinds == null || !_markTextBox.CheckedMarkKinds.Any())
{
ret.NarrowByMarkKinds = false;
}
else
{
ret.NarrowByMarkKinds = true;
foreach (var kind in _markTextBox.CheckedMarkKinds)
{
ret.AddMarkKind(kind);
}
ret.MarkCompoundKind = _markTextBox.IsAnyChecked ? MemoConditionCompoundKind.Any : MemoConditionCompoundKind.All;
}
if (_importanceTextBox.CheckedImportanceKinds == null || !_importanceTextBox.CheckedImportanceKinds.Any())
{
ret.NarrowByImportanceKind = false;
}
else
{
ret.NarrowByImportanceKind = true;
foreach (var kind in _importanceTextBox.CheckedImportanceKinds)
{
ret.AddImportanceKind(kind);
}
}
if (!_timeSpanTextBox.IsRecentTimeSpanSelected)
{
ret.NarrowByRecentTimeSpan = false;
}
else
{
ret.NarrowByRecentTimeSpan = true;
ret.RecentTimeSpan = _timeSpanTextBox.RecentTimeSpan;
}
if (!_timeSpanTextBox.IsTimeSpanSelected)
{
ret.NarrowByTimeSpan = false;
}
else
{
ret.NarrowByTimeSpan = true;
ret.TimeSpan = _timeSpanTextBox.TimeSpan;
}
return(ret);
}
protected void HandleAddTableToolStripButtonClick(object sender, EventArgs e)
{
if (_EditorCanvas == null)
{
return;
}
var dialog = new CreateTableForm();
if (dialog.ShowDialog(this) != DialogResult.OK)
{
return;
}
var colCount = dialog.ColumnCount;
var rowCount = dialog.RowCount;
var target = _EditorCanvas.RootEditor.Content;
var bounds = new Rectangle(32, 32, 100, 100);
var modelFactory = new DelegatingModelFactory <MemoTable>(
() => {
var ret = MemoFactory.CreateTable();
return(ret);
}
);
var req = new CreateNodeRequest();
req.ModelFactory = modelFactory;
req.Bounds = bounds;
var createdBounds = Rectangle.Empty;
var cmd1 = target.GetCommand(req) as CreateNodeCommand;
var cmd2 = new DelegatingCommand(
() => {
var created = cmd1.CreatedEditor;
if (created != null)
{
var table = created.Model as MemoTable;
for (int i = 0; i < colCount; ++i)
{
table.AddColumn();
}
for (int i = 0; i < rowCount; ++i)
{
table.AddRow();
}
}
},
() => {},
() => {
// todo: これでもundo，redoで行，列の幅が復元できない
// Boundsは復元される
var created = cmd1.CreatedEditor;
created.Figure.Bounds = createdBounds;
}
);
var cmd = cmd1.Chain(cmd2);
_EditorCanvas.CommandExecutor.Execute(cmd);
createdBounds = cmd1.CreatedEditor.Figure.Bounds;
dialog.Dispose();
FocusEditorCanvas();
//var cmd = target.RequestCreateNode(modelFactory, bounds) as CreateNodeCommand;
//var created = cmd.CreatedEditor;
//if (created != null) {
// var colCount = 3;
// var rowCount = 3;
// var table = created.Model as MemoTable;
// for (int i = 0; i < colCount; ++i) {
// table.AddColumn();
// }
// for (int i = 0; i < rowCount; ++i) {
// foreach (var cell in table.AddRow().Cells) {
// var run = new Run("テスト" + i);
// var para = new Paragraph(run);
// para.Padding = new Insets();
// para.HorizontalAlignment = HorizontalAlignment.Left;
// var stext = new StyledText(para);
// stext.VerticalAlignment = VerticalAlignment.Center;
// stext.Font = _facade.Settings.GetDefaultMemoContentFont();
// cell.StyledText = stext;
// }
// }
//}
}
protected void MemoMarkDropDownMenuItemClick(ToolStripSplitButton button, MemoMarkKind kind, Image image)
{
if (_EditorCanvas == null)
{
return;
}
var memo = _EditorCanvas.EditorContent as Memo;
var marks = memo.Marks;
var isAdding = !marks.Any(mark => mark.Kind == kind);
if (memo.Marks.Any(mark => mark.Kind == kind))
{
ICollectionUtil.Remove(memo.Marks, mark => mark.Kind == kind);
}
else
{
var newMark = MemoFactory.CreateMark();
newMark.Kind = kind;
memo.Marks.Add(newMark);
}
/// ToolStripSplitButtonを選択されたkindに変更
button.Tag = kind;
button.Image = image;
if (_facade.IsMainFormLoaded)
{
var info = _PageContent.MemoInfo;
_facade.MainForm.InvalidateMemoListBox(new [] { info });
}
_PageContent.IsModified = true;
/// 選択中のノートのマーク設定
//var targets = _EditorCanvas.SelectionManager.SelectedEditors;
//if (!targets.Any(
// editor => {
// var content = editor.Model as MemoContent;
// return content != null && content.IsMarkable;
// }
//)) {
// return;
//}
///// markの追加か削除かの判定，最初のIsMarkableなeditorで判断する
//var first = targets.First(
// editor => {
// var content = editor.Model as MemoContent;
// return content != null && content.IsMarkable;
// }
//);
//var firstContent = first.Model as MemoContent;
//if (firstContent == null) {
// return;
//}
//var firstMarks = firstContent.Marks;
//var isAdding = !firstMarks.Any(mark => mark.Kind == kind);
///// markの変更
//foreach (var target in targets) {
// var content = target.Model as MemoContent;
// if (content == null || !content.IsMarkable) {
// continue;
// }
// if (isAdding && !content.Marks.Any(mark => mark.Kind == kind)) {
// var newMark = MemoFactory.CreateMark();
// newMark.Kind = kind;
// content.Marks.Add(newMark);
// } else if (!isAdding && content.Marks.Any(mark => mark.Kind == kind)) {
// ICollectionUtil.Remove(content.Marks, mark => mark.Kind == kind);
// }
//}
///// ToolStripSplitButtonを選択されたkindに変更
//button.Tag = kind;
//button.Image = image;
}
