ContextNode.CreatePartiallyPopulatedSubNode, méthode

Article
11/05/2008

Mise à jour : November 2007

Crée un objet ContextNode enfant qui contient uniquement les informations suivantes : Type, Id et Location.

Espace de noms : Microsoft.Ink
Assembly : Microsoft.Ink.Analysis (dans Microsoft.Ink.Analysis.dll)

Syntaxe

'Déclaration
Public Function CreatePartiallyPopulatedSubNode ( _
    type As Guid, _
    nodeId As Guid, _
    nodeLocation As AnalysisRegion _
) As ContextNode
'Utilisation
Dim instance As ContextNode
Dim type As Guid
Dim nodeId As Guid
Dim nodeLocation As AnalysisRegion
Dim returnValue As ContextNode

returnValue = instance.CreatePartiallyPopulatedSubNode(type, _
    nodeId, nodeLocation)

public ContextNode CreatePartiallyPopulatedSubNode(
    Guid type,
    Guid nodeId,
    AnalysisRegion nodeLocation
)

public:
ContextNode^ CreatePartiallyPopulatedSubNode(
    Guid type, 
    Guid nodeId, 
    AnalysisRegion^ nodeLocation
)

public ContextNode CreatePartiallyPopulatedSubNode(
    Guid type,
    Guid nodeId,
    AnalysisRegion nodeLocation
)

public function CreatePartiallyPopulatedSubNode(
    type : Guid, 
    nodeId : Guid, 
    nodeLocation : AnalysisRegion
) : ContextNode

Paramètres

type
Type : System.Guid
Type de l'objet ContextNode à créer. Utilisez l'un des GUID définis dans la classe ContextNodeType pour spécifier le type à créer.

nodeId
Type : System.Guid
Identificateur du nouveau nœud.

nodeLocation
Type : Microsoft.Ink.AnalysisRegion
Emplacement du nouveau nœud.

Valeur de retour

Type : Microsoft.Ink.ContextNode
Nouvel objet ContextNode qui contient uniquement des informations sur Type, Id et Location. Ce nouveau nœud est un enfant du ContextNode.

Notes

Cette méthode est utilisée pour le proxy de données afin de créer un objet ContextNode dans l'arborescence des nœuds de contexte avant que toutes les informations associées soient disponibles. Il est possible d'ajouter le reste des informations à son sujet ultérieurement.

Exemples

L'exemple suivant est une méthode appelée CreatePartiallyPopulatedNode, issue d'un exemple de code qui utilise un System.Windows.Forms.TreeView (page pouvant être en anglais) en tant que modèle de document pour montrer comment utiliser le proxy de données afin de stocker et charger une arborescence des nœuds de contexte pour un InkAnalyzer. La classe DocumentNodeData stocke les données ContextNode dans le modèle de document en affectant un objet DocumentNodeData à la propriété Tag (page pouvant être en anglais) de chaque objet TreeNode (page pouvant être en anglais). La méthode CreatePartiallyPopulatedNode utilise un objet TreeNode (page pouvant être en anglais) et un objet InkAnalyzer pour créer le nœud rempli partiellement dans l'arborescence des nœuds de contexte InkAnalyzer qui correspond au TreeNode (page pouvant être en anglais) du modèle de document. Dans cet exemple, tous les nœuds sont partiellement remplis à leur création. Ils sont ensuite placés dans une file d'attente de nœuds destinés à être complètement remplis ultérieurement à l'aide de l'ensemble des données de nœud.

La méthode obtient tout d'abord les données de nœud de la propriété Tag (page pouvant être en anglais) de l'objet TreeNode (page pouvant être en anglais) passé. Elle utilise ensuite la propriété Id pour vérifier que le nœud n'est pas actuellement dans l'arborescence des nœuds de contexte. Elle utilise alors le nœud parent d'arborescence pour rechercher le nœud parent correspondant dans le InkAnalyzer. Si le nœud parent n'existe pas encore dans l'arborescence des nœuds de contexte, il est ajouté par récursivité. Si le nœud parent existe dans l'arborescence, il doit être rempli partiellement. S'il était complètement rempli, il contiendrait déjà tous ses sous-nœuds et il ne serait pas nécessaire d'en ajouter un nouveau. Par conséquent, la propriété PartiallyPopulated vérifie que le nœud parent est rempli partiellement, auquel cas il est ajouté à une file d'attente en vue d'être rempli complètement ultérieurement. S'il n'est pas rempli partiellement, une exception est levée. Enfin, la méthode CreatePartiallyPopulatedSubNode est appelée sur le nœud parent et le nouveau nœud est ajouté à la file d'attente des nœuds à remplir complètement. Le nouvel objet ContextNode est retourné. Pour plus d'informations sur le proxy de données, consultez Data Proxy with Ink Analysis.

Private Function CreatePartiallyPopulatedNode(ByVal documentNode As TreeNode, _
    ByVal theInkAnalyzer As Microsoft.Ink.InkAnalyzer) As Microsoft.Ink.ContextNode

    Dim nodeData As DocumentNodeData = documentNode.Tag '

    ' Check that the node does not already exist in the InkAnalyzer.
    If Nothing <> theInkAnalyzer.FindNode(nodeData.Id) Then
        Throw New ApplicationException("The node already exists in the InkAnalyzer.")
    End If

    ' Find the parent analyzer node.
    Dim parentNodeData As DocumentNodeData = documentNode.Parent.Tag

    Dim analyzerParentNode As Microsoft.Ink.ContextNode = _
        theInkAnalyzer.FindNode(parentNodeData.Id)

    If Nothing = analyzerParentNode Then
        ' The parent analyzer node does not exist yet. Create one.
        analyzerParentNode = Me.CreatePartiallyPopulatedNode(documentNode.Parent, theInkAnalyzer)
    ElseIf analyzerParentNode.PartiallyPopulated Then
        ' The parent analyzer node exists and is partially populated. Add it
        ' to the stack of nodes to fully populate.
        Me.QueueNodeToPopulate(analyzerParentNode)
    Else
        ' The parent analyzer node exists and is fully populated. This
        ' should not happen.
        Throw New ApplicationException("The parent analyzer node is fully populated.")
    End If

    ' Create the partially populated node under its parent analyzer node.
    Dim analyzerNode As Microsoft.Ink.ContextNode = _
        analyzerParentNode.CreatePartiallyPopulatedSubNode(nodeData.Type, _
        nodeData.Id, nodeData.Location)

    ' Add the new node to the stack of nodes to fully populate.
    Me.QueueNodeToPopulate(analyzerNode)

    Return analyzerNode

End Function 'CreatePartiallyPopulatedNode

        private Microsoft.Ink.ContextNode CreatePartiallyPopulatedNode(
            TreeNode documentNode, Microsoft.Ink.InkAnalyzer theInkAnalyzer)
        {
            DocumentNodeData nodeData = documentNode.Tag as DocumentNodeData;

            // Check that the node does not already exist in the InkAnalyzer.
            if (null != theInkAnalyzer.FindNode(nodeData.Id))
            {
                throw new ApplicationException(
                    "The node already exists in the InkAnalyzer.");
            }

            // Find the parent analyzer node.
            DocumentNodeData parentNodeData =
                documentNode.Parent.Tag as DocumentNodeData;
            Microsoft.Ink.ContextNode analyzerParentNode =
                theInkAnalyzer.FindNode(parentNodeData.Id);
            if (null == analyzerParentNode)
            {
                // The parent analyzer node does not exist yet. Create one.
                analyzerParentNode =
                    this.CreatePartiallyPopulatedNode(
                        documentNode.Parent, theInkAnalyzer);
            }
            else if (analyzerParentNode.PartiallyPopulated)
            {
                // The parent analyzer node exists and is partially populated. Add it
                // to the stack of nodes to fully populate.
                this.QueueNodeToPopulate(analyzerParentNode);
            }
            else
            {
                // The parent analyzer node exists and is fully populated. This
                // should not happen.
                throw new ApplicationException(
                    "The parent analyzer node is fully populated.");
            }

            // Create the partially populated node under its parent analyzer node.
            Microsoft.Ink.ContextNode analyzerNode =
                analyzerParentNode.CreatePartiallyPopulatedSubNode(
                    nodeData.Type, nodeData.Id, nodeData.Location);

            // Add the new node to the stack of nodes to fully populate.
            this.QueueNodeToPopulate(analyzerNode);

            return analyzerNode;
        }

Plateformes

Windows Vista

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.