# 1. Amulet V2.0 Overview

## 1.1 Introduction

The Amulet research project in the School of Computer Science at Carnegie Mellon University is creating a comprehensive set of tools which make it significantly easier to create graphical, highly-interactive user interfaces. The lower levels of Amulet are called the Amulet Toolkit,' and these provide mechanisms that allow programmers to code user interfaces much more easily. Amulet stands for Automatic Manufacture of Usable and Learnable Editors and Toolkits.

Section 1.9 describes the differences between Amulet v2 and previous versions of Amulet. Code written for Amulet v1 will need to be editied before it will compile and run properly with Amulet v2.

Unix:
OS: SunOS, HP/UX, Linux, IBM AIX, SGI
Compilers: gcc 2.6.3, gcc 2.7.0, ObjectCenter 2.1.0, AIX xlc, SGI CC
PC
OS: Windows NT 3.5 and 3.51 and Windows 95
Compilers: Visual C++ 2.0, 2.1 or 4.0
Mac
Compilers: Metrowerks CodeWarrior 8
We are running SunOS, HP/UX, Windows NT 3.51, and Codewarrior 8, so we'll be best able to help you if you're using one of these systems.

http://www.cs.cmu.edu/~amulet

A previous project named Garnet was developed by the same group who is now writing Amulet. It has features similar to those in Amulet, but is implemented in Lisp. For information about Garnet, please refer to the Garnet home page:

http://www.cs.cmu.edu/~garnet


There is a mailing list called amulet-users@cs.cmu.edu where users and developers exchange information about Amulet. Topics include user questions and software releases. To be added to the list, please send your request to amulet-users-request@cs.cmu.edu.

## 1.3 Using Amulet in Products: Copyright and Licensing

Amulet is available for free by anonymous FTP or WWW. Amulet has been put into the public domain. This means that anyone can use Amulet for whatever they want. In particular, Amulet can be used for commercial development without any license or fees. The resulting binaries and libraries can also be distributed commercially or for free without payments or licenses to Carnegie Mellon University (CMU). You can even include portions of the Amulet source code in your projects or products. The only restriction is that the documentation for Amulet is copyrighted, so you cannot distribute the Amulet manual or papers without permission from CMU. In return, CMU assumes no responsibility for how well Amulet works, and will not guarantee to provide any support. If you need more formal legal language, see Section 1.10 below. If you need this formally signed, then replace your company's name for COMPANY and send it back to us.

## 1.4 How to Retrieve and Install Amulet

You will download a different file depending on whether you're installing Amulet on a Unix, PC, or Macintosh system. You will get only the files you need to compile Amulet on your machine. If you plan to install Amulet on multiple platform types, you will need to download a different distribution for each platform type.

### 1.4.1 The Amulet Manual

The Amulet documentation is also available for free, but it is copyrighted. This means you cannot distribute the Amulet manuals without written permission from the authors.

http://www.cs.cmu.edu/afs/cs/project/amulet/amulet2/manual/Amulet_ManualTOC.doc.html
To retrieve the Amulet documentation via WWW, launch your favorite browser and go to the following URL:

http://www.cs.cmu.edu/~amulet/amulet2-documentation.html


### 1.4.2 Retreiving the Amulet source code distribution

The Amulet source distribution can be retrieved via anonymous FTP, or from the Amulet WWW pages.

#### 1.4.2.1 Retrieving the source distribution via FTP

To download the compressed Amulet source code files via FTP, you'll need an FTP client program. FTP to ftp.cs.cmu.edu (128.2.206.173) and login as 'anonymous' with your e-mail address as the password.

#### 1.4.2.2 Retrieving the source distribution via WWW

To download the compressed Amulet source code files from the WWW you'll need a web browser such as Netscape, Mosaic, lynx, or www. Run your browser and go to the following URL:

http://www.cs.cmu.edu/~amulet/amulet2-release.html

Scroll down to the section of the web page labelled Downloading the current release of Amulet.'' Follow the link appropriate for the version of Amulet you want to download. This will automatically download the compressed Amulet source code to your machine.

### 1.4.3 Installing Amulet on a PC

To install Amulet on your PC, you will need to retrieve the file amulet.zip as described in Section 1.4.2.

#### 1.4.3.1 Unpacking amulet.zip

Once you have retrieved the file amulet.zip via FTP or WWW, unzip it into the directory where you want it to reside, preserving the directory structure. For example, if you use pkunzip and want to have Amulet files in the C:\AMULET directory, at the DOS prompt type 'pkunzip -d amulet.zip C:\'.

#### 1.4.3.2 Windows Environment Variables

Next you should set the environment variable AMULET_DIR to the directory where you installed Amulet. In Windows NT, go to the Program Manager, and open the Control Panel. Choose System, and add AMULET_DIR = C:\amulet (substitute the appropriate pathname) to the User Environment Variables section. Amulet uses this environment variable to look for its dynamic link libraries, as well as some bitmap files in the demo programs. If the AMULET_DIR is not set, Amulet looks in C:\amulet by default.

#### 1.4.3.3 Configuring Visual C++

In the Visual C++ menubar, choose Tools: Options to bring up the Visual C++ options window. Choose the Directories panel to access the search paths. Add the Amulet include directory C:\AMULET\INCLUDE to the include path, and add the Amulet library directory C:\AMULET\LIB to the library path. (If you installed Amulet in some other directory, be sure to specify that directory instead.)

#### 1.4.3.4 Visual C++ Project Files

Amulet supports development with Visual C++ versions 2 and 4. These two development environments use different project files, so we've provided projects for all of the sample and demo programs for both versions of Visual C++.

#### 1.4.3.5 Compiling The Amulet Library

To build any of the sample programs or to link your own application to Amulet, you must first build the Amulet library file. The Amulet 2.0 distribution does not come with any precompiled libraries; a different version would be required for Visual C++ 2 or 4.

Once you have a compiled version of AMULETD.LIB or AMULET.LIB, you are ready to write your own Amulet programs and link them to the Amulet library. Section 1.4.3.6 discusses how you can build and run some of the Amulet samples and test programs. Your first experience with Amulet programming should involve the Amulet Tutorial, which includes a starter program and instructions to acquaint you with the compiling process. When you are ready to write your own Amulet program, see Section 1.4.3.8 for instructions about linking your new program to the Amulet library.

#### 1.4.3.6 Compiling Test Programs and Demos

There are about 10 test programs included in Amulet that test the lower levels of Amulet: the ORE object system, GEM graphics routines, OPAL graphical objects, Interactors event handlers, and Widgets. The project files for these tests appear in the amulet\bin\ directory. You can build and run these programs to test your installation of Amulet, but they are not intended to be particularly good examples of Amulet coding style. The makefiles for these programs assume you've installed Amulet in \AMULET, so if you want to try these programs and have installed Amulet elsewhere, you might have to change the makefiles.

#### 1.4.3.7 Using console.cpp to Simulate a Terminal Window

The Amulet test programs were designed in a Unix environment, and require a simulated terminal window for text output. We provide a simple way to add a console to any of your Amulet programs, using the file console.cpp. To include a console in your custom Amulet program, just add the file amulet\src\gem\console.cpp to your Visual C++ project. A console will automatically be allocated when your program starts, and destroyed when the program completes execution.

#### 1.4.3.8 Writing and Compiling New Programs Using Amulet

The easiest way to create a project file for your own Amulet program is to copy the project file from one of the sample programs (tutorial is a good one), remove the sample code from the project, and add your application's .cpp files instead. At that point you should be able to successfully compile your Amulet application.

#### 1.4.3.9 PC filenames

To support as many users as possible, we are using 8 character file names with 3 character extensions for the Windows Amulet files. This manual generally refers to Unix or machine independant file names, which are often longer than 8 characters. The PC files are kept in the same directories as their equivalent Unix or Mac files. In cases where the Unix filenames are too long for the PC, the filename is logically shortened, either by truncation or removal of vowels. On the PC, the extension .cpp is used for all C++ code files, and headers use the extension .h.

### 1.4.4 Installating Amulet on a Unix Workstation

To install Amulet on your Unix workstation, you will need to retrieve the file amulet.tar.Z as described in Section 1.4.2.

#### 1.4.4.1 Unpacking amulet.tar.Z

Expanding amulet.tar.Z into a usable Amulet directory structure is a two part process. At the Unix prompt, first type "uncompress amulet.tar.Z". Your copy of amulet.tar.Z will be replaced with amulet.tar. Now type "tar -xvf amulet.tar" at the Unix prompt to generate the amulet/ directory tree as a subdirectory of your current directory.

#### 1.4.4.2 Setting your Environment Variables

The Amulet Makefiles have been written so that all Amulet users must set two environment variables in their Unix shell before they can compile any program. Consistent binding of these variables by all Amulet users ensures that the installed Amulet binaries will always be compatible with user programs. Once Amulet has been installed and programs are being written that only depend on its library file, it would be possible for users to write their own Makefiles without regard to these variables. However, we recommend that all Amulet users at a site continue to use consistent values of environment variables to facilitate upgrading to future versions of the system. Typically, these environment variables will be set in your .login file:

If you are using SunOS or HP/UX, then set AMULET_VARS_FILE to one of the following files, which have been tested by the Amulet group on our own machines.

 Makefile.vars.gcc.Sun For gcc on SunOS 4.x
 Makefile.vars.gcc.HP For gcc on HP/UX 9.x
 Makefile.vars.CC.Sun For ObjectCenter's CC on SunOS 4.x
 Makefile.vars.CC.HP For ObjectCenter's CC on HP/UX 9.x
For example, if you run csh, your .login might contain the lines

	setenv AMULET_DIR        /usr/johndoe/work/amulet

	setenv AMULET_VARS_FILE  Makefile.vars.CC.HP

If you are using a different platform, you may find a file tailored to your platform in the contrib directory. Files in contrib are provided by other Amulet users. Among them you will find:

 Makefile.vars.gcc.Solaris For gcc on Solaris
 Makefile.vars.gcc.linux For gcc on linux (static library only)
 Makefile.vars.gcc.linux-ELF For gcc on linux with ELF shared libraries
 Makefile.vars.gcc.AIX For gcc on AIX
 Makefile.vars.CC.AIX For xlc on AIX
To use one of these files, first copy it to your bin directory, so that the Makefiles can find it, then set your AMULET_VARS_FILE variable

		setenv AMULET_DIR        /usr/janedoe/amulet

		setenv AMULET_VARS_FILE  Makefile.vars.gcc.linux-ELF

If you can't find your platform in either the bin or the contrib directory, then you should set your AMULET_VARS_FILE variable to the file:

 Makefile.vars.custom  For any other configuration
If you run csh, your .login might include the lines:

		setenv AMULET_DIR        /usr/jonwoo/amulet

		setenv AMULET_VARS_FILE  Makefile.vars.custom

If you use Makefile.vars.custom, try compiling Amulet first. If the compilation does not finish smoothly, you probably need to make changes to the variables in Makefile.vars.custom. See Section 1.4.4.6 for more information. Only edit amulet/bin/Makefile.vars.custom while installing Amulet.

#### 1.4.4.3 Generating the Amulet Library File

After you have set your environment variables, cd into the bin/ directory and invoke make, with no arguments. This generates many object files, and eventually the Amulet library will be deposited in the amulet/lib/ directory. If you are using Makefile.vars.gcc.Sun, Makefile.vars.gcc.HP, Makefile.vars.gcc.Solaris, or Makefile.vars.gcc.linux-ELF, then Amulet is compiled into a shared library called libamulet.* (The suffix indicating a shared library is platform-dependent, but it is typically .so or .sl.) If you are using any other compiler or platform, then Amulet is compiled into a static library called libamulet.a.

It is common to get many warning messages during the build, but you should have no fatal errors. If the compile procedure is interrupted by an error, you may need to customize the Makefile variables for your platform. Set your AMULET_VARS_FILE environment variable to Makefile.vars.custom, and refer to Section 1.4.4.6. Change appropriate variables in Makefile.vars.custom, and recompile. If you are unable to compile Amulet after trying different combinations of compiler switches, please send mail to amulet-bugs@cs.cmu.edu and we will try to make the Amulet code more portable.

#### 1.4.4.4 Compiling Test Programs and Examples

From the bin/ directory, doing 'make all' generates about 10 executable binaries that test the lower levels of Amulet: ORE object system, GEM graphics routines, OPAL graphical objects, Interactors event handlers, and Widgets. You can run these programs directly, such as './testgem'. You can build and run these programs to test your installation of Amulet, but they are not intended to be particularly good examples of Amulet coding style.

#### 1.4.4.5 Writing and Compiling New Programs Using Amulet

It is important to set your AMULET_DIR and AMULET_VARS_FILE environment variables, and to retain the structure of the sample Makefiles in your local version. By keeping the line 'include $(AMULET_DIR)/bin/Makefile.vars' at the top of your Makefile, and continuing to reference the Amulet Makefile variables such as AM_CFLAGS and CC, you will be assured of generating binary files compatible with the Amulet libraries. #### 1.4.4.6 Customizing the Makefile.vars.custom Variables C++ is a standardized language, but many compilers do not fully support the ANSI standard completely or correctly. Because of this, Amulet requires different source code in certain places with various platform/ compiler combinations. We handle this with conditional code that depends on the compile-time definition of the variables defined in your AMULET_VARS_FILE. These variables need to be set apropriately for your system. This section is a guide to the variables that control the conditional Amulet code. If, after experimenting with the compiler variables documented below, you are still not able to successfully compile Amulet, please send mail to amulet-bugs@cs.cmu.edu so we can try to make the Amulet code more portable. ##### 1.4.4.6.1 Compiler Variables HP Including -DHP in the AM_CFLAGS list will cause some type casting required for HP's that is inappropriate on other machines. GCC Including -DGCC in the AM_CFLAGS list causes different header files to be referenced than when Amulet is compiled with CC or Visual C++. NEED_BOOL Including -DNEED_BOOL in the AM_CFLAGS list causes Amulet to define the bool type. This type is pre-defined in gcc. NEED_MEMMOVE Including -DNEED_MEMMOVE in the AM_CFLAGS list causes Amulet to define its own memmove() function. This function is missing in some C libraries. NEED_STRING Including -DNEED_STRING in the AM_CFLAGS list causes Amulet to include the standard header file strings.h in special places required by some versions of the CC compiler. DEBUG Including -DDEBUG in the AM_OP list causes Amulet debug-ging code to be compiled into your binaries. If you do not define DEBUG, you will lose a lot of runtime debugging information, such as slot, object, and wrapper names, and tracing and breaking in the debugger, but your executable will be smaller and it will run faster. This switch is not the same as the -g option, which compiles debugging symbols for a debugger such as gdb into your executable. Using the DEBUG switch compiles in Amulet-specific runtime debugging information which makes it easier to debug your Amulet application while it's running. The options -g and -DDEBUG are mutually exclusive; neither is required to use the features the other provides. ##### 1.4.4.6.2 Makefile Variables CC Your compiler, such as /usr/local/bin/gcc. If you're compiling using ObjectCenter's CC, you may have to specify the pathname explicitly. Otherwise, a default (non-Centerline) CC may be used which will not successfully compile Amulet. LD Your linker, such as /bin/ld. This command is used to link libraries into archive files. AM_OP Options you want to pass to your compiler, such as -g to put gcc debugging information in the binaries, -O to enable optimization, or -pg to enable profiling. AM_CFLAGS A list of switches to pass to the compiler, including the Amulet compiler variables listed above and any include and library paths you need to specify. AM_LDFLAGS A list of switches to pass to the linker. AM_LIBS A list of libraries to link with your program, such as -lX11 and -lg++. AM_LIB_SHARING A symbol indicating which kind of library should be built: either static to make a static Amulet library (libamulet.a), or shared to make a shared library. This option will build shared libraries only if your compiler is gcc, version 2.7.0 or newer. AM_SHLIB_SUFFIX The appropriate suffix for a shared library on your platform. On HP/UX, for example, shared libraries end with .sl'', but on Solaris and linux, shared libraries end with .so''. ##### 1.4.4.6.3 Command Line make options Make allows you to specify override values for makefile variables on the command line. This allows quick testing of various Makefile configurations without having to edit the Makefile.vars.* file every time you want to try something new. To override a makefile variable on the command line, just type make <variable>=<value> <target>. For example, to try compiling testselectionwidget with shared libraries turned off, type: make AM_LIB_SHARING=static testselectionwidget  ##### 1.4.4.6.4 Xlib Pathnames Some compilers on Unix systems do not know where to find the Xlib library and include files. You may need to include the pathnames for your Xlib files in the AM_CFLAGS list in Makefile.vars.custom. The include path should be provided with the -I switch, and the library path should be provided with the -L switch. AM_CFLAGS = -$(AM_OP) I\$(AMULET_DIR)/include -DGCC -DDEBUG -DHP \
-I/usr/include/X11R5 -L/usr/lib/X11R5

Note that a backslash is required at the end of a line when the definition of a Makefile variable continues on the next line.

/usr/include/X11R?, /usr/lib/X11R?

/usr/local/X11R?/include, /usr/local/X11R?/lib


#### 1.4.4.7 Why is my application so big?

Many users complain that applications that link to the Amulet library are very large. It is not unusual to have a hello world program compile down to a few megabytes of executable. Obviously, not all of this is useful, necessary information. There are several things you can do to reduce the size of your executables.

### 1.4.5 Installing Amulet on a Macintosh

To install Amulet on your Macintosh, you will need to retrieve the file amulet.sea.hqx as described in Section 1.4.2. The Macintosh version of Amulet is being developed with Metrowerks CodeWarrior 8. The code will run with CodeWarrior 7 as well, but you will need to make your own new project files (see Section 1.4.5.6) for the tests and demos. The project files we provide will work on CodeWarrior 8, but not on CodeWarrior 7 without modification.

#### 1.4.5.1 Unpacking amulet.sea.hqx

Once you have retrieved the file amulet.sea.hqx via FTP or WWW, unbinhex it. Some communications programs (such as Netscape and Fetch) do this for you automatically. If yours does not, try using Stuffit Expander. Run the application amulet.sea and select the directory where want the Amulet source tree to reside.

#### 1.4.5.2 Macintosh Environment Variables

Amulet needs to know the location of your amulet directory for some bitmap files in the demo programs. Use SimpleText to create an ASCII text file called amulet.env in the Preferences folder in the System Folder of your boot drive. This text file must contain the full pathname to your amulet directory. For example, if your boot drive is called Hard Disk and the amulet folder is called amulet then the pathname would be Hard Disk:amulet. Note that there should be no colon at the end of the pathname and that this file must be an ASCII text file.

#### 1.4.5.3 Creating the Precompiled Header file

Launch the CodeWarrior IDE application and open the CodeWarrior project file named AmuletHeaders68K.proj if your Macintosh is running a 680x0 processor or open AmuletHeadersPPC.proj if your Macintosh is running a PowerPC processor. These project files are located in amulet:MAC:pch. Then, select the AmuletHeaders.pch file in the project window and choose Compile from the Project menu.

#### 1.4.5.4 Compiling The Amulet Library

To build any of the sample programs or to link your own application to Amulet, you must first build the Amulet library file. The Amulet 2.0 distribution does not come with any precompiled libraries.

Once you have a compiled version of the Amulet library you are ready to write your own Amulet programs and link them to the Amulet library. Section 1.4.5.5 discusses how you can build and run some of the Amulet samples and test programs. Your first experience with Amulet programming should involve the Amulet Tutorial, which includes a starter program and instructions to acquaint you with the compiling process. When you are ready to write your own Amulet program, see Section 1.4.5.6 for instructions about linking your new program to the Amulet library.

#### 1.4.5.5 Compiling Test Programs and Demos

There are about 10 test programs included in Amulet that test the lower levels of Amulet: the ORE object system, GEM graphics routines, OPAL graphical objects, Interactors event handlers, and Widgets. The project files for these tests appear in the amulet:MAC directory. You can build and run these programs to test your installation of Amulet, but they are not intended to be particularly good examples of Amulet coding style.

#### 1.4.5.6 Writing and Compiling New Programs Using Amulet

The easiest way to create a project file for your own Amulet program is to start with the stationary project files that are provided with the Amulet distribution. They are amulet:MAC:am_stationary68K.stat for 680x0 processors and amulet:MAC:am_stationaryPPC.stat for PowerPC processors. Open the appropriate project file, save it as your new project file and add your application's .cpp files instead. At that point you should be able to successfully compile your Amulet application.

## 1.5 Test Programs and Demos

The procedure for compiling and executing the demos and test programs is different depending on your platform. See Section 1.4.3 for PC-specific instructions, or Section 1.4.4 for Unix-specific instructions on installing Amulet and compiling the tests and samples.

hello This program creates a window and displays 'hello world' in it. You can exit by hitting meta-shift-f1.
goodbye_button This program creates a button widget on the screen which quits when pressed.
goodbye_inter This program displays goodbye world'' in a window, and an interactor causes the program to quit when the text is clicked on.
tutorial This program simply creates a window on the screen. It is the starting point for all the examples in the Amulet Tutorial.
checkers This is a two-player checkers game that demonstrates the multi-screen capabilities of Amulet in Unix. You can run it on two screens by supplying the names of the displays when the program is executed, as in 'checkers my_machine:0.0 your_machine:0.0'. On the PC or Macintosh, you can still run this program, but it can only be displayed on one screen.
space This program looks a little bit like NetTrek, and demonstrates many features of Amulet: constraints, bitmaps, polylines, widgets, and scrolling windows. Some of the interactions to try are:
agate This program is used to train a new gesture classifier for use by the gesture interactor. See Section 5.3.5.6 for more information about the gesture interactor, agate, and gesture classifiers.

Usually the only Amulet header file you'll need to include in your Amulet programs is amulet.h, which will include all of the others for you. If you like to use header files as a reference manual, you can find them in the include/amulet/ directory.

The header file amulet.h includes all the headers most amulet programmers will ever need to use: standard_slots.h, value_list.h, gdefs.h, idefs.h, opal.h, inter.h, and widgets.h. Here is a summary of the basic header files, listing the major objects, classes, and functions they define.

All other header files are considered Advanced header files. They support advanced Amulet features, such as user-defined objects, daemons, constraints, and so on. Most users should never include these files explicitly. For users who will be using Amulet's advanced features, here is a brief summary of the contents of each advanced header file.

### 1.6.3 Standard Header File Macros

The actual names of the header files described above are slightly different on each machine. Long names are truncated on the PC, as described in Section 1.4.3.9. Directory paths aren't specified in the same way on the Mac as they are on Unix. To allow these files to be included simply without explicit conditional compilation on the various platforms, we've provided a set of C++ #defines which give each .h file a standard identifier on all platforms. These #defines are in amulet/include/am_inc.h.

#include <amulet.h>

#include <am_inc.h>

#include OBJECT_ADVANCED__H

#include OPAL_ADVANCED__H

Visual C++ sometimes has problems with am_inc.h if you have the precompiled headers option turned on in your project. Most of the time, building the project again fixes the problem (you don't need to do a Build All). If you get errors such as, #include expected a filename, found an indentifier,'' this is the problem you're experiencing. To avoid it in the future, turn off precompiled headers in your project.

## 1.7 Parts of Amulet

Amulet is divided into several layers, which each have their own interface (and chapter of this manual). The overall picture is shown below.

## 1.8 Known Bugs

We know about several bugs in Amulet which users might come across, which we have not found solutions for yet. Some of them are listed here.

### 1.8.1 Linux bugs

Many people experience various problems compiling and running Amulet on Linux platforms. Some people get internal compiler errors when trying to compile with gcc, particularly gcc 2.7.2. These internal compiler errors are not consistent. They happen in a different section of code each compile, and usually a make clean prevents any of the errors from occurring. Some people compile and link successfully, but then their executable won't run because Linux claims it's not a properly executable file. These bugs might be due to improper Linux/ gcc installations, or to bugs in compiler or OS software. We haven't found any way to fix these problems yet, and we can't reproduce them on the Linux machines we have access to, so we've been unable to find workarounds

### 1.8.2 Visual C++ bugs

Visual C++ 4.1 gets an internal compiler error when trying to compile the dotted/dashed line code in gwline.cpp. Because we don't have access to VC++ 4.1 to debug the problem, we've added a conditional compiler directive to compile out the inline assembly code when compiling with VC++ version 4.1 or newer. Your Amulet code shouldn't crash, but dotted and dashed lines may not be drawn correctly when you compile with VC++ 4.1.

### 1.8.3 Macintosh Bugs

Dotted and dashed lines aren't supported correctly on the Macintosh. For best results using dotted and dashed lines on any platform, you should use the predefined Am_Styles Am_Dotted_Line and Am_Dashed_Line instead of defining your own custom dashed and dotted lines. These predefined styles will be supported in future versions of Amulet, but the dashing and dotting customizations will probably not be supported.

## 1.9 Changes since Version 1.2

There have been many changes in Amulet since version 1. In particular, all code that worked with V1.2 must be edited to compile with version 2 (for details, see Section 1.9.7). The following sections provide a summary of the changes, but you should look in the specific sections of this manual for complete information about Amulet's new features.

### 1.9.2 Changes from V2.0 alpha to V2.0 beta

We have made a few changes between the alpha and beta releases of V2.0. They are described in this section. These should not require editing your code, if you have already upgraded to V2.0alpha.

### 1.9.3 Major Changes between V1.2 and V2.0alpha

Also, tracing and breaking on slot change; many more types print out meaningfully for cout.

### 1.9.4 Minor Changes between V1.2 and V2.0alpha

even if the SLOT of obj does not yet contain a value. The formula must return a real'' value before the result of the formula is used (such as to draw the object).
Unix:
OS: SunOS, HP/UX, Linux, IBM AIX, SGI
Compilers: gcc 2.6.3, gcc-2.7.0, ObjectCenter 2.1.0
PC
OS: Windows NT 3.5 and 3.51 and Windows 95
Compilers: Visual C++ 2.0, 2.1 or 4.0
Mac
Compilers: Metrowerks CodeWarrior 7 and 8

### 1.9.7 Summary of Non-Backwards Compatible Changes

1) All methods must now be declared using the Am_Define_Method_Type, Am_Define_Method_Type_Impl, and Am_Define_Method macros. Details are below.

#### 1.9.7.1 Details

1) Removed Am_Call, Am_Function_Call, Am_Object_Proc type, all of the Function_Narrow routines, and the old *function* types

extern Am_Where_Method Am_Inter_In;

- If you need a new new type, put Am_Define_Method_Type in a .h file for each new type of method (new signature of parameters or return type)

    Am_Object_Method method;

    method = undo_handler.Get(Am_PERFORM_UNDO_THE_UNDO);

    method.Call(undo_handler);


- For every procedure that is used as a method, change its definition to use the Am_Define_Method macro.
- If any of your methods require a new method TYPE, use the define_method_type and define_method_type_impl macros
- Change the storing of the method in the slot to NOT have any casts and NOT have an & in front of it.
- Replace all calls of methods to use the new form.
2)

// in .h file:

extern Am_Formula get_window_height;

// in .cc file:

Am_Define_Formula(int, get_window_height) {

... code ...

}

...

  .Set(Am_HEIGHT, get_window_height)

--- Operationally: replace all Am_Formula::Create(*) with just * and replace all Am_Declare_Formula's with extern Am_Formula

## 1.10 Formal, Legal Language

1. This License Agreement, effective as of April 1, 1996, is between: Carnegie Mellon University having a principal place of business at 5000 Forbes Avenue, Pittsburgh, PA 15213-3890 (CMU''); and a company (`COMPANY'').