home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / rxfolder.c < prev    next >
C/C++ Source or Header  |  1999-02-14  |  93KB  |  2,255 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: RXFOLDER.C                                                         |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 02.08.1994                  |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x PM                                                       |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |   Rexx-Script-Folder und Script-Settings                                  |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18. #pragma strings(readonly)
  19.  
  20. #define INCL_PM
  21. #include <os2.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include "main.h"
  25. #include "resids.h"
  26. #include "messages.h"
  27. #include "structs.h"
  28. #include "msgheader.h"
  29. #include "dialogids.h"
  30. #include "areaman\areaman.h"
  31. #include "utility.h"
  32. #include "setupdlg.h"
  33. #include "rxfolder.h"
  34. #include "controls\editwin.h"
  35. #include "util\fltutil.h"
  36. #include "rexxexec.h"
  37.  
  38. /*--------------------------------- Defines ---------------------------------*/
  39.  
  40. #ifndef CRA_SOURCE
  41. #define CRA_SOURCE  0x00004000L
  42. #endif
  43.  
  44. #define SCRIPTDRAGTYPE "FleetStreet Script," DRT_TEXT
  45. #define SCRIPTRMF      "<DRM_FLEET,DRF_SCRIPT>,(DRM_OS2FILE,DRM_DISCARD,DRM_PRINT)x(DRF_UNKNOWN)"
  46. #define EMPTYSCRIPTRMF "<DRM_FLEET,DRF_SCRIPT>,<DRM_DISCARD,DRF_UNKNOWN>"
  47.  
  48. #define NUM_PAGES_SCRIPT  2
  49. #define NUM_PAGES_RXSETTINGS  1
  50. #if 0
  51. #define RGB_GREY         0x00cccccc
  52. #define TAB_FONT         "8.Helv"
  53. #endif
  54.  
  55. #define MAX_NUM_QUICKACCESS    10
  56.  
  57. #define RXM_CHECKQUICKACCESS   (WM_USER+1)
  58.  
  59. /*---------------------------------- Typen ----------------------------------*/
  60.  
  61. typedef struct {
  62.              MINIRECORDCORE RecordCore;
  63.              HWND           hwndSettings;
  64.              HWND           hwndMonitor;
  65.              PRXSCRIPT      pScript;
  66.           } SCRIPTRECORD, *PSCRIPTRECORD;
  67.  
  68. typedef struct {
  69.              HWND          hwndFolderPopup;
  70.              HWND          hwndScriptPopup;
  71.              HWND          hwndSubMenu;
  72.              HPOINTER      hptrScript;
  73.              HPOINTER      hptrScriptFolder;
  74.              BOOL          bNotify;
  75.              HSWITCH       hSwitch;
  76.              PSCRIPTRECORD pPopupRecord;
  77.              BOOL          bForeground;
  78.           } SCRIPTFOLDERDATA, *PSCRIPTFOLDERDATA;
  79.  
  80. typedef struct {
  81.              USHORT    cb;
  82.              PRXSCRIPT pScript;
  83.           } OPENSCRIPT, *POPENSCRIPT;
  84.  
  85. typedef struct {
  86.            PRXSCRIPT    pScript;
  87.            HWND         notebook;
  88.            NBPAGE       PageTable[NUM_PAGES_SCRIPT];
  89.            BOOL         bNotify;
  90.         } SCRIPTBOOKDATA, *PSCRIPTBOOKDATA;
  91.  
  92. typedef struct {
  93.            HWND         notebook;
  94.            BOOL         bNotify;
  95.            NBPAGE       PageTable[NUM_PAGES_RXSETTINGS];
  96.         } RXFOLDERSETTINGSDATA, *PRXFOLDERSETTINGSDATA;
  97.  
  98. /*---------------------------- Globale Variablen ----------------------------*/
  99.  
  100. extern HMODULE hmodLang;
  101. extern HAB anchor;
  102. extern HWND hwndRxFolder, client;
  103. extern SCRIPTLIST scriptlist;
  104. extern REXXHOOKS rexxhooks;
  105. extern int tidRexxExec;
  106. extern PRXSCRIPT pExecScript;
  107. extern HWND hwndMonitor;
  108.  
  109. static PFNWP OldContainerProc;
  110.  
  111. /*--------------------------- Funktionsprototypen ---------------------------*/
  112.  
  113. /*----------------------- interne Funktionsprototypen -----------------------*/
  114. static MRESULT EXPENTRY NewScriptContainerProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  115. static int FillScriptFolder(HWND hwndCnr, HPOINTER hptr);
  116. static void ScriptSettingsClosed(HWND hwndCnr, ULONG ulScriptID);
  117. static void ScriptMonitorClosed(HWND hwndCnr, HWND hwndMonitor);
  118. static int OpenScriptSettings(HWND hwndCnr, PSCRIPTRECORD pRecord);
  119. static PSCRIPTRECORD AddNewScript(HWND hwndCnr, HPOINTER hptr);
  120. static int HaveScriptName(PVOID pScriptList, char *pchName);
  121. static int DeleteScript(HWND hwndCnr, PSCRIPTRECORD pRecord);
  122. static void CleanupScriptFolder(HWND hwndCnr);
  123. static void InitScriptDrag(HWND hwnd, PCNRDRAGINIT pInit);
  124. static int OpenScript(HWND hwndCnr, PSCRIPTRECORD pRecord);
  125. static int OpenScriptEdit(PSCRIPTRECORD pRecord);
  126. static void NewScriptName(HWND hwndCnr, ULONG ulScriptID);
  127. static MRESULT RxFolderDragOver(HWND hwndCnr, PCNRDRAGINFO pCnrDrag);
  128. static void RxFolderDrop(HWND hwndCnr, PCNRDRAGINFO pCnrDrag, PSCRIPTFOLDERDATA pData);
  129.  
  130. static MRESULT EXPENTRY ScriptSettingsProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  131. static void InsertScriptPages(HWND notebook, NBPAGE *Table);
  132. static MRESULT EXPENTRY RxGeneralProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  133. static MRESULT EXPENTRY RxMonitorProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  134.  
  135. static BOOL QuickAccessPossible(BOOL SelfQuickAccess);
  136. static void BroadcastToScripts(HWND hwndCnr, ULONG msg, MPARAM mp1, MPARAM mp2);
  137.  
  138. static MRESULT EXPENTRY RxFolderSettingsProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  139. static void InsertRxSettingsPages(HWND notebook, NBPAGE *Table);
  140. static MRESULT EXPENTRY RxHooksProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
  141. static SHORT EXPENTRY SortRexxFolder(PSCRIPTRECORD p1, PSCRIPTRECORD p2, PVOID pData);
  142.  
  143.  
  144. /*---------------------------------------------------------------------------*/
  145. /* Funktionsname: ScriptFolderProc                                           */
  146. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  147. /* Beschreibung: Window-Procedure des Script-Folders                         */
  148. /*                                                                           */
  149. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  150. /* Parameter: WinProc                                                        */
  151. /*                                                                           */
  152. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  153. /* Rückgabewerte: MRESULT                                                    */
  154. /*                                                                           */
  155. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  156. /* Sonstiges: -                                                              */
  157. /*                                                                           */
  158. /*---------------------------------------------------------------------------*/
  159.  
  160. MRESULT EXPENTRY ScriptFolderProc(HWND hwnd, ULONG message, MPARAM mp1, MPARAM mp2)
  161. {
  162.    extern WINDOWCOLORS windowcolors;
  163.    extern WINDOWFONTS  windowfonts;
  164.    extern GENERALOPT generaloptions;
  165.    extern HWND hwndhelp, client;
  166.    PSCRIPTFOLDERDATA pFolderData = (PSCRIPTFOLDERDATA) WinQueryWindowULong(hwnd, QWL_USER);
  167.    CNRINFO cnrinfo;
  168.  
  169.    switch (message)
  170.    {
  171.       case WM_INITDLG:
  172.          /* Instanzdaten anfordern */
  173.          pFolderData = malloc(sizeof(SCRIPTFOLDERDATA));
  174.          memset(pFolderData, 0, sizeof(SCRIPTFOLDERDATA));
  175.          WinSetWindowULong(hwnd, QWL_USER, (ULONG) pFolderData);
  176.  
  177.          OldContainerProc = WinSubclassWindow(WinWindowFromID(hwnd, IDD_RXFOLDER+1),
  178.                                               NewScriptContainerProc);
  179.  
  180.          /* Icon laden */
  181.          pFolderData->hptrScript = LoadIcon(IDIC_RXSCRIPT);
  182.          pFolderData->hptrScriptFolder = LoadIcon(IDIC_SCRIPTFOLDER);
  183.          SendMsg(hwnd, WM_SETICON, (MPARAM) pFolderData->hptrScriptFolder, NULL);
  184.  
  185.          /* Switch-Entry */
  186.          pFolderData->hSwitch=AddToWindowList(hwnd);
  187.  
  188.          /* Menues laden */
  189.          pFolderData->hwndScriptPopup = WinLoadMenu(HWND_OBJECT,
  190.                                                     hmodLang, IDM_RXF_POPUP);
  191.          pFolderData->hwndFolderPopup = WinLoadMenu(WinWindowFromID(hwnd, IDD_RXFOLDER+1),
  192.                                                     hmodLang, IDM_RXF_POPUP2);
  193.          /* Conditional Cascade style setzen */
  194.          if (pFolderData->hwndScriptPopup)
  195.          {
  196.             MENUITEM MenuItem;
  197.  
  198.             SendMsg(pFolderData->hwndScriptPopup, MM_QUERYITEM,
  199.                        MPFROM2SHORT(IDM_RXF_OPEN, TRUE),
  200.                        &MenuItem);
  201.             if (MenuItem.hwndSubMenu)
  202.             {
  203.                ULONG ulStyle;
  204.  
  205.                ulStyle = WinQueryWindowULong(MenuItem.hwndSubMenu, QWL_STYLE);
  206.                WinSetWindowULong(MenuItem.hwndSubMenu, QWL_STYLE,
  207.                                  ulStyle | MS_CONDITIONALCASCADE);
  208.                pFolderData->hwndSubMenu = MenuItem.hwndSubMenu;
  209.             }
  210.          }
  211.  
  212.          if (pFolderData->hwndFolderPopup)
  213.             ReplaceSysMenu(hwnd, pFolderData->hwndFolderPopup, 1);
  214.  
  215.          if (scriptlist.ulFlags & SCRIPTS_FOREGROUND)
  216.          {
  217.             pFolderData->bForeground = TRUE;
  218.             WinCheckMenuItem(pFolderData->hwndFolderPopup, IDM_RXF_FGROUND, TRUE);
  219.             WinSetOwner(hwnd, client);
  220.          }
  221.          else
  222.          {
  223.             pFolderData->bForeground = FALSE;
  224.             WinCheckMenuItem(pFolderData->hwndFolderPopup, IDM_RXF_FGROUND, FALSE);
  225.             WinSetOwner(hwnd, HWND_DESKTOP);
  226.          }
  227.  
  228.          /* Farben und Font setzen */
  229.          SetBackground(WinWindowFromID(hwnd, IDD_RXFOLDER+1), &windowcolors.scriptback);
  230.          SetForeground(WinWindowFromID(hwnd, IDD_RXFOLDER+1), &windowcolors.scriptfore);
  231.          SetFont(WinWindowFromID(hwnd, IDD_RXFOLDER+1), windowfonts.scriptfont);
  232.  
  233.          /* Sortierfunktion */
  234.          cnrinfo.cb = sizeof(cnrinfo);
  235.          cnrinfo.pSortRecord = (PVOID) SortRexxFolder;
  236.          WinSendDlgItemMsg(hwnd, IDD_RXFOLDER+1, CM_SETCNRINFO, &cnrinfo,
  237.                            MPFROMLONG(CMA_PSORTRECORD));
  238.  
  239.          /* Icons einfuegen */
  240.          FillScriptFolder(WinWindowFromID(hwnd, IDD_RXFOLDER+1),
  241.                           pFolderData->hptrScript);
  242.          RestoreWinPos(hwnd, &scriptlist.FolderPos, TRUE, TRUE);
  243.          pFolderData->bNotify = TRUE;
  244.          break;
  245.  
  246.       case WM_DESTROY:
  247.          /* Farben und Font */
  248.          CleanupScriptFolder(WinWindowFromID(hwnd, IDD_RXFOLDER+1));
  249.          RemoveFromWindowList(pFolderData->hSwitch);
  250.          QueryBackground(WinWindowFromID(hwnd, IDD_RXFOLDER+1), &windowcolors.scriptback);
  251.          QueryForeground(WinWindowFromID(hwnd, IDD_RXFOLDER+1), &windowcolors.scriptfore);
  252.          QueryFont(WinWindowFromID(hwnd, IDD_RXFOLDER+1), windowfonts.scriptfont);
  253.          if (pFolderData->hptrScript)
  254.             WinDestroyPointer(pFolderData->hptrScript);
  255.          if (pFolderData->hptrScriptFolder)
  256.             WinDestroyPointer(pFolderData->hptrScriptFolder);
  257.          if (pFolderData->hwndScriptPopup)
  258.             WinDestroyWindow(pFolderData->hwndScriptPopup);
  259.          if (pFolderData->hwndFolderPopup)
  260.             WinDestroyWindow(pFolderData->hwndFolderPopup);
  261.  
  262.          if (pFolderData->bForeground)
  263.          {
  264.             if (!(scriptlist.ulFlags & SCRIPTS_FOREGROUND))
  265.             {
  266.                scriptlist.ulFlags |= SCRIPTS_FOREGROUND;
  267.                scriptlist.bDirty = TRUE;
  268.             }
  269.          }
  270.          else
  271.          {
  272.             if (scriptlist.ulFlags & SCRIPTS_FOREGROUND)
  273.             {
  274.                scriptlist.ulFlags &= ~SCRIPTS_FOREGROUND;
  275.                scriptlist.bDirty = TRUE;
  276.             }
  277.          }
  278.          free(pFolderData);
  279.          break;
  280.  
  281.       case WM_CONTROL:
  282.          if (SHORT1FROMMP(mp1) == IDD_RXFOLDER+1)
  283.          {
  284.             switch(SHORT2FROMMP(mp1))
  285.             {
  286.                PCNREDITDATA pEdit;
  287.                PSCRIPTRECORD pRecord;
  288.                PNOTIFYRECORDENTER pEnter;
  289.  
  290.                case CN_ENTER:
  291.                   pEnter = (PNOTIFYRECORDENTER) mp2;
  292.                   if (pEnter->pRecord)
  293.                   {
  294.                      pRecord = (PSCRIPTRECORD) pEnter->pRecord;
  295.                      if (pRecord->pScript->pchPathName[0])
  296.                      {
  297.                         if (!tidRexxExec && !hwndMonitor)
  298.                            OpenScript(pEnter->hwndCnr, pRecord);
  299.                      }
  300.                      else
  301.                         OpenScriptSettings(WinWindowFromID(hwnd, IDD_RXFOLDER+1),
  302.                                            pRecord);
  303.                   }
  304.                   break;
  305.  
  306.                case CN_REALLOCPSZ:
  307.                   pEdit = (PCNREDITDATA) mp2;
  308.                   pRecord = (PSCRIPTRECORD) pEdit->pRecord;
  309.                   free (pRecord->pScript->pchScriptName);
  310.                   pRecord->pScript->pchScriptName = malloc(pEdit->cbText+1);
  311.                   pRecord->pScript->pchScriptName[0] = '\0';
  312.                   pRecord->RecordCore.pszIcon = pRecord->pScript->pchScriptName;
  313.                   pRecord->pScript->bDirty=TRUE;
  314.                   scriptlist.bDirty = TRUE;
  315.                   return (MRESULT) TRUE;
  316.  
  317.                case CN_ENDEDIT:
  318.                   /* Settings offen ? */
  319.                   pEdit = (PCNREDITDATA) mp2;
  320.                   if (((PSCRIPTRECORD)pEdit->pRecord)->hwndSettings)
  321.                      SendMsg(((PSCRIPTRECORD)pEdit->pRecord)->hwndSettings,
  322.                                 RXSET_NEWNAME,
  323.                                 MPFROMLONG(((PSCRIPTRECORD)pEdit->pRecord)->pScript->ulScriptID),
  324.                                 NULL);
  325.                   WinSendDlgItemMsg(hwnd, IDD_RXFOLDER+1, CM_SORTRECORD,
  326.                                     (MPARAM) SortRexxFolder, NULL);
  327.                   SendMsg(client, RXM_UPDATEMENU, NULL, NULL);
  328.                   break;
  329.  
  330.                case CN_INITDRAG:
  331.                   InitScriptDrag(hwnd, (PCNRDRAGINIT) mp2);
  332.                   break;
  333.  
  334.                case CN_CONTEXTMENU:
  335.                   pFolderData->pPopupRecord = (PSCRIPTRECORD) mp2;
  336.                   if (pFolderData->pPopupRecord)
  337.                   {
  338.                      /* Popup-Menue eines Scripts */
  339.                      RECTL rcl;
  340.                      POINTL ptl;
  341.                      QUERYRECORDRECT QRecord;
  342.  
  343.                      if (pFolderData->pPopupRecord->RecordCore.flRecordAttr & CRA_SELECTED)
  344.                      {
  345.                         PSCRIPTRECORD pRecord;
  346.                         HWND hwndCnr = WinWindowFromID(hwnd, IDD_RXFOLDER+1);
  347.                         BOOL bScriptOpen=FALSE, bScriptEmpty=FALSE;
  348.                         int i=0;
  349.  
  350.                         pRecord=NULL;
  351.                         while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
  352.                                                     pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  353.                                                     MPFROMLONG(CRA_SELECTED)))
  354.                         {
  355.                            if (pRecord->hwndMonitor)
  356.                               bScriptOpen=TRUE;
  357.                            else
  358.                               if (!pFolderData->pPopupRecord->pScript->pchPathName[0])
  359.                                  bScriptEmpty=TRUE;
  360.                            if (++i == 2)  /* verhindern, daß mehrere Scripte gestartet werden */
  361.                               bScriptEmpty=TRUE;
  362.                         }
  363.                         if (bScriptOpen)
  364.                         {
  365.                            WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_DELETE, FALSE);
  366.                            SendMsg(pFolderData->hwndSubMenu, MM_SETDEFAULTITEMID,
  367.                                       MPFROMSHORT(IDM_RXF_OPEN_SCR), NULL);
  368.                            WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SCR, TRUE);
  369.                            WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SET, FALSE);
  370.                         }
  371.                         else
  372.                         {
  373.                            WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_DELETE, TRUE);
  374.                            if (!bScriptEmpty)
  375.                            {
  376.                               SendMsg(pFolderData->hwndSubMenu, MM_SETDEFAULTITEMID,
  377.                                          MPFROMSHORT(IDM_RXF_OPEN_SCR), NULL);
  378.                               WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SET, FALSE);
  379.                               WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_EDIT, TRUE);
  380.                            }
  381.                            else
  382.                            {
  383.                               SendMsg(pFolderData->hwndSubMenu, MM_SETDEFAULTITEMID,
  384.                                          MPFROMSHORT(IDM_RXF_OPEN_SET), NULL);
  385.                               WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SCR, FALSE);
  386.                               WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_EDIT, FALSE);
  387.                            }
  388.                         }
  389.                      }
  390.                      else
  391.                      {
  392.                         /* nur ein Record */
  393.                         if (pFolderData->pPopupRecord->hwndMonitor)
  394.                         {
  395.                            WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_DELETE, FALSE);
  396.                            SendMsg(pFolderData->hwndSubMenu, MM_SETDEFAULTITEMID,
  397.                                       MPFROMSHORT(IDM_RXF_OPEN_SCR), NULL);
  398.                            WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SCR, TRUE);
  399.                            WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SET, FALSE);
  400.                         }
  401.                         else
  402.                         {
  403.                            WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_DELETE, TRUE);
  404.                            if (pFolderData->pPopupRecord->pScript->pchPathName[0])
  405.                            {
  406.                               SendMsg(pFolderData->hwndSubMenu, MM_SETDEFAULTITEMID,
  407.                                          MPFROMSHORT(IDM_RXF_OPEN_SCR), NULL);
  408.                               WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SET, FALSE);
  409.                               WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_EDIT, TRUE);
  410.                            }
  411.                            else
  412.                            {
  413.                               SendMsg(pFolderData->hwndSubMenu, MM_SETDEFAULTITEMID,
  414.                                          MPFROMSHORT(IDM_RXF_OPEN_SET), NULL);
  415.                               WinCheckMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_SCR, FALSE);
  416.                               WinEnableMenuItem(pFolderData->hwndScriptPopup, IDM_RXF_OPEN_EDIT, FALSE);
  417.                            }
  418.                         }
  419.                      }
  420.  
  421.                      QRecord.cb = sizeof(QUERYRECORDRECT);
  422.                      QRecord.pRecord = (PRECORDCORE) pFolderData->pPopupRecord;
  423.                      QRecord.fRightSplitWindow = FALSE;
  424.                      QRecord.fsExtent = CMA_ICON;
  425.                      WinSendDlgItemMsg(hwnd, IDD_RXFOLDER+1, CM_QUERYRECORDRECT,
  426.                                        &rcl, &QRecord);
  427.                      ptl.x = rcl.xRight;
  428.                      ptl.y = rcl.yBottom;
  429.                      WinMapWindowPoints(WinWindowFromID(hwnd, IDD_RXFOLDER+1),
  430.                                         HWND_DESKTOP, &ptl, 1);
  431.                      WinPopupMenu(HWND_DESKTOP, hwnd, pFolderData->hwndScriptPopup,
  432.                                   ptl.x, ptl.y, 0,
  433.                                   PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD |
  434.                                   PU_MOUSEBUTTON1);
  435.                   }
  436.                   else
  437.                   {
  438.                      /* Popup-Menue des Folders */
  439.                      POINTL ptl;
  440.  
  441.                      WinQueryPointerPos(HWND_DESKTOP, &ptl);
  442.                      WinPopupMenu(HWND_DESKTOP, hwnd, pFolderData->hwndFolderPopup,
  443.                                   ptl.x, ptl.y, 0,
  444.                                   PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD |
  445.                                   PU_MOUSEBUTTON1);
  446.                   }
  447.                   break;
  448.  
  449.                case CN_HELP:
  450.                   SendMsg(hwnd, WM_HELP, MPFROMSHORT(IDD_RXFOLDER+1), NULL);
  451.                   break;
  452.  
  453.                case CN_DROP:
  454.                   RxFolderDrop(WinWindowFromID(hwnd, IDD_RXFOLDER+1), (PCNRDRAGINFO) mp2, pFolderData);
  455.                   break;
  456.  
  457.                case CN_DRAGOVER:
  458.                   return RxFolderDragOver(WinWindowFromID(hwnd, IDD_RXFOLDER+1), (PCNRDRAGINFO) mp2);
  459.  
  460.                default:
  461.                   break;
  462.             }
  463.          }
  464.          break;
  465.  
  466.       case DM_DISCARDOBJECT:
  467.          if (mp1)
  468.          {
  469.             ULONG ulNum, i;
  470.             PDRAGITEM pItem;
  471.             PSCRIPTRECORD pRecord;
  472.             HWND hwndCnr= WinWindowFromID(hwnd, IDD_RXFOLDER+1);
  473.  
  474.             DrgAccessDraginfo((PDRAGINFO) mp1);
  475.             ulNum = DrgQueryDragitemCount((PDRAGINFO) mp1);
  476.             for (i=0; i<ulNum; i++)
  477.             {
  478.                pItem = DrgQueryDragitemPtr((PDRAGINFO) mp1, i);
  479.  
  480.                pRecord = NULL;
  481.                while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
  482.                                            pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  483.                                            MPFROMLONG(CRA_SOURCE)))
  484.                {
  485.                   if (pRecord->pScript->ulScriptID == pItem->ulItemID)
  486.                      break;
  487.                }
  488.                if (pRecord)
  489.                   DeleteScript(WinWindowFromID(hwnd, IDD_RXFOLDER+1), pRecord);
  490.             }
  491.             DrgFreeDraginfo((PDRAGINFO) mp1);
  492.          }
  493.          else
  494.             WinAlarm(HWND_DESKTOP, WA_NOTE);
  495.          return (MRESULT) DRR_SOURCE;
  496.  
  497.       case DM_PRINTOBJECT:
  498.          return (MRESULT) DRR_TARGET;
  499.  
  500.       case WM_MENUEND:
  501.          if ((HWND) mp2 == pFolderData->hwndScriptPopup ||
  502.              (HWND) mp2 == pFolderData->hwndFolderPopup)
  503.          {
  504.             /* Emphasis wegnehmen */
  505.             if (pFolderData->pPopupRecord)
  506.                RemoveSourceEmphasis(WinWindowFromID(hwnd, IDD_RXFOLDER+1));
  507.             else
  508.                WinSendDlgItemMsg(hwnd, IDD_RXFOLDER+1, CM_SETRECORDEMPHASIS, NULL, MPFROM2SHORT(FALSE, CRA_SOURCE));
  509.             if ( (HWND) mp2 == pFolderData->hwndFolderPopup)
  510.                ResetMenuStyle(pFolderData->hwndFolderPopup, hwnd);
  511.          }
  512.          break;
  513.  
  514.       case WM_INITMENU:
  515.          if ((HWND) mp2 == pFolderData->hwndFolderPopup)
  516.             pFolderData->pPopupRecord=NULL;
  517.          if ((HWND) mp2 == pFolderData->hwndScriptPopup ||
  518.              (HWND) mp2 == pFolderData->hwndFolderPopup)
  519.          {
  520.             /* Emphasis setzen */
  521.             if (pFolderData->pPopupRecord)
  522.             {
  523.                ApplySourceEmphasis(WinWindowFromID(hwnd, IDD_RXFOLDER+1), (PRECORDCORE) pFolderData->pPopupRecord);
  524.             }
  525.             else
  526.                WinSendDlgItemMsg(hwnd, IDD_RXFOLDER+1, CM_SETRECORDEMPHASIS,
  527.                                  NULL,
  528.                                  MPFROM2SHORT(TRUE, CRA_SOURCE));
  529.          }
  530.          break;
  531.  
  532.       case WM_ACTIVATE:
  533.          if (mp1)
  534.             WinAssociateHelpInstance(hwndhelp, hwnd);
  535.          else
  536.             WinAssociateHelpInstance(hwndhelp, NULLHANDLE);
  537.          break;
  538.  
  539.       case WM_CONTEXTMENU:
  540.       case WM_TEXTEDIT:
  541.          if (!SHORT1FROMMP(mp1) &&
  542.              WinQueryFocus(HWND_DESKTOP) == WinWindowFromID(hwnd, IDD_RXFOLDER+1))
  543.          {
  544.             WinSendDlgItemMsg(hwnd, IDD_RXFOLDER+1, message,
  545.                               mp1, mp2);
  546.          }
  547.          break;
  548.  
  549.       case WM_CLOSE:
  550.          WinPostMsg(client, RXF_CLOSE, NULL, NULL);
  551.          break;
  552.  
  553.       case WM_ADJUSTWINDOWPOS:
  554.          if (((PSWP)mp1)->fl & SWP_MINIMIZE)
  555.             WinShowWindow(WinWindowFromID(hwnd, IDD_RXFOLDER+1), FALSE);
  556.          if (((PSWP)mp1)->fl & (SWP_MAXIMIZE|SWP_RESTORE))
  557.             WinShowWindow(WinWindowFromID(hwnd, IDD_RXFOLDER+1), TRUE);
  558.          break;
  559.  
  560.       case WM_ADJUSTFRAMEPOS:
  561.          SizeToClient(anchor, (PSWP) mp1, hwnd, IDD_RXFOLDER+1);
  562.          break;
  563.  
  564.       case WM_WINDOWPOSCHANGED:
  565.          if (pFolderData && pFolderData->bNotify)
  566.             SaveWinPos(hwnd, (PSWP) mp1, &scriptlist.FolderPos, &scriptlist.bDirty);
  567.          break;
  568.  
  569.       case WM_COMMAND:
  570.          switch(SHORT1FROMMP(mp1))
  571.          {
  572.             PSCRIPTRECORD pNewScript;
  573.             PSCRIPTRECORD pRecord;
  574.             HWND hwndCnr;
  575.  
  576.             case IDM_RXF_OPEN_SET:
  577.                hwndCnr = WinWindowFromID(hwnd, IDD_RXFOLDER+1);
  578.                if (pFolderData->pPopupRecord->RecordCore.flRecordAttr & CRA_SELECTED)
  579.                {
  580.                   pRecord=NULL;
  581.                   while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  582.                                               MPFROMLONG(CRA_SELECTED)))
  583.                   {
  584.                      OpenScriptSettings(hwndCnr, pRecord);
  585.                   }
  586.                }
  587.                else
  588.                   OpenScriptSettings(hwndCnr, pFolderData->pPopupRecord);
  589.                return (MRESULT) FALSE;
  590.  
  591.             case IDM_RXF_OPEN_SCR:
  592.                if (pFolderData->pPopupRecord->pScript->pchPathName[0] &&
  593.                    !tidRexxExec && !hwndMonitor)
  594.                   OpenScript(WinWindowFromID(hwnd, IDD_RXFOLDER+1),
  595.                              pFolderData->pPopupRecord);
  596.                return (MRESULT) FALSE;
  597.  
  598.             case IDM_RXF_OPEN_EDIT:
  599.                if (pFolderData->pPopupRecord->pScript->pchPathName[0] &&
  600.                    !tidRexxExec && !hwndMonitor)
  601.                   OpenScriptEdit(pFolderData->pPopupRecord);
  602.                return (MRESULT) FALSE;
  603.  
  604.             case IDM_RXF_CREATE:
  605.                if (pNewScript = AddNewScript(WinWindowFromID(hwnd, IDD_RXFOLDER+1),
  606.                                              pFolderData->hptrScript))
  607.                   OpenScriptSettings(WinWindowFromID(hwnd, IDD_RXFOLDER+1), pNewScript);
  608.                return (MRESULT) FALSE;
  609.  
  610.             case IDM_RXF_DELETE:
  611.                if (generaloptions.safety & SAFETY_CHANGESETUP)
  612.                   if (MessageBox(hwnd, IDST_MSG_DELSCRIPT, IDST_TITLE_DELSCRIPT,
  613.                                  IDD_DELSCRIPT, MB_YESNO| MB_QUERY| MB_DEFBUTTON2) != MBID_YES)
  614.                      return (MRESULT) FALSE;
  615.                /* zaehlen */
  616.                hwndCnr = WinWindowFromID(hwnd, IDD_RXFOLDER+1);
  617.                if (pFolderData->pPopupRecord->RecordCore.flRecordAttr & CRA_SELECTED)
  618.                {
  619.                   ULONG ulNum=0;
  620.                   int i=0;
  621.                   PSCRIPTRECORD *ppRecordArray;
  622.  
  623.                   pRecord=NULL;
  624.                   while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  625.                                               MPFROMLONG(CRA_SELECTED)))
  626.                      ulNum++;
  627.  
  628.                   if (ulNum)
  629.                   {
  630.                      ppRecordArray = calloc(ulNum, sizeof(PSCRIPTRECORD));
  631.                      pRecord=NULL;
  632.                      while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  633.                                                  MPFROMLONG(CRA_SELECTED)))
  634.                         ppRecordArray[i++]=pRecord;
  635.  
  636.                      for (i=0; i< ulNum; i++)
  637.                         DeleteScript(hwndCnr, ppRecordArray[i]);
  638.                      free(ppRecordArray);
  639.                   }
  640.                }
  641.                else
  642.                   DeleteScript(hwndCnr, pFolderData->pPopupRecord);
  643.                return (MRESULT) FALSE;
  644.  
  645.             case IDM_RXF_FGROUND:
  646.                if (pFolderData->bForeground)
  647.                {
  648.                   pFolderData->bForeground = FALSE;
  649.                   WinCheckMenuItem(pFolderData->hwndFolderPopup, IDM_RXF_FGROUND, FALSE);
  650.                   WinSetOwner(hwnd, HWND_DESKTOP);
  651.                }
  652.                else
  653.                {
  654.                   pFolderData->bForeground = TRUE;
  655.                   WinCheckMenuItem(pFolderData->hwndFolderPopup, IDM_RXF_FGROUND, TRUE);
  656.                   WinSetOwner(hwnd, client);
  657.                }
  658.                return (MRESULT) FALSE;
  659.  
  660.             case IDM_RXF_SETTINGS:
  661.                WinDlgBox(HWND_DESKTOP, hwnd, RxFolderSettingsProc, hmodLang,
  662.                          IDD_RXFOLDERSETTINGS, NULL);
  663.                return (MRESULT) FALSE;
  664.  
  665.             case DID_CANCEL:
  666.                break;
  667.  
  668.             default:
  669.                return (MRESULT) FALSE;
  670.          }
  671.          return (MRESULT) FALSE;
  672.  
  673.       case RXSET_CLOSE:
  674.          ScriptSettingsClosed(WinWindowFromID(hwnd, IDD_RXFOLDER+1), (ULONG) mp1);
  675.          break;
  676.  
  677.       case RXSET_NEWNAME:
  678.          NewScriptName(WinWindowFromID(hwnd, IDD_RXFOLDER+1), (ULONG) mp1);
  679.          break;
  680.  
  681.       case RXM_CHECKQUICKACCESS:
  682.          BroadcastToScripts(WinWindowFromID(hwnd, IDD_RXFOLDER+1), message, mp1, mp2);
  683.          break;
  684.  
  685.       case REXXM_CLOSE:
  686.          ScriptMonitorClosed(WinWindowFromID(hwnd, IDD_RXFOLDER+1), (HWND) mp1);
  687.          break;
  688.  
  689.       default:
  690.          break;
  691.    }
  692.    return WinDefDlgProc(hwnd, message, mp1, mp2);
  693. }
  694.  
  695. static SHORT EXPENTRY SortRexxFolder(PSCRIPTRECORD p1, PSCRIPTRECORD p2, PVOID pData)
  696. {
  697.    pData = pData;
  698.  
  699.    return stricmp(p1->pScript->pchScriptName, p2->pScript->pchScriptName);
  700. }
  701.  
  702. /*---------------------------------------------------------------------------*/
  703. /* Funktionsname: NewScriptContainerProc                                     */
  704. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  705. /* Beschreibung: Neue Window-Prozedur des Script-Folder-Containers           */
  706. /*               wg. Container-Bug bei Drag-Over                             */
  707. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  708. /* Parameter: WinProc                                                        */
  709. /*                                                                           */
  710. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  711. /* Rückgabewerte: MRESULT                                                    */
  712. /*                                                                           */
  713. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  714. /* Sonstiges: -                                                              */
  715. /*                                                                           */
  716. /*---------------------------------------------------------------------------*/
  717.  
  718. static MRESULT EXPENTRY NewScriptContainerProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  719. {
  720.    switch(message)
  721.    {
  722.       case DM_DRAGOVER:
  723.          DrgAccessDraginfo(mp1);
  724.          break;
  725.  
  726.       case WM_BUTTON2DOWN:
  727.          return (MRESULT) FALSE;
  728.  
  729.       default:
  730.          break;
  731.    }
  732.    return OldContainerProc(parent, message, mp1, mp2);
  733. }
  734.  
  735. /*---------------------------------------------------------------------------*/
  736. /* Funktionsname: FillScriptFolder                                           */
  737. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  738. /* Beschreibung: Fuellt den Script-Folder mit allen Script-Objekten          */
  739. /*                                                                           */
  740. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  741. /* Parameter: hwndCnr: Container-Window-Handle                               */
  742. /*            hptr: Zu verwendendes Icon                                     */
  743. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  744. /* Rückgabewerte: 0   OK                                                     */
  745. /*                sonst Fehler                                               */
  746. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  747. /* Sonstiges: -                                                              */
  748. /*                                                                           */
  749. /*---------------------------------------------------------------------------*/
  750.  
  751. static int FillScriptFolder(HWND hwndCnr, HPOINTER hptr)
  752. {
  753.    RECORDINSERT RecordInsert;
  754.    PSCRIPTRECORD pRecord, pFirstRecord;
  755.    PRXSCRIPT pScript;
  756.  
  757.    if (scriptlist.ulNumScripts == 0)
  758.       return 0;
  759.  
  760.    /* Records vom Container anfordern */
  761.    pFirstRecord = SendMsg(hwndCnr, CM_ALLOCRECORD,
  762.                              MPFROMLONG(sizeof(SCRIPTRECORD) - sizeof(MINIRECORDCORE)),
  763.                              MPFROMLONG(scriptlist.ulNumScripts));
  764.    pRecord = pFirstRecord;
  765.  
  766.    pScript = scriptlist.pScripts;
  767.    while (pRecord)
  768.    {
  769.       pRecord->hwndSettings = NULLHANDLE;
  770.       pRecord->hwndMonitor  = NULLHANDLE;
  771.       pRecord->pScript      = pScript;
  772.  
  773.       pRecord->RecordCore.flRecordAttr = 0;
  774.       pRecord->RecordCore.pszIcon = pScript->pchScriptName;
  775.  
  776.       pRecord->RecordCore.hptrIcon = hptr;
  777.  
  778.       pRecord = (PSCRIPTRECORD) pRecord->RecordCore.preccNextRecord;
  779.       pScript = pScript->next;
  780.    }
  781.  
  782.    /* Records einfuegen */
  783.    RecordInsert.cb = sizeof(RECORDINSERT);
  784.    RecordInsert.pRecordOrder = (PRECORDCORE) CMA_END;
  785.    RecordInsert.pRecordParent = NULL;
  786.    RecordInsert.fInvalidateRecord = TRUE;
  787.    RecordInsert.zOrder = CMA_TOP;
  788.    RecordInsert.cRecordsInsert = scriptlist.ulNumScripts;
  789.  
  790.    SendMsg(hwndCnr, CM_INSERTRECORD, pFirstRecord, &RecordInsert);
  791.  
  792.    return 0;
  793. }
  794.  
  795. /*---------------------------------------------------------------------------*/
  796. /* Funktionsname: ScriptSettingsClosed                                       */
  797. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  798. /* Beschreibung: Settings-Notebook eines Scripts wurde geschlossen           */
  799. /*                                                                           */
  800. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  801. /* Parameter: hwndCnr: Container-Window-Handle                               */
  802. /*            ulScriptID: Script-ID des geschlossenen Scripts                */
  803. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  804. /* Rückgabewerte: -                                                          */
  805. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  806. /* Sonstiges: -                                                              */
  807. /*                                                                           */
  808. /*---------------------------------------------------------------------------*/
  809.  
  810. static void ScriptSettingsClosed(HWND hwndCnr, ULONG ulScriptID)
  811. {
  812.    PSCRIPTRECORD pRecord = NULL;
  813.  
  814.    while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORD, pRecord,
  815.                                MPFROM2SHORT(pRecord ? CMA_NEXT : CMA_FIRST,
  816.                                             CMA_ITEMORDER)))
  817.    {
  818.       if (pRecord->pScript->ulScriptID == ulScriptID)
  819.       {
  820.          if (pRecord->hwndSettings)
  821.             WinDestroyWindow(pRecord->hwndSettings);
  822.          pRecord->hwndSettings = NULLHANDLE;
  823.  
  824.          if (!pRecord->hwndMonitor)
  825.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord,
  826.                        MPFROM2SHORT(FALSE, CRA_INUSE));
  827.  
  828.          SendMsg(hwndCnr, CM_SORTRECORD, (MPARAM) SortRexxFolder, NULL);
  829.          SendMsg(client, RXM_UPDATEMENU, NULL, NULL);
  830.          break;
  831.       }
  832.    }
  833.  
  834.    return;
  835. }
  836.  
  837. /*---------------------------------------------------------------------------*/
  838. /* Funktionsname: ScriptMonitorClosed                                        */
  839. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  840. /* Beschreibung: Monitor eines Scripts wurde geschlossen                     */
  841. /*                                                                           */
  842. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  843. /* Parameter: hwndCnr: Container-Window-Handle                               */
  844. /*            hwndMonitor: Window-Handle des Monitors                        */
  845. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  846. /* Rückgabewerte: -                                                          */
  847. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  848. /* Sonstiges: -                                                              */
  849. /*                                                                           */
  850. /*---------------------------------------------------------------------------*/
  851.  
  852. static void ScriptMonitorClosed(HWND hwndCnr, HWND hwndMonitor)
  853. {
  854.    PSCRIPTRECORD pRecord = NULL;
  855.  
  856.    while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORD, pRecord,
  857.                                MPFROM2SHORT(pRecord ? CMA_NEXT : CMA_FIRST,
  858.                                             CMA_ITEMORDER)))
  859.    {
  860.       if (pRecord->hwndMonitor == hwndMonitor)
  861.       {
  862.          if (!pRecord->hwndSettings)
  863.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord,
  864.                        MPFROM2SHORT(FALSE, CRA_INUSE));
  865.          pRecord->hwndMonitor = NULLHANDLE;
  866.  
  867.          break;
  868.       }
  869.    }
  870.  
  871.    return;
  872. }
  873.  
  874. /*---------------------------------------------------------------------------*/
  875. /* Funktionsname: BroadcastToScripts                                         */
  876. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  877. /* Beschreibung: Leitet eine Message an alle offenen Scripts weiter          */
  878. /*                                                                           */
  879. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  880. /* Parameter: hwndCnr: Container-Window-Handle                               */
  881. /*            msg: Message                                                   */
  882. /*            mp1, mp2: Message-Parameter                                    */
  883. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  884. /* Rückgabewerte: -                                                          */
  885. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  886. /* Sonstiges: -                                                              */
  887. /*                                                                           */
  888. /*---------------------------------------------------------------------------*/
  889.  
  890. static void BroadcastToScripts(HWND hwndCnr, ULONG msg, MPARAM mp1, MPARAM mp2)
  891. {
  892.    PSCRIPTRECORD pRecord = NULL;
  893.  
  894.    while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORD, pRecord,
  895.                                MPFROM2SHORT(pRecord ? CMA_NEXT : CMA_FIRST,
  896.                                             CMA_ITEMORDER)))
  897.    {
  898.       if (pRecord->hwndSettings)
  899.          SendMsg(pRecord->hwndSettings, msg, mp1, mp2);
  900.    }
  901.  
  902.    return;
  903. }
  904.  
  905. /*---------------------------------------------------------------------------*/
  906. /* Funktionsname: NewScriptName                                              */
  907. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  908. /* Beschreibung: Script-Name hat sich geändert                               */
  909. /*                                                                           */
  910. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  911. /* Parameter: hwndCnr: Container-Window-Handle                               */
  912. /*            ulScriptID: Script-ID des  Scripts                             */
  913. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  914. /* Rückgabewerte: -                                                          */
  915. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  916. /* Sonstiges: -                                                              */
  917. /*                                                                           */
  918. /*---------------------------------------------------------------------------*/
  919.  
  920. static void NewScriptName(HWND hwndCnr, ULONG ulScriptID)
  921. {
  922.    PSCRIPTRECORD pRecord = NULL;
  923.  
  924.    while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORD, pRecord,
  925.                                MPFROM2SHORT(pRecord ? CMA_NEXT : CMA_FIRST,
  926.                                             CMA_ITEMORDER)))
  927.    {
  928.       if (pRecord->pScript->ulScriptID == ulScriptID)
  929.       {
  930.          if (pRecord->hwndSettings)
  931.             SendMsg(pRecord->hwndSettings, RXSET_NEWNAME, MPFROMLONG(ulScriptID), NULL);
  932.  
  933.          pRecord->RecordCore.pszIcon = pRecord->pScript->pchScriptName;
  934.          SendMsg(hwndCnr, CM_INVALIDATERECORD, &pRecord, MPFROM2SHORT(1, CMA_TEXTCHANGED));
  935.          SendMsg(hwndCnr, CM_SORTRECORD, (MPARAM) SortRexxFolder, NULL);
  936.  
  937.          break;
  938.       }
  939.    }
  940.  
  941.    return;
  942. }
  943.  
  944. /*---------------------------------------------------------------------------*/
  945. /* Funktionsname: OpenScriptSettings                                         */
  946. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  947. /* Beschreibung: Oeffnet Settings-Notebook eines Scripts                     */
  948. /*                                                                           */
  949. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  950. /* Parameter: hwndCnr: Container-Window-Handle                               */
  951. /*            pRecord: Record des Scripts                                    */
  952. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  953. /* Rückgabewerte: 0  OK                                                      */
  954. /*                -1 Fehler                                                  */
  955. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  956. /* Sonstiges: -                                                              */
  957. /*                                                                           */
  958. /*---------------------------------------------------------------------------*/
  959.  
  960. static int OpenScriptSettings(HWND hwndCnr, PSCRIPTRECORD pRecord)
  961. {
  962.    if (pRecord->hwndSettings)
  963.       SetFocus(pRecord->hwndSettings);
  964.    else
  965.    {
  966.       OPENSCRIPT OpenScript;
  967.  
  968.       /* in-use-emphasis setzen */
  969.       SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord,
  970.                  MPFROM2SHORT(TRUE, CRA_INUSE));
  971.  
  972.       OpenScript.cb = sizeof(OpenScript);
  973.       OpenScript.pScript = pRecord->pScript;
  974.  
  975.       pRecord->hwndSettings = WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, ScriptSettingsProc,
  976.                                          hmodLang, IDD_RXSETTINGS, &OpenScript);
  977.    }
  978.    return 0;
  979. }
  980.  
  981. /*---------------------------------------------------------------------------*/
  982. /* Funktionsname: AddNewScript                                               */
  983. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  984. /* Beschreibung: Erzeugt ein neues Script                                    */
  985. /*                                                                           */
  986. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  987. /* Parameter: hwndCnr: Container-Window-Handle                               */
  988. /*            hptr: Zu verwendendes Icon                                     */
  989. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  990. /* Rückgabewerte: NULL Fehler                                                */
  991. /*                sonst Zeiger auf neuen Record                              */
  992. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  993. /* Sonstiges: -                                                              */
  994. /*                                                                           */
  995. /*---------------------------------------------------------------------------*/
  996.  
  997. static PSCRIPTRECORD AddNewScript(HWND hwndCnr, HPOINTER hptr)
  998. {
  999.    PRXSCRIPT pScript, pNewScript, pLastScript=NULL;
  1000.    RECORDINSERT RecordInsert;
  1001.    PSCRIPTRECORD pNewRecord;
  1002.    ULONG ulNewID=0;
  1003.  
  1004.    /* Ende der Templatekette suchen */
  1005.    pLastScript = pScript = scriptlist.pScripts;
  1006.    while (pScript)
  1007.    {
  1008.       if (pScript->ulScriptID > ulNewID)
  1009.          ulNewID = pScript->ulScriptID;
  1010.       pLastScript = pScript;
  1011.       pScript = pScript->next;
  1012.    }
  1013.    ulNewID++;
  1014.  
  1015.    /* neues Skript erzeugen */
  1016.    pNewScript = malloc(sizeof(RXSCRIPT));
  1017.    memset(pNewScript, 0, sizeof(RXSCRIPT));
  1018.  
  1019.    /* Name */
  1020.    pNewScript->pchScriptName = malloc(100);
  1021.    CreateUniqueName(IDST_RX_NEWSCRIPT, &scriptlist, HaveScriptName, 100, pNewScript->pchScriptName);
  1022.  
  1023.    /* hinten anhaengen */
  1024.    pNewScript->next = NULL;
  1025.    pNewScript->prev = pLastScript;
  1026.    if (pLastScript)
  1027.       pLastScript->next = pNewScript;
  1028.    if (!scriptlist.pScripts)
  1029.       scriptlist.pScripts = pNewScript;
  1030.  
  1031.    scriptlist.ulNumScripts++;
  1032.    scriptlist.bDirty = TRUE;
  1033.  
  1034.    /* Default-Daten setzen */
  1035.    pNewScript->bDirty = TRUE;
  1036.    pNewScript->ulScriptID = ulNewID;
  1037.  
  1038.    /* Record vom Container anfordern */
  1039.    pNewRecord = SendMsg(hwndCnr, CM_ALLOCRECORD,
  1040.                            MPFROMLONG(sizeof(SCRIPTRECORD) - sizeof(MINIRECORDCORE)),
  1041.                            MPFROMLONG(1));
  1042.  
  1043.    if (pNewRecord)
  1044.    {
  1045.       pNewRecord->hwndSettings = NULLHANDLE;
  1046.       pNewRecord->hwndMonitor  = NULLHANDLE;
  1047.       pNewRecord->pScript      = pNewScript;
  1048.  
  1049.       pNewRecord->RecordCore.flRecordAttr = 0;
  1050.       pNewRecord->RecordCore.pszIcon = pNewScript->pchScriptName;
  1051.       pNewRecord->RecordCore.hptrIcon = hptr;
  1052.  
  1053.       /* Record einfuegen */
  1054.       RecordInsert.cb = sizeof(RECORDINSERT);
  1055.       RecordInsert.pRecordOrder = (PRECORDCORE) CMA_END;
  1056.       RecordInsert.pRecordParent = NULL;
  1057.       RecordInsert.fInvalidateRecord = TRUE;
  1058.       RecordInsert.zOrder = CMA_TOP;
  1059.       RecordInsert.cRecordsInsert = 1;
  1060.  
  1061.       SendMsg(hwndCnr, CM_INSERTRECORD, pNewRecord, &RecordInsert);
  1062.  
  1063.       return pNewRecord;
  1064.    }
  1065.    else
  1066.       return NULL;
  1067. }
  1068.  
  1069. static int HaveScriptName(PVOID pScriptList, char *pchName)
  1070. {
  1071.    PRXSCRIPT pScript = ((PSCRIPTLIST)pScriptList)->pScripts;
  1072.  
  1073.    while (pScript)
  1074.       if (!strcmp(pScript->pchScriptName, pchName))
  1075.          return TRUE;
  1076.       else
  1077.          pScript = pScript->next;
  1078.  
  1079.    return FALSE;
  1080. }
  1081.  
  1082. /*---------------------------------------------------------------------------*/
  1083. /* Funktionsname: DeleteScript                                               */
  1084. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1085. /* Beschreibung: Loescht ein Script-Objekt                                   */
  1086. /*                                                                           */
  1087. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1088. /* Parameter: hwndCnr: Container-Window-Handle                               */
  1089. /*            pRecord: Zeiger auf Record                                     */
  1090. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1091. /* Rückgabewerte: 0  OK                                                      */
  1092. /*                -1 Fehler                                                  */
  1093. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1094. /* Sonstiges: -                                                              */
  1095. /*                                                                           */
  1096. /*---------------------------------------------------------------------------*/
  1097.  
  1098. static int DeleteScript(HWND hwndCnr, PSCRIPTRECORD pRecord)
  1099. {
  1100.    if (pRecord->hwndMonitor)
  1101.       return -1;
  1102.  
  1103.    if (tidRexxExec && pRecord->pScript == pExecScript)
  1104.       return -1;
  1105.  
  1106.    /* offenes Notebook schliessen */
  1107.    if (pRecord->hwndSettings)
  1108.       WinDestroyWindow(pRecord->hwndSettings);
  1109.  
  1110.    /* Record im Container loeschen */
  1111.    SendMsg(hwndCnr, CM_REMOVERECORD, &pRecord, MPFROM2SHORT(1, CMA_INVALIDATE));
  1112.  
  1113.    /* Felder freigeben */
  1114.    if (pRecord->pScript->pchScriptName)
  1115.       free(pRecord->pScript->pchScriptName);
  1116.  
  1117.    /* Skript selbst loeschen */
  1118.    if (scriptlist.pScripts == pRecord->pScript)
  1119.       scriptlist.pScripts = scriptlist.pScripts->next;
  1120.  
  1121.    if (pRecord->pScript->next)
  1122.       pRecord->pScript->next->prev = pRecord->pScript->prev;
  1123.    if (pRecord->pScript->prev)
  1124.       pRecord->pScript->prev->next = pRecord->pScript->next;
  1125.    free(pRecord->pScript);
  1126.  
  1127.    scriptlist.ulNumScripts--;
  1128.    scriptlist.bDirty = TRUE;
  1129.  
  1130.    /* endgueltig aus Container entfernen */
  1131.    SendMsg(hwndCnr, CM_FREERECORD, &pRecord, MPFROMLONG(1));
  1132.  
  1133.    SendMsg(client, RXM_UPDATEMENU, NULL, NULL);
  1134.  
  1135.    return 0;
  1136. }
  1137.  
  1138. /*---------------------------------------------------------------------------*/
  1139. /* Funktionsname: CleanupScriptFolder                                        */
  1140. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1141. /* Beschreibung: Loescht alle Objekte aus dem Script-Folder                  */
  1142. /*                                                                           */
  1143. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1144. /* Parameter: hwndCnr: Container-Window-Handle                               */
  1145. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1146. /* Rückgabewerte: -                                                          */
  1147. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1148. /* Sonstiges: -                                                              */
  1149. /*                                                                           */
  1150. /*---------------------------------------------------------------------------*/
  1151.  
  1152. static void CleanupScriptFolder(HWND hwndCnr)
  1153. {
  1154.    PSCRIPTRECORD pRecord = NULL;
  1155.  
  1156.    /* alle offenen Templates schliessen */
  1157.    while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORD, pRecord,
  1158.                                MPFROM2SHORT(pRecord ? CMA_NEXT : CMA_FIRST,
  1159.                                             CMA_ITEMORDER)))
  1160.    {
  1161.       if (pRecord->hwndSettings)
  1162.          WinDestroyWindow(pRecord->hwndSettings);
  1163.    }
  1164.  
  1165.    /* Folder leeren */
  1166.    SendMsg(hwndCnr, CM_REMOVERECORD, NULL, MPFROM2SHORT(0, CMA_FREE));
  1167. }
  1168.  
  1169. /*---------------------------------------------------------------------------*/
  1170. /* Funktionsname: InitScriptDrag                                             */
  1171. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1172. /* Beschreibung: Behandelt Drag-Init f. Scripts                              */
  1173. /*                                                                           */
  1174. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1175. /* Parameter: hwnd: Dialog-Window-Handle                                     */
  1176. /*            pInit: Init-Struktur v. Container                              */
  1177. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1178. /* Rückgabewerte: -                                                          */
  1179. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1180. /* Sonstiges: -                                                              */
  1181. /*                                                                           */
  1182. /*---------------------------------------------------------------------------*/
  1183.  
  1184. static void InitScriptDrag(HWND hwnd, PCNRDRAGINIT pInit)
  1185. {
  1186.    PDRAGINFO pDraginfo;
  1187.    DRAGITEM dItem;
  1188.    DRAGIMAGE dImage[3];
  1189.    char *pchTemp, *pchTemp2;
  1190.    PSCRIPTRECORD pRecord;
  1191.    HWND hwndCnr = WinWindowFromID(hwnd, IDD_RXFOLDER+1);
  1192.    ULONG ulNum=0;
  1193.    int i=0;
  1194.  
  1195.    if (!pInit->pRecord)
  1196.       return;
  1197.  
  1198.    if (pInit->pRecord->flRecordAttr & CRA_SELECTED)
  1199.    {
  1200.       /* alle selektierten */
  1201.       pRecord = NULL;
  1202.       while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  1203.                                   MPFROMLONG(CRA_SELECTED)))
  1204.       {
  1205.          ulNum++;
  1206.          if (pRecord->hwndMonitor)
  1207.             return;
  1208.  
  1209.          if (tidRexxExec && pRecord->pScript == pExecScript)
  1210.             return;
  1211.       }
  1212.       pDraginfo = DrgAllocDraginfo(ulNum);
  1213.       pDraginfo->usOperation=DO_DEFAULT;
  1214.       pDraginfo->hwndSource=hwnd;
  1215.  
  1216.       pRecord = NULL;
  1217.       while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  1218.                                   MPFROMLONG(CRA_SELECTED)))
  1219.       {
  1220.          /* Source emphasis */
  1221.          SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(TRUE, CRA_SOURCE));
  1222.  
  1223.          /* Drag-Item vorbereiten*/
  1224.          dItem.hwndItem=hwnd;
  1225.          dItem.ulItemID= pRecord->pScript->ulScriptID;
  1226.          dItem.hstrType=DrgAddStrHandle(SCRIPTDRAGTYPE);
  1227.          pchTemp = strdup(pRecord->pScript->pchPathName);
  1228.          pchTemp2 = strrchr(pchTemp, '\\');
  1229.          if (pchTemp2)
  1230.          {
  1231.             dItem.hstrSourceName=DrgAddStrHandle(pchTemp2+1);
  1232.             dItem.hstrTargetName=DrgAddStrHandle(pchTemp2+1);
  1233.             pchTemp2++;
  1234.             *pchTemp2='\0';
  1235.             dItem.hstrContainerName=DrgAddStrHandle(pchTemp);
  1236.          }
  1237.          else
  1238.          {
  1239.             dItem.hstrSourceName=DrgAddStrHandle(pchTemp);
  1240.             dItem.hstrTargetName=DrgAddStrHandle(pchTemp);
  1241.             dItem.hstrContainerName = NULLHANDLE;
  1242.          }
  1243.          free(pchTemp);
  1244.  
  1245.          if (pRecord->pScript->pchPathName[0])
  1246.             dItem.hstrRMF=DrgAddStrHandle(SCRIPTRMF);
  1247.          else
  1248.             dItem.hstrRMF=DrgAddStrHandle(EMPTYSCRIPTRMF);
  1249.  
  1250.          if (pRecord->hwndSettings)
  1251.             dItem.fsControl= DC_OPEN;
  1252.          else
  1253.             dItem.fsControl= 0;
  1254.          dItem.fsSupportedOps=DO_COPYABLE;
  1255.          DrgSetDragitem(pDraginfo, &dItem, sizeof(dItem), i);
  1256.          i++;
  1257.       }
  1258.       for (i=0; i<ulNum && i<3; i++)
  1259.       {
  1260.          /* Drag-Image vorbereiten */
  1261.          dImage[i].cb=sizeof(DRAGIMAGE);
  1262.          dImage[i].hImage=pInit->pRecord->hptrIcon;
  1263.          dImage[i].fl=DRG_ICON;
  1264.          dImage[i].cxOffset=i*10;
  1265.          dImage[i].cyOffset=i*10;
  1266.       }
  1267.  
  1268.       DrgDrag(hwnd, pDraginfo, dImage, (ulNum<3)?ulNum:3, VK_ENDDRAG, NULL);
  1269.       DrgFreeDraginfo(pDraginfo);
  1270.  
  1271.       /* Source emphasis wegnehmen */
  1272.       RemoveSourceEmphasis(hwndCnr);
  1273.    }
  1274.    else
  1275.    {
  1276.       /* nur einer */
  1277.       pRecord = (PSCRIPTRECORD) pInit->pRecord;
  1278.  
  1279.       if (pRecord->hwndMonitor)
  1280.          return;
  1281.  
  1282.       if (tidRexxExec && pRecord->pScript == pExecScript)
  1283.          return;
  1284.  
  1285.       pDraginfo = DrgAllocDraginfo(1);
  1286.       pDraginfo->usOperation=DO_DEFAULT;
  1287.       pDraginfo->hwndSource=hwnd;
  1288.  
  1289.       /* Source emphasis */
  1290.       SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(TRUE, CRA_SOURCE));
  1291.  
  1292.       /* Drag-Item vorbereiten*/
  1293.       dItem.hwndItem=hwnd;
  1294.       dItem.ulItemID= pRecord->pScript->ulScriptID;
  1295.       dItem.hstrType=DrgAddStrHandle(SCRIPTDRAGTYPE);
  1296.       pchTemp = strdup(pRecord->pScript->pchPathName);
  1297.       pchTemp2 = strrchr(pchTemp, '\\');
  1298.       if (pchTemp2)
  1299.       {
  1300.          dItem.hstrSourceName=DrgAddStrHandle(pchTemp2+1);
  1301.          dItem.hstrTargetName=DrgAddStrHandle(pchTemp2+1);
  1302.          pchTemp2++;
  1303.          *pchTemp2='\0';
  1304.          dItem.hstrContainerName=DrgAddStrHandle(pchTemp);
  1305.       }
  1306.       else
  1307.       {
  1308.          dItem.hstrSourceName=DrgAddStrHandle(pchTemp);
  1309.          dItem.hstrTargetName=DrgAddStrHandle(pchTemp);
  1310.          dItem.hstrContainerName = NULLHANDLE;
  1311.       }
  1312.       free(pchTemp);
  1313.  
  1314.       if (pRecord->pScript->pchPathName[0])
  1315.          dItem.hstrRMF=DrgAddStrHandle(SCRIPTRMF);
  1316.       else
  1317.          dItem.hstrRMF=DrgAddStrHandle(EMPTYSCRIPTRMF);
  1318.  
  1319.       if (pRecord->hwndSettings)
  1320.          dItem.fsControl= DC_OPEN;
  1321.       else
  1322.          dItem.fsControl= 0;
  1323.       dItem.fsSupportedOps=DO_COPYABLE;
  1324.       DrgSetDragitem(pDraginfo, &dItem, sizeof(dItem), 0);
  1325.  
  1326.       /* Drag-Image vorbereiten */
  1327.       dImage[0].cb=sizeof(DRAGIMAGE);
  1328.       dImage[0].hImage=pInit->pRecord->hptrIcon;
  1329.       dImage[0].fl=DRG_ICON;
  1330.       dImage[0].cxOffset=i*10;
  1331.       dImage[0].cyOffset=i*10;
  1332.  
  1333.       DrgDrag(hwnd, pDraginfo, dImage, 1, VK_ENDDRAG, NULL);
  1334.       DrgFreeDraginfo(pDraginfo);
  1335.  
  1336.       /* Source emphasis wegnehmen */
  1337.       SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(FALSE, CRA_SOURCE));
  1338.    }
  1339.  
  1340.    return;
  1341. }
  1342.  
  1343. /*---------------------------------------------------------------------------*/
  1344. /* Funktionsname: RxFolderDragOver                                           */
  1345. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1346. /* Beschreibung: Behandelt Drag-Over des Rexx-Folders                        */
  1347. /*                                                                           */
  1348. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1349. /* Parameter: hwndCnr: Container-Window-Handle                               */
  1350. /*            pCnrDrag: Drag-Infos vom Container                             */
  1351. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1352. /* Rückgabewerte: MRESULT                                                    */
  1353. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1354. /* Sonstiges: -                                                              */
  1355. /*                                                                           */
  1356. /*---------------------------------------------------------------------------*/
  1357.  
  1358. static MRESULT RxFolderDragOver(HWND hwndCnr, PCNRDRAGINFO pCnrDrag)
  1359. {
  1360.    USHORT usDrop=DOR_NEVERDROP;
  1361.    USHORT usDefaultOp=DO_COPY;
  1362.    PID pid1, pid2;
  1363.    TID tid;
  1364.  
  1365.    hwndCnr = hwndCnr;
  1366.  
  1367.    if (!pCnrDrag->pRecord)
  1368.    {
  1369.       DrgAccessDraginfo(pCnrDrag->pDragInfo);
  1370.       if (pCnrDrag->pDragInfo->usOperation < DO_UNKNOWN)
  1371.       {
  1372.          WinQueryWindowProcess(hwndCnr, &pid1, &tid);
  1373.          WinQueryWindowProcess(pCnrDrag->pDragInfo->hwndSource, &pid2, &tid);
  1374.          if (pid1 != pid2)
  1375.          {
  1376.             PDRAGITEM pdItem;
  1377.             ULONG ulNumItems;
  1378.             ULONG i;
  1379.  
  1380.             ulNumItems = DrgQueryDragitemCount(pCnrDrag->pDragInfo);
  1381.  
  1382.             for (i=0; i<ulNumItems; i++)
  1383.             {
  1384.                pdItem = DrgQueryDragitemPtr(pCnrDrag->pDragInfo, i);
  1385.                if (DrgVerifyRMF(pdItem, "DRM_OS2FILE", NULL) &&
  1386.                    pdItem->hstrSourceName &&
  1387.                    !(pdItem->fsControl & (DC_CONTAINER | DC_PREPARE | DC_GROUP)))
  1388.                   usDrop = DOR_DROP;
  1389.             }
  1390.          }
  1391.          else
  1392.             usDrop = DOR_NODROPOP;
  1393.       }
  1394.       else
  1395.          usDrop = DOR_NODROPOP;
  1396.  
  1397.       DrgFreeDraginfo(pCnrDrag->pDragInfo);
  1398.    }
  1399.    else
  1400.       usDrop = DOR_NODROP;
  1401.  
  1402.    return MRFROM2SHORT(usDrop, usDefaultOp);
  1403. }
  1404.  
  1405. /*---------------------------------------------------------------------------*/
  1406. /* Funktionsname: RxFolderDrop                                               */
  1407. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1408. /* Beschreibung: Behandelt Drop      des Rexx-Folders                        */
  1409. /*                                                                           */
  1410. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1411. /* Parameter: hwndCnr: Container-Window-Handle                               */
  1412. /*            pCnrDrag: Drag-Infos vom Container                             */
  1413. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1414. /* Rückgabewerte: -                                                          */
  1415. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1416. /* Sonstiges: -                                                              */
  1417. /*                                                                           */
  1418. /*---------------------------------------------------------------------------*/
  1419.  
  1420. static void RxFolderDrop(HWND hwndCnr, PCNRDRAGINFO pCnrDrag, PSCRIPTFOLDERDATA pData)
  1421. {
  1422.    if (!pCnrDrag->pRecord)
  1423.    {
  1424.       DrgAccessDraginfo(pCnrDrag->pDragInfo);
  1425.       if (pCnrDrag->pDragInfo->usOperation < DO_UNKNOWN)
  1426.       {
  1427.          PDRAGITEM pdItem;
  1428.          ULONG ulNumItems;
  1429.          ULONG i;
  1430.  
  1431.          ulNumItems = DrgQueryDragitemCount(pCnrDrag->pDragInfo);
  1432.  
  1433.          for (i=0; i<ulNumItems; i++)
  1434.          {
  1435.             pdItem = DrgQueryDragitemPtr(pCnrDrag->pDragInfo, i);
  1436.             if (DrgVerifyRMF(pdItem, "DRM_OS2FILE", NULL) &&
  1437.                 pdItem->hstrSourceName &&
  1438.                 !(pdItem->fsControl & (DC_CONTAINER | DC_PREPARE | DC_GROUP)))
  1439.             {
  1440.                /* Script aus diesem Filenamen erzeugen */
  1441.                PSCRIPTRECORD pNewScript;
  1442.                char *pchTemp;
  1443.  
  1444.                pNewScript = AddNewScript(hwndCnr, pData->hptrScript);
  1445.                if (pNewScript)
  1446.                {
  1447.                   ULONG ulLen;
  1448.  
  1449.                   if (pdItem->hstrContainerName)
  1450.                      DrgQueryStrName(pdItem->hstrContainerName, LEN_PATHNAME+1, pNewScript->pScript->pchPathName);
  1451.  
  1452.                   pchTemp = pNewScript->pScript->pchPathName;
  1453.                   while(*pchTemp)
  1454.                      pchTemp++;
  1455.                   if (pdItem->hstrSourceName)
  1456.                      DrgQueryStrName(pdItem->hstrSourceName, LEN_PATHNAME+1, pchTemp);
  1457.  
  1458.                   if (pdItem->hstrTargetName)
  1459.                   {
  1460.                      ulLen= DrgQueryStrNameLen(pdItem->hstrTargetName);
  1461.                      free(pNewScript->pScript->pchScriptName);
  1462.                      pNewScript->pScript->pchScriptName = malloc(ulLen+1);
  1463.                      DrgQueryStrName(pdItem->hstrTargetName, ulLen+1, pNewScript->pScript->pchScriptName);
  1464.                      pNewScript->RecordCore.pszIcon = pNewScript->pScript->pchScriptName;
  1465.                      SendMsg(hwndCnr, CM_INVALIDATERECORD, &pNewScript,
  1466.                                 MPFROM2SHORT(1, CMA_TEXTCHANGED));
  1467.                   }
  1468.  
  1469.                   OpenScriptSettings(hwndCnr, pNewScript);
  1470.                }
  1471.             }
  1472.          }
  1473.       }
  1474.       DrgDeleteDraginfoStrHandles(pCnrDrag->pDragInfo);
  1475.       DrgFreeDraginfo(pCnrDrag->pDragInfo);
  1476.    }
  1477.  
  1478.    return;
  1479. }
  1480.  
  1481. /*---------------------------------------------------------------------------*/
  1482. /* Funktionsname: OpenScript                                                 */
  1483. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1484. /* Beschreibung: Laesst ein Script laufen                                    */
  1485. /*                                                                           */
  1486. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1487. /* Parameter: hwndCnr: Container-Window-Handle                               */
  1488. /*            pRecord: Zeiger auf Container-Record                           */
  1489. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1490. /* Rückgabewerte: 1 Fehler                                                   */
  1491. /*                0 OK                                                       */
  1492. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1493. /* Sonstiges: -                                                              */
  1494. /*                                                                           */
  1495. /*---------------------------------------------------------------------------*/
  1496.  
  1497. static int OpenScript(HWND hwndCnr, PSCRIPTRECORD pRecord)
  1498. {
  1499.    if (pRecord->hwndMonitor)
  1500.       SetFocus(pRecord->hwndMonitor);
  1501.    else
  1502.    {
  1503.       if (!(pRecord->pScript->ulFlags & REXXFLAG_NOMONITOR))
  1504.          SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord,
  1505.                     MPFROM2SHORT(TRUE, CRA_INUSE));
  1506.  
  1507.       if (StartRexxScript(pRecord->pScript->ulScriptID, &pRecord->hwndMonitor))
  1508.       {
  1509.          SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord,
  1510.                     MPFROM2SHORT(FALSE, CRA_INUSE));
  1511.          return 1;
  1512.       }
  1513.    }
  1514.  
  1515.    return 0;
  1516. }
  1517.  
  1518. static int OpenScriptEdit(PSCRIPTRECORD pRecord)
  1519. {
  1520.    HOBJECT hobj;
  1521.  
  1522.    hobj = WinQueryObject(pRecord->pScript->pchPathName);
  1523.    if (hobj)
  1524.    {
  1525.       WinSetObjectData(hobj, "OPEN=DEFAULT");
  1526.       return 0;
  1527.    }
  1528.    else
  1529.       return 1;
  1530. }
  1531.  
  1532. /*---------------------------------------------------------------------------*/
  1533. /* Funktionsname: ScriptSettingsProc                                         */
  1534. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1535. /* Beschreibung: Window-Prozedur f. Script-Settings                          */
  1536. /*                                                                           */
  1537. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1538. /* Parameter: WinProc                                                        */
  1539. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1540. /* Rückgabewerte: MRESULT                                                    */
  1541. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1542. /* Sonstiges: -                                                              */
  1543. /*                                                                           */
  1544. /*---------------------------------------------------------------------------*/
  1545.  
  1546. static MRESULT EXPENTRY ScriptSettingsProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  1547. {
  1548.    extern HWND hwndhelp;
  1549.    POPENSCRIPT pOpenScript;
  1550.    PSCRIPTBOOKDATA pBookData = (PSCRIPTBOOKDATA) WinQueryWindowULong(hwnd, QWL_USER);
  1551.    MRESULT resultbuf;
  1552.    ULONG ulPageID;
  1553.    HWND hwndPage;
  1554.  
  1555.    switch(msg)
  1556.    {
  1557.       case WM_INITDLG:
  1558.          /* Instanzdaten */
  1559.          pBookData = malloc(sizeof(SCRIPTBOOKDATA));
  1560.          memset(pBookData, 0, sizeof(SCRIPTBOOKDATA));
  1561.          WinSetWindowULong(hwnd, QWL_USER, (ULONG) pBookData);
  1562.  
  1563.          pBookData->notebook = WinWindowFromID(hwnd, IDD_RXSETTINGS+1);
  1564.  
  1565.          /* Leere Seiten einfuegen */
  1566.          InsertScriptPages(pBookData->notebook, pBookData->PageTable);
  1567.  
  1568.          pOpenScript = (POPENSCRIPT) mp2;
  1569.          pBookData->pScript = pOpenScript->pScript;
  1570.  
  1571.          /* Titel */
  1572.          WinSetWindowText(hwnd, pBookData->pScript->pchScriptName);
  1573.  
  1574.          /* erste Seite gleich anzeigen */
  1575.          LoadPage(pBookData->notebook, &(pBookData->PageTable[0]), pOpenScript);
  1576.  
  1577.          RestoreWinPos(hwnd, &pBookData->pScript->SettingsPos, TRUE, TRUE);
  1578.          pBookData->bNotify = TRUE;
  1579.          break;
  1580.  
  1581.       case WM_COMMAND:
  1582.          return (MRESULT) FALSE;
  1583.  
  1584.       case WM_DESTROY:
  1585.          free(pBookData);
  1586.          break;
  1587.  
  1588.       case WM_ADJUSTFRAMEPOS:
  1589.          SizeToClient(anchor, (PSWP) mp1, hwnd, IDD_RXSETTINGS+1);
  1590.          break;
  1591.  
  1592.       case WM_WINDOWPOSCHANGED:
  1593.          if (pBookData && pBookData->bNotify)
  1594.          {
  1595.             if (SaveWinPos(hwnd, (PSWP) mp1, &pBookData->pScript->SettingsPos, &pBookData->pScript->bDirty))
  1596.                scriptlist.bDirty = TRUE;
  1597.          }
  1598.          break;
  1599.  
  1600.       case WM_QUERYTRACKINFO:
  1601.          /* Default-Werte aus Original-Prozedur holen */
  1602.          resultbuf=WinDefDlgProc(hwnd, msg, mp1, mp2);
  1603.  
  1604.          /* Minimale Fenstergroesse einstellen */
  1605.          ((PTRACKINFO)mp2)->ptlMinTrackSize.x=490;
  1606.          ((PTRACKINFO)mp2)->ptlMinTrackSize.y=350;
  1607.  
  1608.          return resultbuf;
  1609.  
  1610.       case WM_CLOSE:
  1611.          WinPostMsg(hwndRxFolder, RXSET_CLOSE,
  1612.                     MPFROMLONG(pBookData->pScript->ulScriptID), NULL);
  1613.          break;
  1614.  
  1615.       case WM_ACTIVATE:
  1616.          if (mp1)
  1617.             WinAssociateHelpInstance(hwndhelp, hwnd);
  1618.          else
  1619.             WinAssociateHelpInstance(hwndhelp, NULLHANDLE);
  1620.          break;
  1621.  
  1622.       case WM_CONTROL:
  1623.          if (SHORT1FROMMP(mp1)==IDD_RXSETTINGS+1)
  1624.             if (SHORT2FROMMP(mp1)==BKN_PAGESELECTED)
  1625.             {
  1626.                int i=0;
  1627.                /* Seitenwechsel */
  1628.                /* neue Seite in Seiten-Tabelle suchen */
  1629.  
  1630.                while (i<NUM_PAGES_SCRIPT)
  1631.                {
  1632.                   if (pBookData->PageTable[i].PageID == ((PPAGESELECTNOTIFY)mp2)->ulPageIdNew)
  1633.                      break;
  1634.                   else
  1635.                      i++;
  1636.                }
  1637.  
  1638.                /* Seite ggf. Laden */
  1639.                if (i<NUM_PAGES_SCRIPT && pBookData->PageTable[i].hwndPage==NULLHANDLE)
  1640.                {
  1641.                   OPENSCRIPT OpenScript;
  1642.  
  1643.                   OpenScript.cb = sizeof(OpenScript);
  1644.                   OpenScript.pScript = pBookData->pScript;
  1645.                   LoadPage(pBookData->notebook, &(pBookData->PageTable[i]), &OpenScript);
  1646.                }
  1647.             }
  1648.          break;
  1649.  
  1650.       case RXSET_NEWNAME:
  1651.          WinSetWindowText(hwnd, pBookData->pScript->pchScriptName);
  1652.          ulPageID = (ULONG) SendMsg(pBookData->notebook, BKM_QUERYPAGEID,
  1653.                                        MPFROMLONG(0),
  1654.                                        MPFROM2SHORT(BKA_FIRST, BKA_MAJOR));
  1655.          if (ulPageID)
  1656.          {
  1657.             hwndPage = (HWND) SendMsg(pBookData->notebook, BKM_QUERYPAGEWINDOWHWND,
  1658.                                          MPFROMLONG(ulPageID), NULL);
  1659.             if (hwndPage)
  1660.                SendMsg(hwndPage, RXSET_NEWNAME, mp1, mp2);
  1661.          }
  1662.          break;
  1663.  
  1664.       case RXM_CHECKQUICKACCESS:
  1665.          ulPageID = (ULONG) SendMsg(pBookData->notebook, BKM_QUERYPAGEID,
  1666.                                        MPFROMLONG(0),
  1667.                                        MPFROM2SHORT(BKA_FIRST, BKA_MAJOR));
  1668.          if (ulPageID)
  1669.          {
  1670.             hwndPage = (HWND) SendMsg(pBookData->notebook, BKM_QUERYPAGEWINDOWHWND,
  1671.                                          MPFROMLONG(ulPageID), NULL);
  1672.             if (hwndPage)
  1673.                SendMsg(hwndPage, msg, mp1, mp2);
  1674.          }
  1675.          break;
  1676.  
  1677.       default:
  1678.          break;
  1679.    }
  1680.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  1681. }
  1682.  
  1683. /*---------------------------------------------------------------------------*/
  1684. /* Funktionsname: InsertScriptPages                                          */
  1685. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1686. /* Beschreibung: Fuegt alle Seiten in das Notebook ein                       */
  1687. /*                                                                           */
  1688. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1689. /* Parameter: notebook: Window-Handle des Notebooks                          */
  1690. /*            Table:    Seitentabelle                                        */
  1691. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1692. /* Rückgabewerte: -                                                          */
  1693. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1694. /* Sonstiges: -                                                              */
  1695. /*                                                                           */
  1696. /*---------------------------------------------------------------------------*/
  1697.  
  1698. static void InsertScriptPages(HWND notebook, NBPAGE *Table)
  1699. {
  1700.    SetNotebookParams(notebook, 120);
  1701.  
  1702.    /* Leere Seiten einfuegen, Tabelle fuellen */
  1703.    InsertEmptyPage(notebook, IDST_TAB_RXGENERAL, &(Table[0]));
  1704.    Table[0].resID=IDD_RXSET_GENERAL;
  1705.    Table[0].DlgProc=RxGeneralProc;
  1706.    InsertEmptyPage(notebook, IDST_TAB_RXMONITOR, &(Table[1]));
  1707.    Table[1].resID=IDD_RXSET_MONITOR;
  1708.    Table[1].DlgProc=RxMonitorProc;
  1709.  
  1710.    return;
  1711. }
  1712.  
  1713. /*---------------------------------------------------------------------------*/
  1714. /* Funktionsname: RxGeneralProc                                              */
  1715. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1716. /* Beschreibung: Window-Procedure f. General-Optionen                        */
  1717. /*                                                                           */
  1718. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1719. /* Parameter: WinProc                                                        */
  1720. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1721. /* Rückgabewerte: MRESULT                                                    */
  1722. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1723. /* Sonstiges: -                                                              */
  1724. /*                                                                           */
  1725. /*---------------------------------------------------------------------------*/
  1726.  
  1727. static MRESULT EXPENTRY RxGeneralProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  1728. {
  1729.    PRXSCRIPT pScript = (PRXSCRIPT) WinQueryWindowULong(hwnd, QWL_USER);
  1730.    ULONG ulLen;
  1731.    char *pchTemp;
  1732.    BOOL bTemp;
  1733.  
  1734.    switch(msg)
  1735.    {
  1736.       case WM_INITDLG:
  1737.          pScript = ((POPENSCRIPT)mp2)->pScript;
  1738.          WinSetWindowULong(hwnd, QWL_USER, (ULONG) pScript);
  1739.  
  1740.          /* Script-Name */
  1741.          WinSendDlgItemMsg(hwnd, IDD_RXSET_GENERAL+3, EM_SETTEXTLIMIT,
  1742.                            MPFROMSHORT(100), NULL);
  1743.          WinSetDlgItemText(hwnd, IDD_RXSET_GENERAL+3, pScript->pchScriptName);
  1744.  
  1745.          /* Script-File */
  1746.          WinSubclassWindow(WinWindowFromID(hwnd, IDD_RXSET_GENERAL+5),
  1747.                            FileEntryProc);
  1748.          WinSendDlgItemMsg(hwnd, IDD_RXSET_GENERAL+5, EM_SETTEXTLIMIT,
  1749.                            MPFROMSHORT(LEN_PATHNAME), NULL);
  1750.          WinSetDlgItemText(hwnd, IDD_RXSET_GENERAL+5, pScript->pchPathName);
  1751.  
  1752.          /* Quick-Access */
  1753.          if (pScript->ulFlags & REXXFLAG_QUICKACCESS)
  1754.             WinCheckButton(hwnd, IDD_RXSET_GENERAL+7, TRUE);
  1755.          else
  1756.             if (!QuickAccessPossible(FALSE))
  1757.                WinEnableControl(hwnd, IDD_RXSET_GENERAL+7, FALSE);
  1758.          break;
  1759.  
  1760.       case WM_DESTROY:
  1761.          /* Script-Name */
  1762.          ulLen = WinQueryDlgItemTextLength(hwnd, IDD_RXSET_GENERAL+3);
  1763.  
  1764.          pchTemp = malloc(ulLen+1);
  1765.          pchTemp[0]='\0';
  1766.  
  1767.          WinQueryDlgItemText(hwnd, IDD_RXSET_GENERAL+3, ulLen+1, pchTemp);
  1768.          if (strcmp(pchTemp, pScript->pchScriptName))
  1769.          {
  1770.             free(pScript->pchScriptName);
  1771.             pScript->pchScriptName=pchTemp;
  1772.             pScript->bDirty = TRUE;
  1773.             scriptlist.bDirty = TRUE;
  1774.          }
  1775.          else
  1776.             free(pchTemp);
  1777.  
  1778.          /* Pfadname */
  1779.          pchTemp = malloc(LEN_PATHNAME+1);
  1780.          WinQueryDlgItemText(hwnd, IDD_RXSET_GENERAL+5, LEN_PATHNAME+1, pchTemp);
  1781.          if (strcmp(pchTemp, pScript->pchPathName))
  1782.          {
  1783.             strcpy(pScript->pchPathName, pchTemp);
  1784.             pScript->bDirty = TRUE;
  1785.             scriptlist.bDirty = TRUE;
  1786.          }
  1787.          free(pchTemp);
  1788.  
  1789.          /* Quick-Access */
  1790.          bTemp = WinQueryButtonCheckstate(hwnd, IDD_RXSET_GENERAL+7);
  1791.          if (bTemp && !(pScript->ulFlags & REXXFLAG_QUICKACCESS))
  1792.          {
  1793.             pScript->ulFlags |= REXXFLAG_QUICKACCESS;
  1794.             pScript->bDirty = TRUE;
  1795.             scriptlist.bDirty = TRUE;
  1796.          }
  1797.          else
  1798.             if (!bTemp && (pScript->ulFlags & REXXFLAG_QUICKACCESS))
  1799.             {
  1800.                pScript->ulFlags &= ~REXXFLAG_QUICKACCESS;
  1801.                pScript->bDirty = TRUE;
  1802.                scriptlist.bDirty = TRUE;
  1803.             }
  1804.          break;
  1805.  
  1806.       case WM_CONTROL:
  1807.          if (SHORT1FROMMP(mp1) == IDD_RXSET_GENERAL+3)
  1808.          {
  1809.             if (SHORT2FROMMP(mp1) == EN_KILLFOCUS)
  1810.             {
  1811.                ulLen = WinQueryDlgItemTextLength(hwnd, IDD_RXSET_GENERAL+3);
  1812.  
  1813.                pchTemp = malloc(ulLen+1);
  1814.                pchTemp[0]='\0';
  1815.  
  1816.                WinQueryDlgItemText(hwnd, IDD_RXSET_GENERAL+3, ulLen+1, pchTemp);
  1817.                if (strcmp(pchTemp, pScript->pchScriptName))
  1818.                {
  1819.                   free(pScript->pchScriptName);
  1820.                   pScript->pchScriptName=pchTemp;
  1821.                   pScript->bDirty = TRUE;
  1822.                   scriptlist.bDirty = TRUE;
  1823.                   SendMsg(hwndRxFolder, RXSET_NEWNAME, MPFROMLONG(pScript->ulScriptID), NULL);
  1824.                }
  1825.                else
  1826.                   free(pchTemp);
  1827.  
  1828.             }
  1829.          }
  1830.          if (SHORT1FROMMP(mp1) == IDD_RXSET_GENERAL+7)
  1831.          {
  1832.             if (SHORT2FROMMP(mp1) == BN_CLICKED ||
  1833.                 SHORT2FROMMP(mp1) == BN_DBLCLICKED)
  1834.             {
  1835.                bTemp = WinQueryButtonCheckstate(hwnd, IDD_RXSET_GENERAL+7);
  1836.                if (bTemp)
  1837.                  pScript->ulFlags |= REXXFLAG_QUICKACCESS;
  1838.                else
  1839.                  pScript->ulFlags &= ~REXXFLAG_QUICKACCESS;
  1840.                pScript->bDirty = TRUE;
  1841.                scriptlist.bDirty = TRUE;
  1842.  
  1843.                bTemp = QuickAccessPossible(FALSE);
  1844.                if (hwndRxFolder)
  1845.                   SendMsg(hwndRxFolder, RXM_CHECKQUICKACCESS,
  1846.                              MPFROMLONG(bTemp), NULL);
  1847.  
  1848.             }
  1849.          }
  1850.          break;
  1851.  
  1852.       case WM_COMMAND:
  1853.          if (SHORT1FROMMP(mp1) == IDD_RXSET_GENERAL+6) /* Locate-Button */
  1854.          {
  1855.             char pathnamebuffer[LEN_PATHNAME+1];
  1856.  
  1857.             WinQueryDlgItemText(hwnd, IDD_RXSET_GENERAL+5,
  1858.                                 LEN_PATHNAME+1, pathnamebuffer);
  1859.             if (GetPathname(hwnd, pathnamebuffer)==DID_OK)
  1860.             {
  1861.                WinSetDlgItemText(hwnd, IDD_RXSET_GENERAL+5, pathnamebuffer);
  1862.             }
  1863.          }
  1864.          return (MRESULT) FALSE;
  1865.  
  1866.       case RXSET_NEWNAME:
  1867.          WinSetDlgItemText(hwnd, IDD_RXSET_GENERAL+3, pScript->pchScriptName);
  1868.          break;
  1869.  
  1870.       case RXM_CHECKQUICKACCESS:
  1871.          bTemp = WinQueryButtonCheckstate(hwnd, IDD_RXSET_GENERAL+7);
  1872.          if (!bTemp && !mp1)
  1873.             WinEnableControl(hwnd, IDD_RXSET_GENERAL+7, FALSE);
  1874.          else
  1875.             WinEnableControl(hwnd, IDD_RXSET_GENERAL+7, TRUE);
  1876.          break;
  1877.  
  1878.       default:
  1879.          break;
  1880.    }
  1881.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  1882. }
  1883.  
  1884. /*---------------------------------------------------------------------------*/
  1885. /* Funktionsname: RxMonitorProc                                              */
  1886. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1887. /* Beschreibung: Window-Procedure f. Monitor-Optionen                        */
  1888. /*                                                                           */
  1889. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1890. /* Parameter: WinProc                                                        */
  1891. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1892. /* Rückgabewerte: MRESULT                                                    */
  1893. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1894. /* Sonstiges: -                                                              */
  1895. /*                                                                           */
  1896. /*---------------------------------------------------------------------------*/
  1897.  
  1898. static MRESULT EXPENTRY RxMonitorProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  1899. {
  1900.    PRXSCRIPT pScript = (PRXSCRIPT) WinQueryWindowULong(hwnd, QWL_USER);
  1901.    BOOL bTemp;
  1902.  
  1903.    switch(msg)
  1904.    {
  1905.       case WM_INITDLG:
  1906.          pScript = ((POPENSCRIPT)mp2)->pScript;
  1907.          WinSetWindowULong(hwnd, QWL_USER, (ULONG) pScript);
  1908.  
  1909.          if (pScript->ulFlags & REXXFLAG_NOMONITOR)
  1910.          {
  1911.             WinCheckButton(hwnd, IDD_RXSET_MONITOR+1, FALSE);
  1912.             WinCheckButton(hwnd, IDD_RXSET_MONITOR+2, TRUE);
  1913.             WinEnableControl(hwnd, IDD_RXSET_MONITOR+3, FALSE);
  1914.          }
  1915.          else
  1916.          {
  1917.             WinCheckButton(hwnd, IDD_RXSET_MONITOR+1, TRUE);
  1918.             WinCheckButton(hwnd, IDD_RXSET_MONITOR+2, FALSE);
  1919.             WinEnableControl(hwnd, IDD_RXSET_MONITOR+3, TRUE);
  1920.          }
  1921.          if (pScript->ulFlags & REXXFLAG_AUTOCLOSE)
  1922.             WinCheckButton(hwnd, IDD_RXSET_MONITOR+3, TRUE);
  1923.          else
  1924.             WinCheckButton(hwnd, IDD_RXSET_MONITOR+3, FALSE);
  1925.          SetFocusControl(hwnd, IDD_RXSET_MONITOR+1);
  1926.          return (MRESULT) TRUE;
  1927.  
  1928.       case WM_DESTROY:
  1929.          bTemp = WinQueryButtonCheckstate(hwnd, IDD_RXSET_MONITOR+2);
  1930.          if (bTemp && !(pScript->ulFlags & REXXFLAG_NOMONITOR))
  1931.          {
  1932.             pScript->ulFlags |= REXXFLAG_NOMONITOR;
  1933.             pScript->bDirty = TRUE;
  1934.             scriptlist.bDirty = TRUE;
  1935.          }
  1936.          else
  1937.             if (!bTemp && (pScript->ulFlags & REXXFLAG_NOMONITOR))
  1938.             {
  1939.                pScript->ulFlags &= ~REXXFLAG_NOMONITOR;
  1940.                pScript->bDirty = TRUE;
  1941.                scriptlist.bDirty = TRUE;
  1942.             }
  1943.  
  1944.          bTemp = WinQueryButtonCheckstate(hwnd, IDD_RXSET_MONITOR+3);
  1945.          if (bTemp && !(pScript->ulFlags & REXXFLAG_AUTOCLOSE))
  1946.          {
  1947.             pScript->ulFlags |= REXXFLAG_AUTOCLOSE;
  1948.             pScript->bDirty = TRUE;
  1949.             scriptlist.bDirty = TRUE;
  1950.          }
  1951.          else
  1952.             if (!bTemp && (pScript->ulFlags & REXXFLAG_AUTOCLOSE))
  1953.             {
  1954.                pScript->ulFlags &= ~REXXFLAG_AUTOCLOSE;
  1955.                pScript->bDirty = TRUE;
  1956.                scriptlist.bDirty = TRUE;
  1957.             }
  1958.          break;
  1959.  
  1960.       case WM_CONTROL:
  1961.          if (SHORT1FROMMP(mp1) == IDD_RXSET_MONITOR+1 ||
  1962.              SHORT1FROMMP(mp1) == IDD_RXSET_MONITOR+2)
  1963.          {
  1964.             if (WinQueryButtonCheckstate(hwnd, IDD_RXSET_MONITOR+1))
  1965.                WinEnableControl(hwnd, IDD_RXSET_MONITOR+3, TRUE);
  1966.             else
  1967.                WinEnableControl(hwnd, IDD_RXSET_MONITOR+3, FALSE);
  1968.          }
  1969.          break;
  1970.  
  1971.       case WM_COMMAND:
  1972.          return (MRESULT) FALSE;
  1973.  
  1974.       default:
  1975.          break;
  1976.    }
  1977.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  1978. }
  1979.  
  1980. /*---------------------------------------------------------------------------*/
  1981. /* Funktionsname: QuickAccessPossible                                        */
  1982. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1983. /* Beschreibung: Prueft, ob ein weiteres Script mit Quick-Access versehen    */
  1984. /*               werden kann                                                 */
  1985. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1986. /* Parameter: SelfQuickAccess: Das Script selbst ist schon mit Quick-Access  */
  1987. /*                             versehen                                      */
  1988. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1989. /* Rückgabewerte: TRUE  Weiteres Quick-Access moeglich                       */
  1990. /*                FALSE Weiteres Quick-Access nicht moeglich                 */
  1991. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1992. /* Sonstiges: -                                                              */
  1993. /*                                                                           */
  1994. /*---------------------------------------------------------------------------*/
  1995.  
  1996. static BOOL QuickAccessPossible(BOOL SelfQuickAccess)
  1997. {
  1998.    int i=0;
  1999.    PRXSCRIPT pScript;
  2000.  
  2001.    if (SelfQuickAccess)
  2002.       return TRUE;
  2003.  
  2004.    pScript = scriptlist.pScripts;
  2005.  
  2006.    while(pScript)
  2007.    {
  2008.       if (pScript->ulFlags & REXXFLAG_QUICKACCESS)
  2009.          i++;
  2010.       pScript = pScript->next;
  2011.    }
  2012.  
  2013.    if (i >= MAX_NUM_QUICKACCESS)
  2014.       return FALSE;
  2015.    else
  2016.       return TRUE;
  2017. }
  2018.  
  2019. /*---------------------------------------------------------------------------*/
  2020. /* Funktionsname: UpdateRexxMenu                                             */
  2021. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2022. /* Beschreibung: Fuellt das Rexx-Menue neu mit den Quick-Access-Entraegen    */
  2023. /*                                                                           */
  2024. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2025. /* Parameter: hwndSubMenu: Window-Handle des Rexx-Menues                     */
  2026. /*                                                                           */
  2027. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2028. /* Rückgabewerte: -                                                          */
  2029. /*                                                                           */
  2030. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2031. /* Sonstiges: -                                                              */
  2032. /*                                                                           */
  2033. /*---------------------------------------------------------------------------*/
  2034.  
  2035. void UpdateRexxMenu(HWND hwndSubMenu)
  2036. {
  2037.    MENUITEM MenuItem;
  2038.    int iCount;
  2039.    PRXSCRIPT pScript = scriptlist.pScripts;
  2040.    PCHAR pchMenuText;
  2041.    PCHAR pchSrc, pchDst;
  2042.    char pchAccelPrefix[20]="";
  2043.  
  2044.    LoadString(IDST_RX_ACCEL, sizeof(pchAccelPrefix), pchAccelPrefix);
  2045.  
  2046.    /* Alle Eintraege loeschen */
  2047.    for (iCount = IDM_RXQUICK1; iCount <= IDM_RXQUICK10; iCount++)
  2048.       SendMsg(hwndSubMenu, MM_DELETEITEM, MPFROM2SHORT(iCount, FALSE), NULL);
  2049.  
  2050.    /* Eintraege fuellen */
  2051.    iCount = IDM_RXQUICK1;
  2052.    while (pScript && iCount <= IDM_RXQUICK10)
  2053.    {
  2054.       if (pScript->ulFlags & REXXFLAG_QUICKACCESS)
  2055.       {
  2056.          MenuItem.iPosition   = MIT_END;
  2057.          MenuItem.afStyle     = MIS_TEXT;
  2058.          MenuItem.afAttribute = 0;
  2059.          MenuItem.id          = iCount;
  2060.          MenuItem.hwndSubMenu = NULLHANDLE;
  2061.          MenuItem.hItem       = 0;
  2062.  
  2063.          /* Menue-Text vorbereiten */
  2064.          pchMenuText=malloc(strlen(pScript->pchScriptName)+20);
  2065.          pchDst=pchMenuText;
  2066.          pchSrc=pScript->pchScriptName;
  2067.          while(*pchSrc)
  2068.          {
  2069.             if (*pchSrc == '\r')
  2070.                *pchDst++= ' ';
  2071.             else
  2072.                if (*pchSrc != '\n')
  2073.                   *pchDst++ = *pchSrc;
  2074.             pchSrc++;
  2075.          }
  2076.          *pchDst=*pchSrc;
  2077.          strcat(pchMenuText, pchAccelPrefix);
  2078.          pchDst = strchr(pchMenuText, 0);
  2079.          if (iCount == IDM_RXQUICK10)
  2080.             strcpy(pchDst, "0");
  2081.          else
  2082.             _itoa(iCount-IDM_RXQUICK1+1, pchDst, 10);
  2083.  
  2084.          SendMsg(hwndSubMenu, MM_INSERTITEM, &MenuItem, pchMenuText);
  2085.          free(pchMenuText);
  2086.          iCount++;
  2087.       }
  2088.       pScript = pScript->next;
  2089.    }
  2090.  
  2091.    return;
  2092. }
  2093.  
  2094. static MRESULT EXPENTRY RxFolderSettingsProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  2095. {
  2096.    extern HWND hwndhelp;
  2097.    MRESULT resultbuf;
  2098.    PRXFOLDERSETTINGSDATA pData = (PRXFOLDERSETTINGSDATA) WinQueryWindowULong(hwnd, QWL_USER);
  2099.  
  2100.    switch(msg)
  2101.    {
  2102.       case WM_INITDLG:
  2103.          pData = calloc(1, sizeof(RXFOLDERSETTINGSDATA));
  2104.          WinSetWindowULong(hwnd, QWL_USER, (ULONG) pData);
  2105.  
  2106.          pData->notebook = WinWindowFromID(hwnd, IDD_RXFOLDERSETTINGS+1);
  2107.  
  2108.          /* Leere Seiten einfuegen */
  2109.          InsertRxSettingsPages(pData->notebook, pData->PageTable);
  2110.  
  2111.          /* erste Seite gleich anzeigen */
  2112.          LoadPage(pData->notebook, &(pData->PageTable[0]), NULL);
  2113.  
  2114.          RestoreWinPos(hwnd, &scriptlist.FolderSettingsPos, TRUE, TRUE);
  2115.          pData->bNotify=TRUE;
  2116.          break;
  2117.  
  2118.       case WM_ADJUSTFRAMEPOS:
  2119.          SizeToClient(anchor, (PSWP) mp1, hwnd, IDD_RXFOLDERSETTINGS+1);
  2120.          break;
  2121.  
  2122.       case WM_WINDOWPOSCHANGED:
  2123.          if (pData && pData->bNotify)
  2124.             SaveWinPos(hwnd, (PSWP) mp1, &scriptlist.FolderSettingsPos, &scriptlist.bDirty);
  2125.          break;
  2126.  
  2127.       case WM_QUERYTRACKINFO:
  2128.          /* Default-Werte aus Original-Prozedur holen */
  2129.          resultbuf=WinDefDlgProc(hwnd, msg, mp1, mp2);
  2130.  
  2131.          /* Minimale Fenstergroesse einstellen */
  2132.          ((PTRACKINFO)mp2)->ptlMinTrackSize.x=490;
  2133.          ((PTRACKINFO)mp2)->ptlMinTrackSize.y=350;
  2134.  
  2135.          return resultbuf;
  2136.  
  2137.       case WM_DESTROY:
  2138.          free(pData);
  2139.          break;
  2140.  
  2141.       case WM_COMMAND:
  2142.          return (MRESULT) FALSE;
  2143.  
  2144.       case WM_ACTIVATE:
  2145.          if (mp1)
  2146.             WinAssociateHelpInstance(hwndhelp, hwnd);
  2147.          else
  2148.             WinAssociateHelpInstance(hwndhelp, NULLHANDLE);
  2149.          break;
  2150.  
  2151.       default:
  2152.          break;
  2153.    }
  2154.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  2155. }
  2156.  
  2157. static void InsertRxSettingsPages(HWND notebook, NBPAGE *Table)
  2158. {
  2159.    SetNotebookParams(notebook, 120);
  2160.  
  2161.    /* Leere Seiten einfuegen, Tabelle fuellen */
  2162.    InsertEmptyPage(notebook, IDST_TAB_RXHOOKS, &(Table[0]));
  2163.    Table[0].resID=IDD_RXHOOKS;
  2164.    Table[0].DlgProc=RxHooksProc;
  2165.  
  2166.    return;
  2167. }
  2168.  
  2169. static MRESULT EXPENTRY RxHooksProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
  2170. {
  2171.    int i;
  2172.    SHORT sSel1=0, sSel2=0;
  2173.    SHORT sItem;
  2174.  
  2175.    switch(msg)
  2176.    {
  2177.       case WM_INITDLG:
  2178.          for (i=IDD_RXHOOKS+2; i<= IDD_RXHOOKS+4; i+=2)
  2179.          {
  2180.             HWND hwndList=WinWindowFromID(hwnd, i);
  2181.             PRXSCRIPT pScript = scriptlist.pScripts;
  2182.             SHORT sItem;
  2183.             char pchTemp[50];
  2184.  
  2185.             LoadString(IDST_RX_NOHOOK, 50, pchTemp);
  2186.             WinInsertLboxItem(hwndList, LIT_END, pchTemp);
  2187.  
  2188.             while (pScript)
  2189.             {
  2190.                sItem = WinInsertLboxItem(hwndList, LIT_END, pScript->pchScriptName);
  2191.  
  2192.                SendMsg(hwndList, LM_SETITEMHANDLE, MPFROMSHORT(sItem),
  2193.                           MPFROMLONG(pScript->ulScriptID));
  2194.  
  2195.                if (i == IDD_RXHOOKS+2 && pScript->ulScriptID == rexxhooks.ulExitID)
  2196.                   sSel1 = sItem;
  2197.                if (i == IDD_RXHOOKS+4 && pScript->ulScriptID == rexxhooks.ulPreSaveID)
  2198.                   sSel2 = sItem;
  2199.  
  2200.                pScript = pScript->next;
  2201.             }
  2202.          }
  2203.          WinSendDlgItemMsg(hwnd, IDD_RXHOOKS+2, LM_SELECTITEM, MPFROMSHORT(sSel1),
  2204.                            MPFROMSHORT(TRUE));
  2205.          WinSendDlgItemMsg(hwnd, IDD_RXHOOKS+4, LM_SELECTITEM, MPFROMSHORT(sSel2),
  2206.                            MPFROMSHORT(TRUE));
  2207.          break;
  2208.  
  2209.       case WM_COMMAND:
  2210.          return (MRESULT) FALSE;
  2211.  
  2212.       case WM_DESTROY:
  2213.          sItem = (USHORT)WinSendDlgItemMsg(hwnd, IDD_RXHOOKS+2, LM_QUERYSELECTION,
  2214.                                            MPFROMSHORT(LIT_FIRST), NULL);
  2215.          if (sItem >= 0)
  2216.          {
  2217.             ULONG ulID;
  2218.  
  2219.             ulID = (ULONG) WinSendDlgItemMsg(hwnd, IDD_RXHOOKS+2, LM_QUERYITEMHANDLE,
  2220.                                              MPFROMSHORT(sItem), NULL);
  2221.             if (ulID != rexxhooks.ulExitID)
  2222.             {
  2223.                extern DIRTYFLAGS dirtyflags;
  2224.  
  2225.                rexxhooks.ulExitID = ulID;
  2226.                dirtyflags.hooksdirty = TRUE;
  2227.             }
  2228.          }
  2229.          sItem = (USHORT)WinSendDlgItemMsg(hwnd, IDD_RXHOOKS+4, LM_QUERYSELECTION,
  2230.                                            MPFROMSHORT(LIT_FIRST), NULL);
  2231.          if (sItem >= 0)
  2232.          {
  2233.             ULONG ulID;
  2234.  
  2235.             ulID = (ULONG) WinSendDlgItemMsg(hwnd, IDD_RXHOOKS+4, LM_QUERYITEMHANDLE,
  2236.                                              MPFROMSHORT(sItem), NULL);
  2237.             if (ulID != rexxhooks.ulPreSaveID)
  2238.             {
  2239.                extern DIRTYFLAGS dirtyflags;
  2240.  
  2241.                rexxhooks.ulPreSaveID = ulID;
  2242.                dirtyflags.hooksdirty = TRUE;
  2243.             }
  2244.          }
  2245.          break;
  2246.  
  2247.       default:
  2248.          break;
  2249.    }
  2250.    return WinDefDlgProc(hwnd, msg, mp1, mp2);
  2251. }
  2252.  
  2253. /*-------------------------------- Modulende --------------------------------*/
  2254.  
  2255.