The Claw Demo version has been replaced by the Claw Introductory Version. Click here to download it.

What's new in the Claw Demo, version 1.2:

• Basic bitmap operations (full Claw has many more)
• Basic edit controls (for strings and integers)
• Beep support
• Help file support
• Icon operations
• Additional menu support
• Up-down controls

This demonstration version has four complete example programs included. Shapes demonstrates the use of CLAW to build a graphics application, AdTest shows a simple multitasking billboard program. BigJob shows how a Windows interface can be easily added to an existing 'big' Ada 'job' (program). TestCC shows how CLAW can easily set and change the colors, fonts, and other characteristics of controls.

The demonstrations include examples of most of the important functional areas in CLAW: Windows, Controls, Dialogs, Tools, and Canvases. Since the implementations of the different varieties of these items are rather similar, the demo includes only a few examples of each item.

Compiling the demonstration version.

Janus/Ada: You must have Janus/Ada 3.1.1a or later. If you have a previous version of Janus/Ada, contact sales@rrsoftware.com to receive an update. Updates require current software support. (Note that the full version of Claw 1.2 requires Janus/Ada 3.1.1d).

To build the demo version of CLAW, unzip the CLAW_D~1.ZIP (Claw_Demo_Janus.Zip) file in an appropriate directory. Make sure that you have proper access to Janus/Ada. Then, Run CompClaw with the full path of Claw as the parameter. For example, if you have made D:\Claw as your CLAW directory , run "CompClaw D:\Claw" from the DOS box command line. This command will compile the entire demo, and link all four example programs.

GNAT: To run the demo for GNAT version 3.10p1 or later, do the following steps: Unzip the CLAW_D~2.ZIP (Claw_Demo_Gnat.Zip) file into a suitable directory, using an Unzip utility that handles long file names.
Set Gnat path environment appropriately. (This means executing an existing Gnat 'setpath.bat' file if you have one).
Execute mk_shape.bat to compile and link Shapes.exe
Execute mk_ads.bat to compile and link Adtest.exe
Execute mk_big.bat to compile and link Bigjob.exe
Execute mk_tcc.bat to compile and link TestCC.exe
Run each of the four demos.
This code has been tested with version 3.10p1 of Gnat for Windows 95/NT (as downloaded in September 1997), and with a recent supported version of GNAT. Gnat does generate some warnings but they may be ignored.

We do not support the use of the demo with earlier versions of GNAT. In particular, CLAW does not work with version 3.09 of GNAT.

We understand that there is a problem executing programs containing resources on Windows NT with GNAT 3.10p. (Three of the demo examples, Shapes, Bigjob, and TestCC are such programs). Stripping the programs solves the problem. (That is, run Strip on the executable.) These programs will run on Windows 95. This problem is fixed in recent GNAT versions. Do NOT run Strip in the latest versions of GNAT - it will destroy your executable file.

Note: The 3 files Testcc.rbj, Shapes.rbj, and Bigjob.rbj are provided for convenience. If you wish to start from complete source code, run "rc xxx.rc" on each of the *.rc files to generate *.res files. Then run cvtres xxx.res on each .res file to generate .obj files. Rename the resulting .obj files to something convenient - we used .rbj. We didn't include adtest.rbj because adtest is an example that doesn't need a resource file - look at adtest.rc and you'll see there's essentially nothing there.

The usual Gnat distribution does not contain rc.exe or cvtres.exe so you'll have to get those from elsewhere, for instance a Microsoft SDK or C++ compiler.

ObjectAda: Version 7.1.2 of ObjectAda is required to use the demo. (Version 7.1.1 can compile the demo, but, because of a finalization bug, some programs do not work properly.)

Unzip the CLAW_D~3.ZIP (Claw_Demo_OA.Zip) file into a suitable directory.
Create a project.
Use 'project' 'settings' 'link' to select Window (rather than Console).
Use 'project' 'settings' 'search' and include <objectada>/win32ada/binding/lib and <objectada>/apilib (where <objectada> denotes the CDROM drive or disk path where these are to be found).
Ignore the warning message on the /apilib directory.

Use 'project' 'settings' 'files' to include all Claw demo Ada source files, including Claw*.ad? and the four example programs. You can then "Build" adtest, which does not need a resource file, and execute it. The other three examples each has a .res file (supplied as a convenience so you needn't run rc.exe on the .rc files). To build one of them, Project/Settings/Files/Add its .res file to the project, Removing any previously added .res file, and then Build and execute the example.

Rational APEX: Version 2.0.1 or later of APEX is required to use the demo.

The version 1.20 demo comes pre-installed in the claw.ss subsystem. There is no need to download or install the demo.

The demo examples are found the claw-examples.ss subsystem, found in the projects directory. They can be built directly there. You may need to compile the resource files (Testcc.rc, Shapes.rc, Bigjob.rc) before the examples will link. This can easily be accomplished by selecting "Compile"|"Resource", and selecting the desired file.

If you have APEX 2.0.1, the demo version of the builder on the web site is newer than the one included with APEX. You may want to download and install it.

For any of the compilers:

To run the programs, simply type the name of the program while in an MSDOS window. After trying various things with Shapes, Exit it, go back to the MSDOS window, and try Adtest, Bigjob, or TestCC.

Claw Application Builder Readme

Installing the Claw Builder:
Files:
Cbld_Demo.Zip (Demo builder & documentation file)
Cbld_Sample.Zip (Sample project and source)

We assume that the Claw demo has already been installed properly.

1. Create a directory to hold the builder. We will use \Claw\Cbuild in our examples, but you may use anything you wish. Create a subdirectory of the program called "Sample".
2. Unzip Cbld_Demo.Zip into \Claw\CBuild.
3. Unzip Cbld_Sample.Zip into \Claw\Cbuild\Sample. If the two sample files do not have a long file name, rename them appropriately:
   ren Sample~1.ads Sample_Custom-Valid.Ads
   ren Sample~1.adb Sample_Custom-Valid.Adb
   
4. The builder is self-registering. However, you can better match the default settings to your compiler by manually registering it. Do this by running "CBuild /INSTGB" from the command line (for GNAT), "Cbuild /INSTOB" for ObjectAda, "CBuild /INSTAB" for Rational APEX, or "CBuild /INSTJB" for Janus/Ada. Note that the option must be given in all capital letters.
   
   If you don't want desktop and start menu icons for the Claw Builder, remove the 'B' from the /INST option.
5. We're now going to generate the sample application, in order to verify that the Claw Builder was installed properly.
   Open CBuild. Select "Open", then navigate to \Claw\Cbuild\Sample. Select the Sample project file. Select "Project","Properties" from the main menu. Go to the "Files" page, and change the "Generated code output path" to D:\Claw\CBuild\Sample, where D: is the disk name for the drive where you installed CBuild. You can use the Browse button to make this easier. While we're in the project, we also should correct the help file path. Switch to the "Help" page, and change the "Application Help Path", again to D:\Claw\CBuild\Sample. Press "OK" when you're done.
6. We also have to correct the paths of the graphic files. Select "Graphics Manager" (under "Project" on the main menu). Select "App_Icon" from the list of graphics, then push the "Modify Graphic" button. In the "Modify Graphic" dialog, push the "Browse" button, then select "Icon Files" in "Files of Type". Select the "Claw" file (it should be here with the sample application in the "Sample" subdirectory). Press the "Open" and then the "OK" buttons to get back to the graphic manager. The sample should show a small Claw now. Now, select "Big_Claw" from the list of graphics, push the "Modify_Graphic" button, push the "Browse" button, and select the "Cl200" file. Return to the graphic manager with "Open" and "OK", and a large Claw should show in the sample window.
7. Select "Project" "Generate Code" from the main menu. The sample code should now be generated. Select "File" "Save" to change the sample project file. (We save the file to save the path changes you made above).
8. The next step depends on the compiler you have. Follow the appropriate directions for your compiler.
   1. For Janus/Ada, modify the Init.Bat file to point at the location of the Claw object files. This appears as \Claw\Object in the file. Make sure that the paths and environment variables for Janus/Ada are set.
   2. Run Init.Bat to set up the project, then run Comp.Bat to compile the Sample application.
   3. For GNAT, go to a DOS window. Change directories to \Claw\Sample. Make sure that your Ada_Include_Path, Ada_Objects_Path, and Include environment variables are properly set for Claw programs. (This means that "\Claw\Source" should by included in each of those variables).
   4. Compile the sample application with the command:
      gnatmake -O2 -gnato sample.ada -largs -mwindows my_app.rbj
      Note: You may need to process the generated .Rc file in order for this command to succeed. GNAT does not provide the tools necessary to do this, so we can't provide directions. We have done this for the sample application and produced my_app.rbj. You'll have to do it for your own applications.
   5. If you are using GNAT 3.10p, and are running on Windows NT, you'll need to run Strip on the resulting executable. This is necessary to avoid a bug in GNAT 3.10p. This step is not necessary when running on Windows 95, nor when using a newer version of GNAT.
   6. For ObjectAda, create a project.
      Use 'project' 'settings' 'link' to select Window (rather than Console).
      Use 'project' 'settings' 'search' and include <objectada>/win32ada/binding/lib and <objectada>/apilib (where <objectada> denotes the CDROM drive or disk path where these are to be found).
      Use 'project' 'settings' 'search' to include the Claw project.
      Use 'project' 'settings' 'files' to include all Sample source files.
      Also include My_App.res. (If you don't have My_App.res, create it by running rc on My_App.rc -- "rc My_app.rc").
      "Build" Sample.Ada, which will compile the Sample program.
   7. For Rational APEX, create a view in the Claw_Examples subsystem.
      Return to the Claw Builder. Check that the global option for APEX pragmas is set (find it in "Project" "Options" on the "Miscellaneous" page). Reset the "Generated code output path" (in the project properties) to point at the subdirectory of the new view. Select "Project" "Generate Code" from the main menu to generate the code directly into this view. If needed, open the APEX GUI. Navigate to the sample view. Select "Compile" "Resource", and run the resource compiler on My_App.rc. Select "Compile" "Link" to link the main program "Sample"; this will compile all of the needed sample files.
9. Now (for all compilers), run the application from the command line by typing "Sample". Note that the programmer provided routines which make up "Sample" mainly Beep (in different tones on Windows NT, but all of the same on Windows 95) when they are called.
10. If you've gotten this far, you're ready to start using the builder. You probably will want to read the overview and tutorial for the builder in the builder help. (Use "Help"/"Help Topics" in the builder to get to it.) Next, familiarize yourself with the builder by playing with the sample application. Finally, you can build your own applications.

To deinstall Claw Builder, simply run "CBuild /UNINST" from a command line prompt. (This will remove the registry entries used by the builder.) Then, delete the files. Note that "UNINST" must be in capitals; otherwise, you will see a "file not found" error. Then the Builder files can be deleted. Note that the full version of Claw has a standard Uninstall program.

Compatibility: