Konvertieren eines Freihandobjekts in Freihand

Implementierung der Konvertierung von einem Freihandobjekt (tInk) in Freihand.

So konvertieren Sie von einem Freihandobjekt in Freihand

1. Verwenden Sie die IPersistStream-Schnittstelle , um den Inhalt des Text-Freihandobjekts in einen Stream zu schreiben. Das Text-Freihandobjekt verwendet das serialisierte Freihandformat, um in den Dampf zu schreiben.
2. Lesen Sie den Inhalt des Datenstroms in ein BYTE-Array.
3. Verwenden Sie die Load-Methode des InkDisp-Objekts, um den Inhalt des Datenstroms in das InkDisp-Objekt zu laden.

Beispiel für Freihandobjekt zu Freihandobjekt

Das folgende Codefragment konvertiert ein Freihandobjekt in Freihand.

Zunächst ruft der Code ein Text-Freihandobjekt ab.

/* Create a variable to hold the text ink object */
CComPtr<IInkObject *> spITextInk;

/* Obtain the text ink object */

Anschließend erstellt der Code einen Zeiger für den Stream, der den Inhalt des Text-Freihandobjekts enthält.

// Create a Stream pointer to hold the saved object
CComPtr<IStream *> spStream = NULL; 

Anschließend ruft der Code die IPersistStream-Schnittstelle aus dem Text-Freihandobjekt ab.

// Declare the IPersistStream to be used for retrieving the saved data from the text ink
CComPtr<IPersistStream *> spIPersistStream = NULL;
// Get the actual IPersistStream interface off of the TextInk
HRESULT hr = pITextInk->QueryInterface(IID_IPersistStream, (void **)&spIPersistStream);
ASSERT(SUCCEEDED(hr) && spIPersistStream);

Anschließend verwendet der Code die IPersistStream-Schnittstelle , um den Inhalt des Text-Freihandobjekts im Stream zu speichern.

if( SUCCEEDED(hr) && pIPersistStream )
{
    // Create the stream 
    if( SUCCEEDED(hr=CreateStreamOnHGlobal(NULL, TRUE, &spStream)) && spStream )
    {
        // Save the TextInk through IPersistStream Interface to the IStream
        hr = spIPersistStream->Save(spStream, FALSE);
    }
}

Anschließend erstellt der Code ein InkCollector-Objekt , erstellt ein InkDisp-Objekt für den InkCollector, fügt den InkCollector an das Anwendungsfenster an und aktiviert die Freihandauflistung für den InkCollector.

// Now create an InkCollector object along with InkDisp Object
if( SUCCEEDED(hr) && spStream)
{
    CComPtr<IInkCollector *> spIInkCollector;
    CComPtr<IInkDisp *> spIInkDisp = NULL;

    // Create the InkCollector object.
    hr = CoCreateInstance(CLSID_InkCollector, 
        NULL, CLSCTX_INPROC_SERVER, 
        IID_IInkCollector, 
        (void **) &spIInkCollector);
    if (FAILED(hr)) 
        return -1;

    // Get a pointer to the Ink object
    hr = spIInkCollector->get_Ink(&spIInkDisp);
    if (FAILED(hr)) 
        return -1;

    // Tell InkCollector the window to collect ink in
    hr = spIInkCollector->put_hWnd((long)hwnd);
    if (FAILED(hr)) 
        return -1;

    // Enable ink input in the window
    hr = spIInkCollector->put_Enabled(VARIANT_TRUE);
    if (FAILED(hr)) 
        return -1;

Anschließend ruft der Code die Größe des Datenstroms ab und erstellt ein sicheres Array, das den Inhalt des Datenstroms enthält.

    // Now create a variant data type based on the IStream data
    const LARGE_INTEGER li0 = {0, 0};
    ULARGE_INTEGER uli = {0,0};

    // Find the size of the stream
    hr = spStream->Seek(li0, STREAM_SEEK_END, &uli);
    ASSERT(0 == uli.HighPart);
    DWORD dwSize = uli.LowPart;

    // Set uli to point to the beginning of the stream.
    hr=spStream->Seek(li0, STREAM_SEEK_SET, &uli);
    ASSERT(SUCCEEDED(hr));

    // Create a safe array to hold the stream contents
    if( SUCCEEDED(hr) )
    {
        VARIANT vtData;
        VariantInit(&vtData);
        vtData.vt = VT_ARRAY | VT_UI1;

        vtData.parray = ::SafeArrayCreateVector(VT_UI1, 0, dwSize);
        if (vtData.parray)
        {

Schließlich greift der Code auf das sichere Array zu und verwendet die Load-Methode des InkDisp-Objekts, um die Freihandeingabe aus dem Array zu laden.

            DWORD dwRead = 0;
            LPBYTE pbData = NULL; 

            if (SUCCEEDED(::SafeArrayAccessData(vtData.parray, (void**)&pbData)))
            {
                // Read the data from the stream to the varian data and load that into an InkDisp object
                if (TRUE == spStream->Read(pbData, uli.LowPart, &dwRead)
                    && SUCCEEDED(spIInkDisp->Load(vtData)))
                {
                    hr = S_OK;
                }
                ::SafeArrayUnaccessData(vtData.parray);
            }
            ::SafeArrayDestroy(vtData.parray);
        }
    }
}