|
Description:
TMultiProperty
component is destined for creating multilanguage and multiinterface
applications. It allows to change properties of components after project
compilation.
Work principle is the following: the component is placed on
one of the forms of the project (doesn't matter on which one), its
properties are set correspondingly. Two files, needed for proper work of
the component, can be created in design-time before final compilation of
your project.
- Pattern-file of the project, holding the names and types of all
the components together with names, types and values ranges of their
properties;
- "Native" value-file of these properties in binary DFM
format.
These two files are created together. In "native" values
of properties are those that were set at the moment of creation of
the value-file. If creation of the files was performed:
- in design-time, then content of the "native"
value-file is same as content all DFM files of the project.
- in run-time, then the values written to the file will be those
assigned at the moment, and may differ from the values in DFM
files. Also be aware that not all components are created
simultaneously. For example, pattern and values files can appear
incomplete, if created in OnCreate event.
After creation of these files it becomes possible to create
own value files. It's easy to do with the help of MultiEditor,
which is distributed together with the component. Basically,
pattern-file is required only for editing of the value-files in
MultiEditor and is not needed for the work of the application
itself. That's why you can safely move it to other folder after project
compilation, since its size can be very large.
After creation of new value-files they can be loaded to compiled
application. This will change the appearance of the application
correspondingly to the information in value-files. This can be done on
application run though command line params (corresponding option should
be turned on in component).
Features:
This component is a good alternative to many existing
interface-translating systems, such as
Multilizer and etc. Primary advantages of the
TMultiProperty over competing are the following:
- The tool works on the
application level, i.e. is a part of it. It doesn't require
recompilation and reload of the application. It can be configured
using command line params (temporary turn on/off, recreate files,
load value-files).
-
MultiEditor is packaged together with the component. It
allows to create new value-files without the application. Only
pattern-file and preferably "native" value-file are
required.
- It possible to change
values of all properties (except binary) of all components,
including non-standard, non-visual, with complicated object
properties. In addition, you can filter components by names and
classes at the moment of pattern-file creation.
- Creation of
value-files can be performed by the end user him/herself. Programmer
can limit user's access to the editing of some values. Properties or
components can be made invisible or read-only.
-
The format of value-files
is standard binary DFM format, and can be used by other programs. In
addition, the size of value-files is small enough. But have in mined
that the size of pattern-file can be large (about tens megabytes)
-
Loading of value-file can be performed at the initialization of
application (reading ValueFile value from DFM, registry or command
line) or at any other moment of program execution.
|
