private static List <DarkTreeNode> GetDirectoryNodes(
ref Stack <DarkTreeNode> stack, DirectoryInfo[] directories, DarkTreeView expandedSourceTreeView, bool expandAllNodes)
{
List <DarkTreeNode> nodes = new List <DarkTreeNode>();
foreach (DirectoryInfo directory in directories)
{
DarkTreeNode childDirectoryNode = new DarkTreeNode(directory.Name)
{
Icon = Properties.Resources.folder.ToBitmap(),
Tag = directory
};
nodes.Add(childDirectoryNode);
stack.Push(childDirectoryNode);
if (expandedSourceTreeView != null)
{
DarkTreeNode expandedSourceChildNode = expandedSourceTreeView.FindNode(childDirectoryNode.FullPath);
if (expandedSourceChildNode != null)
{
childDirectoryNode.Expanded = expandedSourceChildNode.Expanded;
}
}
else if (expandAllNodes)
{
childDirectoryNode.Expanded = true;
}
}
return(nodes);
}
private void Export(bool normalformat)
{
string export = string.Empty;
try
{
DarkTreeNode node = accTree.SelectedNodes[0];
string[] title = node.Text.Split('|');
string gid = title[1].Replace(" ", null);
string date = title[2];
string pw = node.Nodes[0].Text;
string lw = node.Nodes[1].Text;
if (normalformat)
{
export = $"<= Exported by Pollery =>\r\n -> Date: {date} \r\n -> Grow ID: {gid} \r\n -> Password(s): {pw} \r\n -> Last world: {lw}";
}
else
{
export = $"{gid}:{pw}";
}
}
catch
{
DarkMessageBox.ShowWarning("Please select a valid account node.", "Invalid Node", DarkDialogButton.Ok);
return;
}
File.WriteAllText("accounts.txt", export);
DarkMessageBox.ShowInformation("Exported to account.txt!", "Exported successfully.", DarkDialogButton.Ok);
}
private void darkTreeView1_MouseClick(object sender, MouseEventArgs e)
{
if (darkTreeView1.SelectedNodes.Count > 0 && e.Button == MouseButtons.Right)
{
DarkTreeNode dtn = darkTreeView1.SelectedNodes[0];
if (dtn.Icon != Resources.Folder_16x)
{
if ((string)dtn.Tag == "folder")
{
darkContextMenu2.Show(Cursor.Position);
}
else
{
if (canShow)
{
darkContextMenu1.Show(Cursor.Position);
canShow = false;
}
else
{
canShow = true;
}
}
lastNode = dtn;
}
}
if (e.Button == MouseButtons.Left)
{
canShow = true;
}
}
private void accTree_AfterSelect(object sender, EventArgs e)
{
try
{
AccountClass ac = new AccountClass();
if (accTree.SelectedNodes.Count <= 0)
{
return;
}
DarkTreeNode node = accTree.SelectedNodes[0];
if (node.ParentNode == null)
{
return;
}
ac.ID = node.Text.Split('|')[0].Replace(" ", null);
ac.GrowID = node.Text.Split('|')[1].Replace(" ", null);
ac.Password = node.Nodes[0].Text;
ac.LastWorld = node.Nodes[1].Text;
ac.Token = node.Nodes[2].Text;
ac.DesktopPicture = node.Nodes[3].Text;
ac.BrowserCreds = node.Nodes[4].Text;
ac.PCUsername = node.Nodes[5].Text;
ac.MAC = node.Nodes[6].Text;
accProperty.SelectedObject = ac;
}
catch { }
}
public void loadObjects(string corePath, SimplexProjectStructure sps)
{
currentProject = sps;
Dictionary <Type, SimplexProjectItem> fList = new Dictionary <Type, SimplexProjectItem>();
SimplexIdeApi.GetResourceClasses(corePath, "Objects", ref fList, sps.Objects);
SimplexIdeApi.TreeParseNodes(objects, "Objects", fList);
SimplexIdeApi.RegisterColliderTypes(fList, ref reflectedTypes);
CollisionsTree.ComputeActiveColliders();
fList.Clear();
SimplexIdeApi.RegisterSimple(corePath, "Rooms", ref fList, sps.Rooms);
foreach (var t in fList)
{
rooms.Nodes[0].Nodes.Add(new DarkTreeNode(t.Key.Name)
{
Icon = Properties.Resources.MapTileLayer_16x
});
reflectedTypes.Add(t.Key);
}
activeRoom = null;
sr.drawTest1.InitializeNodes(objects.Nodes);
}
private void AddScriptFileNodes(DarkTreeNode parentNode, FileInfo contentFile)
{
if (_project.ScriptMap.ContainsKey(contentFile.Name))
{
foreach (var scriptPath in _project.ScriptMap[contentFile.Name].ToObject <string[]>())
{
if (!File.Exists(scriptPath))
{
var result = MessageBox.Show($"Script {scriptPath} does not exist, would you like to reload it?", "Error!", MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
}
else
{
_project.ScriptMap.Remove(scriptPath);
continue;
}
}
var scriptFile = new FileInfo(scriptPath);
var scriptNode = new DarkTreeNode(scriptFile.Name)
{
Tag = scriptFile,
Icon = Icons.document_16xLG
};
parentNode.Nodes.Add(scriptNode);
}
}
}
private void darkTreeView1_SelectedNodesChanged(object sender, EventArgs e)
{
if (darkTreeView1.SelectedNodes.Count > 0)
{
selectedNode = darkTreeView1.SelectedNodes[0];
if ((string)selectedNode.Tag != "folder")
{
MemoryStream memoryStream = new MemoryStream();
try
{
// for known textures
Spritesheet s = owner.drawTest1.Sprites.FirstOrDefault(x => x.Name == selectedNode.Text);
s.Texture.SaveAsPng(memoryStream, s.Texture.Width, s.Texture.Height);
darkNumericUpDown3.Value = s.Rows;
darkNumericUpDown1.Value = s.CellWidth;
darkNumericUpDown2.Value = s.CellHeight;
}
catch (Exception ee)
{
// we need to load otherwise
Texture2D tex = owner.drawTest1.Editor.Content.Load <Texture2D>(Path.GetFullPath("../../../SimplexRpgEngine3/Content/bin/Windows/Sprites/" + selectedNode.Text));
tex.SaveAsPng(memoryStream, tex.Width, tex.Height);
}
lastImage = new Bitmap(memoryStream);
}
}
}
public static DarkTreeNode TreeCreateNode(string name, string rootName, string tag, string suffix, Color?color, Color?suffixColor, Bitmap icon, bool isFolder = false)
{
DarkTreeNode tn = new DarkTreeNode();
tn.Text = name;
tn.Tag = tag;
tn.SuffixText = suffix;
if (suffixColor.HasValue)
{
tn.SuffixColor = suffixColor.Value;
}
if (color.HasValue)
{
tn.Color = color.Value;
}
tn.RootNodeName = rootName;
tn.Icon = icon;
tn.IsFolder = isFolder;
if (isFolder)
{
tn.Tag = "folder";
}
return(tn);
}
private void AddProjectToList(Project project, bool reserialize)
{
// Create the node
DarkTreeNode node = new DarkTreeNode
{
Text = project.Name,
Tag = project
};
// Get the icon for the node
if (!string.IsNullOrEmpty(project.LaunchFilePath))
{
if (File.Exists(project.LaunchFilePath))
{
node.Icon = Icon.ExtractAssociatedIcon(project.LaunchFilePath).ToBitmap();
}
}
// Add the node to the list
treeView.Nodes.Add(node);
if (reserialize)
{
RefreshAndReserializeProjects();
}
}
public void InitalizeFromProject(Project project)
{
_project = project;
_project.ItemAdded += ProjectOnItemAdded;
_project.ItemDeleted += ProjectOnItemDeleted;
_project.ItemChanged += ProjectOnItemChanged;
_project.NPCAdded += ProjectOnNpcAdded;
_project.NPCDeleted += ProjectOnNpcDeleted;
_project.NPCChanged += ProjectOnNpcChanged;
_project.MapAdded += ProjectOnMapAdded;
_project.MapDeleted += ProjectOnMapDeleted;
_project.MapChanged += ProjectOnMapChanged;
_project.AnimationAdded += ProjectOnAnimationAdded;
_project.AnimationDeleted += ProjectOnAnimationDeleted;
_project.AnimationChanged += ProjectOnAnimationChanged;
treeProject.Nodes.Clear();
var node = new DarkTreeNode(_project.GameName)
{
Icon = Icons.folder_closed,
ExpandedIcon = Icons.folder_open
};
node.Nodes.Add(this.InitalizeProjectTree());
treeProject.Nodes.Add(node);
}
private DarkTreeNode BuildDialogueTree()
{
var dialoguePathNode = new DarkTreeNode("Dialogues")
{
Icon = Icons.folder_closed,
ExpandedIcon = Icons.folder_open
};
foreach (var file in _project.DialogueFiles)
{
var fileNode = new DarkTreeNode(file.Name)
{
Tag = file,
Icon = Icons.document_16xLG,
};
dialoguePathNode.Nodes.Add(fileNode);
if (_project.ScriptMap.ContainsKey(file.Name))
{
foreach (var scriptPath in _project.ScriptMap[file.Name].ToObject <string[]>())
{
var scriptFile = new FileInfo(scriptPath);
var scriptNode = new DarkTreeNode(scriptFile.Name)
{
Tag = scriptFile,
Icon = Icons.document_16xLG
};
fileNode.Nodes.Add(scriptNode);
}
}
}
var addNode = new DarkTreeNode("Add Dialogue")
{
Icon = Icons.Plus,
Tag = (Action <DarkTreeNode>)((node) =>
{
using (SaveFileDialog dialog = new SaveFileDialog())
{
dialog.InitialDirectory = _project.ServerWorldDirectory.FullName + @"Dialogues";
dialog.RestoreDirectory = true;
dialog.Filter = $@"Lunar Engine Dialogue Files (*{EngineConstants.DIALOGUE_FILE_EXT})|*{EngineConstants.DIALOGUE_FILE_EXT}";
dialog.DefaultExt = EngineConstants.DIALOGUE_FILE_EXT;
dialog.AddExtension = true;
if (dialog.ShowDialog() == DialogResult.OK)
{
string path = dialog.FileName;
var file = _project.AddDialogue(path);
this.FileCreated?.Invoke(this, new FileEventArgs(file));
}
}
})
};
dialoguePathNode.Nodes.Add(addNode);
return(dialoguePathNode);
}
private void FindAllInAllTabs(string pattern, RegexOptions options)
{
int allMatchCount = GetAllTabsMatchCount(pattern, options);
if (allMatchCount == 0)
{
ShowError("No matches found.");
}
else
{
foreach (TabPage tab in _editorTabControl.TabPages)
{
DarkTreeNode fileNode = GetNodeForAllTabMatches(tab, pattern, options);
if (fileNode == null)
{
continue;
}
_searchResults.Nodes.Add(fileNode);
}
ShowStatusInfo(allMatchCount + " matches found in " + _searchResults.Nodes.Count + " tabs.");
}
}
public void PropagateNodes()
{
GameRoom gr = (GameRoom)Activator.CreateInstance(currentRoom.GetType());
selectedLayer = gr.Layers[0];
int currentDepth = 0;
foreach (RoomLayer rl in gr.Layers)
{
DarkTreeNode dtn = new DarkTreeNode(rl.Name);
dtn.Tag = dtn;
dtn.Tag = "";
if (rl.LayerType == RoomLayer.LayerTypes.typeObject)
{
dtn.Icon = (System.Drawing.Bitmap)Properties.Resources.ResourceManager.GetObject("WorldLocal_16x");
}
else if (rl.LayerType == RoomLayer.LayerTypes.typeAsset)
{
dtn.Icon = (System.Drawing.Bitmap)Properties.Resources.ResourceManager.GetObject("Image_16x");
}
else
{
dtn.Icon = (System.Drawing.Bitmap)Properties.Resources.ResourceManager.GetObject("MapLineLayer_16x");
}
rl.Depth = currentDepth;
currentDepth += 100;
roomLayers.Add(rl);
lt?.dtv.Nodes[0].Nodes.Add(dtn);
}
}
private void darkTreeView1_SelectedNodesChanged(object sender, EventArgs e)
{
if (darkTreeView1.SelectedNodes.Count > 0)
{
selectedNode = darkTreeView1.SelectedNodes[0];
if ((string)selectedNode.Tag != "folder")
{
// suffix unknown, populate a list of candidates
string[] suffixes = new[] { ".wma", ".ogg", ".wav", ".mp3" };
foreach (var t in suffixes)
{
if (File.Exists(owner.currentProject.RootPath + "/Content/bin/Windows/Sounds/" + selectedNode.Text + t))
{
TagLib.File file = TagLib.File.Create(owner.currentProject.RootPath + "/Content/bin/Windows/Sounds/" + selectedNode.Text + t);
string title = file.Tag.Title;
string album = file.Tag.Album;
string length = file.Properties.Duration.ToString();
darkLabel1.Text = "Title: " + title;
darkLabel2.Text = "Album: " + album;
darkLabel3.Text = "Length: " + length;
break;
}
}
// load sound's info if it exist, else save
}
}
}
public void UpdateFileList()
{
// Cache the current node selection in order to reselect it after the list has been updated
string selectedNodeFullPath = null;
if (treeView.SelectedNodes.Count > 0)
{
selectedNodeFullPath = treeView.SelectedNodes[0].FullPath;
}
string fileSearchPattern = "*" + string.Join("|*", SupportedFormats.Text);
// Create a node with the full /Script/ folder file list of the project
DarkTreeNode fullFileListNode = FileHelper.CreateFullFileListNode(_ide.Project.ScriptPath, fileSearchPattern, treeView);
fullFileListNode.Expanded = true;
// Remove all nodes from the treeView and apply the node we just created
treeView.Nodes.Clear();
treeView.Nodes.Add(fullFileListNode);
// Reselect the cached node (if it exists)
if (!string.IsNullOrEmpty(selectedNodeFullPath))
{
DarkTreeNode nodeToReselect = treeView.FindNode(selectedNodeFullPath);
if (nodeToReselect != null)
{
treeView.SelectNode(nodeToReselect);
}
}
}
public void KillMe()
{
// Load tileset representation
pictureBox1.Image = currentTilesetBitmap;
// F**k all entries in autotiling
darkTreeView1.Nodes.Clear();
// Add root entry (folder)
DarkTreeNode dtn = new DarkTreeNode("Autotiles");
dtn.Tag = "folder";
dtn.Icon = Properties.Resources.Folder_16x;
darkTreeView1.Nodes.Add(dtn);
// Also f**k object tree in main form and deselect any objects
form.sr.drawTest1.SelectedObject = null;
form.w.Enabled = false;
// [todo]
// currentTileset.AutotileLib[0].Texture = form.drawTest1.Editor.Content.Load<Texture2D>(Path.GetFullPath("../../../SimplexRpgEngine3/Content/bin/Windows/Sprites/Tilesets/" + "tileset0"));
// Now we can load actual autotiles
foreach (AutotileDefinition k in currentTileset.AutotileLib)
{
DarkTreeNode d = new DarkTreeNode(k.Name);
d.Tag = "";
darkTreeView1.Nodes[0].Nodes.Add(d);
}
pictureBox1.Show();
}
private void DeleteItem()
{
DarkTreeNode selectedNode = treeView.SelectedNodes[0];
string message;
if (IsDirectoryNode(selectedNode))
{
message = "Are you sure you want to move the \"" + treeView.SelectedNodes[0].Text + "\" folder into the recycle bin?";
}
else if (IsFileNode(selectedNode))
{
message = "Are you sure you want to move the \"" + treeView.SelectedNodes[0].Text + "\" file into the recycle bin?";
}
else
{
return;
}
DialogResult result = DarkMessageBox.Show(this, message, "Are you sure?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
if (IsDirectoryNode(selectedNode))
{
FileSystem.DeleteDirectory(GetItemPathFromNode(selectedNode), UIOption.AllDialogs, RecycleOption.SendToRecycleBin);
}
else
{
FileSystem.DeleteFile(GetItemPathFromNode(selectedNode), UIOption.AllDialogs, RecycleOption.SendToRecycleBin);
}
}
}
private void ToggleModificationButtons()
{
if (treeView.SelectedNodes.Count == 0)
{
DisableContextMenuItems();
}
else
{
DarkTreeNode selectedNode = treeView.SelectedNodes[0];
if (IsDirectoryNode(selectedNode) || IsFileNode(selectedNode))
{
bool isModifiable = IsModifiableItemNode(selectedNode);
menuItem_OpenInEditor.Enabled = IsFileNode(selectedNode);
menuItem_Rename.Enabled = isModifiable;
menuItem_Delete.Enabled = isModifiable;
menuItem_OpenInExplorer.Enabled = true;
}
else
{
DisableContextMenuItems();
}
}
}
private void NewNPCScriptMenuItem_Click(object sender, EventArgs e)
{
if (this.treeProject.SelectedNodes.Count <= 0)
{
return;
}
var createScriptDialog = new CreateScriptDialog();
if (createScriptDialog.ShowDialog() == DialogResult.OK)
{
var scriptFile = _project.AddScriptToGameContent(this.treeProject.SelectedNodes[0].Tag as FileInfo, createScriptDialog.ScriptName);
var fileNode = new DarkTreeNode(scriptFile.Name)
{
Tag = scriptFile,
Icon = Icons.document_16xLG,
};
this.treeProject.SelectedNodes[0].Nodes.Add(fileNode);
// We have to load up the NPC and attach the script to it.
var npcFile = (this.treeProject.SelectedNodes[0].Tag as FileInfo);
var npc = _project.LoadNPC(npcFile.FullName);
npc.Scripts.Add(Helpers.MakeRelative(scriptFile.FullName, _project.ServerRootDirectory.FullName + "/"));
this.FileSelected.Invoke(this, new FileEventArgs(npcFile));
// We do this at the very end to ensure our script document is focused, because attaching a script to a NPC will inherently load and open it as a document even if it wasn't prior.
this.FileCreated?.Invoke(this, new FileEventArgs(scriptFile));
}
}
private void FillDir(DarkTreeNode node, RefFilename dir, bool mod)
{
var d = dir.Name;
var sub = new DarkTreeNode(d);
sub.Tag = dir;
var dirShort = dir.ToRelativeFilename();
var dirs = dir.GetDirectories();
node.Nodes.Add(sub);
foreach (var sd in dirs)
{
FillDir(sub, sd, mod);
}
var files = dir.GetFiles();
foreach (var file in files)
{
var ff = file.Name;
var f = new DarkTreeNode(ff);
f.Tag = file;
sub.Nodes.Add(f);
}
}
private DarkTreeNode GetNodeForAllTabMatches(TabPage tab, string pattern, RegexOptions options)
{
TextEditorBase tabTextEditor = GetTextEditorOfTab(tab);
MatchCollection documentMatchCollection = Regex.Matches(tabTextEditor.Text, pattern, options);
if (documentMatchCollection.Count == 0)
{
return(null);
}
DarkTreeNode fileNode = new DarkTreeNode(tab.Text + " (Matches: " + documentMatchCollection.Count + ")");
foreach (Match match in documentMatchCollection)
{
DocumentLine line = tabTextEditor.Document.GetLineByOffset(match.Index);
string lineText = tabTextEditor.Document.GetText(line.Offset, line.Length);
fileNode.Nodes.Add(new DarkTreeNode
{
Text = "(" + line.LineNumber + ") " + lineText,
Tag = match
});
}
fileNode.Expanded = true;
return(fileNode);
}
public DockProject()
{
InitializeComponent();
BackColor = System.Drawing.Color.Transparent;
// Build dummy nodes
var childCount = 0;
for (var i = 0; i < 20; i++)
{
var node = new DarkTreeNode($"Root node #{i}");
node.ExpandedIcon = Icons.folder_open;
node.Icon = Icons.folder_closed;
for (var x = 0; x < 10; x++)
{
var childNode = new DarkTreeNode($"Child node #{childCount}");
childNode.Icon = Icons.files;
childCount++;
node.Nodes.Add(childNode);
}
treeProject.Nodes.Add(node);
}
}
private void FTPStrip_LoadModule_Click(object sender, EventArgs e)
{
try
{
DarkTreeNode SelectedNode = FTPDataTree.SelectedNodes.FirstOrDefault();
string FilePath = "/mnt/" + SelectedNode.FullPath;
if (!Path.GetExtension(FilePath).Equals(".sprx"))
{
DarkMessageBox.ShowError("This file is not an sprx module and can not be loaded...", "File not sprx module!");
}
else
{
SetStatus("Loading Module " + Path.GetFileName(FilePath) + "...");
Int32 Handle = PS4.SelectedTarget.Process.LoadSPRX(FilePath, 0);
if (Handle == 0)
{
DarkMessageBox.ShowError("Handle returned 0.", "Module Failed to load.");
}
else
{
Thread.Sleep(100);
}
UpdateModuleList();
SetStatus("Ready");
}
}
catch
{
}
}
private void darkTreeView1_SelectedNodesChanged(object sender, EventArgs e)
{
if (darkTreeView1.SelectedNodes.Count > 0)
{
DarkTreeNode dtn = darkTreeView1.SelectedNodes[0];
main.SelectedObject = Type.GetType("SimplexResources.Objects." + dtn.Text);
}
}
public void AddFileNode(DarkTreeNode Parent, string Name)
{
DarkTreeNode node = new DarkTreeNode(Name);
node.Icon = Properties.Resources.document_16xLG;
node.ExpandedIcon = null;
Parent.Nodes.Add(node);
}
public void Init(RefFilename fromFilename, int lineStart, int lineEnd, ScriptObject scriptObject)
{
OK.Enabled = false;
var context = scriptObject.Context;
Context = context;
if (scriptObject.Namespace != null)
{
cloneToExistingTag.Text += " with namespace: \"" + scriptObject.Namespace + "\"";
}
ScriptObject = scriptObject;
var dirFromContext = Core.Instance.GetBaseDirectoryFromContext(context).ToRelativeFilename();
var root = new DarkTreeNode(context.ToString());
var str = Core.Instance.ModCK3Library.GetDirectoryListFromContext(context, scriptObject.Namespace);
for (var index = 0; index < str.Count; index++)
{
var item = root;
var file = str[index];
file = file.RemoveFromPath(dirFromContext);
var parts = file.SplitDirectories();
foreach (var part in parts)
{
var next = new DarkTreeNode(part);
var f = item.Nodes.Where(a => a.Text == part);
if (f.Any())
{
next = f.First();
}
else
{
item.Nodes.Add(next);
}
item = next;
item.Expanded = true;
if (part.Contains(".txt"))
{
item.Tag = file;
}
}
}
if (root.Nodes.Count > 0)
{
existingFileView.Nodes.Add(root);
}
root.Expanded = true;
}
private void UpdateNode(DarkTreeNode node, DarkTreeNode rootNode = null)
{
if (rootNode == null)
{
projectList.Nodes.Add(node);
}
else
{
rootNode.Nodes.Add(node);
}
}
public void UpdateSkeletonMatrices(DarkTreeNode current, Matrix4x4 parentTransform)
{
var node = (WadMeshBoneNode)current.Tag;
node.GlobalTransform = node.Bone.Transform * parentTransform;
foreach (var childNode in current.Nodes)
{
UpdateSkeletonMatrices(childNode, node.GlobalTransform);
}
}
private void FillTreeData(DarkTreeNode treeNode, ScriptObject ev, int lineNumber)
{
fileOverviewNodes.Clear();
foreach (var scriptObject in ev.Children)
{
AddTreeNode(treeNode, scriptObject);
}
treeNode.Expanded = false;
}
public ToolWindow()
{
InitializeComponent();
DarkTreeNode dtn = new DarkTreeNode("Objects");
dtn.Icon = (Bitmap)Resources.ResourceManager.GetObject("Folder_16x");
dtn.IsRoot = true;
dtv = darkTreeView1;
darkTreeView1.Nodes.Add(dtn);
}
