
Welcome to ChartFolio!

Section 0.1 - Introduction

Welcome to ChartFolio!  The intent of this chapter to introduce you to the 
ChartFolio Products, and give you an overview of the following topics:

·  What the ChartFolio Framework/API products are
·  How these products are deployed
·  How to find documentation for these products
·  How to build your ChartFolio component libraries
·  How to resolve any problems with the products
·  What the next steps to using ChartFolio are

Section 0.2 - The ChartFolio Product Line

The ZAF-based ChartFolio product line currently consists of a set of 
source code and documentation that yields a set of C++ static libraries 
that are completely compatible with any ZAF-based application.  Any 
programmer who uses the ZAF C++ cross-platform GUI libraries can use 
the ChartFolio libraries to rapidly deploy ZAF-based chart-objects into 
their software programs, saving valuable time and resources.

These ChartFolio libraries are a collection of C++ source code files, 
interface definition header files, application resource files, and 
documentation.  They also include a set of demo programs which serve as 
a set of samples for the product's task-oriented tutorial approach to 
documentation.

The ChartFolio Libraries are currently deployed as a set of "leveled" 
libraries - where each product level implements an increasing set of 
charting functionality and features. For more details on ChartFolio's 
leveled-architecture, see the appendix on "ChartFolio Architecture."

The current ChartFolio Framework/API product library set includes:

0.2.1	The ChartFolio Framework/API Library:

The ChartFolio Framework/API library implements a API (Application 
Programmer Interface) to deploy a "chart-object" into the ZAF library, 
in the form of a ZafWindowObject-derived class called ZafChartControl.  
ChartFolio also implements a very open-ended framework for extensible 
"Chart-Models", "Chart-Engines" and other associated "Chart-Objects".  
If you need to extend the ChartFolio framework to provide customized 
functionality specific to your own particular application, you will 
find this to be a easily-understandable and straight-forward task.


Additional ChartFolio products will include:

0.2.2	"ChartFolio Real-Time" (an advanced Real-Time Interface):

The ChartFolio model-view-control architecture has implicit real-time 
data-update capability built into the framework. The ChartFolio Real-Time product will provide an explicit implementation of this implicit real-time capability as a set of pre-packaged extensions to the standard ChartFolio Framework/API product.

0.2.3	"ChartFolio Interactive" (an advanced User Interface):

The ChartFolio Interactive product deploys a set of extensions to the 
standard Framework/API product which implement a set of custom controls 
and dialog objects that interface directly to the ChartFolio API.  
These custom dialogs and controls enable application end-users to 
manipulate the run-time attributes of any Interactive-enabled chart 
object via a chart-format dialog.

The ChartFolio AUI product will also serve as an excellent example 
and benchmark for advanced C++ programmers who will want to extend 
the open-ended architecture of the ChartFolio framework.  Just as 
ZAF based C++ programmers soon learn how to extend the base ZAF 
window objects into their own customized window objects, ChartFolio 
programmers can also extend the ChartFolio framework to provide 
customized charting functionality for their ZAF applications.

Note that as of the time of this document, these new products are 
still under development and testing.  ChartFolio programmers who have 
purchased pre-release/beta licenses for these products will have access 
to all updates of these new products up to and including their initial 
commercial releases.

Section 0.3 - Copyrights and Licenses

0.3.1	ChartFolio Source Code License Agreement

The rights and responsibilities of your licensed use of our source 
code software component libraries are defined in your software license 
agreement.  A copy of this agreement is located in the subdirectory: 
"~\cf_zaf\read_me", in the text file: "cf_licen.txt".  Our copyrights 
are in the text file "cf_copyr.txt".
0.3.2 	What This Really Means:

We are in business to sell source code licenses for our cross-platform 
C++ component libraries.  There are a lot of benefits for our customers 
which come from having direct access to this C++ source code we produce, 
such as having direct ability to extend our class library framework, 
and not having to "fly blind" if there are ever any problems with the 
code that need to be solved.  We don't like working with stuff we can't 
see "all the way to the bottom", and we figure that you do too - so 
we make sure that you can always see what is going on with our products!

When you use ChartFolio we become, in essence, an extension of your 
software development team.  You might want to think of us as a set of 
"invisible programmers" on your software development team who work 
with you and deliver high-quality, pre-tested code into a set of specific 
directories for your use.   The bottom-line: our products are going to 
save you a lot of time and headaches, and knock weeks (if not months) 
off your development timeline.

Another benefit to having our source code in your hands is that it 
protects your business.  You trust us by putting part of your business 
requirements - charting - in our hands.

We in turn trust you by licensing our complete source code for your 
non-competitive use on a royalty-free basis.  Our philosophy is that 
we come to be - in essence - your business partners. We figure that 
if we do our job right, solve your challenges, and fulfill your needs, 
you are going to want to continue our relationship, get new and improved 
versions of our products, and... "leave the charting to us"!

Section 0.4 - Deployment of the ChartFolio Products

The ChartFolio product is typically delivered as an encrypted archive 
in the popular ZIP file format, which is configured as follows:

~/cf_zaf/               "ChartFolio for Zinc/ZAF"
 |
 |____/demo/...         A Collection of demo programs...
 |                      (*.hpp, *.cpp, *.mak files)
 |
 |____/doc              Product documentation in MS-Word
 |                      (*.doc) and/or HTML (*.htm) formats
 |
 |____/include          Header (*.h, *.hpp*) files:
 |    |
 |    |_____/cf_api       for the ChartFolio API product
 |
 |
 |____/read_me          Product Read-Me! (*.txt) files
 |
 |____/src              Source (*.cpp) files
            Library (*.mak) makefiles


Section 0.5 - Documentation for the ChartFolio Products

Electronic Documentation for the ChartFolio Products is delivered 
as a set of HTML (*.htm) files for maximum deployment flexibility. 
These files are located in the cf_zaf\doc sub-directory. The master 
HTML index-file is named: "cf_index.htm".  Printed sets of product 
documentation are also available for a nominal charge directly from 
DPC Technology Corporation.

Section 0.6 - ChartFolio-for-ZAF Installation
	
Once the library files have been installed (un-zipped), a few 
additional steps must be performed before the libraries and demos 
can be built.

PC users: Before building the libraries, the following environment 
variables must be set:

	CF_ZAF - specifies the location of ChartFolio's root directory.  
		For example:

		set CF_ZAF=c:\cf_zaf

	INCLUDE - specifies the path used to find include files.  
		Most likely, this variable was already set when ZAF 
		itself was built.  ChartFolio requires that its own 
		include path be added to this variable.  For example:

		set INCLUDE=c:\bc5\include;c:\zaf5\include;c:\cf_zaf\include

Unix users: Before building the libraries, a script must be run in 
order to determine the desired environment and correctly configure 
makefiles.  This script is called minstall, and resides in the 
ChartFolio root directory.  Simply type minstall - it will ask where 
ZAF is installed, what operating system/compiler is desired,  and 
which various compiler options are desired.


Section 0.7 - Building your ChartFolio-for-ZAF Library

The process of building a working ChartFolio library is designed 
to be as close to building a working set of ZAF libraries as possible.  
For PC compilers, ChartFolio uses Zinc's zmake utility, and supplies 
a zmake.mak file used to build the library.  For Unix users, the 
standard Unix make utility is used, and a posix.mak file (converted 
to a Makefile by the aforementioned install procedure) is used.

To build the library, change directory to the ChartFolio source 
directory and issue a make command.  For PC users, the commands 
would be:

	cd %CF_ZAF%\src
	zmake win32
	(or zmake win16)

Similarly, Unix users would issue the following commands:

	cd $CF_ZAF/src
	make

The library is placed in the same directory where ZAF libraries 
currently reside.  For PC users, this directory is 
%ZAF_ROOT%\lib\%ZINC_COMPILER% (for example, c:\zaf5\lib\borland).  
For Unix users, this directory is $ZAF_ROOT/lib.
Section 0.8 - Building your ChartFolio-for-ZAF Demos

The process of building a set of ChartFolio demo is similar to 
the above process for building the ChartFolio library.  Each demo 
subdirectory contains a zmake.mak file (for PC compilers) and a 
posix.mak file (for Unix compilers).  Thus, PC users can build a 
demo by typing the following:

	cd %CF_ZAF%\demo\d1_hello
	zmake win32
	zmake win16

Similarly, Unix users would issue the following commands:

	cd $CF_ZAF/demo/d1_hello
	make

To easily build the entire demo suite in one step, make-all 
procedure files (a .bat file for PC users, and a Makefile for 
Unix users) are also available, and reside in the demo root 
directory.


Section 0.9 - Technical Support for ChartFolio

If you have an issue or problem with the ChartFolio products 
that you need to report, you should fill out an issue report 
(located in file: "cf_zaf\read_me\cf_issue.txt") and email it 
to: support@dpc.tech.com.

As improvements, bug fixes and new products are released, they 
are made available by rolling them into the current version of 
the "perpetually-ready-to-ship" version of the product we keep 
at our Internet FTP drop-box (ftp.dpc-tech.com).  These encrypted 
ZIP archives follow the same format as the regular product (they 
essentially ARE the latest version of our product) so getting 
product updates takes minutes, not days or weeks!

Licensed customers of DPC Technology will have the current set 
of access passwords and/or encryption keys to download any new 
versions and update their ChartFolio product with the latest 
changes and improvements: 24 hours a day, 7 days a week, every 
day of the year!

ChartFolio customers also get 60 days of update service for free 
when they first license the ChartFolio product.  You can extend 
this update service with a yearly maintenance program that we 
offer as a service.  In essence, because we are committed to 
keeping the ChartFolio product on the leading edge of proven 
C++ technology, you will enjoy the benefits of a "continuously 
improving" product!

This is a very powerful mechanism for technical support.  
Because many ChartFolio customers are already network users, and 
are comfortable using Internet programs like FTP, many of them 
purchase the electronic form of our product because of the savings 
(in both time and money) this offers.

Because licensed ChartFolio customers can come and get a product 
update from the FTP drop-box, this means that there is virtually 
no difference between (a) completing an initial purchase of our 
products or (b) receiving the latest technical updates.  In essence, 
licensed ChartFolio customers can always have access to the most 
up-to-date version of the products.

Section 0.10 - Next Steps

Your next steps in using the ChartFolio-for-ZAF product should be:

0.10.1	Review all applicable release and/or configuration notes:

Any current product release notes and disclaimers are located 
in the directory: "~\cf_zaf\read_me", in files: "release.txt" 
and/or "disclaim.txt".

0.10.2	Review the library makefile procedure(s) for your ZAF 
configuration:

The makefiles for the ChartFolio-for-ZAF libraries are located 
in the directory: "~\cf_zaf\src".  

0.10.3	Build the ChartFolio library for your configuration:

By following the above library build procedure, you should be 
able to build your version of the charting library in a 
straightforward manner.

Occasionally, however, there can be certain ZAF environments 
which may prove more difficult to correctly configure makefiles 
for.  If you have any problems, contact DPC's technical support 
(email to: support@dpc-tech.com).  Most library-makefile problems 
can be isolated to particular system-configurations for the ZAF 
product, and there is almost always a good work-around to correct 
any library-makefile build problems.

0.10.4	Build the ChartFolio demos to verify your configuration:

By following the procedures documented above (Section 0.6), you 
should be able to build demos for your version of the charting 
library in a straightforward manner.

As with the library build procedures, there can occasionally be 
certain ZAF environments which may prove more difficult to correctly 
configure template-makefiles for.  If you have any problems, 
contact DPC's technical support (support@dpc-tech.com).  As with 
library builds, most demo-makefile problems can be isolated to 
particular system-configurations for the ZAF product, and there 
is almost always a good work-around to correct any demo-makefile 
build problems.

0.10.5	Review the Demos and the Work-Flow Chapters:

With your ChartFolio-for-ZAF Framework/API library and your 
ChartFolio-for-ZAF demo programs, you are now ready to dig into 
the product!  Having used software components ourselves for many 
years, we understand how you are most likely to want to use our 
ChartFolio-for-ZAF product - we figure you will want to:

(1) Get a simple demo up and running;
(2) Clone this demo to your own program under development;
(3) Pass your application's data to a chart;
(4) Manipulate the display-characteristics of your chart;
(5) Make a few more tweaks and modifications to finish.

The ChartFolio product documentation is geared to support this 
process.  Chapter One will show you how a simple ZAF program can 
use a ChartFolio object to easily display a chart-object. Chapter 
Two will give an overview of the typical work-flow involved in using 
ChartFolio chart-objects with you ZAF application.  The rest of the 
chapters will present task-oriented topics organized into typical 
work-flows for using ChartFolio chart-objects, such as: data 
manipulation, color manipulation, working with labels and titles, 
view-geometry, etc.

After performing these tasks, you should be well on your way to 
making productive use of the ChartFolio products, and deploying 
world-class charts for data visualization into your ZAF-based 
applications.
 