CapeSoft xFiles 4
Documentation

• Introduction
• Requirements
• Online Code Generator
• Upgrading From xFiles 3       [NEW]
• Overview of xFiles 4 New Features    
• What is XML?
• Overview of the Classes        [NEW]
• Adding xFiles to an APP
• Adding xFiles to a Hand-Code Project      [UPDATED]
• Encoding: ANSI / Unicode
• Extended Name Attributes    [NEW - REALLY IMPORTANT]
• Setting Attributes at Runtime
• Using xFiles in Code
• Reading XML
  • Things you need to know to Load XML
  • Loading From an XML File into a Group, Queue or File
  • Loading From an XML String into a Group, Queue or File
  • Loading XML from a StringTheory object into a Clarion Structure
  • Loading XML from the Web into a Clarion Structure
  • Loading into a structure with a Pointer
  • Loading into a structure with a StringTheory pointer
  • Loading Parent and Child records at the same time
  • Adjusting data records before they are saved
  • Deformatting incoming XML fields
  • Loading an HTML Table into a Queue
  • Loading into a Table
  • Loading Arrays
• Creating XML
  • Saving a Clarion Structure to an XML file on the Disk
  • Saving a Clarion structure to an XML string in Memory
  • Saving a Clarion structure into a StringTheory object
  • Arrays
  • Formatting outgoing fields
    
  • Changing the Name of a Field in outgoing XML
  • Properties which can be set before a call to Save
  • Properties which can be set in SaveTweakFieldSettings
  • Methods which can be used during a Save
  • Using a View to create a filtered, sorted, nested, XML file
    
  • Including a binary file in outgoing XML
  • Handling Structures with Pointers
  • Storing a Queue Inside a Group
  • Storing multiple things in the same XML file
  • Saving Fields As Attributes
  • Adding Custom Text into the XML File
• xFilesTree - Tree Manipulations
• Background
• Attributes
• Children
• Result
• xFiles Template
• Some Practical Applications
  • Creating RSS Feed Files
  • Storing Global Settings in an XML file
  • Creating SOAP requests
  • Importing Large Files
• xCell Class
  • Introduction
  • Declare an Object
  • Reuse
  • WorkSheets
  • Printing
  • Styles
  • Columns
  • Rows
  • Cells
    • Date And Time Fields
  • Saving
  • Example
• Examples
• Classes
  • xFileXML Methods
  • xFileXML Properties
  • xFileLinkDLLmethods
  • xFileLinkDLL Properties
• Deriving a Class and Using in Your Apps
• Support
• Installation
• Distribution
• License & Copyright
• Version History

1. xFiles 4 makes use of the StringTheory and Reflection accessories. The global extensions for these need to be added to apps that have the xFiles global extension.
2. Hand-coded apps should note updated instructions.
3. There are new classes available, so check out the section Overview of the Classes to see what class is most appropriate to your situation. This also lists the different default settings between xFileXML and xFilesStream classes.

Converting an object from xFileXML to xFilesStream

• Adds a new Tree-Based parser (xFilesTree), while preserving the original Streaming based parser (xFilesStream)  [1]
• xFilesTree supports creating nested XML, to match JOINS in VIEWS.
• xFilesStream class has new LOAD and SAVE methods that support STRINGTHEORY objects (in addition to plain strings, and disk files.)
• xFilesStream class has support for Extended Name Attributes (attribute)
• xFilesStream class has simplified use of SetAsAttribute usage.

Advantages of XML

XML versus JSON

Global Extension

Local Extension

1. Add
   include('Reflection.Inc'),Once
   include('StringTheory.Inc'),Once
   include('xFiles.Inc'),Once
   
   to your main module
2. Add the xFiles, Reflection and StringTheory defines to your project. Set
   
   xFilesLinkMode=>1;StringTheoryLinkMode=>1;ReflectionLM=>1;xFilesDllMode=>0;StringTheoryDLLMode=>0;ReflectionDM=>0
   
   if the classes should be linked into the project, and
   
   xFilesLinkMode=>0;StringTheoryLinkMode=>0;ReflectionLM=>0;xFilesDllMode=>1;StringTheoryDLLMode=>1;ReflectionDM=>1
   
   
   if the object is exported from another DLL.
   
   Also make sure the _ABCDllMode_ and _ABCLinkMode_ defines are set appropriately for the project.
3. When you want to declare an xFiles object in a procedure you can declare it using the class name. For example;
   
   xml  xFilesStream
   
   If you wish to derive methods (see methods documentation) then declare it with the method (for example)
   
   xml         class(xFilesStream)
   AssignField   Procedure (Long DataStartPos,Long DataEndPos),Long, derived
               End
   
   and then add the derived procedure (adding your own code)
   
   xml.AssignField Procedure (Long DataStartPos,Long DataEndPos)
     Code
     parent.AssignField(DataStartPos,DataEndPos)
   
   For a full list of available classes and method declarations see the xfiles.inc file.

Loading

Saving

xFilesTree Class

Setting Attributes at Runtime

• Things you need to know to Load XML
• Loading From an XML File into a Group, Queue or File
• Loading From an XML String into a Group, Queue or File
• Loading XML from a StringTheory object into a Clarion Structure
• Loading XML from the Web into a Clarion Structure
• Loading into a structure with a Pointer
• Loading Parent and Child records at the same time
• Adjusting data records before they are saved
• Formatting or Deformatting incoming XML fields
• Loading an HTML Table into a Queue
• Loading into a Table

Things you need to know to load XML

Loading an XML File from the disk into a Clarion Structure

Loading an XML File from a string into a Clarion Structure

Loading XML from a StringTheory object into a Clarion Structure

Loading XML from the Web into a Clarion Structure

Loading into a structure with a pointer

Loading Parent and Child records at the same time

Adjusting incoming data records before they are saved

Deformating incoming XML fields

Loading an HTML Table into a Queue

Loading Into a Table

Loading Into Arrays

• Saving a Clarion Structure to an XML file on the Disk
• Saving a Clarion structure to an XML string in Memory
• Saving a Clarion structure into a StringTheory object
• Arrays
• Formatting outgoing fields
  
• Changing the Name of a Field in outgoing XML
• Properties which can be set before a call to Save
• Properties which can be set in SaveTweakFieldSettings
• Methods which can be used during a Save
• Using a View to create a filtered, sorted, XML file
• Including a binary file in outgoing XML
• Handling Structures with Pointers
• Storing a Queue Inside a Group
• Storing multiple things in the same XML file
• Saving Fields As Attributes
• Adding Custom Text into the XML File

Saving a Clarion Structure to an XML file on the Disk

Saving a Clarion structure to an XML string in Memory

Saving a Clarion structure to a StringTheory Object

Arrays

Formatting Outgoing Fields

Changing the Name of a Field in Outgoing XML

Properties which can be set before a call to Save (xFilesStream only)

Properties which can be set in SaveTweakFieldSettings (xFilesStream only)

Methods which can be used during a Save (xFilesStream only)

Using a View to create a filtered, sorted, nested, XML file

Including a Binary file in outgoing XML

Handling Structures with Pointers

Storing a Queue Inside a Group or Queue

Storing multiple things in the same XML file.

Saving Fields as Attributes

Adding Custom Text into the XML file

• Background
• Attributes
• Children
• Result

Background

Nodes

Attributes

Children

Result

• Global Extension Template
• Generic xFiles Template (to use an xFiles object)
• Export to/Import from XML Control Template

The Global xFiles Extension Template

Local xFiles Template (IncludexFilesObject - Use an xFiles Object)

xFiles provides a template to make it simple to add an object to a procedure. The value of adding the object via a template is that all the possible methods are generated, for easy embedding. If you are wanting to write embed code into methods, then use this template to declare the object. Otherwise simply declare the object in embed code as well.

General Tab

Do Not Generate This Object

If this option is on then the template will not generate the object, or any of it's methods.

Object Name

The name of the object in the procedure. If the object is alone in the procedure then use a simple name like XML. if there are multiple objects in the procedure, then give it a unique name.

Class Name

Select a class from the drop-down. Note that the xFileXML class is deprecated and should not be used for new objects.

xFileXML Tab

This tab is only offered for the xFileXML object, which is deprecated. For new code use the xFileStream or xFileTree class instead.

Disable All xFiles Features

To use the template:

• Right click on the procedure you wish to add an object to and Choose "extensions", then press the "insert" button.
• Choose "IncludexFilesObject - Use an xFiles object" from the 'Class xFiles - CapeSoft xFiles - Version x.xx" section.
• In the "This Object Name" field enter "xmlWriter".

The class details tab allows properties to be added to the class and methods to be added, overloaded or customised and provides access to the method and data embeds for the object.

Export to/Import from XML Control Template

You can populate this control template onto a window, and export a file/queue/group to a file from a button on the window.
  You can setup the following options in the control template:

• Local Data - the data source (typically this would be the name of the file to export - or the queue or group)
• XML File - the file to export the data to. You can use quotes or a variable name.
• Display Status - shows a message after exporting or importing the file.
• ThisWindow.Reset(1) - resets the window after loading the file, forcing your browses and fields to be refreshed.

• Remove File Prefix from field Labels - removes the file prefix from fields labels that are entered into the XML file. Note: these settings must match on import and export (if using a different instance of this control template to do the other import/export)
• Encoding method - allows you to select whether to use iso-8859-1, utf-8 or windows-1252. The default method is iso-8859-1, but you can force it to one of the others if you prefer.
• Set Logging to - allows you to force debug logging on or off - otherwise you can use the compile time settings that are in the classes (normally off).
• Customize Header and Footer - allows you to enter a customizable Header and or Footer (for things like RSS Feeds, etc).
• Field Type Overrides - if you don't want to save MEMOs and/or BLOBs into your XML file, then you can disable this with these checkboxes.
• CDATA Saving - you can encase your data in CDATA tags - you can select which field type you would like to do this for using these checkboxes

• Creating RSS Feed Files
• Storing Global Settings in an XML file
• Creating SOAP requests
• Using a View to create a filtered, sorted, XML file
• Formatting a field before it is saved to XML
• Storing multiple things in the same XML file
• Saving Fields As Attributes

Creating RSS Feed Files

Storing Global Settings in an XML file

Creating SOAP requests

Importing Large Files

• Introduction
• Declare an Object
• Encoding
• Reuse
• WorkSheets
• Styles
• Columns
• Rows
• Cells
• Formulas
• Saving
• Example

Introduction

Declare an Object

Reuse

Encoding

WorkSheets

Printing

Styles

Columns

Rows

Cells

Formulas

Saving

Example

xFileXML Properties

AddRecord

AddText

CCopy

Init

myQueue           queue
from                  string(80)
to                    string(80)
                  end
xmlFileName       string(260)
 CODE
 xmlFileName = 'myXmlFile.xml'
 thisFileXML.Init(myQueue, xmlFileName)

Load

xml               xFileXml
myQueue           queue
from                  string(80)
to                    string(80)
                  end

xmlFileName       string(260)

  CODE
  xmlFileName = 'myXmlFile.xml'
  xml.start()
  xml.SetTagCase(sf:caseLower)
  xml.Load(myQueue, xmlFileName,'table','record')

Save

Start

Generic File Loading and Saving

SaveBinData

LoadBinData

XML file modification and settings

CreateHeader

CreateFooter

DisableField

LoadTweakSettings

SaveTweakFieldSettings

SetAsAttribute

UseCharset

Record handling and management

Deriving an xFiles Class

Using the Derived Class in an App

• xCell
• Remove: ProtectObject and ProtectScenarios properties.

• xFilesStream
• Add: If a Group field is set as PRIVATE, then all fields inside the group are Private as well.
• Add: Support for REQUIRED attribute when saving.
• Fix: Nested GROUPs did not parse attributes correctly when doing a SAVE
• Fix: Field types were not parsed when SAVing.

• Internal: Updated to version 4.32 of Capexx templates.
• Add: Documentation: Deriving a Class and Using in Your Apps
• xFilesTree
  
• Fix: Cstring and PStrings used to clip values, now doesn't.
• xFilesStream
• Fix: Cstring and PStrings used to clip values, now doesn't.

• xFilesTree
  
• Change: Added support for boundryless arrays inside groups. See Loading Arrays
• Internal: Position method can take optional Offset parameter. FillField can take an Index parameter.

• xFilesTree
  
• Change: when loading, if RemovePrefix is set, then prefixes (namespaces) are removed from the XML tree node names after loading.
• Internal: Update to Capexx.tpw version 4.30

• NOTE: Requires Reflection 1.27 or later.
• xFilesStream
  
• Fix: Loading with MatchByNumber could fail.

• NOTE: Requires Reflection 1.26 or later.
• xFilesStream and xFilesTree
  
• Fix: Encoding in header part did not support st: Equate encoding for utf-8.
• xFilesStream
  
• Fix: Memos and Blobs could possible not load.
• Fix: Memos and Blobs were not CDATA Decoded on Load.

• NOTE: Requires StringTheory 3.58 or later, Reflection 1.23 or later.
• xFilesStream and xFilesTree
• Add: XMLToHTML method
• xFilesStream
• Fix: If Assigning a value to a (nested structure) not in the loading structure, then the nesting import could fail.
• xFilesPropertyClass
• Add: indent property
• xFilesTree
• Add: WithViewFieldNumber, Parse methods
• Add: Support for Demo Mode.
• Add: View supports Private attribute
• Add: SetType, SetPicture, SetAttribute methods.
• Internal: xFilesTableFieldsQueueType: renamed FieldNumber to ViewFieldNumber, added IsPrivate, Changed TagName to Cstring.
• Fix: off-by-1 error in ParseProcessingInstruction, ParseExclaim

• xFilesStream
• Fix: StartRecord had incorrect length if formatting was off. Affected xCell class (export to Excel).

• FilesStream
• Fix: AssignField method handles rf:StringTheoryJson, rf:StringTheoryXML, rf:StringJsonPtr, rf:StringXMLPtr, rf:CstringJsonPtr, rf:CstringXmlPtr, rf:StringXML and rf:CStringXML types.
• Fix: Better assessment of when a string is empty
• Fix: Injected extra space when saving structures that had record level attributes.
• Fix: _PrepareCurrentField supports rf:StringTheoryJson, rf:StringJsonPtr,rf:CstringJsonPtr,  rf:StringTheoryXML, rf:StringXml, rf:CstringXML, rf:StringXmlPtr, rf:CstringXmlPtr. (XML fields are not XMLEncoded).
• xFilesTree
• AssignValue method now clips strings, but not cstrings or pstrings.
• Fix: AssignValue, FillField method: support for rf:stringJson et al.

• Add: prefix property to xFileXML class for backward compatibility with NT11.

• Add: Documentation : Importing Large Files
• xFilesStream
  
• Add: AssignQueue Method
• xFilesTree
• Add Chunk property, SetChunk, GetChunk methods
• Fix: Memory leak in XmlTree Destruct not disposing attributes property

• xFileXML / xFilesStream
  
• Fix: non-blank StringTheory objects were excluded when DontSaveBlanks or DontSaeBlankNumbers was set.

• xFileXML / xFilesStream
  
• Fix: Only leaf nodes should be passed through the Decode method.

• xFileXML
• Fix: Use of derived instead of Virtual in declaration of some methods could cause issues in some Legacy app situations.
• All
• Fix: Legacy example app did not include xFiles.

• xFilesTree
• Changed: Extended string length for group and column names from 100 to rf:StringLen (currently 252 chars.)

• xFilesTree
• Add: support for Required extended attribute
• Add: AfterReflectionParse methods to allow embedding after a structure is parsed. Good for runtime tweaking of Reflection properties.
• Change: Load methods that take (structure, string, length) now take (structure, string, *length) to avoid ambiguous calls.
• Change: When Saving, if Base64 attribute, then do not force decimal encoding, or conversion to utf-8

• xFilesTree
• Fix: When loading, if Group is not in XML skip over all fields in group when reading.

• xCell
• Added SetSaveEncoding and SetDontUtfEncode methods.

• xFileXml / xFilesStream
• Fix: Could drop closing tag on opening record boundary in some edge cases, where formatting of output was off.
• 
  
• xCell
• Added SetIndentSize(size,CRLFString) method. as in xcell.SetIndentSize(2,'<13,10>') or xCell.SetIndentSize(0,'')

• xFileXml
• Fix: Better backward compatibility with ReplacementChar and PrefixChar

• xFilesTree
• Fix: Parsing the end of a DocType string, went one character too many.

• xFilesTree
• Fix: Load(Q,StringTheory,boundary,boundary) did not flow through the methods correctly.

• xFilesTree
• Add: support for <!Doctype type fields (xf:exclaim).

• xFileXML
• Add: Construct method, calls Start.
• Fix: IsGroup method did not allow for xf:CaseAny setting

• xFilesStream
• Fix: Worker was not clearing properties in _PrepareField method.

• xFilesStream
• Add: SetLoadEncoding method.
• Change: ValidateUpdateRecord no longer called when inserting into a queue. Use ValidateRecord in that circumstance.
• Removed: Prefix property. Replaced with GetPrefix and SetPrefix methods. (Uses the Reflection Prefix property).
• Renamed: IndentBy replaced with IndentSize.
• Renamed: _SetIndentSize method to SetIndentSize.
• Add: Methods to move xFilesStream and xFilesTree classes closer together: SetIndent, GetIndent, SetDemoMode, GetRecords, GetSkipRecords, SetSkipRecords, SetCRLF, ClearColumnDisabled.
• Fix: Memos and Blobs in Views did not respect SaveMemosAsCData and SaveBlobsAsCData properties.
• 
  
• xFilesTree
• Add: IndentSize, crlf properties to properties class.
• Add: GetPrefix, SetPrefix methods
• Add: SetIndentSize, SetIndent, GetIndent, SetCRLF, ClearColumnDisabled, SetDemoMode, GetRecords, GetSkipRecords, SetSkipRecords, methods.
• Add: SameMemosAsCData property (defaults to true)
• Add: Varieties of Load and Save methods to match xFilesStream methods.
• Add: ValidateUpdateMethod

• Remove: DontReplaceColons : Use SetDontReplaceColons instead
• Fix: xCell class replaced colons with underscores

• Add: DontSaveFalseBooleans property (SetDontSaveFalseBooleans method)
• Add: DontSaveBlankAttributes property  (SetDontSaveBlankAttributes method)
• Fix: Numeric field types set in ENA could be excluded from output.
• Internal: Some properties changed from Long to Byte

• Fix: XmlClarionClass: Better identifies multiple siblings of same name, to create Queues instead of Groups.
• Fix: HasSiblingsOfSameName could GPF.
• Fix: XMLTree used CString(10) instead of CString(100) for the groupname.

• Add: Over for DontUtf8Encode so as not to conflict with SendTo

• Version 4 initial release. See Upgrading From xFiles 3  and Overview of xFiles 4 New Features .
• Note: XmlClarion class is a work-in-progress.

• Remove: AppName property from class.
• Add Start and ErrorTrap methods to class.
• Fix: Do not ampersand decode when in CDATA

• Clarion 11.1 Install

• Fix: Regression: One of the ASSERT conditions was backwards.

• Add: XF:MaxParentNameSize equate.
• Add: ASSERTS to notify when XF:MaxFieldNameSize or XF:MaxParentNameSize are not big enough.

• Add: template generates _XFILES_ pragma

• Fix: In some places MaxPrefixLengthInXML was not respected, leading to mismatching of tags when loading.

• Add: RenameWorkSheet method.

• Fix: Avoid problems calling FreeGroupData and FreeQueueData if self.G or self.Q not set.
• Fix: Meta property not being set in xCell class, is saving XML to a string.
• Fix: For xCell objects make sure meta property is set to '<?mso-application progid="Excel.Sheet"?>'

• Fix: Badly formed XML comment could cause an index-out-of-range error.

• Fix: Add Tab as possible whitespace character when looking for CDATA
• Fix: Allow for whitespace inside data, between tags and CDATA section.

• Add: ValidateUpdateRecord method.

• Fix: self._indent = 0 added to Start method.
• Change: Internal group separator changed from . to *.

• Add: SaveEncoding and DontUtf8Encode properties to xCell class.
• Fix: Maximum column width allowed in Excel is 512
• Fix: Improvements to xCell Numeric method for strings with multiple commas.

• Fix: When exporting a VIEW, if the File Record was not BINDed _before_ setting Prop:Order then the prop:order would not be applied.

• Add: DontSaveBlankGroups property. Applies to DontSaveBlanks as well. (Inspired by Eric Lankreijer)
• Fix: Remapped XF:DWORD equate to Ulong not Long.

• Fix: Start method did not reset Prefix property.

• Add: Clarion11 to install.

• Change: When loading into a table, and UpdateFileOnLoad is false, and a duplicate is encountered, the Load no longer terminates, but proceeds to find other records that should be loaded.

• Fix: Saving in DemoMode got into an endless loop.

• Fix: Saving Groups got into an endless loop.

• Add: SaveRecords and SkipRecords properties.
• Add: Records property.
• Removed: TruncateIfNeeded method.
• Removed: MaxNumberOfRecords property. (This property was very strange. If you were using it contact us and we'll discuss what you should be doing.)

• Add: support for Underline in xCell SetStyleFont method. Courtesy of Simon Kempster.

• Add: support for Printing options added to xCell class. Courtesy of Rolf von Fintel.
• Fix: CleanFileName method returns clipped name.
• Fix: Blank Styles and Types are treated as omitted in calls to xCell.SetCell

• Add: Label property - used in trace method, makes it easier to debug nested objects.
• Add: self.CRLF to self.Meta property.
• Fix: Location of closing group tags could be misplaced with heavily nested groups. (This affected xCell class as well.)
• Refactor: _GroupName field changed to _GroupFieldNumber (since that's what it is.)
• Refactor: First parameter of DecGroups method removed. (Wasn't being used)
• Refactor: Improved indentation for xCell class.

• Fix: Regression: Some group tags were missing
• Fix: Regression: When AddArrayIndexToTag property was true, the closing number was always 0.

• Add: AddArrayIndexToTag property.
• Add: Support for Group Arrays when saving.
• Fix: xCell START method did not clear all the properties back to their default state.
• Refactor: SaveOneField method returns number of fields saved.
• Updated to Cape Template 4.11

• Add: Meta property to xfileXML class and xCell class.
• Add: XSLT and Meta properties cleared in Start method.
• Add: AddText method.
• Add: AddAtListStart, AddAtRecordStart, AddAtRecordEnd, AddAtListEnd Methods.
• Add: xCell meta property defaults to <?mso-application progid="Excel.Sheet"?>

• Add: xCell class, SetCellDate. SetCellTime and SetCellDateTime methods.
• Document: Updated section on writing date and time values using xCell class.

• Add: xCell class, SetCell method, correct case of DateTime type.
• Fix: xCell class, SetCell method, defaulted unknown types to String.
• Document: Added section on writing date and time values using xCell class.

• Fix: SET not called when Saving a Table and the table does not have a primary key. (Courtesy of Daniel Clemente Lopez)

• Refactor: All default values moved to Start method, called automatically by Construct.
• Fix: Closing tags did not take / into account when calculating prefix length (regression from 2.93)

• Add: MaxPrefixLengthInXML property. This sets the cut-off length for removing prefixes, from the incoming XML, when removePrefix is on. The default value is 4 (which includes the separator.)

• Fix: SetGroupLengths could fail if last field in the group was an attribute.

• Fix: SetGropLengths could fail if nested Groups, with attributes, and fields of the same name were involved leading to bad xml.

• Fix: Remove whitespace before and after CDATA when importing XML.

• Add: Support for a progress control to be updated when doing a LOAD or a SAVE.

• Add: new flavor of Load method which makes multi-level imports easier, and the embedded code simpler. See Loading Parent and Child records at the same time
• Updated: xFiles\Examples\ParentChild\inv.app to use new method described above.

• Fix: Names of Blobs and Memos used in a view was not correct when SAVEing the View.
• Fix: When in Demo mode do not actually reference any memo or blob as the table may be closed.
• Fix: xCell, SetRow method did not correct set the style for the row.

• Change: Text after a pipe in field names removed. To handle things like
  MyFile String(30) | READONLY

• Change: xCell class :  Length of Formula field extended from 50 chars to 1024 chars.
• Fix: IsBoundary tweak for dontReplaceColons.   
• Fix: Tag name for Views, when File Field has external name set.

• Fix: Updated xcell.SetColumn method to handle p_Index < 1.

• Add: Optional Key parameter to Save(Table) method. If omitted then the Primary key is used.
• Change: RootBoundaryAttribute, _pFileBoundaryAttribute made larger.
• Change: GetFieldNumber and DisableField methods get an optional case parameter.

• Add: CheckSize method
• Fix: Appending a large xml to an existing xml could result in an index out of range error.

• Fix: Better boundaries of E in xcell.numeric.

• Add: ColorWeb method to xCell class. Color parameters can now be passed either as Clarion LONG's or Web #aabbcc format to xCell methods that take a color.
• Improvement: xCell.SetStyleInterior method validates Pattern parameter and sets to Solid if not valid.
• Documentaiton: Formulas for xCell class discussed.
• Documentation: Example of xCell methods added.

• Add: Start method to xCell call and xFileXml class to restore the object to it's initial state for reuse.

• Add: DontAbbreviateEmptyTags property to enforce <abc></abc> instead of <abc/> for empty tags.

• Change: If loading a group, and the FileBoundary is set, but the RecordBoundary is blank, then internally swaps them.
• Fix: Prevent a possible "Index out of range" if in DecGroupTag and self.Parents is already blank.

• Add: WrapText to StylesQueue for xCell [courtesy of Robert Kolanko]
• Add: MergeAcross and MergeDown to CellQueue for xCell [courtesy of Robert Kolanko]
• Fix: IsGroup method could return the wrong value if the group name was duplicated as a no-group-name earlier in the xml.
• Fix: If FileBoundary was blank then BinDataLen could be incorrectly lengthened
• Removed: Calls to Wait and Release (which contained no code.)
• Removed: Experimental and incomplete xFileJSON class - use jFiles instead.
• Removed conditional compiles for C5 and C55 support.
• Replaced: Calls to OMITTED with names, not numbers.

• Improvement: When called to create a string, makes sure xmlData property is not left pointing to null if the string is empty.

• Improvement:  xCell.Numeric method made smarter so that - and + signs limited to start of string.

• Improvement:  xCell.Numeric method made smarter to invalidate numbers with multiple chars, which are legal, but only allowed once. +, -, . and E.

• Fix: When writing text into attributes, that text was not being XML encoded (ie > to &gt; etc.)
• Change: p_Type parameter to xCell.SetCell method is now case insensitive.

• Fix: Setting the .CRLF property to blank did not have the desired effect.

• Fix: xCell.SetCell method would set a cell type to be Number even if it contained a space. (Excel does not like this.)
• Fix: xCell.Numeric did not ignore leading and trailing spaces.
• Fix: xCell.SetCell, if type forced to numeric then value is LEFTed.

• Fix: Use of Zip class did not Close the file after reading it.

• Tweak: xCell class exporting numbers containing a comma are sent to Excel as a number, not a string.

• Add: DisableField method
• Fix: Possible out-of-range error in _IsBoundary method.

• Add: DontUTF8encode and DontUTF8Decode properties.

• Fix: Removed a regression added in 2.62 which cased some exports to Excel to generate a GPF.

• Some code added to xCell class to trap misuse of class and prevent gpf.

• _Indent property set to 0 at start of save. [update-- introduces a regression, this change undone in 2.64 build]
•  If _Indent drops below 0 then reset to 0.

• Clarion 10 Install
• Removed %cwversion code

• Fix: Possible Index-out-of-range

• Fix: Regression in IsGroup.

• Improvement: Profiled IsGroup method, and optimized code. (Can be a lot faster to Load structures with lots of sub-groups)
• Improvement: Other minor optimizations.

• Fix: Bug in RemoveComments that could result in an Index-Out-Of-Range error.

• Extended: Maximum length of data in an excel cell (CellQueueType) extended from 50 chars to 2048 chars.
• Add: AddTimePicture and ExcelTimePicture methods to support time columns in Excel.

• Performance Improvement: XML files with no space characters could load slower than desired.

• Fix: xCellStyles needed to set Bold and Italic as attributes.

• Fix: When saving structures with more than 2 levels of Groups, the closing tag did not get added correctly.

• Add: ReplacementChar property - defaults to '.' Allows you to specify the replacement character for the colon in field names.
• Fix: Empty fields could be excluded even if property was set to 0.

• Fix: Regression: xml.Save(view) was broken.

• Added Class : xCell, and all dependent classes and structures.
• Added _sFieldRequired property. Forces field to be included, even if it is blank and would normally be excluded.
• Added Method : SetRequired
• Fix: Structures that terminated with multiple nested groups did not always close properly.

• Added DemoMode and DemoModeValue property.
•  Added _sGroup and s_String (internal) properties
• Refactored DecGroup method (internal use)
• Added p_close parameter to _WriteStartTag method.
• Added support for DontSaveBlankStrings to attributes
• Fix: Test IsGroup before IsString.
• Refactor: Removed various conditional compile statements for C5 and C55 support.
• Fix: If in Append mode, SOAP envelope is not repeated

• Clarion 9.1 build

• Fix: Load from file method did not reset loadFromString property when switch from a string load to a file load. (thanks to Dave Bratovich for spotting this one.)
• Add: DontSaveBlankStrings, DontSaveBlankNumbers, DontSaveBlanks properties.
• CleanFileName method is stricter on characters allowed in file names.
• Add: TRACE method added.
• Add: xslt property for adding an xml-stylesheet reference at the top of the xml output.

• Fix:  Error : Indistinguishable new prototype: LOAD when using xFiles procedure extension in Legacy Source procedure.

• Update: Installer detects Clarion 9

• Changed to Ver4 object/template management system. IMPORTANT READ THIS.
• Add: support for Multi-Proj in C8
• Fix: Allowed SOAPBodyBoundary and SOAPEnvelopeBoundary attributes to be used independently of each other.

• Fix: The first attribute could be created with the trailing " omitted.

• Add: SetAsAttribute method extended to give a lot more control over creating attributes in xml that is being created.

• Fix: When saving large tables, and there are large numbers of encodable characters (&, <, > and so on) then a GPF was possible.

• Fix: When saving Views to a file, MEMO fields specifically mentioned in the view were not exported.

• Fix: If a group, contained an Array, then the closing tag of the group would be located incorrectly.

• Added: NotBoundary property for structures that contain a field with the same name as the record boundary.
• Lengthened max attribute length to 4K.

• Fix: If removePrefix was set, and the incoming xml FileBoundary had a prefix, then the FileBoundaryAttribute property was set incorrectly.

• Added CurrentFieldLength property.

• Added RecordNumber property.
• Added StartRecord method, matches existing EndRecord method, and allows for overriding of record boundaries during a .SAVE.
• Added xFileJSON class (Work In Progress)
• Fix: ' and " charterers not correctly encoded when creating xml.
• Fix: if a string contained multiple characters needing encoding, then some chars at the end of the string would not be encoded.

• CHANGE: _pRecordBoundaryAttribute property changed name to RecordBoundaryAttribute
• Added support for Attributes when creating XML.
• Fix: Possible GPF when used in Multi-DLL mode with BoTran.

• Fix: Calling Save on a File, with Strings set to CData did not correctly recognize a Group as a Group.

• Corrected examples with missing files.

• Support for attributes quoted with a single-quote added.

• Support for ColumnDisabled property added to .Load method.

• Tweak to template to support xFile objects generated into Source procedures in Clarion 8.

• Added .CRLF property so that alternate line endings can be used. Default is CR/LF (ie char 13, followed by char 10). Use this in conjunction with the IndentBy property to minimize the size of the xml.

• Add new method, SaveCurrentFieldToXML with name parameter. Makes custom formatting of fields easier if you have the name.
• Add new method FormatCurrentField to simplify simple formatting of a current field.
• Added section to the docs: Formatting a field before it is saved to XML

• Added new method, UseCharSet which sets the .SaveEncoding property based on a Clarion Charset.
• .RSSVersion string extended from 10, to 252 characters

• Added support for auto closed, empty tags, when doing a 'match by number'.

• Fixed place where dontReplaceColons property was not being respected.
• Added PROC attribute to Save method declaration

• Added XF:CaseAny equate
• Set default of TagCase property to XF:CaseAny

• Fixed regression with errant SOAP boundary appearing in non-soap xml.

• Added support for SOAPHeader property.

• Prototype for Copy method changed to explicitly take both source and destination structures. This avoids possible thread problem with global, unthreaded, objects.
• .TagCase property can be set to XF:CaseAsIs for Loading. If set, then all structure external names need to be set specifically.

• SOAPEnvelopeBoundaryAttribute lengthened from 252 to 1024 characters.

• fixed regression in string length of encoded strings when converting & to &amp;

• Fixed bug with encoding of &, < and > in xml that wasn't encoded any other way.

• Fixed regression with records being filtered in ValidateRecord

• Added .PrefixChar property (defaults to :)

• Add EndRecord method - allows you to embed strings, when saving, right before the end of a record.
• AddString method - allows you to inject a custom string into the xml stream when saving.

• Fix possible GPF when saving large fields (> 1 MB).
• Optimized encoding of &, < and > characters.

• Fix GPF in AssignField. If CurrentFieldNumber was 0 , then it was using that to check the GroupLen array.

• ParseAttr method saves, and restores currentTag property.
• Autoclosing a tag while in a record refined.

• CurrentTag property set when parsing attributes on a .Load
• added support for <record attr="whatever" /><record attr="something" /> styled xml
• added autoCloseTags property for loading invalid xml.

• Updated Demo app, modernising calls in embeds to .Load and .Save
• Fixed bug where closing tag might be truncated if indent was <> 0 at that point.

• Added IndentBy property. Set to 2 by default. Set to 0 to suppress all indenting, before the call to .Save.

• Fixed another problem with groups in a VIEW

• Fixed problem detecting GROUPs in Views with a JOIN
• Fixed problem where SetFieldPointer method could enter infinite loop
• Fixed problem where IgnoreGroups property was on.

• Added support for structures that contain a field with the same name as the record.
• Added support for multiple fields, with the same name, in the same structure.
• Added new section to the docs called Importing Advanced Structures.
• Added StoreWholeRecord property.
• Fixed: Bug closing group structures where last field in group was disabled, or an Over.

• fixed bug where xml with no encoding specified was assumed to be utf. This affected extended character sets that were encoded, but used a scheme other than utf-8.

• fixed bug where attribute started a new line
• fixed bug when loading memos and blobs
• tweaked code in decode method for Clarion 5.5 and earlier support.
• Change to Copy method to allow for the case where the file is closed.
• fixed bug in complex structure save where text was appended.

• Added support for one complex structure inside another. For example a queue of Queues, a queue of Files and so on. See QinQ example for hints on the way to do it.

• Fixed regression with dimensions being over-detected.

• Added automatic detection of dimensioned fields to Groups and Queues for Load and Save. Only C6 and higher can detect automatically, C5 and C5.5 need to set _Dimension[FieldNumber] specifically in SaveTweakFieldSettngs.

• added support for &quot; and  &apos; encoded characters.
• added support for group structures that contain attributes, but no data, and end with the abbreviated close tag.
• extended example added in version 1.91to handle cnumber field.

• Added support for xml where the record boundary contains data. See ParentChild example, Example2 procedure.

• Fixed regression with CurrentTag property missing.
• Corrected ParentChild example which was missing the example xml file.

• Fixed bug where SendToString property was not explicitly being set to 0 when .Save method (to file) was called.
• Added UpdateAsWhole property for updating incoming records. Note that if the file has memos then this mode is not supported.

• Fixed bug where updating records that contain arrays - save Buffer size was calculated incorrectly.

• Better support for arrays in Queues and arrays in Groups. However note that you need to manually set
  xml._Dimension[fieldnumber] = xxx
  before calling Load or Save.
  xxx is the size of the dimensioned field (i.e. the number of elements in the array).

• Added support for decoding xml that has no File boundary AND no Record boundary. In this case each tag triggers a save to the File, or Queue.
• New example, "ParentChild" included to show how child records inside a parent xml can be parsed using a second xFiles object.

• AssignField method (used when loading) now takes decoded string rather than encoded boundaries into BinData. This allows for much easier control over altering (formatting / deformatting etc) incoming values before they are assigned to the Group, Queue or Field field.

• fixed bug where number of fields in group was inaccurate if group contained fields with no label.
• fixed bug where groups-in-groups could fail where group tags were case sensitive.
• Calling ._close after an error resulted in the error code being cleared.

• Fixed regression where multiple root boundary tags were included in multi-part xml docs.

• Fixed possible memory lead when saving xml into a string.
• Fixed possible "hang" where an error occurs during a load, leaving the CriticalSection in an unreleased state
• Corrected problem with SOAP header being omitted if OmitXMLHeader was set when calling Save. (Thanks to Sebastian Arribas.)
• Added AddQueueRecord method. (Virtual method called before a record is added to the Queue)

• Extended Append to support Xml-To-Strings.

• Added _sFieldNameAttribute and _sFieldNameAttributeLen properties. See properties which can be set in SaveTweakFieldSettings.

• Clarion 7 compatible install.
• Class - don't write the record boundary if there is none.
• Template - change to the tpw (fix Methods list to '' when finished generating the list).

• Fixed extra space at the end of RootBoundary and SOAPBoundary tags.
• More template updates to prevent dropped objects.
• Import/Export Control template updated to support Clarion 5.
• Table, and Row boundaries added to the Import/Export Control template.

• Documented limitations for Clarion 5, and Clarion 5.5
• Improved support for Clarion 5 File-To-XML
• Added small FileDump example.
• Template change to try and avoid orphaned methods.

• fixed bug in FileBinary.Init method that could truncate file names. (Thanks to Benjamin Krajmalnik)
• improved support for groups, where the Clarion group is a superset of the XML group, of the xml file being loaded.

• Added template option to both global and local templates;
  "Update File on Import if record already exists".
• fixed bug with importing records if records already exist.
• improved error information when errors occur while loading an XML file.
• improved speed when importing records, and the records exist, and the file has no memos or blobs.

• fixed possible GPF when loading/saving XML from a string (not a file).
• improved the RemovePrefix support a lot. Specifically if the .RemoveProperty is set then prefixes in the XML are now ignored, INCLUDING prefixes in the FileBoundary and RecordBoundary. In additional prefixes in the .RecordBoundary and .FileBoundary properties are also removed.

• fixed regression: DontCleanFileName property was in the wrong class.

• fixed bug which hindered loading of CDATA strings > 1024 characters
• improved group support when saving and loading File, View and Queue structures
• explicitly cleared various properties on load & save, making multiple use of the same object better.
• handles .\ and ..\ in path better when writing in append mode.wc o:\cl
• Added new property IgnoreGroupTags. Set this before saving to NOT write out the group tags around grouped fields.
  Set this before loading to allow ungrouped XML fields to be loaded into a structure - even if they are grouped in your clarion layout. If the XML fields are grouped then the fields will still load, however there may be complications if you have duplicate field names in the xml.

• Fix: Allowed more characters as legal in CleanFileName method
• Fix: Handled case in Load where record boundary is a subset of a field label.

• support for auto-closed tags in RSS feed
• Added support for loading xml files that contain comment

• Added support for nested groups for both load and save.
• added "standalone" property which can be se to "yes" or "no" as desired. For example;
  
  <?xml version="1.0" standalone="yes">
• Fixed regression in XML Settings class. FileBoundary and RecordBoundary attributes now set correctly.
• Fixed over-zealous error reporting in _close method. Closing an already closed file no longer results in an error.
• New Jump-Start section added to the docs - Creating an XML File or String

• Fixed regression with Load methods not using default FileBoundary and RecordBoundary properties.
  VERY IMPORTANT NOTE: These properties are now no longer set to default values by the INIT method. If you are using the (obsolete) Load mechanism of
  xml.Init()
  xml.Load()
  Then you will need to set these two properties before the call to .Load. (Before or after .Init is fine.) EG
  self._pRecordBoundary = 'item' ! or 'data'
  self._pFileBoundary = 'queue' ! or 'file', or 'view', or 'group'
  
  As an alternative use the new forms of .Load and .Save.
• Added extra Save methods to support setting the FileBoundary and RecordBoundary in the Save command.

• Added extra Load methods to support setting the FileBoundary and RecordBoundary in the Load command.
• Created a new Jump-Start section in the Docs - Loading / Importing & Parsing XML Files

• Added two new procedures, AddOldField and LoadAllOldFields. This allows you to change a table, view, group or queue field name and still import and XML file using the old field name.
• Some more minor bug fixes.

• Changed: Remove all Stop() message for API failures. These are handled by ErrorTrap (and logged if logging is enabled) and the application should choose the desired behaviour when an error occurs. NOTE: Error and ErrorStr properties are set when an error occurs. ErrorTrap is obsolete.
• Added: Additional file handling for opening files that are not already open when the Load(), Save() and Copy() methods are used. The file maintains it's state (if a closed file is opened it is closed when the method is complete).
• Added: Additional features specific to CapeSoft Email Server in Service mode. This release is required for the source code version of Capesoft Email Server 3.83 and later.

• Fix: Supports <tag/> syntax as well as <tag /> syntax.
• Add: Any attributes in the Record Boundary are now parsed into fields as if they were separate tags. For example
  <record firstname="bruce" lastname="brown">
     <dob>1/1/2000</dob>
  </record>
  Is processed as if it was
  <record>
     <firstname>bruce</firstname>
     <lastname>brown</lastname>
     <dob>1/1/2000</dob>
  </record>
• General: cleaned code to remove out-of-date comments, and old, commented-out code.

• If RootBoundary set during Load, then root boundary attributes loaded into RootBoundaryAttribute property.

• Add: Ability to store multiple things (Groups, Queues, Files, Views) in a single XML file. See Storing multiple things in the same XML file for more details.
• Add: Files which are part of the View are automatically Bound.
• Fix:A GPF could occur if using the .Save(View) method, and the table could not be opened.
• Fix: Dict example was missing Wages.Tps file.
• Fix: Saving a View would fail if the view had a prop:filter
• Fix: Tag names for blobs & memos were not clipped
• Fix: If the "simple" form of the view was coded (i.e. with no projected fields) then xFiles would GPF if the file structure contained over fields.
• Fix: Loading file boundary attribute was broken if attribute did not exist.

• Added ability so save VIEWS to an XML file, or string.
• Added .ValidateRecord method to allow client-side filtering of records being saved, or loaded.
• Added ability to ignore attributes on a record boundary. (Similar to the feature done for 1.51 for the file boundary.
• Setting _pFileBoundary property to blank suppresses the file boundary tag in both Load and Save methods.
• Added SoapEnvelopeBoundary and SoapBodyBoundary properties that allow you to set specific tags when creating a soap packet. They default to soap:Envelope and soap:Body respectively.
• Added .TagCase property. This defaults to XF:CaseLower. Other options are XF:CaseUpper and XF:CaseAsIs. In order to have mixed case tags, the Name property for each field in the group/file/queue must be set.
• Added a section to docs, Creating SOAP Requests.
• Added a section to docs, Using a View to create a filtered, sorted, XML file.
• Added a new example (Examples\SOAPClient\Convert) courtesy of Larry Sand (www.ClarionFreeImage.com)
• Added new example (Examples\Dict) that show minimalist source procedures saving a file, or view, to XML.
• Change: SoapEnvelopeText property (added in version1.52) has changed name to SoapEnvelopeBoundaryAttribute to make naming more standard.
• Fix: If .Load method opens the file, then it closes the file as well. If file is closed, and .Save is called, then file is opened, and closed. If .Save is called in View mode then all necessary files and view itself, if not already open, will be opened and closed.
• Internal: Calls to .SaveTweakSettings, and .LoadTweakSettings moved higher in .Save and .Load methods respectively.

• Added new Save methods to save a group to a string, and Queue to a string. .Save(Group) and .Save(Queue) respectively. XML String is in .xmlData property after the call is made.
• Added .SoapEnvelope property and .SoapEnvelopeText property. If .SoapEnveloper = 1 then a SOAP envelope will be wrapped around the XML.

• Added support for additional attributes in the file boundary tag. For example if an XML file is modified in Excel the Schema is added to the tag that acts as the file boundary:
  <file xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  Which is now supported. Additional attributes will be ignored, and overwritten when the file is saved, however the file will now load as expected.
• Template - added description into extension template header for ease of identification of which instance of xFiles each extension is.
• Template - fix for legacy class generation (includes xfiles01.tpw 1.54)

• Documented the xFileLinkDLL class
• New Quick Start guide for dynamic DLL loading using xFileLinkDLL
• Support for loading XML based on field number rather than field name (allows an XML file to be loaded where the field names don't match those of the data structure being loaded). Also support starting from any field in the XML.
• Updated the documentation, fixed incorrect links, added numerous new links, fixed references where xFilesXML was simply referred to as "xFiles", update the Contents to assist with navigation and added additional links to the JumpStart/Quickstart guides in the documentation.
• New xFileXML.Load() method to load directly from memory by passing the data structure and string that contains the XML to load. Using this method means that the LoadFromString property does not need to be set and the xFileXML.xmlData does not need to be populated manually.

• Extensive new document for the xFileXML class, a large number of new methods and properties have been documented and the existing documentation expanded on.
• Support for storing multiple data structures in a single XML file.
• Support for reading data from an XML file that contains more than the data structure currently being read.
• Support for writing multiple data structures and custom XML to a single file.
• Added support for Multi-Proj

• Fixed a bug that could cause problems loading groups (the data would not be loaded from the XML file, unless Save had previously been called).
• Updated documentation for the xFileXML class to include additional class methods, this update is currently a work in progress and the documentation will be further updated shortly (for all classes).
• Added xFileXML.SaveBinData() and xFileXML.LoadBinData() methods to allow files to be loaded and saved directly to the binData property of the class without doing any parsing. This can be used to save multiple groups, files and queues to a single XML file by using the .saveToString property to create the XML in memory, populating it into the binData property and the using SaveBinData() to write it to disk. The standard Load() method handles loading data from XML files that contains multiple data structures (see below)
• Added support for reading an XML file that contains multiple groups, files and queues.

• New example. Uses the xFileTimer object to delay 1ms between tasks.

• Code to handle nested groups and queues uses the IsGroup() function, which is not available in version of Clarion prior to C6. In 1.20 Beta this results in a compiled error when using C55. This code has now been wrapped in a conditional compile for C6 only.
• Added support for nested groups, queues and records in groups, queues and records. Previously only groups were handled.
• Fixed compile errors in example applications due to missing Global extensions.
• The Multi Dimensional example used GPFReporter, Hyperactive and WinEvent, these have been removed.

• Updated xFileXML.Copy() function to allow queues to be copied to files and files to be copied to queue.
• Fixed xFileXML.Copy() function when used with Files - an option was used that was not supported by some driver types (such as the IMDD), all functions are now very generic and should support all file drivers.
• Added handling to prevent issues when xFileXML.RemoveDuplicatesAfterSort was called with a file instead of a queue.
• New handling for tables (especially IMDD tables) to support the same features as queues.
• Numerous fixes of table handling code, fixed loading and saving issue etc.
• Added the ability to override the main wrapping tag to so that files and queues can be populated from an XML file regardless of whether the wrapper tag is <queue> or <file>.
• Fixed: Sub groups and queues (group within groups/queue and queues within queues) now output correctly. Previously the fields would be output, but the sub group/queue itself would also be dumped as a single "field" within the XML.
• This is now the official version used by Email Server 3.50 and above. Previous version of xFiles are not compatible with Email Server source code.

• Fixed Global Disable (was trying it include some code in the Export from and Import to file control template which was causing compile errors).
• In Init - don't override settings (with defaults) that were set prior to Init being called.
• Includes a stamped version to indicate the version of xFiles that the application was previously compiled with.
• Warning is generated if a XMLFile is attempted to be imported to a file, or a name for the file is not specified.
• Case insensitive parent method name checking (if the parent method's name case was different, then the class deriver saw as two different methods).
• Fixed GPF in export to string.

• Replaces Colons with Dots (for fieldnames if required) even if the RemovePrefix property is set (was previously either doing the one of the other).
• Template option to specify whether (in field names) colons must be replaced by dots or not.
• Fixed regression (from 1.08) - omitting fields (where export was not from SendTo)

• New property - ColumnDisabledStr - a string over the ColumnDisabled byte array (makes setting or resetting these bytes easy)
• Added a constructor method (which is called from the construct method) - makes deriving the construct method possible.

• Very Important !!: self._NoFreeBeforeLoad has been inversely replaced by self.FreeFileBeforeLoad, self.FreeQueueBeforeLoad and self.FreeGroupBeforeLoad. You can turn this on or off in the template (or via handcode).
• Very Important: You need to add the xFiles Global Extension template to your applications that use xFiles. If you have used your own derived xFiles class, you will need to enter that into the field provided on the Class tab of the new xFiles Global Extension template.
• Important: self.InverseOrder has been replaced by self.InverseAddOrder and self.InverseTruncateOrder
• Important: self._cRecordBoundary has been replaced by self._pRecordBoundary
• Important: self._cIndent has been replaced by self._pIndent
• Important: self._cFieldName has been replaced by self._pFieldName
• Important: self._cRecordBoundary has been replaced by self._pRecordBoundary
• Important: self.GetValue() and self.SetValue() prototypes changes - but continue to work as before.
• Important: self._ReplaceColon() has been replaced by self._ReplaceColonInString().
• Added: Support for Importing and Exporting Clarion Files to and from XML (so it now handles Files, Queues & Groups). File to xml is only supported in C55 and above. And files with multi-dimensional fields, memos and/or blobs are only supported in C60 and above.
• Made import case insensitive for XML tags.
• Added: Dim, Blob & Memo support
• Added: self.SaveEncoding (defaults to iso-8859-1) but can also be set to utf-8 or windows-1252
• Added: self.LoadEncoding - which tells you what the encoding of the loaded XML file is.
• Added: CDATA support
• Added: self.SaveStringsToCData (Default off)
• Added: self.SaveMemosAsCData (Default on)
• Added: self.SaveBlobsAsCData (Default on)
• Added: self.SaveAsCData[index] (default off or on depending on SaveStringsToCData etc. options - override this in SaveTweakSeattings()
• Added: self.DontUseMemos (defaults off)
• Added: self.DontUseBlobs (defaults off)
• Added: CustomHeader (string) - which allows for a custom header string to be added when creating the header
• Added: CustomSectionAfterFileBoundary (string) - which allows for a custom section string to be added after the file boundary tag.
• Added: CustomFooter (string) - which allows for a custom footer string to be added when creating the footer
• Added: Advanced methods - self.SaveTweakSettings() and self.LoadTweakSettings() - which are called from Load() and Save() after the analyzing phase before the actual reading/writing phase - allow last minute changes to the configurations.
• Added: self.ForceDecimalEncode128 which forces all characters > 128 to be encoding as &#128;
• Added: Control template for Exporting and Importing Files / Queues and Groups.
• Added: self.RemovePrefix - which if set to 1 will remove the prefix from queues, groups & files. e.g. <Pro.ProductName> becomes just <ProductName>
• Added: self.FreeGroupData (defaults to a clear)
• Added: self.FreeQueueData (defaults to a free)
• Added: self.FreeGroupData (defaults to a loop / next / delete) - It's better to override this method with your own ABC Relational Delete - and xFiles may implement an update feature in future instead of delete and insert - which can break relational constraints.
• Added: self.RSSVersion (string) which you can set to '2.0' for example and your file/queue will be exported in RSS format. Best to set this before calling Save() and/or Load() e.g. Set in Construct()
• Fixed: Critical Section support for C5 and C55 applications that don't use NetTalk 4.\
• Fixed: interference with other templates (using the Object01.tpw template) - new xFiles01.tpw
• Fixed: a bug where a 0 byte file could be locked after loading with the Binary Class
• Added: SaveToString support added (previously was just doing LoadToString)
• Note: the zip functionality (with particular note to the save xml in zip file functionality) will be undergoing some future changes.

• Fixed Wait Release problem in Zip code
• Changed Wait Release code to use NetTalk's Wait Release object if available.
  If you are not using the xFiles template, and don't have NetTalk v4.00 or newer please add the following project define to your application:
  xFilesNoNetTalk4=>1
  This is not needed if you have NetTalk v4.00 or if you are using the xFiles Extension Template, as this is controlled automatically.

• Fixed install. Use this version rather than v1.03.

• Added column suppression (for SendTo support). See new property - ColumnDisabled 

• Added zlib_cs.dll and Explode.dll to the Install.
• Tweak to the template for Clarion 5 to remove warnings.
• Removed the p_DontCloseNow parameter to the Save() methods, and added SaveButDontClose() methods
• Fixed Destruct Freeing blocks twice

• Corrections and additions to the documentation.
• Added an xFiles template to easily add the xFiles object to a procedure (replaces Object Writer's Object User template, and provides default settings for xFiles).
• New Save and Load methods that take the data structure and file name and can be called without needing Init to be called.
• Changed all example to use the new xFiles template to populate the object.
• Cleaned up and updated the documentation, added docs for addition class properties.

• xFiles escapes captivity!
• Initial documentation etc.
• The original class name was changed from QueueFile, all classes included renamed for consistency.