menu.c

NASA 开发使用的一个专家系统

   /*******************************************************/
   /*      "C" Language Integrated Production System      */
   /*                                                     */
   /*                  A Product Of The                   */
   /*             Software Technology Branch              */
   /*             NASA - Johnson Space Center             */
   /*                                                     */
   /*               CLIPS Version 6.00  10/01/92          */
   /*                                                     */
   /*                     MENU MODULE                     */
   /*******************************************************/

/**************************************************************/
/* Purpose: Contains the callback functions for items on the  */
/*      main menu.                                            */
/*                                                            */
/* Principal Programmer(s):                                   */
/*      Christopher J. Ortiz                                  */
/*                                                            */
/* Contributing Programmer(s):                                */
/*                                                            */
/* Revision History:                                          */
/*                                                            */
/**************************************************************/

/*-------------------------------+
| Windows & System Include Files |
+-------------------------------*/
#include <windows.h>
#include <stdlib.h>
#include <string.h>

/*------------------------+
| CLIPS 6.0 Include Files |
+------------------------*/
#include "setup.h"
#include "commline.h"
#include "filecom.h"
#include "router.h"
#include "agenda.h"
#include "evaluatn.h"
#include "dffctdef.h"
#include "genrccom.h"
#include "defins.h"
#include "classcom.h"
#include "engine.h"
#include "dffnxfun.h"
#include "globldef.h"
#include "tmpltdef.h"

/*------------------------+
| Interface Include Files |
+------------------------*/
#include "ids.h"
#include "clipsdde.h"
#include "dialog.h"
#include "main.h"
#include "menucmds.h"
#include "diag_win.h"

/*----------------+
| Local Functions |
+----------------*/
VOID DoExecutionChoice ( HWND, WORD );
VOID DoWindowChoice (HWND, WORD);
VOID DoBrowseChoice (HWND, WORD);
VOID DoFileChoice   (HWND, WORD);
VOID DoHelpChoice   (HWND, WORD);
VOID DoModuleChoice (HWND, WORD);

char CompleteString[255];

/*******************************************************************
* DialogWndProc: Call back function to handle the main menu.
*******************************************************************/

long FAR PASCAL DialogWndProc(hMain, message, wParam, lParam)
   HWND     hMain;
   unsigned message;
   WORD     wParam;
   LONG     lParam;

{  switch (message)
   {  case WM_COMMAND:
      {  switch ( wParam )
	 {  extern HMENU hMenu;

	    /*----------+
	    | File Menu |
	    +----------*/
	    case IDM_FILE_LOAD:
	    case IDM_FILE_LBATCH:
	    case IDM_FILE_LBINARY:
	    case IDM_FILE_EDITOR:
	    case IDM_FILE_DRIBBLE:
	    case IDM_FILE_SBINARY:
	    case IDM_FILE_QUIT:
	    case IDM_EDIT_PASTE:
	       DoFileChoice ( hMain, wParam );
	       break;

	    /*------------+
	    | Browse Menu |
	    +------------*/
	    case IDM_BROWSE_RULE:
	    case IDM_BROWSE_TEMPLATE:
	    case IDM_BROWSE_FACTS:
	    case IDM_BROWSE_FUNCTION:
	    case IDM_BROWSE_GLOBAL:
	    case IDM_BROWSE_GENERIC:
	    case IDM_BROWSE_CLASS:
	    case IDM_BROWSE_INSTANCES:
	    case IDM_BROWSE_AGENDA:
	       DoBrowseChoice ( hMain, wParam );
	       break;

	    /*------------+
	    | Window Menu |
	    +------------*/
	    case IDM_WIN_FACTS:
	    case IDM_WIN_AGENDA:
	    case IDM_WIN_FOCUS:
	    case IDM_WIN_INSTANCE:
	    case IDM_WIN_GLOBALS:
	    case IDM_WIN_ALL:
	    case IDM_WIN_NONE:
	    case IDM_WIN_CLEAR:
	    case IDC_WIN_MINIMIZE:
	    case IDC_WIN_MAXIMIZE:
	       DoWindowChoice (hMain, wParam);
	       break;

	    /*---------------+
	    | Execution Menu |
	    +---------------*/
	    case IDM_EXE_PREFERENCES:
	    case IDM_EXE_OPTIONS:
	    case IDM_EXE_WATCH:
	    case IDM_EXE_RESET:
	    case IDM_EXE_RUN:
	    case IDM_EXE_HALT:
	    case IDM_EXE_HALT_NOW:
	    case IDM_EXE_STEP:
	    case IDM_EXE_CLEAR:
	       DoExecutionChoice ( hMain, wParam );
	       break;

	    /*----------+
	    | Help Menu |
	    +----------*/
	    case IDM_HELP_ABOUT:
	    case IDM_HELP_COMPLETE:
	    case IDM_HELP_CLIPS:
	       DoHelpChoice ( hMain, wParam);
	       break;

	    /*------------+
	    | Module Menu |
	    +------------*/
	    default:
	    {  if ( wParam >= IDM_MODULE_ONE )
	       {  HMENU hMenu = GetMenu (hMain);
		  DoModuleChoice ( hMenu, wParam );
	       }
	       break;
	    }

	 }
	 break;
      } // WM_COMMAND

      default:
	 return DoWindowMessage ( hMain, message, wParam, lParam );
   }
   return ( NULL );
}

/***************************************************
* DoExecutionChoice: Process all menu options from
*    the EXECUTION menu.
****************************************************/

VOID DoExecutionChoice ( hMain, wParam )
   HWND hMain;
   WORD wParam;

{  extern HANDLE hInst;

   switch (wParam)
   {   case IDM_EXE_PREFERENCES:
		{  FARPROC lpOptionDlg;
	 lpOptionDlg = MakeProcInstance (OptionDlgProc, hInst);
	 DialogBox (hInst, "OptionDlg", hMain, lpOptionDlg);
	 FreeProcInstance (lpOptionDlg);
	 break;
      }

      case IDM_EXE_OPTIONS:
		{  FARPROC lpProcOption;
	 lpProcOption = MakeProcInstance(ExecDlg, hInst);
	 DialogBox(hInst,"Exec_Option", hMain, lpProcOption);
	 FreeProcInstance(lpProcOption);
	 break;
      }

      case IDM_EXE_WATCH:
		{  FARPROC lpWatchDlg;
	 lpWatchDlg = MakeProcInstance (WatchDlgProc, hInst);
	 DialogBox (hInst, "WatchDlg", hMain, lpWatchDlg);
	 FreeProcInstance (lpWatchDlg);
	 break;
      }

      case IDM_EXE_CLEAR:
      {  if ( JoeWarnings ("OK to clear CLIPS environment?"))
	 {  PrintCLIPS ("wclips","(clear)\n");
	    UpdateCursor ( WAIT_CURSOR );
	    Clear ( );
	    PrintPrompt();
	    UpdateCursor ( ARROW_CURSOR );
	 }
	 break;
      }

      case IDM_EXE_RESET:
      {  if ( GetNextActivation(NULL)!=NULL)
	 {  if (!JoeWarnings ("There are activations on the agenda.  OK to reset the CLIPS environment?"))
		break;
	 }
	 PrintCLIPS ("wclips","(reset)\n");
	 UpdateCursor ( WAIT_CURSOR );
	 Reset ( );
	 PrintPrompt();
	 UpdateCursor ( ARROW_CURSOR );
	 break;
      }

      case IDM_EXE_RUN:
      {  PrintCLIPS ("wclips","(run)\n");
	 SetCommandString(    "(run)\n");
	 break;
      }

      case IDM_EXE_HALT:
      {  extern int ShiftKeyDown;
	 if ( !ShiftKeyDown )
	 {  if ( ExecutingRule != NULL )
	      HaltRules = CLIPS_TRUE;
	    else
	    {  SetHaltExecution(CLIPS_TRUE);
	       CloseAllBatchSources();
	    }
	    break;
	 }
      }

      case IDM_EXE_HALT_NOW:
      {  SetHaltExecution ( CLIPS_TRUE );
	 CloseAllBatchSources();
	 break;
      }

      case IDM_EXE_STEP:
      {  extern int rulestep;
	 char Command[12];
	 sprintf (Command,"(run %3d)\n",rulestep);
	 PrintCLIPS ("wclips",Command);
	 SetCommandString(Command);
	 break;
      }
   }
}

/***************************************************
* DoWindowChoice: Process all menu options from
*    the WINDOW menu.
****************************************************/
VOID DoWindowChoice (hMain, wParam)
   HWND hMain;
   WORD wParam;
{  extern SCREEN WinDialog;
   switch (wParam)
   {  case IDM_WIN_FACTS:
      {
#if DEFTEMPLATE_CONSTRUCT
	 extern SCREEN WinFact;
	 HMENU hMenu = GetMenu(hMain);
	 if ( GetMenuState (hMenu, wParam, MF_BYCOMMAND ) == MF_CHECKED )
	 {  ShowWindow ( WinFact.hWnd, SW_HIDE );
	     CheckMenuItem (hMenu, wParam, MF_BYCOMMAND | MF_UNCHECKED );
	 }
	 else
	 {  int width =  GetSystemMetrics ( SM_CXSCREEN );
	    int height = GetSystemMetrics ( SM_CYSCREEN );
	    MoveWindow( WinFact.hWnd, (width * 0.66), 0, (width * 0.33), (height * 0.33 )-5, TRUE);
	    ShowWindow ( WinFact.hWnd, SW_SHOW );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_CHECKED );
	 }
#endif
	 break;
      }

      case IDM_WIN_AGENDA:
      {
#if DEFRULE_CONSTRUCT
	 extern SCREEN WinAgenda;
	 HMENU hMenu = GetMenu(hMain);
	 if ( GetMenuState (hMenu, wParam, MF_BYCOMMAND ) == MF_CHECKED )
	 {  ShowWindow ( WinAgenda.hWnd, SW_HIDE );
	    CheckMenuItem (hMenu, wParam, MF_BYCOMMAND | MF_UNCHECKED );
	 }
	 else
	 {  int width =  GetSystemMetrics ( SM_CXSCREEN );
	    int height = GetSystemMetrics ( SM_CYSCREEN );
	    MoveWindow( WinAgenda.hWnd, 0, (height * 0.66),(width * 0.4)-5, (height * 0.33), TRUE);
	    ShowWindow ( WinAgenda.hWnd, SW_SHOW );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_CHECKED );
	 }
#endif
	 break;
      }

      case IDM_WIN_INSTANCE:
      {
#if OBJECT_SYSTEM
	 extern SCREEN WinInst;
	 HMENU hMenu = GetMenu(hMain);
	 if ( GetMenuState (hMenu, wParam, MF_BYCOMMAND ) == MF_CHECKED )
	 {  ShowWindow ( WinInst.hWnd, SW_HIDE );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_UNCHECKED );
	 }
	 else
	 {  int width =  GetSystemMetrics ( SM_CXSCREEN );
	    int height = GetSystemMetrics ( SM_CYSCREEN );
	    MoveWindow( WinInst.hWnd, (width * 0.66), (height * 0.33),(width * 0.33), (height * 0.33)-5, TRUE);
	    ShowWindow ( WinInst.hWnd, SW_SHOW );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_CHECKED );
	 }
#endif
	 break;
      }

      case IDM_WIN_GLOBALS:
      {
#if DEFGLOBAL_CONSTRUCT
	 HMENU hMenu = GetMenu(hMain);
	 extern SCREEN WinGlobal;
	 if ( GetMenuState (hMenu, wParam, MF_BYCOMMAND ) == MF_CHECKED )
	 {  ShowWindow ( WinGlobal.hWnd, SW_HIDE );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_UNCHECKED );
	 }
	 else
	 {  int width =  GetSystemMetrics ( SM_CXSCREEN );
	    int height = GetSystemMetrics ( SM_CYSCREEN );
	    MoveWindow( WinGlobal.hWnd, (width * 0.66), (height * 0.66 ), (width * 0.33), (height * 0.33 ), TRUE);
	    ShowWindow ( WinGlobal.hWnd, SW_SHOW );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_CHECKED );
	 }
#endif
	 break;
      }

      case IDM_WIN_FOCUS:
      {
#if DEFRULE_CONSTRUCT
	 HMENU hMenu = GetMenu(hMain);
	 extern SCREEN WinFocus;
	 if ( GetMenuState (hMenu, wParam, MF_BYCOMMAND ) == MF_CHECKED )
	 {  ShowWindow ( WinFocus.hWnd, SW_HIDE );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_UNCHECKED );
	 }
	 else
	 {  int width =  GetSystemMetrics ( SM_CXSCREEN );
	    int height = GetSystemMetrics ( SM_CYSCREEN );
	    MoveWindow( WinFocus.hWnd, (width * 0.4), (height * 0.66 ), (width * 0.26)-5, (height * 0.33 ), TRUE);
	    ShowWindow ( WinFocus.hWnd, SW_SHOW );
	    CheckMenuItem ( hMenu, wParam, MF_BYCOMMAND | MF_CHECKED );
	 }
#endif
	 break;
      }

      case IDM_WIN_ALL:
      {  HMENU hMenu = GetMenu(hMain);
	 CheckMenuItem ( hMenu, IDM_WIN_GLOBALS,  MF_BYCOMMAND | MF_UNCHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_FACTS,    MF_BYCOMMAND | MF_UNCHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_INSTANCE, MF_BYCOMMAND | MF_UNCHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_AGENDA,   MF_BYCOMMAND | MF_UNCHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_FOCUS,    MF_BYCOMMAND | MF_UNCHECKED );
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_FACTS, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_AGENDA, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_INSTANCE, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_GLOBALS, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_FOCUS, NULL);
	 break;
      }

      case IDC_WIN_MAXIMIZE:
      {  extern SCREEN WinFact, WinFocus, WinGlobal, WinAgenda, WinInst;
	 HMENU hMenu = GetMenu(hMain);
	 int CMD = MF_BYCOMMAND;
	 int CHK = MF_CHECKED;

	 if( GetMenuState (hMenu, IDM_WIN_GLOBALS, CMD)==CHK)
	    ShowWindow ( WinGlobal.hWnd, SW_SHOW );

	 if( GetMenuState (hMenu, IDM_WIN_FACTS, CMD)==CHK)
	    ShowWindow ( WinFact.hWnd, SW_SHOW );

	 if( GetMenuState (hMenu, IDM_WIN_INSTANCE, CMD)==CHK)
	    ShowWindow ( WinInst.hWnd, SW_SHOW );

	 if( GetMenuState (hMenu, IDM_WIN_AGENDA, CMD)==CHK)
	    ShowWindow ( WinAgenda.hWnd, SW_SHOW );

	 if( GetMenuState (hMenu, IDM_WIN_FOCUS, CMD)==CHK)
	    ShowWindow ( WinFocus.hWnd, SW_SHOW );
	 break;
      }

      case IDC_WIN_MINIMIZE:
      {  extern SCREEN WinFact, WinFocus, WinGlobal, WinAgenda, WinInst;
	 ShowWindow ( WinFact.hWnd, SW_HIDE );
	 ShowWindow ( WinFocus.hWnd, SW_HIDE );
	 ShowWindow ( WinGlobal.hWnd, SW_HIDE );
	 ShowWindow ( WinAgenda.hWnd, SW_HIDE );
	 ShowWindow ( WinInst.hWnd, SW_HIDE );
	 break;
      }

      case IDM_WIN_NONE:
      {  HMENU hMenu = GetMenu(hMain);

	 CheckMenuItem ( hMenu, IDM_WIN_GLOBALS,  MF_BYCOMMAND | MF_CHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_FACTS,    MF_BYCOMMAND | MF_CHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_INSTANCE, MF_BYCOMMAND | MF_CHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_AGENDA,   MF_BYCOMMAND | MF_CHECKED );
	 CheckMenuItem ( hMenu, IDM_WIN_FOCUS,    MF_BYCOMMAND | MF_CHECKED );
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_FOCUS, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_FACTS, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_AGENDA, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_INSTANCE, NULL);
	 SendMessage (hMain, WM_COMMAND, IDM_WIN_GLOBALS, NULL);
	 break;
      }

      case IDM_WIN_CLEAR:
      {  ClearDialogWnd();
	 PrintPrompt ();
	 break;
      }
   }
   SetFocus(WinDialog.hWnd);
}

/***************************************************
* DoBrowseChoice: Process all menu options from
*    the BROWSE menu.
****************************************************/
VOID DoBrowseChoice ( hMain, wParam )
   HWND hMain;
   WORD wParam;

{  extern HANDLE hInst;
   switch ( wParam )
   {
#if DEFRULE_CONSTRUCT
      case IDM_BROWSE_RULE:
      {  FARPROC lpProc;

	 lpProc = MakeProcInstance(DefRuleManager, hInst);
	 DialogBox(hInst,"List_Manager", hMain, lpProc);
	 FreeProcInstance(lpProc);
	 break;
      }

      case IDM_BROWSE_AGENDA:
      {  FARPROC lpProc;
	 lpProc = MakeProcInstance(AgendaManager, hInst);
	 DialogBox(hInst,"Agenda_Manager", hMain, lpProc);
	 FreeProcInstance(lpProc);
	 break;
      }
#endif

#if DEFGLOBAL_CONSTRUCT
      case IDM_BROWSE_GLOBAL:
      {  FARPROC lpProc;

	 lpProc = MakeProcInstance(DefGlobalManager, hInst);
	 DialogBox(hInst,"List_Manager", hMain, lpProc);
	 FreeProcInstance(lpProc);
	 break;
      }
#endif

#if DEFTEMPLATE_CONSTRUCT
      case IDM_BROWSE_TEMPLATE:
      {  FARPROC lpProc;

	 lpProc = MakeProcInstance(DefTemplateManager, hInst);