private void Timer1_Tick(object obj, System.EventArgs eventArgs)
{
if (this.Blq)
{
tabControl.Visible = true;
treeView3dModel.Select();
treeView3dModel.Focus();
tabControl.Select();
treeViewObjects.Select();
treeViewObjects.Focus();
}
if (objectTreeModified)
{
UpdateTreeViewObjects();
objectTreeModified = false;
}
if (meshTreeModified)
{
UpdateTreeView3dModel();
meshTreeModified = false;
}
bool flag = TreeViewUtil.IsVScrollVisible(this.treeViewObjects);
if (this.Blq)
{
this.BlR = flag;
}
if (flag != this.BlR)
{
this.BlR = flag;
this.treeViewObjects.Invalidate(true);
}
this.Blq = false;
}
private void LoadEntities()
{
List <Entity> entities = new List <Entity>();
if (Map.Instance == null)
{
return;
}
entities.AddRange(Map.Instance.Children);
while (entities.Count > 0)
{
Entity entity = entities[0];
entities.RemoveAt(0);
Map.EditorLayer editorLayer = null;
if (entity is MapObject)
{
MapObject mapObject = entity as MapObject;
editorLayer = mapObject.EditorLayer;
}
TreeNode layerNode = TreeViewUtil.FindNodeByTag(rootLayerNode, editorLayer);
layerNode = layerNode ?? rootNode;
CreateEntityNode(entity, layerNode, false);
}
}
// ????????
void ModiRights(List <ObjectInfo> aName,
QuickRights quickrights)
{
List <TreeNode> nodes = new List <TreeNode>();
for (int i = 0; i < aName.Count; i++)
{
ObjectInfo objectinfo = aName[i];
string strName = objectinfo.Path;
// 将名字转换为节点对象指针
TreeNode node = null;
if (objectinfo.ImageIndex == ResTree.RESTYPE_SERVER)
{
node = this.treeView_resRightTree.Nodes[0];
}
else
{
node = TreeViewUtil.GetTreeNode(this.treeView_resRightTree.Nodes[0], strName);
}
if (node == null)
{
MessageBox.Show(this, "节点路径 '" + strName + "' 没有找到对应的对象...");
continue;
}
nodes.Add(node);
}
ModiRights(nodes, quickrights);
}
private void enumerateTreeNodes_objects()
{
EnumerateNodesDelegate enumerateAllNodesDelegate =
new EnumerateNodesDelegate(enumerateAllNodes);;
while (!TreeViewUtil.EnumerateNodes(treeViewObjects, enumerateAllNodesDelegate))
{
;
}
}
private void UpdateTagTreeView(bool init)
{
var cond = _tagTextBox.Text;
var oldChecked = GetCheckedTags().ToArray();
Predicate <MemoTag> pred = null;
if (!StringUtil.IsNullOrWhitespace(cond))
{
var names = cond.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
pred = tag => {
//if (names.Any(name => !StringUtil.IsNullOrWhitespace(name) && tag.FullName.IndexOf(name.Trim(), StringComparison.OrdinalIgnoreCase) > -1)) {
if (
names.Where(
name => !StringUtil.IsNullOrWhitespace(name)
).All(
name => tag.FullName.IndexOf(name.Trim(), StringComparison.OrdinalIgnoreCase) > -1
)
)
{
return(true);
}
if (init)
{
return(_targetMemo != null && tag.Memos.Contains(_targetMemo));
}
else
{
return(oldChecked.Contains(tag));
}
};
}
_tagTreeView.BeginUpdate();
TreeViewUtil.UpdateTagTreeView(_tagTreeView, _facade.Workspace, pred);
_tagTreeView.Sort();
_tagTreeView.ExpandAll();
_tagTreeView.EndUpdate();
if (_tagTreeView.Nodes.Count > 0)
{
_tagTreeView.SelectedNode = _tagTreeView.Nodes[0];
}
if (_targetMemo != null)
{
if (!init)
{
UpdateTagTreeViewChecked(oldChecked);
}
}
}
private void tsmiDeleteLayer_Click(object sender, EventArgs e)
{
TreeNode node = CurrentLayerNode;
if (node == null)
{
tsmiDeleteLayer.Enabled = false;
return;
}
List <TreeNode> valueNodes = new List <TreeNode>();
TreeViewUtil.EnumerateNodes(node, (_node) => {
if (_node.Tag is Entity)
{
valueNodes.Add(_node);
}
return(true);
});
if (valueNodes.Count > 0)
{
string infoMessage = string.Format("该Layer下有{0}个节点, 删除该Layer会将这些节点放在根节点下。是否继续？", valueNodes.Count);
if (MessageBox.Show(infoMessage, "询问", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.No)
{
return;
}
}
Map.EditorLayer layer = node.Tag as Map.EditorLayer;
if (Map.Instance != null && layer == Map.Instance.RootEditorLayer)
{
tsmiDeleteLayer.Enabled = false;
return;
}
if (layer.Remove())
{
node.Tag = null;
if (node.Parent != null)
{
treeViewEntities.SelectedNode = node.Parent;
}
node.Remove();
UpdateData();
MapWorld.Instance.Modified = true;
}
}
private void GetProjectNameDlg_Load(object sender, System.EventArgs e)
{
treeView1.ImageList = imageList_projectNodeType;
treeView1.PathSeparator = "/";
this.AcceptButton = this.button_OK;
if (scriptManager != null)
{
try
{
scriptManager.FillTree(this.treeView1);
}
catch (System.IO.FileNotFoundException ex)
{
/*
* MessageBox.Show("装载" + scriptManager.CfgFilePath + "文件失败，原因:"
+ ex.Message);
*/
MessageBox.Show(ex.Message);
return;
}
catch (System.Xml.XmlException ex)
{
MessageBox.Show("装载 " + scriptManager.CfgFilePath + " 文件失败，原因:"
+ ex.Message);
return;
}
}
if (textBox_projectName.Text != "")
{
Debug.Assert(treeView1.PathSeparator == "/", "");
TreeViewUtil.SelectTreeNode(treeView1,
textBox_projectName.Text,
'/');
}
checkBox_noneProject_CheckedChanged(null, null);
// 2009/2/8
if (this.DisableNoneProject == true)
{
this.checkBox_noneProject.Enabled = false;
}
}
private void resTree_AfterCheck(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
if (resTree.CheckBoxes != true)
{
return;
}
TreeNode[] nodes = TreeViewUtil.GetCheckedNodes(this.resTree);
if (nodes.Length == 0)
{
textBox_resPath.Text = "";
return;
}
textBox_resPath.Text = "";
for (int i = 0; i < nodes.Length; i++)
{
if (EnabledIndices != null &&
StringUtil.IsInList(nodes[i].ImageIndex, EnabledIndices) == false)
{
continue;
}
/*
* if (nodes[i].ImageIndex != ResTree.RESTYPE_DB)
* continue;
*/
if (textBox_resPath.Text != "")
{
textBox_resPath.Text += ";";
}
ResPath respath = new ResPath(nodes[i]);
textBox_resPath.Text += respath.FullPath;
}
}
// ========================================
// method
// ========================================
// ------------------------------
// public
// ------------------------------
public void UpdateTags()
{
var selectedNode = SelectedNode;
var selectedObj = selectedNode == null? null: selectedNode.Tag;
BeginUpdate();
Nodes.Clear();
if (_isAllTagsEnabled)
{
_allTagsNode = Nodes.Add(AllTagsText);
_allTagsNode.Tag = AllTags;
_allTagsNode.ImageIndex = 1;
_allTagsNode.SelectedImageIndex = 1;
}
if (_isUntaggedEnabled)
{
_untaggedNode = Nodes.Add(UntaggedText);
_untaggedNode.Tag = Untagged;
_untaggedNode.ImageIndex = 2;
_untaggedNode.SelectedImageIndex = 2;
}
_tagRootNode = Nodes.Add(TagRootText);
_tagRootNode.Tag = TagRoot;
_tagRootNode.ImageIndex = 1;
_tagRootNode.SelectedImageIndex = 1;
TreeViewUtil.UpdateTagTreeView(_tagRootNode, _facade.Workspace);
_tagRootNode.Expand();
Sort();
EndUpdate();
SelectNode(selectedObj);
OnUpdated();
}
public void ClearSelection()
{
if (this.treeViewObjects.SelectedNode != null && this.treeViewObjects.SelectedNode.Tag != null)
{
this.treeViewObjects.BeginUpdate();
if (this.treeViewObjects.SelectedNode.Parent != null)
{
this.treeViewObjects.SelectedNode = this.treeViewObjects.SelectedNode.Parent;
}
else if (this.currentObjectsNode != null)
{
this.treeViewObjects.SelectedNode = this.currentObjectsNode;
}
else
{
this.treeViewObjects.SelectedNode = TreeViewUtil.FindNodeByTag(this.treeViewObjects, null);
}
this.treeViewObjects.EndUpdate();
}
if (this.treeView3dModel.SelectedNode != null && this.treeView3dModel.SelectedNode.Tag != null)
{
this.treeView3dModel.BeginUpdate();
if (this.treeView3dModel.SelectedNode.Parent != null)
{
this.treeView3dModel.SelectedNode = this.treeView3dModel.SelectedNode.Parent;
}
else if (this.current3dModelNode != null)
{
this.treeView3dModel.SelectedNode = this.current3dModelNode;
}
else
{
this.treeView3dModel.SelectedNode = TreeViewUtil.FindNodeByTag(this.treeView3dModel, null);
}
this.treeView3dModel.EndUpdate();
}
OnSelectedItemChange();
}
public void UpdateMapObjectLayer(MapObject target)
{
if (target == null)
{
return;
}
TreeNode objectNode = TreeViewUtil.FindNodeByTag(rootNode, target);
if (objectNode == null)
{
return;
}
TreeNode layerNode = target.EditorLayer == null? rootNode : TreeViewUtil.FindNodeByTag(rootNode, target.EditorLayer);
if (layerNode != null)
{
objectNode.Remove();
layerNode.Nodes.Add(objectNode);
TreeViewUtil.ExpandTo(objectNode);
}
}
private void UpdateTreeViewObjects()
{
Blr.Clear();
treeViewObjects.BeginUpdate();
TreeNode selected = treeViewObjects.SelectedNode;
string selectPath = null;
if (selected != null)
{
selectPath = selected.FullPath;
}
treeViewObjects.Nodes.Clear();
foreach (EntityType current in EntityTypes.Instance.Types)
{
if (current.CreatableInMapEditor /*&& !(current is DecorativeObjectType)*/ &&
(string.IsNullOrEmpty(current.FilePath) || VirtualFile.Exists(current.FilePath)))
{
InsertEntityType(current);
}
}
enumerateTreeNodes_objects();
currentObjectsNode = null;
/*
* if (TreeViewUtil.FindNodeByTag(treeViewObjects, null) == null)
* {
* currentObjectsNode = new TreeNode(ToolsLocalization.Translate("Various", "(no selection)"), 3, 3);
* treeViewObjects.Nodes.Add(currentObjectsNode);
* treeViewObjects.SelectedNode = currentObjectsNode;
* }
* //*/
treeViewObjects.TreeViewNodeSorter = new TreeNodeComparer(currentObjectsNode);
treeViewObjects.Sort();
treeViewObjects.EndUpdate();
if (selectPath != null)
{
TreeNode treeNode = TreeViewUtil.FindNodeByText(treeViewObjects, selectPath);
if (treeNode != null)
{
List <TreeNode> nodes = new List <TreeNode>();
TreeNode node = treeNode;
while (node.Parent != null)
{
nodes.Add(node);
node = node.Parent;
}
for (int i = nodes.Count - 1; i >= 0; i--)
{
nodes[i].Expand();
}
treeViewObjects.SelectedNode = treeNode;
}
}
if (treeViewObjects.Nodes.Count > 0)
{
TreeNode objectNode = treeViewObjects.Nodes[0];
objectNode.EnsureVisible();
objectNode.Expand();
treeViewObjects.TopNode = objectNode;
}
}
// ========================================
// method
// ========================================
public void RebuildTree()
{
_root.Nodes.Clear();
_root.Nodes.Add(_untaggedNode);
TreeViewUtil.BuildTagTree(_root, _facade.Workspace, _tagImageIndex);
}
private void UpdateData(string currentPath)
{
this.treeView.BeginUpdate();
this.treeView.Nodes.Clear();
while (this.imageListTreeView.Images.Count > 2)
{
this.imageListTreeView.Images.RemoveAt(2);
}
foreach (ResourceType current in ResourceTypeManager.Instance.Types)
{
Image icon = current.Icon;
if (icon != null)
{
int count = this.imageListTreeView.Images.Count;
this.imageListTreeView.Images.Add(icon);
icon.Tag = count;
}
}
this.rootNode = new TreeNode("Data", 0, 0);
this.treeView.Nodes.Add(rootNode);
this.UpdateDataDirectory("", rootNode);
this.treeView.TreeViewNodeSorter = new NodeComparer();
this.treeView.Sort();
this.rootNode.Expand();
if (this.rootNode.Nodes.Count == 1)
{
this.rootNode.Nodes[0].Expand();
}
bool flag = false;
if (!string.IsNullOrEmpty(currentPath))
{
TreeNode nodeByPath = this.GetNodeByPath(currentPath);
if (nodeByPath != null)
{
TreeViewUtil.ExpandTo(nodeByPath);
this.treeView.SelectedNode = nodeByPath;
flag = true;
}
}
if (!flag && string.IsNullOrEmpty(currentPath) && !string.IsNullOrEmpty(currentHelperDirectoryName))
{
TreeNode nodeByPath2 = GetNodeByPath(currentHelperDirectoryName);
if (nodeByPath2 != null)
{
TreeViewUtil.ExpandTo(nodeByPath2);
treeView.SelectedNode = nodeByPath2;
flag = true;
}
}
if (this.allowChooseNull)
{
this.nullValueNode = new TreeNode(ToolsLocalization.Translate("ChooseResourceForm", "(Null)"), 1, 1);
this.nullValueNode.Name = nullValueNode.Text;
this.treeView.Nodes.Add(nullValueNode);
if (string.IsNullOrEmpty(currentPath) && !flag)
{
this.treeView.SelectedNode = nullValueNode;
flag = true;
}
}
if (!flag && treeView.Nodes.Count != 0)
{
this.treeView.SelectedNode = treeView.Nodes[0];
}
this.treeView.EndUpdate();
}
