Changes between Version 14 and Version 15 of FDORfc60

Timestamp:

Apr 13, 2011, 9:06:47 AM (13 years ago)

Author:

gregboone

Comment:

--

FDORfc60

@@ -400 +400 @@
 }}}
 
+==== Selecting Annotation Text Objects Through FDO ====
+
+Annotation Text instances owned by FDO features will be queryable and selectable through a new FDO Interface FdoIAnnotation. The FdoIAnnotation type will be considered a primary data type that can be accessed when reading FDO features, in the same manner that Raster, Association and Geometry are currently exposed. This will allow complex Annotation objects to be associated to logical features such as roads, pipes, etc.
+ 
+The FdoIAnnotation Interface allows clients that interact with and maintain Annotation text to do so through a single interface. Whereas the data that completely defines the set of Text Elements may be spread across several logical classes, accessing the Annotation will be managed through a more linear mechanism that allows users to manage data with worrying where that data is stored. 
+
+{{{
+class FdoIAnnotation : public FdoIDisposable
+{
+public:
+    FdoIEnvelope* TextEnvelope;
+    FdoString* DefaultBaseMapScale;
+    FdoExpression* DefaultTextValue;
+    FdoString* DefaultTextAttributesAsXml;
+    FdoAnnotationTextElementCollection* TextElements; 
+};
+}}}
+
+In this simplified view of FdoIAnnotation, we see how the Annotation’s text envelope, map scale, default values, and text elements are all available through a single interface.
+
+From FdoIAnnotation, users are able to retrieve the collection of text attributes associated to the annotation. This is possible by accessing the TextElements property and iterating over the returned !FdoAnnotationTextElement Collection. Each object in the collection represents a piece of individual Annotation text. 
+
+{{{
+class FdoAnnotationTextElement : public FdoIDisposable
+{
+public:
+    FdoByteArray*  Location;
+    FdoByteArray*  LeaderLine;
+    FdoExpression* TextValue;
+    FdoString*     TextAttributesAsXml;
+};
+}}}
+
+In order to access the above example data through the FDO logical model The FDO API’s !FdoFeatureReader class will be extended to allow Annotation properties to be queried by name and by index, in the same manner as Geometry and Raster properties are today queried. 
+
+{{{
+class FdoIFeatureReader: public FdoIReader
+{
+public:
+…
+…
+    FdoIAnnotation* GetAnnotation(FdoString* propertyName);
+    FdoIAnnotation* GetAnnotation(FdoInt32 index);
+};
+}}}
+
+
+===== Querying Features with Annotation Properties =====
+
+Using the above Road/!RoadAnnotation Example, here is an example of how Annotation properties would be queried from an FDO data store.
+
+{{{
+// Create a select command to retrieve Road features and its associated Annotations
+FdoISelectP selectCmd = (FdoISelect*)conn->CreateCommand(FdoCommandType_Select); 
+selectCmd->SetFeatureClassName(L"Road");
+
+// Add the class properties to the selection set, including the Annotation property
+FdoIdentifierCollectionP props =  selectCmd->GetPropertyNames();
+props->Add(FdoIdentifierP(FdoIdentifier::Create(L"FeatId")));
+props->Add(FdoIdentifierP(FdoIdentifier::Create(L"Geometry")));
+props->Add(FdoIdentifierP(FdoIdentifier::Create(L"Name")));
+props->Add(FdoIdentifierP(FdoIdentifier::Create(L"Width")));
+props->Add(FdoIdentifierP(FdoIdentifier::Create(L"Annotation")));
+
+// The selection can be arbitrarily filtered against
+FdoFilterP filter = FdoFilter::Parse(L"FeatId > 100");
+selectCmd->SetFilter(filter);
+
+// Execute the command and get a feature reader that points to the retrieved records
+FdoIFeatureReaderP reader = selectCmd->Execute();
+while (reader->ReadNext())
+{
+    // Get the Annotation property by name
+    FdoPtr<FdoIAnnotation> annotation = reader->GetAnnotation(L"Annotation");
+
+    // The annotation will have an envelope and default properties, some
+    // or all of which may be NULL. Envelope is a Geometry ByteArray. The
+    // Default Text will be an expression that can be evaluated as any
+    // database value
+    FdoByteArrayP envelope = annotation->GetEnvelope();
+    FdoExpressionP defaultText = annotation->GetDefaultTextValue();
+    FdoStringP defaultTextAttributes = annotation->GetDefaultTextAttibutesAsXml();
+    const char* charArray = (const char*)textAttributes;
+    
+    // The TextAttributes would be an XML string that needs to be streamed into memory
+    // and then Read into the XML API class FdoTextElementAttributes
+    FdoIoMemoryStreamP stream = FdoIoMemoryStream::Create();
+    stream->Write( (FdoByte*) charArray, strlen(charArray) );
+    stream->Reset();
+
+    // Create the XML API class that allows programatic access to the XML properties
+    // and read the XML stream into the corresponding classes.
+    FdoTextElementAttributesP defaultAttributes = FdoTextElementAttributes::Create();
+    defaultAttributes->ReadXml(stream);
+
+    // Each Annotation has 0...n Text Elements that are the actual text values
+    FdoAnnotationTextElementCollectionP textElements = annotation->GetTextElements();
+    for (FdoInt32 i=0; i<textElements->GetCount(); i++)
+    {
+        // Get the nth Text Element and read its values
+        FdoAnnotationTextElementP textElement = textElements->GetItem(i);
+        FdoExpressionP textValue = textElement->GetTextValue();
+        FdoByteArrayP location = textElement->GetLocation();
+        FdoByteArrayP leader = textElement->GetLeaderLine();
+
+        // As seen above, the XML text will need to be parsed into its API clases
+        FdoStringP textAttributes = textElement->GetTextAttributesAsXml();
+        if (textAttributes != L"")
+        {
+            const char* charArrayA = (const char*)textAttributes;
+            FdoIoMemoryStreamP streamA = FdoIoMemoryStream::Create();
+            streamA->Write( (FdoByte*) charArrayA, strlen(charArrayA) );
+            streamA->Reset();
+
+            FdoTextElementAttributesP attributes = FdoTextElementAttributes::Create();
+            attributes->ReadXml(streamA);
+        }
+    }
+}
+}}}
+