/*	XMessages.h
 *
 *		Events that are sent by the YAAF library. This is a clearing
 *	house for all library events
 */

/**********************************************************************

  YAAF is Copyright 1997-1999 by William Woody.

  Redistribution and use in source and binary forms, with or without 
  modification, are permitted provided that the following conditions 
  are met:

  Redistributions of source code must retain the above copyright notice, 
  this list of conditions and the following disclaimer.

  Neither the name of the copyright holder or other contributors may
  be used to promote products derived from this software without
  specific written prior permission.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
  OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
  SOFTWARE.
  
  Contact:   woody@alumni.caltech.edu
  Web page:  http://www.pandawave.com/yaaf/

**********************************************************************/

#ifndef PandaWave_XMESSAGES
#define PandaWave_XMESSAGES

#include <XConfig.h>

/**@name YAAF Messages
 *
 *		These are the macros defining the different messages that are sent
 *	internally by YAAF.
 *
 *		Each message that is sent by YAAF consists of the triple
 *	(message, argument, ptr_argument). The first parameter #message#
 *	is a constant which indicates the type of message. Those message
 *	macros are listed below.
 *
 *		The second #argument# parameter is a 32-bit long integer which
 *	is dependant on the message. The third #ptr_argument# parameter is
 *	a (void *) parameter which is also dependant on the message, and
 *	generally points to a structure containing more information.
 *
 *		Each message may also return a 32-bit long integer indicating
 *	the status of that message. In general, if you do not process a
 *	message, you should return '-1'. Messages that fail generally return
 *	'0', and success with '1', though that's message-specific. The
 *	return value of broadcast messages are ignored.
 *
 *		Note that message identifiers are only guarenteed unique to
 *	a particular control or message source. That means that different
 *	controls may potentially send the same message identifier, but have
 *	different meanings for those message identifiers. (Generally most
 *	controls send their control identifier in the #arg# parameter, and
 *	are encouraged to do so.)
 *
 *		Also note that identifiers are generally identified as a 32-bit
 *	quantity that is a four-character code. YAAF reserves all lower-case
 *	four character codes for system messages, meaning that when we add
 *	new messages in the future that are internal to the YAAF event loop
 *	or window or view message handling, these will be composed of lower-
 *	case characters only.
 */
 
//@{

/************************************************************************/
/*																		*/
/*	Forwards															*/
/*																		*/
/************************************************************************/

class XGWindow;
class XGDocument;
class XGView;
class XGSlider;
class XGInlineEdit;
class XGInlinePopup;

/************************************************************************/
/*																		*/
/*	Application Events													*/
/*																		*/
/************************************************************************/

/*$	KXGAppPreEvent
 *
 *		This message is globally broadcast to all registered receivers
 *	before an event is pulled from the event queue and processed.
 *
\begin{verbatim}
		Type:			Broadcast
		Args:
			arg         0
			parg        NULL
		Return:
			ignored
\end{verbatim}
 */

#define KXGAppPreEvent		'pree'

/*$	KXGAppPostEvent
 *
 *		This message is globally broadcast to all registered receivers
 *	after an event is pulled from the event queue and processed.
 *
\begin{verbatim}
		Type:			Broadcast
		Args:
			arg         0
			parg        NULL
		Return:
			ignored
\end{verbatim}
 */

#define KXGAppPostEvent		'post'

/*$	KXGAppPeriodic
 *
 *		This message is sent to the current focus. This permits you to
 *	handle things like a blinking cursor in a text editor box.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        NULL
		Return:
			ignored
\end{verbatim}
 */

#define KXGAppPeriodic		'peri'

/*$	KXGAppEvent
 *
 *		This is sent before an event is processed. This broadcasts
 *	the message structure. Return 1 if the message should not be
 *	handled by my internal event loop, return 0 (or -1) if the
 *	message should be handled.
 *
 *		If you have a need to filter out events globally (for
 *	example, to support QuickTime), you should override the
 *	XGAppCore::FilterEvent method instead.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        pointer to OS dependant event record
		Return:
			-1:         not processed here; passed up to parent.
			0:          this event should be passed through the
			            rest of YAAF.
			1:          this event should *not* be processed by
			            YAAF.
\end{verbatim}
 */

#define KXGAppEvent			'even'

/*$	KXGKeyEvent
 *
 *		Keyboard event.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         hi word: modifier flags
			            lo word: keyboard key code or char code (If
			            KSpecialKey set, this is one of the following
			            key codes listed below
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
			
If the KSpecialKey flag is set, the key code in the low word of arg
is one of the key codes listed below:

	KKeyUpCursor        Up arrow key
	KKeyDownCursor      Down arrow key
	KKeyLeftCursor      Left arrow key
	KKeyRightCursor     Right arrow key
	KKeyInsert          Insert key
	KKeyDelete          Delete key (backspace key)
	KKeyHome            Home key
	KKeyEnd             End key
	KKeyPageUp          Page Up key
	KKeyPageDown        Page Down key
	KKeyEscape          Escape key
	KKeyHelp            Help key (Macintosh)
	KKeyNumLock         Num Lock key
	KKeyClear           Clear key (Macintosh)

	KKeyF1              F1 through F15 keys
	KKeyF2
	KKeyF3
	KKeyF4
	KKeyF5
	KKeyF6
	KKeyF7
	KKeyF8
	KKeyF9
	KKeyF10
	KKeyF11
	KKeyF12
	KKeyF13
	KKeyF14
	KKeyF15

\end{verbatim}
 */

#define KXGKeyEvent			'keye'

#define	KKeyUpCursor		128
#define KKeyDownCursor		129
#define KKeyLeftCursor		130
#define KKeyRightCursor		131
#define KKeyInsert			132
#define KKeyDelete			133
#define KKeyHome			134
#define KKeyEnd				135
#define KKeyPageUp			136
#define KKeyPageDown		137
#define KKeyEscape			138
#define KKeyHelp			139
#define KKeyNumLock			140
#define KKeyClear			141

#define KKeyF1				160
#define KKeyF2				161
#define KKeyF3				162
#define KKeyF4				163
#define KKeyF5				164
#define KKeyF6				165
#define KKeyF7				166
#define KKeyF8				167
#define KKeyF9				168
#define KKeyF10				169
#define KKeyF11				170
#define KKeyF12				171
#define KKeyF13				172
#define KKeyF14				173
#define KKeyF15				174

/*$	KXGMenuKey
 *
 *		This is sent when a menu key (a key with an accelerator)
 *	is sent. This is used by Windows and X for keyboard navigation of
 *	dialog boxes.
 *
 *		The arguments and usage is identical to the KXGKeyEvent
 *	message. Note that this is *not* sent on the Macintosh; the
 *	Macintosh User Interface Guidelines does not support keyboard
 *	navigation. That permits you to write the appropriate nagivation
 *	rules yourself: on the Macintosh, the events will simply not
 *	be sent.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         hi word: modifier flags
			            lo word: keyboard key code or char code (If
			            (See KXGKeyEvent for more information.)
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define KXGMenuKey			'keym'

#if OPT_WINOS

/*	KXGWInternal
 *
 *		Internal event; this is sent to the view that contains a 
 *	control, so that control events can be funneled through the YAAF
 *	event dispatch mechanism.
 *
 *		This is specific to Windows 95/Windows NT
 */

#define KXGWInternal			'wint'

struct XGSWInternalRecord {
	HWND		w;
	UINT		msg;
	WPARAM		wp;
	LPARAM		lp;
};

#endif // OPT_WINOS

/************************************************************************/
/*																		*/
/*	Menu Events															*/
/*																		*/
/************************************************************************/

/*$	KXGGetMenuStatus
 *
 *		This gets the status of this menu item in the menu bar. This
 *	message is dispatched to the current focus of this focus event
 *	for every menu command when the XGMenu::UpdateMenuBar() method
 *	is called. This is used to determine which items should be checked
 *	and which should be enabled.
 *
 *		A toolbar which provides menu command functionality can also
 *	send this command in order to determine which buttons in the toolbar
 *	should be activated and which should be hilited.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         Menu Command ID
			parg        Pointer to XGSMenuStatus record
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
			
		The pointer provided in parg points to a structure with the
		following format:
		
		struct XGSMenuStatus {
			bool		enable;				// should this be enabled?
			bool		check;				// should this be checked?
			char		mark;				// mark to use for menu check
		};

		If you want to check the menu with something other than a
		checkmark, you would put one of the following constants into
		the mark field:

		#define KXGCommand			0x11	// Use command mark
		#define KXGCheckmark		0x12	// Use checkmark (default)
		#define KXGDiamond			0x13	// Use diamond
		
		Note that the behavior of the 'check' and 'mark' fields are
		different than that used by PowerPlant. Here, the 'check'
		field is set to 'true' if the menu item should be checked.
		If it should be checked, then you can alter the value in
		the 'mark' field if you want to show something other than
		a checkmark. This can also be loaded with an ASCII character,
		such as a 'o' or '-' character.
\end{verbatim}
 */

#define KXGGetMenuStatus			'stat'

/*	XGSMenuStatus
 *
 *		This is the record passed as part of the KXGGetMenuStatus
 *	event; this contains the place where the return results should
 *	be placed.
 */

struct XGSMenuStatus {
	bool		enable;				// should this be enabled?
	bool		check;				// should this be checked?
	char		mark;				// mark to use for menu check
};

/*
 *	XGSMenuStatus.mark constants
 */

#define KXGCommand			0x11	// Use command mark
#define KXGCheckmark		0x12	// Use checkmark (default)
#define KXGDiamond			0x13	// Use diamond

/*$	KXGDoMenuCommand
 *
 *		This gets sent when the specified menu command was clicked
 *	by the user. This event is dispatched as a result of calling the
 *	OS dependant event processing routines for the menu bar with the
 *	specified focus.
 *
 *		A toolbar which provided menu command functionality can
 *	also send this event when a button in the toolbar is pressed
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         Menu Command ID
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define KXGDoMenuCommand			'menu'

/************************************************************************/
/*																		*/
/*	File Events															*/
/*																		*/
/************************************************************************/

/*$	KXGOpenApplication
 *
 *		Open application. Sent if no files are explicitly specified
 *	when this application was first start up.
 *
 *		Note that while this is a dispatched message, you should
 *	handle the message in your application object. That will provide
 *	consistant behavior as your application runs.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define KXGOpenApplication			'oapp'

/*$	KXGDoOpenDocument
 *
 *		Open document. Sent when a document is specified in the command
 *	line on application launch.
 *
 *		Note that while this is a dispatched message, you should
 *	handle the message in your application object. That will provide
 *	consistant behavior as your application runs.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        Pointer to file specification.
			
						(Version 1.0a6 or earlier)
						
			            (Macintosh: FSSpec * of file to open)
			            (Windows, X: char * of full path of file to open)
			            
			            (Version 1.0a7 or later)
			            
			            Points to an XGFileSpecifier object with the
			            specified file.
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define KXGDoOpenDocument				'odoc'

/*$	KXGDoPrintDocument
 *
 *		Print document. Sent when the document is asked to be printed
 *
 *		Note that while this is a dispatched message, you should
 *	handle the message in your application object. That will provide
 *	consistant behavior as your application runs.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        Pointer to file specification.
			
						(Version 1.0a6 or earlier)
						
			            (Macintosh: FSSpec * of file to open)
			            (Windows, X: char * of full path of file to open)
			            
			            (Version 1.0a7 or later)
			            
			            Points to an XGFileSpecifier object with the
			            specified file.
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define KXGDoPrintDocument			'pdoc'

/*
 *	The following declarations are used to help find code which
 *	needs updating
 */

#define KXGOpenDocument				(do "KXGOpenDocument superceeded. Please see docs.")
#define KXGPrintDocument			(do "KXGPrintDocument superceeded. Please see docs.")

/*$	KXGQuitApplication
 *
 *		Quit application. This is sent when your application is asked
 *	to shut down. If you trap this message, you must either shut the
 *	application down yourself by calling the XGAppCore::Exit() routine,
 *	or you can return 0 (and thus prevent application termination), or
 *	return -1 to pass the message upwards.
 *
 *		By default this message is processed by the XGAppCore routine
 *	by closing all open windows, and if they can be closed, exiting
 *	the application. 
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define KXGQuitApplication			'qapp'


/************************************************************************/
/*																		*/
/*	Window Events														*/
/*																		*/
/************************************************************************/

/*$	KXGEventWindowName						(dispatch)
 *
 *		This event is sent upwards when a window is renamed. This gives
 *	the objects above which are maintaining a window menu to update it's
 *	contents
 *
 *		Note that this message is used by the XGAppMultiWindow
 *	class to maintain the window menu.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        Pointer to XGSWindowEvent object with name already 
			            set in the window.
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
			
		The parg parameter contains a pointer to the following structure.
		This structure is used by all of the window event routines.
		
		struct XGSWindowEvent {
			XGWindow		*window;		// Pointer to current window
		};

\end{verbatim}
 */

#define KXGEventWindowName			'namw'

/*	XGSWindowEvent
 *
 *		This is the way views are passed through the parg pointer.
 *	Instead of a pointer to the parg (which can be confusing), we
 *	pass a pointer to one of these.
 */

struct XGSWindowEvent {
	XGWindow						*window;
};

/*$	KXGEventWindowCreate						(dispatch)
 *
 *		This event is sent when a window is created. If the window
 *	should not be created, you can throw an error. (If you need the
 *	window to not be created *silently*, throw the XGAbort object.)
 *
 *		Note that this message is used by the XGAppMultiWindow
 *	class to maintain the window menu.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        Pointer to XGSWindowEvent object with name already 
			            set in the window.
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
			
		The parg parameter contains a pointer to the following structure.
		This structure is used by all of the window event routines.
		
		struct XGSWindowEvent {
			XGWindow		*window;		// Pointer to current window
		};

\end{verbatim}
 */

#define KXGEventWindowCreate		'crew'

/*$	KXGEventWindowPreDestroy					(dispatch)
 *
 *		This event is sent when a window is about to be destroyed. If the
 *	window is not to be destroyed, throw an error. (If you need the window
 *	to not be destroyed *silently*, throw the XGAbort object.)
 *
 *		Note that this message is used by the XGAppMultiWindow
 *	class to maintain the window menu.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        Pointer to XGSWindowEvent object with name already 
			            set in the window.
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
			
		The parg parameter contains a pointer to the following structure.
		This structure is used by all of the window event routines.
		
		struct XGSWindowEvent {
			XGWindow		*window;		// Pointer to current window
		};

\end{verbatim}
 */
 
#define KXGEventWindowPreDestroy 	'pdsw'

/*$	KXGEventWindowDestroy						(dispatch)
 *
 *		This event is sent when the window is destroyed. While the
 *	window pointer is still valid when this message is thrown, it 
 *	will be immediately torn down right afterwards. Further, some
 *	resources associated with this window may have already been
 *	shut down. This is the only message which guarentees that the
 *	window is now gone.
 *
 *		Note that this message is used by the XGAppMultiWindow
 *	class to maintain the window menu.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         0
			parg        Pointer to XGSWindowEvent object with name already 
			            set in the window.
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
			
		The parg parameter contains a pointer to the following structure.
		This structure is used by all of the window event routines.
		
		struct XGSWindowEvent {
			XGWindow		*window;		// Pointer to current window
		};

\end{verbatim}
 */

#define KXGEventWindowDestroy		'desw'

/************************************************************************/
/*																		*/
/*	Control Events														*/
/*																		*/
/************************************************************************/

/*$	KXGControlClick
 *
 *		The control specified was clicked on. This is sent by buttons
 *	and other things that may be triggered. Logically this indicates that
 *	a control was "clicked", whatever that control happens to be.
 *
 *		Note that if the control is a list item and it's clicked on,
 *	this sends the KXGListValue message instead.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the control sending this message
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define	KXGControlClick				'cclk'

/*$	KXGKeyClick
 *
 *		This is sent by the edit box every time a key is pressed or
 *	the contents of the edit box is otherwise changed. This
 *	gives the top level code the opportunity to say 'no' to this key
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the control sending this message
			parg        pointer to the new contents (as a C string)
		Return:
			-1:         not processed, passed up to parent.
			0:          processed here; accept update
			1:          processed here; change is *not* acceptable.
\end{verbatim}
 */

#define KXGKeyClick					'kclk'

/*$	KXGListSelect
 *
 *		This message is sent when the list is double-clicked on. You
 *	must get the list and query the current selection to determine
 *	which items were double-clicked.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the control sending this message
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */
 
#define KXGListSelect				'lsel'

/*$	KXGListValue
 *
 *		This message is sent when the list has had a state change
 *	due to being clicked on. You must get the list and query the
 *	selection to determine what was selected.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the control sending this message
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */
 
#define KXGListValue				'lval'

/*$	KXGPopValue
 *
 *		Popup value. This is sent by a pop-up menu when the user
 *	changes the value through selection. You have to query the
 *	control to get it's current value.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the control sending this message
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define	KXGPopValue					'pval'

/*$	KXGSliderStart
 *
 *		This message is sent <<before>> a scrollbar or slider's values 
 *  are changed. This gives anything which relies on the control's
 *	value to update an opportunity to do so before change messages
 *	are sent.
 *
 *		This works around a problem when the current contents of a
 *	window is scrolled before an update event can be processed; in that
 *	event, under some circumstances, the update region gets confused,
 *	and the window winds up with dirty (or unrendered) bits. This
 *	helps avoid that problem by giving the window the opportunity
 *	to update itself before scrolling bits around.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the control sending this message
			parg        NULL
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
\end{verbatim}
 */

#define KXGSliderStart				'scrs'

/*$	KXGSliderValue
 *
 *		This message is sent by controls which automatically change
 *	in value, such as sliders and scrollbars. This gives your aplication
 *	a chance to respond to changes in the slider value as they occur,
 *	or when they are complete.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the control sending this message
			parg        Pointer to XGSValue structure
		Return:
			-1:         not processed, passed up to parent.
			other:      processed here.
			
	The parg pointer points to a structure of type XGSValue, which
	contains a pointer to the slider, as well as the slider's old
	and new values. This gives your control the opportunity to
	update itself properly, knowing the old and new values.
	
	The structure's format is:
			
		struct XGSValue {
			XGSlider		*slider;	// pointer to slider control
			long			oldVal;		// old slider value
			long			newVal;		// new slider value
		};
\end{verbatim}
 */

#define KXGSliderValue				'sval'

struct XGSValue {
	XGSlider						*slider;
	long							oldVal;
	long							newVal;
};

/*$	KXGInlineClose
 *
 *		Inline edit view will close. If this returns 1, the
 *	inline edit view won't be closed. This gives your application
 *	the opportunity to save the contents of an inline editor
 *	control, so that your data field can be updated.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the inline editor sending this message
			parg        Pointer to XGSInline structure
		Return:
			-1:         not processed, passed up to parent.
			0:          processed here. The inline editor can close
			1:          processed here. The inline editor will *not*
			            close, but will remain open. Note that this can
			            look a bit strange when the reason for the
			            inline editor going into the background is
			            because the focus was lossed due to the
			            window being moved.
			            
			            Also note that due to a change in the way
			            YAAF handles the focus, if the focus is
			            shifted to another control in the same window,
			            this *will* close the inline editor box.
			            So this should be treated only as a *hint*;
			            it is possible that the window will be closed
			            dispite your desires...
			
	The parg pointer points to a structure of type XGSInline, which
	as the following format:

		struct XGSInline {
			XGInlineEdit	*edit;		// pointer to inline editor control
		};
 */

#define KXGInlineClose				'icls'

struct XGSInline {
	XGInlineEdit					*edit;
};

/*$	KXGPopupInlineClose
 *
 *		Inline popup view will close. If this returns 1, the
 *	inline edit view won't be closed. This gives your application
 *	the opportunity to save the contents of an inline editor
 *	control, so that your data field can be updated.
 *
\begin{verbatim}
		Type:			Dispatched
		Args:
			arg         ID of the inline editor sending this message
			parg        Pointer to XGSInline structure
		Return:
			-1:         not processed, passed up to parent.
			0:          processed here. The inline editor can close
			1:          processed here. The inline editor will *not*
			            close, but will remain open. Note that this can
			            look a bit strange when the reason for the
			            inline editor going into the background is
			            because the focus was lossed due to the
			            window being moved.
			            
			            Also note that due to a change in the way
			            YAAF handles the focus, if the focus is
			            shifted to another control in the same window,
			            this *will* close the inline editor box.
			            So this should be treated only as a *hint*;
			            it is possible that the window will be closed
			            dispite your desires...
			
	The parg pointer points to a structure of type XGSInline, which
	as the following format:

		struct XGSPopupInline {
			XGInlinePopup	*popup;		// pointer to inline popup control
			long			value;		// value of current selection or -1
										// if no change.
		};
 */

#define KXGPopupInlineClose			'pcls'

struct XGSPopupInline {
	XGInlinePopup					*popup;	// pointer to inline popup control
	long							value;	// value of current selection or -1
											// if no change.
};

//@}

#endif
