                      Copyright 1995, Hyperion Softword

                    *************************************
                    *  Orpheus 2, beta release 2.00.17  *
                    *************************************

                Comments and queries to:  Hyperion Softword,
                535 Duvernay, Sherbrooke, QC J1L 1Y8, Canada
                    tel/fax - 819-566-6296 (Rod Willmot)
                       email - willmot@interlinx.qc.ca


Contents of this file:  Purpose
                        Usage
                        Supported Features
                        Missing Features
                        About CMP Files
                        Making Hotspots



PURPOSE:
========

    This program, the Simulator, is for use with hypertext projects that
    are still under development in OH.EXE.  Normally it is called by
    OH.EXE itself when you give the "Simulate Reader" command on the
    Project Menu.  However, it can also be run as a standalone program.

    The Simulator enables authors to view a work in progress exactly as
    it will be seen in the Reader when finished.  The Simulator obeys
    all project-specific settings made in the Project Options dialog,
    and responds to command buttons set up through the Screen Layout
    dialog.  In order for the Simulator to have something to work with,
    you must at some point give a Compile command, either from the Build
    Dialog (on the Project Menu), or with a convenient command that is also
    on the Project Menu, "Compile, Simulate".  See "About CMP Files" below.

    A special function of the Simulator is to enable authors working with
    graphics to create hotspots.  See "Making Hotspots" below.


USAGE:
======

    To run the Simulator as a standalone program:

        OHSIM [filename]

    where [filename] is the name of the project, with no extension.  The
    project must contain at least one CMP file in its storage directories,
    which in turn must include a compiled version of the project's Homecard.


SUPPORTED FEATURES:
===================

    The Simulator should support all features documented in online Help,
    with the exception of certain elements of the Reader that would be
    pointless to include.  In other words, if you are using a feature
    that will run in the Reader, you should be able to test it in the
    Simulator.  Missing features noted below will be added in coming
    releases.


MISSING FEATURES:
=================

    The Simulator does not yet replicate the Reader's built-in menus (which
    aren't there yet anyway), nor does it provide access to Reader Help
    (which hasn't been written yet).  Support for certain script commands
    will be added in parallel to both the Reader and the Simulator, in
    forthcoming releases.


ABOUT CMP FILES:
================

    Unlike the Orpheus Reader, which uses HTX files, and Orpheus Help,
    which uses HLP files, the Simulator uses the CMP files stored with
    your project's uncompiled cards.  CMP files are created when you
    give a Compile command through the Build Dialog; they contain all
    of the compiled cards for one storage directory.

    CMP files represent an intermediate stage between uncompiled cards and a
    finished, distributable HTX document.  They are the hypertext equivalent
    of the .OBJ files so dear to programmers.  Throughout the development
    period of a project, you should periodically open the Build Dialog
    (on the Project Menu) and, with Selection set to "Compile if new or
    changed", give a "Compile only" command.  All new or updated cards will
    be compiled, with the compiled version stored away automatically in the
    appropriate CMP file.  (NOTE: this does not in any way change the
    original - text file - copies of your uncompiled cards.)  You can then
    use the Simulator to examine and experience your work as if you were
    your intended reader, without having to product a finished HTX and fire
    up OHREAD.EXE.  Of course, when you do give the command to assemble a
    finished product, if most of the work is already present in CMP form
    the assembly will be extremely fast.  Since the compiler will also alert
    you to any problem areas in your project, it's a good idea to do an
    incremental compile at the end of every development day.

    For more about CMP and other files used by Orpheus, see Help on
    Files and Directories.


MAKING HOTSPOTS:
================

    The Simulator is your tool for making hotspots in Orpheus 2.  As
    documented in Help, any Graphic card can have hotspots applied to a
    graphic (PCX, GIF, or other supported format) or to an ansi screen.
    Each hotspot can then be linked either to another card (Text or Graphic)
    OR to one or more commands immediately following the hotspot command.

    The first step in adding a hotspot to a Graphic card is to compile the
    card so that the Simulator can display it.  For example, suppose you
    wish to add hotspots to a PCX (this has no effect on the original PCX
    file).  Start by entering the graphic() command that will display the
    PCX.  Next, compile the card either through the Build Dialog or, more
    conveniently, by giving the Quicktest command on the Project Menu.
    Quicktest compiles the current card and then immediately opens the
    Simulator if no errors were found.  If you use the Build Dialog first,
    give the Simulate Reader command when compilation is finished.

    ---------------------------------------------------------------------
    NOTE: Hotspot-making is thoroughly discussed in online Help, under
    Script Command Reference->Hotspot->Making Hotspots.  In the following
    paragraph I'll just summarize the method for drawing a simple hotspot
    in a graphic screen.  Read Help to learn about setting a "goto" point,
    making a hotspot with multiple parts, and drawing hotspots in ansi
    screens.  YOU CAN ALSO GET QUICK HELP WHILE ACTUALLY DRAWING A HOTSPOT:
    just press <F1> for a command summary.
    ---------------------------------------------------------------------

    Once you are in the Simulator and looking at your Graphic card with the
    displayed graphic, press <Alt-H> to signal that you want to make a
    hotspot.  Orpheus acknowledges the request by beeping twice.  To draw
    the hotspot you will use the left button of the mouse, clicking on the
    corners of a shape defining the desired area of the hotspot.  After the
    first click, you'll notice that a "rubber band" attached to the point
    where you clicked follows the mouse pointer on the other end.  Now point
    to another corner of the area you want to define, and click again.  Add
    one or more additional corners, but do NOT try to click on the corner
    where you started.  Instead, press <Enter> to close the shape:  Orpheus
    draws the final line between the first corner and the last.

        *** Remember, once you have pressed <Alt-H> to begin a hotspot,
        *** you can get quick help on hotspots by pressing <F1>.

    At this stage you could mark the goto point or define additional shapes
    as part of the same hotspot, but for now we'll keep it simple:  having
    pressed <Enter> already to close the shape, press <Enter> again to conclude
    your work on that hotspot.

    What happens next is new as of version 2.00.14:  the Simulator prompts
    you to enter a brief description of the hotspot.  This is to help you
    identify that hotspot later, when you are ready to link it to something.
    If you plan to make additional hotspots in other cards, in the same
    session, it's a good idea to include the card number in your description.
    The card number is displayed in the upper portion of the dialog.

    After you have entered your description, the Simulator saves your new
    hotspot (including the description) to a text file named HOTSPOT.LOG.
    This file is stored in your project's Project directory.  If you make
    additional hotspots during the same session in the Simulator, they will
    be added to this file; however, the next time you enter the Simulator
    and make another hotspot, the old data will be erased.

    The next step is to copy your hotspot into your Graphic card.  Press
    <Alt-F4> to exit the Simulator; unless you ran OHSIM.EXE from the DOS
    prompt, this returns you to where you started from in OH.EXE.  To load
    your hotspot, open the Link Menu and select "Hotspot".  This calls up
    the Hotspot Dialog, where you can either insert the contents of the
    entire HOTSPOT.LOG file at the cursor, or load the file into a separate
    window.  Use the first method if you only made hotspots in the same
    card; use the second method if you made hotspots in different card
    during the same Simulator session.  If you do load HOTSPOT.LOG in
    another window, you can copy selected command lines wherever you wish
    the same as you would mark and copy any other text.

    One thing to remember about the hotspot() command:  it must go *below*
    the graphic() or ansi() command that displays whatever image is intended
    to have that hotspot.  This is because Orpheus (the Reader and
    Simulator) will only a hotspot that was made at the same screen resolution
    as the graphic currently onscreen.

    After you have copied or inserted your hotspot command from HOTSPOT.LOG
    into your graphic card, you can link it another card or to the commands
    on lines below it.  Both techniques are discussed in online Help, which
    is essential reading.  Though all this may seem complicated to read it
    here, after you've made half a dozen hotspots you'll find the procedures
    simple and pretty quick.

    To test a finished hotspot, do another quick compile and check it out in
    the Simulator.


