public NodeDetach(MapNode node)
{
this.node = node;
this.parent = node.Parent;
this.siblingAbove = node.Previous;
this.position = node.Pos;
}
public void AddHyperlink()
{
MapCtrl mapCtrl = SetupMapCtrlWithEmptyTree();
var t = mapCtrl.MapView.Tree;
var r = t.RootNode;
var c1 = new MapNode(r, "c1");
var c11 = new MapNode(c1, "6");
var c12 = new MapNode(c1, "2");
var c13 = new MapNode(c1, "4");
var c14 = new MapNode(c1, "7");
var c15 = new MapNode(c1, "1");
var c16 = new MapNode(c1, "5");
var c17 = new MapNode(c1, "3");
var c121 = new MapNode(c12, "c121");
var c2 = new MapNode(r, "c2");
var c3 = new MapNode(r, "c3", NodePosition.Left);
var c31 = new MapNode(c3, "c31");
var c32 = new MapNode(c3, "c32");
r.Selected = true;
t.SelectedNodes.Add(c32, true);
mapCtrl.AddHyperlink("abc");
Assert.AreEqual("abc", r.Link);
Assert.AreEqual("abc", c32.Link);
Assert.IsNull(c31.Link);
}
private void Tree_AttributeChanged(MapNode node, AttributeChangeEventArgs e)
{
//// Task List Change
// task completed
if (e.ChangeType == AttributeChange.Added && e.AttributeSpec.IsCompletionDate())
{
Add(node);
TaskChanged(node, GetEventArgs(node, CompletedTaskChange.TaskCompleted, e));
}
// task removed
else if (e.ChangeType == AttributeChange.Removed && e.AttributeSpec.IsCompletionDate())
{
if (Remove(node))
{
TaskChanged(node, GetEventArgs(node, CompletedTaskChange.TaskRemoved, e));
}
}
// completion date updated
else if(e.ChangeType == AttributeChange.ValueUpdated && e.AttributeSpec.IsCompletionDate())
{
Remove(node);
Add(node);
TaskChanged(node, GetEventArgs(node, CompletedTaskChange.CompletionDateUpdated, e));
}
//// Task Property Change (which doesn't affect list)
else if(CompletedTaskPropertyChanged != null && e.AttributeSpec.IsStartDate() && node.IsTaskComplete())
{
var args = new CompletedTaskPropertyEventArgs(){ PropertyChanged = CompletedTaskProperty.StartDate };
if (!string.IsNullOrEmpty(e.oldValue)) args.OldValue = DateHelper.ToDateTime(e.oldValue);
CompletedTaskPropertyChanged(node, args);
}
}
public void MoveNodeUp()
{
var t = new MapTree();
var r = new MapNode(t, "r");
r.MoveUp();
}
public TaskView(MapNode node, string dueOnText,
Action<TaskView, TaskViewEvent> onTaskViewEvent, bool showDeferOption = true)
{
InitializeComponent();
ShowDeferOption = showDeferOption;
this.ContextMenuStrip = CreateContextMenu();
OnTaskViewEvent = onTaskViewEvent;
SetQuickActionsVisiblity(false);
MapNode = node;
TaskTitle = node.Text;
RefreshTaskPath();
TaskDueOnText = dueOnText;
if (node.Selected)
Selected = true;
this.Paint += new System.Windows.Forms.PaintEventHandler(this.TaskView_Paint);
}
public void SetNoteEditorBackColor()
{
bool result = true;
System.Threading.Thread t = new System.Threading.Thread(() =>
{
MetaModel.MetaModel.Initialize();
var persistence = new PersistenceManager();
var noteEditor = new NoteEditor();
var form = CreateForm();
form.Controls.Add(noteEditor);
form.Shown += (sender, args) =>
{
var ptree1 = persistence.NewTree();
var c1 = new MapNode(ptree1.Tree.RootNode, "c1");
c1.Selected = true;
var sut = new NoteEditorCtrl(noteEditor, persistence);
sut.SetNoteEditorBackColor(Color.Azure);
result = noteEditor.BackColor.Equals(Color.Azure);
form.Close();
};
form.ShowDialog();
});
t.SetApartmentState(System.Threading.ApartmentState.STA);
t.Start();
t.Join();
Assert.IsTrue(result);
}
public void SortChildren_WithRootNodeSortABC_Desc()
{
var r = new MapNode(new MapTree(), "r");
var c1 = new MapNode(r, "C");
var c11 = new MapNode(c1, "c11");
var c12 = new MapNode(c1, "c12");
var c121 = new MapNode(c12, "c121");
var c13 = new MapNode(c1, "c13");
var c131 = new MapNode(c13, "c131");
var c1311 = new MapNode(c131, "c1311");
var c2 = new MapNode(r, "B");
var c3 = new MapNode(r, "C", NodePosition.Left);
var c31 = new MapNode(c3, "c31");
var c32 = new MapNode(c3, "c32");
var c4 = new MapNode(r, "A");
var c5 = new MapNode(r, "F");
var c6 = new MapNode(r, "D");
var c7 = new MapNode(r, "E");
r.SortChildren((node1, node2) => string.CompareOrdinal(node2.Text, node1.Text));
Assert.AreEqual(c5, r.FirstChild);
Assert.AreEqual(c7, r.FirstChild.Next);
Assert.AreEqual(c2, r.LastChild.Previous);
Assert.AreEqual(c4, r.LastChild);
}
/// <summary>
/// Delete this attribute from the given node if attribute exists
/// </summary>
/// <param name="node"></param>
public static void RemoveCompletionDate(MapNode node)
{
MapTree.AttributeSpec aspec = GetAttributeSpec(node.Tree);
if (aspec != null)
{
node.DeleteAttribute(aspec);
}
}
public void SerializeImage_InvalidChar()
{
MetaModel.MetaModel.Initialize();
var refNode = new MapNode(new MapTree(), "OK");
refNode.Italic = true;
var nodeStyle = new NodeStyle("TestStyle\"1", refNode, true);
new NodeStyleImageSerializer().SerializeImage(nodeStyle.Image, nodeStyle.Title);
}
public void Serialize(MapNode node, Emitter emitter)
{
emitter.Emit(new MappingStart());
SerializeScalarProperties(node, emitter);
emitter.Emit(new MappingEnd());
}
public NodeView(MapNode node, PointF location)
{
this.node = node;
this.left = location.X;
this.top = location.Y;
CreateNodeViewContent();
}
private void PendingTasks_TaskTextChanged(MapNode node, TaskTextEventArgs e)
{
TaskReminderDialog dialog = GetOpenDialog(node);
if (dialog == null) return;
if (e.ChangeType == TaskTextChange.TextChange)
dialog.TaskView.TaskTitle = node.Text;
else if (e.ChangeType == TaskTextChange.AncestorTextChange)
dialog.TaskView.RefreshTaskPath();
}
public void Copy(MapNode node, bool multiApply = false)
{
this.formatSource = node;
Status = multiApply? FormatPainterStatus.MultiApply : FormatPainterStatus.SingleApply;
mapView.Canvas.KeyDown += Canvas_KeyDown;
mapView.Canvas.NodeMouseEnter += Canvas_NodeMouseEnter;
mapView.Canvas.NodeMouseExit += Canvas_NodeMouseExit;
if(StateChanged != null) { StateChanged(this); }
}
private void PendingTasks_TaskSelectionChanged(MapNode node, TaskSelectionEventArgs e)
{
TaskReminderDialog dialog = GetOpenDialog(node);
if (dialog == null) return;
if (e.ChangeType == TaskSelectionChange.Selected)
dialog.TaskView.Selected = true;
else
dialog.TaskView.Selected = false;
}
public void Add_ReAddingNode_OneSelectedEvent()
{
var t = new MapTree();
var r = new MapNode(t, "r");
int eventSelectCount = 0;
t.SelectedNodes.NodeSelected += (node, nodes) => eventSelectCount++;
t.SelectedNodes.Add(r);
t.SelectedNodes.Add(r);
Assert.AreEqual(1, eventSelectCount);
}
public void RegisterMap()
{
var t = new MapTree();
var r = new MapNode(t, "r");
ChangeManager manager = new ChangeManager();
manager.RegisterMap(t);
r.Text = "changed";
Assert.IsTrue(manager.CanUndo);
}
public void HighlightedNode()
{
MetaModel.MetaModel.Initialize();
var n = new MapNode(
new MapNode(new MapTree(), null),
"Sample",
NodePosition.Left);
var sut = new StyleImageGenerator(n);
Assert.IsNull(sut.HighlightedNode);
}
public void Add(MapNode node)
{
DateTime dateTime = node.GetDueDate();
ControlGroup ctrlGroup = GetApplicableGroup(dateTime);
if (ctrlGroup != null)
{
ITaskGroup taskGroup = (ITaskGroup)ctrlGroup.Tag;
TaskView tv = new TaskView(node, taskGroup.ShortDueDateString(dateTime), OnTaskViewEvent);
AddToGroup(ctrlGroup, tv);
}
}
public void GetNodeView()
{
MetaModel.MetaModel.Initialize();
var n = new MapNode(
new MapNode(new MapTree(), null),
"Sample",
NodePosition.Left);
var sut = new StyleImageGenerator(n);
var image = sut.GenerateImage();
Assert.IsNotNull(sut.GetNodeView(n));
}
internal IChange CreateChange(MapNode node, IconChangedEventArgs e)
{
switch(e.ChangeType)
{
case IconChange.Added:
return new IconAdd(node, e.Icon);
case IconChange.Removed:
return new IconRemove(node, e.Icon);
default:
return null;
}
}
private void PendingTasks_TaskChanged(MindMate.Model.MapNode node, Model.PendingTaskEventArgs args)
{
taskPlugin.PluginManager.RescheduleTask(reminder, DateTime.Now);
TaskReminderDialog dialog = GetOpenDialog(node);
if (dialog == null)
{
return;
}
dialog.Close();
}
/// <summary>
/// Create a child MapNode and adds task to it
/// </summary>
/// <param name="text"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
public bool AddSubTask(string text, DateTime startDate, DateTime endDate)
{
if(PluginManager.ActiveNodes.Count == 1)
{
MapNode node = new MapNode(PluginManager.ActiveNodes.First, text);
node.SetStartDate(startDate);
node.SetEndDate(endDate);
return true;
}
else
{
return false;
}
}
public static bool GetAttribute(MapNode node, out MapNode.Attribute attribute)
{
MapTree.AttributeSpec aspec = GetAttributeSpec(node.Tree);
if (aspec != null)
{
if (node.GetAttribute(aspec, out attribute))
{
return true;
}
}
attribute = MapNode.Attribute.Empty;
return false;
}
/// <summary>
/// Currently it is hooked up to mouse down event
/// </summary>
/// <param name="node"></param>
/// <param name="evt"></param>
public void MapNodeClick(MapNode node, NodeMouseEventArgs evt)
{
if (mapCtrl.MapView.NodeTextEditor.IsTextEditing)
{
mapCtrl.EndNodeEdit();
return;
}
bool shiftKeyDown = (Control.ModifierKeys & Keys.Shift) == Keys.Shift;
bool ctrlKeyDown = (Control.ModifierKeys & Keys.Control) == Keys.Control;
// Toggle folding or follow link (node has children + no key modifier)
if (node.HasChildren && !shiftKeyDown && !ctrlKeyDown)
{
mapCtrl.MapView.SelectedNodes.Add(node, shiftKeyDown || ctrlKeyDown);
if (node.Link == null || evt.NodePortion == NodePortion.Body)
{
if (node.Parent != null) mapCtrl.ToggleFolded(node);
}
else
{
mapCtrl.FollowLink(node);
}
}
// deselect already selected node (ctrl key + node already selected)
else if (mapCtrl.MapView.SelectedNodes.Count > 1 && mapCtrl.MapView.SelectedNodes.Contains(node) && ctrlKeyDown)
{
mapCtrl.MapView.SelectedNodes.Remove(node);
}
else
{
mapCtrl.MapView.SelectedNodes.Add(node, shiftKeyDown || ctrlKeyDown);
//edit node or follow link (no children + only selected node + no key modifier)
if (mapCtrl.MapView.SelectedNodes.Count == 1 && !node.HasChildren &&
!shiftKeyDown && !ctrlKeyDown)
{
if (node.Link == null)
{
mapCtrl.BeginNodeEdit(node, TextCursorPosition.End);
}
else
{
mapCtrl.FollowLink(node);
}
}
}
}
public void GenerateImage()
{
MetaModel.MetaModel.Initialize();
var n = new MapNode(
new MapNode(new MapTree(), null),
"Sample",
NodePosition.Left);
var sut = new StyleImageGenerator(n);
using (var image = sut.GenerateImage())
{
using (var refImage = Image.FromFile(@"Resources\NodeStyle-GenerateImage.bmp"))
{
Assert.AreEqual(0.0f, image.PercentageDifference(refImage, 0));
}
if (SaveActualImage) image.Save(@"Resources\NodeStyle-GenerateImage-Actual.bmp");
}
}
public void AttachTo_ChildrenAttached()
{
var r = new MapNode(new MapTree(), "r");
var c1 = new MapNode(r, "c1");
var c11 = new MapNode(c1, "c11");
var c12 = new MapNode(c1, "c12");
var c13 = new MapNode(c1, "c13");
var c2 = new MapNode(r, "c2");
var c3 = new MapNode(r, "c3", NodePosition.Left);
var c31 = new MapNode(c3, "c31");
var c32 = new MapNode(c3, "c32");
c3.Detach();
c3.AttachTo(c2);
Assert.IsTrue(c32.IsDescendent(c2));
}
public void AttachTo()
{
var r = new MapNode(new MapTree(), "r");
var c1 = new MapNode(r, "c1");
var c11 = new MapNode(c1, "c11");
var c12 = new MapNode(c1, "c12");
var c13 = new MapNode(c1, "c13");
var c2 = new MapNode(r, "c2");
var c3 = new MapNode(r, "c3", NodePosition.Left);
var c31 = new MapNode(c3, "c31");
var c32 = new MapNode(c3, "c32");
c3.Detach();
c3.AttachTo(c2);
Assert.AreEqual(c2.FirstChild, c3);
}
internal IChange CreateChange(MapNode node, NodePropertyChangedEventArgs e)
{
switch (e.ChangedProperty)
{
case NodeProperties.Text:
return new TextChange(node, (string)e.OldValue);
case NodeProperties.Bold:
return new BoldChange(node, (bool)e.OldValue);
case NodeProperties.Italic:
return new ItalicChange(node, (bool)e.OldValue);
case NodeProperties.Folded:
return new FoldChange(node, (bool)e.OldValue);
case NodeProperties.FontName:
return new FontNameChange(node, (string)e.OldValue);
case NodeProperties.FontSize:
return new FontSizeChange(node, (float)e.OldValue);
case NodeProperties.Link:
return new LinkChange(node, (string)e.OldValue);
case NodeProperties.BackColor:
return new BackColorChange(node, (Color)e.OldValue);
case NodeProperties.Color:
return new ColorChange(node, (Color)e.OldValue);
case NodeProperties.Shape:
return new ShapeChange(node, (NodeShape)e.OldValue);
case NodeProperties.LineWidth:
return new LineWidthChange(node, (int)e.OldValue);
case NodeProperties.LinePattern:
return new LinePatternChange(node, (System.Drawing.Drawing2D.DashStyle)e.OldValue);
case NodeProperties.LineColor:
return new LineColorChange(node, (Color)e.OldValue);
case NodeProperties.NoteText:
return new NoteTextChange(node, (string)e.OldValue);
case NodeProperties.Image:
return new ImageChange(node, (Image)e.OldValue);
case NodeProperties.ImageAlignment:
return new ImageAlignmentChange(node, (ImageAlignment)e.OldValue);
case NodeProperties.Label:
return new LabelChange(node, (string)e.OldValue);
case NodeProperties.Strikeout:
return new StrikeoutChange(node, (bool)e.OldValue);
default:
return null;
}
}
private void Reminder_TaskDue(MindMate.Model.MapNode node, ReminderType reminderType)
{
if (reminderType == ReminderType.Final)
{
TaskReminderDialog dialog = GetOpenDialog(node);
if (dialog != null)
{
dialog.Close();
}
}
TaskReminderDialog dlg = new TaskReminderDialog(node, reminderType);
dlg.Left = Screen.PrimaryScreen.Bounds.Width - 50 - dlg.Width;
dlg.Top = Screen.PrimaryScreen.Bounds.Height - 100 - dlg.Height;
dlg.TaskViewEvent += taskPlugin.OnTaskViewEvent;
openDialogs.Add(dlg);
dlg.FormClosing += Dlg_FormClosing;
dlg.Show();
}
internal IChange CreateChange(MapNode node, TreeStructureChangedEventArgs e)
{
switch(e.ChangeType)
{
case TreeStructureChange.Deleted:
return new NodeDelete(node);
case TreeStructureChange.Detached:
return new NodeDetach(node);
case TreeStructureChange.Attached:
case TreeStructureChange.New:
return new NodeAttach(node);
case TreeStructureChange.MovedLeft:
case TreeStructureChange.MovedDown:
return new MoveDown(node);
case TreeStructureChange.MovedRight:
case TreeStructureChange.MovedUp:
return new MoveUp(node);
default:
return null;
}
}
public void GetDescendentsCount()
{
var r = new MapNode(new MapTree(), "r");
var c1 = new MapNode(r, "C");
var c11 = new MapNode(c1, "6");
var c12 = new MapNode(c1, "2");
var c121 = new MapNode(c12, "c121");
var c13 = new MapNode(c1, "4");
var c14 = new MapNode(c1, "7");
var c15 = new MapNode(c1, "1");
var c16 = new MapNode(c1, "5");
var c17 = new MapNode(c1, "3");
var c2 = new MapNode(r, "B");
var c3 = new MapNode(r, "C", NodePosition.Left);
var c31 = new MapNode(c3, "c31");
var c32 = new MapNode(c3, "c32");
int count = r.GetDescendentsCount();
Assert.AreEqual(13, count);
}
public void AddToSelection()
{
var r = new MapNode(new MapTree(), "r");
var c1 = new MapNode(r, "C");
var c11 = new MapNode(c1, "6");
var c12 = new MapNode(c1, "2");
var c121 = new MapNode(c12, "c121");
var c13 = new MapNode(c1, "4");
var c14 = new MapNode(c1, "7");
var c15 = new MapNode(c1, "1");
var c16 = new MapNode(c1, "5");
var c17 = new MapNode(c1, "3");
var c2 = new MapNode(r, "B");
var c3 = new MapNode(r, "C", NodePosition.Left);
var c31 = new MapNode(c3, "c31");
var c32 = new MapNode(c3, "c32");
r.AddToSelection();
c1.AddToSelection();
Assert.AreEqual(2, r.Tree.SelectedNodes.Count);
}
private static void PasteImage(MapNode pasteLocation)
{
new MapNode(pasteLocation, "").InsertImage(Clipboard.GetImage(), true);
}
public static void Paste(MapNode pasteLocation, bool asText = false, bool pasteFileAsImage = false)
{
if (Clipboard.ContainsData(MindMateClipboardFormat))
{
foreach (MapNode node in internalClipboard)
{
if (asText)
{
new MapNode(pasteLocation, node.Text);
}
else
{
node.CloneAsDetached().AttachTo(pasteLocation);
}
}
}
else if (Clipboard.ContainsText())
{
string link = GetBrowserSourceLink();
MapTextSerializer serializer = new MapTextSerializer();
serializer.Deserialize(Clipboard.GetText(TextDataFormat.Text), pasteLocation,
(parent, text) =>
{
if (asText)
{
return(new MapNode(parent, text));
}
else
{
string tempLink = link; // add link to source website in case text itself is not a URL (if text is URL, link to it)
if (text.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
text.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
{
tempLink = text;
}
return(new MapNode(parent, text)
{
Link = tempLink
});
}
});
}
else if (Clipboard.ContainsImage())
{
PasteImage(pasteLocation);
}
else if (Clipboard.ContainsFileDropList())
{
if (pasteFileAsImage)
{
PasteFileListAsImage(pasteLocation);
}
else
{
PasteFileDropList(pasteLocation, asText);
}
}
hasCutNode = false;
StatusChanged?.Invoke();
if (pasteLocation.Folded)
{
pasteLocation.Folded = false;
}
}
internal void FireEvent(MapNode node, AttributeChangingEventArgs args)
{
AttributeChanging(node, args);
}
public IconList(MapNode node)
{
this.node = node;
}
