DynamicRenderer.EnableDataCache, propriété

Article
11/05/2008

Mise à jour : November 2007

Obtient ou définit une valeur qui indique si la mise en cache de données est activée pour l'objet DynamicRenderer.

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

Syntaxe

'Déclaration
Public Property EnableDataCache As Boolean
'Utilisation
Dim instance As DynamicRenderer
Dim value As Boolean

value = instance.EnableDataCache

instance.EnableDataCache = value

public bool EnableDataCache { get; set; }

public:
property bool EnableDataCache {
    bool get ();
    void set (bool value);
}

/** @property */
public boolean get_EnableDataCache()
/** @property */
public  void set_EnableDataCache(boolean value)

public function get EnableDataCache () : boolean
public function set EnableDataCache (value : boolean)

Valeur de propriété

Type : System.Boolean
true si la mise en cache de données est activée ; sinon false.

Notes

Affecter la valeur true à la propriété EnableDataCache vous permet de gérer la situation lorsque des processus lents bloquent la file d'attente de sortie. Si la fenêtre est invalidée pendant un moment après le dessin de traits par l'objet DynamicRenderer, un délai peut s'écouler avant que les traits collectés puissent être à nouveau dessinés. En plaçant les traits du DynamicRenderer en cache, ceux-ci peuvent être redessinés via un appel à la méthode Refresh. Toutefois, une fois que les traits sont collectés, libérez-les du cache en appelant la méthode ReleaseCachedData. En général, cette action se produit dans la méthode CustomStylusDataAdded.

Il est également utile d'affecter la valeur true à la propriété EnableDataCache lorsque vous souhaitez afficher des traits à mesure qu'ils sont dessinés, mais uniquement lorsque vous les avez utilisés et lorsque vous n'avez plus besoin de les stocker. Dans ce cas, stockez les identificateurs de données dans le paramètre data de la méthode CustomStylusDataAdded, puis libérez les données lorsque vous n'avez plus besoin des traits mis en cache.

Si cette propriété a la valeur true, vous devez appeler la méthode ReleaseCachedData pour les traits stockés dans l'objet collectant l'entrée manuscrite. Si elle a la valeur false, il n'est pas nécessaire d'appeler la méthode ReleaseCachedData. L'inconvénient de la valeur false est que les données de trait qui ont été initialement restituées dynamiquement, puis invalidées par diverses opérations ne sont pas restituées tant que les données de trait n'ont pas atteint l'objet de collecte d'entrée manuscrite et n'y sont pas restituées.

L'affectation de la valeur false efface les données en mémoire cache. Ainsi, une exception d'argument est levée lorsque le code appelle la méthode ReleaseCachedData pour tout objet DynamicRendererCachedData en attente dans la file d'attente suite à l'affectation de la valeur false à la propriété EnableDataCache.

Pour plus d'informations sur cette propriété, consultez Dynamic-Renderer Plug-ins.

Exemples

Cet exemple C# développe le RealTimeStylus Ink Collection Sample fourni dans la section technologie Tablet and Touch du Kit de développement logiciel Windows. Après l'activation du DynamicRenderer, theDynamicRenderer, la valeur true est affectée à la propriété EnableDataCache. La propriété DataInterest est modifiée de sorte que DataInterestMask soit ajouté. La méthode CustomStylusDataAdded recherche des données avec l'identificateur de champ DynamicRendererCachedDataGuid, puis libère les données à l'aide de la propriété CachedDataId des données.

// ...
private void InkCollection_Load(object sender, System.EventArgs e)
{
    // ...
    
    // Enable the real time stylus and the dynamic renderer
    myRealTimeStylus.Enabled = true;
    myDynamicRenderer.Enabled = true;  

    // Enable caching. If a refresh happens during inking, then
    // the stroke will still be displayed.  However, we have to 
    // release the cached data later.
    myDynamicRenderer.EnableDataCache = true;
    
    // ...
}
// ...
public DataInterestMask DataInterest
{
    get
    {
        return DataInterestMask.StylusDown |
               DataInterestMask.Packets |
               DataInterestMask.StylusUp |
               DataInterestMask.Error |
               DataInterestMask.CustomStylusDataAdded;
    }
}
public void CustomStylusDataAdded(RealTimeStylus sender, CustomStylusData data)
{
    // Release any cached data that's shown up.
    if (data.CustomDataId == DynamicRenderer.DynamicRendererCachedDataGuid)
    {
        DynamicRendererCachedData cachedData = (DynamicRendererCachedData) data.Data;
       cachedData.DynamicRenderer.ReleaseCachedData(cachedData.CachedDataId);
    }
}
// ...

Cet exemple C# place les données d'un objet DynamicRenderer en cache. Cela garantit qu'une invalidation de fenêtre n'efface pas les traits. L'exemple efface ensuite les traits par programme. Après avoir activé l'objet DynamicRenderer, theDynamicRenderer, la propriété EnableDataCache a la valeur true. Dans le gestionnaire d'événements Paint (page pouvant être en anglais), l'exemple appelle DynamicRenderer.Refresh pour redessiner les données de stylet dans le cache. La propriété DataInterest est modifiée de sorte que DataInterestMask soit ajouté. La méthode CustomStylusDataAdded recherche des données avec l'identificateur de champ DynamicRendererCachedDataGuid et stocke l'identificateur de données dans un ArrayList, cachedIds (page pouvant être en anglais). La méthode ClearStrokes appelle ReleaseCachedData sur tous les identificateurs dans cachedIds, puis appelle Refresh (page pouvant être en anglais) sur le Control (page pouvant être en anglais).

using Microsoft.StylusInput;
using Microsoft.StylusInput.PluginData;
// ...
public class InkCollection : Form, IStylusAsyncPlugin
{ 
    private RealTimeStylus theRealTimeStylus;
    private DynamicRenderer theDynamicRenderer;
    private ArrayList cachedIds = new ArrayList();
// ...
    private void TempInkCollection_Load(object sender, System.EventArgs e)
    {
        theDynamicRenderer = new DynamicRenderer(this);
        theRealTimeStylus = new RealTimeStylus(this, true);

        ' Add the dynamic renderer to the synchronous plugin notification chain.
        ' Synchronous notifications occur on the pen thread.
        theRealTimeStylus.SyncPluginCollection.Add(theDynamicRenderer)

        // Add the dynamic renderer to the synchronous plugin notification chain.
        // Synchronous notifications occur on the pen thread.
        myRealTimeStylus.SyncPluginCollection.Add(myDynamicRenderer);

        // Add the form to the asynchronous plugin notification chain.  This plugin
        // will be used to collect stylus data into an ink object.  Asynchronous
        // notifications occur on the UI thread.
        myRealTimeStylus.AsyncPluginCollection.Add(this);

        // Enable the real time stylus and the dynamic renderer
        myRealTimeStylus.Enabled = true;
        myDynamicRenderer.Enabled = true;  

        // Enable caching. If a refresh happens during inking, then
        // the stroke will still be displayed.  However, we have to 
        // release the cached data later.
        myDynamicRenderer.EnableDataCache = true;
    }
// ...
    private void InkCollection_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
    {
        // Refresh the dynamic renderer, since it's possible that a stroke is being
        // collected at the time Paint occurs.  In this case, the portion of the stroke
        // that has already been collected will need to be redrawn.
        theDynamicRenderer.ClipRectangle = e.ClipRectangle;
        theDynamicRenderer.Refresh();
    }
// ...
    public DataInterestMask DataInterest
    {
        get
        {
            return DataInterestMask.CustomStylusDataAdded;
        }
    }

    public void CustomStylusDataAdded(RealTimeStylus sender, CustomStylusData data)
    {
        // Release any cached data that's shown up.
        if (data.CustomDataId == DynamicRenderer.DynamicRendererCachedDataGuid)
        {
            DynamicRendererCachedData cachedData = (DynamicRendererCachedData) data.Data;
            cachedIds.Add(cachedData.CachedDataId);
        }
    }
// ...
    private void ClearStrokes()
    {
        // Release all data
        foreach int dataId in cachedIds
        {
            theDynamicRenderer.ReleaseCachedData(dataId);
        }
        // Clear our stored list of Ids
        cachedIds.Clear();
        // Refresh the window
        this.Refresh()
    }
}

Cet exemple Microsoft Visual Basic .NET place les données d'un objet DynamicRenderer en cache. Cela garantit qu'une invalidation de fenêtre n'efface pas les traits. L'exemple efface ensuite les traits par programme. Après avoir activé l'objet DynamicRenderer, theDynamicRenderer, la propriété EnableDataCache a la valeur true. Dans le gestionnaire d'événements Paint (page pouvant être en anglais), l'exemple appelle DynamicRenderer.Refresh pour redessiner les données de stylet dans le cache. La propriété DataInterest est modifiée de sorte que DataInterestMask soit ajouté. La méthode CustomStylusDataAdded recherche des données avec l'identificateur de champ DynamicRendererCachedDataGuid et stocke l'identificateur de données dans un ArrayList, cachedIds (page pouvant être en anglais). La méthode ClearStrokes appelle ReleaseCachedData sur tous les identificateurs dans cachedIds, puis appelle Refresh (page pouvant être en anglais) sur le Control (page pouvant être en anglais).

Imports Microsoft.StylusInput
Imports Microsoft.StylusInput.PluginData
' ...
Public Class TempInkCollector
    Inherits System.Windows.Forms.Form
    Implements Microsoft.StylusInput.IStylusAsyncPlugin

    Private theRealTimeStylus As RealTimeStylus
    Private theDynamicRenderer As DynamicRenderer
    Private cachedIds As ArrayList = New ArrayList()
' ...
    Private Sub TempInkCollector_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        theDynamicRenderer = New DynamicRenderer(Me)
        theRealTimeStylus = New RealTimeStylus(Me, True)

        ' Add the dynamic renderer to the synchronous plugin notification chain.
        ' Synchronous notifications occur on the pen thread.
        theRealTimeStylus.SyncPluginCollection.Add(theDynamicRenderer)

        ' Add the form to the asynchronous plugin notification chain.  This plugin
        ' will be used to collect stylus data into an ink object.  Asynchronous
        ' notifications occur on the UI thread.
        theRealTimeStylus.AsyncPluginCollection.Add(Me)

        ' Enable the real time stylus and the dynamic renderer
        theRealTimeStylus.Enabled = True
        theDynamicRenderer.Enabled = True
        theDynamicRenderer.EnableDataCache = True
    End Sub
' ...
    Private Sub InkCollector_Paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles MyBase.Paint
        ' Refresh the dynamic renderer, since it's possible that a stroke is being
        ' collected at the time Paint occurs.  In this case, the portion of the stroke
        ' that has already been collected will need to be redrawn.
        theDynamicRenderer.ClipRectangle = e.ClipRectangle
        theDynamicRenderer.Refresh()
    End Sub
'...
    Overridable Overloads ReadOnly Property DataInterest() As DataInterestMask Implements IStylusAsyncPlugin.DataInterest
        Get
            Return DataInterestMask.CustomStylusDataAdded
        End Get
    End Property
    Public Sub CustomStylusDataAdded(ByVal sender As Microsoft.StylusInput.RealTimeStylus, ByVal data As Microsoft.StylusInput.PluginData.CustomStylusData) Implements Microsoft.StylusInput.IStylusAsyncPlugin.CustomStylusDataAdded
        If data.CustomDataId.Equals(DynamicRenderer.DynamicRendererCachedDataGuid) Then
            ' Convert to DynamicRendererCachedData
            Dim cachedData As DynamicRendererCachedData = data.Data
            ' Add to list of ids.
            cachedIds.Add(cachedData.CachedDataId)
        End If
    End Sub
' ...
    Private Sub ClearStrokes()
        ' Release all data
        Dim dataId As Integer
        For Each dataId In cachedIds
            theDynamicRenderer.ReleaseCachedData(dataId)
        Next
        ' Clear our stored list of Ids
        cachedIds.Clear()
        ' Refresh the window
        Me.Refresh()
    End Sub
End Class

Plateformes

Windows Vista, Windows XP SP2, Windows Server 2003

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.