2541 lines
72 KiB
C#
2541 lines
72 KiB
C#
// <copyright file="gpl-2.0.txt">
|
|
// ORIGINAL CODE BASE IS Copyright (C) 2006-2010 by Alphons van der Heijden.
|
|
// The code was donated on 2010-04-28 by Alphons van der Heijden to Brandon 'Dimentox Travanti' Husbands &
|
|
// Malcolm J. Kudra, who in turn License under the GPLv2 in agreement with Alphons van der Heijden's wishes.
|
|
//
|
|
// The community would like to thank Alphons for all of his hard work, blood sweat and tears. Without his work
|
|
// the community would be stuck with crappy editors.
|
|
//
|
|
// The source code in this file ("Source Code") is provided by The LSLEditor Group to you under the terms of the GNU
|
|
// General Public License, version 2.0 ("GPL"), unless you have obtained a separate licensing agreement ("Other
|
|
// License"), formally executed by you and The LSLEditor Group.
|
|
// Terms of the GPL can be found in the gplv2.txt document.
|
|
//
|
|
// GPLv2 Header
|
|
// ************
|
|
// LSLEditor, a External editor for the LSL Language.
|
|
// Copyright (C) 2010 The LSLEditor Group.
|
|
//
|
|
// This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
|
|
// License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any
|
|
// later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
|
|
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
// details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License along with this program; if not, write to the Free
|
|
// Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
// ********************************************************************************************************************
|
|
// The above copyright notice and this permission notice shall be included in copies or substantial portions of the
|
|
// Software.
|
|
// ********************************************************************************************************************
|
|
// </copyright>
|
|
//
|
|
// <summary>
|
|
//
|
|
//
|
|
// </summary>
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.Xml;
|
|
using Timer = System.Windows.Forms.Timer;
|
|
|
|
namespace LSLEditor.Solution
|
|
{
|
|
public partial class SolutionExplorer : ToolWindow
|
|
{
|
|
public enum TypeSL : int
|
|
{
|
|
// Inventory containers
|
|
Inventory = 0,
|
|
Animations = 1,
|
|
Body_Parts = 2,
|
|
Calling_Cards = 3,
|
|
Clothes = 4,
|
|
Gestures = 5,
|
|
Landmarks = 6,
|
|
Lost_And_Found = 7,
|
|
Notecards = 8,
|
|
Objects = 9,
|
|
Photo_Album = 10,
|
|
Scripts = 11,
|
|
Sounds = 12,
|
|
Textures = 13,
|
|
Trash = 14,
|
|
Folder = 15,
|
|
|
|
// Special containers
|
|
Solution = 16,
|
|
Project = 17,
|
|
Prim = 18, // not used, use Object instead
|
|
Unknown = 19,
|
|
|
|
// Normal items!!
|
|
|
|
// Animations
|
|
Animation = 20,
|
|
|
|
Gesture = 21,
|
|
Landmark = 22,
|
|
Notecard = 23,
|
|
Object = 24, // This is a normal container item!!!
|
|
|
|
// Photo Album
|
|
Snapshot = 25,
|
|
|
|
Script = 26,
|
|
LSLIScript = 42,
|
|
Sound = 27,
|
|
Texture = 28,
|
|
|
|
// Body parts
|
|
Eyes = 29,
|
|
Hair = 30,
|
|
Shape = 31,
|
|
Skin = 32,
|
|
|
|
// Clothes
|
|
Gloves = 33,
|
|
Jacket = 34,
|
|
Pants = 35,
|
|
Shirt = 36,
|
|
Shoes = 37,
|
|
Skirt = 38,
|
|
Socks = 39,
|
|
Underpants = 40,
|
|
Undershirt = 41
|
|
}
|
|
private TypeSL[] BodyPartsTypes =
|
|
{
|
|
TypeSL.Eyes,
|
|
TypeSL.Hair,
|
|
TypeSL.Shape,
|
|
TypeSL.Skin
|
|
};
|
|
private TypeSL[] ClothesTypes =
|
|
{
|
|
TypeSL.Gloves,
|
|
TypeSL.Jacket,
|
|
TypeSL.Pants,
|
|
TypeSL.Shirt,
|
|
TypeSL.Shoes,
|
|
TypeSL.Skirt,
|
|
TypeSL.Socks,
|
|
TypeSL.Underpants,
|
|
TypeSL.Undershirt
|
|
};
|
|
private TypeSL[] FilesTypes =
|
|
{
|
|
TypeSL.Animation,
|
|
TypeSL.Gesture,
|
|
TypeSL.Landmark ,
|
|
TypeSL.Notecard,
|
|
TypeSL.Snapshot,
|
|
TypeSL.Object,
|
|
TypeSL.Script,
|
|
TypeSL.LSLIScript,
|
|
TypeSL.Sound,
|
|
TypeSL.Texture
|
|
};
|
|
|
|
public struct RealTag
|
|
{
|
|
public TypeSL ItemType;
|
|
public string Name;
|
|
public string Description;
|
|
public Guid Guid;
|
|
public string Path;
|
|
|
|
public RealTag(TypeSL ItemType, string Name, Guid Guid)
|
|
{
|
|
this.ItemType = ItemType;
|
|
this.Name = Name;
|
|
this.Description = string.Empty;
|
|
this.Guid = Guid;
|
|
this.Path = null;
|
|
}
|
|
|
|
public RealTag(TypeSL ItemType,string Name, Guid Guid, string Path)
|
|
{
|
|
this.ItemType = ItemType;
|
|
this.Name = Name;
|
|
this.Description = string.Empty;
|
|
this.Guid = Guid;
|
|
this.Path = Path;
|
|
}
|
|
}
|
|
|
|
public string DirectorySolution;
|
|
public string NameSolution;
|
|
public string Repository;
|
|
|
|
private TreeNode ActiveSolution;
|
|
private TreeNode ActiveProject;
|
|
private TreeNode ActiveObject;
|
|
|
|
private TreeNode CutObject;
|
|
private TreeNode CopyObject;
|
|
|
|
public LSLEditorForm parent;
|
|
|
|
private SolidBrush brushHighLightBackground;
|
|
private SolidBrush brushNormalForeColor;
|
|
private SolidBrush brushCutForeColor;
|
|
private SolidBrush brushBackColor;
|
|
private Pen penWhite;
|
|
private Pen penBackColor;
|
|
|
|
private ImageList imageList1;
|
|
|
|
private OpenFileDialog openFileDialog1;
|
|
|
|
private Timer timer;
|
|
|
|
private bool m_dirty;
|
|
|
|
private ListViewItem m_HoveredItem;
|
|
private ToolTip toolTip1;
|
|
|
|
|
|
public bool IsDirty
|
|
{
|
|
get
|
|
{
|
|
return m_dirty;
|
|
}
|
|
}
|
|
|
|
public SolutionExplorer()
|
|
{
|
|
InitializeComponent();
|
|
|
|
this.Repository = null;
|
|
|
|
this.toolTip1 = new ToolTip();
|
|
|
|
this.m_dirty = false;
|
|
|
|
this.components = new System.ComponentModel.Container();
|
|
|
|
imageList1 = new ImageList();
|
|
imageList1.TransparentColor = Color.Transparent;
|
|
for (int intI = 0; intI <= 42; intI++)//41
|
|
{
|
|
TypeSL typeSL = (TypeSL)intI;
|
|
imageList1.Images.Add(intI.ToString(), new Bitmap(typeof(LSLEditorForm), "ImagesSolutionExplorer." + typeSL.ToString().Replace("_", " ") + ".gif"));
|
|
}
|
|
|
|
// take care of this as an property
|
|
//this.parent = parent;
|
|
|
|
this.brushHighLightBackground = new SolidBrush(Color.FromArgb(0xff, 0x6d, 0x6e, 0x6f));
|
|
this.brushNormalForeColor = new SolidBrush(Color.FromArgb(0xff, 0xff, 0xff, 0xff));
|
|
this.brushCutForeColor = new SolidBrush(Color.FromArgb(0xff, Color.DarkGray));
|
|
this.brushBackColor = new SolidBrush(Color.FromArgb(0xff, 0x3e, 0x3e, 0x3e));
|
|
this.penWhite = new Pen(Color.White);
|
|
this.penBackColor = new Pen(this.brushBackColor);
|
|
|
|
|
|
this.treeView1.ImageList = imageList1;
|
|
this.treeView1.ShowRootLines = false; // just 1 root
|
|
this.treeView1.ForeColor = Color.White;
|
|
this.treeView1.BackColor = Color.FromArgb(0xff, 0x3e, 0x3e, 0x3e);
|
|
this.treeView1.LabelEdit = false;
|
|
this.treeView1.BeforeCollapse += new TreeViewCancelEventHandler(treeView1_BeforeCollapse);
|
|
this.treeView1.DrawMode = TreeViewDrawMode.OwnerDrawText;
|
|
this.treeView1.DrawNode += new DrawTreeNodeEventHandler(treeView1_DrawNode);
|
|
this.treeView1.AfterLabelEdit += new NodeLabelEditEventHandler(treeView1_AfterLabelEdit);
|
|
this.treeView1.MouseDown += new MouseEventHandler(treeView1_MouseDown);
|
|
|
|
this.treeView1.NodeMouseDoubleClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.treeView1_NodeMouseDoubleClick);
|
|
|
|
this.treeView1.MouseUp += new MouseEventHandler(treeView1_MouseUp);
|
|
|
|
this.treeView1.TreeViewNodeSorter = new NodeSorter();
|
|
|
|
this.listView1.Dock = DockStyle.Fill;
|
|
this.listView1.View = View.Details;
|
|
this.listView1.HeaderStyle = ColumnHeaderStyle.None;
|
|
//this.listView1.Scrollable = false;
|
|
|
|
this.listView1.GridLines = true;
|
|
this.listView1.Columns.Add("Name",60);
|
|
this.listView1.Columns.Add("Value",250);
|
|
|
|
// for disposing
|
|
this.timer = new Timer(this.components);
|
|
this.timer.Interval = 250;
|
|
this.timer.Tick += new EventHandler(timer_Tick);
|
|
|
|
this.openFileDialog1 = new OpenFileDialog();
|
|
}
|
|
|
|
public string GetCurrentSolutionPath()
|
|
{
|
|
if (ActiveSolution == null)
|
|
return null;
|
|
if (DirectorySolution == null)
|
|
return null;
|
|
if (NameSolution == null)
|
|
return null;
|
|
|
|
return Path.Combine(DirectorySolution, NameSolution + ".sol");
|
|
}
|
|
|
|
|
|
public string GetProjectName(Guid guid)
|
|
{
|
|
TreeNode tn = FindGuid(this.treeView1.TopNode, guid);
|
|
if (tn != null)
|
|
{
|
|
while (tn != this.treeView1.TopNode)
|
|
{
|
|
tn = tn.Parent;
|
|
if (GetTypeSL(tn) == TypeSL.Project)
|
|
return tn.Text;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
private void timer_Tick(object sender, EventArgs e)
|
|
{
|
|
timer.Stop();
|
|
RenameAction(this.treeView1.SelectedNode);
|
|
}
|
|
|
|
private int NumberOfProjects()
|
|
{
|
|
if (ActiveSolution == null)
|
|
return 0;
|
|
int intProjects = 0;
|
|
foreach (TreeNode tn in ActiveSolution.Nodes)
|
|
{
|
|
if (GetTypeSL(tn) == TypeSL.Project)
|
|
intProjects++;
|
|
}
|
|
return intProjects;
|
|
}
|
|
|
|
private bool HasInventory()
|
|
{
|
|
foreach (TreeNode tn in ActiveSolution.Nodes)
|
|
{
|
|
if (GetTypeSL(tn) == TypeSL.Inventory)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void EmptyInventory(TreeNode parentNode)
|
|
{
|
|
this.m_dirty = true;
|
|
TreeNode treeNode = new TreeNode("Inventory", (int)TypeSL.Inventory, (int)TypeSL.Inventory);
|
|
string strInventoryPath = Path.Combine(DirectorySolution, "Inventory");
|
|
treeNode.Tag = new RealTag(TypeSL.Inventory, "Inventory", Guid.NewGuid(), strInventoryPath);
|
|
parentNode.Nodes.Insert(0,treeNode);
|
|
for (int intI = 1; intI < 15; intI++)
|
|
{
|
|
TypeSL typeSL = (TypeSL)intI;
|
|
string strName = typeSL.ToString().Replace('_', ' ');
|
|
TreeNode tn = new TreeNode(strName, intI, intI);
|
|
tn.Tag = new RealTag(typeSL, strName, Guid.NewGuid());
|
|
treeNode.Nodes.Add(tn);
|
|
}
|
|
}
|
|
|
|
private EditForm GetEditForm(Guid guid)
|
|
{
|
|
LSLEditorForm lslEditorForm = this.parent;
|
|
foreach (Form form in lslEditorForm.Children)
|
|
{
|
|
EditForm editForm = form as EditForm;
|
|
if (editForm == null || editForm.IsDisposed)
|
|
continue;
|
|
if (editForm.guid == guid)
|
|
return editForm;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void CloseSolution()
|
|
{
|
|
if (this.ActiveSolution == null)
|
|
return;
|
|
|
|
this.parent.StopSimulator();
|
|
|
|
if (this.parent.CloseAllOpenWindows())
|
|
{
|
|
SaveSolutionFile();
|
|
|
|
this.ActiveProject = null;
|
|
this.ActiveSolution = null;
|
|
this.ActiveObject = null;
|
|
|
|
this.m_dirty = false;
|
|
|
|
this.treeView1.Nodes.Clear();
|
|
|
|
this.listView1.Items.Clear();
|
|
|
|
if(!Properties.Settings.Default.ShowSolutionExplorer)
|
|
this.parent.ShowSolutionExplorer(false);
|
|
this.parent.SolutionItemsFileMenu(false);
|
|
}
|
|
}
|
|
|
|
public bool CreateNew(string strNameProject,string strDirectory,string strNameSolution,bool blnCreateSolutionDirectory)
|
|
{
|
|
DirectorySolution = Path.Combine(strDirectory,strNameSolution);
|
|
|
|
string strSolutionFileName = Path.Combine(DirectorySolution, strNameSolution + ".sol");
|
|
|
|
if(File.Exists(strSolutionFileName))
|
|
{
|
|
MessageBox.Show("Solution file already exists", "Create new Solution", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return false;
|
|
}
|
|
|
|
AddSolution(strNameSolution);
|
|
|
|
string strProjectPath;
|
|
if (blnCreateSolutionDirectory)
|
|
strProjectPath = Path.Combine(DirectorySolution, strNameProject);
|
|
else
|
|
strProjectPath = DirectorySolution;
|
|
|
|
// made active, if only project
|
|
AddItem(TypeSL.Project,strNameProject, Guid.NewGuid() , strProjectPath);
|
|
|
|
return true;
|
|
}
|
|
|
|
public void AddExistingProject()
|
|
{
|
|
this.openFileDialog1.Multiselect = false;
|
|
this.openFileDialog1.FileName = "";
|
|
this.openFileDialog1.Filter = "LSLEditor Project file (*.prj)|*.prj|All Files (*.*)|*.*";
|
|
if (this.openFileDialog1.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
if (File.Exists(this.openFileDialog1.FileName))
|
|
LoadItem(this.openFileDialog1.FileName,false);
|
|
}
|
|
}
|
|
|
|
#region UserInterface stuff
|
|
|
|
// disable root solution collapse (there is no + sign)
|
|
void treeView1_BeforeCollapse(object sender, TreeViewCancelEventArgs e)
|
|
{
|
|
e.Cancel = (e.Node == this.ActiveSolution);
|
|
}
|
|
|
|
void treeView1_DrawNode(object sender, DrawTreeNodeEventArgs e)
|
|
{
|
|
if (e.Node.IsEditing)
|
|
return;
|
|
|
|
if (e.Bounds.Height == 0)
|
|
return;
|
|
|
|
Font font;
|
|
if (e.Node == ActiveProject || e.Node == ActiveObject)
|
|
font = new Font(this.treeView1.Font, FontStyle.Bold);
|
|
else
|
|
font = new Font(this.treeView1.Font, FontStyle.Regular);
|
|
|
|
// Draw background
|
|
SizeF sizeF = e.Graphics.MeasureString(e.Node.Text, font);
|
|
Rectangle rect = new Rectangle(e.Bounds.Location, new Size((int)sizeF.Width + 5, e.Bounds.Height - 1));
|
|
|
|
if ((e.State & TreeNodeStates.Selected) != 0)
|
|
{
|
|
e.Graphics.FillRectangle(brushHighLightBackground, rect);
|
|
e.Graphics.DrawRectangle(penWhite, rect);
|
|
}
|
|
else
|
|
{
|
|
e.Graphics.FillRectangle(brushBackColor, rect);
|
|
e.Graphics.DrawRectangle(penBackColor, rect);
|
|
}
|
|
|
|
// Draw text
|
|
Point point = new Point(e.Bounds.Location.X, e.Bounds.Location.Y + 2);
|
|
if (e.Node.ForeColor != Color.Empty)
|
|
e.Graphics.DrawString(e.Node.Text, font, brushCutForeColor, point);
|
|
else
|
|
e.Graphics.DrawString(e.Node.Text, font, brushNormalForeColor, point);
|
|
|
|
// Clean up
|
|
font.Dispose();
|
|
}
|
|
|
|
void treeView1_AfterLabelEdit(object sender, NodeLabelEditEventArgs e)
|
|
{
|
|
this.treeView1.LabelEdit = false;
|
|
|
|
if (e.Label == null || e.Label.Trim() == "")
|
|
{
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
|
|
// check for illegal chars!!
|
|
string strLabel = e.Label;
|
|
|
|
foreach (char chrF in e.Label.ToCharArray())
|
|
{
|
|
foreach (char chrInvalid in Path.GetInvalidFileNameChars())
|
|
{
|
|
if (chrF == chrInvalid)
|
|
{
|
|
MessageBox.Show("Char '" + chrInvalid + "' is not allowed", "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
string strBackup = e.Node.Text;
|
|
string strSource = GetFullPath(e.Node);
|
|
e.Node.Text = e.Label;
|
|
string strDestination = GetFullPath(e.Node);
|
|
|
|
if (e.Node == ActiveSolution)
|
|
{
|
|
NameSolution = e.Label;
|
|
UpdateVisualSolutionName();
|
|
string strOldSolutionFile = Path.GetFullPath(Path.Combine(strSource, strBackup + ".sol"));
|
|
string strNewSolutionFile = Path.GetFullPath(Path.Combine(strDestination, NameSolution + ".sol"));
|
|
|
|
if (File.Exists(strNewSolutionFile) && string.Compare(strOldSolutionFile, strNewSolutionFile, true) != 0)
|
|
{
|
|
if (MessageBox.Show("Destination solution exists! overwrite?", "Oops...", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) != DialogResult.Yes)
|
|
{
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
File.Delete(strNewSolutionFile);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MessageBox.Show("Error: " + exception.Message, "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(File.Exists(strOldSolutionFile))
|
|
File.Move(strOldSolutionFile, strNewSolutionFile);
|
|
ShowProperties(ActiveSolution);
|
|
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
|
|
// source and destination are the same, cancel it all (file or directory)
|
|
if (string.Compare(strSource, strDestination, true) == 0)
|
|
{
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
|
|
|
|
// rename file
|
|
if (File.Exists(strSource))
|
|
{
|
|
if (File.Exists(strDestination))
|
|
{
|
|
if (MessageBox.Show("Destination file exists! overwrite?", "Oops...", MessageBoxButtons.YesNo , MessageBoxIcon.Warning) != DialogResult.Yes)
|
|
{
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
File.Delete(strDestination);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MessageBox.Show("Error: " + exception.Message, "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
}
|
|
try
|
|
{
|
|
File.Move(strSource, strDestination);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MessageBox.Show("Error: " + exception.Message, "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
|
|
RealTag rt = (RealTag)e.Node.Tag;
|
|
string oldName = rt.Name;
|
|
rt.Name = e.Node.Text;
|
|
e.Node.Tag = rt; // save name
|
|
EditForm editForm = GetEditForm(rt.Guid);
|
|
if (editForm != null)
|
|
{
|
|
editForm.FullPathName = strDestination; // GetFullPath(e.Node);
|
|
editForm.SaveCurrentFile();
|
|
}
|
|
|
|
if (rt.ItemType == TypeSL.LSLIScript)
|
|
{
|
|
EditForm form = GetEditForm(rt.Guid);
|
|
if(form != null)
|
|
{
|
|
form.SaveCurrentFile();
|
|
form.Dirty = true;
|
|
form.Show();
|
|
|
|
// Get the expanded version of the form
|
|
string x = Helpers.LSLIPathHelper.GetExpandedTabName(Helpers.LSLIPathHelper.CreateExpandedScriptName(oldName));
|
|
EditForm xform = (EditForm)parent.GetForm(x);
|
|
|
|
if (xform != null && xform.Visible)
|
|
{
|
|
string src = xform.SourceCode;
|
|
xform.Dirty = false;
|
|
xform.Close();
|
|
form.SourceCode = src;
|
|
form.Dirty = true;
|
|
parent.ExpandForm(form);
|
|
}
|
|
}
|
|
}
|
|
|
|
return; // rename file complete
|
|
}
|
|
|
|
// rename directory
|
|
if (Directory.Exists(strSource))
|
|
{
|
|
if (Directory.Exists(strDestination))
|
|
{
|
|
if (MessageBox.Show("Destination directory exists! overwrite?", "Oops...", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) != DialogResult.Yes)
|
|
{
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
Directory.Delete(strDestination, true);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MessageBox.Show("Error: " + exception.Message, "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
Directory.Move(strSource, strDestination);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MessageBox.Show("Error: " + exception.Message, "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
return;
|
|
}
|
|
|
|
RealTag rt = (RealTag)e.Node.Tag;
|
|
rt.Name = e.Node.Text;
|
|
e.Node.Tag = rt; // save name
|
|
|
|
// update all path of opened windows
|
|
foreach (Form form in this.parent.Children)
|
|
{
|
|
EditForm editForm = form as EditForm;
|
|
if (editForm == null || editForm.IsDisposed)
|
|
continue;
|
|
TreeNode tn = FindGuid(e.Node, editForm.guid);
|
|
if (tn != null)
|
|
{
|
|
editForm.FullPathName = GetFullPath(tn);
|
|
editForm.SaveCurrentFile();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
MessageBox.Show("Can not rename, source does not exist", "Oops...");
|
|
e.Node.Text = strBackup;
|
|
e.CancelEdit = true;
|
|
}
|
|
#endregion
|
|
|
|
private bool IsItem(TreeNode treeNode)
|
|
{
|
|
TypeSL typeSL = GetTypeSL(treeNode);
|
|
return ((int)typeSL >= 20);
|
|
}
|
|
|
|
private bool IsItemAndNotObject(TreeNode treeNode)
|
|
{
|
|
TypeSL typeSL = GetTypeSL(treeNode);
|
|
int intTypeSL = (int)typeSL;
|
|
return (intTypeSL >= 20 && typeSL != TypeSL.Object);
|
|
}
|
|
|
|
|
|
private bool IsInventoryContainer(TreeNode treeNode)
|
|
{
|
|
TypeSL TypeSL = GetTypeSL(treeNode);
|
|
return ((int)TypeSL <= 15);
|
|
}
|
|
|
|
private TypeSL GetTypeSL(TreeNode treeNode)
|
|
{
|
|
if (treeNode == null)
|
|
return TypeSL.Unknown;
|
|
if (treeNode.Tag == null)
|
|
return TypeSL.Unknown;
|
|
RealTag realTag = (RealTag)treeNode.Tag;
|
|
return realTag.ItemType;
|
|
}
|
|
|
|
private string GetPath(TreeNode treeNode)
|
|
{
|
|
if (treeNode == null)
|
|
return null;
|
|
if (treeNode.Tag == null)
|
|
return null;
|
|
RealTag realTag = (RealTag)treeNode.Tag;
|
|
string strPath = realTag.Path;
|
|
if (strPath == null)
|
|
return null;
|
|
|
|
if(strPath.EndsWith(treeNode.Text))
|
|
return strPath;
|
|
|
|
// Project has been renamed
|
|
strPath = Path.Combine(Path.GetDirectoryName(strPath), treeNode.Text);
|
|
realTag.Path = strPath;
|
|
treeNode.Tag = realTag;
|
|
return strPath;
|
|
}
|
|
|
|
private string GetXml(int intDepth, TreeNode treeNode)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
RealTag realTag = (RealTag)treeNode.Tag;
|
|
string strTagName = realTag.ItemType.ToString();
|
|
string strValue = treeNode.Text;
|
|
if (treeNode == ActiveSolution)
|
|
strValue = NameSolution;
|
|
for (int intI = 0; intI < intDepth; intI++)
|
|
sb.Append('\t');
|
|
string strActive = "";
|
|
string strDescription = "";
|
|
if (treeNode == ActiveObject)
|
|
strActive = @" active=""true""";
|
|
if (realTag.Description != string.Empty)
|
|
strDescription = @" description=""" + realTag.Description + @"""";
|
|
sb.AppendFormat("<{0} name=\"{1}\" guid=\"{2}\"{3}{4}>\r\n", strTagName, strValue, realTag.Guid, strActive, strDescription);
|
|
foreach (TreeNode childNode in treeNode.Nodes)
|
|
sb.Append(GetXml(intDepth + 1, childNode));
|
|
for (int intI = 0; intI < intDepth; intI++)
|
|
sb.Append('\t');
|
|
sb.AppendFormat("</{0}>\r\n", strTagName);
|
|
return sb.ToString();
|
|
}
|
|
|
|
private string GetFullPath(TreeNode treeNode)
|
|
{
|
|
if (treeNode == ActiveSolution)
|
|
return DirectorySolution;
|
|
|
|
TreeNode parentNode = treeNode;
|
|
string strPath = "";
|
|
while (GetPath(parentNode) == null)
|
|
{
|
|
strPath = Path.Combine(parentNode.Text, strPath);
|
|
parentNode = parentNode.Parent;
|
|
}
|
|
strPath = Path.Combine(GetPath(parentNode), strPath);
|
|
return Path.GetFullPath(strPath);
|
|
}
|
|
|
|
private void RecursiveLoad(TreeNode treeNode, XmlNode xmlParentNode)
|
|
{
|
|
foreach (XmlNode xmlNode in xmlParentNode.SelectNodes("./*"))
|
|
{
|
|
TypeSL typeSL = (TypeSL)Enum.Parse(typeof(TypeSL), xmlNode.Name);
|
|
|
|
if (typeSL == TypeSL.Prim) // Old!!!
|
|
typeSL = TypeSL.Object;
|
|
|
|
string strName = xmlNode.Attributes["name"].Value;
|
|
Guid guid = new Guid(xmlNode.Attributes["guid"].Value);
|
|
|
|
XmlAttribute attributePath = xmlNode.Attributes["path"];
|
|
XmlAttribute attributeDescription = xmlNode.Attributes["description"];
|
|
int intImageIndex = (int)typeSL;
|
|
TreeNode tn = new TreeNode(strName, intImageIndex, intImageIndex);
|
|
|
|
RealTag realTag = new RealTag(typeSL, strName, guid);
|
|
|
|
if (attributePath != null)
|
|
realTag.Path = attributePath.Value;
|
|
if (attributeDescription != null)
|
|
realTag.Description = attributeDescription.Value;
|
|
|
|
tn.Tag = realTag;
|
|
|
|
XmlAttribute attributeActive = xmlNode.Attributes["active"];
|
|
if (attributeActive != null)
|
|
{
|
|
if (attributeActive.Value == "true")
|
|
ActiveObject = tn;
|
|
}
|
|
treeNode.Nodes.Add(tn);
|
|
RecursiveLoad(tn, xmlNode);
|
|
}
|
|
}
|
|
|
|
|
|
private void LoadItem(string strPath, bool blnActive)
|
|
{
|
|
XmlDocument xmlItemFile = new XmlDocument();
|
|
try
|
|
{
|
|
xmlItemFile.Load(strPath);
|
|
}
|
|
catch
|
|
{
|
|
MessageBox.Show("Not a valid item file", "Oops...");
|
|
return;
|
|
}
|
|
foreach (XmlNode xmlItem in xmlItemFile.SelectNodes("./*"))
|
|
{
|
|
TypeSL typeSL = (TypeSL)Enum.Parse(typeof(TypeSL), xmlItem.Name);
|
|
TreeNode currentItem = AddItem(typeSL,
|
|
xmlItem.Attributes["name"].Value,
|
|
new Guid(xmlItem.Attributes["guid"].Value),
|
|
Path.GetDirectoryName(strPath));
|
|
if (currentItem == null)
|
|
continue;
|
|
if (blnActive)
|
|
ActiveProject = currentItem;
|
|
RecursiveLoad(currentItem, xmlItem);
|
|
}
|
|
}
|
|
|
|
public bool OpenSolution(string strPath)
|
|
{
|
|
DirectorySolution = Path.GetDirectoryName(strPath);
|
|
NameSolution = Path.GetFileNameWithoutExtension(strPath);
|
|
|
|
XmlDocument xml = new XmlDocument();
|
|
try
|
|
{
|
|
xml.Load(strPath);
|
|
}
|
|
catch
|
|
{
|
|
MessageBox.Show("Not a valid Solution file", "Oops...");
|
|
this.parent.UpdateRecentProjectList(strPath, false);
|
|
return false;
|
|
}
|
|
|
|
this.treeView1.Nodes.Clear();
|
|
|
|
foreach (XmlNode xmlSolution in xml.SelectNodes("//Solution"))
|
|
{
|
|
if (xmlSolution.Attributes["repository"] != null)
|
|
this.Repository = xmlSolution.Attributes["repository"].Value;
|
|
|
|
AddSolution(xmlSolution.Attributes["name"].Value);
|
|
foreach (XmlNode xmlItem in xmlSolution.SelectNodes("./*"))
|
|
{
|
|
string strItemPath = xmlItem.Attributes["path"].Value;
|
|
if (!Path.IsPathRooted(strItemPath))
|
|
strItemPath = Path.Combine(DirectorySolution, strItemPath);
|
|
if (!File.Exists(strItemPath))
|
|
continue; // TODO verbose error
|
|
bool blnActive = false;
|
|
if (xmlItem.Attributes["active"] != null)
|
|
blnActive = (xmlItem.Attributes["active"].Value == "true");
|
|
LoadItem(strItemPath,blnActive);
|
|
}
|
|
}
|
|
this.parent.ShowSolutionExplorer(true);
|
|
this.parent.SolutionItemsFileMenu(true);
|
|
this.parent.UpdateRecentProjectList(strPath,true);
|
|
this.m_dirty = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool SaveSolutionFile()
|
|
{
|
|
if (ActiveSolution == null)
|
|
return false;
|
|
if (DirectorySolution == null)
|
|
return false;
|
|
if (NameSolution == null)
|
|
return false;
|
|
|
|
if (!Directory.Exists(DirectorySolution))
|
|
Directory.CreateDirectory(DirectorySolution);
|
|
|
|
string strSolutionFileName = Path.Combine(DirectorySolution, NameSolution + ".sol");
|
|
StreamWriter sw = new StreamWriter(strSolutionFileName);
|
|
string strRepositoryAttribute;
|
|
if (this.Repository == null)
|
|
strRepositoryAttribute = "";
|
|
else
|
|
strRepositoryAttribute = string.Format(" repository=\"{0}\"",this.Repository);
|
|
sw.WriteLine("<Solution name=\"{0}\"{1}>",NameSolution,strRepositoryAttribute);
|
|
foreach (TreeNode nodeItem in ActiveSolution.Nodes)
|
|
{
|
|
RealTag realTag = (RealTag)nodeItem.Tag;
|
|
string strItemPath = SaveItemFile(nodeItem);
|
|
if (strItemPath != null)
|
|
{
|
|
// Make path relative, if it is the same as solution directory
|
|
if (strItemPath.ToLower().IndexOf(DirectorySolution.ToLower()) == 0)
|
|
strItemPath = strItemPath.Substring(DirectorySolution.Length+1);
|
|
string strActive = "";
|
|
if (ActiveProject == nodeItem)
|
|
strActive = @" active=""true""";
|
|
sw.WriteLine("\t<Project name=\"{0}\" path=\"{1}\"{2}/>", nodeItem.Text, strItemPath, strActive);
|
|
}
|
|
}
|
|
sw.WriteLine("</Solution>");
|
|
sw.Close();
|
|
this.m_dirty = false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private string SaveItemFile(TreeNode nodeItem)
|
|
{
|
|
string strName = nodeItem.Text;
|
|
RealTag realTag = (RealTag)nodeItem.Tag;
|
|
string strPath = realTag.Path;
|
|
|
|
if (!Directory.Exists(strPath))
|
|
Directory.CreateDirectory(strPath);
|
|
|
|
string strExtension = ".prj";
|
|
if (realTag.Name == "Inventory")
|
|
strExtension = ".inv";
|
|
string strFilePath = Path.Combine(strPath, strName + strExtension);
|
|
StreamWriter sw = new StreamWriter(strFilePath);
|
|
sw.Write(GetXml(0, nodeItem));
|
|
sw.Close();
|
|
return strFilePath;
|
|
}
|
|
|
|
private void AddSolution(string strNameSolution)
|
|
{
|
|
this.NameSolution = strNameSolution;
|
|
ActiveSolution = new TreeNode("Solution '" + strNameSolution + "'", (int)TypeSL.Solution, (int)TypeSL.Solution);
|
|
ActiveSolution.Tag = new RealTag(TypeSL.Solution, strNameSolution, Guid.NewGuid());
|
|
this.treeView1.Nodes.Insert(0,ActiveSolution);
|
|
ActiveSolution.Expand();
|
|
this.parent.SolutionItemsFileMenu(true);
|
|
}
|
|
|
|
private void UpdateVisualSolutionName()
|
|
{
|
|
int intProjects = NumberOfProjects();
|
|
ActiveSolution.Text = "Solution '" + this.NameSolution + "' (" + intProjects + " project" + ((intProjects != 1) ? "s" : "") + ")";
|
|
}
|
|
|
|
private bool ItemExist(Guid guid)
|
|
{
|
|
foreach (TreeNode itemNode in ActiveSolution.Nodes)
|
|
{
|
|
RealTag realTag = (RealTag)itemNode.Tag;
|
|
if (realTag.Guid == guid)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private TreeNode AddItem(TypeSL typeSL, string strName, Guid guid, string strPath)
|
|
{
|
|
if (ItemExist(guid))
|
|
return null;
|
|
|
|
if (!Directory.Exists(strPath))
|
|
Directory.CreateDirectory(strPath);
|
|
|
|
TreeNode treeNode = new TreeNode(strName, (int)typeSL, (int)typeSL);
|
|
treeNode.Tag = new RealTag(typeSL, strName, guid, strPath);
|
|
|
|
if (ActiveProject == null && typeSL == TypeSL.Project)
|
|
ActiveProject = treeNode;
|
|
|
|
ActiveSolution.Nodes.Add(treeNode);
|
|
ActiveSolution.Expand();
|
|
UpdateVisualSolutionName();
|
|
|
|
this.m_dirty = true;
|
|
|
|
return treeNode;
|
|
}
|
|
|
|
private TreeNode AddNewContainer(TreeNode parent, TypeSL typeSL, string strNewName, Guid guid)
|
|
{
|
|
if (parent == null)
|
|
return null;
|
|
|
|
string strDirectoryContainer = Path.Combine(GetFullPath(parent), strNewName);
|
|
if (!Directory.Exists(strDirectoryContainer))
|
|
Directory.CreateDirectory(strDirectoryContainer);
|
|
|
|
TreeNode treeNode = new TreeNode(strNewName, (int)typeSL, (int)typeSL);
|
|
treeNode.Tag = new RealTag(typeSL, strNewName, guid);
|
|
|
|
if (ActiveObject == null && typeSL == TypeSL.Object)
|
|
ActiveObject = treeNode;
|
|
|
|
parent.Nodes.Add(treeNode);
|
|
parent.Expand();
|
|
|
|
this.m_dirty = true;
|
|
|
|
return treeNode;
|
|
}
|
|
|
|
|
|
private void AddNewFile(TreeNode parent, TypeSL typeFile)
|
|
{
|
|
if (parent == null)
|
|
return;
|
|
|
|
string strName = typeFile+"{0}";
|
|
string strExtension = "";
|
|
switch (typeFile)
|
|
{
|
|
case TypeSL.Script:
|
|
strExtension = ".lsl";
|
|
break;
|
|
case TypeSL.LSLIScript:
|
|
strExtension = ".lsli";
|
|
break;
|
|
case TypeSL.Notecard:
|
|
strExtension = ".txt";
|
|
break;
|
|
case TypeSL.Texture:
|
|
strExtension = ".tga";
|
|
break;
|
|
case TypeSL.Animation:
|
|
strExtension = ".ani";
|
|
break;
|
|
case TypeSL.Gesture:
|
|
strExtension = ".ges";
|
|
break;
|
|
case TypeSL.Landmark:
|
|
strExtension = ".lmrk";
|
|
break;
|
|
case TypeSL.Snapshot:
|
|
strExtension = ".pic";
|
|
break;
|
|
case TypeSL.Sound:
|
|
strExtension = ".snd";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
string strNewName = GetNewFileName(parent, strName + strExtension);
|
|
|
|
string strFilePath = Path.Combine(GetFullPath(parent), strNewName);
|
|
|
|
if (!File.Exists(strFilePath))
|
|
{
|
|
StreamWriter sw = new StreamWriter(strFilePath);
|
|
|
|
switch (typeFile)
|
|
{
|
|
case TypeSL.Script:
|
|
sw.Write(AutoFormatter.ApplyFormatting(0,Helpers.GetTemplate.Source()));
|
|
break;
|
|
case TypeSL.LSLIScript:
|
|
sw.Write(AutoFormatter.ApplyFormatting(0, Helpers.GetTemplate.Source()));
|
|
break;
|
|
case TypeSL.Notecard:
|
|
sw.Write("notecard");
|
|
break;
|
|
default:
|
|
// empty file
|
|
break;
|
|
}
|
|
sw.Close();
|
|
}
|
|
|
|
TreeNode newFile = new TreeNode(strNewName, (int)typeFile, (int)typeFile);
|
|
newFile.Tag = new RealTag(typeFile, strNewName, Guid.NewGuid());
|
|
parent.Nodes.Add(newFile);
|
|
parent.Expand();
|
|
|
|
this.m_dirty = true;
|
|
}
|
|
|
|
private void AddExistingFile(TreeNode parent, string strName, Guid guid)
|
|
{
|
|
if (parent == null)
|
|
return;
|
|
|
|
string strFilePath = Path.Combine(GetFullPath(parent), strName);
|
|
|
|
TypeSL typeFile = TypeSL.Unknown;
|
|
|
|
switch (Path.GetExtension(strName))
|
|
{
|
|
case ".lsl":
|
|
typeFile = TypeSL.Script;
|
|
break;
|
|
case ".txt":
|
|
typeFile = TypeSL.Notecard;
|
|
break;
|
|
case ".ogg":
|
|
case ".wav":
|
|
case ".mp3":
|
|
typeFile = TypeSL.Sound;
|
|
break;
|
|
case ".ani":
|
|
typeFile = TypeSL.Animation;
|
|
break;
|
|
case ".gif":
|
|
case ".jpg":
|
|
case ".jpeg":
|
|
case ".tiff":
|
|
case ".bmp":
|
|
case ".png":
|
|
typeFile = TypeSL.Snapshot;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
TreeNode newFile = new TreeNode(strName, (int)typeFile, (int)typeFile);
|
|
newFile.Tag = new RealTag(typeFile, strName, guid);
|
|
parent.Nodes.Add(newFile);
|
|
parent.Expand();
|
|
|
|
this.m_dirty = true;
|
|
}
|
|
|
|
private void AddExistingFile(TreeNode tn)
|
|
{
|
|
if (GetTypeSL(tn) != TypeSL.Object)
|
|
return;
|
|
this.openFileDialog1.FileName = "";
|
|
this.openFileDialog1.Filter = "All Files (*.*)|*.*";
|
|
this.openFileDialog1.Multiselect = true;
|
|
if (this.openFileDialog1.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
foreach (string strSourcePath in this.openFileDialog1.FileNames)
|
|
{
|
|
string strName = Path.GetFileName(strSourcePath);
|
|
string strDestinationPath = Path.Combine(GetFullPath(tn), strName);
|
|
|
|
bool blnAdd = true;
|
|
foreach (TreeNode child in tn.Nodes)
|
|
{
|
|
if (child.Text == strName)
|
|
{
|
|
blnAdd = false;
|
|
|
|
if (strSourcePath.ToLower() == strDestinationPath.ToLower())
|
|
break;
|
|
|
|
if (MessageBox.Show("Overwrite existing file?", "File already exists", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == DialogResult.OK)
|
|
{
|
|
child.Remove();
|
|
blnAdd = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!blnAdd)
|
|
continue;
|
|
if (strSourcePath.ToLower() != strDestinationPath.ToLower())
|
|
{
|
|
try
|
|
{
|
|
File.Copy(strSourcePath, strDestinationPath, true);
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
MessageBox.Show(exception.Message, "Oops...", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
AddExistingFile(tn, strName, Guid.NewGuid());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void AddNewObject()
|
|
{
|
|
if (ActiveProject == null)
|
|
return;
|
|
AddNewContainer(ActiveProject, TypeSL.Object, GetNewDirectoryName(ActiveProject, "Object{0}"), Guid.NewGuid());
|
|
}
|
|
|
|
#region ContextMenus
|
|
|
|
private ToolStripMenuItem cmsItemsAdd(ContextMenuStrip cms, string strName, string strValue,string strKeys)
|
|
{
|
|
ToolStripMenuItem tsmi = new ToolStripMenuItem(strValue);
|
|
tsmi.ShortcutKeyDisplayString = strKeys;
|
|
tsmi.Name = strName;
|
|
cms.Items.Add(tsmi);
|
|
return tsmi;
|
|
}
|
|
|
|
private ToolStripMenuItem cmsItemsAdd(ContextMenuStrip cms, string strName, string strValue)
|
|
{
|
|
ToolStripMenuItem tsmi = new ToolStripMenuItem(strValue);
|
|
tsmi.Name = strName;
|
|
cms.Items.Add(tsmi);
|
|
return tsmi;
|
|
}
|
|
|
|
private ContextMenuStrip ContextMenuSolution()
|
|
{
|
|
ContextMenuStrip cms = new ContextMenuStrip();
|
|
cms.MouseClick += new MouseEventHandler(cms_MouseClick);
|
|
cmsItemsAdd(cms, "CloseSolution", "Close Solution");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
|
|
if (Properties.Settings.Default.VersionControlSVN)
|
|
{
|
|
if (this.Repository == null)
|
|
{
|
|
cmsItemsAdd(cms, "SvnImport", "Import Solution SVN");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
}
|
|
else // already workingcopy
|
|
{
|
|
cmsItemsAdd(cms, "SvnUpdate", "SVN update");
|
|
cmsItemsAdd(cms, "SvnCommit", "SVN commit");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
}
|
|
}
|
|
|
|
cmsItemsAdd(cms, "AddNewProject", "Add New Project");
|
|
cmsItemsAdd(cms, "AddExistingProject", "Add Existing Project...");
|
|
if (!HasInventory())
|
|
{
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "AddInventory", "Add Empty Inventory");
|
|
}
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
if (GetTypeSL(CutObject) == TypeSL.Project || GetTypeSL(CopyObject) == TypeSL.Project)
|
|
cmsItemsAdd(cms, "Paste", "Paste project" , "Ctrl+V");
|
|
cmsItemsAdd(cms, "Rename", "Rename" , "F2");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Properties", "Properties");
|
|
return cms;
|
|
}
|
|
|
|
private ContextMenuStrip ContextMenuInventory(TypeSL typeSL)
|
|
{
|
|
ContextMenuStrip cms = new ContextMenuStrip();
|
|
cms.MouseClick += new MouseEventHandler(cms_MouseClick);
|
|
|
|
if (typeSL != TypeSL.Inventory)
|
|
{
|
|
ToolStripMenuItem tsmiClothes = cmsItemsAdd(cms, "Add", "Add Clothes");
|
|
tsmiClothes.DropDownItemClicked += new ToolStripItemClickedEventHandler(tsmi_DropDownItemClicked);
|
|
foreach (TypeSL file in ClothesTypes)
|
|
tsmiClothes.DropDownItems.Add(file.ToString(), this.imageList1.Images[(int)file]);
|
|
|
|
ToolStripMenuItem tsmiBodyParts = cmsItemsAdd(cms, "Add", "Add Body Parts");
|
|
tsmiBodyParts.DropDownItemClicked += new ToolStripItemClickedEventHandler(tsmi_DropDownItemClicked);
|
|
foreach (TypeSL file in BodyPartsTypes)
|
|
tsmiBodyParts.DropDownItems.Add(file.ToString(), this.imageList1.Images[(int)file]);
|
|
|
|
ToolStripMenuItem tsmiFiles = cmsItemsAdd(cms, "Add", "Add Items");
|
|
tsmiFiles.DropDownItemClicked += new ToolStripItemClickedEventHandler(tsmi_DropDownItemClicked);
|
|
foreach (TypeSL file in FilesTypes)
|
|
tsmiFiles.DropDownItems.Add(file.ToString(), this.imageList1.Images[(int)file]);
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
}
|
|
cmsItemsAdd(cms, "AddNewFolder", "Add New Folder");
|
|
|
|
if (typeSL == TypeSL.Folder)
|
|
{
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Cut", "Cut" , "Ctrl+X");
|
|
cmsItemsAdd(cms, "Copy", "Copy","Ctrl+C");
|
|
cmsItemsAdd(cms, "Delete", "Delete", "Del");
|
|
cmsItemsAdd(cms, "Rename", "Rename", "F2");
|
|
}
|
|
if (CutObject != null || CopyObject != null)
|
|
{
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Paste", "Paste", "Ctrl+V");
|
|
}
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Properties", "Properties");
|
|
|
|
return cms;
|
|
}
|
|
|
|
private ContextMenuStrip ContextMenuProject()
|
|
{
|
|
ContextMenuStrip cms = new ContextMenuStrip();
|
|
cms.MouseClick += new MouseEventHandler(cms_MouseClick);
|
|
cmsItemsAdd(cms, "AddNewObject", "Add New Object");
|
|
cmsItemsAdd(cms, "AddExistingObject", "Add Existing Object...");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
if (NumberOfProjects() > 1 || ActiveProject == null)
|
|
cmsItemsAdd(cms, "SetAsActiveProject", "Set as Active Project");
|
|
cmsItemsAdd(cms, "DebugStart","Debug Start");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Cut","Cut","Ctrl+X");
|
|
cmsItemsAdd(cms, "Copy", "Copy", "Ctrl+C");
|
|
cmsItemsAdd(cms, "Remove","Remove");
|
|
if (GetTypeSL(CutObject) == TypeSL.Object || GetTypeSL(CopyObject) == TypeSL.Object)
|
|
cmsItemsAdd(cms, "Paste", "Paste Object","Ctrl+V");
|
|
cmsItemsAdd(cms, "Rename","Rename","F2");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Properties","Properties");
|
|
return cms;
|
|
}
|
|
|
|
public void CreateNewFileDrowDownMenu(ToolStripMenuItem tsmi)
|
|
{
|
|
tsmi.DropDownItemClicked += new ToolStripItemClickedEventHandler(tsmi_DropDownItemClicked);
|
|
foreach (TypeSL file in FilesTypes)
|
|
tsmi.DropDownItems.Add(file.ToString(), this.imageList1.Images[(int)file]);
|
|
}
|
|
|
|
public void CreateNewFileDrowDownMenu(ContextMenuStrip cms)
|
|
{
|
|
ToolStripMenuItem tsmi = cmsItemsAdd(cms, "Add", "Add New Item");
|
|
tsmi.DropDownItemClicked += new ToolStripItemClickedEventHandler(tsmi_DropDownItemClicked);
|
|
foreach (TypeSL file in FilesTypes)
|
|
tsmi.DropDownItems.Add(file.ToString(), this.imageList1.Images[(int)file]);
|
|
}
|
|
|
|
private ContextMenuStrip ContextMenuBox()
|
|
{
|
|
ContextMenuStrip cms = new ContextMenuStrip();
|
|
cms.MouseClick += new MouseEventHandler(cms_MouseClick);
|
|
|
|
CreateNewFileDrowDownMenu(cms);
|
|
//ToolStripMenuItem tsmi = cmsItemsAdd(cms, "Add", "Add New File");
|
|
//tsmi.DropDownItemClicked += new ToolStripItemClickedEventHandler(tsmi_DropDownItemClicked);
|
|
//foreach (TypeSL file in FilesTypes)
|
|
// tsmi.DropDownItems.Add(file.ToString(), this.imageList1.Images[(int)file]);
|
|
|
|
cmsItemsAdd(cms, "AddExistingFile", "Add Existing File(s)...");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "SetAsActiveBox", "Set As Active Object");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "ExcludeFromProject", "Exclude From Project");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Cut", "Cut","Ctrl+X");
|
|
cmsItemsAdd(cms, "Copy", "Copy", "Ctrl+C");
|
|
cmsItemsAdd(cms, "Delete", "Delete", "Del");
|
|
if (IsItem(CutObject) || IsItem(CopyObject))
|
|
cmsItemsAdd(cms, "Paste", "Paste", "Ctrl+V");
|
|
cmsItemsAdd(cms, "Rename", "Rename","F2");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Properties", "Properties");
|
|
return cms;
|
|
}
|
|
|
|
private ContextMenuStrip ContextMenuFile()
|
|
{
|
|
ContextMenuStrip cms = new ContextMenuStrip();
|
|
cms.MouseClick += new MouseEventHandler(cms_MouseClick);
|
|
cmsItemsAdd(cms, "Open", "Open");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Cut", "Cut" , "Ctrl+X");
|
|
cmsItemsAdd(cms, "Copy", "Copy", "Ctrl+C");
|
|
cmsItemsAdd(cms, "Delete", "Delete", "Del");
|
|
cmsItemsAdd(cms, "Rename", "Rename", "F2");
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
ToolStripMenuItem tsmi = cmsItemsAdd(cms, "ChangeFileType", "Change filetype");
|
|
CreateNewFileDrowDownMenu(tsmi);
|
|
cms.Items.Add(new ToolStripSeparator());
|
|
cmsItemsAdd(cms, "Properties", "Properties");
|
|
return cms;
|
|
}
|
|
|
|
#endregion
|
|
|
|
void tsmi_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
|
|
{
|
|
// Add New File
|
|
TreeNode tn;
|
|
ToolStripDropDownItem tsddi = sender as ToolStripDropDownItem;
|
|
ContextMenuStrip cms = tsddi.Owner as ContextMenuStrip;
|
|
if (cms != null)
|
|
tn = cms.Tag as TreeNode;
|
|
else
|
|
tn = ActiveObject;
|
|
|
|
if (tn != null)
|
|
{
|
|
string strName = tsddi.Name;
|
|
if (strName == "ChangeFileType")
|
|
{
|
|
RealTag realTag = (RealTag)tn.Tag;
|
|
TypeSL stypeSl = (TypeSL)Enum.Parse(typeof(TypeSL), e.ClickedItem.Text);
|
|
realTag.ItemType = stypeSl;
|
|
tn.Tag = realTag;
|
|
tn.ImageIndex = (int)stypeSl;
|
|
tn.SelectedImageIndex = (int)stypeSl;
|
|
this.treeView1.Invalidate(tn.Bounds);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
TypeSL typeSL = (TypeSL)Enum.Parse(typeof(TypeSL), e.ClickedItem.Text);
|
|
if (typeSL != TypeSL.Object)
|
|
AddNewFile(tn, typeSL);
|
|
else
|
|
AddNewContainer(tn, TypeSL.Object, GetNewDirectoryName(tn, "Object{0}"), Guid.NewGuid());
|
|
}
|
|
}
|
|
}
|
|
|
|
void treeView1_MouseUp(object sender, MouseEventArgs e)
|
|
{
|
|
if (e.Button != MouseButtons.Left)
|
|
return;
|
|
|
|
TreeNode treeNode = this.treeView1.GetNodeAt(new Point(e.X, e.Y));
|
|
if (treeNode == null)
|
|
return;
|
|
|
|
if (e.X < treeNode.Bounds.X) // only when clicked on the label
|
|
return;
|
|
|
|
if (timer.Tag != null)
|
|
{
|
|
if (timer.Tag == treeNode)
|
|
{
|
|
timer.Tag = null;
|
|
timer.Start();
|
|
return;
|
|
}
|
|
}
|
|
timer.Tag = treeNode;
|
|
}
|
|
|
|
void treeView1_MouseDown(object sender, MouseEventArgs e)
|
|
{
|
|
TreeNode treeNode = this.treeView1.GetNodeAt(new Point(e.X, e.Y));
|
|
if (treeNode == null)
|
|
return;
|
|
|
|
this.treeView1.SelectedNode = treeNode;
|
|
|
|
RealTag realTag = (RealTag)treeNode.Tag;
|
|
|
|
if (e.Button == MouseButtons.Right)
|
|
{
|
|
ContextMenuStrip cms = null;
|
|
switch (realTag.ItemType)
|
|
{
|
|
case TypeSL.Solution:
|
|
cms = ContextMenuSolution();
|
|
break;
|
|
case TypeSL.Project:
|
|
cms = ContextMenuProject();
|
|
break;
|
|
case TypeSL.Object:
|
|
cms = ContextMenuBox();
|
|
break;
|
|
default:
|
|
if (IsInventoryContainer(treeNode))
|
|
cms = ContextMenuInventory(realTag.ItemType);
|
|
else if (IsItem(treeNode))
|
|
cms = ContextMenuFile();
|
|
else
|
|
cms = new ContextMenuStrip();
|
|
break;
|
|
}
|
|
cms.Tag = treeNode;
|
|
this.treeView1.ContextMenuStrip = cms;
|
|
}
|
|
}
|
|
|
|
private string GetNewName(TreeNode treeNode, bool blnDirectory, string strFormat)
|
|
{
|
|
string strDirectory = GetFullPath(treeNode);
|
|
if (File.Exists(strDirectory))
|
|
strDirectory = Path.GetDirectoryName(strDirectory);
|
|
|
|
if (!Directory.Exists(strDirectory))
|
|
Directory.CreateDirectory(strDirectory);
|
|
|
|
RealTag realTag = (RealTag)treeNode.Tag;
|
|
if (blnDirectory)
|
|
{
|
|
string strName = strFormat.Replace("({0}) ", "").Replace("{0}", "").Replace("Copy of ","");
|
|
if (!Directory.Exists(Path.Combine(strDirectory, strName)))
|
|
return strName;
|
|
strName = strFormat.Replace("({0}) ", "").Replace("{0}", "");
|
|
if (!Directory.Exists(Path.Combine(strDirectory, strName)))
|
|
return strName;
|
|
|
|
for (int intI = 1; intI < 255; intI++)
|
|
{
|
|
strName = string.Format(strFormat, intI);
|
|
if (!Directory.Exists(Path.Combine(strDirectory, strName)))
|
|
return strName;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string strName = strFormat.Replace("({0}) ", "").Replace("{0}", "").Replace("Copy of ","");
|
|
if (!File.Exists(Path.Combine(strDirectory, strName)))
|
|
return strName;
|
|
strName = strFormat.Replace("({0}) ", "").Replace("{0}", "");
|
|
if (!File.Exists(Path.Combine(strDirectory, strName)))
|
|
return strName;
|
|
|
|
for (int intI = 2; intI < 255; intI++)
|
|
{
|
|
strName = string.Format(strFormat, intI);
|
|
if (!File.Exists(Path.Combine(strDirectory, strName)))
|
|
return strName;
|
|
}
|
|
}
|
|
MessageBox.Show("There are 255 items with the same name", "Oops...");
|
|
return null;
|
|
}
|
|
|
|
private string GetNewFileName(TreeNode treeNode, string strFormat)
|
|
{
|
|
return GetNewName(treeNode, false, strFormat);
|
|
}
|
|
|
|
private string GetNewDirectoryName(TreeNode treeNode, string strFormat)
|
|
{
|
|
return GetNewName(treeNode, true, strFormat);
|
|
}
|
|
|
|
private void DeleteAction(TreeNode tn)
|
|
{
|
|
if (MessageBox.Show("Delete " + tn.Text, "Delete?", MessageBoxButtons.YesNo) == DialogResult.Yes)
|
|
DeleteChildren(tn);
|
|
}
|
|
|
|
private void DeleteChildren(TreeNode tn)
|
|
{
|
|
// remove backwards, foreach does not work
|
|
for(int intI=tn.Nodes.Count-1;intI>=0;intI--)
|
|
DeleteChildren(tn.Nodes[intI]);
|
|
|
|
string strPath = GetFullPath(tn);
|
|
if (File.Exists(strPath))
|
|
{
|
|
File.Delete(strPath);
|
|
RealTag rt = (RealTag)tn.Tag;
|
|
EditForm editForm = GetEditForm(rt.Guid);
|
|
if (editForm != null)
|
|
{
|
|
this.parent.ActivateMdiForm(editForm);
|
|
this.parent.CloseActiveWindow();
|
|
}
|
|
}
|
|
else if (Directory.Exists(strPath))
|
|
{
|
|
if (Directory.GetFiles(strPath).Length == 0)
|
|
Directory.Delete(strPath, true);
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Not found: " + tn.Text, "Oops...");
|
|
}
|
|
tn.Remove();
|
|
|
|
this.m_dirty = true;
|
|
}
|
|
|
|
private void CopyChildren(TreeNode Source,TreeNode Destination)
|
|
{
|
|
RealTag realTag = (RealTag)Source.Tag;
|
|
realTag.Guid = Guid.NewGuid(); // copy objects have new guid
|
|
if (realTag.Path!=null)
|
|
realTag.Path = Path.Combine(Path.GetDirectoryName(GetFullPath(Source)), Destination.Text);
|
|
|
|
Destination.Tag = realTag;
|
|
Destination.ImageIndex = Source.ImageIndex;
|
|
Destination.SelectedImageIndex = Source.SelectedImageIndex;
|
|
|
|
string strSourcePath = GetFullPath(Source);
|
|
string strDestionationPath = GetFullPath(Destination);
|
|
if (File.Exists(strSourcePath))
|
|
File.Copy(strSourcePath, strDestionationPath);
|
|
else if (Directory.Exists(strSourcePath))
|
|
Directory.CreateDirectory(strDestionationPath);
|
|
else
|
|
MessageBox.Show("Error: " + strSourcePath, "Oops...");
|
|
|
|
foreach (TreeNode child in Source.Nodes)
|
|
{
|
|
TreeNode clone = new TreeNode(child.Text);
|
|
Destination.Nodes.Add(clone);
|
|
CopyChildren(child, clone);
|
|
}
|
|
this.m_dirty = true;
|
|
}
|
|
|
|
private void PasteAction(TreeNode tn)
|
|
{
|
|
// paste on same object, get parent!!
|
|
// paste on item, get parent!!
|
|
if (tn == CopyObject || tn==CutObject || IsItemAndNotObject(tn))
|
|
tn = tn.Parent;
|
|
|
|
// sanitycheck, search all parents, may not be CopyObject or CutObject
|
|
TreeNode parentNode = tn;
|
|
while (parentNode != null)
|
|
{
|
|
if (parentNode == CopyObject || parentNode == CutObject)
|
|
return;
|
|
parentNode = parentNode.Parent;
|
|
}
|
|
|
|
switch(GetTypeSL(tn))
|
|
{
|
|
case TypeSL.Solution:
|
|
if (GetTypeSL(CutObject) != TypeSL.Project &&
|
|
GetTypeSL(CopyObject) != TypeSL.Project)
|
|
return;
|
|
break;
|
|
case TypeSL.Project:
|
|
if (GetTypeSL(CutObject) != TypeSL.Object &&
|
|
GetTypeSL(CopyObject) != TypeSL.Object)
|
|
return;
|
|
break;
|
|
case TypeSL.Object:
|
|
if (!IsItem(CutObject) && !IsItem(CopyObject))
|
|
return;
|
|
break;
|
|
default:
|
|
if(IsInventoryContainer(tn))
|
|
{
|
|
if (!IsItem(CutObject) && !IsItem(CopyObject) &&
|
|
GetTypeSL(CutObject) != TypeSL.Folder &&
|
|
GetTypeSL(CopyObject) != TypeSL.Folder)
|
|
return;
|
|
}
|
|
else if (!IsItem(tn)) // is special container
|
|
{
|
|
// must be a file
|
|
if (!IsItem(CutObject) && !IsItem(CopyObject) &&
|
|
GetTypeSL(CutObject) != TypeSL.Folder &&
|
|
GetTypeSL(CopyObject) != TypeSL.Folder)
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (CutObject != null) // Paste the Cut object
|
|
{
|
|
string strName = CutObject.Text;
|
|
|
|
foreach(TreeNode treeNode in tn.Nodes)
|
|
{
|
|
if (treeNode.Text == strName)
|
|
{
|
|
MessageBox.Show("Destination already exists","Oops...");
|
|
return;
|
|
}
|
|
}
|
|
|
|
TreeNode Destination = new TreeNode(strName);
|
|
tn.Nodes.Add(Destination);
|
|
|
|
CopyChildren(CutObject, Destination);
|
|
DeleteChildren(CutObject);
|
|
|
|
CutObject.Remove();
|
|
CutObject = null;
|
|
}
|
|
if (CopyObject != null) // Paste the Copy object
|
|
{
|
|
string strName;
|
|
if (IsItem(CopyObject) && GetTypeSL(CopyObject) != TypeSL.Object)
|
|
strName = GetNewFileName(tn, "Copy ({0}) of " + CopyObject.Text);
|
|
else
|
|
strName = GetNewDirectoryName(tn, "Copy ({0}) of " + CopyObject.Text);
|
|
|
|
TreeNode Destination = new TreeNode(strName);
|
|
tn.Nodes.Add(Destination);
|
|
|
|
CopyChildren(CopyObject, Destination);
|
|
|
|
CopyObject = null;
|
|
|
|
if (tn == ActiveSolution)
|
|
UpdateVisualSolutionName();
|
|
}
|
|
}
|
|
|
|
private void RemoveAction(TreeNode tn)
|
|
{
|
|
if (GetTypeSL(tn) == TypeSL.Project)
|
|
{
|
|
SaveItemFile(tn); // saving pending updates!!
|
|
if (ActiveProject == tn)
|
|
ActiveProject = null;
|
|
// Does not!!!! delete, only remove form project
|
|
tn.Remove();
|
|
UpdateVisualSolutionName();
|
|
this.m_dirty = true;
|
|
}
|
|
}
|
|
|
|
private void RenameAction(TreeNode tn)
|
|
{
|
|
RealTag realTag = (RealTag)tn.Tag;
|
|
if (IsInventoryContainer(tn))
|
|
{
|
|
if(realTag.ItemType != TypeSL.Folder)
|
|
return;
|
|
}
|
|
|
|
if (realTag.ItemType == TypeSL.Solution)
|
|
tn.Text = this.NameSolution;
|
|
this.treeView1.LabelEdit = true;
|
|
tn.BeginEdit();
|
|
}
|
|
|
|
private void CutAction(TreeNode tn)
|
|
{
|
|
if (CutObject != null)
|
|
CutObject.ForeColor = Color.Empty;
|
|
CutObject = tn;
|
|
tn.ForeColor = Color.DarkGray;
|
|
}
|
|
|
|
private void CopyAction(TreeNode tn)
|
|
{
|
|
if (CutObject != null)
|
|
{
|
|
CutObject.ForeColor = Color.Empty;
|
|
CutObject = null;
|
|
}
|
|
CopyObject = tn;
|
|
}
|
|
|
|
public void AddNewProjectAction()
|
|
{
|
|
string strNewProjectName = GetNewDirectoryName(ActiveSolution, "Project{0}");
|
|
string strProjectPath = Path.Combine(DirectorySolution, strNewProjectName);
|
|
AddItem(TypeSL.Project, strNewProjectName, Guid.NewGuid(), strProjectPath);
|
|
}
|
|
|
|
private void treeView1_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e)
|
|
{
|
|
timer.Stop();
|
|
timer.Tag = null;
|
|
|
|
Guid guid = ((RealTag)e.Node.Tag).Guid;
|
|
string path = GetFullPath(e.Node);
|
|
|
|
// already opened
|
|
EditForm editForm = GetEditForm(guid);
|
|
if (editForm != null)
|
|
{
|
|
TabPage tabPage = editForm.Tag as TabPage;
|
|
if (tabPage == null)
|
|
{
|
|
if(editForm.Visible)
|
|
{
|
|
editForm.Focus();
|
|
} else
|
|
{
|
|
// Check if there's a related expanded lsl or lsli opened. If so, focus it. Else open the lsli.
|
|
EditForm expandedForm = (EditForm)parent.GetForm(Helpers.LSLIPathHelper.GetExpandedTabName(Helpers.LSLIPathHelper.CreateExpandedScriptName(Path.GetFileName(path))));
|
|
EditForm collapsedForm = (EditForm)parent.GetForm(Helpers.LSLIPathHelper.CreateCollapsedScriptName(Path.GetFileName(path)));
|
|
if (expandedForm != null && expandedForm.Visible)
|
|
{
|
|
expandedForm.Focus();
|
|
}
|
|
else if (collapsedForm != null && collapsedForm.Visible)
|
|
{
|
|
collapsedForm.Focus();
|
|
}
|
|
else
|
|
{
|
|
// Open a new one
|
|
if (GetTypeSL(e.Node) == TypeSL.Script || GetTypeSL(e.Node) == TypeSL.LSLIScript)
|
|
{
|
|
this.parent.OpenFile(GetFullPath(e.Node), guid, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TabControl tabControl = tabPage.Parent as TabControl;
|
|
if(tabControl != null)
|
|
tabControl.SelectedTab = tabPage;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Check if it's an lsli that has an open expanded form
|
|
if (GetTypeSL(e.Node) == TypeSL.Script || GetTypeSL(e.Node) == TypeSL.LSLIScript)
|
|
{
|
|
if (Helpers.LSLIPathHelper.IsLSLI(path)) {
|
|
// Check if there's a related expanded lsl opened. If so, focus it. Else open the lsli.
|
|
EditForm expandedForm = (EditForm)parent.GetForm(Helpers.LSLIPathHelper.GetExpandedTabName(Helpers.LSLIPathHelper.CreateExpandedScriptName(Path.GetFileName(path))));
|
|
EditForm collapsedForm = (EditForm)parent.GetForm(Helpers.LSLIPathHelper.CreateCollapsedScriptName(Path.GetFileName(path)));
|
|
if (expandedForm != null && expandedForm.Visible)
|
|
{
|
|
expandedForm.Focus();
|
|
} else if(collapsedForm != null && collapsedForm.Visible)
|
|
{
|
|
collapsedForm.Focus();
|
|
} else
|
|
{
|
|
// Open a new one
|
|
if (GetTypeSL(e.Node) == TypeSL.Script || GetTypeSL(e.Node) == TypeSL.LSLIScript)
|
|
{
|
|
this.parent.OpenFile(GetFullPath(e.Node), guid, true);
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
// Open a new one
|
|
if (GetTypeSL(e.Node) == TypeSL.Script || GetTypeSL(e.Node) == TypeSL.LSLIScript)
|
|
{
|
|
this.parent.OpenFile(GetFullPath(e.Node), guid, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GetTypeSL(e.Node) == TypeSL.Notecard)
|
|
this.parent.OpenFile(GetFullPath(e.Node), guid, false);
|
|
}
|
|
private void PropertiesActions(TreeNode tn)
|
|
{
|
|
SolutionExplorer.RealTag realTag = (SolutionExplorer.RealTag)tn.Tag;
|
|
Guid oldGuid = realTag.Guid;
|
|
GuidProperty prop = new GuidProperty(realTag);
|
|
|
|
if (prop.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
EditForm editForm = GetEditForm(oldGuid);
|
|
if (editForm != null)
|
|
editForm.guid = prop.guid;
|
|
realTag.Guid = prop.guid;
|
|
tn.Tag = realTag;
|
|
ShowProperties(tn);
|
|
}
|
|
}
|
|
private void ShowProperties(TreeNode tn)
|
|
{
|
|
RealTag realTag = (RealTag)tn.Tag;
|
|
|
|
this.listView1.Items.Clear();
|
|
|
|
ListViewItem lvi = new ListViewItem("Name");
|
|
lvi.SubItems.Add(tn.Text);
|
|
this.listView1.Items.Add(lvi);
|
|
|
|
if (realTag.Description != string.Empty)
|
|
{
|
|
lvi = new ListViewItem("Description");
|
|
lvi.SubItems.Add(realTag.Description);
|
|
this.listView1.Items.Add(lvi);
|
|
}
|
|
|
|
lvi = new ListViewItem("Guid");
|
|
lvi.SubItems.Add(realTag.Guid.ToString());
|
|
this.listView1.Items.Add(lvi);
|
|
|
|
lvi = new ListViewItem("Path");
|
|
lvi.SubItems.Add(GetFullPath(tn));
|
|
this.listView1.Items.Add(lvi);
|
|
|
|
lvi = new ListViewItem("Modified");
|
|
FileInfo fi = new FileInfo(GetFullPath(tn));
|
|
lvi.SubItems.Add(fi.LastWriteTime.ToString("s"));
|
|
this.listView1.Items.Add(lvi);
|
|
|
|
}
|
|
|
|
private void SetAsActiveProject(TreeNode tn)
|
|
{
|
|
ActiveObject = null;
|
|
ActiveProject = tn;
|
|
foreach (TreeNode child in ActiveProject.Nodes)
|
|
{
|
|
if (GetTypeSL(child) == TypeSL.Object)
|
|
{
|
|
ActiveObject = child;
|
|
break;
|
|
}
|
|
}
|
|
this.treeView1.Invalidate();
|
|
}
|
|
|
|
private void SetAsActiveBox(TreeNode tn)
|
|
{
|
|
ActiveProject = null;
|
|
ActiveObject = tn;
|
|
if (GetTypeSL(ActiveObject.Parent) == TypeSL.Project)
|
|
ActiveProject = ActiveObject.Parent;
|
|
this.treeView1.Invalidate();
|
|
}
|
|
|
|
private void DebugStart()
|
|
{
|
|
MessageBox.Show("TODO: Debug start", "Todo");
|
|
}
|
|
|
|
private void AddExistingObject(TreeNode tn)
|
|
{
|
|
MessageBox.Show("TODO: Add Existing Object", "Todo");
|
|
}
|
|
|
|
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
|
|
{
|
|
ShowProperties(e.Node);
|
|
}
|
|
|
|
private TreeNode FindGuid(TreeNode treeNode, Guid guid)
|
|
{
|
|
if (treeNode == null)
|
|
return null;
|
|
foreach (TreeNode tn in treeNode.Nodes)
|
|
{
|
|
RealTag rt = (RealTag)tn.Tag;
|
|
if (rt.Guid == guid)
|
|
return tn;
|
|
TreeNode found = FindGuid(tn, guid);
|
|
if (found != null)
|
|
return found;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private delegate bool IHateThisToo(Guid guid, string name);
|
|
private delegate string IHateThis(Guid guid);
|
|
public string GetObjectName(Guid guid)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
return this.treeView1.Invoke(new IHateThis(GetObjectName), new object[] { guid }).ToString();
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return string.Empty;
|
|
TreeNode parent = treeNode.Parent;
|
|
RealTag realTag = (RealTag)parent.Tag;
|
|
if (realTag.ItemType != TypeSL.Object)
|
|
return string.Empty;
|
|
return realTag.Name;
|
|
}
|
|
|
|
public bool SetObjectName(Guid guid, string name)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
return (bool)this.treeView1.Invoke(new IHateThisToo(SetObjectName), new object[] { guid, name });
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return false;
|
|
TreeNode parent = treeNode.Parent;
|
|
RealTag realTag = (RealTag)parent.Tag;
|
|
if (realTag.ItemType != TypeSL.Object)
|
|
return false;
|
|
|
|
string strBackup = parent.Text;
|
|
string strSource = GetFullPath(parent);
|
|
parent.Text = name;
|
|
string strDestination = GetFullPath(parent);
|
|
|
|
try
|
|
{
|
|
Directory.Move(strSource, strDestination);
|
|
realTag.Name = name;
|
|
parent.Tag = realTag;
|
|
parent.Text = name;
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
parent.Text = strBackup;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public string GetObjectDescription(Guid guid)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
return this.treeView1.Invoke(new IHateThis(GetObjectDescription), new object[] { guid }).ToString();
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return string.Empty;
|
|
TreeNode parent = treeNode.Parent;
|
|
RealTag realTag = (RealTag)parent.Tag;
|
|
if (realTag.ItemType != TypeSL.Object)
|
|
return string.Empty;
|
|
return realTag.Description;
|
|
}
|
|
|
|
public bool SetObjectDescription(Guid guid, string description)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
return (bool)this.treeView1.Invoke(new IHateThisToo(SetObjectDescription), new object[] { guid, description });
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return false;
|
|
TreeNode parent = treeNode.Parent;
|
|
RealTag realTag = (RealTag)parent.Tag;
|
|
if (realTag.ItemType != TypeSL.Object)
|
|
return false;
|
|
realTag.Description = description;
|
|
parent.Tag = realTag;
|
|
return true;
|
|
}
|
|
|
|
|
|
public string GetScriptName(Guid guid)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
return this.treeView1.Invoke(new IHateThis(GetScriptName), new object[] { guid }).ToString();
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return string.Empty;
|
|
return treeNode.Text;
|
|
}
|
|
|
|
public string GetKey(Guid guid)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
return this.treeView1.Invoke(new IHateThis(GetKey), new object[] { guid }).ToString();
|
|
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return string.Empty;
|
|
TreeNode parent = treeNode.Parent;
|
|
RealTag rt = (RealTag)parent.Tag;
|
|
return rt.Guid.ToString();
|
|
}
|
|
|
|
private TypeSL GetTypeSLFromInteger(int type)
|
|
{
|
|
TypeSL typeSL = TypeSL.Unknown;
|
|
switch (type)
|
|
{
|
|
case -1: //INVENTORY_ALL -1 all inventory items
|
|
return TypeSL.Unknown;
|
|
case 20: //INVENTORY_ANIMATION 20 animations 0x14
|
|
return TypeSL.Animation;
|
|
case 13: //INVENTORY_BODYPART 13 body parts 0x0D
|
|
return TypeSL.Hair | TypeSL.Skin | TypeSL.Eyes | TypeSL.Shape;
|
|
case 5: //INVENTORY_CLOTHING 5 clothing 0x05
|
|
return TypeSL.Jacket | TypeSL.Gloves | TypeSL.Pants | TypeSL.Shirt | TypeSL.Shoes | TypeSL.Skirt | TypeSL.Socks | TypeSL.Underpants | TypeSL.Undershirt;
|
|
case 21: //INVENTORY_GESTURE 21 gestures 0x15
|
|
return TypeSL.Gesture;
|
|
case 3: //INVENTORY_LANDMARK 3 landmarks 0x03
|
|
return TypeSL.Landmark;
|
|
case 7: //INVENTORY_NOTECARD 7 notecards 0x07
|
|
return TypeSL.Notecard;
|
|
case 6: //INVENTORY_OBJECT 6 objects 0x06
|
|
return TypeSL.Object;
|
|
case 10: //INVENTORY_SCRIPT 10 scripts 0x0A
|
|
return TypeSL.Script;
|
|
case 1: //INVENTORY_SOUND 1 sounds 0x01
|
|
return TypeSL.Sound;
|
|
case 0: //INVENTORY_TEXTURE 0 textures 0x00
|
|
return TypeSL.Texture;
|
|
default:
|
|
break;
|
|
}
|
|
return typeSL;
|
|
}
|
|
|
|
private delegate void DelegateRemoveInventory(Guid guid, SecondLife.String name);
|
|
public void RemoveInventory(Guid guid, SecondLife.String name)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
this.treeView1.Invoke(new DelegateRemoveInventory(RemoveInventory), new object[] { guid, name });
|
|
return;
|
|
}
|
|
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return;
|
|
TreeNode parent = treeNode.Parent;
|
|
for (int i = 0; i < parent.Nodes.Count; ++i)
|
|
{
|
|
if (parent.Nodes[i].Text == name)
|
|
{
|
|
parent.Nodes.RemoveAt(i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
private delegate string DelegateGetInventoryName(Guid guid, int type, int number);
|
|
public string GetInventoryName(Guid guid, int type, int number)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
return this.treeView1.Invoke(new DelegateGetInventoryName(GetInventoryName), new object[] { guid, type, number }).ToString();
|
|
}
|
|
|
|
TypeSL typeSL = GetTypeSLFromInteger(type);
|
|
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return string.Empty;
|
|
TreeNode parent = treeNode.Parent;
|
|
int intI=0;
|
|
foreach (TreeNode tn in parent.Nodes)
|
|
{
|
|
if (typeSL == TypeSL.Unknown || (typeSL & GetTypeSL(tn) ) == GetTypeSL(tn))
|
|
{
|
|
if (intI == number)
|
|
return tn.Text;
|
|
intI++;
|
|
}
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
private delegate string DelegateGetInventoryKey(Guid guid, string name);
|
|
public string GetInventoryKey(Guid guid, string name)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
return this.treeView1.Invoke(new DelegateGetInventoryKey(GetInventoryKey), new object[] { guid, name }).ToString();
|
|
}
|
|
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return string.Empty;
|
|
TreeNode parent = treeNode.Parent;
|
|
foreach (TreeNode tn in parent.Nodes)
|
|
{
|
|
if (tn.Text == name)
|
|
{
|
|
RealTag rt = (RealTag)tn.Tag;
|
|
return rt.Guid.ToString();
|
|
}
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
private delegate int DelegateGetInventoryType(Guid guid, string name);
|
|
public int GetInventoryType(Guid guid, string name)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
return (int)this.treeView1.Invoke(new DelegateGetInventoryType(GetInventoryType), new object[] { guid, name });
|
|
}
|
|
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return SecondLife.INVENTORY_NONE;
|
|
TreeNode parent = treeNode.Parent;
|
|
foreach (TreeNode tn in parent.Nodes)
|
|
{
|
|
if (tn.Text == name)
|
|
{
|
|
RealTag rt = (RealTag)tn.Tag;
|
|
switch (rt.ItemType)
|
|
{
|
|
case TypeSL.Texture:
|
|
return SecondLife.INVENTORY_TEXTURE;
|
|
case TypeSL.Sound:
|
|
return SecondLife.INVENTORY_SOUND;
|
|
case TypeSL.Landmark:
|
|
return SecondLife.INVENTORY_LANDMARK;
|
|
case TypeSL.Gloves:
|
|
case TypeSL.Jacket:
|
|
case TypeSL.Pants:
|
|
case TypeSL.Shirt:
|
|
case TypeSL.Shoes:
|
|
case TypeSL.Skirt:
|
|
case TypeSL.Socks:
|
|
case TypeSL.Underpants:
|
|
case TypeSL.Undershirt:
|
|
return SecondLife.INVENTORY_CLOTHING;
|
|
case TypeSL.Object:
|
|
return SecondLife.INVENTORY_OBJECT;
|
|
case TypeSL.Script:
|
|
return SecondLife.INVENTORY_SCRIPT;
|
|
case TypeSL.Animation:
|
|
return SecondLife.INVENTORY_ANIMATION;
|
|
case TypeSL.Eyes:
|
|
case TypeSL.Hair:
|
|
case TypeSL.Shape:
|
|
case TypeSL.Skin:
|
|
return SecondLife.INVENTORY_BODYPART;
|
|
case TypeSL.Gesture:
|
|
return SecondLife.INVENTORY_GESTURE;
|
|
case TypeSL.Notecard:
|
|
return SecondLife.INVENTORY_NOTECARD;
|
|
default:
|
|
return SecondLife.INVENTORY_NONE;
|
|
}
|
|
}
|
|
}
|
|
return SecondLife.INVENTORY_NONE;
|
|
}
|
|
|
|
private delegate int DelegateGetInventoryNumber(Guid guid, int type);
|
|
public int GetInventoryNumber(Guid guid, int type)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
return (int)this.treeView1.Invoke(new DelegateGetInventoryNumber(GetInventoryNumber), new object[] { guid, type });
|
|
}
|
|
|
|
TypeSL typeSL = GetTypeSLFromInteger(type);
|
|
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return -1;
|
|
TreeNode parent = treeNode.Parent;
|
|
int intI = 0;
|
|
foreach (TreeNode tn in parent.Nodes)
|
|
{
|
|
if (typeSL == TypeSL.Unknown || (typeSL & GetTypeSL(tn)) == GetTypeSL(tn))
|
|
intI++;
|
|
}
|
|
return intI;
|
|
}
|
|
|
|
private delegate string DelegateGetPath(Guid guid, string name);
|
|
public string GetPath(Guid guid, string name)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
return this.treeView1.Invoke(new DelegateGetPath(GetPath), new object[] { guid, name }).ToString();
|
|
}
|
|
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return string.Empty;
|
|
TreeNode parent = treeNode.Parent;
|
|
foreach (TreeNode tn in parent.Nodes)
|
|
{
|
|
if (tn.Text == name || ((RealTag)tn.Tag).Guid.ToString() == name)
|
|
return GetFullPath(tn);
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
private delegate Guid GetParentGuidDelegate(Guid guid);
|
|
public Guid GetParentGuid(Guid guid)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
return (Guid)this.treeView1.Invoke(new GetParentGuidDelegate(GetParentGuid), new object[] { guid });
|
|
}
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return Guid.Empty;
|
|
TreeNode parent = treeNode.Parent;
|
|
// Only return parent when it is an object
|
|
if (((RealTag)parent.Tag).ItemType != TypeSL.Object)
|
|
return guid;
|
|
else // Return object itself, has no parent object
|
|
return ((RealTag)parent.Tag).Guid;
|
|
}
|
|
|
|
private delegate Guid GetGuidFromObjectNrDelegate(Guid ObjectGuid, int intLinkNum);
|
|
public Guid GetGuidFromObjectNr(Guid ObjectGuid, int intLinkNum)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
{
|
|
return (Guid)this.treeView1.Invoke(new GetGuidFromObjectNrDelegate(GetGuidFromObjectNr), new object[] { ObjectGuid, intLinkNum });
|
|
}
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, ObjectGuid);
|
|
if (treeNode == null)
|
|
return Guid.Empty;
|
|
int intNr = 0;
|
|
foreach (TreeNode tn in treeNode.Nodes)
|
|
{
|
|
RealTag realTag = (RealTag)tn.Tag;
|
|
if (realTag.ItemType == TypeSL.Object)
|
|
{
|
|
intNr++;
|
|
if (intNr == intLinkNum)
|
|
return realTag.Guid;
|
|
}
|
|
}
|
|
return Guid.Empty; // no objects found
|
|
}
|
|
|
|
private void GetScriptsFromNode(TreeNode treeNode, List<Guid> list, bool recursive)
|
|
{
|
|
foreach (TreeNode tn in treeNode.Nodes)
|
|
{
|
|
RealTag realTag = (RealTag)tn.Tag;
|
|
if (realTag.ItemType == TypeSL.Script)
|
|
list.Add(realTag.Guid);
|
|
else
|
|
if (realTag.ItemType == TypeSL.Object && recursive)
|
|
GetScriptsFromNode(tn, list, recursive);
|
|
}
|
|
}
|
|
|
|
private delegate List<Guid> GetScriptsDelegate(Guid guid, bool recursive);
|
|
public List<Guid> GetScripts(Guid guid, bool recursive)
|
|
{
|
|
if (this.treeView1.InvokeRequired)
|
|
return this.treeView1.Invoke(new GetScriptsDelegate(GetScripts), new object[] { guid, recursive }) as List<Guid>;
|
|
|
|
List<Guid> list = new List<Guid>();
|
|
TreeNode treeNode = FindGuid(this.treeView1.TopNode, guid);
|
|
if (treeNode == null)
|
|
return list; // empty
|
|
GetScriptsFromNode(treeNode, list, recursive);
|
|
return list;
|
|
}
|
|
|
|
private void listView1_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
ListViewItem lvi = this.listView1.GetItemAt(e.X,e.Y);
|
|
if (lvi == null)
|
|
this.toolTip1.SetToolTip(this.listView1, "");
|
|
else if (lvi != m_HoveredItem)
|
|
{
|
|
m_HoveredItem = lvi;
|
|
this.toolTip1.SetToolTip(this.listView1, lvi.SubItems[1].Text);
|
|
}
|
|
}
|
|
|
|
private void treeView1_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (this.treeView1.SelectedNode == null)
|
|
return;
|
|
if (e.KeyCode == Keys.ControlKey)
|
|
return;
|
|
switch (e.KeyCode)
|
|
{
|
|
case Keys.F2:
|
|
RenameAction(this.treeView1.SelectedNode);
|
|
e.Handled = true;
|
|
break;
|
|
case Keys.Delete:
|
|
DeleteAction(this.treeView1.SelectedNode);
|
|
e.Handled = true;
|
|
break;
|
|
case Keys.C:
|
|
if (e.Control)
|
|
{
|
|
CopyAction(this.treeView1.SelectedNode);
|
|
e.SuppressKeyPress = true;
|
|
e.Handled = true;
|
|
}
|
|
break;
|
|
case Keys.V:
|
|
if (e.Control)
|
|
{
|
|
PasteAction(this.treeView1.SelectedNode);
|
|
e.SuppressKeyPress = true;
|
|
e.Handled = true;
|
|
}
|
|
break;
|
|
case Keys.X:
|
|
if (e.Control)
|
|
{
|
|
CutAction(this.treeView1.SelectedNode);
|
|
e.SuppressKeyPress = true;
|
|
e.Handled = true;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void SvnImport()
|
|
{
|
|
SvnAguments svnArguments = new SvnAguments();
|
|
svnArguments.Text = "SVN import";
|
|
svnArguments.Comment = "Initial import";
|
|
if (svnArguments.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
string strRepository = svnArguments.Repository;
|
|
string strMessage = svnArguments.Comment;
|
|
|
|
strMessage = strMessage.Replace('"', '\'');
|
|
|
|
string strNameOfDirectory = Path.GetFileName(this.DirectorySolution);
|
|
|
|
if (!strRepository.EndsWith(strNameOfDirectory))
|
|
{
|
|
if (!strRepository.EndsWith("/"))
|
|
strRepository += "/";
|
|
strRepository += strNameOfDirectory;
|
|
}
|
|
|
|
this.Repository = strRepository;
|
|
this.SaveSolutionFile();
|
|
|
|
// import "c:\temp\a\b \d\dir" "file:///d:/temp/svn/...." -m "Initital "
|
|
string strArguments = string.Format("import \"{0}\" \"{1}\" -m \"{2}\"", this.DirectorySolution, this.Repository, strMessage);
|
|
Svn svn = new Svn();
|
|
if (!svn.Execute(strArguments, false, true))
|
|
return;
|
|
try
|
|
{
|
|
Directory.Move(this.DirectorySolution, this.DirectorySolution + ".bak");
|
|
svn.Execute("checkout \"" + this.Repository + "\" \"" + this.DirectorySolution + "\"", false, true);
|
|
}
|
|
catch // (Exception exception)
|
|
{
|
|
MessageBox.Show("Can't rename Directory", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SvnUpdate()
|
|
{
|
|
Svn svn = new Svn();
|
|
svn.Execute("update \"" + this.DirectorySolution + "\"",true, true);
|
|
}
|
|
|
|
private void SvnCommit()
|
|
{
|
|
SvnAguments svnArguments = new SvnAguments();
|
|
svnArguments.Text = "SVN Commit";
|
|
svnArguments.ReadOnly = true;
|
|
svnArguments.Repository = this.Repository;
|
|
svnArguments.Comment = "";
|
|
if (svnArguments.ShowDialog(this) == DialogResult.OK)
|
|
{
|
|
Svn svn = new Svn();
|
|
svn.Execute("commit \"" + this.DirectorySolution + "\" -m \"" + svnArguments.Comment+ "\"", true, true);
|
|
}
|
|
}
|
|
|
|
private void cms_MouseClick(object sender, MouseEventArgs e)
|
|
{
|
|
ContextMenuStrip cms = sender as ContextMenuStrip;
|
|
TreeNode tn = cms.Tag as TreeNode;
|
|
ToolStripMenuItem tsi = cms.GetItemAt(e.X, e.Y) as ToolStripMenuItem;
|
|
|
|
if (tsi == null)
|
|
return; // TODO, why is this??
|
|
|
|
if (tsi.DropDownItems.Count == 0)
|
|
cms.Visible = false;
|
|
this.treeView1.Invalidate(tn.Bounds);
|
|
|
|
switch (tsi.Name)
|
|
{
|
|
case "SvnImport":
|
|
SvnImport();
|
|
break;
|
|
case "SvnUpdate":
|
|
SvnUpdate();
|
|
break;
|
|
case "SvnCommit":
|
|
SvnCommit();
|
|
break;
|
|
case "CloseSolution":
|
|
CloseSolution();
|
|
break;
|
|
case "AddExistingFile":
|
|
AddExistingFile(tn);
|
|
break;
|
|
case "AddExistingProject":
|
|
AddExistingProject();
|
|
break;
|
|
case "AddNewProject":
|
|
AddNewProjectAction();
|
|
break;
|
|
case "AddNewObject":
|
|
AddNewContainer(tn, TypeSL.Object, GetNewDirectoryName(tn, "Object{0}"), Guid.NewGuid());
|
|
break;
|
|
case "AddNewFolder":
|
|
AddNewContainer(tn, TypeSL.Folder, GetNewDirectoryName(tn, "Folder{0}"), Guid.NewGuid());
|
|
break;
|
|
case "AddInventory":
|
|
EmptyInventory(tn);
|
|
break;
|
|
case "SetAsActiveProject":
|
|
SetAsActiveProject(tn);
|
|
break;
|
|
case "SetAsActiveBox":
|
|
SetAsActiveBox(tn);
|
|
break;
|
|
case "Cut":
|
|
CutAction(tn);
|
|
break;
|
|
case "Copy":
|
|
CopyAction(tn);
|
|
break;
|
|
case "Delete":
|
|
DeleteAction(tn);
|
|
break;
|
|
case "Paste":
|
|
PasteAction(tn);
|
|
break;
|
|
case "Remove":
|
|
RemoveAction(tn);
|
|
break;
|
|
case "Rename":
|
|
RenameAction(tn);
|
|
break;
|
|
case "Add":
|
|
// via dropdownitems
|
|
return;
|
|
case "ChangeFileType":
|
|
// via dropdownitems
|
|
return;
|
|
case "Properties":
|
|
PropertiesActions(tn);
|
|
break;
|
|
case "DebugStart":
|
|
DebugStart();
|
|
break;
|
|
case "AddExistingObject":
|
|
AddExistingObject(tn);
|
|
break;
|
|
default:
|
|
MessageBox.Show("cms_MouseClick: " + tsi.Text, "TODO!!");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
public class NodeSorter : System.Collections.IComparer
|
|
{
|
|
public int Compare(object x, object y)
|
|
{
|
|
TreeNode tx = x as TreeNode;
|
|
TreeNode ty = y as TreeNode;
|
|
return string.Compare(tx.Text, ty.Text);
|
|
}
|
|
}
|
|
|
|
|
|
}
|