Roadmap to the Compaq Visual Fortran Samples
The CompaqTM Visual Fortran (Visual Fortran)
kit provides a number of source code sample programs (samples) that cover a
variety of topics. These samples are provided for illustration purposes only,
although they can be freely used as a basis for other programs. You can copy
the samples as needed. Use a text editor to view the samples; they are not
listed as topics in HTMLHelp Viewer.
On the Visual Fortran media CD-ROM, samples are located in folders under
Info\Df\Samples. If you request that samples be installed using a Custom
installation, the samples are by default installed in subdirectories under:
Program Files\Microsoft Visual Studio\Df98\Samples
If you do not install samples, you can copy appropriate samples folders or
files from the Visual Fortran CD-ROM to your hard disk (remove the
Read-Only attribute file property for the files copied).
The ...\Df98\Samples\Tutorial folder contains short example programs, called
Tutorial samples, that describe (as source comments) how they can be built.
Unlike other samples, all Tutorial samples are contained in a single directory.
Other (longer) sample programs are provided in their own subdirectories. Most
samples also include a project workspace file, allowing you to
open the project workspace in the visual development environment (Microsoft® Developer Studio), view the source files in the FileView pane, build the
sample, and run it.
Visual Fortran samples include the following:
Advanced
Within the Advanced category, there are several other categories of samples. Each category is
described below, and the specific samples within each are described in its section. Each category
is contained within its own subdirectory of ..\Df98\Samples\Advanced:
- Samples using Component Object Model (advanced\com)
- Samples Showing Direct Fortran 90 Descriptor Manipulation (advanced\descript)
- Samples Using OpenGL (advanced\opengl)
- Samples Using Win32 API Calls (advanced\win32)
- Component Object Model (Advanced\Com)
The COM samples demonstrate use of the Component Object Model from within Visual Fortran.
- adder: The adder sample demonstrates a Fortran COM server and its use by Visual Fortran, Visual C++, and Visual Basic clients. The COM server implements a very simple "adding machine" object. Each client displays a dialog box that uses the server.
Adder is used as an example in the "Creating a COM Server" chapter of the Visual Fortran Programmer's Guide.
- autodice: The autodice sample demonstrates interactions between Fortran and Excel 97. This program takes 12 numbers and uses Automation to tell Excel 97 to draw a histogram of the numbers. The EXCEL97A moduled generated by the Fortran Module Wizard is used as the interface to EXCEL. You must have Microsoft Excel 97 installed on your computer in order to successfully run this sample.
- dlines: The dlines sample demonstrates interactions between Fortran and the Developer's Studio. This program converts Debug lines to IFDEF metacommands. It uses COM to drive Microsoft Developer's Studio to edit the source file.
The COM interfaces defined in DSAPP.F90 are taken from ...\Microsoft Visual Studio\Common\MSDev98\Bin\devshl.dll.
The COM interfaces defined in DSTEXT.F90 are taken from ...\Microsoft Visual Studio\Common\MSDev98\Bin\devedit.pkg.
This program is invoked with the following command line:
dlines inputsource outputsource debugchar ifdefname
Where: |
Inputsource is the filename of the input source file. Note: The source file must be fixed form. |
|
outputsource is the filename of the output source file. |
|
debugchar is the the debug character in the source file to replace with IFDEF directives (metacommands) |
|
ifdefname is the name to use with the IFDEF directives |
This program is useful as a tool to edit PowerStation Fortran files that used something other than "C" or "D" as the comment character.
- dsbuild: The dsbuild sample demonstrates using Automation to drive Developers Studio to rebuild a project configuration.
The automation interfaces defined in DSAPPA.F90 are taken from ...\Microsoft Visual Studio\Common\MSDev98\Bin\devshl.dll.
The Automation interfaces defined in DSBLDA.F90 are taken from ...\Microsoft Visual Studio\Common\MSDev98\Bin\devbld.pkg.
This program is invoked with the following command line:
dsbuild project.dsw configuration
Where: | project.dsw is the file specification of the project file |
| configuration is the name of the configuration to rebuild. |
- errinfo: The ErrorInfo sample demonstrates a Fortran COM Server that supports COM ErrorInfo objects.
- iweb: The iweb sample uses the COM interfaces in SHDOCVW.DLL to start a Web Browser and direct the browser to navigate to a specified URL.
The program is invoked with the following command line:
iweb url
Where: url is the URL to display
Any arguments not provided on the command line will be prompted for.
- safearray: The safearray sample demonstrates converting a Fortran two-dimensional array to a COM SafeArray and reading the data back from the SafeArray.
- variant: The variant sample demonstrates using the VARIANT manipulation routines in Visual Fortran. VARIANTs are used in COM interfaces.
- Direct Fortran 90 Descriptor Manipulation (Advanced\Descript)
In other languages, such as C or Pascal, pointers are simple memory addresses with no notion
of how the information is organized at the address pointed to. Fortran 90 pointers differ
dramatically, by not just containing a memory address, but also keeping track of the bounds
and strides of each dimension of an array. To accomplish this, the Fortran 90 compiler uses
something called an Array Descriptor, which stores the details of how the array is organized.
Array Descriptors may also be called Dope Vectors in other implementations.
By manipulating the contents of a descriptor directly, you can perform operations that would
otherwise not be possible in strict Fortran 90. You can associate a Fortran 90 pointer with any
piece of memory, organized in any way desired (so long as it is rectangular in terms of array
bounds). You can also pass Fortran 90 pointers to other languages, such as C, and have the
other language correctly interpolate the descriptor to obtain the information it needs. Important
for mixed language programming, you can create a Fortran 90 pointer associated with an array
which is accessed in C’s row order, rather than Fortran’s traditional column order, allowing the
same array to be used with the same subscripts from both C and Fortran.
The descript workspace has three subprojects. Each creates its own executable, and there are
no dependencies between them.
- cassign: A Fortran 90 pointer is associated with a C array, in row order. This pointer is
then passed back to Fortran, which reads the values written by C in exactly the same way
that C wrote them. This project uses descript.h, which provides the C prototypes, routines, and structure
definitions to the Fortran 90 pointers.
- fassign: A Fortran 90 pointer is associated with a Fortran 90 array, in row order, and
then passed to a C routine which can read the array in natural C notation.
- cube: Through use of the Bitmap module a Fortran 90 pointer is
created that points to an internal .BMP file, with its special structure (rows reversed). Once
this pointer is setup, the .BMP can be written to directly and then quickly displayed on a
QuickWin child window. This method is used to show a flicker-free spinning cube.
- OpenGL (Advanced\Opengl)
OpenGL is a protocol for performing advanced 3-dimensional graphics.
Visual Fortran includes Fortran 90 modules and link libraries for using OpenGL from
Fortran. The sample programs included in this section illustrate programs that take
advantage of these facilities.
All OpenGL samples will run under Windows® NT® and Windows 98, but require the OSR2
release of Windows 95 to run there. Refer to the Frequently Asked Questions page at
http://www.compaq.com/fortran for more information.
- 3dcube: The 3dcube sample displays a three-dimensional box on a black background. It uses QuickWin to create the window and draw the shapes using primitive 3D graphics.
- olympic: The olympic sample displays 5 rings on a window that rotate and
move towards each other, ultimately creating the Olympic symbol. It illustrates calls to
the OpenGL libraries, techniques for supporting code on both x86 and Alpha, techniques for reading arguments from the command line, and interface blocks, among other Fortran 90 concepts. This sample must be compiled with /fpscomp:logicals due to a difference in the way that Visual Fortran and Microsoft Powerstation Fortran interpret logical values. It must also be linked against the QuickWin libraries.
- puzzle: The puzzle sample displays a Rubik's Cube, and allows you to try and solve it. There is currently a problem with the colors in this sample. It uses Win32 calls to manage the windowing interface. Again, it illustrates techniques for supporting code on both x86 and Alpha.
- simple: The simple sample displays some points, lines, and simple shapes in a window. It uses QuickWin to manage the windowing interface. It is, as it sounds, a very simple example, using primitive 2-D graphics. One interesting aspect of it is the use of color and how to set some of the standard colors.
- wave: The wave sample displays a window with a surface waving. It uses QuickWin to manage the windowing interface. Beyond the usage of OpenGL, here are many interesting demonstrations in this sample, including the animation and the trapping of characters typed while the window has focus. The keys that are trapped are:
- C, which changes the contour of the wave
- [space], which pauses the animation. To resume, hit space again.
- S, which changes the shading of the wave
- A, which causes the wave to spin. To stop spinning, hit A again.
- L, which changes the color of the wave.
- Win32 API Calls (Advanced\Win32)
Visual Fortran includes Fortran 90 modules and libraries for doing Windows
programming at the Win32 API level. The samples presented here show Win32 API examples of how this
is done:
- angle: The angle sample uses the Windows interface to manage the GUI. It illustrates a basic Windows program, including the event dispatcher, and the use of pens and dialog boxes. The angle sample displays a shape consisting of a straight line plus an arc, and allows the user to input X,Y coordinates, angle of the arc, and radius of the arc, and then redraws.
- bounce: The bounce sample uses Win32 calls but creates a console application, rather than a Windows based one. It is a multi-threaded application that creates a new thread whenever the letter "A" is typed, up to a maximum of 32. Each thread bounces a happy face of a different color across the screen. All threads are terminated when the letter "Q" is typed. This particular application requires that several compatibility switches be set: /fpscomp:logicals, /fpscomp:ioformat, /fpscomp:general. These are found under the Compatibility entry on the Fortran tab of the BuildSettings dialog box.
- check_sd: The check_sd sample illustrates the use of security descriptors. The purpose of the sample is to assist people who want to manipulate security descriptors with sample code that they can start from. This sample, as is, examines the security descriptor on files, and could be easily modified to check the security descriptor on other objects. To use this sample, check_sd with no arguments checks the security descriptors on the A: device. check_sd d:\a.fil will check the d:\a.fil file. In this case, D: must be formatted with the NTFS file system because only NTFS files have security descriptors.
- cliptext: The cliptext sample demonstrates copying text to and from the clipboard. It uses the Windows interface to manage the GUI, and as such, also demonstrates the use of WinMain and MainWndProc that contains the event dispatcher. It has an "about" box, located under the File menu item, as there is no Help.
- cmndlg: The cmndlg sample demonstrates the use of common dialog boxes, including "About", File access dialogs, and error message dialogs. Each dialog box is demonstrated being used in three different ways: standard, suing a modified template, and using a hook function. Cmndlg displays "Hello World" in a window, and allows the user to change the text and colors, etc.
- consolec: The consolec sample demonstrates the use of the SetConsoleTxtAttribute() and GetConsoleScreenBufferInfo() APIs to set or get the console text color attributes. This is a console application that is linked against dfwin.lib. If no arguments are passed to consolec, it prints out a color sample in a command window. The arguments are FOREGROUND color and BACKGROUND color, and the valid options are BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, YELLOW or WHITE. The color argument passed must be in uppercase, or an error will be output.
- cursor: The cursor sample demonstrates how to manipulate a cursor and select a region. It uses the Windows interface to manage the GUI. The program will either let the user draw boxes (regions) or will calculate 1027 prime numbers when RETURN is entered. During that calculation, the cursor is turned into an hourglass.
- drives: The drives sample determines all drives on the system, both local and remote, and determines their file system type. This is a console application that links against dfwin.lib.
- event: The event sample demonstrates the basic concepts involved when using asynchronous I/O. It reads one file asynchronously and writes another synchronously. This is a console application that links against dfwin.lib and requires two arguments, the input file and output file. This executable transfers one file to another. Refer to the readme.txt for information on how to set it up in the Developer's Studio.
- exitwin: The exitwin sample demonstrates how to shut down applications. When run, it will ask whether you want to continue, as it will log you off. Optionally, you can compile it to reboot the system. This is a Windows application that uses Windows to manage the GUI.
- floppy: The floppy sample demonstrates how to access a physical floppy disk using the Win32 API set. It has two major functions:
- It can be used to display the geometry of a disk, floppy -g a:
- It can be used to produce a disk image or to write a disk image to a floppy, floppy -c a: bootdisk (produces a disk image of a:) or floppy -c bootdisk a: (make a: identical to bootdisk image).
This is a console program that is linked against dfwin.lib.
- generic: The generic sample demonstrates the basic concepts required in building a Windows application and could be used as a basis for building a first Windows program. The specific features that generic implements are:
- Custom icon
- Standard Menu Bar
- Standard Help Menu
- Full WinHelp Support
- Keyboard Accelerator Usage
- Version Control Information
- getdev: The getdev sample demonstrates the GetDeviceCaps() API. Also, in this sample, the main window is a dialog box, and all the interesting code is in the window procedure for that dialog box. This is different than many of the other Windows-based samples, which use MainWndProc to handle the events.
- getopenfilename: The getopenfilename sample demonstrates the use of the API GetOpenFileName(). When run, it brings up a dialog box listing either text files or Fortran files in the project directory. It also gives you the option of opening the file read-only.
- getsys: The getsys sample demonstrates the APIs GetSysColor(), GetSystemDirectory(), GetSystemInfo(), GetSystemMetrics(), GetSystemPaletteEntries(), and GetSystemTime(). Also, in this sample, the main window is a dialog box, and all the interesting code is in the window procedure for that dialog box. This is different than many of the other Windows-based samples, which use MainWndProc to handle the events.
- inherit: The inherit sample demonstrates inheritance of file handles from one process to a child process. It also demonstrates the use of anonymous pipes as stdout and stderr replacements. It contains two projects, child and inherit. The inherit project creates inherit.exe, which can be run without the other project. To run inherit, specify two parameters:
- Trace file to write stdout and stderr
- Command to execute
The inherit program is run within QuickWin so that it can be a "console-less" parent. Otherwise, there are configuration problems when trying to pipe.
To use this sample, first set the current project to child and build it, then set the current project to inherit and build it. Before you run it, read the "readme.txt" file in the project; this will tell you what changes you need to make to your project configuration in order to run this sample.
- input: The input sample is a basic Windows application that does very general processing on mouse button events and keyboard events. It demonstrates how input messages are received, and what additional information comes with the message.
When run, it displays the current pointer location, whether the right or left mousebutton was clicked, and outputs a message based on a 5 second timer.
- maskblt: The maskblt sample is intended to demonstrate masked bit block tranfers. It is unclear that it is working correctly, either in its current form, or as received from Microsoft. However, it does demonstrate basic calls to functions that support bitmaps and keyboard accelerators used by clipboard functions.
- MDI: The MDI sample demonstrates the multiple document interface. It creates a simple window that can create child windows within itself. It also can set the titles on these child windows.
- menu: The menu sample demonstrates the use of popup menus, user defined menus and menu fuctions. It is a very simple program that allows you to select items off a menu, invoke a pop-up menu, and basically do little else, but is a good example of how to start with menus.
- mltithrd: The mltitrhd sample demonstrates the use of multiple threads. The main routine, mltithrd.f90, has a brief guide to writing multi-threaded applications at the top of the file. It uses the multi-document interface to create child windows, and bounces colored traces through each one.
- output: The output sample demonstrates using TextOut() and DrawText() to write to a window. It is a very simple sample, outputting text and a few simple shapes, such as a rectangle, ellipse, and pie-wedge.
- owncombo: The owncombo sample demonstrates the use of functions and messages for combo boxes and owner-draw control styles. It brings up a window and lets you play with the different combo box styles.
- paths: The paths sample demonstrates the use of paths and clipping regions. A path is one or more figures or shapes that are filled, outlined, or both filled and outlined. Paths are used in various drawing and painting applications. This sample demonstrates how 6 different types of paths can be set up. With this release, when the application first runs, the window is too small for the titles on the paths, and must be manually resized.
- platform: The platform sample demonstrates some very simple menu choices, and the popup dialog boxes that you can create from them. This sample displays "menus" that give you information about which platform you are running on.
- plgdraw: The plgdraw sample demonstrates the PlgBlt() API. The PlgBlt function performs a bit-block transfer of the bits of color data from the specified rectangle in the source device context to the specified parallelogram in the destination device context. The sample displays a rendered version of the contents of the middle grid in the leftmost grid.
- polydraw: The polydraw sample demonstrates capturing mouse clicks and movement, and combining that with some keyboard input (the CTRL or SHIFT keys). It is a very simple program that allows the user to draw lines, curves, and move some points around on the screen.
- process: The process sample demonstrates creating and terminating processes from within another program. The user interface is very simple, a dialog box with two buttons "Create" and "Terminate", and window with the list of created processes.
- registry: The registry sample demonstrates the Registry API. This sample displays information from the system registry, allowing the user to traverse the various trees. It is a fairly simple sample, but could be used as an example.
- select: The select sample demonstrates how to manipulate a cursor and select a region. This sample has two projects under it:
- Select, which provides a dynamic link library (dll) of routines for selecting a region
- Demo, which contains an executable program that uses the select library above.
To use this sample, first set select as the current project and build select.dll,
then set demo as the current project to build the executable.
- setinfo: The setinfo sample demonstrates how to set the attributes of a file. It has a simple interface, allowing the user to enter a filename in an edit field. The GetInfo button will retrieve information about the file and display it. To set file inormation, modify the values in the Time and Date edit fields, and click the SetInfo button. To set file attributes, set the appropriate check boxes and click on the SetAttr button.
This sample also demonstrates the use of the GetFileTime() and SetFileTime() API calls.
- sharemem: The sharemem sample demonstrates the use of named shared memory between two independent processes. There are two projects in this sample, sharemem and othrproc. These can be built in either order; neither depends on the other. To use this sample, first start Sharemem, then start Othrproc. [note, this is best done outside of Developer's Studio.] The visual effect is better if the focus remains with Othrproc, while the mouse moves with Sharemem. A "shadow" mouse is displayed on Othrproc with the same coordinates as the mouse on Sharemem.
- startp: The startp sample demonstrates various CreateProcess() parameters, including starting processes in a given priority class. This is very similar to the "start" command but with added functionality. It is best run from outside Developer's Studio, but when run from within Developer's Studio, will give usage information in a console window.
- streblt: The streblt sample demonstrates the use of the StretchBlt function. This BLock Transfer function goes beyond a simple BitBlt, giving the option of stretching or compressing a bitmap to fit a different area in the destination device context.
- subclass: The subclass sample demonstrates subclassing of standard windows controls, such as button, edit field, and list box. It allows the user to create an arbitrary number of child controls on the main window. These controls are subclassed, and the subclass procedure provides the user a way to move and size the controls. A menu item switches in and out of "Test Mode". When this is on, the subclass procedure passes all message through to the standard procedure, and the controls act just like normal.
- takeown: The takeown sample demonstrates how to give an Administrator access to a file that has been denied to all. It must be run from an Administrator account. There is a sample file provided named "takeown.txt" which may be used by the sample.
- termproc: The termproc sample demonstrates how to terminate a process, given its process id. Although this can be built within the Developer's Studio, it is best run from the command line.
- threads: The threads sample demonstrates suspending, resuming, and setting the priorities of threads. The display shows two threads, red and green, which draw paths across the window. There are menu items to suspend, resume, and set the priority of the two threads. Caution, if the priority of one or the other of the threads is set too high little else will run on the system.
- timers: The timer sample demonstrates the use of the SetTimer() and KillTimer() APIs. It creates 4 rectangles on its window, each with a different and inverts the color whenever the timer goes off. This sample demonstrates two timer mechanisms
- tls: The tls sample demonstrates multiple threads calling into a single DLL.
It also demonstrates the use of DLLEXPORT to export entry points from a DLL, rather than using .DEF files.
This sample has two projects, tlsdll and tls. The workspace is configured such that the tls project is dependent on the tlsdll project. If you build tls, it will automatically build tlsdll.
When running, each thread is blocked waiting for the user to click OK in a message box. The thread may be running in a minimized window.
- virtmem: The virtmem sample demonstrates the use of various virtual memory APIs. The sample has a main window with menu items that will modify a set page to have different attributes. In order to write to memory, the page must be committed and set to read/write access. Attempting to write to a read only page will cause an access error, "memory cannot be read".
- world: The world sample demonstrates scaling and translating an image from a metafile with world coordinate transforms. It uses the calls SetWorldTransform() and PlayEnhMetaFile() to do the linear transformation between world space and page space, and to play the enhanced metafile. The sample provides a single sample metafile, sample.emf, although others could be used.
- wxform: The wxform sample demonstrates world transforms. It has three dialog boxes that display help, track mouse movements, or allow the user to enter transform information. The different quadrants of the screen have different properties, as described in the help box. This sample also demonstrates using messages to communicate between different window procedures.
Dialog Boxes (Dialog)
The Dialog samples demonstrate several of the dialog controls available through Visual Fortran, including the ones that are new with V6.0. There is also a sample that demonstrates how to use modeless dialog boxes, again, new with V6.0.
The dialog samples can be found in the directory ..\Df98\Samples\Dialog:
- CelsiCon: The CelsiCon sample is a console application that uses a dialog box. It uses an undocumented hook into the dialog initialization event WM_INITDIALOG. It also sets special customizations on that dialog box by using Win32 calls. With a simple modification to the source program, it can also be built as a QuickWin application.
- dllprgrs: The dllprgrs sample demonstrates using the Visual Fortran Dialog Procedures in a DLL. The public routines in the DLL can be called to:
- DisplayProgressBox - Display a dialog box containing a progress bar
- SetProgress - Set the current progress bar value
- DestroyProgressBox - Destroy the dialog box
- fxplorer: The fxplorer sample demonstrates an SDI Fortran Windows application using the Visual Fortran Dialog Procedures. It uses an Internet Explorer ActiveX control in the main window of the application. The Internet Explorer control is installed with Internet Explorer. If Internet Explorer is not installed, this sample will not run.
- mmplayer: The mmplayer sample demonstrates a Dialog-based Fortran Windows application using the Visual Fortran Dialog Procedures. It uses an ActiveMovie control in the main window of the application. The ActiveMovie control is installed with Internet Explorer. If Internet Explorer is not installed, this sample will not run.
- progress: The progress sample program demonstrates a "dialog-based" Fortran application using the Visual Fortran Dialog Functions, including the progress bar, which is new in VF V6.0. The main window of the application is a dialog box. It contains "Start", "Stop", and "Exit" buttons plus a progress bar. The "Start" button begins a lengthy operation that is broken into 100 steps. In this simple example, each step is sleeping for .25 seconds.
- showfont: The showfont sample demonstrates a "dialog-based" Fortran application using the Visual Fortran Dialog Functions. The main window of the application is a dialog box. This program demonstrates the use of a Tab control, which is new in VF V6.0. The Tab control is used to select the properties of a font. The font is used to display a sample text string.
- temp: The temp sample displays a modal dialog box that converts a Celsius temperature to a Fahrenheit temperature, and vice-versa.
- therm: The therm program demonstrates a "dialog-based" Fortran application using various Visual Fortran Dialog Functions, including several that are new to VF V6.0. The main window of the application is a dialog box. This program uses a Spin control, a Slider control, a Progress bar control, and Picture controls. It also demonstrates using multiple modeless dialog boxes.
- whizzy: The whizzy sample demonstrates many of the controls available with the dialog manager module provided by Visual Fortran. Note that it is built with the "Logical Values" compatibility switch set. This is required for correct interaction with the dialog manager routines.
Within Visual Fortran you can create and use dynamically linked libraries (DLLs). A DLL is loaded at runtime by its
calling modules (.EXE or .DLL). When a DLL is loaded, it is mapped into the address space
of the calling process. There are generally two ways to bring in a DLL, either at image
activation time or at run-time. If an image is linked against the import library for a
DLL the code is mapped into the image's address space at image activation time. If the
import library is not available, the DLL needs to be mapped in with Windows API calls.
The following DLL examples can be found in subdirectories under ..\Df98\Samples\DLL:
New with Visual Fortran V6.5 are some routines to make it easier for the user to control floating point exception handling. Note that all these samples must be compiled with fpe:0, and under the Release configuration, must be compiled with Optimization:None and Traceback Enabled. These switches are required to enable all floating point errors to signal, to keep the compiler from optimizing away the test cases, and to provide an accurate traceback map.
The ISOVAR suite of samples demonstrate one possible implementation for the interface to dynamic length character strings in Fortran 95. The publicly accessible interface defined by this module is conformant with the auxilliary standard, ISO/IEC 1539-2 : 1999
There are a number of miscellaneous samples that demonstrate some specific aspects of
Visual Fortran or its utilities. The following miscellaneous examples can be found
in separate subdirectories under ..\Df98\Samples\Misc:
Visual Fortran can be called by a number of other languages, including Visual C/C++ and Visual Basic. Also, it can
call other languages, such as C/C++. The following samples in subdirectories under ..\Df98\Samples\Mixlang
demonstrate some of the calling standards or argument definitions
that must be used to effectively interwork with other languages:
Visual Fortran provides a library of functions called QuickWin. QuickWin is a
library that lets you build applications with a simplified version of the Windows interface
with Visual Fortran. The QuickWin library provides a rich set of Windows features, but it
does not include the complete Windows Applications Programming Interface (API). If you need
additional capabilities, you must set up a Windows application to call the Win32 API directly rather than using QuickWin to build your program. The following samples demonstrate how to use QuickWin, and how to program around some of the strange paradigms of the package.
The following QuickWin examples can be found in subdirectories under ..\Df98\Samples\QuickWin:
SCIGRAPH is a package of Fortran routines for drawing scientific graphs. Graph types
available include line, bar, XY, and pie graphs. All graphs are fully customizable, including control over axis, log scales, data points, colors and
shades, error bars, and many other aspects of a scientific graph. All graphs are drawn using Visual Fortran's QuickWin graphics routines, so they can be easily added to
an already existing QuickWin application. The SciGraph package can be found in ..\Df98\Samples\SciGraph:
All Tutorial samples are simple programs, and most of them are standalone. Each contains
compilation information at the top of the file, both for command line and from within
Developer's Studio. If there are multiple files, this is noted at the top of the program.
All tutorial samples can be found in the directory ..\Df98\Samples\Tutorial: