Menu
▾
▴
Tree [b913e1] master v2.362 / History
nune
Read Me
Introduction
This is the README file of Instigate Application Framework Version 2.362 developed by Instigate Design CJSC.
CONTENTS
1. Getting Started
2. Prerequisites
3. Compilation
4. Installation
5. Usage
6. Troubleshooting
7. Maintainers
8. Future Scope
1. Getting Started
The main goal of Application Framework is to provide set of libraries
and tools to improve performance of R&D, QA, Applications, Tech Writers
and Managers teams working on a SW product. This was specifically created
to increase performance and competitiveness of Instigate Design CJSC in its
main business - Software and Hardware Design services and consulting.
Special tools and libraries are available for EDA tools in particular,
however the framework is far more general than a typical EDA-specific
application cockpits and databases. Examples of non-EDA SW that would
benefit from Framework equally well are:
- Integrated Development Environments for programming languages,
which include source level debuggers, profilers, etc.
- Embedded applications for mobile devices, such as
video/audio/photo players/viewers, e-mail/IM clients, etc.
- General purpose applications such as file managers,
Web Browsers, Word Processors, etc.
The main distinguishing factors of Instigate Application Framework from
other similar projects and systems are:
- The Framework was designed based on real need at Instigate Design to
develop very different types of applications for very different
customers. Therefore it is based on real use-cases and
user-stories, and not hypothetical problem statements and
contemplation "in the vacuum" about what such Framework should do.
- The Framework is fundamentally based on the embedded scripting
language, which provides huge benefits such as: automatic
support of basic database operations in both GUI and Command
Line interface; automatic serialization (persistency) of
in-memory data structures onto disk database; automatic
generation of high-quality reference-manual for users of the
application; automatic support of modern GUI features such as
copy/cut/paste, undo/redo, drag'n'drop, and many others.
- The level of abstraction from GUI Look & Feel details
is unprecedented and allows to write same code and use it
with GTK+ and in future other underlying toolkits.
Similarly the level of abstraction from underlying scripting
language allows to write same code and obtain application with
TCL, Python, JS, Guile support and in the future also with other
languages.
Finally, level of abstraction from underlying persistence
mechanisms allows to save/load the data in XML and TCL formats.
- Cut/Copy/Paste, Undo/Redo, Drag'n'Drop are fully implemented.
- Export documentation is available both for the application and
the document being edited by the application (if applicable).
- Weak notion of "error" and support of "permissive" operation
is available
- GUI dialogs are auto-generated, and support complex dynamic
scenarios
- Automatic Replay of actions is supported to create demo scenarios
of the Application using scripts
- Build system support with various types of packaging
- 3 OS versions are supported (Ubuntu 22.04, CentOS7 and Bagrevand 12.*).
2. Prerequisites
For each OS corresponding script is supported to install prerequisites. They are
located at ./utl directory:
- install_prerequisites_bagrevand.sh
- install_prerequisites_ubuntu.sh
- install_prerequisites_centos.sh (is not ready yet).
Please use appropriate install_prerequisites_<OS>.sh script when performing
upcoming instructions.
To install prerequisites please follow these steps:
a) Run ./utl/install_prerequisites_<OS>.sh script to install all required
native libraries and Instigate FOSS libraries on your environment.
User can specify his/her own <install_prefix> path via '-p' or '--prefix'
options.
All tools/libraries will be installed at
<install_prefix>/instigate-software' path.
By default <install_prefix> will be '/opt/'.
If default path is used you should run the script as a root user:
sudo ./utl/install_prerequisites_<OS>.sh
System tools and third party libraries will be installed at
<install_prefix>/instigate-software/gnu_system path.
Instigate FOSS libraries will be installed at
<install_prefix>/instigate-software/os3/2.0 path.
b) Create symbolic link in /tmp pointing to install directory:
ln -s <install_prefix>/instigate-software /tmp/instigate-software
The path to Instigate FOSS libraries should be specified to
INSTIGATE_OS3_PATH env variable in the top level makefile:
export INSTIGATE_OS3_PATH := /tmp/instigate-software/os3/2.0
This value has been assigned in top level makefile by default.
Note: You can create the symbolic link at a different path, but be sure
to set INSTIGATE_OS3_PATH environment variable accordingly.
export INSTIGATE_OS3_PATH := <your_path>/instigate-software/os3/2.0
Note: If a symbolic link is created in the /tmp directory, it must be
recreated after each system restart.
3. Compilation
ATTENTION!!!
If it is required to build the project only for 64 bit machine due to missing
gcc multi-lib support (32 and 64) update the following makefiles:
- src/sockets/makefile
- src/threads/makefile
- src/vcd_core/makefile
by replacing
'#include $(mkf_path)/lib_lib32_64.mk'
line with
'#include $(mkf_path)/lib_lib64.mk' in the makefile
Otherwise the project will be built for both 32 and 64 bit machines.
Compile the package as follows:
a) Configure build parameters by issuing 'make setup' command specifying:
- release or debug build (default is debug):
make setup build_type=<release|debug>
- static or dynamic linking (default is dynamic):
make setup link_type=<static|dynamic>
- enable using sdk:
make setup use_sdk=yes
By default sdk_path is set to:
/tmp/instigate-software/gnu_system/3.2/x86_64
If you've created symbolic link elsewhere, specify it during
'make setup' command as follows:
make setup use_sdk=yes sdk_path=<your_path>/instigate-software/gnu_system/3.2/x86_64 build_type=release link_type=dynamic
Note 1: all options should be specified during a single 'make setup'
command.
Note 2: Based on link_type either static libraries (.a) or shared
libraries (.so) will be built.
b) Build the library using 'make' command.
Multi-threaded build is supported, e.g. "make -j4" will run 4 parallel
threads if you are running it on a quad-cpu computer.
Additional features:
a) Run basic tests via 'make test' command.
Test results will be available in 'test_results.txt' file and
'tst_results' directory.
b) Generate documentation via the following commands:
- make user_docs
- make developer_docs
The generated documentation will be available in the 'doc' directory.
c) Cleanup results of previous build via 'make clean' command.
4. Installation
Use 'make install' command which will install the package under the
directory specified by the variable 'install_path'. The variable is
defined in the top level makefile and defaults to
$INSTIGATE_OS3_PATH/framework/<version>/<arch>_<build_type>
The value of 'install_path' variable should be used in the
applications which are using Instigate Application Framework
(see '5. Usage' section for details).
5. Usage
In order to build application against Application Framework you will need
to point to it from the makefile of your application using the variable
INSTIGATE_ENV_FRAMEWORK_ROOT.
Sample Application (media_payer) is provided as an example of Application
Framework usage within this package. You can move it outside the package and
use it as a standalone application.
Please follow user-guide.odt file for the details.
6. Troubleshooting
The framework has been developed to base on 80% principle, to cover
80% of the most common use-cases in GUI/UI design.
The next version is going to consider all the currently covered use-cases
as basis, and will provide more coherent and elegant solution to all.
The underlying GTK+ framework version is quite stable, but in addition
we are using the C++ wrapper (GtkMM) libraries, which are relatively less
stable.
7. Maintainer
Instigate Design CJSC
e-mail: info@instigatedesign.com
Phone: +374-60 510-710
8. Future Scope
a) Main goal: maximally merge Application Generator and Framework into one
- this means that Framework classes should be defined in AppGen
- the 100% fusion would result in something like Smalltalk
- probably due to C++ being a compiled language that goal will not be
reached, also because we want to remain non-intrusive
in the case that user has own DB (not created with AppGen).
- the 100% fused version is already being developed in parallel
as part of Metax/Mani framework (https://instigate.academy).
b) Second major goal: complete interoperability between scripting languages
- TCL should yield its prime role to unified C++ OO CRUD API
- the C++ OO CRUD API should contain all major methods for
traversing/modifying data hierarchy and invoking functions
i.e. top() - get session, get()/set() - for properties,
create()/destroy() - for owned collections and
add()/remove() - for compositions,
call() - for methods and functions.
- the same commands should be published in TCL/Python/JS/Scheme/etc
and replace the vast amount of <type>_set_<property> and
similar commands in the current framework.
- it should be possible to also add methods written in e.g. Python,
i.e. c++ should not be the only language to write functions
or methods.
- in case of 100% fusion: we should be also able to define classes
in Python / JS / etc and have them fully interoperable with
C++ and each other.
c) Third major milestone would be adding Metax ODM as back-end, which would
allow to interoperate with Manifest framework, especially for
apps generated using AppGenerator.
- Currently DB is automatically saved in XML, we can add JSON support
and instead of storing it in file-system, store in Metax
- we further can extend FWK to make JSON schema a first class citizen
in framework, equivalent in capabilities to classes manifested
via C++ API.
- 100% fusion would assume same as described in point (a) above.
