Treeview: Hvad har man klikket på?

Overskriften burde have heddet:
Treeview: Hvilket level har man klikket på? :o)

Du kan vel tælle antallet af punktumer..

int level = s.Split('.').Length;

ranglen >> tak det var lige det jeg skulle bruge :o)

Drop et svar.

Jeg har også lige et spørgsmål mere:

Hvordan får jeg fat på parent (det første ciffer) uanset hvilket level der er blevet klikket på?

Fx hvis der er blevet klikket på
0.0.0.1 - så skal jeg have fat på 0
1.2.2.2 - så skal jeg have fat på 1
4.0 - så skal jeg have fat på 4

Med venlig hilsen

Det kan du ved at bruge strengens indexer..

parent = s[0];

ranglen >> kanon det virker også :-)

her er lidt output!
der er blevet klikket på:
0.0.0.1 - parent er 48
1.2.2.2 - parent er 49


og det passer jo, fordi
48 er DEC for symbolet 0
48 er DEC for symbolet for 1.

men hvordan kan det være at den "ved",  at den kun skal kigge foran punktumet?

Sjov løsning du har valgt. hvorfor ik gøre det i noget af følgende stil.

TreeNode node = treeView.SeletedNode;
int i = 0;
while(node != null)
{
node = node.Parent;
i++;
}
return i;

det "ved" den fordi du kigger på strengen som et array af chars. [0] første char, [1] andet char, ...

segato, jeg synes faktisk din løsning i dette tilfælde er mere sjov.

Har rodet en hel del med treeview og syntes der mangler en masse. Jeg stødte på et par problemmer med at finde en nodes index f.eks. eller at hente en node ud fra et index. Men kan lige smide klassen jeg i isn tid lavede måske du kunn ebruge noget derfra:

    public class CEXmlDocument : XmlDocument
    {
        public CEXmlDocument()
        {
            //
            // TODO: Add constructor logic here
            //               
        }

        public CEXmlDocument clone()
        {   
            CEXmlDocument doc = new CEXmlDocument();

            foreach(XmlNode node in this.ChildNodes )
            {
                doc.AppendChild(doc.ImportNode(node, true));
            }       

            return doc;
        }

        public XmlNode getNextNode(XmlNode currXmlNode)
        {
            string test = currXmlNode.Name;

            XmlNode next_node = null;

            if ( currXmlNode.FirstChild != null )
            {
                next_node = currXmlNode.FirstChild;
            }
            else if ( currXmlNode.NextSibling != null )
            {
                next_node = currXmlNode.NextSibling;
            }
            else if ( currXmlNode.ParentNode != null )
            {
                while(currXmlNode.ParentNode.NextSibling != null & currXmlNode.ParentNode != null)
                {                   
                    currXmlNode = currXmlNode.ParentNode;
                    if( currXmlNode.NextSibling != null )
                        return currXmlNode.NextSibling;
                }
               
                if(currXmlNode.NextSibling != null)
                    next_node = currXmlNode.NextSibling;
                else
                    next_node = null;
            }
            else
            {
                return null;
            }
            return next_node;           
        }           

        public int getIndexFromNode(XmlNode xmlNode)
        {
            int nodecount = 0;
            if (xmlNode !=null)
            {   
                XmlNode currXmlNode = this.FirstChild;
                while(currXmlNode != xmlNode)
                {   
                    if (currXmlNode.FirstChild != null) // child node
                        currXmlNode = currXmlNode.FirstChild;
                    else if (currXmlNode.NextSibling != null) // next sibling
                        currXmlNode = currXmlNode.NextSibling;
                    else                            // next sibling of parent
                    {
                        while(currXmlNode.ParentNode.NextSibling == null)
                        {
                            currXmlNode = currXmlNode.ParentNode;
                        }
                        currXmlNode = currXmlNode.ParentNode.NextSibling;
                    }
                    nodecount++;
                }
                return nodecount;
            }
            else
            {
                return -1;
            }               
        }

        public XmlNode getNodeFromIndex(int index)
        {
            XmlNode node = this.FirstChild;

            for(int i = 0; i < index; i++)
            {
                if(node == null)
                {
                    return node;
                }
                node = getNextNode(node);                   
            }   
            return node;
        }
    }

Ved godt det et XmlDocument men det nøjagtig det samme for et treeview.

Her er den i treeview model:D

public class CTreeView : System.Windows.Forms.TreeView
    {
        public CTreeView()
        {
            //
            // TODO: Add constructor logic here
            //
        }

        public TreeNode getNodeFromIndex(int index)
        {
            TreeNode node = this.Nodes[0];

            for(int i = 0; i < index; i++)
            {
                if(node == null)
                {
                    return node;
                }
                node = node.NextVisibleNode;               
            }   
            return node;
        }

        public TreeNode GetNextNode(TreeNode curr_node)
        {
            TreeNode next_node = null;
            if(curr_node.FirstNode != null )
            {
                next_node = curr_node.FirstNode;
            }
            else if( curr_node.NextNode != null )
            {
                next_node = curr_node.NextNode;
            }
            else if( curr_node.Parent != null )
            {
                while(curr_node.Parent.NextNode != null & curr_node.Parent != null)
                {
                    curr_node = curr_node.Parent;                   
                }
                if(curr_node.Parent.NextNode != null)
                    next_node = curr_node.Parent.NextNode;
                else
                    next_node = null;
            }
            else
            {
                return null;
            }
            return next_node;           
        }

        public int getIndexFromNode(TreeNode treeNode)
        {
            int nodecount = 0;
            if (treeNode !=null)
            {
                if(treeNode.TreeView == null)
                    return -1;

                TreeNode currNode = treeNode.TreeView.Nodes[0];
                while(currNode != treeNode)
                {   
                    if (currNode.FirstNode != null) // child node
                        currNode = currNode.FirstNode;
                    else if (currNode.NextNode != null) // next sibling
                        currNode = currNode.NextNode;
                    else                            // next sibling of parent
                    {
                        while(currNode.Parent.NextNode == null)
                        {
                            currNode = currNode.Parent;
                        }
                        currNode = currNode.Parent.NextNode;
                    }
                    nodecount++;
                }
                return nodecount;
            }
            else
            {
                return -1;
            }               
        }
    }

I stedet for at tælle, kunne man også vælge at sætte node.Tag = level, når noden oprettes. Så har man altid level lige ved hånden..

Tror det er det han gør. Personligt kan jeg bare godt lide genbrugelig kode så hvofor ik specialiere et treeview med en getLevel(), og så en anden dag har han lige den funktionalitet ved hånden? Men det som alt andet smag og behag:D

segato >>
Det er Microsoft.Web.UI.WebControls.TreeView jeg anvender. Det som du anvender er System.Windows.Forms.TreeView.

Der er nogle forskelle hist og her, men grundideen skulle være den samme :o)

Det som ranglen forslog med at tælle virker egentligt fint nok. Men jeg kigger din kode i gennem lidt senere. Og mange tak for det :o)

Med venlig hilsen

Det helt i orden mester og som du siger så er det faktisk det samme. Der er rigtig mange ting treeview, xmldocument og masser af andre ting der bygger på samme princip.

Tak for hjælpen. Beklager det sene svar.