Dela via

Exempel på bläckserialisering

Det här exemplet visar hur du serialiserar och deserialiserar bläck i olika format. Programmet representerar ett formulär med fält för att ange förnamn, efternamn och signatur. Användaren kan spara dessa data som pure ink serialized format (ISF), Extensible Markup Language (XML) med hjälp av base64-kodad ISF eller HTML, som refererar till pennanteckningar i en base64-kodad GIF-bild (Fortified Graphics Interchange Format). Programmet gör det också möjligt för användaren att öppna filer som har sparats som XML- och ISF-format. ISF-formatet använder utökade egenskaper för att lagra förnamn och efternamn, medan XML- och HTML-formaten lagrar den här informationen i anpassade attribut.

Det här exemplet stöder inte inläsning från HTML-formatet eftersom HTML inte är lämpligt för lagring av strukturerade data. Eftersom data är uppdelade i namn, signatur och så vidare krävs ett format som bevarar den här separationen, till exempel XML eller någon annan typ av databasformat.

HTML är mycket användbart i en miljö där formatering är viktigt, till exempel i ett ordbearbetningsdokument. HTML-koden som sparas av det här exemplet använder förstärkta GIF-filer. Dessa GIF-filer har ISF inbäddad i dem, vilket bevarar den fullständiga återgivningen av pennanteckningen. Ett ordbehandlingsprogram kan spara ett dokument som innehåller flera typer av data, till exempel bilder, tabeller, formaterad text och pennanteckning som sparats i ETT HTML-format. Den här HTML-koden återges i webbläsare som inte känner igen pennanteckningar. Men när det läses in i ett program som är ink-aktiverat är den fullständiga återgivningen av den ursprungliga pennanteckningen tillgänglig och kan återges, redigeras eller användas för igenkänning.

Följande funktioner används i det här exemplet:

Samla bläck

Börja med att referera till Tablet PC-API:et, som installeras med Windows Vista och Windows XP Tablet PC Edition Software Development Kit (SDK).

using Microsoft.Ink;

Konstruktorn skapar och aktiverar en InkCollector, ic, för formuläret.

ic = new InkCollector(Signature.Handle);
ic.Enabled = true;

Spara en fil

Metoden SaveAsMenu_Click hanterar dialogrutan Spara som, skapar en filström där du kan spara pennanteckningsdata och anropar den save-metod som motsvarar användarens val.

Spara till en ISF-fil

I metoden SaveISF läggs värdena för för- och efternamn till i ExtendedProperties-egenskapen hos InkCollector-objektets Ink-egenskap innan pennanteckningen serialiseras och skrivs till filen. När bläcket har serialiserats tas för- och efternamnsvärdena bort från Ink-objektets ExtendedProperties-egenskap.

byte[] isf;

// This is the ink object which is serialized
ExtendedProperties inkProperties = ic.Ink.ExtendedProperties;

// Store the name fields in the ink object
// These fields roundtrip through the ISF format
// Ignore empty fields since strictly empty strings 
//       cannot be stored in ExtendedProperties.
if (FirstNameBox.Text.Length > 0)
{
    inkProperties.Add(FirstName, FirstNameBox.Text);
}
if (LastNameBox.Text.Length > 0)
{
    inkProperties.Add(LastName, LastNameBox.Text);
}

// Perform the serialization
isf = ic.Ink.Save(PersistenceFormat.InkSerializedFormat);

// If the first and last names were added as extended
// properties to the ink, remove them - these properties
// are only used for the save and there is no need to
// keep them around on the ink object.
if (inkProperties.DoesPropertyExist(FirstName))
{
    inkProperties.Remove(FirstName);
}
if (inkProperties.DoesPropertyExist(LastName))
{
    inkProperties.Remove(LastName);
}

// Write the ISF to the stream
s.Write(isf,0,isf.Length);

Spara till en XML-fil

I metoden SaveXML används ett XmlTextWriter--objekt för att skapa och skriva till ett XML-dokument. Med hjälp av metoden Ink objektets Save konverteras först bläcket till en base64-kodad Ink Serialized Format-bytearray, och sedan konverteras bytearrayen till en sträng som ska skrivas till XML-filen. Textdata från formuläret skrivs också ut till XML-filen.

// Get the base64 encoded ISF
base64ISF_bytes = ic.Ink.Save(PersistenceFormat.Base64InkSerializedFormat);

// Convert it to a String
base64ISF_string = utf8.GetString(base64ISF_bytes);

// Write the ISF containing node to the XML
xwriter.WriteElementString("Ink", base64ISF_string);

// Write the text data from the form
// Note that the names are stored as XML fields, rather
// than custom properties, so that these properties can 
// be most easily accessible if the XML is saved in a database.
xwriter.WriteElementString("FirstName",FirstNameBox.Text);
xwriter.WriteElementString("LastName",LastNameBox.Text);

Spara till en HTML-fil

Metoden SaveHTML använder avgränsningsrutan för samlingen Strokes för att testa förekomsten av en signatur. Om signaturen existerar konverteras den till det skyddade GIF-formatet med hjälp av pennanteckningsobjektets metod Spara och sparas i en fil. GIF-filen refereras sedan till i HTML-filen.

if (ic.Ink.Strokes.GetBoundingBox().IsEmpty)
{
   MessageBox.Show("Unable to save empty ink in HTML persistence format.");
}
else
{
    FileStream gifFile;
    byte[] fortifiedGif = null;
    ...

    // Create a directory to store the fortified GIF which also contains ISF
    // and open the file for writing
    Directory.CreateDirectory(nameBase + "_files");
    using (FileStream gifFile = File.OpenWrite(nameBase + "_files\\signature.gif"))
    {

        // Generate the fortified GIF representation of the ink
        fortifiedGif = ic.Ink.Save(PersistenceFormat.Gif);

        // Write and close the gif file
        gifFile.Write(fortifiedGif, 0, fortifiedGif.Length);
    }

Läser in en fil

Metoden OpenMenu_Click hanterar dialogrutan Öppna, öppnar filen och anropar den inläsningsmetod som motsvarar användarens val.

Läser in en ISF-fil

Metoden LoadISF läser den tidigare skapade filen och konverterar Byte-arrayen till bläck med Ink-objektets Load-metod. Ink-insamlaren är tillfälligt inaktiverad för att tilldela Ink-objektet till den. Metoden LoadISF kontrollerar sedan ink-objektets ExtendedProperties-egenskap för för- och efternamnssträngarna.

Ink loadedInk = new Ink();
byte[] isfBytes = new byte[s.Length];

// read in the ISF
s.Read(isfBytes, 0, (int) s.Length);

// load the ink into a new ink object
// After an ink object has been "dirtied" it can never load ink again
loadedInk.Load(isfBytes);

// temporarily disable the ink collector and swap ink objects
ic.Enabled = false;
ic.Ink = loadedInk;
ic.Enabled = true;

// Repaint the inkable region
Signature.Invalidate();

ExtendedProperties inkProperties = ic.Ink.ExtendedProperties;

// Get the raw data out of this stroke's extended
// properties list, using the previously defined 
// Guid as a key to the extended property.
// Since the save method stored the first and last
// name information as extended properties, this
// information can be remove now that the load is complete.
if (inkProperties.DoesPropertyExist(FirstName))
{
    FirstNameBox.Text = (String) inkProperties[FirstName].Data;
    inkProperties.Remove(FirstName);
}
else
{
    FirstNameBox.Text = String.Empty;
}

if (inkProperties.DoesPropertyExist(LastName))
{
    LastNameBox.Text = (String) inkProperties[LastName].Data;
    inkProperties.Remove(LastName);
}
else
{
    LastNameBox.Text = String.Empty;
}

Läser in en XML-fil

Metoden LoadXML läser in en tidigare skapad XML-fil, hämtar data från ink-noden och konverterar data i noden till pennanteckningar med hjälp av metoden Ink-objektets Load. InkCollector- inaktiveras tillfälligt för att tilldela ink-objektet till det. Signaturrutan är ogiltig och för- och efternamnsinformationen hämtas från XML-dokumentet.

// This object encodes our byte data to a UTF8 string
UTF8Encoding utf8 = new UTF8Encoding();

XmlDocument xd = new XmlDocument();
XmlNodeList nodes;
Ink loadedInk = new Ink();

// Load the XML data into a DOM
xd.Load(s);

// Get the data in the ink node
nodes = xd.GetElementsByTagName("Ink");

// load the ink into a new ink object
// After an ink object has been "dirtied" it can never load ink again
if (0 != nodes.Count)
    loadedInk.Load(utf8.GetBytes(nodes[0].InnerXml));

// temporarily disable the ink collector and swap ink objects
ic.Enabled = false;
ic.Ink = loadedInk;
ic.Enabled = true;

// Repaint the inkable region
Signature.Invalidate();

// Get the data in the FirstName node
nodes = xd.GetElementsByTagName("FirstName");
if (0 != nodes.Count)
{
    FirstNameBox.Text = nodes[0].InnerXml;
}
else
{
    FirstNameBox.Text = String.Empty;
}

// Get the data in the LastName node
nodes = xd.GetElementsByTagName("LastName");
if (0 != nodes.Count)
{
    LastNameBox.Text = nodes[0].InnerXml;
}
else
{
    LastNameBox.Text = String.Empty;
}

Stänga formuläret

Formulärets metod Dispose tar bort objektet InkCollector.

 

 

  • Last updated on