[Show Table of Contents]	11 Configuring KineticFusion	[Hide Table of Contents]

Previous 11.2 KineticFusion Properties Summary	Home Up One Level

11.3 KineticFusion Properties Details

11.3.1 General Properties

11.3.1.1 kinesis.preload

This property defines the behavior of the KineticFusion application on startup. The KineticFusion application takes several seconds to load in the application and optimize the compiler. This delay is normally encountered when the first ActionScript script block is analyzed by the application. This startup for processing the first ActionScript blocks can be greatly decreased by setting the value of this property to 'true'. When set, the KineticFusion compiler will load in all application components used by the application when the application first starts and initialize the compiler by loading all top-level intrinsic class definitions.

Value Type	Boolean
	false Application and compiler are loaded and initialized on demand true Application and compiler are loaded and initialized on startup
Default Value	true

11.3.2 General Repository properties

11.3.2.1 kinesis.repository.directory

When KineticFusion converts SWF movies to RVML it extracts all multimedia resources from the SWF movie and stores these in a separate repository location. When the property 'kinesis.repository.isRelative' is false or undefined, all repositories are located under the name of the directory specified by this property. A repository is created for each SWF movie using the name of the RVML output file and the word "Resources" e.g. for an output document called myMovie.rvml, a repository directory will be created called myMovieResources. Currently, five different types of resources are supported by KineticFusion: sound, image, font, video, and Classes and each resource type is stored in a separate subdirectory in the repository. A reference to the absolute location to the repository is stored in the RVML file so this property is not used when compiling RVML back to SWF. The repository is also used as the default location for storing decompiled ActionScript 2.0 classes.

This property is also used to define the default base repository path for Repository elements with a 'File' type that do not have an explicit repositoryBase attribute defined.

Value Type	Directory
Default Value	${Installation Directory}/projects/repository

11.3.2.2 kinesis.repository.isRelative

When KineticFusion converts SWF movies to RVML it extracts all multimedia resources from the SWF movie and stores these in a separate repository location. When this property is true, all new repository locations are created relative to the location of the output RVML document. The 'kinesis.repository.relativePrefix' property can be used to specify additional subdirectories under which the repository is created.

Value Type	Boolean
	false New repositories will be created under the directory specified by the property 'kinesis.repository.directory' true New repositories will be created relative to the location of the output RVML document
Default Value	false

11.3.2.3 kinesis.repository.overwrite

When an SWF movie is being converted to RVML, all resources are stored in a repository. When an SWF movie is converted several times then the same resources may be stored in the repository multiple times. When this property is set to 'false', should a file with the same name as a resource already exist, a new file with an additional suffix is created e.g. if a file Image1.jpg already exists in the repository and an SWF is decompiled again, then this will result in a new resource called Image1_00000001.jpg being created. This can result in a resource repository quickly getting filled up with many duplicate resources. When this property is set to 'true', resources will be overwritten if they already exist in the repository. This will stop the repository from getting cluttered with duplicate files, however all existing RVML documents that reference the repository may refer to incorrect resources.

Value Type	Boolean
	false Create new resources when decompiling new SWF true Overwrite existing resources when decompiling new SWF
Default Value	false

11.3.2.4 kinesis.repository.relativePrefix

When KineticFusion converts SWF movies to RVML it extracts all multimedia resources from the SWF movie and stores these in a separate repository location. When the property 'kinesis.repository.isRelative' is true, this property defines an additional path to be added to the repository under the directory containing the output RVML file. When left blank or undefined, the repository for an SWF is placed in the same directory as the RVML file. To prevent pollution of the directory, a user can use this property to ensure that the resources for all RVML files in that directory are stored in a single common subdirectory. For example, when decompiling an swf to Test.rvml in directory c:/rvml, when this property is blank the movie repository is stored in c:/rvml/TestResources. When this property is set to 'repository', the movie repository is stored in c:/rvml/repository/TestResources.

Value Type	String
Default Value	Blank

11.3.2.5 kinesis.repository.systemFontPath

KineticFusion can use TrueType fonts for rendering static and dynamic text. TrueType fonts generally contain a large number of character representations and hinting information. Rather than extracting this font information from the font file every time it is requested in RVML, TrueType fonts can be imported into the KineticFusion application in native format and stored in the System font path. Fonts in the system font path can be be referenced by font name alone. System fonts are also used to augment font information to in RVML documents that are missing glyphs after editing. All missing glyphs and metrics, if available, are automatically imported on demand from the corresponding system font.

Value Type	String representing a location where system fonts can be stored
Default Value	None

11.3.2.6 kinesis.repository.defaultSystemFont

When modifying RVML documents, it is possible to change text within a static or dynamic text field to contain characters that are not available in the original font. KineticFusion will automatically look for missing characters in a system font of the same name. However, if no system font can be located, this property defines a replacement font family that should be used for all missing characters. KineticFusion will attempt to match all the style attributes of the missing font characters, e.g. bold, italic, using the Windows font naming convention when selecting a font from the default family to use as a replacement. The Windows font naming convention adds Bold and Italic suffixes to the font name e.g. Arial, Arial Bold, Arial Italic, Arial Bold Italic. If the specific font style cannot be found, then the normal font is used.

Value Type	String representing the default font family name to be used
Default Value	None

11.3.2.7 Image Resource Properties

11.3.2.7.1 kinesis.repository.storeJPEGExternal

The JPEG image format is an optimized 'lossy' image format in which the storage size of the image can be reduced at the expense of a (normally) slight reduction in image quality. This compression ability makes it one the most common image formats in use today, especially for photographic images. JPEG images can be created, viewed and edited with virtually all graphical packages. SWF movies can contain JPEG images, stored in the SWF when it is published. When KineticFusion decompiles an SWF movie all JPEG images are extracted to SWF movies that contain only the image. The SWF movie is sized to exactly the dimensions of the image and is created with a red background, so any alpha-channel in the image can be clearly seen. The application will also extract all JPEG images into valid JPEG image files when this property is 'true' so that these images can be modified using an image-processing application. The resource description in RVML will always refer to the SWF resource type even when this property is set to 'true' as KineticFusion can read images from SWF movies quicker than from JPEG image files. The resource description in RVML can be edited manually to refer to the JPEG image if the image is edited externally.

Value Type	Boolean
	false Do not create copy of resource as external JPEG image true Create copy of resource as external JPEG image
Default Value	false

11.3.2.7.2 kinesis.repository.storeLosslessExternal

There are many image formats for storing lossless image information, the most popular being the GIF format. Due to licensing issues, a new image format call PNG is replacing GIF images as the storage format of choice for storing lossless images. Lossless images are often used instead of JPEG images when using images that are produced from vector sources that can be highly compressed e.g. maps, cartoons. PNG images can be created, viewed and edited with many graphical packages. SWF movies can contain lossless images, derived from any of the popular lossless image formats, stored in the SWF when it is published. When KineticFusion decompiles an SWF movie all lossless images are extracted to SWF movies that contain only the image. The SWF movie is sized to exactly the dimensions of the image and is created with a red background, so any alpha-channel in the image can be clearly seen. The application will also extract all lossless images into valid PNG image files when this property is 'true' so that these images can be modified using an image-processing application. The resource description in RVML will always refer to the SWF resource type even when this property is set to 'true' as KineticFusion can read lossless images from SWF movies much quicker than from PNG image files. The resource descripton in RVML can be edited manually to refer to the PNG image if the image is edited externally. The creation and importing of PNG images take up considerable processing resources so the preferred storage format is SWF.

Value Type	Boolean
	false Do not create copy of resource as external PNG image true Create copy of resource as external PNG image
Default Value	false

11.3.3 RVML Output Properties

11.3.3.1 kinesis.xml.dtdLocation

This property defines the location of the RVML DTD document that can be used to validate the document. The value of this property is embedded into the header of all RVML documents in the format specified by the outputValidatingXML property. The RVML DTD is distributed with KineticFusion and is found in the installation 'config' directory.

Value Type	Path to RVML.dtd
Default Value	dtd/RVML.dtd

11.3.3.2 kinesis.xml.outputBOM

KineticFusion uses UTF-8 for all output documents. This is thought to be the most efficient character for representing XML documents and will be able handle all character sets supported by the Flash platform. However, KineticFUsion must guess at the encoding of all input RVML documents. The encoding attribute of the XML declaration is optional so KineticFusion reads in some sample data from the beginning of the file to determine the encoding. The UTF-8 Byte-Order-Mark (BOM) is a three-byte marker at the beginning of UTF-8 documents (0xef 0xbb 0xbf) that automatically signals to all Unicode-aware processors that the document is in UTF-8 format.
If KineticFusion cannot not find a character code greater that 127 in the first 4K of the input document, the document is assumed to be in ISO-8859-1 encoding. This is a common 8-bit Latin encoding. However, should any UTF-8 characters be embedded within the document outside of the first 4K they will incorrectly decoded.
When this configuration property is enabled, KineticFusion will output a UTF-8 BOM marker at the beginning of all RVML documents. While this is the most exact manner of identifying the document as UTF-8, many editors and processors are still not Unicode-aware and cannot interpret the BOM byte sequence. Adding a UTF BOM can cause other XML processors to abort as the XML declaration, where defined, must be the first character of a document. Non Unicode-aware processors may instead believe that the XML declaration is not until the fourth character.
See also the documentation on kinesis.xml.outputUTFComment

Value Type	Boolean
	false Do not write a UTF-8 BOM at the beginning of each RVML output document true Write a UTF-8 BOM at the beginning of each RVML output document
Default Value	false

11.3.3.3 kinesis.xml.outputUTFComment

Value Type	Boolean
	false Do not write a UTF-8 comment after the XML declaration at the top of each RVML output document true Write a UTF-8 BOM comment after the XML declaration
Default Value	true

11.3.3.4 kinesis.swf.inputEncoding

All strings stored in an SWF movie are encoded using a specific encoding format. Since SWF version 6, this encoding format has been standardized and uses the "UTF-8" format. However in SWF versions less than 6, strings are encoded in SWF movies in a locale-specific way, using an implicit character encoding. For most SWF movies, this encoding defaults to the default locale of the authoring environment. KineticFusion will use the default system locale when reading SWF movies of version 5 or lower. If an SWF movie has strings in a different encoding, then this property should be set to the name of the desired encoding.

Value Type	Encoding String
Default Value	UTF-8

11.3.3.5 kinesis.xml.outputFontDefinitions

SWF movies can contain a number of embedded font definitions. An SWF font definition contains a definition of each glyph exported with the font, plus optional additional metrics information for defining inter-glyph properties. KineticFusion normally exports all font resources to the repository to be stored in SWF movies however each font can be represented as RVML instead. When this property is set to 'true', a 'FontDefinition' RVML tag is defined for each embedded font and all associated font information is output as RVML. This can be very useful when a user wishes to reuse a glyph outline as an RVML symbol or to alter the metrics of a font however, for large fonts, this can cause any resulting RVML document to become extremely large. It is recommended that SWF font resources be used for production RVML documents.

Value Type	Boolean
	false Store all font resources in SWF format true Output FontDefinition elements for all embedded font resources
Default Value	false

11.3.3.6 kinesis.xml.colorFormat

The KineticFusion RVML parser can accept color specifications in a number of different formats: named colors, 'rgb(r,g,b)' tuples with opacity attributes, 'rgba(r,g,b,a)' tuples, and SVG-style hexadecimal formats. For readability purposes, KineticFusion outputs colors by name if possible by default. When not possible it outputs colors using the 'rgb(r,g,b)' tuple format with an optional opacity attribute, in the range of 0 to 1, if the alpha channel value is not 100%. This configuration option permits a developer to override the color output format.

Value Type	String
	name_rgb The name of the color is used, if known, otherwise an rgb tuple and opacity attribute is used to represent the color name_rgba The name of the color is used, if known, otherwise an rgba tuple is used to represent the color name_hex The name of the color is used, if known, otherwise an rgb hex format (#rrggbb) and opacity attribute is used to represent the color name_hexa The name of the color is used, if known, otherwise an rgba hex format (#rrggbbaa) is used to represent the color rgb An rgb tuple and opacity attribute is used to represent the color rgba An rgba tuple is used to represent the color hex An rgb hex format (#rrggbb) and opacity attribute is used to represent the color hexa An rgba hex format (#rrggbbaa) is used to represent the color
Default Value	name_rgb

11.3.3.7 kinesis.xml.outputOptionalBounds

Several SWF symbols have bounds that are explicitly stored within the SWF movie. However, most symbols do not specify explicit bounds. The bounds of a symbol are very useful for calculating the transformation attributes required to scale symbols when placing and minipulating them on the timeline.
When this attribute is enabled KineticFusion will automatically calculate the bounds for MorphShape, Button, and MovieClip symbols and add a bounds attributes to the RVML symbols. These attributes are informational only.

Value Type	Boolean
	false Do not calculate or output optional bounds attributes true Calculate and output optional bounds attributes for MorphShape, Button and MovieClip symbols
Default Value	true

11.3.3.8 kinesis.xml.shortPlaceElements

Each Place element and Alter element in RVML can have a Transform child element that defines an absolute geometric transform to be applied to the symbol. In many cases the action of the Transform element is unclear as there is no reference to the actual height or width attributes of the symbol being replaced.
When this propererty is enabled, all geometric transforms for symbols placed or altered on the timeline are analyzed to see if they can be more simply expressed in terms of the width, height and rotation of of the symbol. If so, then the Transform element is discarded and the new attributes are added to the Place/Alter elements for width, height, and rotation.
There are both advantages and disadvantages to this approach. The advantage is that it adds much more semantic information to the timeline operation, and makes it much easier to highlight the function of the transform. The main disadvantage is that if the content of the symbol changes before recompilation, the modified content could affect the attributes of the symbol and so cause the new timeline operation to use a different transform than the original.

Value Type	Boolean
	false Do not replace Transform elements, even where possible. true Replace all Transform elements with attributes, where possible
Default Value	true

11.3.3.9 kinesis.xml.outputValidatingXML

This property allows the user to configure the XML header of all RVML documents produced by decompiling SWF movies. When an RVML document is compiled to SWF format, the input RVML is not checked for total conformity with the RVML DTD. This can permit an invalid RVML document structure to be processed and output as SWF. When this property is set to true, the XML header output at the top of the RVML document contains an uncommented reference to the DTD defined by the 'kinesis.xml.dtdLocation' property. When false, the DTD reference is still output but within an XML comment so that a user may enable the DTD manually by editing the document and removing the comment delimiters.

Value Type	Boolean
	false A commented DTD reference will be output in the header of all RVML documents true An active DTD reference will be output in the header of all RVML documents
Default Value	false

11.3.3.10 kinesis.actionscript.resolveSWFClasses

ActionScript 2.0 is a valuable representation for ActionScript classes but the underlying compiled representation of an AS 2.0 class is the same as that used in AS 1.0. This means that when AS 2.0 classes are decompiled, they will be decompiled as AS 1.0 ActionScript, and its corresponding RVML configuration symbols. When this property is true, all input SWF movies are analyzed for the presence of AS2.0 classes. All discovered classes will be removed from the RVML document and reconstituted in the class subdirectory of the movie repository. Additionally all classes will be analyzed to ensure that field references are fully resolved and visibility rules for AS2.0 classes are adhered to. Classes decompiled in this way are suitable for compilation by the KineticFusion compiler, however they may lack a lot of the semantic information found in the original source class. The default visibility information for all class methods, constructors and properties is public while all fields default to private visibility. In addition, dynamic classes may be changed to ordinary classes and augmented instead with additional fields that were referenced for the class. Type information is not currently restored for these classes though this will be a feature of a later version of KineticFusion. When this property is set to false, all output ActionScript will be in AS 1.0 format. When converting a resulting document to SWF, the analyzeScripts property should be disabled since there will be many class references in this code to classes that are already defined implicitly in AS1.0.

Value Type	Boolean
	false Input SWF movies will not be analyzed for the presence of AS2.0 classes. true Input SWF movies will be analyzed for the presence of AS2.0 classes, and all classes will be extracted and stored in the repository.
Default Value	true

11.3.3.11 kinesis.actionscript.storeDuplicateSystemClasses

When KineticFusion decompiles SWFs containing AS2.0 classes, it will extract all class definitions and store them in the repository (for more information on this see kinesis.actionscript.resolveSWFClasses ). The class path for these decompiled classes is added to the generated RVML so that all classes used in the movie can be located when regenerating an SWF. On recompiling all classes specified in the ClassPath element inside an RVML document take precedence over classes that are found on either the system or user class path.

When an SWF contains AS2.0 classes for which the user already has the source code for, it is frequently preferable that the original source code is used when recompiling the RVML document, rather than the classes generated on decompiling. When this option is set to false, all decompiled classes that can also be located on the system class path ( see kinesis.actionscript.systemClassPath ) are discarded and are not stored in the class repository. On recompilation, the class definition on the system class path will instead be used for compilation.

A similar property, kinesis.actionscript.storeDuplicateUserClasses exists for determining the behavior of class found on the user class path

Value Type	Boolean
	false All classes found on the system class path will be discarded true All classes found on the system class path will also be included in the decompiled class repository
Default Value	true

11.3.3.12 kinesis.actionscript.storeDuplicateUserClasses

When an SWF contains AS2.0 classes for which the user already has the source code for, it is frequently preferable that the original source code is used when recompiling the RVML document, rather than the classes generated on decompiling. When this option is set to false, all decompiled classes that can also be located on the user class path ( see kinesis.actionscript.userClassPath ) are discarded and are not stored in the class repository. On recompilation, the class definition on the user class path will instead be used for compilation.

A similar property, kinesis.actionscript.storeDuplicateSystemClasses exists for determining the behavior of class found on the system class path

Value Type	Boolean
	false All classes found on the user class path will be discarded true All classes found on the user class path will also be included in the decompiled class repository
Default Value	true

11.3.3.13 kinesis.actionscript.unicodeConstants

ActionScript can contain constant text strings. These strings can be composed of any standard Unicode characters. When ActionScript string constants are defined in source code, they can be defined as normal characters (in an editor that supports the viewing and editing of such characters), or using the standard Unicode notation of \Uxxxx, where xxxx represents the character code for the character. When KineticFusion decompiles string constants, it can convert all characters with a code greater than 127 to Unicode character notation. This is the default behavior when this property is set to true. When set to false, the characters are output directly however they may be converted to XML Unicode entities if the property kinesis.xml.unicodeEntities is set to true.

Value Type	Boolean
	false Output Non-ASCII characters in native format true Output non-ASCII characters as Unicode constants
Default Value	true

11.3.3.14 kinesis.xml.unicodeEntities

XML documents can represent text content in a number of ways. Since all Unicode characters are valid XML characters, these characters can be embedded in any RVML text without additional processing. Not all document viewers and editors, however, have the necessary font sets or capabilities to render these character correctly. KineticFusion will output all characters with a character code less than 127 as a standard character. If this property is set to true, then all characters with codes greater than 127 will be output as Unicode character entities - that is, the numeric character code, prefixed with a '#' character and suffixed with a semicolon. When false, then all characters, regardless of their character code will be output as standard characters.

Value Type	Boolean
	false Output Non-ASCII characters in native format true Output non-ASCII characters as Unicode character entities
Default Value	true

11.3.4 SWF Output Properties

11.3.4.1 kinesis.swf.outputEncoding

All strings stored in an SWF movie are encoded using a specific encoding format. Since SWF version 6, this encoding format has been standardized and uses the "UTF-8" format. However in SWF versions less than 6, strings are encoded in SWF movies in a locale-specific way, using an implicit character encoding. For most SWF movies, this encoding defaults to the default locale of the authoring environment. KineticFusion will use the default system locale when writing SWF movies of version 5 or lower. If an output SWF movie is to have strings in a different encoding, then this property should be set to the name of the desired encoding.

Value Type	Encoding String
Default Value	UTF-8

11.3.4.2 kinesis.swf.outputMetadata

Each RVML document can contain structured metadata information for the overall document and for each symbol within the document. This metadata can specify a title for the RVML document and a description for each document symbol. Using metadata is the preferred manner for documenting RVML symbols as it permits the roundtripping of documentation that would otherwise be lost, when stored in comments. When this property is set to 'true', a compressed block of data is added to the end of any SWF created by KineticFusion. This block contains all the Title and Desc elements defined in the movie, and this is used to recreate metadata when the SWF is re-read. The overhead associated with this block is quite small since the block is compressed (regardless of the compressed nature of the movie). It is recommended that metadata is output only for development RVML documents and not for production RVML documents, since it may allow other users to recreate your RVML document more easily.

Value Type	Boolean
	false Discard all movie and symbol metadata on movie output true Add compressed block at end of movie containing all Title and Desc elements that can be reconstituted on input. The Metadata element is not currently stored.
Default Value	false

11.3.4.3 kinesis.swf.outputSymbolNames

Each symbol used in an RVML document has a unique symbol ID. When an SWF movie is converted to RVML these symbol IDs are allocated to each symbol based on any identifier allocated to the symbol or container of the symbol within the SWF move e.g. if a symbol is exported with the name 'Square', KineticFusion will assign the ID 'Square' to the symbol; if a symbol is placed on the timeline of a MovieClip with name 'Clip' and an instance name of 'Square' KineticFusion will create a symbol ID of 'Clip.Square' for the symbol. For those symbols whose names cannot be derived then generic names are created for the symbols instead.

SWF movies have no concept of symbol ID names but instead use numeric IDs. If a symbol is given an ID that does not correlate with the KineticFusion-assigned ID then this ID will be discarded when the SWF movie is created. When the user is performing round-trip processing of RVML movies, it may be desirable to ensure that symbol names are maintained (round-tripping can be useful for verification purposes, or for simplifying symbols by resolving ShapeTransforms, Paths, Arcs etc). When this property is set to 'true', a compressed block of data is added to the end of any SWF created by KineticFusion. This block contains the symbol name for each symbol ID in the movie, and this is used to recreate symbol IDs when the SWF is re-read. The overhead associated with this block is quite small since the block is compressed (regardless of the compressed nature of the movie). It is recommended that symbol names are output only for development RVML documents and not for production RVML documents, since it may allow other users to recreate your RVML document more easily.

Value Type	Boolean
	false Discard all symbol name information on movie output true Add compressed block at end of movie containing all precompiled symbol names
Default Value	false

11.3.4.4 kinesis.xml.validate

When an RVML document is compiled to SWF format, KineticFusion will assume the document is conformant with the RVML specification and the input RVML is not checked against the RVML DTD. This can permit an invalid RVML document structure to be processed and output as SWF. When this property is set to true, the header of the RVML document must reference a valid DTD for the RVML vocabulary. This allows verification of the input RVML and ensures that all elements and attributes are correctly specified. Should the input RVML document not match the required document structure as required DTD, an error will be reported indicating the location and type of the error. As wrongly structured documents are a frequent cause of error, validation is extremely useful for debugging purposes. It is recommended to validate RVML documents frequently during development, however there is no need to revalidate existing correct RVML documents as validation requires additional computing resources. Validation against the RVML Schema, also located in the installation 'config' directory, is also possible when supported by the XML parser used, and the appropriate XML header is defined in the document. More information about configuring different XML parsers can be found in the Installation Readme.

Value Type	Boolean
	false No validation is performed on input RVML documents. The validation feature of the parser is turned off. true All input RVML documents are validated. By default, documents are validated against a DTD and a DTD must be specified in the header of the RVML document. All errors will be reported to the user.
Default Value	false

11.3.5 Logging Properties

11.3.5.1 kinesis.logging.logFile

KineticFusion logs all output to both the KineticFusion GUI console and to the application standard output. When this option is defined, it specifies an additional file for all logging output. This is useful when the output of the KineticFusion compiler or class analyzer is to be processed automatically to automatically identify errors or execution status. The behavior of the log file is further determined by the kinesis.logging.appendFile property

Value Type	File name
Default Value	None

11.3.5.2 kinesis.logging.appendFile

When the kinesis.logging.logFile property is defined, all log output is written to the specified log file in addition to the normal destinations. This property specifies the behavior of the application when writing to the log file. When true, the existing contents of the file remain unchanged and all new log output is appended to the log file. When false, all existing file content is discarded. If the file does not already exist, this option is ignored.

Value Type	Boolean
	false If a log file is specified, it is truncated on application startup true If a log file is specified, then all logged output will be appended to the specified file
Default Value	false

11.3.5.3 kinesis.logging.logActionScriptToConsole

When KineticFusion is running in GUI mode, all ActionScript messages are written to the output Warnings table. This option is used when running KineticFusion in command-line mode for defining whether ActionScript warnings should be logged to the normal logging console. It is overridden in the GUI by the persistent menu option View->Log ActionScript to Console thaqt defaults initially to false. When enabled, the entire text of the error message is printed out with the name of the file, the error ID, and the source line.

Value Type	Boolean
	false ActionScript warnings and errors are not logged to the console true ActionScript warnings and errors are logged to the console
Default Value	true

11.3.5.4 kinesis.logging.format

KineticFusion current produces all log messages in the following format:

Warning|Error :- (Error Number) Message
Location (as <FileName>, Line: <line>, Col: <col>)
Source Line

Some IDEs require log messages in different fonts that this. One such IDE is NetBeans that requires all location output to be in the form:

If the specified format canot be interpreted then the output defaults to the normal KineticFusion style. In the future, if it is desirable, we may use external templates to specify the logging format.

Value Type	String
	netbeans Use the NetBeans format for representing location information kf Use the normal KineticFusion logging format
Default Value	kf

11.3.6 ActionScript Properties

11.3.6.1 ActionScript Parsing Properties

11.3.6.1.1 kinesis.actionscript.analyzeScripts

All ActionScript defined within an RVML document or referenced by an RVML document can be in either AS 1.0 format or AS2.0 format. While the KineticFusion compiler accepts AS2.0 syntax for all scripts, this property can be used to indicate whether type-checking should be enabled and external classes referenced. When true, all declared types and class references are resolved using the defined class paths for the document or application. All referenced classes are compiled, analyzed and output in the resulting SWF document. Classes defined using AS 1.0 convention can still be used however intrinsic class definitions must exist on the class path for all such classes. When false, no RVML or included scripts will be analyzed and no external classes will be compiled into the resulting SWF movie. This property should be enabled for all AS 2.0 development environments.

Value Type	Boolean
	false All RVML movies are standalone, and references to external AS2.0 classes are ignored. true All scripts inside input RVML movies are analyzed for references to external AS2.0 classes. These classes are loaded as necessary and included in SWF movies.
Default Value	true

11.3.6.1.2 kinesis.actionscript.useMetadata

KineticFusion supports the definition of metadata for classes and class members. This enables additional constraints to be defined that implement concepts not supported in ActionScript such as 'final' abstract' and 'const'. This functionality is implemented using Javadoc comments that precede each class or class member declaration.
When this option is disabled, all defined metadata is ignored and not included in any semantic analysis. As metadata is only used to enforce constraints this will have no negative impact on compiling code however it is recommended that this option only be disabled for production environments or when it is suspected that metadata is being interpreted incorrectly. The application must be restarted when this property is changed.

Value Type	Boolean
	false No ActionScript class metadata will be parsed or used during semantic analysis true All defined ActionScript metadata will be used during semantic analysis
Default Value	true

11.3.6.1.3 kinesis.actionscript.enableWarningMessages

The KineticFusion compiler performs a detailed semantic analysis of all AS2.0 code. While the number of warning messages may appear overwhelming, each warning messages indicates the location of a possible error condition in the associated ActionScript code. While it is recommended that warning messages be disabled individually, should the warning be unwarranted, it is also possible to suppressed all generated warning messages. When this property is enabled, only messages configured as Errors will be reported to the user. This property should only be disabled for production systems which may speed compilation. For development systems it is recommended that warning messages be disabled only within a given RVML document or individually using the ErrorConfiguration.properties file. Otherwise legitimate warnings may be suppressed.

Value Type	Boolean
	false No warning level messages will be output for all AS2.0 script compilations. true All warning messages for classes on any of the user class paths will be generated.
Default Value	false

11.3.6.1.4 kinesis.actionscript.includePath

It is possible to include external source files into any internal or external ActionScript script using the #include directive. This property indicates the root paths used to try and locate all referenced include files. All path components must be separated with a semicolon. Relative include locations are only permitted from within included files, not directly within the RVML document e.g. '../include/includeMe.as' will only use the include paths to look up the AS file location, not relative to the RVML file itself. When a nested include directive is encountered in an external ActionScript file, the compiler will first search from the location of the referencing ActionScript file before searching the include path.

Value Type	String containing one or more directories, each separated by a semicolon
Default Value	The application CLASSPATH.

11.3.6.1.5 kinesis.actionscript.logCachedClasses

When KineticFusion compiles a class, it stores the class and all dependency information in an in-core class cache. When a reference is made to a class, the cache is first checked to see if an already compiled class definition exists is current. A cached copy of a class is used for subsequent documents providing the class itself and all of its dependencies have not changed. When analyzing dependencies, only interface changes in a dependent class trigger an automatic recompilation of a cached class. When this option is enabled, all class references that are served by cached classed are logged to the console. This option may be useful in a development environment but should be disabled in production environments.

Value Type	Boolean
	false No logging of classes retrieved from the application class cache is carried out. true All references to AS2.0 classes that are retrieved from the application class cache are logged.
Default Value	false

11.3.6.1.6 kinesis.actionscript.logParsedClasses

When a reference is found to an ActionScript class, the application class cache is firstly check to see if a current definition for class already exists. If the class does not exist in the cache or is not current, then the class is loaded from its ActionScript source. When this option is enabled, all class references that are compiled from ActionScript source are logged to the console. This option may be useful in a development environment but should be disabled in production environments.

Value Type	Boolean
	false No logging of parsed classes is carried out. true All classes that are compiled, or recompiled, from source will be logged
Default Value	false

11.3.6.1.7 kinesis.actionscript.packagesAreStable

When KineticFusion searches for ActionScript class references it scans all defined class paths for ActionScript files to build up a list of potentially valid class definitions. When this property is true, then the class path scan procedure is only performed once, and all discovered package hierarchies are cached for future use. This will speed up the compilation process as any external ActionScript class path is only checked once. However, when a user creates a new ActionScript class, it will not be discovered by the KineticFusion compiler without restarting the application. When this property is false, the class paths are scanned every time an RVML document is processed. It is recommended that this property is set to true for production systems.

Value Type	Boolean
	false Available classes are discovered before analysis of each RVML document referencing AS2.0 classes. true All possible class files are discovered when a class path is first referenced. The creation of new class files will not be picked up by the compiler.
Default Value	false

11.3.6.1.8 kinesis.actionscript.slashIDSupport

Slash notation was used for identifying symbols such as movie clips and buttons in the Flash 4 player. All symbols were identified by a full path using notation very similar to that used in navigating directory hierarchies. The root timeline was identified by '/', a symbol 'x' placed on the root timeline was identified by '/x' and a property of the symbol 'x' identified by '/x:property'. The current 'dot' notation superseded this notation in the Flash 5 player, and this notation is no longer used for most purposes. However, SWF movies containing Slash notation can be successfully decompiled, and it will be necessary to enable this property to recompile the RVML. Slash notation is forbidden in ActionScript 2.0 as the syntax 'a:b' is ambiguous, and when compiling a movie with an SWF version of seven or higher. An additional constraint when Slash notation is enabled is that a space is mandatory after all colons within conditional expressions to avoid ambiguity. All in all, it is recommended to disable this property unless slash notation support is absolutely necessary.

Value Type	Boolean
	false Slash Identifier support in ActionScript is not supported on RVML input true All Slash Identifier constructs are correctly parsed as normal identifiers.
Default Value	false

11.3.6.1.9 kinesis.actionscript.systemClassPath

This property defines the location for intrinsic classes and optional component classes referenced in RVML documents or by the Class Analyzer. Analysis and compilation of classes located on this path are treated differently than those on the user class path. The key differences are:

The package names "System" and "TextField" are permitted on this class path. These packages share the same name as classes and this is forbidden by the KineticFusion compiler. However, since these classes and packages are intrinsic and defined within the player, they are permitted.
All compilation warnings for classes on the system class path are discarded. This is extremely useful when working with class hierarchies from 3rd parties. As it is expected that these hierarchies are tested and stable then warning messages are disabled. This permits a development group to implement coding standards that may conflict with those of 3rd parties. The system class path is a good location to place the V2 component classes, if they are used by the user.

The installation classes directory contains a set of intrinsic class definitions shipped with KineticFusion. On installation, the systemClassPath property in the config/KineticFusion.properties file is set to this directory. Multiple class path elements can be defined on the system path: they must be separated by a semicolon character (';'). Note: the System class path is searched AFTER the user class path so it is possible for a user to override a system class with a class on the user class path.
If a class path element contains sub-folders of the form FP<Version> (for example, FP7 or FP8) then the folders will be interpreted as version-specific class folders and the contents of the sub-folders will be used for locating classes depending on the output version.

Value Type	Single directory location of root of system class hierarchy
Default Value	None

11.3.6.1.10 kinesis.actionscript.useCachedClasses

When KineticFusion compiles a class, that class is stored in the application class cache. As long as the cached class is considered to be current, it will be returned for all future references to the class. Classes are added to the cache after successful compilation providing no compilation errors are found, however all compilations warnings are ignored. When this property is set to false, then a reference to an ActionScript class results in the class being compiled from source. This may be useful when a user wants to see all compilation warnings generated for a particular RVML document. When false, then the class cache is used to try and resolve all class references. It is recommended that this property is set to true for production systems.

Value Type	Boolean
	false ActionScript classes are reparsed and warnings regenerated for each RVML document. true Class files are not recompiled between RVML documents unless necessary due to the class or its dependencies being modified
Default Value	true

11.3.6.1.11 kinesis.actionscript.userClassPath

KineticFusion permits compilation of ActionScript classes referenced in RVML script blocks or using the Class Analyzer. This property specifies the list of root class directories to be used for locating all user classes. Multiple path components can be specified and all path components must be separated with a semicolon(';'). All classes parsed from these locations are subject to strict error reporting (subject to the enableWarningMessages property). When a class reference is found, each class path component is searched in the order in which they are defined in the property value. If a referenced class cannot be found on the user class path, the system class path is then searched.
If a class path element contains sub-folders of the form FP<Version> (for example, FP7 or FP8) then the folders will be interpreted as version-specific class folders and the contents of the sub-folders will be used for locating classes depending on the output version. Normally, such a path structure is suitable only for the intrinsic classes and is only located on the system path.

Value Type	String containing one or more directories, each separated by a semicolon
Default Value	None

11.3.6.2 ActionScript Code Generation Properties

11.3.6.2.1 kinesis.actionscript.logLoadedClasses

It can be unclear, when creating a SWF movie containing AS2.0 classes, what classes are included in the SWF. ActionScript classes can reference many other ActionScript classes and this can result in SWF movies becoming larger than expected. It is also possible that classes that are intended to be distributed with the SWF movie are omitted. When this property is enabled, all classes stored in the output SWF movie are listed on the console in the order in which they will be created.This is useful to verify that all desired classes are loaded and to verify the load order of specific classes. If a dynamic reference to a class is required that affects the load order, this can be specified with the IncludeClass element in RVML. This option can be useful in a development environment but should be disabled in production environments.

Value Type	Boolean
	false No logging of used classes is carried out. true All AS2.0 classes embedded in an output SWF movie are listed, in the order in which they will be loaded.
Default Value	false

11.3.6.2.2 kinesis.actionscript.optimizeFunctions

Flash players with a version of 6.0.65 and higher include new ActionScript optimizations. The effect of these optimizations are to reduce the invocation time for global and anonymous functions, and greatly speed up the execution of functions containing parameters and local variables. In addition to this speed increase, a side effect of these optimizations is that resulting SWF movies are smaller in size. This works primarily by changing local variable references to quick lookups, removing the variable name and replacing it with a table index. While there are many benefits to this, there are a few caveats also:

SWFs produced that contain this optimization will only run on players of Versions 6.0.65 or higher
The names of all local variables will be deleted and will not exist on decompilation
Any variable accessed within a With block cannot be optimized
No block containing an eval statement within the block or child block (e.g. a function within a function) can not have its variables optimized since the variable names may be required by the eval statement at runtime. If eval statements are used, but only reference global variables then it is a good idea to add a new eval() method to the String prototype or reference a global function that performs the eval operation instead.

Value Type	Boolean
	false No optimization of ActionScript is carried out. true All ActionScript functions will be analyzed and qualifying functions will be compressed using new optimization techniques supported in Flash Player Version 6.0.65 and higher.
Default Value	false

11.3.6.2.3 kinesis.actionscript.removeTraceStatements

Trace function calls are frequently used for debugging scripts. The trace() function is a native function and it normally used to print statements to a debugger, during development. Rather than remove all trace statements manually, it is possible for KineticFusion to remove all trace() function calls from generated code. This will increase both execution speed and reduce the output movie size. Removing trace statements may have side-effects however, as the expression passed as an argument to the function is also discarded e.g.

i=0;
while( i < 10)
trace( i++); // discarded so loop becomes infinite

These side effects can also be useful as the trace() function can be used to embed enhanced debugging calls during development, and these can be stripped out automatically on production e.g.

trace(myLocalConnection.printValue( value));

Value Type	Boolean
	false All trace() functions are output by the compiler true All trace() function calls and their arguments are removed by the compiler
Default Value	false

11.3.6.2.4 kinesis.actionscript.replaceTraceStatements

Trace function calls are frequently used for debugging scripts. The trace() function is restricted to the Macromedia Flash development environment and trace output cannot normally be caught from a running SWF movie. Thankfully there are a growing number of powerful third-party logging components and debugging tools available that provide superior functionality.

This property specifies an ActionScript code fragment that is used to replace all trace() statements at compile-time. The code fragment is normally a single line of code but it can also contain multiple statements separated by semicolons.

In order to ensure that this feature is fully compatible with the Macromedia compiler, the trace statement that is replaced is case-insensitive and must have a single argument.

The script fragment used to replace the trace statements supports placeholder identifiers so that the specified logging script can receive all expected parameters. The following placeholder identifiers are currently supported:

__ARG: The single argument to the original trace statement
__CLASS: The name of the class containing the trace statement. This is a String constant.
__METHOD: The name of the class method containing the trace statement. This is a String constant.
__FILE: The name of the file containing the trace statement. This is a string constant.
__LINE: The line on which the trace statement was defined. This is a numeric constant.

For example, to replace all trace() calls to call to a static method if a logging class, the trace statement could be represented as:

com.kinesis.Trace.log(__ARG, __METHOD, __CLASS);

Care should be taken that the code that performs the tracing functionality does not, itself, contain a trace() statement as this can cause an infinite loop.

Developers have a choice of how they wish to continue to add tracing statements to an application. Our recommendation is to continue to use the trace() method as trace statements can be completely removed from an output SWF using the kinesis.actionscript.removeTraceStatements configuration option. By continuing to use trace statements, different logging frameworks can be plugged in and out of your SWF application without changing a single line of code.

Value Type	String
Default Value	none

11.3.6.2.5 kinesis.actionscript.setterReturnsValue

ActionScript classes provide for class properties that are defined as methods using additional get/set qualifiers. KineticFusion correctly translates these methods to properties however there are two different conventions for the implementation of the 'setter' method. Classes compiled using the Macromedia compiler add an additional automatic invocation of the 'get' method of a property at the end of the 'set' method. Hence, every time a property is set, the 'get' method is also called. While it may be envisioned that this is necessary for expressions in which the property is used in an assignment chain( e.g. var = property = value;), in practice the 'value' expression is the expression passed back to all assignees.

KineticFusion, by default does not return the value from an assignment to a property. As a result, property accessors execute quicker and display more intuitive behavior. This property can be enabled, however, for code that depends on this feature. Note: it may be necessary to enable this property should the 'get' property methods of a class be required to exhibit similar behavior under multiple ActionScript compilers.

Value Type	Boolean
	false No AS2.0 'set' property methods will have an implicit return value generated. true At the end of each 'set' property method, an implicit call is made to the 'get' method for the property.
Default Value	false

11.3.6.2.6 kinesis.actionscript.warnBlockSize

The is an implicit restriction of 32765 bytes on the size of the executable code within an ActionScript class. This limit is due to a restriction on the implementation of classes within the Macromedia compiler - while it is possible to get around this restriction, it would mean that classes would only compile with KineticFusion so we have chosen to also enforce the restriction. The 32K limit includes all embedded String constants but it does not include any String constant tables. This can make it difficult for a developer to know when the class size is approaching the 32K limit.
This option defines a logging threshold for the number of executable bytes that are permitted in any ActionScript block (including inline RVML blocks). When the number of generated bytes exceed the specified value, a log message is output specifying the name of the class (or location of the block) and the actual size of the generated bytecode. This can be used as an early indicator to refactor ActionScript classes. The threshold does not include the size of the String constant table which can have an independent size of 64K for each block.
It is possible to get the size of all output blocks by setting the value of this property to some low number e.g. 1. This will then print out the size of all ActionScript bytecode blocks as they are being generated.
Note that when the 32K limit is exceeded, KineticFusion will automatically perform additional space optimization on embedded String constants which will generally provide several thousand more bytes of breathing space - this will be logged on the KineticFusion console and it is highly recommended that classes are refactored at this stage.

Value Type	Integer
	0 No threshold monitoring is performed > 0 The threshold number of generated 'executable' bytes after which logging occurs
Default Value	0

11.3.7 Component Properties

11.3.7.1 kinesis.components.path

KineticFusion is able to include SWC components in both compilation and decompilation without having to specify the entire component as RVML. This configuration property can be used to specify one or more folders in which to look for referenced SWC components. The path can be a compound path with each path component separated by a semicolon.
Once the paths are defined KineticFusion will automatically search the specified folders and all sub-folders for SWC files. During decompilation, the specified paths are used to identify components whose assets can be removed from the output RVML document, if the kinesis.components.resolve property is set.

Value Type	String containing one or more directories, each separated by a semicolon
Default Value	None

11.3.7.2 kinesis.components.resolve

SWC components, when represented in RVML, can needlessly complicate RVML output, adding all the symbol definitions and resources to the output RVML. When this property is set to true, all defined components on the component path (see the kinesis.components.path property) are retrieved and the input SWF is automatically checked for each component. Each discovered component is automatically removed from the RVML output and replaced instead with a short Component element that specifies that the component should be included in the SWF on compilation.
It should only be necessary to include SWC components in RVML output if a developer does not have access to SWC component archives or wishes to modify the component or its assets in some way.

Value Type	Boolean
	false The RVML is output containing all embedded SWC component assets and symbols true The RVML is output with only placeholders for SWC components and all associated symbols and assets are stripped from the RVML
Default Value	false

11.3.7.3 kinesis.components.logMissingAssets

KineticFusion will only resolve embedded components from an SWF if it can ensure that all the contents of the component exist within the SWF. This ensures that SWFs containing symbols with the same name as components are not accidentally identified as components and removed. However, should the assets associated with an external component be augmented since the component was added to the SWF, KineticFusion will not be able to fully identify the component. When this option is enabled, KineticFusion will log all the required symbols in the component that do not exist in the SWF. If the developer know that the component is the correct component, then these logged assets can be added to the kinesis.components.ignoreAssets property to resolve the component regardless.

Value Type	Boolean
	false Components that cannot be fully identified are ignored true All missing assets of potential components are logged
Default Value	false

11.3.7.4 kinesis.components.ignoreAssets

KineticFusion will only extract embedded components from an SWF if it can ensure that all the contents of the component exist within the SWF. If a component has been upgraded since the SWF was originally created then the assets in the component may not match the assets stored in the SWF. In this case, it is still desirable that the component be identified and resolved so that the RVML will reference the most up-to-date component on compilation. This property defines a list of space-separated or comma-separated names representing assets that are not required within an SWF in order to resolve embedded components. This option is only applicable if kinesis.components.logMissingAssets option, used to retrieve the list of missing assets, is enabled.

Value Type	String containing one or more asset names separated by comma or space characters
Default Value	None

11.3.8 Datasource Properties

11.3.8.1 kinesis.datasources.globalLocation

KineticFusion is able to include dynamic data from external datasources when compiling RVML. Each RVML document can have any number of datasources defined within it however it is also possible to define a single global datasource for the application. The values defined in this datasource are available to all RVML documents compiled by the application. It can be used to define global paths, dimensions, colors, or any other arbitrary data that can be referenced within RVML either within attribute expressions (using the syntax ${expression}) or Template elements.
The global datasource is a Java properties document containing data in the form dotted_name=value.
This property defines the location of the global datasource, and is specified as either an absolute file name or URL. The type of the location defaults to 'File' but this can be changed with the kinesis.datasources.globalType property.

Value Type	String representing a single file or URL
Default Value	None

11.3.8.2 kinesis.datasources.globalType

KineticFusion is able to include dynamic data from external datasources when compiling RVML. The location of the global datasource is specified using the kinesis.datasources.globalLocation property. By default, this property references a file but this property can be used to change the interpretation of the location to a URL

Value Type	String
	File The specified location should be interpreted as a file URL The specified location should be interpreted as a URL
Default Value	File

11.3.9 Template Properties

11.3.9.1 kinesis.templates.templateRoot

RVML can be created dynamically when processing an RVML document by using templates. By default, KineticFusion automatically supports the FreeMarker templating language. When Template elements are found within an RVML document, they can be defined either inline or taken from an external template file.
When external template files are used, the location specified on the Template element is relative to the template root folder as specified by this property. All templates used in RVML processing must reside under this folder and the system will not permit file addresses outside this location. This property is ignored for Template locations specified as URLs.

Value Type	String representing a single folder under containing all template files
Default Value	The startup folder for the application, as identified by the user.dir property (the value of this can be displayed, when running the GUI, in the Help->About KineticFusion->System tab).

11.3.9.2 kinesis.templates.defaultEncoding

When an external template file is being loaded for processing, it is important to know the encoding of the template. Where an encoding is not explicitly specified in RVML for a particular template, the value of this property is used to specify the encoding of the template. It will default to the standard Latin encoding unless explicitly specified.

Value Type	Encoding String
Default Value	ISO-8859-1

11.3.9.3 kinesis.templates.defaultLocale

Some of the template operations require the outputting of text, numeric and date information. The default locale of the application is used to format these strings in accordance with rules specified by the output operations. A specific locale can be specified for each template specified in an RVML document. When no locale information is specified, this property is used to define the locale of the template.

Value Type	Locale String
Default Value	Default application locale

11.3.9.4 kinesis.templates.logOutput

Templates can be used to generate complex RVML or text. To aid in the debugging of these blocks, KineticFusion can log the output of a template before further processing. In this way, the developer can see the result of the template execution.

Value Type	Boolean
	false The template output is not logged but passed direvctly to KineticFusion to process true The template output is logged in addition to being passed to KineticFusion for processing
Default Value	false

11.3.10 Tag Library Properties

11.3.10.1 kinesis.xml.tagLibraryConfigFile

KineticFusion is able to process RVML documents that include XML tags from namespaces other than the default RVML namespace. This enables developers to create handlers to perform application-specific functionality that may not be straightforward in standard RVMl, or to support other XML dialects embedded inside an RVML document. Handlers for a single namespace are generally packaged into a single location or jar, and the namespace and factory class for the namespace defined in the Tag Libraries configuration file. This property defines the location of the configuration file to use to resolve external tag libraries.

Value Type	String representing a single file
Default Value	None



Previous 11.2 KineticFusion Properties Summary	Home Up One Level