zProLang
============================================================================

	Summary  Interface class to the ProBoard language files.

	Remarks  zProLang is a class that directly supports the ProBoard
	         language files. It will handle almost any type of prompt you
	         can encounter there. Works in both EXE and SDK modes (will
	         display files locally, but won't run pexen in EXE mode). You
	         can load any number of prompts in a single object and then
	         display them at any time in your program.


	ZPROLANG::ZPROLANG
	------------------------------------------------------------------------

		Summary  Prepares a language file for use and constructs the object.

		Syntax   zProLang(zTerminal * const pTerminal);

		Remarks  This constructor will create a zProLang object and attach
		         it to the current user's language file. It will also set
		         the internal search mode depending on the existence of a
		         language index file (created by SCiUTIL). If this file
		         exists (instruct your users to run SCiUTIL) and it is up to
		         date, it will be used by the loader, otherwise, the file
		         will be searched sequentially. The 'pTerminal' constant
		         pointer should point to a zTerminal object created by the
		         caller. This is necessary because the display functions
		         do not interpret the ProBoard language codes themselves
		         but simply pass them on to the terminal object. This means
		         that you must have a 'proboard_interp' interpreter
		         installed in the terminal hander _before_ you call this
		         constructor. For more information, refer to the zTerminal
		         class documentation.


	ZPROLANG::~ZPROLANG
	------------------------------------------------------------------------

		Summary  Destroys the object and disposes of all memory allocations.

		Syntax   ~zProLang();

		Remarks  Frees all memory allocated by the object internally. If you
		         choose to create the object with the 'new' operator, make
		         sure you use 'delete' to dispose of the object and invoke
		         the destructor or a memory leak will occur.


	ZPROLANG::LOAD
	------------------------------------------------------------------------

		Summary  Loads a prompt definition from the language file.

		Syntax   Boolean Load(short aNum);

		Remarks  Loads a prompt specified by the 'aNum' parameter. Prompts
		         are numbered the same way they are in the ProCFG language
		         editor, i.e. they start from 1, not 0. This function will
		         return True is the prompt has been found and loaded
		         successfully and False otherwise. Make sure you give a
		         valid number here. You can Load() any number of prompts
		         into the same object and they can be all used after that
		         with the Exec() method. It is not required to preload the
		         prompts, though, as Exec() will do that if you request a
		         prompt which has not been pre-loaded.


	ZPROLANG::EXEC
	------------------------------------------------------------------------

		Summary  Displays a prompt definition.

		Syntax   int Exec(short aNum, Boolean honorType = True);

		Remarks  Display a previously loaded prompt. You have to use the
		         Load() method to load the prompt into the object. Then use
		         this method to display it. The 'aNum' parameter passed to
		         this function is the same you used in the Load() function.
		         If you compile to SDK pex mode (with the PB_SDK #defined),
		         the prompts will behave just like ProBoard itself. *.A??
		         files will be shown and pexen will be executed. The EXE
		         version will ignore the PEX prompts (@pFILENAME@) but it
		         will display *.A?? files using the same search algorithm
		         as ProBoard. First an Avatar file, the ANSi, and finally
		         ASCii. Note that it is fine to Exec() prompts that have
		         not been loaded with Load(). In this case, the function
		         will call Load() to get them. The 'honorType' parameter
		         which defaults to True specifies how the function should
		         handle prompts (i.e. text strings that have some hotkeys
		         associated with them). If 'honorType' is enabled, the
		         routine will return the hotkey number in the hotkey list
		         (starting from 1). It is your responsibility to know what
		         to do with it. For example, prompt #4 has three hotkeys.
		         The first one specifies a 'Yes' response, the second one -
		         a 'No' response, and the third one - 'Continuous' response.
		         You need not concern which keys are defined there. Instead,
		         if you receive 1 as a return value, you should assume a yes
		         response. If you disable this processing, the function will
		         display the prompt and return immediately even if the prompt
		         has hotkeys.

		Return	 -1 on error
		          0 on normal display
		         >0 hotkey pressed


	ZPROLANG::ERROR
	------------------------------------------------------------------------

		Summary  Report and reset status of internal error flag.

		Syntax   Boolean Error();

		Remarks  Return the current error state. Returns True if there was
		         an error and False otherwise. This will reset the internal
		         flag, so you can check for multiple errors. Use after
		         constructing the object to find out if the file was found
		         and loaded successfully. Also use after the Load() method
		         to find out if the prompt has been loaded successfully. The
		         Exec() method does not set the error flag.


	ZPROLANG::GETNUMPROMPTS
	------------------------------------------------------------------------

		Summary  Returns the number of prompts in the language file.

		Syntax   ushort GetNumPrompts() const;

		Remarks  Return the number of prompts in the loaded language file.
		         This number varies from version to version (i.e. newer
		         ProBoard language files have more entries).


	ZPROLANG::GETFLAGS, ZPROLANG::GETLEVEL, ZPROLANG::GETSTATUS
	------------------------------------------------------------------------

		Summary  Check accessibility of the language file.

		Syntax   ulong GetFlags() const;
                 ushort GetLevel() const;
                 Boolean GetStatus() const;

		Remarks  The first one returns the access flags for this language
		         file in standard ProBoard bitmap format. The second returns
		         the access level for this language file. And the last one
		         returns True if the language is available or False if not.


	ZPROLANG::GETNAME, ZPROLANG::GETCOPYRIGHT
	------------------------------------------------------------------------

		Summary  Retrieve the name and copyright text for the language.

		Syntax   const char *GetName() const;
                 const char *GetCopyright() const;

		Remarks  Get the name of the language. This is different from the
		         file name and is set in the language editor. This is
		         usually a longer description. The second function gets the
		         copyright string for the language file. This is usually set
		         by the person who created the file. May not be present in
		         all files, though.


	ZPROLANG::GETMENUPATH, GETTEXTPATH, GETQUESTPATH
	-------------------------------------------------------------------------

		Summary  Retrieve the location of the language support files.

		Syntax   const char *GetMenuPath() const;
                 const char *GetTextPath() const;
                 const char *GetQuestPath() const;

		Remarks  Return the paths that define the location of the menus,
		         the display files and the questionnaires for this file.

    ZPROLANG::GETITEMTEXT, GETITEMKEYS
    -------------------------------------------------------------------------

        Summary  Retrieve the text and hotkey list for an item.

        Syntax   const char *GetItemText(short aNum);
                 const char *GetItemKeys(short aNum);

        Remarks  These functions return the raw text and hotkey list (if
                 any) for prompt number 'aNum'. Note that both functions
                 assume that the prompt is loaded already (i.e. unlike
                 Exec(), they will _not_ automatically load the prompt).

