IPaper::Laden

In de volgende C++-voorbeeldcode ziet u hoe u de bestaande stroom in de opslag opent, nieuwe papiereigenschappen leest en deze vervolgens instelt als de huidige waarden voor COPaper.

Hier volgt de methode IPaper::Load uit Paper.cpp.

STDMETHODIMP COPaper::CImpIPaper::Load(
                 SHORT nLockKey,
                 IStorage* pIStorage)
  {
    HRESULT hr = E_FAIL;
    IStream* pIStream;
    INKDATA* paInkData;
    ULONG ulToRead, ulReadIn;
    LONG lNewArraySize;
    PAPER_PROPERTIES NewProps;

    if (OwnThis())
    {
      if (m_bLocked && m_cLockKey == nLockKey && NULL != pIStorage)
      {
       // Open the "PAPERDATA" stream where the paper data is stored.
        hr = pIStorage->OpenStream(
               STREAM_PAPERDATA_USTR,
               0,
               STGM_READ | STGM_DIRECT | STGM_SHARE_EXCLUSIVE,
               0,
               &pIStream);
        if (SUCCEEDED(hr))
        {
          // Obtained paper data stream. Read the Paper Properties.
          ulToRead = sizeof(PAPER_PROPERTIES);
          hr = pIStream->Read(
                           &NewProps,
                           ulToRead,
                           &ulReadIn);
          if (SUCCEEDED(hr) && ulToRead != ulReadIn)
            hr = E_FAIL;
          if (SUCCEEDED(hr))
          {
            // Handle the different versions of ink data format.
            switch (NewProps.lInkDataVersion)
            {
              case INKDATA_VERSION10:
                // Allocate an ample-sized ink data array.
                lNewArraySize = NewProps.lInkArraySize + 
                                               INKDATA_ALLOC;
                paInkData = new INKDATA[(LONG) lNewArraySize];
                if (NULL != paInkData)
                {
                  // Delete the old ink data array.
                  delete [] m_paInkData;

                  // Assign the new array.
                  m_paInkData = paInkData;
                  m_lInkDataMax = lNewArraySize;

                  // Read the complete array of Ink Data.
                  ulToRead = NewProps.lInkArraySize * sizeof(INKDATA);
                  hr = pIStream->Read(m_paInkData, 
                                      ulToRead, &ulReadIn);
                  if (SUCCEEDED(hr) && ulToRead != ulReadIn)
                    hr = E_FAIL;
                  if (SUCCEEDED(hr))
                  {
                    // Set COPaper to use the new PAPER_PROPERTIES
                    // data.
                    m_lInkDataEnd = NewProps.lInkArraySize-1;
                    m_crWinColor = NewProps.crWinColor;
                    m_WinRect.right = NewProps.WinRect.right;
                    m_WinRect.bottom = NewProps.WinRect.bottom;

                    // Copy the new properties into current 
                    // properties.
                    memcpy(
                      &m_PaperProperties,
                      &NewProps,
                      sizeof(PAPER_PROPERTIES));
                  }
                }
                else
                  hr = E_OUTOFMEMORY;
                break;
              default:
                hr = E_FAIL;  // Bad version.
                break;
            }
          }

          // Release the stream.
          pIStream->Release();
        }
      }

      UnOwnThis();
    }

    // Notify other connected clients that Paper is now loaded.
    // If Paper not loaded, then erase to a safe, empty ink data 
    // array.
    if (SUCCEEDED(hr))
      m_pBackObj->NotifySinks(PAPER_EVENT_LOADED, 0, 0, 0, 0);
    else
      Erase(nLockKey);

    return hr;
  }

Nu wordt de methode IStorage::OpenStream aangeroepen om de bestaande stream te openen in de opslag met de naam PAPERDATA. Toegangsmodusvlagmen zijn alleen-lezen, directe en niet-gedeelde exclusieve toegang. Wanneer de stream is geopend, wordt de methode IStream::Read aangeroepen om de PAPER_PROPERTIES structuur te lezen. Als de waarde die daadwerkelijk wordt gelezen niet gelijk is aan de aangevraagde hoeveelheid, wordt de belastingsbewerking afgebroken en wordt E_FAIL geretourneerd. Als de indelingsversie in de nieuw gelezen PAPER_PROPERTIES niet wordt herkend, wordt de laadbewerking afgebroken en wordt Laden E_FAIL geretourneerd.

Met een geldige versie van de inktgegevensindeling wordt de grootte van de nieuwe inktgegevensmatrix uit de PAPER_PROPERTIES die is gelezen, gebruikt om een nieuwe inktgegevensmatrix van de vereiste grootte toe te wijzen. De bestaande inktgegevens worden verwijderd en de bijbehorende gegevens gaan verloren. Als deze gegevens waardevol waren, moeten deze zijn opgeslagen voordat Load werd aangeroepen. Nadat de nieuwe matrix is toegewezen, wordt IStream::Read opnieuw aangeroepen om de gegevens uit de stroom in de matrix te lezen. Als deze aanroep slaagt, worden de waarden in de zojuist gelezen papiereigenschappen gebruikt als de huidige waarden voor COPaper.

Tijdens deze laadbewerking werd een tijdelijke PAPER_PROPERTIES structuur, NewProps, gebruikt voor het opslaan van de nieuwe eigenschappen die zijn gelezen. Als alles slaagt met de belasting, wordt NewProps gekopieerd naar de PAPER_PROPERTIES structuur, m_PaperProperties. Net als voorheen wordt de IStream- niet meer vereist nadat laden is voltooid, wordt de IStream--aanwijzer vrijgegeven.

Als er een fout optreedt aan het einde van Laden, wordt de matrix met inktgegevens gewist omdat deze mogelijk beschadigde gegevens bevat.

Als er geen fout optreedt aan het einde van Load, wordt de client IPaperSink::Loaded methode aangeroepen in de interne methode COPaper NotifySinks om de client te informeren dat de laadbewerking is voltooid. Dit is een belangrijke melding voor de client, omdat deze nieuwe geladen inktgegevens moeten worden weergegeven. Deze melding maakt aanzienlijk gebruik van verbindingsbare objectfuncties in COPaper.