/// <summary>
/// Shows the open file dialog box and opens a document.
/// </summary>
private void OpenDocument()
{
string fileName = SelectOpenFileName();
if (fileName == null)
{
return;
}
// This operation can take some time so we set the Cursor to WaitCursor.
Application.DoEvents();
Cursor cursor = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
// Load document is put in a try-catch block to handle situations when it fails for some reason.
try
{
// Loads the document into Aspose.Words object model.
mDocument = new Document(fileName);
Tree.BeginUpdate();
// Clears the tree from the previously loaded documents.
Tree.Nodes.Clear();
// Creates instance of an Item class which will control the GUI representation of the document root node.
Tree.Nodes.Add(Item.CreateItem(mDocument).TreeNode);
// Shows the immediate children of the document node.
Tree.Nodes[0].Expand();
// Selects root node of the tree.
Tree.SelectedNode = Tree.Nodes[0];
Tree.EndUpdate();
Text = "Document Explorer - " + fileName;
menuSaveAs.Enabled = true;
toolBar1.Buttons[1].Enabled = true;
menuRender.Enabled = true;
toolBar1.Buttons[3].Enabled = true;
menuPreview.Enabled = true;
toolBar1.Buttons[4].Enabled = true;
menuExpandAll.Enabled = true;
toolBar1.Buttons[6].Enabled = true;
menuCollapseAll.Enabled = true;
toolBar1.Buttons[7].Enabled = true;
}
catch (Exception ex)
{
new ExceptionDialog(ex).ShowDialog();
}
// Restore cursor.
Cursor.Current = cursor;
}
public void Populate(ArrayList designs)
{
Hashtable categories = new Hashtable(0, new CaseInsensitiveHashCodeProvider(), new CaseInsensitiveComparer());
treeView1.BeginUpdate();
// clear nodes
treeView1.Nodes.Clear();
for (int i = 0; i < designs.Count; ++i)
{
DesignData design = (DesignData)designs[i];
CategoryNode category = null;
if (categories.ContainsKey(design.Category))
{
category = (CategoryNode)categories[design.Category];
}
else
{
category = new CategoryNode(design.Category);
categories.Add(category.Text, category);
treeView1.Nodes.Add(category);
}
category.AddDesign(design);
}
treeView1.EndUpdate();
categories.Clear();
}
/// <summary>
/// Purpose: Initializes the tree and fill the root node with the initial nodes.
/// </summary>
private void InitTreeAndFillRoot()
{
// Add all devices in this machine. Get them from WMI. See for
// detailed WMI information the WMI Platform SDK Documentation.
SelectQuery sqLogicalDrives = new SelectQuery("SELECT * FROM Win32_LogicalDisk");
ManagementObjectSearcher mosSearcher = new ManagementObjectSearcher(sqLogicalDrives);
ManagementObjectCollection mocLogicalDrives = mosSearcher.Get();
tvMain.BeginUpdate();
foreach (ManagementObject moDrive in mocLogicalDrives)
{
// add a node. Select an image for the drive type.
TreeNode tnNode = tvMain.Nodes.Add(moDrive.Properties["DeviceID"].Value.ToString());
int iDriveType = int.Parse(moDrive.Properties["DriveType"].Value.ToString());
if (iDriveType < 2 || iDriveType > 5)
{
tnNode.ImageIndex = 0;
tnNode.SelectedImageIndex = 0;
}
else
{
tnNode.ImageIndex = iDriveType;
tnNode.SelectedImageIndex = iDriveType;
}
// add dummy node so the user can browse fast through the directories.
// add an empty string, a directory can't be an empty string.
TreeNode tnDummy = tnNode.Nodes.Add("");
}
tvMain.EndUpdate();
}
public void InitializeVirtual(string platform)
{
if (!mInitialized)
{
GameDataTreeView.BeginUpdate();
GameDataTreeView.Nodes.Clear();
mVirtual = true;
// Populate our project tree
ArrayList virtualDirectories = MOG_DBAssetAPI.GetAllProjectSyncTargetFilesForPlatform(platform);
ArrayList fixedUpVirtualDirectories = new ArrayList();
foreach (string file in virtualDirectories)
{
// Only add files that have '\\' in front of them. These are files. Those
// without '\\' are packages and the files that go into them
if (file.StartsWith("\\"))
{
fixedUpVirtualDirectories.Add(file.TrimStart("\\".ToCharArray()));
}
else
{
// File did not have a starting '\', so just add it :)
fixedUpVirtualDirectories.Add(file);
}
}
mSyncTargetFiles = new DirectorySet(fixedUpVirtualDirectories);
if (MOG_ControllerProject.GetCurrentSyncDataController() != null)
{
mRoot = new TreeNode(MOG_ControllerProject.GetCurrentSyncDataController().GetSyncDirectory());
mRoot.Tag = new guiAssetTreeTag(MOG_ControllerProject.GetCurrentSyncDataController().GetSyncDirectory(), mRoot, MOG_ControllerProject.GetCurrentSyncDataController(), false);
VirtualExpand(mRoot, "", MOG_ControllerProject.GetCurrentSyncDataController());
FillDirectory(mRoot, MOG_ControllerProject.GetCurrentSyncDataController().GetSyncDirectory(), SystemColors.InactiveCaptionText);
GameDataTreeView.Nodes.Add(mRoot);
mRoot.Expand();
}
mInitialized = true;
// If we have nothing for this tree, we should disable it...
if (GameDataTreeView.Nodes.Count < 1)
{
GameDataTreeView.Visible = false;
NoLocalDataLabel.Visible = true;
}
else
{
GameDataTreeView.Visible = true;
NoLocalDataLabel.Visible = false;
}
GameDataTreeView.EndUpdate();
}
}
private void tvRegistry_BeforeExpand(object sender, System.Windows.Forms.TreeViewCancelEventArgs e)
{
tvRegistry.BeginUpdate();
foreach (TreeNode tn in e.Node.Nodes)
{
AddBranch(tn);
}
tvRegistry.EndUpdate();
}
private void CloseCurrentFile()
{
_treeView_Elements.BeginUpdate();
_treeView_Elements.Nodes.Clear();
_treeView_Elements.EndUpdate();
_dsImage.Reset();
FreeImage();
}
private void OpenDatabase(string fName)
{
if (database != null)
{
CloseDatabase();
}
if (fName.Length > 0)
{
database = new SqliteDb();
int err = database.Open(fName);
if (err != 0)
{
database = null;
}
}
if (database != null)
{
databaseName = fName;
treeView1.BeginUpdate();
// Clear the TreeView each time the method is called.
treeView1.Nodes.Clear();
TreeNode databaseNode = new TreeNode(fName);
SqliteVm vm = new SqliteVm(database, true);
string tableList = "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;";
int fini = vm.Execute(tableList);
while (fini == Sqlite.Row)
{
string tableName = vm.GetString("name");
databaseNode.Nodes.Add(tableName);
fini = vm.NextRow();
}
vm.SqlFinalize();
vm = null;
treeView1.Nodes.Add(databaseNode);
treeView1.EndUpdate();
//Enable menu items
this.menuItem3.Enabled = true;
this.menuAddTest.Enabled = true;
this.saveAsMenuItem.Enabled = true;
this.saveDbMenuItem.Enabled = true;
}
}
/// <summary>
/// Clears all the tree nodes and reloads the scripts from Pandora
/// </summary>
private void RefreshTrees()
{
tCat.BeginUpdate();
tItems.BeginUpdate();
tCat.Nodes.Clear();
tItems.Nodes.Clear();
tCat.Nodes.AddRange(Pandora.Items.GetNodes());
tCat.EndUpdate();
tItems.EndUpdate();
}
/// <summary>
/// Initialize the Explorer treeView
/// </summary>
public void Initialize()
{
GameDataTreeView.BeginUpdate();
GameDataTreeView.Nodes.Clear();
// Create MOG projects root
PopulateMogProjects();
// Get all local drives available on this computer
PopulateLocalDrives(DRIVE_TYPE_HD);
GameDataTreeView.EndUpdate();
}
/// <summary>
/// Refresh both treenodes
/// </summary>
private void RefreshTrees()
{
tClasses.BeginUpdate();
tProps.BeginUpdate();
tClasses.Nodes.Clear();
tProps.Nodes.Clear();
tClasses.Nodes.AddRange(PropsData.Props.TreeNodes);
tClasses.EndUpdate();
tProps.EndUpdate();
}
/// <summary>
/// Refreshes the trees
/// </summary>
private void RefreshTrees()
{
tCat.BeginUpdate();
tDeco.BeginUpdate();
tCat.Nodes.Clear();
tDeco.Nodes.Clear();
tCat.Nodes.AddRange(Decorator.TreeNodes);
tCat.EndUpdate();
tDeco.EndUpdate();
}
private void fillTreeTeachers()
{
_treeView1.BeginUpdate();
foreach (Teacher teacher in AppForm.CURR_OCTT_DOC.TeachersRootNode.Nodes)
{
TreeNode tn = new TreeNode(teacher.getTreeText());
tn.Tag = teacher;
_treeView1.Nodes.Add(tn);
}
_treeView1.ExpandAll();
_treeView1.EndUpdate();
this.Refresh();
}
/// <summary>
/// Gets or sets a value indicating whether the New Folder item appears in the menu.
/// </summary>
//public bool ShowNewFolderButton
//{
// get
// {
// return mnuNew.Enabled;
// }
// set
// {
// mnuNew.Enabled = value;
// }
//}
#endregion
#region Helper Functions
/// <summary>
/// Adds the root node for the device to the TreeView
/// </summary>
private void AddRoot()
{
//stop updates during filling
tvFolders.BeginUpdate();
//add an empty node (use device image)
TreeNode root = tvFolders.Nodes.Add("");
root.ImageIndex = 0; // ehemals 1
root.SelectedImageIndex = 0; // ehemals 1
tvFolders.EndUpdate();
}
private void miNew_Click(object sender, System.EventArgs e)
{
CheckModified();
tCat.BeginUpdate();
tCat.Nodes.Clear();
tCat.EndUpdate();
tLoc.BeginUpdate();
tLoc.Nodes.Clear();
tLoc.EndUpdate();
m_Changed = false;
}
/// <summary>
/// Reloads the trees
/// </summary>
private void RefreshTrees()
{
tCat.BeginUpdate();
tImg.BeginUpdate();
tCat.Nodes.Clear();
tImg.Nodes.Clear();
tCat.Nodes.Add(GetDirectoryNode(Pandora.Profile.Screenshots.BaseFolder));
tCat.Nodes[0].Expand();
tCat.EndUpdate();
tImg.EndUpdate();
}
DBObjects(AcDb.ObjectIdCollection objIds, TransactionHelper tr)
{
m_trans = tr;
// Required for Windows Form Designer support
InitializeComponent();
m_tvObjs.BeginUpdate();
AddObjectIdCollectionToTree(objIds);
m_tvObjs.ExpandAll();
m_tvObjs.EndUpdate();
}
LoadTree()
{
m_tvDom.BeginUpdate(); // suppress redraw events
m_tvDom.Nodes.Clear();
MakeTree(m_xmlDoc, null);
m_tvDom.ExpandAll();
if (m_tvDom.Nodes.Count > 0)
{
m_tvDom.SelectedNode = m_tvDom.Nodes[0]; // make first one selected
}
m_tvDom.EndUpdate(); // flushes redraw events
}
/// <summary>
/// 传入ID信息查找模板的值
/// </summary>
/// <param name="strReportID"></param>
/// <param name="strFormID"></param>
/// <param name="strControlID"></param>
private void m_mthFindAllTemplateUsedInCtl(string strFormID, string strControlID)
{
if (strFormID == null || strControlID == null || strFormID.Length <= 0 || strControlID.Length <= 0)
{
return;
}
m_objTextTemplate.m_strDoctor_ID = MDIParent.strOperatorID.Trim();
m_objTextTemplate.m_strFORM_ID = strFormID;
m_objTextTemplate.m_strCONTROL_ID = strControlID;
clsTemplateInfo[] objTemplateInfo;
// clsTextTemplate objTextTemplate;
CustomFromService.clsMinElementColServ m_objServ =
(CustomFromService.clsMinElementColServ)com.digitalwave.iCare.common.clsObjectGenerator.objCreatorObjectByType(typeof(CustomFromService.clsMinElementColServ));
long lngRes = m_objServ.m_lngGetTemplates(strFormID, strControlID, out objTemplateInfo);
if (lngRes > 0 && objTemplateInfo != null)
{
treeView1.BeginUpdate();
for (int i = 0; i < objTemplateInfo.Length; i++)
{
TreeNode node = new TreeNode(objTemplateInfo[i].m_strTEMPLATE_NAME);
node.Tag = objTemplateInfo[i];
node.ImageIndex = 2;
node.SelectedImageIndex = 1;
if (objTemplateInfo[i].m_strDoctor_ID.Trim() == MDIParent.strOperatorID.Trim())
{
node.ForeColor = Color.Green;
}
// else
// node.ForeColor = Color.Yellow;
treeView1.Nodes[0].Nodes.Add(node);
}
treeView1.ExpandAll();
treeView1.EndUpdate();
m_pnlControl.Tag = "";
// m_objTextTemplate.m_strGUI_ID=objTextTemplate.m_strGUI_ID;
// this.m_pnlControl.Tag=objTTVO.m_strGUI_ID;
// if(objTIVO!=null)
// {
// m_mthLoadControl(objTIVO.m_strTEMPLATE_XML);
// this.m_cmdChange.Tag=objTIVO;
// }
// if(objTTVO.m_objTmpCtlValueArr!=null)
// {
// m_mthLoadControlValue(objTTVO.m_objTmpCtlValueArr);
// }
}
}
protected void FilterItems(string filter)
{
elementList.BeginUpdate();
elementList.Nodes.Clear();
ICollection col = showValid.Checked ? validItems : allItems;
if (col == null)
{
elementList.EndUpdate();
return;
}
foreach (ElementListItem s in col)
{
if (filter.Length == 0 || IsMatch(s.Name.QualifiedName, filter))
{
string title = s.Name.QualifiedName;
TreeNode n = new TreeNode(title);
n.Tag = s.Name;
if (s.IsRequired)
{
if (s.IsChoice)
{
n.ImageIndex = 1;
n.SelectedImageIndex = 1;
}
else
{
n.ImageIndex = 2;
n.SelectedImageIndex = 2;
}
}
else
{
n.NodeFont = new Font(elementList.Font, FontStyle.Regular);
}
elementList.Nodes.Add(n);
}
}
if (elementList.Nodes.Count > 0)
{
elementList.SelectedNode = elementList.Nodes[0];
}
elementList.EndUpdate();
}
public void DrawTree(TreeView treeView)
{
treeView.BeginUpdate();
treeView.Nodes["All"].Nodes.Clear();
foreach (Site site in SiteCollection)
{
TreeNode siteNode = new TreeNode(site.Dto.DescriptionName);
siteNode.Tag = site;
treeView.Nodes["All"].Nodes.Add(siteNode);
foreach (Team team in site.TeamColl)
{
TreeNode teamNode = new TreeNode(team.Dto.Description);
teamNode.Tag = team;
siteNode.Nodes.Add(teamNode);
foreach (Agent agent in team.AgentColl)
{
TreeNode agentNode = new TreeNode(agent.Dto.Name);
agentNode.Tag = agent;
teamNode.Nodes.Add(agentNode);
}
}
}
treeView.EndUpdate();
}
public void initialTree(System.Windows.Forms.TreeView tv, System.Data.DataSet ds)
{
tv.BeginUpdate();
tv.Nodes.Clear();
System.Windows.Forms.TreeNode tn = null;
if (tv.Nodes.Count == 0)
{
tn = new System.Windows.Forms.TreeNode("SNOMED", 4, 4);
tv.Nodes.Add(tn);
}
else
{
tn = tv.Nodes[0];
}
//添加子节点
foreach (DataRow dr in ds.Tables["cnp_com_snopmed"].Rows)
{
TreeNode treeModual = null;
if (string.Compare(dr["PARENTCODE"].ToString(), "root") == 0)
{
foreach (TreeNode treeNode in tn.Nodes) //父亲结点
{
break;
}
if (treeModual == null)
{
treeModual = new TreeNode(dr["ID"].ToString(), 0, 1);
treeModual.Tag = dr["ID"].ToString();
tn.Nodes.Add(treeModual);
//添加孙子节点
foreach (DataRow dt in ds.Tables["cnp_com_snopmed"].Rows)
{
TreeNode treeType = null;
if (string.Compare(dt["PARENTCODE"].ToString(), treeModual.Text) == 0)
{
foreach (TreeNode treeNodeType in treeModual.Nodes)
{
if (treeNodeType.Text == dr["ID"].ToString())
{
treeType = treeNodeType;
break;
}
}
if (treeType == null)
{
treeType = new TreeNode(dr["ID"].ToString(), 0, 1);
treeType.Tag = dt["ID"].ToString();
treeType.Text = dt["NAME"].ToString();
treeModual.Nodes.Add(treeType);
}
}
}
treeModual.Text = dr["NAME"].ToString();
}
}
}
tv.EndUpdate();
}
private void btLoad_Click(object sender, System.EventArgs e)
{
OE.OEFolder folder;
OE.OEProject project;
int i, p = 0;
int cnt = OE.FoldersCount;
TreeNode root;
TreeNode node;
Tree.BeginUpdate();
Tree.Nodes.Clear();
for (i = 0; i < cnt; i++)
{
folder = OE.GetFolder(i);
root = new TreeNode(folder.Caption);
root.Tag = folder;
Tree.Nodes.Add(root);
for (p = 0; p < folder.ItemsCount; p++)
{
project = (OE.OEProject)folder.GetItem(p);
node = new TreeNode(project.Caption);
root.Nodes.Add(node);
node.Tag = project;
// node = Tree.Nodes.Add( root );
// node.Text = project.Caption;
}
}
Tree.EndUpdate();
}
public static void LoadCategoriesView(TreeView target, PosData.CategoriesDataTable source)
{
var roots = from p in source
select p;
target.BeginUpdate();
TreeNode currentNode = null;
foreach (PosData.CategoriesRow row in roots)
{
if (row.ParentId == 0)//root nodes only
{
currentNode = new TreeNode(row.CategoryName, 0, 0);
currentNode.Tag = row.CategoryId;
target.Nodes.Add(currentNode);
}
var current = from c in source
where c.ParentId == row.CategoryId && c.ParentId != 0L
select c;
if (current != null && current.Count<PosData.CategoriesRow>() > 0)
{
_LoadCategoriesView(currentNode, current, source);
}
}
target.EndUpdate();
}
public static void RefreshTreeView(TreeView treeView)
{
treeView.BeginUpdate();
foreach (NodeBase node in treeView.Nodes)
node.Refresh();
treeView.EndUpdate();
}
protected void CommonInit(IEnumerable <SnoopableObjectWrapper> objs)
{
m_tvObjs.BeginUpdate();
AddObjectsToTree(objs);
// if the tree isn't well populated, expand it and select the first item
// so its not a pain for the user when there is only one relevant item in the tree
if (m_tvObjs.Nodes.Count == 1)
{
m_tvObjs.Nodes[0].Expand();
if (m_tvObjs.Nodes[0].Nodes.Count == 0)
{
m_tvObjs.SelectedNode = m_tvObjs.Nodes[0];
}
else
{
m_tvObjs.SelectedNode = m_tvObjs.Nodes[0].Nodes[0];
}
}
m_tvObjs.EndUpdate();
// Add Load to update ListView Width
Utils.AddOnLoadForm(this);
}
private void SetupTree()
{
TreeNode CourseNode;
TreeNode CardNode;
tvwCourse.Nodes.Clear();
tvwCourse.BeginUpdate();
tvwCourse.ImageList = imgIcons;
tvwCourse.ImageIndex = 0;
tvwCourse.SelectedImageIndex = 0;
foreach (ICourseInfo c in mParent.db.GolfCourses)
{
CourseNode = tvwCourse.Nodes.Add(c.Name);
CourseNode.Tag = c;
foreach (IScoreCardInfo card in c.ScoreCards)
{
CardNode = CourseNode.Nodes.Add(card.PlayDate.ToShortDateString());
CardNode.Tag = card;
}
}
tvwCourse.AfterSelect += new TreeViewEventHandler(CourseStats);
tvwCourse.EndUpdate();
}
private void RefreshTree()
{
tvFormula.BeginUpdate();
try
{
tvFormula.ImageList = ilFormula;
tvFormula.Nodes.Clear();
tvFormula.Nodes.Add("Root");
tvFormula.Nodes[0].Nodes.Add("Basic");
//tvFormula.Nodes[0].Nodes.Add("Test");
FormulaBase[] fbs = FormulaBase.GetAllFormulas();
foreach (FormulaBase fb in fbs)
{
CreateNode(fb);
}
tvFormula.Nodes[0].Expand();
tvFormula.Nodes[0].Nodes[0].Expand();
gbParam.Controls.Clear();
if (tvFormula.Nodes[0].Nodes[0].Nodes.Count > 0)
{
tvFormula.SelectedNode = tvFormula.Nodes[0].Nodes[0].Nodes[0];
}
}
finally
{
tvFormula.EndUpdate();
}
}
/// <summary>
/// Refreshes the tree
/// </summary>
private void DoTree()
{
Tree.BeginUpdate();
Tree.Nodes.Clear();
Tree.Nodes.AddRange(m_Info.GetTreeNodes());
Tree.EndUpdate();
}
// read list of catalogs for the given library (in the tree node)
private void PopulateCatalogs(TreeNode tn)
{
Cursor c = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
tvLibsCats.BeginUpdate();
if (tn != null)
{
SasLibrary l = new SasLibrary(currentServer, tn.Text);
if (l != null)
{
foreach (SasCatalog cat in l.GetSasCatalogMembers())
{
TreeNode catNode = tn.Nodes.Add(cat.Name);
catNode.ImageIndex = (int)CatImages.Catalog;
catNode.SelectedImageIndex = (int)CatImages.Catalog;
catNode.Tag = "CATALOG";
}
}
}
tvLibsCats.EndUpdate();
Cursor.Current = c;
UpdateToolbar();
}
private void m_cndFind_Click(object sender, System.EventArgs e)
{
clsCaseGradeValue[] objGradeValueArr;
if (m_cboDept.SelectedItem == null /*|| m_cboArea.SelectedItem == null*/)
{
clsPublicFunction.ShowInformationMessageBox("请先选择科室！");
return;
}
long lngRes = 0;
if (m_cboArea.Items.Count > 0)
{
if (m_cboArea.SelectedItem == null)
{
clsPublicFunction.ShowInformationMessageBox("请先选择病区！");
return;
}
lngRes = m_objDomain.m_lngGetGradeInfoByArea(((clsInPatientArea)m_cboArea.SelectedItem).m_StrAreaID_CHR, m_dtpSeachDate.Value, m_dtpSeachDate2.Value, out objGradeValueArr);
}
else
{
lngRes = m_objDomain.m_lngGetGradeInfoByDept(((clsDepartment)m_cboDept.SelectedItem).m_StrDeptID, m_dtpSeachDate.Value, m_dtpSeachDate2.Value, out objGradeValueArr);
}
if (lngRes <= 0 || objGradeValueArr == null)
{
return;
}
m_trvPatient.BeginUpdate();
m_trvPatient.Nodes.Clear();
TreeNode node = null;
if (m_cboArea.Items.Count > 0)
{
node = new TreeNode(m_cboArea.SelectedItem.ToString());
node.Tag = (clsInPatientArea)m_cboArea.SelectedItem;
}
else
{
node = new TreeNode(m_cboDept.SelectedItem.ToString());
node.Tag = (clsDepartment)m_cboDept.SelectedItem;
}
node.ImageIndex = 0;
for (int i = 0; i < objGradeValueArr.Length; i++)
{
TreeNode trnChild = new TreeNode(objGradeValueArr[i].m_strInPatientID);
trnChild.Tag = objGradeValueArr[i];
trnChild.ImageIndex = 1;
trnChild.SelectedImageIndex = 1;
node.Nodes.Add(trnChild);
}
m_trvPatient.Nodes.Add(node);
m_trvPatient.SelectedNode = node;
m_trvPatient.ExpandAll();
m_trvPatient.EndUpdate();
}
public void OnSynchronizationClick_All(TextBox tboxPhonePath, TextBox tboxComputerPath,TreeView treeViewPhone, TreeView treeViewComputer)
{
SynchronAll synAll = new SynchronAll();
synAll.Synhronization(tboxPhonePath.Text, tboxComputerPath.Text);
treeViewPhone.EndUpdate();
treeViewComputer.EndUpdate();
}
public void RebuildTree(ObjectManager om)
{
this.om = om;
tvObject.SuspendLayout();
try
{
tvObject.BeginUpdate();
try
{
tvObject.Nodes.Clear();
foreach (BaseObject bo in om.Objects)
{
TreeNode tn = new TreeNode(bo.Name);
tn.Tag = bo;
tvObject.Nodes.Add(tn);
}
}
finally
{
tvObject.EndUpdate();
}
}
finally
{
tvObject.ResumeLayout();
}
}
void LoadData()
{
using (GmConnection conn = App.ConnectionFactory.CreateConnection())
{
GmCommand cmd = conn.CreateCommand("select ProductCode, Name as ProductName, ParentProductCode from Product where DeletedFlag=0 and GroupFlag=1");
using (IDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
Product p = new Product(dr);
htProducts.Add(p.Code, p);
}
}
}
foreach (Product p in htProducts.Values)
{
if (p.ParentCode != null)
{
Product parent = htProducts[p.ParentCode] as Product;
p.SetParent(parent);
}
else
{
rootProducts.Add(p);
}
}
treeView.BeginUpdate();
BuildTree(treeView.Nodes, rootProducts);
treeView.EndUpdate();
UpdateControls();
UpdateStatus();
}
private void FillTreeView(Listings TreeListing)
{
TreeNode nod;
try
{
tvwBusiness.BeginUpdate();
foreach (Listing li in TreeListing.Listing)
{
nod = new TreeNode(li.CompanyName);
nod.Nodes.Add(li.Address);
nod.Nodes.Add(li.Phone);
tvwBusiness.Nodes.Add(nod);
}
tvwBusiness.EndUpdate();
}
catch (Exception ex)
{
MessageBox.Show("Could not parse results (" + ex.Message + ")!");
}
finally
{
tvwBusiness.Nodes.Clear();
}
}
public static void DisplayTo( TreeView tree )
{
tree.BeginUpdate();
tree.Nodes.Clear();
Recurse( tree.Nodes, Config.GetUserDirectory( "Macros" ) );
tree.EndUpdate();
tree.Refresh();
tree.Update();
}
public static void RecordStep(TreeView tree, string step)
{
if (tree.Nodes[0] != null)
{
tree.BeginUpdate();
tree.Nodes[0].Nodes.Insert(tree.Nodes[0].Nodes.Count, step);
tree.EndUpdate();
tree.ExpandAll();
}
}
public void OnSynchronizationClick_CP(TextBox tboxPhonePath, TextBox tboxComputerPath, TreeView treeViewPhone, TreeView treeViewComputer)
{
CheckedNodes check = new CheckedNodes();
FromCompToPhone synComPhon = new FromCompToPhone();
SynchronizationFolder synFolder = new SynchronizationFolder();
synFolder.SynchronFolder(check.CheckedFolder(treeViewComputer.Nodes), tboxPhonePath.Text);
synComPhon.Synchronization(check.CheckedFiles(treeViewComputer.Nodes), tboxPhonePath.Text, tboxComputerPath.Text);
treeViewPhone.EndUpdate();
treeViewComputer.EndUpdate();
}
public static void AddPageTree(TreeView tvPages)
{
var dal = DALFacade.GetPageSchemeDAL();
var schemes = dal.SelectAll();
tvPages.BeginUpdate();
tvPages.Nodes.Clear();
foreach (var scheme in schemes)
{
var node = new TreeNode(scheme.Name);
node.Tag = node;
tvPages.Nodes.Add(node);
}
Cursor.Current = Cursors.Default;
tvPages.EndUpdate();
}
//-----------------------------------------------------------------------------
// Print the value to the treeview
// This will clear out the TreeView and repopulate it with the Value.
//-----------------------------------------------------------------------------
void Print(MDbgValue val, TreeView t)
{
t.BeginUpdate();
t.Nodes.Clear();
if (val == null)
{
t.Nodes.Add("(Error:Expression not valid in this scope)");
}
else
{
PrintInternal(val, t.Nodes, 0);
}
t.EndUpdate();
}
/// <summary>
/// Adds a Computer object to the specified TreeView.
/// </summary>
/// <param name="treeView">TreeView to add Computer to</param>
/// <param name="computer">Computer added as a node to the TreeView</param>
public static void AddComputerToView(TreeView treeView, Computer computer)
{
TreeNode computerNode = new TreeNode(computer.Name);
AddOperatingSystemNode(computerNode, computer.OperatingSystem);
AddPrintersNode(computerNode, computer.Printers);
AddProcessesNode(computerNode, computer.Processes);
AddSharesNode(computerNode, computer.Shares);
AddLogicalDisksNode(computerNode, computer.LogicalDisks);
AddComputerSystemNode(computerNode, computer.System);
AddProcessorsNode(computerNode, computer.Processors);
AddNetworkAdaptersNode(computerNode, computer.NetworkAdapters);
// Add computer node and its related nodes to this tree view control
treeView.BeginUpdate();
treeView.Nodes.Add(computerNode);
treeView.EndUpdate();
}
public static void PopulateTreeView(DatabaseSchema schema, TreeView treeView1)
{
// Suppress repainting the TreeView until all the objects have been created.
treeView1.BeginUpdate();
treeView1.Nodes.Clear(); //clear out anything that exists
treeView1.ShowNodeToolTips = true;
var treeRoot = new TreeNode("Schema");
treeView1.Nodes.Add(treeRoot);
FillTables(treeRoot, schema);
FillViews(treeRoot, schema);
FillSprocs(treeRoot, schema.StoredProcedures);
FillFunctions(treeRoot, schema);
if (schema.Packages.Count > 0) FillPackages(treeRoot, schema);
FillUsers(treeRoot, schema);
treeView1.EndUpdate();
}
public void Build(TreeView tree)
{
tree.BeginUpdate();
tree.Nodes.Clear();
tree.Nodes.Add(ReadHeader(objectFile.Header));
tree.Nodes.Add(ReadReferences(objectFile.References));
tree.Nodes.Add(ReadGlobals(objectFile.Globals));
tree.Nodes.Add(ReadLateBounds(objectFile.LateBounds));
tree.Nodes.Add(ReadLayouts(objectFile.Layouts));
tree.Nodes.Add(ReadStrings(objectFile.Strings));
tree.Nodes.Add(ReadTypes(objectFile.Types));
tree.Nodes.Add(ReadClasses(objectFile.Classes));
tree.Nodes.Add(ReadInstances(objectFile.Instances));
tree.Nodes.Add(ReadConstructors(objectFile.Constructors));
if (config.DisplayFlatOpCodes)
tree.Nodes.Add(ReadCode(objectFile.OpCodes));
tree.EndUpdate();
}
private void BuildTree(String aText, List<String> summary, IFileSystemItem root,
TreeView aView, Boolean insertSubfolders)
{
summary.Add(String.Format("Имя папки: {0}", root.Name));
summary.Add(new String('-', 50));
summary.Add(String.Empty);
aView.BeginUpdate();
try
{
aView.Nodes.Clear();
TreeNode aRoot = InsertFsi(summary, root, insertSubfolders, true);
aRoot.Text = aText;
aView.Nodes.Add(aRoot);
aRoot.Expand();
aView.SelectedNode = aRoot;
}
finally
{
aView.EndUpdate();
}
}
/// <summary>
/// Fills specified tree with dynamically generated samples list.
/// </summary>
/// <param name="tree">Tree control to fill.</param>
private void FillSamplesTree(TreeView tree)
{
// Loads sample XML data
LoadInXMLData(applicationPath);
// Fill samples tree
tree.BeginUpdate();
XmlNode rootNode = samplesContentXMLDoc["SampleContentList"];
FillSampleListIntern(rootNode, tree.Nodes);
tree.EndUpdate();
// Prepare index list
PrepareIndexInfoList();
// Fill index list
this.listBoxIndex.BeginUpdate();
foreach(object obj in this.indexInfoList)
{
this.listBoxIndex.Items.Add(obj);
}
this.listBoxIndex.EndUpdate();
}
private void ReadTreeNode(TreeView xtreeView)
{
xtreeView.BeginUpdate();
xtreeView.Nodes.Clear();
TreeNode tn = new TreeNode();
if (xtreeView.Nodes.Count == 0)
{
tn = new TreeNode("会员类别信息");
tn.Name = Program.RootCode + Program.RootCode;
tn.ImageIndex = 0;
xtreeView.Nodes.Add(tn);
xtreeView.SelectedNode = tn;
}
string sql = "";
sql = "select * from MemberType where Parent_='0000000000'";
DataTable myDataTable1 = Program.SqlDataTable("MemberType", sql);
foreach (DataRow myDataRow in myDataTable1.Rows) //添加一级地址
{
TreeNode tnfirst = new TreeNode();
tnfirst.Text = myDataRow["nam"].ToString();
tnfirst.Name = myDataRow["Code"].ToString() + myDataRow["SysNo"].ToString();
xtreeView.SelectedNode.Nodes.Add(tnfirst);
if (Int32.Parse(myDataRow["SysNo"].ToString()) == 0)
{
tnfirst.ImageIndex = 0;
}
else
{
tnfirst.ImageIndex = 1;
}
GetTVAllNode(tnfirst, tnfirst.Name.Substring(0, 10));
}
xtreeView.ExpandAll();
xtreeView.EndUpdate();
//myDataAdapter.Dispose();
//myDataSet.Dispose();
}
public void Import(TextBox dataCardTextBox, string initializeString, TreeView treeView)
{
if (IsValid(dataCardTextBox, "Datacard"))
{
CurrentState = State.StateImporting;
treeView.BeginUpdate();
ImportDataCard(dataCardTextBox.Text, initializeString, treeView);
treeView.EndUpdate();
}
}
private static TreeNode LastSelectNode = null; //最后选中的节点
#endregion Fields
#region Methods
/// <summary>
/// 恢复TREEVIEW最后一次选中的节点状态 和展开的状态和图标
/// </summary>
/// <param name="treeView"></param>
/// <param name="fileName"></param>
public static bool LoadXml(TreeView treeView, string fileName)
{
bool working = true;
XmlTextReader reader = null;
try
{
treeView.Nodes.Clear();
// disabling re-drawing of treeview till all nodes are added
treeView.BeginUpdate();
reader = new XmlTextReader(fileName);
TreeNode parentNode = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name == XmlNodeTag)
{
TreeNode newNode = new TreeNode();
bool isEmptyElement = reader.IsEmptyElement;
// loading node attributes
int attributeCount = reader.AttributeCount;
if (attributeCount > 0)
{
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToAttribute(i);
SetAttributeValue(newNode, reader.Name, reader.Value);
SetTreeViewState(treeView);
}
}
// add new node to Parent Node or TreeView
if (parentNode != null)
parentNode.Nodes.Add(newNode);
else
treeView.Nodes.Add(newNode);
// making current node 'ParentNode' if its not empty
if (!isEmptyElement)
{
parentNode = newNode;
}
}
}
// moving up to in TreeView if end tag is encountered
else if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.Name == XmlNodeTag)
{
parentNode = parentNode.Parent;
}
}
else if (reader.NodeType == XmlNodeType.XmlDeclaration)
{ //Ignore Xml Declaration
}
else if (reader.NodeType == XmlNodeType.None)
{
working = false;
}
else if (reader.NodeType == XmlNodeType.Text)
{
parentNode.Nodes.Add(reader.Value);
}
working = false;
}
working = false;
}
finally
{
treeView.EndUpdate();
reader.Close();
working = false;
}
working = false;
return working;
}
/// <summary>
/// 把XML文件读取到TREE中
/// </summary>
/// <param name="treeView"></param>
/// <param name="fileName"></param>
public static void LoadXmlFile(TreeView treeView, string fileName)
{
XmlTextReader reader = null;
try
{
treeView.BeginUpdate();
reader = new XmlTextReader(fileName);
TreeNode n = new TreeNode(fileName);
treeView.Nodes.Add(n);
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
bool isEmptyElement = reader.IsEmptyElement;
StringBuilder text = new StringBuilder();
text.Append(reader.Name);
int attributeCount = reader.AttributeCount;
if (attributeCount > 0)
{
text.Append(" ( ");
for (int i = 0; i < attributeCount; i++)
{
if (i != 0) text.Append(", ");
reader.MoveToAttribute(i);
text.Append(reader.Name);
text.Append(" = ");
text.Append(reader.Value);
}
text.Append(" ) ");
}
if (isEmptyElement)
{
n.Nodes.Add(text.ToString());
}
else
{
n = n.Nodes.Add(text.ToString());
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
n = n.Parent;
}
else if (reader.NodeType == XmlNodeType.XmlDeclaration)
{
}
else if (reader.NodeType == XmlNodeType.None)
{
return;
}
else if (reader.NodeType == XmlNodeType.Text)
{
n.Nodes.Add(reader.Value);
}
}
}
finally
{
treeView.EndUpdate();
reader.Close();
}
}
/// <summary>
/// Fills in the specified System.Windows.Forms.TreeView component with content representing the fuzzy relation
/// </summary>
/// <param name="treeView">Treeview component to display the relation's hierararchy</param>
/// <param name="pictureBox">PictureBox component to display graphs for particular nodes, where possible. Null if graphs not required.</param>
/// <param name="label">Label to display caption for the picture. Null if graphs not required.</param>
public void BuildTree( TreeView treeView, PictureBox pictureBox, Label label)
{
_pictureBox = pictureBox;
_label = label;
ImageList imageList = new ImageList();
imageList.Images.Add("dimensions", Resources.dimensions);
imageList.Images.Add("function", Resources.Function1);
imageList.Images.Add("subrelations", Resources.subrelations);
imageList.Images.Add("fuzzySet", Resources.fuzzySet);
imageList.Images.Add("nodeFuzzyRelation", Resources.nodeFuzzyRelation);
imageList.Images.Add("dimensionType", Resources.dimensionType);
imageList.Images.Add("dimensionDiscreteKnown", Resources.dimensionDiscrete);
imageList.Images.Add("dimensionDiscreteUnknown", Resources.dimensionDiscreteUnknown);
imageList.Images.Add("dimensionContinuousKnown", Resources.dimensionContinuous);
imageList.Images.Add("dimensionContinuousUnknown", Resources.dimensionContinuousUnknown);
imageList.Images.Add("defuzzification", Resources.defuzzification);
imageList.Images.Add("defuzzificationOutput", Resources.defuzzificationOutput);
imageList.Images.Add("spacer", Resources.spacer);
treeView.ImageList = imageList;
pictureBox.BackColor = GraphBackgroundColor;
pictureBox.Image = null;
label.Text = "";
treeView.BeginUpdate();
treeView.Nodes.Clear();
if (_deffuzification == null)
{
buildSubTree(_relation, treeView.Nodes, pictureBox, label);
}
else
{
TreeNode deffuz = new TreeNode(_deffuzification.GetType().Name);
deffuz.ImageKey = "defuzzification";
deffuz.SelectedImageKey = "defuzzification";
deffuz.Tag = _deffuzification;
treeView.Nodes.Add(deffuz);
TreeNode deffuzOutput = new TreeNode(
String.Format("{0}={1:F5} {2}",
_deffuzification.OutputDimension.Name,
_deffuzification.CrispValue,
_deffuzification.OutputDimension is IContinuousDimension ? ((IContinuousDimension)_deffuzification.OutputDimension).Unit : ""
)
);
deffuzOutput.ImageKey = "defuzzificationOutput";
deffuzOutput.SelectedImageKey = "defuzzificationOutput";
deffuz.Nodes.Add(deffuzOutput);
buildSubTree(_relation, deffuz.Nodes, pictureBox, label);
}
treeView.EndUpdate();
treeView.AfterSelect -= treeView_AfterSelect_EventHandler;
if (_pictureBox != null && _label != null)
treeView.AfterSelect += treeView_AfterSelect_EventHandler;
}
public static void RebuildList( TreeView tree )
{
tree.BeginUpdate();
UpdateNode( m_Root );
tree.Nodes.Clear();
tree.Nodes.Add( m_Root );
m_Root.Expand();
tree.EndUpdate();
}
public ExpansionTreeView(TreeView treeView, List<StrandNode> strandNodeList,
uint dKrystalLevel, List<int> missingPointValues)
{
_treeView = treeView;
_strandNodeList = strandNodeList;
string missingPointValuesStr = "";
if(missingPointValues.Count > 0)
missingPointValuesStr = K.GetStringOfUnsignedInts(missingPointValues);
#region constant krystal inputs
if(dKrystalLevel == 0) // constant krystal inputs
{
int p = strandNodeList[0].strandPoint;
int d = strandNodeList[0].strandDensity;
strandNodeList[0].Text = "1: m1"
+ ", p" + p.ToString()
+ ", d" + d.ToString();
_treeView.Nodes.Add(strandNodeList[0]);
}
#endregion constant krystal inputs
else
#region line krystal inputs
if(dKrystalLevel == 1) // line krystal
{
_treeView.BeginUpdate();
if(missingPointValues.Count > 0)
_treeView.Nodes.Add("Missing p value(s): " + missingPointValuesStr);
foreach(StrandNode strandNode in strandNodeList)
{
int m = strandNode.strandMoment;
int p = strandNode.strandPoint;
int d = strandNode.strandDensity;
strandNode.Text = m.ToString()
+ ": m" + m.ToString()
+ ", p" + p.ToString()
+ ", d" + d.ToString();
_treeView.Nodes.Add(strandNode);
}
_treeView.EndUpdate();
}
#endregion line krystal inputs
else
#region higher level krystal inputs
{
// Construct the levels of the tree above the strandNodeList, adding the StrandNodes where
// necessary. (The upper levels consist of pure TreeNodes and include the single root node.)
TreeNode[] currentNode = new TreeNode[dKrystalLevel];
int[] localSectionNumber = new int[dKrystalLevel];// does not include the local strand section numbers
int localStrandSectionNumber = 0;
foreach(StrandNode strandNode in strandNodeList)
{
if(strandNode.strandLevel <= dKrystalLevel)
{
localStrandSectionNumber = 0;
int levelIndex = strandNode.strandLevel - 1;
while(levelIndex < dKrystalLevel)
{
TreeNode tn = new TreeNode();
tn.Expand();
currentNode[levelIndex] = tn;
if(levelIndex > 0) // there is only one node at levelIndex == 0, and it has no text
{
currentNode[levelIndex - 1].Nodes.Add(tn);
localSectionNumber[levelIndex - 1]++;
localSectionNumber[levelIndex] = 0;
if(levelIndex == 1)
tn.Text = localSectionNumber[levelIndex - 1].ToString();
else
tn.Text = tn.Parent.Text + "." + localSectionNumber[levelIndex - 1].ToString();
}
levelIndex++;
}
}
localStrandSectionNumber++;
currentNode[dKrystalLevel - 1].Nodes.Add(strandNode);
localSectionNumber[dKrystalLevel - 1]++;
int m = strandNode.strandMoment;
int p = strandNode.strandPoint;
int d = strandNode.strandDensity;
strandNode.Text = strandNode.Parent.Text
+ "." + localStrandSectionNumber.ToString()
+ ": m" + m.ToString()
+ ", p" + p.ToString()
+ ", d" + d.ToString();
}
// Now add the moment numbers to the pure TreeNode.Texts
foreach(StrandNode strandNode in strandNodeList)
{
if(strandNode.strandLevel <= dKrystalLevel)
{
TreeNode tn = strandNode.Parent;
bool continueUp = true;
while(continueUp)
{
if(tn.Text.EndsWith(".1") && tn.Level > 0)
continueUp = true;
else continueUp = false;
int m = strandNode.strandMoment;
tn.Text = tn.Text + ": m" + m.ToString();
if(continueUp)
tn = tn.Parent;
}
}
}
_treeView.BeginUpdate();
_treeView.Nodes.Clear();
if(missingPointValues.Count > 0)
_treeView.Nodes.Add("Missing p value(s): " + missingPointValuesStr);
foreach(TreeNode n in currentNode[0].Nodes)
{
_treeView.Nodes.Add(n);
}
_treeView.EndUpdate();
}
#endregion higher level krystal inputs
}
public static void UpdateTree(TreeView treeView, TypeSystem typeSystem, MosaTypeLayout typeLayout, bool showSizes)
{
treeView.BeginUpdate();
treeView.Nodes.Clear();
foreach (var module in typeSystem.Modules)
{
TreeNode moduleNode = new TreeNode(module.Name);
treeView.Nodes.Add(moduleNode);
foreach (MosaType type in module.Types.Values)
{
TreeNode typeNode = new TreeNode(type.FullName);
moduleNode.Nodes.Add(typeNode);
if (type.BaseType != null)
{
TreeNode baseTypeNode = new TreeNode("Base Type: " + type.BaseType.FullName);
typeNode.Nodes.Add(baseTypeNode);
}
if (type.DeclaringType != null)
{
TreeNode baseTypeNode = new TreeNode("Enclosing Type: " + type.DeclaringType.FullName);
typeNode.Nodes.Add(baseTypeNode);
}
if (type.Interfaces.Count != 0)
{
TreeNode interfacesNodes = new TreeNode("Interfaces");
typeNode.Nodes.Add(interfacesNodes);
foreach (MosaType interfaceType in type.Interfaces)
{
TreeNode interfaceNode = new TreeNode(interfaceType.FullName);
interfacesNodes.Nodes.Add(interfaceNode);
}
}
if (type.Fields.Count != 0)
{
TreeNode fieldsNode = new TreeNode("Fields");
if (showSizes)
fieldsNode.Text = fieldsNode.Text + " (Count: " + type.Fields.Count.ToString() + " - Size: " + typeLayout.GetTypeSize(type).ToString() + ")";
typeNode.Nodes.Add(fieldsNode);
foreach (MosaField field in type.Fields)
{
TreeNode fieldNode = new TreeNode(field.ShortName);
fieldsNode.Nodes.Add(fieldNode);
if (field.IsStatic)
fieldNode.Text = fieldNode.Text + " [Static]";
if (showSizes)
{
fieldNode.Text = fieldNode.Text + " (Size: " + typeLayout.GetFieldSize(field).ToString();
if (!field.IsStatic)
fieldNode.Text = fieldNode.Text + " - Offset: " + typeLayout.GetFieldOffset(field).ToString();
fieldNode.Text = fieldNode.Text + ")";
}
}
}
if (type.Methods.Count != 0)
{
TreeNode methodsNode = new TreeNode("Methods");
typeNode.Nodes.Add(methodsNode);
foreach (MosaMethod method in type.Methods)
{
TreeNode methodNode = new ViewNode<MosaMethod>(method, method.ShortName);
methodsNode.Nodes.Add(methodNode);
if (method.IsStatic)
methodNode.Text = methodNode.Text + " [Static]";
if (method.IsAbstract)
methodNode.Text = methodNode.Text + " [Abstract]";
if (method.IsNewSlot)
methodNode.Text = methodNode.Text + " [NewSlot]";
if (method.IsVirtual)
methodNode.Text = methodNode.Text + " [Virtual]";
if (method.IsFinal)
methodNode.Text = methodNode.Text + " [Final]";
if (method.IsSpecialName)
methodNode.Text = methodNode.Text + " [SpecialName]";
if (method.IsRTSpecialName)
methodNode.Text = methodNode.Text + " [RTSpecialName]";
if (method.GenericArguments.Count != 0)
{
TreeNode genericParameterNodes = new TreeNode("Generic Arguments Types");
methodNode.Nodes.Add(genericParameterNodes);
foreach (var genericParameter in method.GenericArguments)
{
TreeNode GenericParameterNode = new TreeNode(genericParameter.Name);
genericParameterNodes.Nodes.Add(GenericParameterNode);
}
}
}
}
if (typeLayout.GetMethodTable(type) != null)
{
TreeNode methodTableNode = new TreeNode("Method Table");
typeNode.Nodes.Add(methodTableNode);
foreach (MosaMethod method in typeLayout.GetMethodTable(type))
{
TreeNode methodNode = new ViewNode<MosaMethod>(method, method.ShortName);
methodTableNode.Nodes.Add(methodNode);
}
}
}
}
treeView.EndUpdate();
}
/// <summary>
/// Fills in the specified System.Windows.Forms.TreeView component with content representing the fuzzy relation
/// </summary>
/// <param name="treeView">Treeview component to display the relation's hierararchy</param>
/// <param name="pictureBox">PictureBox component to display grapfs for particular nodes, where possible</param>
/// <param name="label">Label to display caption for the picture</param>
public void BuildTree( TreeView treeView, PictureBox pictureBox, Label label)
{
ImageList imageList = new ImageList();
imageList.Images.Add("dimensions", Resources.Graph);
imageList.Images.Add("function", Resources.Function);
imageList.Images.Add("subrelations", Resources.Function);
imageList.Images.Add("fuzzySet", Resources.Function);
imageList.Images.Add("nodeFuzzyRelation", Resources.Function);
imageList.Images.Add("dimensionType", Resources.Function);
imageList.Images.Add("dimensionDiscreteKnown", Resources.Function);
imageList.Images.Add("dimensionDiscreteUnknown", Resources.Function);
imageList.Images.Add("dimensionContinuousKnown", Resources.Function);
imageList.Images.Add("dimensionContinuousUnknown", Resources.Function);
RelationImage img = new RelationImage(_relation, _inputs, _variableDimension);
img.SupportOnly = true;
Bitmap bmp = new Bitmap(300, 200);
imageList.Images.Add(bmp);
treeView.ImageList = imageList;
pictureBox.BackColor = GraphBackgroundColor;
pictureBox.Image = null;
label.Text = "";
treeView.BeginUpdate();
treeView.Nodes.Clear();
buildSubTree(_relation, treeView.Nodes, pictureBox, label);
treeView.EndUpdate();
}
/// <summary>
/// Sets the bold state of the given node.
/// </summary>
/// <param name="item">
/// The node to set.
/// </param>
/// <param name="bolded">
/// Indicates whether the item should be bolded.
/// </param>
/// <param name="tree">
/// The tree that contains the item.
/// </param>
private static void SetBoldState(TreeNode item, bool bolded, TreeView tree)
{
Param.AssertNotNull(item, "item");
Param.Ignore(bolded);
Param.AssertNotNull(tree, "tree");
if (bolded)
{
if (item.NodeFont == null)
{
// Make the item bold.
item.NodeFont = new Font(tree.Font, FontStyle.Bold);
}
else if (!item.NodeFont.Bold)
{
// Make the item bold.
item.NodeFont = new Font(item.NodeFont, FontStyle.Bold);
}
}
else
{
if (item.NodeFont != null && item.NodeFont.Bold)
{
// Make the item not bold.
item.NodeFont = new Font(item.NodeFont, FontStyle.Regular);
}
}
// This forces the tree to redraw the bolded nodes.
tree.BeginUpdate();
tree.EndUpdate();
}
/// <summary>
/// ermittelt alle Empfänger und stellt diese dar
/// </summary>
/// <param name="pin_TreeNode"></param>
/// <param name="pin_IDMenge"></param>
public void LadeMitteilungsEmpfaenger(TreeView pin_TreeView, int[] pin_EmpfaengerIDMenge)
{
#region Holen der Empfänger
String[] einheitenMenge;
String[] helfermenge;
String[] kfzMenge;
// Holen der Empfänger, speichern in die String-Arrays
_st_ToDo.HoleEmpfaenger(pin_EmpfaengerIDMenge, out einheitenMenge, out helfermenge, out kfzMenge);
#endregion
#region Darstellen in EmpfängerTreeview
// Anpassen Treeview beginnen
pin_TreeView.BeginUpdate();
pin_TreeView.Nodes.Clear();
// alle mögliche Kräftetypen
string[] str_typmenge = new string[3];
str_typmenge[0] = "Einheiten";
str_typmenge[1] = "Helfer";
str_typmenge[2] = "Kfz";
// Laufindex
int i_lauf = 0;
// Knoten auf der obersten Hierachieebene erstellen
for(int i=0; i < str_typmenge.Length; i++)
{
pin_TreeView.Nodes.Add(str_typmenge[i]);
}
// Knoten unter dem Oberknoten "Einheit"
foreach(String s in einheitenMenge)
{
TreeNode neuerKnoten = new TreeNode(s);
pin_TreeView.Nodes[0].Nodes.Add(neuerKnoten);
pin_TreeView.Nodes[0].Nodes[i_lauf].Checked = true;
i_lauf++;
}
i_lauf = 0;
// Knoten unter dem Oberknoten "Helfer"
foreach(String s in helfermenge)
{
TreeNode neuerKnoten = new TreeNode(s);
pin_TreeView.Nodes[1].Nodes.Add(neuerKnoten);
pin_TreeView.Nodes[1].Nodes[i_lauf].Checked = true;
i_lauf++;
}
i_lauf = 0;
// Knoten unter dem Oberknoten "Kfz"
foreach(String s in kfzMenge)
{
TreeNode neuerKnoten = new TreeNode(s);
pin_TreeView.Nodes[2].Nodes.Add(neuerKnoten);
pin_TreeView.Nodes[2].Nodes[i_lauf].Checked = true;
i_lauf++;
}
// Anpassen Treeview beenden
pin_TreeView.ExpandAll();
pin_TreeView.EndUpdate();
#endregion
}
public void SortedRecursive ()
{
TreeView tv = new TreeView ();
tv.TreeViewNodeSorter = new InverseNodeSorter ();
tv.BeginUpdate ();
TreeNode root_node = tv.Nodes.Add ("Root");
for (char c = 'a'; c <= 'f'; c++) {
TreeNode node = new TreeNode (c.ToString ());
for (int i = 0; i < 3; i++)
node.Nodes.Add (i.ToString ());
root_node.Nodes.Add (node);
}
tv.EndUpdate ();
// Make sure we are sorted
tv.Sort ();
Assert.AreEqual ("f", root_node.Nodes [0].Text, "#A1");
Assert.AreEqual ("e", root_node.Nodes [1].Text, "#A2");
Assert.AreEqual ("d", root_node.Nodes [2].Text, "#A3");
Assert.AreEqual ("c", root_node.Nodes [3].Text, "#A4");
Assert.AreEqual ("b", root_node.Nodes [4].Text, "#A5");
Assert.AreEqual ("a", root_node.Nodes [5].Text, "#A5");
foreach (TreeNode n in root_node.Nodes) {
Assert.AreEqual ("2", n.Nodes [0].Text, "#B1");
Assert.AreEqual ("1", n.Nodes [1].Text, "#B2");
Assert.AreEqual ("0", n.Nodes [2].Text, "#B3");
}
}
static void BuildAPITree(TreeView Tree, XmlDocument API)
{
try
{
Tree.BeginUpdate();
Tree.Nodes.Clear();
//Build class
foreach (XmlNode Class in API.SelectNodes("api")[0].SelectNodes("class"))
{
TreeNode ClassNode = new TreeNode();
string ClassName = Class.SelectNodes("name")[0].InnerText;
ClassNode.Name = ClassName;
ClassNode.Text = ClassName;
ClassNode.ForeColor = Color.Green;
string ClassType = Class.SelectNodes("type")[0].InnerText;
ClassNode.ToolTipText = Class.SelectNodes("description")[0].InnerText;
TreeNode ConstructorsNode = new TreeNode();
ConstructorsNode.Name = "Constructors";
ConstructorsNode.Text = "Constructors";
ConstructorsNode.ForeColor = Color.Brown;
TreeNode PropertiesNode = new TreeNode();
PropertiesNode.Name = "Properties";
PropertiesNode.Text = "Properties";
PropertiesNode.ForeColor = Color.DarkBlue;
TreeNode MethodsNode = new TreeNode();
MethodsNode.Name = "Methods";
MethodsNode.Text = "Methods";
MethodsNode.ForeColor = Color.IndianRed;
TreeNode MembersNode = new TreeNode();
MembersNode.Name = "Members";
MembersNode.Text = "Members";
if (ClassType.Equals("Non-Static"))
{
ClassNode.Nodes.Add(ConstructorsNode);
}
if (ClassType.Equals("Non-Static") || ClassType.Equals("Static"))
{
ClassNode.Nodes.Add(PropertiesNode);
ClassNode.Nodes.Add(MethodsNode);
}
if (ClassType.Equals("Enum"))
{
ClassNode.Nodes.Add(MembersNode);
}
//Build constructors
try
{
foreach (XmlNode Constructor in Class.SelectNodes("constructors")[0].SelectNodes("constructor"))
{
TreeNode ConstructorNode = new TreeNode();
string ConstructorName = Constructor.SelectNodes("name")[0].InnerText;
ConstructorNode.Name = "constructors-" + ConstructorName;
ConstructorNode.Text = ConstructorName;
ConstructorNode.ForeColor = Color.Brown;
ConstructorNode.ToolTipText = Constructor.SelectNodes("description")[0].InnerText;
ConstructorsNode.Nodes.Add(ConstructorNode);
}
}
catch
{
}
//Build properties
try
{
foreach (XmlNode Property in Class.SelectNodes("properties")[0].SelectNodes("property"))
{
TreeNode PropertyNode = new TreeNode();
string PropertyName = Property.SelectNodes("name")[0].InnerText + " : " + Property.SelectNodes("datatype")[0].InnerText;
PropertyNode.Name = "properties-" + PropertyName;
PropertyNode.Text = PropertyName;
PropertyNode.ForeColor = Color.DarkBlue;
PropertyNode.ToolTipText = Property.SelectNodes("description")[0].InnerText;
PropertiesNode.Nodes.Add(PropertyNode);
}
}
catch
{
}
//Build methods
try
{
foreach (XmlNode Method in Class.SelectNodes("methods")[0].SelectNodes("method"))
{
TreeNode MethodNode = new TreeNode();
string MethodName = Method.SelectNodes("name")[0].InnerText + " : " + Method.SelectNodes("return")[0].InnerText;
MethodNode.Name = "methods-" + MethodName;
MethodNode.Text = MethodName;
MethodNode.ForeColor = Color.IndianRed;
MethodNode.ToolTipText = Method.SelectNodes("description")[0].InnerText;
MethodsNode.Nodes.Add(MethodNode);
}
}
catch
{
}
//Build members
try
{
foreach (XmlNode Member in Class.SelectNodes("members")[0].SelectNodes("member"))
{
TreeNode MemberNode = new TreeNode();
string MemberName = Member.SelectNodes("name")[0].InnerText;
MemberNode.Name = "members-" + MemberName;
MemberNode.Text = MemberName;
MemberNode.ForeColor = Color.IndianRed;
MemberNode.ToolTipText = Member.SelectNodes("description")[0].InnerText;
MembersNode.Nodes.Add(MemberNode);
}
}
catch
{
}
Tree.Nodes.Add(ClassNode);
Tree.EndUpdate();
}
}
catch(Exception Exp)
{
Tree.EndUpdate();
throw Exp;
}
}
public bool ProcessTorrentFile(string torrentFile, TreeView tvTree, CommandLineArgs args)
{
// ----------------------------------------
// read in torrent file
if (tvTree != null)
tvTree.Nodes.Clear();
BEncodeLoader bel = new BEncodeLoader();
BTFile btFile = bel.Load(torrentFile);
if (btFile == null)
return false;
BTItem bti = btFile.GetItem("info");
if ((bti == null) || (bti.Type != BTChunk.kDictionary))
return false;
BTDictionary infoDict = (BTDictionary) (bti);
bti = infoDict.GetItem("piece length");
if ((bti == null) || (bti.Type != BTChunk.kInteger))
return false;
Int64 pieceSize = ((BTInteger) bti).Value;
bti = infoDict.GetItem("pieces");
if ((bti == null) || (bti.Type != BTChunk.kString))
return false;
BTString torrentPieces = (BTString) (bti);
bti = infoDict.GetItem("files");
if (bti == null) // single file torrent
{
bti = infoDict.GetItem("name");
if ((bti == null) || (bti.Type != BTChunk.kString))
return false;
BTString di = (BTString) (bti);
string nameInTorrent = di.AsString();
BTItem fileSizeI = infoDict.GetItem("length");
Int64 fileSize = ((BTInteger) fileSizeI).Value;
this.NewTorrentEntry(torrentFile, -1);
if (this.DoHashChecking)
{
byte[] torrentPieceHash = torrentPieces.StringTwentyBytePiece(0);
FileInfo fi = this.FindLocalFileWithHashAt(torrentPieceHash, 0, pieceSize, fileSize);
if (fi != null)
this.FoundFileOnDiskForFileInTorrent(torrentFile, fi, -1, nameInTorrent);
else
this.DidNotFindFileOnDiskForFileInTorrent(torrentFile, -1, nameInTorrent);
}
this.FinishedTorrentEntry(torrentFile, -1, nameInTorrent);
// don't worry about updating overallPosition as this is the only file in the torrent
}
else
{
Int64 overallPosition = 0;
Int64 lastPieceLeftover = 0;
if (bti.Type != BTChunk.kList)
return false;
BTList fileList = (BTList) (bti);
// list of dictionaries
for (int i = 0; i < fileList.Items.Count; i++)
{
this.Prog(100 * i / fileList.Items.Count);
if (fileList.Items[i].Type != BTChunk.kDictionary)
return false;
BTDictionary file = (BTDictionary) (fileList.Items[i]);
BTItem thePath = file.GetItem("path");
if (thePath.Type != BTChunk.kList)
return false;
BTList pathList = (BTList) (thePath);
// want the last of the items in the list, which is the filename itself
int n = pathList.Items.Count - 1;
if (n < 0)
return false;
BTString fileName = (BTString) (pathList.Items[n]);
BTItem fileSizeI = file.GetItem("length");
Int64 fileSize = ((BTInteger) fileSizeI).Value;
int pieceNum = (int) (overallPosition / pieceSize);
if (overallPosition % pieceSize != 0)
pieceNum++;
this.NewTorrentEntry(torrentFile, i);
if (this.DoHashChecking)
{
byte[] torrentPieceHash = torrentPieces.StringTwentyBytePiece(pieceNum);
FileInfo fi = this.FindLocalFileWithHashAt(torrentPieceHash, lastPieceLeftover, pieceSize, fileSize);
if (fi != null)
this.FoundFileOnDiskForFileInTorrent(torrentFile, fi, i, fileName.AsString());
else
this.DidNotFindFileOnDiskForFileInTorrent(torrentFile, i, fileName.AsString());
}
this.FinishedTorrentEntry(torrentFile, i, fileName.AsString());
int sizeInPieces = (int) (fileSize / pieceSize);
if (fileSize % pieceSize != 0)
sizeInPieces++; // another partial piece
lastPieceLeftover = (lastPieceLeftover + (Int32) ((sizeInPieces * pieceSize) - fileSize)) % pieceSize;
overallPosition += fileSize;
} // for each file in the torrent
}
if (tvTree != null)
{
tvTree.BeginUpdate();
btFile.Tree(tvTree.Nodes);
tvTree.ExpandAll();
tvTree.EndUpdate();
tvTree.Update();
}
this.Prog(0);
return true;
}
private void updateTreeView(string xml, TreeView treeView)
{
treeView.BeginUpdate();
try
{
treeView.Nodes.Clear();
XmlDocument tmpxmldoc = new XmlDocument();
tmpxmldoc.LoadXml(xml);
FillTree(tmpxmldoc.DocumentElement, treeView.Nodes);
treeView.ExpandAll();
}
catch (Exception ex)
{
Logger.Log("Error during XML conversion", Helpers.LogLevel.Error, ex);
}
finally
{
treeView.EndUpdate();
}
}
public static void RenderToTreeControl(List<KPFormCustomization> listCustoms,
TreeView tv)
{
tv.BeginUpdate();
tv.Nodes.Clear();
foreach(KPFormCustomization kpfc in listCustoms)
{
string strName = kpfc.FullName;
int nLastDot = strName.LastIndexOf('.');
if(nLastDot >= 0) strName = strName.Substring(nLastDot + 1);
TreeNode tnForm = tv.Nodes.Add(strName);
tnForm.Tag = kpfc;
TreeNode tnWindow = tnForm.Nodes.Add("Window");
tnWindow.Tag = kpfc.Window;
foreach(KPControlCustomization kpcc in kpfc.Controls)
{
TreeNode tnControl = tnForm.Nodes.Add(kpcc.Name);
tnControl.Tag = kpcc;
}
tnForm.ExpandAll();
}
tv.EndUpdate();
}