home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / areadlg.c next >
C/C++ Source or Header  |  1999-02-14  |  118KB  |  3,015 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: AREADLG.C                                                          |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von:  Michael Hohner           | Am:  14.07.93                   |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System:  OS/2 2.x PM und CSet/2                                           |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |    Area-Liste und Area-Setup                                              |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18.  
  19. #pragma strings(readonly)
  20.  
  21. #define INCL_GPI
  22. #define INCL_BASE
  23. #define INCL_WIN
  24. #include <os2.h>
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include <stdio.h>
  28.  
  29. #include "main.h"
  30. #include "resids.h"
  31. #include "messages.h"
  32. #include "structs.h"
  33. #include "areaman\areaman.h"
  34. #include "areaman\folderman.h"
  35. #include "msgheader.h"
  36. #include "dialogids.h"
  37. #include "setupdlg.h"
  38. #include "dialogs.h"
  39. #include "handlemsg\handlemsg.h"
  40. #include "utility.h"
  41. #include "msglist.h"
  42. #include "util\fltutil.h"
  43. #include "arealistsettings.h"
  44. #include "areasettings.h"
  45. #include "areascan.h"
  46. #include "areadlg.h"
  47. #include "areadrag.h"
  48. #include "folderdrag.h"
  49.  
  50. /*--------------------------------- Defines ---------------------------------*/
  51.  
  52. #ifndef CN_COLORCHANGED
  53. #define CN_COLORCHANGED 200
  54. #endif
  55.  
  56. #ifndef CCS_MINIICONS
  57. #define CCS_MINIICONS 0x800
  58. #endif
  59.  
  60. #define CONTAINERSPACE  3
  61.  
  62. typedef struct
  63. {
  64.    RECORDCORE RecordCore;
  65.    PSZ areadesc;     /* zeigt in AREADEF */
  66.    PSZ msgnotread;
  67.    PSZ totlmsgs;
  68.    AREADEFLIST *pAreaDef;
  69. } AREARECORD, *PAREARECORD;
  70.  
  71. typedef struct
  72. {
  73.    MINIRECORDCORE RecordCore;
  74.    PAREAFOLDER pAreaFolder;
  75. } FOLDERRECORD, *PFOLDERRECORD;
  76.  
  77. typedef struct
  78. {
  79.    HPOINTER    icon;             /* Icon f. Systemmenue */
  80.    HPOINTER    icnFolder;
  81.    HPOINTER    icnFolderOpen;
  82.    HPOINTER    icnFolderUnread;
  83.    HPOINTER    hptrPlus;
  84.    HPOINTER    hptrMinus;
  85.    POINTL      pointl;           /* Merker f. Mindestgroesse */
  86.    char        pchTAreaDesc[50]; /* Strings */
  87.    char        pchTUnread[50];
  88.    char        pchTTotal[50];
  89.    PAREARECORD selectRecord;    /* Record f. Popup-Menue   */
  90.    PFOLDERRECORD selectFolder;
  91.    HWND        hwndpopup;        /* Popup f. Areas          */
  92.    HWND        hwndpopupsmall;   /* Popup f. Gesamtliste    */
  93.    HWND        hwndFolderPopup;
  94.    HWND        hwndSmallFolderPopup;
  95.    ULONG       ulSort;           /* aktuelle Sortierung     */
  96.    BOOL        bKeyboard;        /* Flag f. Tastatur-Aktion */
  97.    BOOL        bAcceptChange;    /* Farbaenderung annehmen  */
  98.    BOOL        bDirty;           /* Inhalt muss upgedated werden */
  99.    PCHAR       *pchParamString;  /* Zeiger f. Auswahl       */
  100.    HSWITCH     hSwitch;          /* Eintrag in Fensterliste */
  101.    LONG        lDisable;         /* Disable-Counter         */
  102.    BOOL        bForeground;      /* Liste im Vordergrund    */
  103.    ULONG       ulIncludeTypes;
  104.    BOOL        bChange;
  105.    BOOL        bExtendedSel;
  106.    BOOL        bDirectEdit;
  107.    PFOLDERRECORD pOpenFolder;
  108. } AREALISTDATA, *PAREALISTDATA;
  109.  
  110. typedef struct
  111. {
  112.    USHORT       cb;
  113.    SQUISHPARAMS SquishParams;
  114. } SQUISHPARAMSPAR;
  115.  
  116.  
  117. #define TAB_FONT    "8.Helv"
  118. #define RGB_GREY    0x00cccccc
  119. #ifndef CRA_SOURCE
  120. #define CRA_SOURCE  0x00004000L    /* 2.1-spezifisch !!! */
  121. #endif
  122.  
  123. /*---------------------------- Globale Variablen ----------------------------*/
  124.  
  125. static PFNWP OldAEditProc;
  126. static PFNWP OldContainerProc;
  127.  
  128. extern HMODULE hmodLang;
  129. extern HAB anchor;
  130. extern AREALISTOPTIONS arealistoptions;
  131. extern HWND client;
  132. extern int CurrentStatus;
  133. extern char CurrentArea[LEN_AREATAG+1];
  134. extern FOLDERANCHOR FolderAnchor;
  135. extern AREALIST arealiste;
  136.  
  137. /*--------------------------- Funktionsprototypen ---------------------------*/
  138. static MRESULT EXPENTRY NewAContainerProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  139. static void InitAreaContainer(HWND hwndDlg, PAREALISTDATA pAreaListData);
  140. static void CleanupAreaList(HWND hwndContainer);
  141. static BOOL DrawItem(POWNERITEM Item);
  142. static SHORT _System SortOrig(PRECORDCORE p1, PRECORDCORE p2, PVOID AreaList);
  143. static SHORT _System SortName(PRECORDCORE p1, PRECORDCORE p2, PVOID AreaList);
  144. static SHORT _System SortNumber(PRECORDCORE p1, PRECORDCORE p2, PVOID AreaList);
  145. static void ResortAreaList(HWND hwndDlg, ULONG ulSortType);
  146. static MRESULT EXPENTRY NewAEditProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  147. static BOOL ScrollToRecord(HWND hwndCnr, PRECORDCORE pRecord);
  148. static PAREARECORD UpdateAreaList(HWND hwndCnr, PAREALISTDATA pAreaListData, char *pchCurrArea);
  149. static MRESULT EXPENTRY SquishParamsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  150. static void MarkSelectedAreas(PAREALIST arealist, ULONG ulFlags,
  151.                               PAREARECORD selectRecord, HWND hwndCnr);
  152.  
  153. static MRESULT DragOverAreaList(HWND hwndDlg, PCNRDRAGINFO pCnrDrag);
  154. static void DropAreaList(HWND hwndDlg, PCNRDRAGINFO pCnrDrag);
  155. static void UpdateAreaNums(PAREARECORD pRecord);
  156. static void InitAreaRecord(PAREARECORD pRecord, PAREADEFLIST pAreaDef, PAREALISTDATA pAreaListData);
  157.  
  158.  
  159. static void InitFolderContainer(HWND hwndDlg, PAREALISTDATA pAreaListData);
  160. static void InsertChildFolders(HWND hwndCnr, PFOLDERRECORD pParentRecord, PAREALISTDATA pAreaListData, LONG FolderToOpen);
  161. static PFOLDERRECORD InsertFolderRecord(HWND hwndCnr, PAREAFOLDER pFolder, PFOLDERRECORD pParent, PAREALISTDATA pAreaListData, LONG FolderToOpen);
  162. static void OpenFolderContext(HWND hwndDlg, PAREALISTDATA pAreaListData, PFOLDERRECORD pRecord);
  163. static PFOLDERRECORD CreateNewFolder(HWND hwndDlg, PAREALISTDATA pAreaListData);
  164. static void OpenFolder(HWND hwndDlg, PAREALISTDATA pAreaListData, PFOLDERRECORD pFolder);
  165. static void SetFolderIcons(HWND hwndDlg, PAREALISTDATA pAreaListData);
  166. static void InitAreaDrag(HWND hwndDlg, PAREALISTDATA pAreaListData, PCNRDRAGINIT pInit);
  167. static void FillDragItem(HWND hwndDlg, PAREARECORD pRecord, PDRAGITEM dItem);
  168. static BOOL IsBetweenContainers(HWND hwndDlg, SHORT x, SHORT y);
  169. static void SetPointer(void);
  170. static void TrackSeparator(HWND hwndDlg);
  171. static void RepositionContainers(HWND hwndDlg);
  172. static MRESULT DragOverFolder(HWND hwndDlg, PCNRDRAGINFO pInfo);
  173. static void DropOnFolder(PCNRDRAGINFO pInfo);
  174. static void DeleteFolder(HWND hwndDlg, PAREALISTDATA pAreaListData, PFOLDERRECORD pFolder);
  175. static void InitFolderDrag(HWND hwndDlg, PAREALISTDATA pAreaListData, PCNRDRAGINIT pInit);
  176. static SHORT EXPENTRY SortFolders(PRECORDCORE p1, PRECORDCORE p2, PVOID pStorage);
  177. static void UpdateScannedFolders(HWND hwndDlg, PAREALISTDATA pAreaListData);
  178. static BOOL FolderHasUnreadAreas(PAREAFOLDER pFolder);
  179.  
  180. /* Sortierfunktionen */
  181. typedef SHORT (* _System SortFuncType)(PRECORDCORE, PRECORDCORE, PVOID);
  182.  
  183. static SortFuncType SortFuncs[] =
  184. {
  185.    SortOrig,
  186.    SortName,
  187.    SortNumber
  188. };
  189.  
  190.  
  191. /*------------------------------ AreaListProc -------------------------------*/
  192. /* Dialog-Prozedur der Area-Liste                                            */
  193. /*---------------------------------------------------------------------------*/
  194. /* Parameter bei Initialisierung:                                            */
  195. /* NULL            Speicher selbst belegen je nach Platzbedarf, Zeiger zu-   */
  196. /*                 rueckgeben;                                               */
  197. /* !=NULL          Speicher ist schon belegt, Rueckgabewerte werden dorthin  */
  198. /*                 geschrieben;                                              */
  199. /*---------------------------------------------------------------------------*/
  200.  
  201. MRESULT EXPENTRY AreaListProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  202. {
  203.    extern WINDOWFONTS windowfonts;
  204.    extern DIRTYFLAGS dirtyflags;
  205.    extern GENERALOPT generaloptions;
  206.    extern BOOL DoingAreaScan;
  207.    extern BOOL DoingFind;
  208.    extern int tidAreaScan;
  209.    extern HWND hwndhelp;
  210.    extern HAB anchor;
  211.    extern BOOL bDoingWork;
  212.    extern DRIVEREMAP driveremap;
  213.    AREADEFLIST *zeiger;
  214.    RECORDINSERT recordInsert;
  215.    PAREARECORD pRecords, pfirstRecord;
  216.    MRESULT resultbuf=0;
  217.    ULONG ulAreaCount=0;
  218.    char *pchTemp;
  219.    AREAPAR AreaPar;
  220.    RECTL rectl, rectl2;
  221.    SWP swp;
  222.    SQUISHPARAMSPAR SqParamsPar;
  223.    RENUMBERPAR RenumberPar;
  224.    PAREALISTDATA pAreaListData;
  225.    HWND hwndCnr = WinWindowFromID(parent, IDD_AREALIST+1);
  226.  
  227.    pAreaListData=(PAREALISTDATA) WinQueryWindowULong(parent, QWL_USER);
  228.  
  229.    switch(message)
  230.    {
  231.       case WM_INITDLG:
  232.          /* Instanzdaten-Block anfordern */
  233.          pAreaListData=calloc(1, sizeof(AREALISTDATA));
  234.          WinSetWindowULong(parent, QWL_USER, (ULONG) pAreaListData);
  235.  
  236.          /* Instanzdaten vorbelegen */
  237.          pAreaListData->pchParamString = &((AREALISTPAR *)mp2)->pchString;
  238.          pAreaListData->ulIncludeTypes = ((AREALISTPAR *)mp2)->ulIncludeTypes;
  239.          pAreaListData->bExtendedSel   = ((AREALISTPAR *)mp2)->bExtendedSel;
  240.          pAreaListData->bChange        = ((AREALISTPAR *)mp2)->bChange;
  241.  
  242.          /* Titel-Override */
  243.          if (((AREALISTPAR *)mp2)->idTitle)
  244.          {
  245.             char pchTitle[100];
  246.  
  247.             LoadString(((AREALISTPAR *)mp2)->idTitle, sizeof(pchTitle), pchTitle);
  248.             WinSetWindowText(parent, pchTitle);
  249.          }
  250.  
  251.          if (pAreaListData->bChange)
  252.             pAreaListData->hSwitch=AddToWindowList(parent);
  253.  
  254.          pAreaListData->hwndpopup=WinLoadMenu(hwndCnr, hmodLang, IDM_AREAPOPUP);
  255.          pAreaListData->hwndpopupsmall=WinLoadMenu(HWND_DESKTOP, hmodLang, IDM_SAREAPOPUP);
  256.          if (pAreaListData->hwndpopupsmall)
  257.             ReplaceSysMenu(parent, pAreaListData->hwndpopupsmall, 1);
  258.  
  259.          pAreaListData->hwndFolderPopup=WinLoadMenu(HWND_DESKTOP, hmodLang, IDM_FOLDERPOPUP);
  260.          pAreaListData->hwndSmallFolderPopup=WinLoadMenu(HWND_DESKTOP, hmodLang, IDM_SFOLDERPOPUP);
  261.  
  262.          SetForeground(hwndCnr, &arealistoptions.lEchoAreaColor);
  263.          SetForeground(WinWindowFromID(parent,IDD_AREALIST+4), &arealistoptions.lFolderFore);
  264.          SetBackground(hwndCnr, &arealistoptions.lBackColor);
  265.          SetBackground(WinWindowFromID(parent,IDD_AREALIST+4), &arealistoptions.lFolderBack);
  266.          SetFont(hwndCnr, windowfonts.arealistfont);
  267.          SetFont(WinWindowFromID(parent,IDD_AREALIST+4), windowfonts.areafolderfont);
  268.  
  269.          pAreaListData->icon=LoadIcon(IDB_AREA);
  270.          SendMsg(parent, WM_SETICON, (MPARAM) pAreaListData->icon, (MPARAM) 0);
  271.  
  272.          pAreaListData->icnFolder=LoadIcon(IDIC_AREAFOLDER);
  273.          pAreaListData->icnFolderOpen=LoadIcon(IDIC_AREAFOLDER_OPEN);
  274.          pAreaListData->icnFolderUnread=LoadIcon(IDIC_AREAFOLDER_UNREAD);
  275.          pAreaListData->hptrPlus=LoadIcon(IDIC_PLUS);
  276.          pAreaListData->hptrMinus=LoadIcon(IDIC_MINUS);
  277.  
  278.          /* Folder-Container */
  279.          if (FolderAnchor.lSplit)
  280.             RepositionContainers(parent);
  281.          InitFolderContainer(parent, pAreaListData);
  282.  
  283.          if (pAreaListData->bChange)
  284.          {
  285.             if (arealistoptions.ulFlags & AREALISTFLAG_FOREGROUND)
  286.             {
  287.                pAreaListData->bForeground = TRUE;
  288.                WinCheckMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_FGROUND, TRUE);
  289.                WinSetOwner(parent, client);
  290.             }
  291.             else
  292.             {
  293.                pAreaListData->bForeground = FALSE;
  294.                WinCheckMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_FGROUND, FALSE);
  295.                WinSetOwner(parent, HWND_DESKTOP);
  296.             }
  297.          }
  298.  
  299.          OldContainerProc=WinSubclassWindow(hwndCnr,
  300.                                             NewAContainerProc);
  301.          WinSubclassWindow(WinWindowFromID(parent, IDD_AREALIST+4),
  302.                                             NewAContainerProc);
  303.          if (pAreaListData->bChange)
  304.             RestoreWinPos(parent, &arealistoptions.ListPos, TRUE, FALSE);
  305.          else
  306.             RestoreWinPos(parent, &arealistoptions.SelectPos, TRUE, FALSE);
  307.          pAreaListData->bAcceptChange=TRUE;
  308.          if (!pAreaListData->bChange)
  309.             WinEnableControl(parent, IDD_AREALIST+2, FALSE);
  310.          else
  311.             WinEnableControl(parent, IDD_AREALIST+2, !DoingAreaScan);
  312.  
  313.          /* minimale Fensterbreite berechnen */
  314.          WinQueryWindowPos(WinWindowFromID(parent, IDD_AREALIST+3), &swp);
  315.          pAreaListData->pointl.x=swp.x+swp.cx+10;
  316.          pAreaListData->pointl.y=160;
  317.  
  318.          InitAreaContainer(parent, pAreaListData);
  319.  
  320.          pAreaListData->selectRecord=UpdateAreaList(hwndCnr,
  321.                                                     pAreaListData,
  322.                                                     *pAreaListData->pchParamString);
  323.          free(*pAreaListData->pchParamString);
  324.          *pAreaListData->pchParamString=NULL;
  325.          if (pAreaListData->bChange)
  326.             pAreaListData->pchParamString=NULL;
  327.  
  328.          if (pAreaListData->selectRecord)
  329.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS,
  330.                     pAreaListData->selectRecord, MPFROM2SHORT(TRUE, CRA_CURSORED | CRA_SELECTED));
  331.          pfirstRecord=SendMsg(hwndCnr, CM_QUERYRECORD,
  332.                               NULL, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
  333.          if (pAreaListData->selectRecord != pfirstRecord)
  334.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS,
  335.                     pfirstRecord, MPFROM2SHORT(FALSE, CRA_SELECTED));
  336.          SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, MPFROM2SHORT(0, CMA_TEXTCHANGED));
  337.  
  338.          /* Ausgewaehlte Area anfahren */
  339.          if (pAreaListData->selectRecord)
  340.             ScrollToRecord(hwndCnr,
  341.                            (PRECORDCORE) pAreaListData->selectRecord);
  342.  
  343.          SetInitialAccel(parent);
  344.          WinShowWindow(parent, TRUE);
  345.          break;
  346.  
  347.       case WM_QUERYTRACKINFO:
  348.          WinQueryWindowPos(parent, &swp);
  349.          if (swp.fl & SWP_MINIMIZE)
  350.             break;
  351.  
  352.          /* Default-Werte aus Original-Prozedur holen */
  353.          resultbuf=WinDefDlgProc(parent,message,mp1,mp2);
  354.  
  355.          /* Minimale Fenstergroesse einstellen */
  356.          ((PTRACKINFO)mp2)->ptlMinTrackSize.x=pAreaListData->pointl.x;
  357.          ((PTRACKINFO)mp2)->ptlMinTrackSize.y=pAreaListData->pointl.y;
  358.          return resultbuf;
  359.  
  360.       case WM_ACTIVATE:
  361.          if (mp1)
  362.          {
  363.             WinAssociateHelpInstance(hwndhelp, parent);
  364.             if (pAreaListData->bDirty)
  365.             {
  366. #if 1
  367.                WinEnableWindowUpdate(WinWindowFromID(hwndCnr, CID_LEFTDVWND), FALSE);
  368. #endif
  369.                SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, NULL);
  370.                if (pAreaListData->ulSort == FOLDER_SORT_UNREAD)
  371.                   ResortAreaList(parent, pAreaListData->ulSort);
  372. #if 1
  373.                WinEnableWindowUpdate(WinWindowFromID(hwndCnr, CID_LEFTDVWND), TRUE);
  374. #endif
  375.  
  376.                pAreaListData->bDirty = FALSE;
  377.             }
  378.          }
  379.          else
  380.             WinAssociateHelpInstance(hwndhelp, NULLHANDLE);
  381.          break;
  382.  
  383.       case WM_CLOSE:
  384.          WinPostMsg(client, ALM_CLOSE, (MPARAM) parent, NULL);
  385.          break;
  386.  
  387.       case WM_DRAWITEM:
  388.          if (SHORT1FROMMP(mp1)==IDD_AREALIST+1)
  389.             return (MRESULT) DrawItem((POWNERITEM)mp2);
  390.          else
  391.             return (MRESULT) FALSE;
  392.  
  393.       case WM_ADJUSTWINDOWPOS:
  394.          if (((PSWP)mp1)->fl & SWP_MINIMIZE)
  395.          {
  396.             WinShowWindow(WinWindowFromID(parent, DID_OK), FALSE);
  397.             WinShowWindow(hwndCnr, FALSE);
  398.          }
  399.          if (((PSWP)mp1)->fl & (SWP_MAXIMIZE|SWP_RESTORE))
  400.          {
  401.             WinShowWindow(WinWindowFromID(parent, DID_OK), TRUE);
  402.             WinShowWindow(hwndCnr, TRUE);
  403.          }
  404.          break;
  405.  
  406.       case WM_ADJUSTFRAMEPOS:
  407.          if (((PSWP)mp1)->fl & (SWP_SIZE|SWP_MAXIMIZE|SWP_MINIMIZE|SWP_RESTORE))
  408.          {
  409.             SWP swp;
  410.  
  411.             rectl.xLeft=0;
  412.             rectl.xRight=((PSWP)mp1)->cx;
  413.             rectl.yBottom=0;
  414.             rectl.yTop=((PSWP)mp1)->cy;
  415.  
  416.             CalcClientRect(anchor, parent, &rectl);
  417.             WinQueryWindowPos(WinWindowFromID(parent, DID_OK), &swp);
  418.             rectl.yBottom += swp.y + swp.cy;
  419.             WinQueryWindowPos(WinWindowFromID(parent, IDD_AREALIST+4), &swp);
  420.             WinSetWindowPos(WinWindowFromID(parent, IDD_AREALIST+4),
  421.                             NULLHANDLE,
  422.                             rectl.xLeft, rectl.yBottom,
  423.                             swp.cx, rectl.yTop-rectl.yBottom,
  424.                             SWP_MOVE | SWP_SIZE);
  425.             WinSetWindowPos(hwndCnr,
  426.                             NULLHANDLE,
  427.                             rectl.xLeft+swp.cx+CONTAINERSPACE, rectl.yBottom,
  428.                             rectl.xRight-rectl.xLeft-swp.cx-CONTAINERSPACE, rectl.yTop-rectl.yBottom,
  429.                             SWP_MOVE | SWP_SIZE);
  430.          }
  431.          break;
  432.  
  433.       case WM_WINDOWPOSCHANGED:
  434.          if (pAreaListData && pAreaListData->bAcceptChange)
  435.          {
  436.             extern DIRTYFLAGS dirtyflags;
  437.  
  438.             if (pAreaListData->bChange)
  439.                SaveWinPos(parent, (PSWP) mp1, &arealistoptions.ListPos, &dirtyflags.alsettingsdirty);
  440.             else
  441.                SaveWinPos(parent, (PSWP) mp1, &arealistoptions.SelectPos, &dirtyflags.alsettingsdirty);
  442.          }
  443.          break;
  444.  
  445.       case WM_DESTROY:
  446.          RemoveFromWindowList(pAreaListData->hSwitch);
  447.          QueryFont(hwndCnr, windowfonts.arealistfont);
  448.          QueryFont(WinWindowFromID(parent,IDD_AREALIST+4), windowfonts.areafolderfont);
  449.          WinDestroyPointer(pAreaListData->icon);
  450.          WinDestroyPointer(pAreaListData->icnFolder);
  451.          WinDestroyPointer(pAreaListData->icnFolderOpen);
  452.          WinDestroyPointer(pAreaListData->icnFolderUnread);
  453.          WinDestroyPointer(pAreaListData->hptrPlus);
  454.          WinDestroyPointer(pAreaListData->hptrMinus);
  455.          WinDestroyWindow(pAreaListData->hwndpopup);
  456.          WinDestroyWindow(pAreaListData->hwndpopupsmall);
  457.          WinDestroyWindow(pAreaListData->hwndFolderPopup);
  458.          WinDestroyWindow(pAreaListData->hwndSmallFolderPopup);
  459.          CleanupAreaList(hwndCnr);
  460.  
  461.          if (pAreaListData->bForeground)
  462.          {
  463.             if (!(arealistoptions.ulFlags & AREALISTFLAG_FOREGROUND))
  464.             {
  465.                arealistoptions.ulFlags |= AREALISTFLAG_FOREGROUND;
  466.                dirtyflags.alsettingsdirty = TRUE;
  467.             }
  468.          }
  469.          else
  470.          {
  471.             if (arealistoptions.ulFlags & AREALISTFLAG_FOREGROUND)
  472.             {
  473.                arealistoptions.ulFlags &= ~AREALISTFLAG_FOREGROUND;
  474.                dirtyflags.alsettingsdirty = TRUE;
  475.             }
  476.          }
  477.          if (pAreaListData->pOpenFolder &&
  478.              FolderAnchor.LastFolder != pAreaListData->pOpenFolder->pAreaFolder->FolderID)
  479.          {
  480.             FolderAnchor.LastFolder = pAreaListData->pOpenFolder->pAreaFolder->FolderID;
  481.             FolderAnchor.bDirty = TRUE;
  482.          }
  483.          free(pAreaListData);
  484.          break;
  485.  
  486.       case WM_SYSCOMMAND:
  487.          if (SHORT1FROMMP(mp1) == SC_MINIMIZE &&
  488.              !pAreaListData->bChange)
  489.             return (MRESULT) FALSE;
  490.          else
  491.             break;
  492.  
  493.       case WM_COMMAND:
  494.          if (pAreaListData->lDisable > 0)
  495.             return (MRESULT) FALSE;
  496.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  497.          {
  498.             switch(SHORT1FROMMP(mp1))
  499.             {
  500.                case DID_OK:
  501.                   if (pAreaListData->bChange)
  502.                   {
  503.                      pRecords=SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
  504.                                       (MPARAM)CMA_FIRST, MPFROMSHORT(CRA_SELECTED));
  505.                      if (pRecords > (PAREARECORD)NULL)
  506.                      {
  507.                         SendMsg(client, ALM_SWITCHAREA, pRecords->pAreaDef->areadata.areatag, NULL);
  508.                         SetFocusControl(client, IDML_MAINEDIT);
  509.                         return (MRESULT) FALSE;
  510.                      }
  511.                      else
  512.                         return (MRESULT) FALSE;
  513.                   }
  514.                   else
  515.                   {
  516.                      pchTemp=NULL;
  517.                      ulAreaCount=0;
  518.  
  519.                      pRecords=(PAREARECORD)CMA_FIRST;
  520.                      while((pRecords=SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
  521.                                              pRecords, MPFROMSHORT(CRA_SELECTED)))>(PAREARECORD)NULL)
  522.                      {
  523.                         ulAreaCount++;
  524.                         pchTemp=realloc(pchTemp, ulAreaCount * (LEN_AREATAG+2));
  525.                         if (ulAreaCount==1)
  526.                            pchTemp[0]='\0';
  527.                         if (ulAreaCount>1)
  528.                            strcat(pchTemp, " ");
  529.                         strcat(pchTemp, pRecords->pAreaDef->areadata.areatag);
  530.                      }
  531.                      if (ulAreaCount)
  532.                         *pAreaListData->pchParamString=pchTemp;
  533.                      else
  534.                         *pAreaListData->pchParamString=NULL;
  535.                   }
  536.                   break;
  537.  
  538.                /* Scan-Button */
  539.                case IDD_AREALIST+2:
  540.                   WinEnableControl(parent, IDD_AREALIST+2, FALSE);
  541.                   MarkAllAreas(&arealiste, pAreaListData->pOpenFolder->pAreaFolder->FolderID, WORK_SCAN);
  542.                   if ((tidAreaScan=_beginthread(&ScanAreas, NULL, 16384, &arealiste))==-1)
  543.                   {
  544.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  545.                      WinEnableControl(parent, IDD_AREALIST+2, TRUE);
  546.                   }
  547.                   return (MRESULT) FALSE;
  548.  
  549.                case DID_CANCEL:
  550.                   WinPostMsg(client, ALM_CLOSE, (MPARAM) parent, NULL);
  551.                   break;
  552.  
  553.                default:
  554.                   break;
  555.             }
  556.          }
  557.          if (SHORT1FROMMP(mp2)==CMDSRC_MENU)
  558.          {
  559.             PWORKDATA pWorkData=NULL, pWorkData2=NULL;
  560.             PAREARECORD *ppChangeRecords=NULL;
  561.             ULONG ulNum;
  562.  
  563.             switch(SHORT1FROMMP(mp1))
  564.             {
  565.                case IDM_AP_SETTINGS:
  566.                   ulNum = CollectRecordPointers(hwndCnr, (PRECORDCORE**)&ppChangeRecords, (PRECORDCORE) pAreaListData->selectRecord);
  567.                   if (ulNum == 1)
  568.                   {
  569.                      if (MSG_LockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste))
  570.                      {
  571.                         MessageBox(parent, IDST_MSG_LOCKERROR, 0,
  572.                                    IDD_LOCKERROR, MB_OK | MB_ERROR);
  573.                         return (MRESULT) FALSE;
  574.                      }
  575.                      AreaPar.cb=sizeof(AREAPAR);
  576.                      AreaPar.pAreaDef=pAreaListData->selectRecord->pAreaDef;
  577.                      AreaPar.bMultiple=FALSE;
  578.                      if (WinDlgBox(HWND_DESKTOP,
  579.                                    parent,
  580.                                    &AreaSettingsProc,
  581.                                    hmodLang,
  582.                                    IDD_AREASETTINGS,
  583.                                    &AreaPar)!= DID_OK)
  584.                      {
  585.                         MSG_UnlockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste);
  586.                         break;
  587.                      }
  588.  
  589.                      MSG_UnlockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste);
  590.                      WinEnableWindowUpdate(hwndCnr, FALSE);
  591.                      SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, MPFROM2SHORT(0, CMA_TEXTCHANGED));
  592.                   }
  593.                   else
  594.                      if (ulNum > 1)
  595.                      {
  596.                         int i;
  597.                         AREADEFLIST AreaDef;
  598.  
  599.                         for (i=0; i<ulNum; i++)
  600.                            if (MSG_LockArea(ppChangeRecords[i]->pAreaDef->areadata.areatag, &arealiste))
  601.                            {
  602.                               int j;
  603.  
  604.                               MessageBox(parent, IDST_MSG_LOCKERROR, 0,
  605.                                          IDD_LOCKERROR, MB_OK | MB_ERROR);
  606.                               /* bisherige wieder unlocken */
  607.                               for (j=0; j<i; j++)
  608.                                  MSG_UnlockArea(ppChangeRecords[j]->pAreaDef->areadata.areatag, &arealiste);
  609.  
  610.                               free(ppChangeRecords);
  611.                               return (MRESULT) FALSE;
  612.                            }
  613.                         memcpy(&AreaDef, ppChangeRecords[0]->pAreaDef, sizeof(AreaDef));
  614.                         AreaPar.cb=sizeof(AREAPAR);
  615.                         AreaPar.pAreaDef=&AreaDef;
  616.                         AreaPar.bMultiple=TRUE;
  617.                         if (WinDlgBox(HWND_DESKTOP,
  618.                                       parent,
  619.                                       &AreaSettingsProc,
  620.                                       hmodLang,
  621.                                       IDD_AREASETTINGS,
  622.                                       &AreaPar)!= DID_OK)
  623.                         {
  624.                            for (i=0; i<ulNum; i++)
  625.                               MSG_UnlockArea(ppChangeRecords[i]->pAreaDef->areadata.areatag, &arealiste);
  626.                            free(ppChangeRecords);
  627.                            break;
  628.                         }
  629.  
  630.                         for (i=0; i<ulNum; i++)
  631.                         {
  632.                            /* Aenderungen uebernehmen */
  633.                            ppChangeRecords[i]->pAreaDef->areadata.ulTemplateID   = AreaDef.areadata.ulTemplateID;
  634.                            ppChangeRecords[i]->pAreaDef->areadata.ulDefAttrib    = AreaDef.areadata.ulDefAttrib;
  635.                            ppChangeRecords[i]->pAreaDef->areadata.ulAreaOpt      &= AREAOPT_FROMCFG;
  636.                            ppChangeRecords[i]->pAreaDef->areadata.ulAreaOpt      |= (AreaDef.areadata.ulAreaOpt & ~AREAOPT_FROMCFG);
  637.                            strcpy(ppChangeRecords[i]->pAreaDef->areadata.address,  AreaDef.areadata.address);
  638.                            strcpy(ppChangeRecords[i]->pAreaDef->areadata.username, AreaDef.areadata.username);
  639.                            ppChangeRecords[i]->pAreaDef->dirty=TRUE;
  640.  
  641.                            MSG_UnlockArea(ppChangeRecords[i]->pAreaDef->areadata.areatag, &arealiste);
  642.                         }
  643.                         arealiste.bDirty = TRUE;
  644.                         WinEnableWindowUpdate(hwndCnr, FALSE);
  645.                         SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, MPFROM2SHORT(0, CMA_TEXTCHANGED));
  646.                      }
  647.                   ResortAreaList(parent, pAreaListData->ulSort);
  648.                   SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, MPFROM2SHORT(0, CMA_TEXTCHANGED));
  649.                   WinEnableWindowUpdate(hwndCnr, TRUE);
  650.                   ScrollToRecord(hwndCnr, NULL);
  651.                   free(ppChangeRecords);
  652.                   break;
  653.  
  654.                case IDM_SAP_CREATE:
  655.                case IDM_AP_CREATE:
  656.                   AreaPar.cb=sizeof(AREAPAR);
  657.                   AreaPar.pAreaDef=malloc(sizeof(AREADEFLIST));
  658.                   AreaPar.bMultiple=FALSE;
  659.                   memset(AreaPar.pAreaDef, 0, sizeof(AREADEFLIST));
  660.                   /* Daten auffuellen */
  661.                   AreaPar.pAreaDef->areadata.areatype = AREATYPE_LOCAL;
  662.                   if (pAreaListData->pOpenFolder)
  663.                      AreaPar.pAreaDef->areadata.ulFolderID = pAreaListData->pOpenFolder->pAreaFolder->FolderID;
  664.  
  665.                   if (WinDlgBox(HWND_DESKTOP,
  666.                                 parent,
  667.                                 &AreaSettingsProc,
  668.                                 hmodLang,
  669.                                 IDD_AREASETTINGS,
  670.                                 &AreaPar) != DID_OK)
  671.                   {
  672.                      free(AreaPar.pAreaDef);
  673.                      break;
  674.                   }
  675.                   if (!AreaPar.pAreaDef->areadata.areatag[0])
  676.                   {
  677.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  678.                      free(AreaPar.pAreaDef);
  679.                      break;
  680.                   }
  681.                   {
  682.                      AREADEFLIST *pNewArea;
  683.  
  684.                      /* Area anhaengen */
  685.                      if (pNewArea = AM_AddArea(&arealiste, &AreaPar.pAreaDef->areadata, ADDAREA_TAIL | ADDAREA_MARKDIRTY))
  686.                      {
  687.                         pRecords=SendMsg(hwndCnr, CM_ALLOCRECORD,
  688.                                          MPFROMLONG(sizeof(AREARECORD)-sizeof(RECORDCORE)),
  689.                                          MPFROMLONG(1));
  690.  
  691.                         InitAreaRecord(pRecords, pNewArea, pAreaListData);
  692.  
  693.                         recordInsert.cb = sizeof(RECORDINSERT);
  694.                         recordInsert.pRecordParent= NULL;
  695.                         recordInsert.pRecordOrder = (PRECORDCORE) CMA_END;
  696.                         recordInsert.zOrder = CMA_TOP;
  697.                         recordInsert.cRecordsInsert = 1;
  698.                         recordInsert.fInvalidateRecord = TRUE;
  699.  
  700.                         SendMsg(hwndCnr, CM_INSERTRECORD, pRecords, &recordInsert);
  701.                         ResortAreaList(parent, pAreaListData->ulSort);
  702.                         arealiste.bDirty = TRUE;
  703.                      }
  704.                      free(AreaPar.pAreaDef);
  705.                   }
  706.                   break;
  707.  
  708.                case IDM_AP_DELETE:
  709.                   if (MSG_LockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste))
  710.                   {
  711.                      MessageBox(parent, IDST_MSG_LOCKERROR, 0,
  712.                                 IDD_LOCKERROR, MB_OK | MB_ERROR);
  713.                      return (MRESULT) FALSE;
  714.                   }
  715.                   if (generaloptions.safety & SAFETY_CHANGESETUP)
  716.                   {
  717.                      if (MessageBox(parent, IDST_MSG_DELAREA, IDST_AL_DELETE,
  718.                                     IDD_DELETEAREA, MB_YESNO | MB_ICONQUESTION |
  719.                                     MB_DEFBUTTON2)==MBID_NO)
  720.                      {
  721.                         MSG_UnlockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste);
  722.                         break;
  723.                      }
  724.                   }
  725.                   /* Area loeschen */
  726.                   AM_DeleteAreaDirect(&arealiste, pAreaListData->selectRecord->pAreaDef);
  727.  
  728.                   SendMsg(hwndCnr, CM_REMOVERECORD, &pAreaListData->selectRecord,
  729.                           MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
  730.                   arealiste.bDirty = TRUE;
  731.                   ScrollToRecord(hwndCnr, NULL);
  732.                   break;
  733.  
  734.                case IDM_AP_SQPARAMS:
  735.                   if (MSG_LockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste))
  736.                   {
  737.                      MessageBox(parent, IDST_MSG_LOCKERROR, 0,
  738.                                 IDD_LOCKERROR, MB_OK | MB_ERROR);
  739.                      return (MRESULT) FALSE;
  740.                   }
  741.                   SqParamsPar.cb=sizeof(SQUISHPARAMSPAR);
  742.                   if (!MSG_ReadSquishParams(&SqParamsPar.SquishParams,
  743.                                             &arealiste, pAreaListData->selectRecord->pAreaDef->areadata.areatag, &driveremap))
  744.                   {
  745.                      if (WinDlgBox(HWND_DESKTOP, parent, SquishParamsProc,
  746.                                    hmodLang, IDD_SQUISHBASEPARAM, &SqParamsPar)==DID_OK)
  747.                      {
  748.                         /* Parameter wieder speichern */
  749.                         if (MSG_WriteSquishParams(&SqParamsPar.SquishParams,
  750.                                                   &arealiste, pAreaListData->selectRecord->pAreaDef->areadata.areatag, &driveremap))
  751.                         {
  752.                            MessageBox(parent, IDST_MSG_ERRWRITESQPARAM, 0, IDD_ERRWRITESQPARAM,
  753.                                       MB_OK | MB_ERROR);
  754.                         }
  755.                      }
  756.                   }
  757.                   else
  758.                   {
  759.                      MessageBox(parent, IDST_MSG_ERRREADSQPARAM, 0, IDD_ERRREADSQPARAM,
  760.                                 MB_OK | MB_ERROR);
  761.                   }
  762.                   MSG_UnlockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste);
  763.                   break;
  764.  
  765.                case IDM_AP_RENUMBER:
  766.                   if (MSG_LockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste))
  767.                   {
  768.                      MessageBox(parent, IDST_MSG_LOCKERROR, 0,
  769.                                 IDD_LOCKERROR, MB_OK | MB_ERROR);
  770.                      return (MRESULT) FALSE;
  771.                   }
  772.                   RenumberPar.cb=sizeof(RENUMBERPAR);
  773.                   strcpy(RenumberPar.pchArea, pAreaListData->selectRecord->pAreaDef->areadata.areatag);
  774.                   RenumberPar.arealist=&arealiste;
  775.                   WinDlgBox(HWND_DESKTOP, parent, RenumberProc, hmodLang,
  776.                             IDD_RENUMBER, &RenumberPar);
  777.                   MSG_UnlockArea(pAreaListData->selectRecord->pAreaDef->areadata.areatag, &arealiste);
  778.                   break;
  779.  
  780.                case IDM_AP_SCAN:
  781.                   MarkSelectedAreas(&arealiste, WORK_SCAN,
  782.                                     pAreaListData->selectRecord,
  783.                                     hwndCnr);
  784.                   WinEnableControl(parent, IDD_AREALIST+2, FALSE);
  785.                   if ((tidAreaScan=_beginthread(&ScanAreas, NULL, 16384, &arealiste))==-1)
  786.                   {
  787.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  788.                      WinEnableControl(parent, IDD_AREALIST+2, TRUE);
  789.                   }
  790.                   break;
  791.  
  792.                case IDM_SAP_SETTINGS:
  793.                   {
  794.                      ALSETTINGSPARAM ALSettingsParam;
  795.  
  796.                      ALSettingsParam.cb=sizeof(ALSettingsParam);
  797.                      ALSettingsParam.pAreaListOptions=&arealistoptions;
  798. #if 0
  799.                      ALSettingsParam.bTagChanged = FALSE;
  800. #endif
  801.  
  802.                      WinDlgBox(HWND_DESKTOP, parent, AreaListSettingsProc,
  803.                                hmodLang, IDD_AREALISTSETTINGS, &ALSettingsParam);
  804.                      if (dirtyflags.alsettingsdirty)
  805.                      {
  806.                         WinEnableWindowUpdate(hwndCnr, FALSE);
  807.                         pAreaListData->bAcceptChange=FALSE;
  808.                         SetForeground(hwndCnr, &arealistoptions.lEchoAreaColor);
  809.                         SetBackground(hwndCnr, &arealistoptions.lBackColor);
  810.                         pAreaListData->bAcceptChange=TRUE;
  811.  
  812.                         UpdateAreaList(hwndCnr, pAreaListData, NULL);
  813.                         ResortAreaList(parent, pAreaListData->ulSort);
  814.                         SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, NULL);
  815.  
  816.                         WinEnableWindowUpdate(hwndCnr, TRUE);
  817.                      }
  818.                   }
  819.                   break;
  820.  
  821.                case IDM_SAP_SCANALL:
  822.                   WinEnableControl(parent, IDD_AREALIST+2, FALSE);
  823.                   MarkAllAreas(&arealiste, FOLDERID_ALL, WORK_SCAN);
  824.                   if ((tidAreaScan=_beginthread(&ScanAreas, NULL, 16384, &arealiste))==-1)
  825.                   {
  826.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  827.                      WinEnableControl(parent, IDD_AREALIST+2, TRUE);
  828.                   }
  829.                   break;
  830.  
  831.                case IDM_SAP_FGROUND:
  832.                   if (pAreaListData->bForeground)
  833.                   {
  834.                      pAreaListData->bForeground = FALSE;
  835.                      WinCheckMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_FGROUND, FALSE);
  836.                      WinSetOwner(parent, HWND_DESKTOP);
  837.                   }
  838.                   else
  839.                   {
  840.                      pAreaListData->bForeground = TRUE;
  841.                      WinCheckMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_FGROUND, TRUE);
  842.                      WinSetOwner(parent, client);
  843.                   }
  844.  
  845.                   break;
  846.  
  847.                case IDM_AP_CATCHUP:
  848.                   if (bDoingWork)
  849.                   {
  850.                      /* Fehlermeldung */
  851.                      MessageBox(parent, IDST_MSG_DOINGWORK, 0, IDD_DOINGWORK,
  852.                                 MB_OK);
  853.                      break;
  854.                   }
  855.                   if (generaloptions.safety & SAFETY_CATCHUP)
  856.                      if (MessageBox(parent, IDST_MSG_CATCHUP, IDST_TITLE_CATCHUP,
  857.                                     IDD_CATCHUP, MB_YESNO) != MBID_YES)
  858.                         break;
  859.                   if (pAreaListData->selectRecord->RecordCore.flRecordAttr & CRA_SELECTED)
  860.                   {
  861.                      /* Alle selektierten Areas absuchen */
  862.                      pRecords=SendMsg(hwndCnr,
  863.                                       CM_QUERYRECORDEMPHASIS, (MPARAM) CMA_FIRST,
  864.                                       MPFROMSHORT(CRA_SELECTED));
  865.  
  866.                      while (pRecords)
  867.                      {
  868.                         if (pWorkData)
  869.                         {
  870.                            pWorkData->next=calloc(1, sizeof(WORKDATA));
  871.                            pWorkData = pWorkData->next;
  872.                         }
  873.                         else
  874.                         {
  875.                            pWorkData=calloc(1, sizeof(WORKDATA));
  876.                            pWorkData2=pWorkData;
  877.                         }
  878.  
  879.                         strcpy(pWorkData->pchSrcArea, pRecords->pAreaDef->areadata.areatag);
  880.                         pWorkData->flWorkToDo = WORK_MARKALL;
  881.  
  882.                         pRecords=SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecords,
  883.                                          MPFROMSHORT(CRA_SELECTED));
  884.                      }
  885.                   }
  886.                   else
  887.                   {
  888.                      /* nur gewählte Area bearbeiten */
  889.                      pWorkData=calloc(1, sizeof(WORKDATA));
  890.  
  891.                      strcpy(pWorkData->pchSrcArea, pAreaListData->selectRecord->pAreaDef->areadata.areatag);
  892.                      pWorkData->flWorkToDo = WORK_MARKALL;
  893.                      pWorkData2=pWorkData;
  894.                   }
  895.                   if (pWorkData2)
  896.                   {
  897.                      extern int tidWorker;
  898.  
  899.                      bDoingWork=TRUE;
  900.                      tidWorker = _beginthread(WorkerThread, NULL, 32768, pWorkData2);
  901.                   }
  902.                   break;
  903.  
  904.                case IDM_FP_CREATE:
  905.                case IDM_SFP_CREATE:
  906.                   CreateNewFolder(parent, pAreaListData);
  907.                   break;
  908.  
  909.                case IDM_FP_OPEN:
  910.                   if (pAreaListData->selectFolder)
  911.                      OpenFolder(parent, pAreaListData, pAreaListData->selectFolder);
  912.                   break;
  913.  
  914.                case IDM_FP_SCAN:
  915.                   if (pAreaListData->selectFolder)
  916.                   {
  917.                      pAreaListData->selectFolder->pAreaFolder->ulFlags ^= FOLDER_AUTOSCAN;
  918.                      pAreaListData->selectFolder->pAreaFolder->bDirty = TRUE;
  919.                      FolderAnchor.bDirty = TRUE;
  920.                   }
  921.                   break;
  922.  
  923.                case IDM_FP_SORT_NONE:
  924.                   pAreaListData->selectFolder->pAreaFolder->ulFlags &= ~FOLDER_SORT_MASK;
  925.                   pAreaListData->selectFolder->pAreaFolder->ulFlags |= FOLDER_SORT_UNSORTED;
  926.                   pAreaListData->selectFolder->pAreaFolder->bDirty = TRUE;
  927.                   FolderAnchor.bDirty = TRUE;
  928.                   if (pAreaListData->pOpenFolder == pAreaListData->selectFolder)
  929.                   {
  930.                      pAreaListData->ulSort = FOLDER_SORT_UNSORTED;
  931.                      ResortAreaList(parent, FOLDER_SORT_UNSORTED);
  932.                   }
  933.                   break;
  934.  
  935.                case IDM_FP_SORT_NAME:
  936.                   pAreaListData->selectFolder->pAreaFolder->ulFlags &= ~FOLDER_SORT_MASK;
  937.                   pAreaListData->selectFolder->pAreaFolder->ulFlags |= FOLDER_SORT_NAME;
  938.                   pAreaListData->selectFolder->pAreaFolder->bDirty = TRUE;
  939.                   FolderAnchor.bDirty = TRUE;
  940.                   if (pAreaListData->pOpenFolder == pAreaListData->selectFolder)
  941.                   {
  942.                      pAreaListData->ulSort = FOLDER_SORT_NAME;
  943.                      ResortAreaList(parent, FOLDER_SORT_NAME);
  944.                   }
  945.                   break;
  946.  
  947.                case IDM_FP_SORT_UNR:
  948.                   pAreaListData->selectFolder->pAreaFolder->ulFlags &= ~FOLDER_SORT_MASK;
  949.                   pAreaListData->selectFolder->pAreaFolder->ulFlags |= FOLDER_SORT_UNREAD;
  950.                   pAreaListData->selectFolder->pAreaFolder->bDirty = TRUE;
  951.                   FolderAnchor.bDirty = TRUE;
  952.                   if (pAreaListData->pOpenFolder == pAreaListData->selectFolder)
  953.                   {
  954.                      pAreaListData->ulSort = FOLDER_SORT_UNREAD;
  955.                      ResortAreaList(parent, FOLDER_SORT_UNREAD);
  956.                   }
  957.                   break;
  958.  
  959.                case IDM_FP_DELETE:
  960.                   DeleteFolder(parent, pAreaListData, pAreaListData->selectFolder);
  961.                   break;
  962.  
  963.                case IDM_SFP_ICONS_LARGE:
  964.                   FolderAnchor.ulFlags = (FolderAnchor.ulFlags & ~AREAFOLDERS_ICONMASK) | AREAFOLDERS_LARGEICONS;
  965.                   FolderAnchor.bDirty = TRUE;
  966.  
  967.                   SetFolderIcons(parent, pAreaListData);
  968.                   break;
  969.  
  970.                case IDM_SFP_ICONS_SMALL:
  971.                   FolderAnchor.ulFlags = (FolderAnchor.ulFlags & ~AREAFOLDERS_ICONMASK) | AREAFOLDERS_SMALLICONS;
  972.                   FolderAnchor.bDirty = TRUE;
  973.  
  974.                   SetFolderIcons(parent, pAreaListData);
  975.                   break;
  976.  
  977.                case IDM_SFP_ICONS_NONE:
  978.                   FolderAnchor.ulFlags = (FolderAnchor.ulFlags & ~AREAFOLDERS_ICONMASK) | AREAFOLDERS_NOICONS;
  979.                   FolderAnchor.bDirty = TRUE;
  980.  
  981.                   SetFolderIcons(parent, pAreaListData);
  982.                   break;
  983.  
  984.                default:
  985.                   break;
  986.             }
  987.             return (MRESULT) FALSE;
  988.          }
  989.          if (SHORT1FROMMP(mp2)==CMDSRC_ACCELERATOR)
  990.             return RedirectCommand(mp1, mp2);
  991.          break;
  992.  
  993.       case SM_SCANENDED:
  994.          if (pAreaListData->bChange)
  995.             WinEnableControl(parent, IDD_AREALIST+2, TRUE);
  996.  
  997.          /* Liste updaten */
  998.          pRecords=NULL;
  999.          while (pRecords=SendMsg(hwndCnr, CM_QUERYRECORD, pRecords,
  1000.                          MPFROM2SHORT(pRecords?CMA_NEXT:CMA_FIRST, CMA_ITEMORDER)))
  1001.             UpdateAreaNums(pRecords);
  1002.  
  1003.          WinEnableWindowUpdate(WinWindowFromID(hwndCnr, CID_LEFTDVWND), FALSE);
  1004.          SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, NULL);
  1005.          if (pAreaListData->ulSort == FOLDER_SORT_UNREAD)
  1006.             ResortAreaList(parent, pAreaListData->ulSort);
  1007.          WinEnableWindowUpdate(WinWindowFromID(hwndCnr, CID_LEFTDVWND), TRUE);
  1008.          UpdateScannedFolders(parent, pAreaListData);
  1009.          return (MRESULT) FALSE;
  1010.  
  1011.       case WM_CONTROL:
  1012.          if (SHORT1FROMMP(mp1)==IDD_AREALIST+1)
  1013.          {
  1014.             switch(SHORT2FROMMP(mp1))
  1015.             {
  1016.                case CN_CONTEXTMENU:
  1017.                   if (DoingAreaScan || DoingFind || pAreaListData->lDisable > 0)
  1018.                   {
  1019.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  1020.                      break;
  1021.                   }
  1022.                   /* erstmal alles enablen */
  1023.                   WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SETTINGS, TRUE);
  1024.                   WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_CREATE  , TRUE);
  1025.                   WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_DELETE  , TRUE);
  1026.                   WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_RENUMBER, TRUE);
  1027.                   WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SQPARAMS, TRUE);
  1028.                   WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SCAN    , TRUE);
  1029.                   WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_CATCHUP , TRUE);
  1030.  
  1031.                   pAreaListData->selectRecord=(PAREARECORD)mp2;
  1032.                   /* Nicht auf einer Areazeile */
  1033.                   if (pAreaListData->selectRecord == NULL)
  1034.                      zeiger=NULL;
  1035.                   else
  1036.                      /* Area-Daten suchen */
  1037.                      zeiger=pAreaListData->selectRecord->pAreaDef;
  1038.  
  1039.                   if (!zeiger)
  1040.                   {
  1041.                      /* nicht gefunden oder nicht auf Areazeile */
  1042.                      WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_DELETE,   FALSE);
  1043.                      WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SETTINGS, FALSE);
  1044.                      WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_RENUMBER, FALSE);
  1045.                      WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SQPARAMS, FALSE);
  1046.                      WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SCAN,     FALSE);
  1047.                      WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_CATCHUP,  FALSE);
  1048.                      WinQueryWindowRect(hwndCnr, &rectl);
  1049.                   }
  1050.                   else
  1051.                   {
  1052.                      QUERYRECORDRECT qrecordc;
  1053.  
  1054.                      if (!pAreaListData->bChange)
  1055.                         break;
  1056.  
  1057.                      qrecordc.cb=sizeof(QUERYRECORDRECT);
  1058.                      qrecordc.pRecord=(PRECORDCORE) mp2;
  1059.                      qrecordc.fRightSplitWindow=FALSE;
  1060.                      qrecordc.fsExtent=CMA_TEXT;
  1061.                      SendMsg(hwndCnr, CM_QUERYRECORDRECT, &rectl, &qrecordc);
  1062.  
  1063.                      /* sind mehrere Areas markiert */
  1064.                      pRecords=SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, (MPARAM) CMA_FIRST,
  1065.                                       MPFROMSHORT(CRA_SELECTED));
  1066.                      pRecords=SendMsg(hwndCnr,
  1067.                                       CM_QUERYRECORDEMPHASIS, pRecords,
  1068.                                       MPFROMSHORT(CRA_SELECTED));
  1069.                      if (pRecords && (pAreaListData->selectRecord->RecordCore.flRecordAttr & CRA_SELECTED))
  1070.                      {
  1071.                         WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_DELETE,   FALSE);
  1072.                         WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_RENUMBER, FALSE);
  1073.                         WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SQPARAMS, FALSE);
  1074.  
  1075.                         /* Source-Emphasis auf die selektierten Areas */
  1076.                         ApplySourceEmphasis(hwndCnr, (PRECORDCORE) pAreaListData->selectRecord);
  1077.                      }
  1078.  
  1079.                      if (DoingAreaScan || DoingFind)
  1080.                         WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_RENUMBER, FALSE);
  1081.                   }
  1082.                   if (zeiger)
  1083.                   {
  1084.                      if (zeiger->areadata.ulAreaOpt & AREAOPT_FROMCFG)
  1085.                         WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_DELETE, FALSE);
  1086.  
  1087.                      if (zeiger->areadata.areaformat != AREAFORMAT_SQUISH)
  1088.                         WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_SQPARAMS, FALSE);
  1089.  
  1090.                      if (zeiger->areadata.areaformat != AREAFORMAT_FTS ||
  1091.                          CurrentStatus != PROGSTATUS_READING ||
  1092.                          !stricmp(CurrentArea, zeiger->areadata.areatag))
  1093.                         WinEnableMenuItem(pAreaListData->hwndpopup, IDM_AP_RENUMBER, FALSE);
  1094.                   }
  1095.                   else
  1096.                   {
  1097.                      if (!pAreaListData->bChange)
  1098.                      {
  1099.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_SETTINGS, FALSE);
  1100.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_CREATE,   FALSE);
  1101.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_SCANALL,  FALSE);
  1102.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_FGROUND,  FALSE);
  1103.                      }
  1104.                      else
  1105.                      {
  1106.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_SETTINGS, TRUE);
  1107.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_CREATE,   TRUE);
  1108.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_SCANALL,  TRUE);
  1109.                         WinEnableMenuItem(pAreaListData->hwndpopupsmall, IDM_SAP_FGROUND,  TRUE);
  1110.                      }
  1111.                   }
  1112.                   if (pAreaListData->selectRecord)
  1113.                      SendMsg(hwndCnr, CM_SETRECORDEMPHASIS,
  1114.                                        pAreaListData->selectRecord, MPFROM2SHORT(TRUE, CRA_SOURCE));
  1115.  
  1116.                   if (pAreaListData->bKeyboard)
  1117.                   {
  1118.                      WinQueryWindowRect(hwndCnr, &rectl2);
  1119.                      WinMapWindowPoints(hwndCnr, HWND_DESKTOP, (PPOINTL) &rectl2, 2);
  1120.  
  1121.                      if (zeiger)
  1122.                         WinPopupMenu(HWND_DESKTOP, parent, pAreaListData->hwndpopup,
  1123.                                      rectl2.xLeft+(rectl2.xRight-rectl2.xLeft)/2,
  1124.                                      rectl2.yBottom+rectl.yBottom+(rectl.yTop-rectl.yBottom)/2,
  1125.                                      0, PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1);
  1126.                      else
  1127.                         WinPopupMenu(HWND_DESKTOP, parent, pAreaListData->hwndpopupsmall,
  1128.                                      rectl2.xLeft+(rectl2.xRight-rectl2.xLeft)/2,
  1129.                                      rectl2.yBottom+rectl.yBottom+(rectl.yTop-rectl.yBottom)/2,
  1130.                                      0, PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1);
  1131.                   }
  1132.                   else
  1133.                   {
  1134.                      POINTL pointl;
  1135.  
  1136.                      WinQueryPointerPos(HWND_DESKTOP, &pointl);
  1137.                      if (zeiger)
  1138.                         WinPopupMenu(HWND_DESKTOP, parent, pAreaListData->hwndpopup,
  1139.                                      pointl.x, pointl.y,
  1140.                                      0, PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1);
  1141.                      else
  1142.                         WinPopupMenu(HWND_DESKTOP, parent, pAreaListData->hwndpopupsmall,
  1143.                                      pointl.x, pointl.y,
  1144.                                      0, PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1);
  1145.                   }
  1146.                   break;
  1147.  
  1148.                case CN_ENTER:
  1149.                   /* OK-Button simulieren */
  1150.                   WinPostMsg(parent, WM_COMMAND, MPFROMSHORT(DID_OK),
  1151.                              MPFROMSHORT(CMDSRC_PUSHBUTTON));
  1152.                   break;
  1153.  
  1154.                case CN_REALLOCPSZ:
  1155.                   if (((PCNREDITDATA)mp2)->cbText > LEN_AREADESC)
  1156.                   {
  1157.                      WinAlarm(HWND_DESKTOP, WA_ERROR);
  1158.                      return (MRESULT) FALSE;
  1159.                   }
  1160.                   else
  1161.                   {
  1162.                      arealiste.bDirty = TRUE;
  1163.                      ((PAREARECORD)((PCNREDITDATA)mp2)->pRecord)->pAreaDef->dirty=TRUE;
  1164.                      return (MRESULT) TRUE;
  1165.                   }
  1166.  
  1167.                case CN_BEGINEDIT:
  1168.                   SendMsg(WinWindowFromID(hwndCnr, CID_MLE),
  1169.                              MLM_SETTEXTLIMIT, MPFROMLONG(LEN_AREADESC), NULL);
  1170.                   OldAEditProc=WinSubclassWindow(WinWindowFromID(hwndCnr, CID_MLE),
  1171.                                                  NewAEditProc);
  1172.                   pAreaListData->bDirectEdit = TRUE;
  1173.                   break;
  1174.  
  1175.                case CN_ENDEDIT:
  1176.                   WinEnableWindowUpdate(hwndCnr, FALSE);
  1177.                   SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, MPFROM2SHORT(0, CMA_TEXTCHANGED));
  1178.                   if (pAreaListData->ulSort == FOLDER_SORT_NAME)
  1179.                      ResortAreaList(parent, pAreaListData->ulSort);
  1180.                   ScrollToRecord(hwndCnr, NULL);
  1181.                   WinEnableWindowUpdate(hwndCnr, TRUE);
  1182.                   pAreaListData->bDirectEdit = FALSE;
  1183.                   break;
  1184.  
  1185.                case CN_HELP:
  1186.                   SendMsg(parent, WM_HELP, MPFROMSHORT(IDD_AREALIST+1), NULL);
  1187.                   break;
  1188.  
  1189.                case CN_COLORCHANGED:
  1190.                   if (pAreaListData->bAcceptChange)
  1191.                   {
  1192.                      QueryBackground(hwndCnr, &arealistoptions.lBackColor);
  1193.                      QueryForeground(hwndCnr, &arealistoptions.lEchoAreaColor);
  1194.                      dirtyflags.alsettingsdirty=TRUE;
  1195.                   }
  1196.                   break;
  1197.  
  1198.                case CN_DRAGOVER:
  1199.                   return DragOverAreaList(parent, (PCNRDRAGINFO) mp2);
  1200.  
  1201.                case CN_DROP:
  1202.                   DropAreaList(parent, (PCNRDRAGINFO) mp2);
  1203.                   break;
  1204.  
  1205.                case CN_INITDRAG:
  1206.                   InitAreaDrag(parent, pAreaListData, (PCNRDRAGINIT) mp2);
  1207.                   break;
  1208.  
  1209.                default:
  1210.                   break;
  1211.             }
  1212.          }
  1213.          if (SHORT1FROMMP(mp1)==IDD_AREALIST+4)
  1214.          {
  1215.             PCNREDITDATA pEdit;
  1216.             PFOLDERRECORD pRecord;
  1217.             PNOTIFYRECORDENTER pEnter;
  1218.  
  1219.             switch(SHORT2FROMMP(mp1))
  1220.             {
  1221.                case CN_COLORCHANGED:
  1222.                   if (pAreaListData->bAcceptChange)
  1223.                   {
  1224.                      QueryBackground(WinWindowFromID(parent, IDD_AREALIST+4),
  1225.                                      &arealistoptions.lFolderBack);
  1226.                      QueryForeground(WinWindowFromID(parent, IDD_AREALIST+4),
  1227.                                      &arealistoptions.lFolderFore);
  1228.                      dirtyflags.alsettingsdirty=TRUE;
  1229.                   }
  1230.                   break;
  1231.  
  1232.                case CN_CONTEXTMENU:
  1233.                   OpenFolderContext(parent, pAreaListData, (PFOLDERRECORD) mp2);
  1234.                   break;
  1235.  
  1236.                case CN_BEGINEDIT:
  1237.                   pAreaListData->bDirectEdit = TRUE;
  1238.                   break;
  1239.  
  1240.                case CN_ENDEDIT:
  1241.                   pAreaListData->bDirectEdit = FALSE;
  1242.                   pEdit = (PCNREDITDATA) mp2;
  1243.                   SendMsg(pEdit->hwndCnr, CM_SORTRECORD, (MPARAM) SortFolders, NULL);
  1244.                   if (pEdit->pRecord == (PRECORDCORE) pAreaListData->pOpenFolder)
  1245.                   {
  1246.                      CNRINFO cnrinfo;
  1247.  
  1248.                      /* Titel neu setzen */
  1249.                      cnrinfo.cb = sizeof(cnrinfo);
  1250.                      cnrinfo.pszCnrTitle = pAreaListData->pOpenFolder->pAreaFolder->pchName;
  1251.                      WinSendMsg(hwndCnr, CM_SETCNRINFO, &cnrinfo, MPFROMLONG(CMA_CNRTITLE));
  1252.                   }
  1253.                   break;
  1254.  
  1255.                case CN_REALLOCPSZ:
  1256.                   pEdit = (PCNREDITDATA) mp2;
  1257.                   pRecord = (PFOLDERRECORD) pEdit->pRecord;
  1258.                   free (pRecord->pAreaFolder->pchName);
  1259.                   pRecord->pAreaFolder->pchName = malloc(pEdit->cbText+1);
  1260.                   pRecord->pAreaFolder->pchName[0] = '\0';
  1261.                   pRecord->RecordCore.pszIcon = pRecord->pAreaFolder->pchName;
  1262.                   pRecord->pAreaFolder->bDirty=TRUE;
  1263.                   FolderAnchor.bDirty = TRUE;
  1264.                   return (MRESULT) TRUE;
  1265.  
  1266.                case CN_HELP:
  1267.                   SendMsg(parent, WM_HELP, MPFROMSHORT(IDD_AREALIST+4), NULL);
  1268.                   break;
  1269.  
  1270.                case CN_ENTER:
  1271.                   pEnter = (PNOTIFYRECORDENTER) mp2;
  1272.                   if (pEnter->pRecord)
  1273.                      OpenFolder(parent, pAreaListData, (PFOLDERRECORD) pEnter->pRecord);
  1274.                   break;
  1275.  
  1276.                case CN_INITDRAG:
  1277.                   InitFolderDrag(parent, pAreaListData, (PCNRDRAGINIT) mp2);
  1278.                   break;
  1279.  
  1280.                case CN_DROP:
  1281.                   DropOnFolder((PCNRDRAGINFO) mp2);
  1282.                   break;
  1283.  
  1284.                case CN_DRAGOVER:
  1285.                   return DragOverFolder(parent, (PCNRDRAGINFO) mp2);
  1286.  
  1287.                case CN_EXPANDTREE:
  1288.                   if (pRecord = (PFOLDERRECORD) mp2)
  1289.                   {
  1290.                      pRecord->pAreaFolder->ulFlags |= FOLDER_EXPANDED;
  1291.                      pRecord->pAreaFolder->bDirty = TRUE;
  1292.                      FolderAnchor.bDirty = TRUE;
  1293.                   }
  1294.                   break;
  1295.  
  1296.                case CN_COLLAPSETREE:
  1297.                   if (pRecord = (PFOLDERRECORD) mp2)
  1298.                   {
  1299.                      pRecord->pAreaFolder->ulFlags &= ~FOLDER_EXPANDED;
  1300.                      pRecord->pAreaFolder->bDirty = TRUE;
  1301.                      FolderAnchor.bDirty = TRUE;
  1302.                   }
  1303.                   break;
  1304.  
  1305.                default:
  1306.                   break;
  1307.             }
  1308.          }
  1309.          break;
  1310.  
  1311.       case WM_MENUEND:
  1312.          if ((HWND) mp2 != pAreaListData->hwndpopup &&
  1313.              (HWND) mp2 != pAreaListData->hwndpopupsmall &&
  1314.              (HWND) mp2 != pAreaListData->hwndFolderPopup &&
  1315.              (HWND) mp2 != pAreaListData->hwndSmallFolderPopup)
  1316.             break;
  1317.          pAreaListData->bKeyboard=FALSE;
  1318.  
  1319.          if ((HWND) mp2 == pAreaListData->hwndpopupsmall)
  1320.             ResetMenuStyle(pAreaListData->hwndpopupsmall, parent);
  1321.  
  1322.          /* Source-Emphasis loeschen */
  1323.          RemoveSourceEmphasis(hwndCnr);
  1324.          RemoveSourceEmphasis(WinWindowFromID(parent, IDD_AREALIST+4));
  1325.          if ((HWND) mp2 == pAreaListData->hwndpopupsmall && !pAreaListData->selectRecord)
  1326.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS,
  1327.                               NULL, MPFROM2SHORT(FALSE, CRA_SOURCE));
  1328.          if ((HWND) mp2 == pAreaListData->hwndSmallFolderPopup && !pAreaListData->selectFolder)
  1329.             WinSendDlgItemMsg(parent, IDD_AREALIST+4, CM_SETRECORDEMPHASIS,
  1330.                               NULL, MPFROM2SHORT(FALSE, CRA_SOURCE));
  1331.          break;
  1332.  
  1333.       case WM_INITMENU:
  1334.          if ((HWND) mp2 == pAreaListData->hwndpopupsmall)
  1335.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS,
  1336.                               NULL, MPFROM2SHORT(TRUE, CRA_SOURCE));
  1337.          break;
  1338.  
  1339.       case WM_CONTEXTMENU:
  1340.       case WM_TEXTEDIT:
  1341.          if (!SHORT1FROMMP(mp1))
  1342.          {
  1343.             if (WinQueryFocus(HWND_DESKTOP)==hwndCnr)
  1344.             {
  1345.                pAreaListData->bKeyboard=TRUE;
  1346.                SendMsg(hwndCnr, message, mp1, mp2);
  1347.             }
  1348.             else
  1349.                if (WinQueryFocus(HWND_DESKTOP)==WinWindowFromID(parent, IDD_AREALIST+4))
  1350.                {
  1351.                   pAreaListData->bKeyboard=TRUE;
  1352.                   WinSendDlgItemMsg(parent, IDD_AREALIST+4, message, mp1, mp2);
  1353.                }
  1354.          }
  1355.          break;
  1356.  
  1357.       case WM_TRANSLATEACCEL:
  1358.          if (pAreaListData->bDirectEdit)
  1359.             return FALSE;
  1360.          else
  1361.             break;
  1362.  
  1363.       case WM_MOUSEMOVE:
  1364.          if (IsBetweenContainers(parent, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1)))
  1365.          {
  1366.             SetPointer();
  1367.             return (MRESULT) TRUE;
  1368.          }
  1369.          break;
  1370.  
  1371.       case WM_BUTTON1DOWN:
  1372.          if (IsBetweenContainers(parent, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1)))
  1373.          {
  1374.             TrackSeparator(parent);
  1375.          }
  1376.          break;
  1377.  
  1378.       case WORKM_ENABLEVIEWS:
  1379.          if (pAreaListData->lDisable > 0)
  1380.             pAreaListData->lDisable--;
  1381.          if (pAreaListData->lDisable == 0)
  1382.          {
  1383.             WinEnableControl(parent, DID_OK, TRUE);
  1384.             WinEnableControl(parent, DID_CANCEL, TRUE);
  1385.             if (pAreaListData->bChange && !DoingAreaScan)
  1386.                WinEnableControl(parent, IDD_AREALIST+2, TRUE);
  1387.          }
  1388.          break;
  1389.  
  1390.       case WORKM_DISABLEVIEWS:
  1391.          pAreaListData->lDisable++;
  1392.          if (pAreaListData->lDisable > 0)
  1393.          {
  1394.             WinEnableControl(parent, DID_OK, FALSE);
  1395.             WinEnableControl(parent, DID_CANCEL, FALSE);
  1396.             WinEnableControl(parent, IDD_AREALIST+2, FALSE);
  1397.          }
  1398.          break;
  1399.  
  1400.       case WORKM_DELETED:
  1401.       case WORKM_ADDED:
  1402.       case WORKM_READ:
  1403.          {
  1404.             /* Anzahl der Messages in der Area veraendert sich evtl. */
  1405.             PMESSAGEID pMessageID = (PMESSAGEID) mp1;
  1406.  
  1407.             /* Liste updaten */
  1408.             pRecords=NULL;
  1409.             while (pRecords=SendMsg(hwndCnr, CM_QUERYRECORD, pRecords,
  1410.                                     MPFROM2SHORT(pRecords?CMA_NEXT:CMA_FIRST, CMA_ITEMORDER)))
  1411.             {
  1412.                if (!stricmp(pRecords->pAreaDef->areadata.areatag, pMessageID->pchAreaTag))
  1413.                {
  1414.                   UpdateAreaNums(pRecords);
  1415.                   pAreaListData->bDirty=TRUE;
  1416.  
  1417.                   break;
  1418.                }
  1419.             }
  1420.          }
  1421.          break;
  1422.  
  1423.       case WORKM_MARKEND:
  1424.          {
  1425.             /* Anzahl der Messages in der Area veraendert sich evtl. */
  1426.             PMESSAGEID pMessageID = (PMESSAGEID) mp1;
  1427.  
  1428.             /* Liste updaten */
  1429.             pRecords=NULL;
  1430.             while (pRecords=SendMsg(hwndCnr, CM_QUERYRECORD, pRecords,
  1431.                             MPFROM2SHORT(pRecords?CMA_NEXT:CMA_FIRST, CMA_ITEMORDER)))
  1432.             {
  1433.                if (!stricmp(pRecords->pAreaDef->areadata.areatag, pMessageID->pchAreaTag))
  1434.                {
  1435.                   UpdateAreaNums(pRecords);
  1436.                   WinEnableWindowUpdate(WinWindowFromID(hwndCnr, CID_LEFTDVWND), FALSE);
  1437.                   SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, NULL);
  1438.                   if (pAreaListData->ulSort == FOLDER_SORT_UNREAD)
  1439.                      ResortAreaList(parent, pAreaListData->ulSort);
  1440.                   WinEnableWindowUpdate(WinWindowFromID(hwndCnr, CID_LEFTDVWND), TRUE);
  1441.  
  1442.                   pAreaListData->bDirty = FALSE;
  1443.                   break;
  1444.                }
  1445.             }
  1446.          }
  1447.          break;
  1448.  
  1449.       case WORKM_SWITCHACCELS:
  1450.          SwitchAccels(parent, (ULONG) mp1);
  1451.          break;
  1452.  
  1453.       default:
  1454.          break;
  1455.    }
  1456.    return WinDefDlgProc(parent, message, mp1, mp2);
  1457. }
  1458.  
  1459. static void InitAreaContainer(HWND hwndDlg, PAREALISTDATA pAreaListData)
  1460. {
  1461.    CNRINFO cnrinfo;
  1462.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+1);
  1463.    PFIELDINFO pFieldInfo=NULL;
  1464.    PFIELDINFO firstFieldInfo=NULL;
  1465.    FIELDINFOINSERT fieldInfoInsert;
  1466.  
  1467.    /* Felder im Container aufbauen */
  1468.    pFieldInfo = SendMsg(hwndCnr, CM_ALLOCDETAILFIELDINFO, MPFROMLONG(3), NULL);
  1469.    firstFieldInfo = pFieldInfo;
  1470.  
  1471.    pFieldInfo->cb = sizeof(FIELDINFO);
  1472.    pFieldInfo->flData = CFA_STRING | CFA_HORZSEPARATOR | CFA_LEFT | CFA_OWNER | CFA_SEPARATOR;
  1473.    pFieldInfo->flTitle = CFA_FITITLEREADONLY;
  1474.    pFieldInfo->pTitleData = pAreaListData->pchTAreaDesc;
  1475.    LoadString(IDST_AL_AREADESC, 50, pFieldInfo->pTitleData);
  1476.    pFieldInfo->offStruct = FIELDOFFSET(AREARECORD, areadesc);
  1477.    pFieldInfo = pFieldInfo->pNextFieldInfo;
  1478.  
  1479.    pFieldInfo->cb = sizeof(FIELDINFO);
  1480.    pFieldInfo->flData = CFA_STRING | CFA_HORZSEPARATOR | CFA_RIGHT |
  1481.                         CFA_FIREADONLY | CFA_SEPARATOR | CFA_OWNER;
  1482.    pFieldInfo->flTitle = CFA_FITITLEREADONLY;
  1483.    pFieldInfo->pTitleData = pAreaListData->pchTUnread;
  1484.    LoadString(IDST_AL_UNREAD, 50, pFieldInfo->pTitleData);
  1485.    pFieldInfo->offStruct = FIELDOFFSET(AREARECORD, msgnotread);
  1486.    pFieldInfo = pFieldInfo->pNextFieldInfo;
  1487.  
  1488.    pFieldInfo->cb = sizeof(FIELDINFO);
  1489.    pFieldInfo->flData = CFA_STRING | CFA_HORZSEPARATOR | CFA_RIGHT |
  1490.                         CFA_FIREADONLY | CFA_OWNER;
  1491.    pFieldInfo->flTitle = CFA_FITITLEREADONLY;
  1492.    pFieldInfo->pTitleData = pAreaListData->pchTTotal;
  1493.    LoadString(IDST_AL_TOTAL, 50, pFieldInfo->pTitleData);
  1494.    pFieldInfo->offStruct = FIELDOFFSET(AREARECORD, totlmsgs);
  1495.  
  1496.    fieldInfoInsert.cb = (ULONG)(sizeof(FIELDINFOINSERT));
  1497.    fieldInfoInsert.pFieldInfoOrder = (PFIELDINFO)CMA_FIRST;
  1498.    fieldInfoInsert.cFieldInfoInsert = 3;
  1499.    fieldInfoInsert.fInvalidateFieldInfo = TRUE;
  1500.  
  1501.    SendMsg(hwndCnr, CM_INSERTDETAILFIELDINFO, firstFieldInfo, &fieldInfoInsert);
  1502.  
  1503.    cnrinfo.cb=sizeof(CNRINFO);
  1504.    cnrinfo.flWindowAttr=CV_DETAIL | CA_DETAILSVIEWTITLES |
  1505.                         CA_CONTAINERTITLE | CA_TITLEREADONLY | CA_TITLESEPARATOR;
  1506.  
  1507.    cnrinfo.pSortRecord=(PVOID) SortFuncs[pAreaListData->ulSort];
  1508.  
  1509.    SendMsg(hwndCnr, CM_SETCNRINFO, &cnrinfo, MPFROMLONG(CMA_FLWINDOWATTR | CMA_PSORTRECORD));
  1510.  
  1511.    if (pAreaListData->bExtendedSel)
  1512.    {
  1513.       ULONG ulStyle=WinQueryWindowULong(hwndCnr, QWL_STYLE);
  1514.       WinSetWindowULong(hwndCnr, QWL_STYLE, ulStyle | CCS_EXTENDSEL);
  1515.    }
  1516.  
  1517.    return;
  1518. }
  1519.  
  1520. /*------------------------------ NewContainerProc ---------------------------*/
  1521. /* Neue Window-Prozedur f. Container, um OS/2-Bug zu umschiffen              */
  1522. /*---------------------------------------------------------------------------*/
  1523.  
  1524. static MRESULT EXPENTRY NewAContainerProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1525. {
  1526.    switch(message)
  1527.    {
  1528. #if 0
  1529.       case DM_DRAGOVER:
  1530.          return (MRESULT) DOR_NEVERDROP;
  1531. #endif
  1532.  
  1533.       case WM_PRESPARAMCHANGED:
  1534.          if ((ULONG) mp1 == PP_FOREGROUNDCOLOR ||
  1535.              (ULONG) mp1 == PP_BACKGROUNDCOLOR)
  1536.          {
  1537.             /* Notification an Owner */
  1538.             SendMsg(WinQueryWindow(parent, QW_OWNER),
  1539.                        WM_CONTROL,
  1540.                        MPFROM2SHORT(WinQueryWindowUShort(parent, QWS_ID),
  1541.                                     CN_COLORCHANGED),
  1542.                        NULL);
  1543.          }
  1544.          break;
  1545.  
  1546.       default:
  1547.          break;
  1548.    }
  1549.    return OldContainerProc(parent, message, mp1, mp2);
  1550. }
  1551.  
  1552. /*------------------------------ CleanupAreaList  ---------------------------*/
  1553. /* Gibt den Speicher fuer die Textfelder wieder frei, entfernt alle Records  */
  1554. /*---------------------------------------------------------------------------*/
  1555.  
  1556. static void CleanupAreaList(HWND hwndContainer)
  1557. {
  1558.    PAREARECORD pRecord=NULL;
  1559.  
  1560.    while(pRecord=SendMsg(hwndContainer, CM_QUERYRECORD,
  1561.                                  pRecord, MPFROM2SHORT(pRecord?CMA_NEXT:CMA_FIRST, CMA_ITEMORDER)))
  1562.    {
  1563.       if (pRecord->msgnotread)
  1564.          free(pRecord->msgnotread);
  1565.       if (pRecord->totlmsgs)
  1566.          free(pRecord->totlmsgs);
  1567.    }
  1568.    SendMsg(hwndContainer, CM_REMOVERECORD, NULL,
  1569.                                 MPFROM2SHORT(0, CMA_FREE));
  1570.  
  1571.    return;
  1572. }
  1573.  
  1574. /*--------------------------- ScrollToRecord  -------------------------------*/
  1575. /* Scrollt den Container zu einem Record                                     */
  1576. /* pRecord: Zeiger auf den Record                                            */
  1577. /* tocursored: Scrollt zum Record mit dem Cursored-Attribut, pRecord ign.    */
  1578. /*---------------------------------------------------------------------------*/
  1579.  
  1580. static BOOL ScrollToRecord(HWND hwndCnr, PRECORDCORE pRecord)
  1581. {
  1582.    QUERYRECORDRECT qrecord;
  1583.    RECTL rectl, rectl2;
  1584.  
  1585.    if (!pRecord)
  1586.    {
  1587.       pRecord=(PRECORDCORE)SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
  1588.                               (MPARAM) CMA_FIRST, MPFROMSHORT(CRA_CURSORED));
  1589.    }
  1590.  
  1591.    if (pRecord)
  1592.    {
  1593.       WinQueryWindowRect(hwndCnr, &rectl2);
  1594.       qrecord.cb=sizeof(QUERYRECORDRECT);
  1595.       qrecord.pRecord=pRecord;
  1596.       qrecord.fRightSplitWindow=FALSE;
  1597.       qrecord.fsExtent=CMA_TEXT;
  1598.       if (SendMsg(hwndCnr, CM_QUERYRECORDRECT, &rectl, &qrecord))
  1599.       {
  1600.          if (rectl.yBottom < (rectl2.yTop-rectl2.yBottom)/2)
  1601.          {
  1602.             SendMsg(hwndCnr, CM_SCROLLWINDOW,
  1603.                        MPFROMSHORT(CMA_VERTICAL),
  1604.                        MPFROMLONG((rectl2.yTop-rectl2.yBottom)/2-rectl.yBottom));
  1605.          }
  1606.       }
  1607.       return TRUE;
  1608.    }
  1609.    else
  1610.       return FALSE;
  1611. }
  1612.  
  1613. /*------------------------------   SortFunc   -------------------------------*/
  1614. /* Sort-  Funktion fuer die Area-Liste                                       */
  1615. /*---------------------------------------------------------------------------*/
  1616.  
  1617. static SHORT _System SortOrig(PRECORDCORE p1, PRECORDCORE p2, PVOID AreaList)
  1618. {
  1619.    AREADEFLIST *zeiger;
  1620.  
  1621.    AreaList=AreaList;
  1622.  
  1623.    zeiger=arealiste.pFirstArea;
  1624.  
  1625.    while (zeiger)
  1626.    {
  1627.       if (zeiger == ((PAREARECORD)p1)->pAreaDef)
  1628.          return -1;
  1629.  
  1630.       if (zeiger == ((PAREARECORD)p2)->pAreaDef)
  1631.          return 1;
  1632.  
  1633.       zeiger=zeiger->next;
  1634.    }
  1635.    return 0;
  1636. }
  1637.  
  1638. static SHORT _System SortName(PRECORDCORE p1, PRECORDCORE p2, PVOID AreaList)
  1639. {
  1640.    AREADEFLIST *zeiger;
  1641.    PAREADEFLIST pArea1 = ((PAREARECORD)p1)->pAreaDef;
  1642.    PAREADEFLIST pArea2 = ((PAREARECORD)p2)->pAreaDef;
  1643.  
  1644.    AreaList=AreaList;
  1645.  
  1646.    /* Reihenfolge: Net - Echo/Lokal,
  1647.                    bei Typgleichheit: nach Desc oder Tag entscheiden */
  1648.  
  1649.    if (pArea1->areadata.areatype == AREATYPE_NET &&  /* Net vor anderen */
  1650.        pArea2->areadata.areatype != AREATYPE_NET)
  1651.       return -1;
  1652.  
  1653.    if (pArea1->areadata.areatype != AREATYPE_NET &&  /* Net vor anderen */
  1654.        pArea2->areadata.areatype == AREATYPE_NET)
  1655.       return 1;
  1656.  
  1657.    if (pArea1->areadata.areatype == pArea2->areadata.areatype &&
  1658.        pArea1->areadata.areatype == AREATYPE_NET)
  1659.    {
  1660.       /* nach Original-Reihenfolge */
  1661.       zeiger=arealiste.pFirstArea;
  1662.  
  1663.       while (zeiger)
  1664.       {
  1665.          if (zeiger == pArea1)
  1666.             return -1;
  1667.  
  1668.          if (zeiger == pArea2)
  1669.             return 1;
  1670.  
  1671.          zeiger=zeiger->next;
  1672.       }
  1673.       return 0;
  1674.    }
  1675.    else
  1676.       return stricmp(((PAREARECORD)p1)->areadesc, ((PAREARECORD)p2)->areadesc);
  1677. }
  1678.  
  1679. static SHORT _System SortNumber(PRECORDCORE p1, PRECORDCORE p2, PVOID AreaList)
  1680. {
  1681.    PAREADEFLIST pArea1 = ((PAREARECORD)p1)->pAreaDef;
  1682.    PAREADEFLIST pArea2 = ((PAREARECORD)p2)->pAreaDef;
  1683.  
  1684.    AreaList=AreaList;
  1685.  
  1686.    /* Net-Areas zuerst */
  1687.    if (pArea1->areadata.areatype == AREATYPE_NET &&  /* Net vor anderen */
  1688.        pArea2->areadata.areatype != AREATYPE_NET)
  1689.       return -1;
  1690.  
  1691.    if (pArea1->areadata.areatype != AREATYPE_NET &&  /* Net vor anderen */
  1692.        pArea2->areadata.areatype == AREATYPE_NET)
  1693.       return 1;
  1694.  
  1695.  
  1696.    if (pArea1->areadata.areatype == pArea2->areadata.areatype)
  1697.    {
  1698.       AREADEFLIST *zeiger;
  1699.  
  1700.       /* Beides sind Net-Areas, nach Original-Reihenfolge */
  1701.       if (pArea1->areadata.areatype == AREATYPE_NET)
  1702.       {
  1703.          zeiger=arealiste.pFirstArea;
  1704.  
  1705.          while (zeiger)
  1706.          {
  1707.             if (zeiger == ((PAREARECORD)p1)->pAreaDef)
  1708.                return -1;
  1709.  
  1710.             if (zeiger == ((PAREARECORD)p2)->pAreaDef)
  1711.                return 1;
  1712.  
  1713.             zeiger=zeiger->next;
  1714.          }
  1715.          return 0;
  1716.       }
  1717.    }
  1718.  
  1719.    /* Beides sind Echos, weiter mit Anzahl ungel. Msgs */
  1720.  
  1721.    /* gescannte zuerst */
  1722.    if (pArea1->scanned &&
  1723.        !pArea2->scanned)
  1724.       return -1;
  1725.  
  1726.    if (!pArea1->scanned &&
  1727.        pArea2->scanned)
  1728.       return 1;
  1729.  
  1730.    if (!pArea1->scanned &&
  1731.        !pArea2->scanned)
  1732.    {
  1733.       /* Beide ungescannt, nach Description */
  1734.       return stricmp(((PAREARECORD)p1)->areadesc, ((PAREARECORD)p2)->areadesc);
  1735.    }
  1736.  
  1737.    /* Beide gescanned, nach Anzahl */
  1738.    if ((pArea1->maxmessages -
  1739.         pArea1->currentmessage) <
  1740.        (pArea2->maxmessages -
  1741.         pArea2->currentmessage))
  1742.       return 1;
  1743.  
  1744.    if ((pArea1->maxmessages -
  1745.         pArea1->currentmessage) >
  1746.        (pArea2->maxmessages -
  1747.         pArea2->currentmessage))
  1748.       return -1;
  1749.  
  1750.    /* Beide gleiche Anzahl, nach Description */
  1751.  
  1752.    return stricmp(((PAREARECORD)p1)->areadesc, ((PAREARECORD)p2)->areadesc);
  1753. }
  1754.  
  1755. /*------------------------------ ResortAreaList -----------------------------*/
  1756. /* Sortiert die Arealiste neu                                                */
  1757. /*---------------------------------------------------------------------------*/
  1758.  
  1759. static void ResortAreaList(HWND hwndDlg, ULONG ulSortType)
  1760. {
  1761.  
  1762.    WinSendDlgItemMsg(hwndDlg, IDD_AREALIST+1, CM_SORTRECORD,
  1763.                      MPFROMP(SortFuncs[ulSortType]), NULL);
  1764.  
  1765. #if 0
  1766.    /* Workaround f. Fixpak 17 und Merlin */
  1767.    ScrollToRecord(WinWindowFromID(hwndDlg, IDD_AREALIST+1), NULL);
  1768. #endif
  1769.  
  1770.    return;
  1771. }
  1772.  
  1773. /*---------------------------------------------------------------------------*/
  1774. /* Funktionsname: MarkAllAreas                                               */
  1775. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1776. /* Beschreibung: Markiert alle (nicht excludeten) Areas mit der angegebenen  */
  1777. /*               Flag-Kombination                                            */
  1778. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1779. /* Parameter:    arealist:  Area-Liste                                       */
  1780. /*               ulFlags:   Flags, die gesetzt werden sollen                 */
  1781. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1782. /* Rückgabewerte: -                                                          */
  1783. /*                                                                           */
  1784. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1785. /* Sonstiges: Flags WORK_* sind in structs.h definiert                       */
  1786. /*                                                                           */
  1787. /*---------------------------------------------------------------------------*/
  1788.  
  1789. void MarkAllAreas(PAREALIST arealist, LONG lFolderID, ULONG ulFlags)
  1790. {
  1791.    AREADEFLIST *zeiger= arealist->pFirstArea;
  1792.  
  1793.    while (zeiger)
  1794.    {
  1795.       if (lFolderID == FOLDERID_ALL)
  1796.       {
  1797.          PAREAFOLDER pFolder = FM_FindFolder(&FolderAnchor, zeiger->areadata.ulFolderID);
  1798.          if (pFolder->ulFlags & FOLDER_AUTOSCAN)
  1799.             zeiger->flWork |= ulFlags;
  1800.       }
  1801.       else
  1802.          if (zeiger->areadata.ulFolderID == lFolderID)
  1803.             zeiger->flWork |= ulFlags;
  1804.       zeiger= zeiger->next;
  1805.    }
  1806.  
  1807.    return;
  1808. }
  1809.  
  1810. /*---------------------------------------------------------------------------*/
  1811. /* Funktionsname: MarkSelectedAreas                                          */
  1812. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1813. /* Beschreibung: Markiert alle selektierten Areas mit der angegebenen        */
  1814. /*               Flag-Kombination                                            */
  1815. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1816. /* Parameter:    arealist:  Area-Liste                                       */
  1817. /*               ulFlags:   Flags, die gesetzt werden sollen                 */
  1818. /*               selectRecord: ausgewählter Record                           */
  1819. /*               hwndCnr:   Window-Handle des Containers, der die Areas      */
  1820. /*                          enthaelt                                         */
  1821. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1822. /* Rückgabewerte: -                                                          */
  1823. /*                                                                           */
  1824. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1825. /* Sonstiges: Flags WORK_* sind in structs.h definiert                       */
  1826. /*                                                                           */
  1827. /*---------------------------------------------------------------------------*/
  1828.  
  1829. static void MarkSelectedAreas(PAREALIST arealist, ULONG ulFlags,
  1830.                               PAREARECORD selectRecord, HWND hwndCnr)
  1831. {
  1832.    PAREARECORD pRecord=NULL;
  1833.    AREADEFLIST *zeiger=NULL;
  1834.  
  1835.    if (selectRecord->RecordCore.flRecordAttr & CRA_SELECTED)
  1836.    {
  1837.       /* Alle selektierten Areas includen */
  1838.       pRecord=SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
  1839.                                        (MPARAM) CMA_FIRST,
  1840.                                        MPFROMSHORT(CRA_SELECTED));
  1841.       do
  1842.       {
  1843.          zeiger = AM_FindArea(arealist, pRecord->pAreaDef->areadata.areatag);
  1844.          if (zeiger)
  1845.             zeiger->flWork |= ulFlags;
  1846.       } while (pRecord=SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
  1847.                                                 pRecord,
  1848.                                                 MPFROMSHORT(CRA_SELECTED)));
  1849.    }
  1850.    else
  1851.    {
  1852.       /* nur gewählte Area includen */
  1853.       zeiger = AM_FindArea(arealist, selectRecord->pAreaDef->areadata.areatag);
  1854.       if (zeiger)
  1855.          zeiger->flWork |= ulFlags;
  1856.    }
  1857.  
  1858.    return;
  1859. }
  1860.  
  1861.  
  1862.  
  1863. /*--------------------------------- DrawItem --------------------------------*/
  1864. /* Behandelt die Ownerdraw-Message in der Arealiste                          */
  1865. /*---------------------------------------------------------------------------*/
  1866.  
  1867. static BOOL DrawItem(POWNERITEM Item)
  1868. {
  1869.    AREADEFLIST *zeiger;
  1870.    POINTL pointl;
  1871.    BOOL bRet=FALSE;
  1872.    LONG lForeColor;
  1873.    PAREARECORD pRecord;
  1874.  
  1875.    pRecord = (PAREARECORD)((PCNRDRAWITEMINFO)Item->hItem)->pRecord;
  1876.  
  1877.    if (!pRecord)
  1878.       return FALSE;
  1879.  
  1880.    if (!pRecord->pAreaDef)
  1881.       return FALSE;
  1882.  
  1883.    zeiger = pRecord->pAreaDef;
  1884.  
  1885.    if (Item->fsAttribute & CRA_SELECTED)
  1886.       return FALSE;
  1887.  
  1888.    if (!((PCNRDRAWITEMINFO)Item->hItem)->pFieldInfo)
  1889.       return FALSE;
  1890.  
  1891.    GpiCreateLogColorTable(Item->hps, 0, LCOLF_RGB, 0, 0, 0);
  1892.  
  1893.    if (((PCNRDRAWITEMINFO)Item->hItem)->pFieldInfo->offStruct == FIELDOFFSET(AREARECORD, areadesc))
  1894.    {
  1895.       Item->rclItem.xLeft += 5;
  1896.  
  1897.       switch(zeiger->areadata.areatype)
  1898.       {
  1899.          case AREATYPE_ECHO:
  1900.             lForeColor = arealistoptions.lEchoAreaColor;
  1901.             break;
  1902.  
  1903.          case AREATYPE_NET:
  1904.             lForeColor = arealistoptions.lNetAreaColor;
  1905.             break;
  1906.  
  1907.          case AREATYPE_LOCAL:
  1908.             lForeColor = arealistoptions.lLocalAreaColor;
  1909.             break;
  1910.  
  1911.          default:
  1912.             break;
  1913.       }
  1914.  
  1915.       WinDrawText(Item->hps, -1, pRecord->areadesc, &Item->rclItem,
  1916.                   lForeColor,
  1917.                   arealistoptions.lBackColor, DT_LEFT);
  1918.       bRet=TRUE;
  1919.    }
  1920.    else
  1921.       bRet=FALSE;
  1922.  
  1923.    if (zeiger->areadata.ulAreaOpt & AREAOPT_SEPARATOR)
  1924.    {
  1925.       LONG FrameClr;
  1926.  
  1927.       if (!WinQueryPresParam(Item->hwnd, PP_BORDERCOLOR, PP_BORDERCOLORINDEX,
  1928.                              NULL, sizeof(LONG), &FrameClr, QPF_ID2COLORINDEX))
  1929.          FrameClr = WinQuerySysColor(HWND_DESKTOP, SYSCLR_WINDOWFRAME, 0);
  1930.  
  1931.       GpiSetColor(Item->hps, FrameClr);
  1932.       pointl.x=Item->rclItem.xLeft;
  1933.       pointl.y=Item->rclItem.yBottom;
  1934.       GpiMove(Item->hps, &pointl);
  1935.       pointl.x=Item->rclItem.xRight;
  1936.       pointl.y=Item->rclItem.yBottom;
  1937.       GpiLine(Item->hps, &pointl);
  1938.    }
  1939.  
  1940.    return bRet;
  1941. }
  1942.  
  1943. /*------------------------------ NewAEditProc  ------------------------------*/
  1944. /* Window-Procedure des MLE beim Direct Edit                                 */
  1945. /*---------------------------------------------------------------------------*/
  1946.  
  1947. static MRESULT EXPENTRY NewAEditProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  1948. {
  1949.    switch(message)
  1950.    {
  1951.       case WM_CHAR:
  1952.          if ((SendMsg(parent, MLM_QUERYTEXTLENGTH, NULL, NULL)==
  1953.              SendMsg(parent, MLM_QUERYTEXTLIMIT, NULL, NULL)) &&
  1954.              !(SHORT1FROMMP(mp1) & KC_VIRTUALKEY))
  1955.          {
  1956.             if (!(SHORT1FROMMP(mp1) & KC_KEYUP))
  1957.                WinAlarm(HWND_DESKTOP, WA_NOTE);
  1958.             return (MRESULT) TRUE;
  1959.          }
  1960.          else
  1961.             break;
  1962.  
  1963.       default:
  1964.          break;
  1965.    }
  1966.    return OldAEditProc(parent, message, mp1, mp2);
  1967. }
  1968.  
  1969. /*------------------------------ UpdateAreaList -----------------------------*/
  1970. /* Arealiste neu fuellen, Exclude-Flag beachten                              */
  1971. /* Rueckgabewert: Zeiger auf momentane Area                                  */
  1972. /*---------------------------------------------------------------------------*/
  1973.  
  1974. static PAREARECORD UpdateAreaList(HWND hwndCnr, PAREALISTDATA pAreaListData, char *pchCurrArea)
  1975. {
  1976.    AREADEFLIST *zeiger=NULL;
  1977.    ULONG ulAreaCount=0;
  1978.    PAREARECORD pfirstRecord=NULL, selectRecord=NULL, pRecords=NULL;
  1979.    RECORDINSERT recordInsert;
  1980.    CNRINFO cnrinfo;
  1981.  
  1982.    CleanupAreaList(hwndCnr);
  1983.  
  1984.    /* Titel neu setzen */
  1985.    cnrinfo.cb = sizeof(cnrinfo);
  1986.    cnrinfo.pszCnrTitle = pAreaListData->pOpenFolder->pAreaFolder->pchName;
  1987.    WinSendMsg(hwndCnr, CM_SETCNRINFO, &cnrinfo, MPFROMLONG(CMA_CNRTITLE));
  1988.  
  1989.    /* Areas einfuegen */
  1990.    zeiger=arealiste.pFirstArea;
  1991.    while (zeiger)
  1992.    {
  1993.       if (((zeiger->areadata.areatype == AREATYPE_LOCAL && (pAreaListData->ulIncludeTypes & INCLUDE_LOCAL)) ||
  1994.            (zeiger->areadata.areatype == AREATYPE_ECHO  && (pAreaListData->ulIncludeTypes & INCLUDE_ECHO)) ||
  1995.            (zeiger->areadata.areatype == AREATYPE_NET   && (pAreaListData->ulIncludeTypes & INCLUDE_NET))) &&
  1996.           zeiger->areadata.ulFolderID == pAreaListData->pOpenFolder->pAreaFolder->FolderID)
  1997.          ulAreaCount++;
  1998.       zeiger=zeiger->next;
  1999.    }
  2000.    if (ulAreaCount==0)
  2001.       return NULL;
  2002.  
  2003.    pfirstRecord=SendMsg(hwndCnr, CM_ALLOCRECORD,
  2004.                            MPFROMLONG(sizeof(AREARECORD)-sizeof(RECORDCORE)),
  2005.                            MPFROMLONG(ulAreaCount));
  2006.    zeiger=arealiste.pFirstArea;
  2007.    pRecords=pfirstRecord;
  2008.    selectRecord=NULL;
  2009.    while (zeiger && pRecords)
  2010.    {
  2011.       if (((zeiger->areadata.areatype == AREATYPE_LOCAL && (pAreaListData->ulIncludeTypes & INCLUDE_LOCAL)) ||
  2012.            (zeiger->areadata.areatype == AREATYPE_ECHO  && (pAreaListData->ulIncludeTypes & INCLUDE_ECHO)) ||
  2013.            (zeiger->areadata.areatype == AREATYPE_NET   && (pAreaListData->ulIncludeTypes & INCLUDE_NET))) &&
  2014.           zeiger->areadata.ulFolderID == pAreaListData->pOpenFolder->pAreaFolder->FolderID)
  2015.       {
  2016.          InitAreaRecord(pRecords, zeiger, pAreaListData);
  2017.  
  2018.          if (pAreaListData->ulSort != FOLDER_SORT_UNREAD)
  2019.            if (AreaInAreaSet(pchCurrArea, zeiger->areadata.areatag))
  2020.            {
  2021.               pRecords->RecordCore.flRecordAttr |= CRA_SELECTED;
  2022.               selectRecord=pRecords;
  2023.            }
  2024.  
  2025.          pRecords=(PAREARECORD)(pRecords->RecordCore.preccNextRecord);
  2026.       }
  2027.       zeiger=zeiger->next;
  2028.    }
  2029.    recordInsert.cb = sizeof(RECORDINSERT);
  2030.    recordInsert.pRecordParent= NULL;
  2031.    recordInsert.pRecordOrder = (PRECORDCORE)CMA_FIRST;
  2032.    recordInsert.zOrder = CMA_TOP;
  2033.    recordInsert.cRecordsInsert = ulAreaCount;
  2034.    recordInsert.fInvalidateRecord = FALSE;
  2035.  
  2036.    SendMsg(hwndCnr, CM_INSERTRECORD,
  2037.               (PRECORDCORE)pfirstRecord, &recordInsert);
  2038.  
  2039.    SetFocus(hwndCnr);
  2040.  
  2041.    if (!selectRecord)
  2042.       selectRecord = pfirstRecord;
  2043.  
  2044.    if (pAreaListData->ulSort == FOLDER_SORT_UNREAD)
  2045.       return pfirstRecord;
  2046.    else
  2047.       return selectRecord;
  2048. }
  2049.  
  2050. static void InitAreaRecord(PAREARECORD pRecord, PAREADEFLIST pAreaDef, PAREALISTDATA pAreaListData)
  2051. {
  2052.    if (!pAreaListData->bChange || (arealistoptions.ulFlags & AREALISTFLAG_SHOWTAGS))
  2053.       pRecord->RecordCore.flRecordAttr=CRA_RECORDREADONLY;
  2054.    else
  2055.       pRecord->RecordCore.flRecordAttr=0;
  2056.    pRecord->RecordCore.pszIcon=NULL;
  2057.    pRecord->RecordCore.pszText=NULL;
  2058.    pRecord->RecordCore.pszName=NULL;
  2059.    pRecord->RecordCore.pszTree=NULL;
  2060.    pRecord->RecordCore.hptrIcon= NULLHANDLE;
  2061.    if (arealistoptions.ulFlags & AREALISTFLAG_SHOWTAGS)
  2062.       pRecord->areadesc=pAreaDef->areadata.areatag;
  2063.    else
  2064.       pRecord->areadesc=pAreaDef->areadata.areadesc;
  2065.    pRecord->pAreaDef=pAreaDef;
  2066.    UpdateAreaNums(pRecord);
  2067.  
  2068.    return;
  2069. }
  2070.  
  2071. static void UpdateAreaNums(PAREARECORD pRecord)
  2072. {
  2073.    if (!pRecord->msgnotread)
  2074.       pRecord->msgnotread=malloc(12);
  2075.    if (!pRecord->totlmsgs)
  2076.       pRecord->totlmsgs=malloc(12);
  2077.  
  2078.    if (pRecord->pAreaDef->scanned)
  2079.    {
  2080.       ULONG count;
  2081.  
  2082.       if ((count=(pRecord->pAreaDef->maxmessages)-(pRecord->pAreaDef->currentmessage))==0)
  2083.          strcpy(pRecord->msgnotread, "-");
  2084.       else
  2085.          _itoa(count, pRecord->msgnotread, 10);
  2086.       _itoa(pRecord->pAreaDef->maxmessages, pRecord->totlmsgs, 10);
  2087.    }
  2088.    else
  2089.    {
  2090.       strcpy(pRecord->msgnotread, "-");
  2091.       strcpy(pRecord->totlmsgs, "-");
  2092.    }
  2093.  
  2094.    return;
  2095. }
  2096.  
  2097. /*----------------------------- SquishParamsProc ----------------------------*/
  2098. /* Window-Prozedur f. Squish-Parameter                                       */
  2099. /*---------------------------------------------------------------------------*/
  2100.  
  2101. static MRESULT EXPENTRY SquishParamsProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  2102. {
  2103.    static SQUISHPARAMSPAR *pParams;
  2104.    extern HWND hwndhelp;
  2105.    extern WINDOWPOSITIONS windowpositions;
  2106.  
  2107.    switch(message)
  2108.    {
  2109.       case WM_INITDLG:
  2110.          pParams=(SQUISHPARAMSPAR*) mp2;
  2111.          WinAssociateHelpInstance(hwndhelp, parent);
  2112.          /* Anzahl der Messages 0-20000 */
  2113.          WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+5, SPBM_SETLIMITS,
  2114.                            MPFROMLONG(20000), MPFROMLONG(0));
  2115.          /* Skipped Messages 0-20000 */
  2116.          WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+6, SPBM_SETLIMITS,
  2117.                            MPFROMLONG(20000), MPFROMLONG(0));
  2118.          /* Anzahl der Tage 0-100 */
  2119.          WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+7, SPBM_SETLIMITS,
  2120.                            MPFROMLONG(100), MPFROMLONG(0));
  2121.  
  2122.          /* Werte setzen */
  2123.          WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+5, SPBM_SETCURRENTVALUE,
  2124.                            MPFROMLONG(pParams->SquishParams.ulMaxMsgs), NULL);
  2125.          WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+6, SPBM_SETCURRENTVALUE,
  2126.                            MPFROMLONG(pParams->SquishParams.ulSkipMsgs), NULL);
  2127.          WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+7, SPBM_SETCURRENTVALUE,
  2128.                            MPFROMLONG(pParams->SquishParams.usDaysToKeep), NULL);
  2129.          RestoreWinPos(parent, &windowpositions.sqparamspos, FALSE, TRUE);
  2130.          break;
  2131.  
  2132.       case WM_COMMAND:
  2133.          if (SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON)
  2134.             if (SHORT1FROMMP(mp1)==DID_OK)
  2135.             {
  2136.                LONG lBuf;
  2137.  
  2138.                WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+5, SPBM_QUERYVALUE,
  2139.                                  &lBuf, MPFROM2SHORT(0, SPBQ_UPDATEIFVALID));
  2140.                pParams->SquishParams.ulMaxMsgs=lBuf;
  2141.                WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+6, SPBM_QUERYVALUE,
  2142.                                  &lBuf, MPFROM2SHORT(0, SPBQ_UPDATEIFVALID));
  2143.                pParams->SquishParams.ulSkipMsgs=lBuf;
  2144.                WinSendDlgItemMsg(parent, IDD_SQUISHBASEPARAM+7, SPBM_QUERYVALUE,
  2145.                                  &lBuf, MPFROM2SHORT(0, SPBQ_UPDATEIFVALID));
  2146.                pParams->SquishParams.usDaysToKeep=(USHORT)lBuf;
  2147.  
  2148. #if 0
  2149.                /* Werte pruefen */
  2150.                if (pParams->SquishParams.ulSkipMsgs>0 &&
  2151.                    pParams->SquishParams.ulMaxMsgs==0)
  2152.                {
  2153.                   MessageBox(parent, IDST_MSG_SQPARAMVALUES, 0, IDD_SQPARAMVALUES,
  2154.                              MB_OK | MB_ERROR);
  2155.                   return (MRESULT) FALSE;
  2156.                }
  2157. #endif
  2158.             }
  2159.          break;
  2160.  
  2161.       case WM_CONTROL:
  2162.          if ((SHORT1FROMMP(mp1)==IDD_SQUISHBASEPARAM+5 ||
  2163.              SHORT1FROMMP(mp1)==IDD_SQUISHBASEPARAM+6 ||
  2164.              SHORT1FROMMP(mp1)==IDD_SQUISHBASEPARAM+6) &&
  2165.              SHORT2FROMMP(mp1)==SPBN_CHANGE)
  2166.             SendMsg((HWND) mp2, SPBM_QUERYVALUE, NULL,
  2167.                        MPFROM2SHORT(0, SPBQ_ALWAYSUPDATE));
  2168.          break;
  2169.  
  2170.       case WM_DESTROY:
  2171.          WinAssociateHelpInstance(hwndhelp, WinQueryWindow(parent, QW_OWNER));
  2172.          QueryWinPos(parent, &windowpositions.sqparamspos);
  2173.          break;
  2174.  
  2175.       default:
  2176.          break;
  2177.    }
  2178.    return WinDefDlgProc(parent, message, mp1, mp2);
  2179. }
  2180.  
  2181. /*---------------------------------------------------------------------------*/
  2182. /* Funktionsname: DragOverAreaList                                           */
  2183. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2184. /* Beschreibung: Verarbeitet ein Drag-Over der Area-Liste                    */
  2185. /*                                                                           */
  2186. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2187. /* Parameter: hwndDlg: Window-Handle der Area-Liste                          */
  2188. /*            pCnrDrag: Drag-Info von Container                              */
  2189. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2190. /* Rückgabewerte: MRESULT wie fuer CN_DRAGOVER                               */
  2191. /*                                                                           */
  2192. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2193. /* Sonstiges:                                                                */
  2194. /*                                                                           */
  2195. /*---------------------------------------------------------------------------*/
  2196.  
  2197. static MRESULT DragOverAreaList(HWND hwndDlg, PCNRDRAGINFO pCnrDrag)
  2198. {
  2199.    USHORT usDrop = DOR_DROP;
  2200.    USHORT usDefaultOp = DO_UNKNOWN;
  2201.  
  2202.    hwndDlg = hwndDlg;
  2203.  
  2204.    if (pCnrDrag->pRecord)
  2205.    {
  2206.       DRAGITEM dItem;
  2207.  
  2208.       DrgAccessDraginfo(pCnrDrag->pDragInfo);
  2209.       DrgQueryDragitem(pCnrDrag->pDragInfo, sizeof(dItem), &dItem, 0);
  2210.  
  2211.       if (WinQueryAnchorBlock(dItem.hwndItem) != anchor)
  2212.          usDrop = DOR_NEVERDROP;
  2213.  
  2214.       if (!DrgVerifyType(&dItem, "FleetStreet Template"))
  2215.          usDrop = DOR_NEVERDROP;
  2216.  
  2217.       DrgFreeDraginfo(pCnrDrag->pDragInfo);
  2218.    }
  2219.    else
  2220.       usDrop = DOR_NODROP;
  2221.  
  2222.  
  2223.    return MRFROM2SHORT(usDrop, usDefaultOp);
  2224. }
  2225.  
  2226. /*---------------------------------------------------------------------------*/
  2227. /* Funktionsname: DropAreaList                                               */
  2228. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2229. /* Beschreibung: Verarbeitet ein Drop der Area-Liste                         */
  2230. /*                                                                           */
  2231. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2232. /* Parameter: hwndDlg: Window-Handle der Area-Liste                          */
  2233. /*            pCnrDrag: Drag-Info von Container                              */
  2234. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2235. /* Rückgabewerte: -                                                          */
  2236. /*                                                                           */
  2237. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2238. /* Sonstiges:                                                                */
  2239. /*                                                                           */
  2240. /*---------------------------------------------------------------------------*/
  2241.  
  2242. static void DropAreaList(HWND hwndDlg, PCNRDRAGINFO pCnrDrag)
  2243. {
  2244.    hwndDlg = hwndDlg;
  2245.  
  2246.    DrgAccessDraginfo(pCnrDrag->pDragInfo);
  2247.  
  2248.    if (pCnrDrag->pRecord)
  2249.    {
  2250.       DRAGITEM dItem;
  2251.  
  2252.       DrgQueryDragitem(pCnrDrag->pDragInfo, sizeof(dItem), &dItem, 0);
  2253.  
  2254.       if (WinQueryAnchorBlock(dItem.hwndItem) == anchor)
  2255.       {
  2256.          if (DrgVerifyType(&dItem, "FleetStreet Template"))
  2257.          {
  2258.             ((PAREARECORD)pCnrDrag->pRecord)->pAreaDef->areadata.ulTemplateID = dItem.ulItemID;
  2259.             ((PAREARECORD)pCnrDrag->pRecord)->pAreaDef->dirty = TRUE;
  2260.             arealiste.bDirty = TRUE;
  2261.          }
  2262.       }
  2263.    }
  2264.    DrgDeleteDraginfoStrHandles(pCnrDrag->pDragInfo);
  2265.    DrgFreeDraginfo(pCnrDrag->pDragInfo);
  2266.  
  2267.    return;
  2268. }
  2269.  
  2270. static void InitFolderContainer(HWND hwndDlg, PAREALISTDATA pAreaListData)
  2271. {
  2272.    CNRINFO cnrinfo;
  2273.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+4);
  2274.    PFOLDERRECORD pRecord;
  2275.    PAREAFOLDER pFolder;
  2276.    PAREADEFLIST pCurrentArea;
  2277.    LONG FolderToOpen = FOLDERID_ALL;
  2278.  
  2279.    /* Container-Info */
  2280.    SetFolderIcons(hwndDlg, pAreaListData);
  2281.  
  2282.    cnrinfo.cb = sizeof(cnrinfo);
  2283.    cnrinfo.pSortRecord = (PVOID) SortFolders;
  2284.    cnrinfo.cxTreeIndent=14;
  2285.  
  2286.    SendMsg(hwndCnr, CM_SETCNRINFO, &cnrinfo,
  2287.            MPFROMLONG(CMA_PSORTRECORD | CMA_CXTREEINDENT));
  2288.  
  2289.    if (pAreaListData->pchParamString && *pAreaListData->pchParamString)
  2290.    {
  2291.       pCurrentArea = AM_FindArea(&arealiste, *pAreaListData->pchParamString);
  2292.       if (pCurrentArea)
  2293.          FolderToOpen = pCurrentArea->areadata.ulFolderID;
  2294.    }
  2295.  
  2296.    /* Inhalt */
  2297.    pFolder = FM_FindFolder(&FolderAnchor, 0);
  2298.    if (pFolder)
  2299.    {
  2300.       pRecord=InsertFolderRecord(hwndCnr, pFolder, NULL, pAreaListData, FolderToOpen);
  2301.       if (pRecord)
  2302.          InsertChildFolders(hwndCnr, pRecord, pAreaListData, FolderToOpen);
  2303.       SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, NULL);
  2304.    }
  2305.  
  2306.    if (pAreaListData->pOpenFolder)
  2307.    {
  2308.       pAreaListData->pOpenFolder->RecordCore.hptrIcon = pAreaListData->icnFolderOpen;
  2309.       SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pAreaListData->pOpenFolder,
  2310.               MPFROM2SHORT(TRUE, CRA_INUSE));
  2311.    }
  2312.  
  2313.    return;
  2314. }
  2315.  
  2316. static SHORT EXPENTRY SortFolders(PRECORDCORE p1, PRECORDCORE p2, PVOID pStorage)
  2317. {
  2318.    pStorage = pStorage;
  2319.  
  2320.    if (p1 && p2 && p1->pszIcon && p2->pszIcon)
  2321.       return stricmp(p1->pszIcon, p2->pszIcon);
  2322.    else
  2323.       return 0;
  2324. }
  2325.  
  2326. static void InsertChildFolders(HWND hwndCnr, PFOLDERRECORD pParentRecord, PAREALISTDATA pAreaListData, LONG FolderToOpen)
  2327. {
  2328.    PAREAFOLDER pChild=NULL;
  2329.    PFOLDERRECORD pRecord;
  2330.  
  2331.    while (pChild = FM_FindFolderWithParent(&FolderAnchor, pChild, pParentRecord->pAreaFolder->FolderID))
  2332.    {
  2333.       if (pChild->FolderID != pParentRecord->pAreaFolder->FolderID) /* keine Schleifen */
  2334.       {
  2335.          pRecord = InsertFolderRecord(hwndCnr, pChild, pParentRecord, pAreaListData, FolderToOpen);
  2336.  
  2337.          /* Kinder einfügen (Rekursion!) */
  2338.          if (pRecord)
  2339.             InsertChildFolders(hwndCnr, pRecord, pAreaListData, FolderToOpen);
  2340.       }
  2341.    }
  2342. }
  2343.  
  2344. static PFOLDERRECORD InsertFolderRecord(HWND hwndCnr, PAREAFOLDER pFolder, PFOLDERRECORD pParent, PAREALISTDATA pAreaListData, LONG FolderToOpen)
  2345. {
  2346.    RECORDINSERT RecordInsert;
  2347.    PFOLDERRECORD pRecord;
  2348.  
  2349.    pRecord = SendMsg(hwndCnr, CM_ALLOCRECORD,
  2350.                           MPFROMLONG(sizeof(FOLDERRECORD)-sizeof(MINIRECORDCORE)),
  2351.                           MPFROMLONG(1));
  2352.  
  2353.    if (pRecord)
  2354.    {
  2355.       pRecord->pAreaFolder = pFolder;
  2356.       pRecord->RecordCore.pszIcon = pFolder->pchName;
  2357.       if (FolderHasUnreadAreas(pFolder))
  2358.          pRecord->RecordCore.hptrIcon = pAreaListData->icnFolderUnread;
  2359.       else
  2360.          pRecord->RecordCore.hptrIcon = pAreaListData->icnFolder;
  2361.       if (pFolder->ulFlags & FOLDER_EXPANDED)
  2362.          pRecord->RecordCore.flRecordAttr = CRA_EXPANDED;
  2363.       else
  2364.          pRecord->RecordCore.flRecordAttr = CRA_COLLAPSED;
  2365.  
  2366.       RecordInsert.cb = sizeof(RecordInsert);
  2367.       RecordInsert.pRecordOrder = (PRECORDCORE) CMA_END;
  2368.       RecordInsert.pRecordParent = (PRECORDCORE) pParent;
  2369.       RecordInsert.fInvalidateRecord = FALSE;
  2370.       RecordInsert.zOrder = CMA_TOP;
  2371.       RecordInsert.cRecordsInsert = 1;
  2372.  
  2373.       SendMsg(hwndCnr, CM_INSERTRECORD, pRecord, &RecordInsert);
  2374.  
  2375.       if ((FolderToOpen != FOLDERID_ALL && pFolder->FolderID == FolderToOpen) ||
  2376.           (pFolder->FolderID == FolderAnchor.LastFolder))
  2377.       {
  2378.          pAreaListData->pOpenFolder = pRecord;
  2379.          pAreaListData->ulSort = pFolder->ulFlags & FOLDER_SORT_MASK;
  2380.       }
  2381.    }
  2382.  
  2383.    return pRecord;
  2384. }
  2385.  
  2386. static void OpenFolderContext(HWND hwndDlg, PAREALISTDATA pAreaListData, PFOLDERRECORD pRecord)
  2387. {
  2388.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+4);
  2389.    RECTL rectl;
  2390.  
  2391.    pAreaListData->selectFolder = pRecord;
  2392.  
  2393.    if (pRecord)
  2394.    {
  2395.       QUERYRECORDRECT qrecordc;
  2396.  
  2397.       qrecordc.cb=sizeof(QUERYRECORDRECT);
  2398.       qrecordc.pRecord=(PRECORDCORE) pRecord;
  2399.       qrecordc.fRightSplitWindow=FALSE;
  2400.       if ((FolderAnchor.ulFlags & AREAFOLDERS_ICONMASK) == AREAFOLDERS_NOICONS)
  2401.          qrecordc.fsExtent=CMA_TEXT;
  2402.       else
  2403.          qrecordc.fsExtent=CMA_ICON;
  2404.       SendMsg(hwndCnr, CM_QUERYRECORDRECT, &rectl, &qrecordc);
  2405.  
  2406.       ApplySourceEmphasis(hwndCnr, (PRECORDCORE) pRecord);
  2407.       WinMapWindowPoints(hwndCnr, HWND_DESKTOP, (PPOINTL) &rectl, 2);
  2408.  
  2409.       WinEnableMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_DELETE, pRecord->pAreaFolder->FolderID);
  2410.       WinCheckMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_SCAN, pRecord->pAreaFolder->ulFlags & FOLDER_AUTOSCAN);
  2411.  
  2412.       WinCheckMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_SORT_NONE, FALSE);
  2413.       WinCheckMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_SORT_NAME, FALSE);
  2414.       WinCheckMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_SORT_UNR, FALSE);
  2415.       switch(pRecord->pAreaFolder->ulFlags & FOLDER_SORT_MASK)
  2416.       {
  2417.          case FOLDER_SORT_UNSORTED:
  2418.             WinCheckMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_SORT_NONE, TRUE);
  2419.             break;
  2420.  
  2421.          case FOLDER_SORT_NAME:
  2422.             WinCheckMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_SORT_NAME, TRUE);
  2423.             break;
  2424.  
  2425.          case FOLDER_SORT_UNREAD:
  2426.             WinCheckMenuItem(pAreaListData->hwndFolderPopup, IDM_FP_SORT_UNR, TRUE);
  2427.             break;
  2428.       }
  2429.  
  2430.       WinPopupMenu(HWND_DESKTOP, hwndDlg, pAreaListData->hwndFolderPopup,
  2431.                    rectl.xRight, rectl.yBottom,
  2432.                    0, PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1);
  2433.    }
  2434.    else
  2435.    {
  2436.       if (!pAreaListData->bKeyboard)
  2437.       {
  2438.          POINTL pointl;
  2439.  
  2440.          WinQueryPointerPos(HWND_DESKTOP, &pointl);
  2441.          rectl.xLeft = pointl.x;
  2442.          rectl.yBottom = pointl.y;
  2443.       }
  2444.       else
  2445.       {
  2446.          WinQueryWindowRect(hwndCnr, &rectl);
  2447.          WinMapWindowPoints(hwndCnr, HWND_DESKTOP, (PPOINTL) &rectl, 2);
  2448.          rectl.xLeft = (rectl.xLeft + rectl.xRight)/2;
  2449.          rectl.yBottom = (rectl.yBottom + rectl.yTop)/2;
  2450.       }
  2451.  
  2452.       WinPopupMenu(HWND_DESKTOP, hwndDlg, pAreaListData->hwndSmallFolderPopup,
  2453.                    rectl.xLeft, rectl.yBottom,
  2454.                    0, PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD | PU_MOUSEBUTTON1);
  2455.       SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, NULL, MPFROM2SHORT(TRUE, CRA_SOURCE));
  2456.  
  2457.    }
  2458. }
  2459.  
  2460. static PFOLDERRECORD CreateNewFolder(HWND hwndDlg, PAREALISTDATA pAreaListData)
  2461. {
  2462.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+4);
  2463.    PAREAFOLDER pNewFolder;
  2464.    AREAFOLDER AreaFolder;
  2465.    PFOLDERRECORD pRecord=NULL;
  2466.  
  2467.    memset(&AreaFolder, 0, sizeof(AreaFolder));
  2468.    AreaFolder.pchName = calloc(1, 50);
  2469.    LoadString(IDST_AL_NEWFOLDER, 50, AreaFolder.pchName);
  2470.  
  2471.    if (!pAreaListData->selectFolder)
  2472.    {
  2473.       /* Root-Folder nehmen */
  2474.       pAreaListData->selectFolder = SendMsg(hwndCnr, CM_QUERYRECORD, NULL, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
  2475.    }
  2476.  
  2477.    if (pAreaListData->selectFolder)
  2478.       AreaFolder.ParentFolder = pAreaListData->selectFolder->pAreaFolder->FolderID;
  2479.  
  2480.    pNewFolder = FM_AddFolder(&FolderAnchor, &AreaFolder, ADDFOLDER_TAIL | ADDFOLDER_NEWID | ADDFOLDER_MARKDIRTY);
  2481.  
  2482.    if (pNewFolder)
  2483.    {
  2484.       pRecord = InsertFolderRecord(hwndCnr, pNewFolder, pAreaListData->selectFolder, pAreaListData, FOLDERID_ALL);
  2485.       SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, NULL);
  2486.    }
  2487.  
  2488.    return pRecord;
  2489. }
  2490.  
  2491. static void OpenFolder(HWND hwndDlg, PAREALISTDATA pAreaListData, PFOLDERRECORD pFolder)
  2492. {
  2493.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+4);
  2494.  
  2495.    if (pAreaListData->pOpenFolder != pFolder)
  2496.    {
  2497.       if (pAreaListData->pOpenFolder)
  2498.       {
  2499.          if (FolderHasUnreadAreas(pAreaListData->pOpenFolder->pAreaFolder))
  2500.             pAreaListData->pOpenFolder->RecordCore.hptrIcon = pAreaListData->icnFolderUnread;
  2501.          else
  2502.             pAreaListData->pOpenFolder->RecordCore.hptrIcon = pAreaListData->icnFolder;
  2503.          SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pAreaListData->pOpenFolder,
  2504.                  MPFROM2SHORT(FALSE, CRA_INUSE));
  2505.          pAreaListData->pOpenFolder = NULL;
  2506.       }
  2507.       pAreaListData->pOpenFolder = pFolder;
  2508.       pAreaListData->ulSort = pFolder->pAreaFolder->ulFlags & FOLDER_SORT_MASK;
  2509.       pFolder->RecordCore.hptrIcon = pAreaListData->icnFolderOpen;
  2510.       SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pFolder,
  2511.               MPFROM2SHORT(TRUE, CRA_INUSE));
  2512.  
  2513.       UpdateAreaList(WinWindowFromID(hwndDlg, IDD_AREALIST+1), pAreaListData, NULL);
  2514.       ResortAreaList(hwndDlg, pAreaListData->ulSort);
  2515.       WinSendDlgItemMsg(hwndDlg, IDD_AREALIST+1, CM_INVALIDATERECORD, NULL, NULL);
  2516.    }
  2517.    else
  2518.       WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwndDlg, IDD_AREALIST+1));
  2519.  
  2520.    return;
  2521. }
  2522.  
  2523. static void SetFolderIcons(HWND hwndDlg, PAREALISTDATA pAreaListData)
  2524. {
  2525.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+4);
  2526.    CNRINFO cnrinfo;
  2527.    ULONG ulStyle;
  2528.  
  2529.    cnrinfo.cb = sizeof(cnrinfo);
  2530.    cnrinfo.slTreeBitmapOrIcon.cx=16;
  2531.    cnrinfo.slTreeBitmapOrIcon.cy=16;
  2532.    cnrinfo.hptrExpanded=pAreaListData->hptrMinus;
  2533.    cnrinfo.hptrCollapsed=pAreaListData->hptrPlus;
  2534.  
  2535.    WinCheckMenuItem(pAreaListData->hwndSmallFolderPopup, IDM_SFP_ICONS_LARGE, FALSE);
  2536.    WinCheckMenuItem(pAreaListData->hwndSmallFolderPopup, IDM_SFP_ICONS_SMALL, FALSE);
  2537.    WinCheckMenuItem(pAreaListData->hwndSmallFolderPopup, IDM_SFP_ICONS_NONE, FALSE);
  2538.  
  2539.    ulStyle = WinQueryWindowULong(hwndCnr, QWL_STYLE) | CCS_MINIICONS;
  2540.    WinSetWindowULong(hwndCnr, QWL_STYLE, ulStyle);
  2541.  
  2542.    switch(FolderAnchor.ulFlags & AREAFOLDERS_ICONMASK)
  2543.    {
  2544.       case AREAFOLDERS_LARGEICONS:
  2545.          cnrinfo.flWindowAttr = CV_TREE | CA_TREELINE;
  2546.          WinCheckMenuItem(pAreaListData->hwndSmallFolderPopup, IDM_SFP_ICONS_LARGE, TRUE);
  2547.          break;
  2548.  
  2549.       case AREAFOLDERS_SMALLICONS:
  2550.          cnrinfo.hptrExpanded=NULLHANDLE;
  2551.          cnrinfo.hptrCollapsed=NULLHANDLE;
  2552.          cnrinfo.flWindowAttr = CV_TREE | CA_TREELINE | CV_MINI;
  2553.          WinCheckMenuItem(pAreaListData->hwndSmallFolderPopup, IDM_SFP_ICONS_SMALL, TRUE);
  2554.          break;
  2555.  
  2556.       case AREAFOLDERS_NOICONS:
  2557.          cnrinfo.flWindowAttr = CV_TREE | CV_TEXT | CA_TREELINE;
  2558.          WinCheckMenuItem(pAreaListData->hwndSmallFolderPopup, IDM_SFP_ICONS_NONE, TRUE);
  2559.          break;
  2560.  
  2561.       default:
  2562.          return;
  2563.    }
  2564.  
  2565.    SendMsg(hwndCnr, CM_SETCNRINFO, &cnrinfo, MPFROMLONG(CMA_TREEICON | CMA_FLWINDOWATTR));
  2566.  
  2567.    return;
  2568. }
  2569.  
  2570. static void InitAreaDrag(HWND hwndDlg, PAREALISTDATA pAreaListData, PCNRDRAGINIT pInit)
  2571. {
  2572.    PDRAGINFO pDraginfo;
  2573.    DRAGITEM dItem;
  2574.    DRAGIMAGE dImage[3];
  2575.    ULONG ulNum=0;
  2576.    PAREARECORD pRecord;
  2577.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+1);
  2578.    int i=0;
  2579.    HWND hwndDrop;
  2580.  
  2581.    if (pInit->pRecord)
  2582.    {
  2583.       if (pInit->pRecord->flRecordAttr & CRA_SELECTED)
  2584.       {
  2585.          /* alle selektierten */
  2586.          pRecord = NULL;
  2587.          while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  2588.                                      MPFROMLONG(CRA_SELECTED)))
  2589.             ulNum++;
  2590.       }
  2591.       else
  2592.          ulNum = 1;
  2593.  
  2594.       pDraginfo = DrgAllocDraginfo(ulNum);
  2595.       pDraginfo->usOperation=DO_DEFAULT;
  2596.       pDraginfo->hwndSource=hwndDlg;
  2597.  
  2598.       if (ulNum > 1)
  2599.       {
  2600.          pRecord = NULL;
  2601.          while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS, pRecord?pRecord:MPFROMLONG(CMA_FIRST),
  2602.                                      MPFROMLONG(CRA_SELECTED)))
  2603.          {
  2604.             /* Source emphasis */
  2605.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(TRUE, CRA_SOURCE));
  2606.  
  2607.             FillDragItem(hwndDlg, pRecord, &dItem);
  2608.             DrgSetDragitem(pDraginfo, &dItem, sizeof(dItem), i);
  2609.             i++;
  2610.          }
  2611.       }
  2612.       else
  2613.       {
  2614.          /* nur einer */
  2615.          pRecord = (PAREARECORD) pInit->pRecord;
  2616.  
  2617.          /* Source emphasis */
  2618.          SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(TRUE, CRA_SOURCE));
  2619.  
  2620.          FillDragItem(hwndDlg, pRecord, &dItem);
  2621.          DrgSetDragitem(pDraginfo, &dItem, sizeof(dItem), 0);
  2622.       }
  2623.  
  2624.       for (i=0; i<ulNum && i<3; i++)
  2625.       {
  2626.          /* Drag-Image vorbereiten */
  2627.          dImage[i].cb=sizeof(DRAGIMAGE);
  2628.          dImage[i].hImage=pAreaListData->icon;
  2629.          dImage[i].fl=DRG_ICON;
  2630.          dImage[i].cxOffset=i*10;
  2631.          dImage[i].cyOffset=i*10;
  2632.       }
  2633.  
  2634.       hwndDrop = DrgDrag(hwndDlg, pDraginfo, dImage, (ulNum<3)?ulNum:3, VK_ENDDRAG, NULL);
  2635.       DrgFreeDraginfo(pDraginfo);
  2636.  
  2637.       if (hwndDrop)
  2638.       {
  2639.          UpdateAreaList(hwndCnr, pAreaListData, NULL);
  2640.          ResortAreaList(hwndDlg, pAreaListData->ulSort);
  2641.          SendMsg(hwndCnr, CM_INVALIDATERECORD, NULL, NULL);
  2642.       }
  2643.       else
  2644.          /* Source emphasis wegnehmen */
  2645.          if (ulNum > 1)
  2646.             RemoveSourceEmphasis(hwndCnr);
  2647.          else
  2648.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(FALSE, CRA_SOURCE));
  2649.    }
  2650. }
  2651.  
  2652. static void FillDragItem(HWND hwndDlg, PAREARECORD pRecord, PDRAGITEM dItem)
  2653. {
  2654.    /* Drag-Item vorbereiten*/
  2655.    dItem->hwndItem=hwndDlg;
  2656.    dItem->ulItemID= (ULONG)pRecord;
  2657.    dItem->hstrType=DrgAddStrHandle(AREADRAGTYPE);
  2658.    dItem->hstrSourceName=DrgAddStrHandle(pRecord->pAreaDef->areadata.areatag);
  2659.    dItem->hstrTargetName=DrgAddStrHandle(pRecord->pAreaDef->areadata.areatag);
  2660.    dItem->hstrContainerName = NULLHANDLE;
  2661.  
  2662.    if (pRecord->pAreaDef->areadata.ulAreaOpt & AREAOPT_FROMCFG)
  2663.       dItem->hstrRMF=DrgAddStrHandle(AREARMF);
  2664.    else
  2665.       dItem->hstrRMF=DrgAddStrHandle(AREARMFDEL);
  2666.    dItem->fsControl= DC_CONTAINER;
  2667.    dItem->fsSupportedOps=DO_MOVEABLE;
  2668.  
  2669.    return;
  2670. }
  2671.  
  2672. static BOOL IsBetweenContainers(HWND hwndDlg, SHORT x, SHORT y)
  2673. {
  2674.    SWP swpFolders, swpList;
  2675.  
  2676.    WinQueryWindowPos(WinWindowFromID(hwndDlg, IDD_AREALIST+4), &swpFolders);
  2677.    WinQueryWindowPos(WinWindowFromID(hwndDlg, IDD_AREALIST+1), &swpList);
  2678.  
  2679.    if (y > swpFolders.y &&
  2680.        y < swpFolders.y+swpFolders.cy &&
  2681.        x >= swpFolders.x+swpFolders.cx &&
  2682.        x < swpList.x)
  2683.       return TRUE;
  2684.    else
  2685.       return FALSE;
  2686. }
  2687.  
  2688. static void SetPointer(void)
  2689. {
  2690.    HPOINTER hptr;
  2691.  
  2692.    hptr = WinQuerySysPointer(HWND_DESKTOP, SPTR_SIZEWE, FALSE);
  2693.    WinSetPointer(HWND_DESKTOP, hptr);
  2694.  
  2695.    return;
  2696. }
  2697.  
  2698. static void TrackSeparator(HWND hwndDlg)
  2699. {
  2700.    TRACKINFO TrackInfo;
  2701.    SWP swpFolders;
  2702.  
  2703.    /* Daten vorbelegen */
  2704.    TrackInfo.cxBorder = 2;
  2705.    TrackInfo.cyBorder = 1;
  2706.    TrackInfo.cxGrid = 1;
  2707.    TrackInfo.cyGrid = 1;
  2708.    TrackInfo.cxKeyboard = 1;
  2709.    TrackInfo.cyKeyboard = 1;
  2710.  
  2711.    WinQueryWindowPos(WinWindowFromID(hwndDlg, IDD_AREALIST+4), &swpFolders);
  2712.    WinQueryWindowRect(hwndDlg, &TrackInfo.rclBoundary);
  2713.    CalcClientRect(anchor, hwndDlg, &TrackInfo.rclBoundary);
  2714.    TrackInfo.rclBoundary.yBottom = swpFolders.y;
  2715.    TrackInfo.rclBoundary.yTop = swpFolders.y+swpFolders.cy;
  2716.  
  2717.    WinInflateRect(anchor, &TrackInfo.rclBoundary, -WinQuerySysValue(HWND_DESKTOP, SV_CXVSCROLL), 0);
  2718.  
  2719.    TrackInfo.rclTrack.xLeft = swpFolders.x+swpFolders.cx;
  2720.    TrackInfo.rclTrack.xRight = swpFolders.x+swpFolders.cx+2;
  2721.    TrackInfo.rclTrack.yBottom = swpFolders.y;
  2722.    TrackInfo.rclTrack.yTop = swpFolders.y+swpFolders.cy;
  2723.  
  2724.    TrackInfo.ptlMinTrackSize.x = 1;
  2725.    TrackInfo.ptlMinTrackSize.y = 1;
  2726.    TrackInfo.ptlMaxTrackSize.x = 2;
  2727.    TrackInfo.ptlMaxTrackSize.y = swpFolders.cy;
  2728.  
  2729.    TrackInfo.fs = TF_ALLINBOUNDARY | TF_MOVE;
  2730.  
  2731.    /* Track */
  2732.    if (WinTrackRect(hwndDlg, NULLHANDLE, &TrackInfo))
  2733.    {
  2734.       FolderAnchor.lSplit = TrackInfo.rclTrack.xLeft - swpFolders.x;
  2735.       FolderAnchor.bDirty = TRUE;
  2736.  
  2737.       RepositionContainers(hwndDlg);
  2738.    }
  2739.    return;
  2740. }
  2741.  
  2742. static void RepositionContainers(HWND hwndDlg)
  2743. {
  2744.    RECTL rectl;
  2745.    SWP swp;
  2746.  
  2747.    WinQueryWindowRect(hwndDlg, &rectl);
  2748.    CalcClientRect(anchor, hwndDlg, &rectl);
  2749.    WinQueryWindowPos(WinWindowFromID(hwndDlg, DID_OK), &swp);
  2750.    rectl.yBottom += swp.y + swp.cy;
  2751.    WinSetWindowPos(WinWindowFromID(hwndDlg, IDD_AREALIST+4),
  2752.                    NULLHANDLE,
  2753.                    rectl.xLeft, rectl.yBottom,
  2754.                    FolderAnchor.lSplit, rectl.yTop-rectl.yBottom,
  2755.                    SWP_MOVE | SWP_SIZE);
  2756.    WinSetWindowPos(WinWindowFromID(hwndDlg, IDD_AREALIST+1),
  2757.                    NULLHANDLE,
  2758.                    rectl.xLeft+FolderAnchor.lSplit+CONTAINERSPACE, rectl.yBottom,
  2759.                    rectl.xRight-rectl.xLeft-FolderAnchor.lSplit-CONTAINERSPACE, rectl.yTop-rectl.yBottom,
  2760.                    SWP_MOVE | SWP_SIZE);
  2761.  
  2762.    return;
  2763. }
  2764.  
  2765. static MRESULT DragOverFolder(HWND hwndDlg, PCNRDRAGINFO pInfo)
  2766. {
  2767.    USHORT usDrop = DOR_NEVERDROP;
  2768.    USHORT usDefaultOp = DO_MOVE;
  2769.  
  2770.    if (pInfo->pRecord)
  2771.    {
  2772.       DrgAccessDraginfo(pInfo->pDragInfo);
  2773.  
  2774.       if (pInfo->pDragInfo->hwndSource == hwndDlg) /* nur innerhalb der Liste */
  2775.       {
  2776.          if (pInfo->pDragInfo->usOperation == DO_DEFAULT ||
  2777.              pInfo->pDragInfo->usOperation == DO_MOVE)
  2778.          {
  2779.             PDRAGITEM pItem;
  2780.             int i;
  2781.  
  2782.             for (i=0; i<pInfo->pDragInfo->cditem; i++)
  2783.             {
  2784.                pItem = DrgQueryDragitemPtr(pInfo->pDragInfo, i);
  2785.                if (pItem)
  2786.                {
  2787.                   if (DrgVerifyTrueType(pItem, AREADRAGTYPE))
  2788.                      continue;
  2789.  
  2790.                   if (DrgVerifyTrueType(pItem, FOLDERDRAGTYPE))
  2791.                   {
  2792.                      if ((PRECORDCORE)pItem->ulItemID == pInfo->pRecord)
  2793.                      {
  2794.                         usDrop = DOR_NODROP;
  2795.                         break;
  2796.                      }
  2797.                   }
  2798.                   else
  2799.                      break;
  2800.                }
  2801.             }
  2802.             if (i >= pInfo->pDragInfo->cditem)
  2803.                usDrop = DOR_DROP;
  2804.          }
  2805.          else
  2806.             usDrop = DOR_NODROPOP;
  2807.       }
  2808.  
  2809.       DrgFreeDraginfo(pInfo->pDragInfo);
  2810.    }
  2811.    else
  2812.       usDrop = DOR_NODROP;
  2813.  
  2814.    return MRFROM2SHORT(usDrop, usDefaultOp);
  2815. }
  2816.  
  2817. static void DropOnFolder(PCNRDRAGINFO pInfo)
  2818. {
  2819.    int i;
  2820.    PDRAGITEM pItem;
  2821.  
  2822.    DrgAccessDraginfo(pInfo->pDragInfo);
  2823.  
  2824.    for (i=0; i<pInfo->pDragInfo->cditem; i++)
  2825.    {
  2826.       pItem = DrgQueryDragitemPtr(pInfo->pDragInfo, i);
  2827.       if (pItem)
  2828.       {
  2829.          if (DrgVerifyTrueType(pItem, AREADRAGTYPE))
  2830.          {
  2831.             PAREARECORD pRecord = (PAREARECORD)pItem->ulItemID;
  2832.  
  2833.             /* Area verschieben */
  2834.             if (pRecord->pAreaDef->areadata.ulFolderID !=
  2835.                 ((PFOLDERRECORD)pInfo->pRecord)->pAreaFolder->FolderID)
  2836.             {
  2837.                pRecord->pAreaDef->areadata.ulFolderID =
  2838.                 ((PFOLDERRECORD)pInfo->pRecord)->pAreaFolder->FolderID;
  2839.  
  2840.                pRecord->pAreaDef->dirty = TRUE;
  2841.                arealiste.bDirty = TRUE;
  2842.             }
  2843.          }
  2844.          else
  2845.             if (DrgVerifyTrueType(pItem, FOLDERDRAGTYPE))
  2846.             {
  2847.                PFOLDERRECORD pRecord = (PFOLDERRECORD)pItem->ulItemID;
  2848.  
  2849.                if (pRecord->pAreaFolder->ParentFolder !=
  2850.                    ((PFOLDERRECORD)pInfo->pRecord)->pAreaFolder->FolderID)
  2851.                {
  2852.                   pRecord->pAreaFolder->ParentFolder = ((PFOLDERRECORD)pInfo->pRecord)->pAreaFolder->FolderID;
  2853.                   pRecord->pAreaFolder->bDirty = TRUE;
  2854.                   FolderAnchor.bDirty = TRUE;
  2855.                }
  2856.             }
  2857.       }
  2858.    }
  2859.  
  2860.    DrgDeleteDraginfoStrHandles(pInfo->pDragInfo);
  2861.  
  2862.    DrgFreeDraginfo(pInfo->pDragInfo);
  2863. }
  2864.  
  2865. static void DeleteFolder(HWND hwndDlg, PAREALISTDATA pAreaListData, PFOLDERRECORD pFolder)
  2866. {
  2867.    PAREADEFLIST pArea= arealiste.pFirstArea;
  2868.    PAREAFOLDER pAFolder = FolderAnchor.pList;
  2869.  
  2870.    /* Areas im Folder nach oben setzen */
  2871.    while (pArea)
  2872.    {
  2873.       if (pArea->areadata.ulFolderID == pFolder->pAreaFolder->FolderID)
  2874.       {
  2875.          pArea->areadata.ulFolderID = pFolder->pAreaFolder->ParentFolder;
  2876.          pArea->dirty = TRUE;
  2877.          arealiste.bDirty = TRUE;
  2878.       }
  2879.       pArea = pArea->next;
  2880.    }
  2881.  
  2882.    /* Folder im Folder nach oben setzen */
  2883.    while (pAFolder)
  2884.    {
  2885.       if (pAFolder->ParentFolder == pFolder->pAreaFolder->FolderID)
  2886.       {
  2887.          pAFolder->ParentFolder = pFolder->pAreaFolder->ParentFolder;
  2888.          pAFolder->bDirty = TRUE;
  2889.          FolderAnchor.bDirty = TRUE;
  2890.       }
  2891.       pAFolder = pAFolder->next;
  2892.    }
  2893.  
  2894.    if (pAreaListData->pOpenFolder == pFolder)  /* aktuellen loeschen */
  2895.    {
  2896.       pAreaListData->pOpenFolder = NULL;
  2897.       FolderAnchor.LastFolder = pFolder->pAreaFolder->ParentFolder;
  2898.    }
  2899.  
  2900.    FM_DeleteFolderDirect(&FolderAnchor, pFolder->pAreaFolder);
  2901.  
  2902.    /* neu anzeigen */
  2903.    WinSendDlgItemMsg(hwndDlg, IDD_AREALIST+4, CM_REMOVERECORD, NULL,
  2904.                      MPFROM2SHORT(0, CMA_FREE));
  2905.    InitFolderContainer(hwndDlg, pAreaListData);
  2906.    UpdateAreaList(WinWindowFromID(hwndDlg, IDD_AREALIST+1), pAreaListData, NULL);
  2907.    ResortAreaList(hwndDlg, pAreaListData->ulSort);
  2908.    WinSendDlgItemMsg(hwndDlg, IDD_AREALIST+1, CM_INVALIDATERECORD, NULL, NULL);
  2909.  
  2910.    return;
  2911. }
  2912.  
  2913. static void InitFolderDrag(HWND hwndDlg, PAREALISTDATA pAreaListData, PCNRDRAGINIT pInit)
  2914. {
  2915.    PDRAGINFO pDraginfo;
  2916.    DRAGITEM dItem;
  2917.    DRAGIMAGE dImage;
  2918.    PFOLDERRECORD pRecord;
  2919.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+4);
  2920.    HWND hwndDrop;
  2921.  
  2922.    if (pInit->pRecord)
  2923.    {
  2924.       pRecord = (PFOLDERRECORD) pInit->pRecord;
  2925.  
  2926.       if (pRecord->pAreaFolder->FolderID) /* nicht root */
  2927.       {
  2928.          pDraginfo = DrgAllocDraginfo(1);
  2929.          pDraginfo->usOperation=DO_DEFAULT;
  2930.          pDraginfo->hwndSource=hwndDlg;
  2931.  
  2932.          /* Source emphasis */
  2933.          SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(TRUE, CRA_SOURCE));
  2934.  
  2935.          /* Drag-Item vorbereiten*/
  2936.          dItem.hwndItem=hwndDlg;
  2937.          dItem.ulItemID= (ULONG)pRecord;
  2938.          dItem.hstrType=DrgAddStrHandle(FOLDERDRAGTYPE);
  2939.          dItem.hstrSourceName=DrgAddStrHandle(pRecord->pAreaFolder->pchName);
  2940.          dItem.hstrTargetName=DrgAddStrHandle(pRecord->pAreaFolder->pchName);
  2941.          dItem.hstrContainerName = NULLHANDLE;
  2942.  
  2943.          if (pRecord->pAreaFolder->FolderID)
  2944.             dItem.hstrRMF=DrgAddStrHandle(FOLDERRMF);
  2945.          else
  2946.             dItem.hstrRMF=DrgAddStrHandle(FOLDERRMFDEL);
  2947.  
  2948.          dItem.fsControl= DC_CONTAINER;
  2949.          dItem.fsSupportedOps=DO_MOVEABLE;
  2950.          DrgSetDragitem(pDraginfo, &dItem, sizeof(dItem), 0);
  2951.  
  2952.          /* Drag-Image vorbereiten */
  2953.          dImage.cb=sizeof(DRAGIMAGE);
  2954.          dImage.hImage=pAreaListData->icnFolder;
  2955.          dImage.fl=DRG_ICON;
  2956.          dImage.cxOffset=0;
  2957.          dImage.cyOffset=0;
  2958.  
  2959.          hwndDrop = DrgDrag(hwndDlg, pDraginfo, &dImage, 1, VK_ENDDRAG, NULL);
  2960.          DrgFreeDraginfo(pDraginfo);
  2961.  
  2962.          if (hwndDrop)
  2963.          {
  2964.             if (pAreaListData->pOpenFolder)
  2965.             {
  2966.                FolderAnchor.LastFolder = pAreaListData->pOpenFolder->pAreaFolder->FolderID;
  2967.                pAreaListData->pOpenFolder = NULL;
  2968.             }
  2969.  
  2970.             /* neu anzeigen */
  2971.             SendMsg(hwndCnr, CM_REMOVERECORD, NULL, MPFROM2SHORT(0, CMA_FREE));
  2972.             InitFolderContainer(hwndDlg, pAreaListData);
  2973.          }
  2974.          else
  2975.             /* Source emphasis wegnehmen */
  2976.             SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord, MPFROM2SHORT(FALSE, CRA_SOURCE));
  2977.       }
  2978.    }
  2979. }
  2980.  
  2981. static void UpdateScannedFolders(HWND hwndDlg, PAREALISTDATA pAreaListData)
  2982. {
  2983.    HWND hwndCnr = WinWindowFromID(hwndDlg, IDD_AREALIST+4);
  2984.  
  2985.    if (pAreaListData->pOpenFolder)
  2986.    {
  2987.       FolderAnchor.LastFolder = pAreaListData->pOpenFolder->pAreaFolder->FolderID;
  2988.       pAreaListData->pOpenFolder = NULL;
  2989.    }
  2990.  
  2991.    SendMsg(hwndCnr, CM_REMOVERECORD, NULL, MPFROM2SHORT(0, CMA_FREE));
  2992.    InitFolderContainer(hwndDlg, pAreaListData);
  2993.  
  2994.    return;
  2995. }
  2996.  
  2997. static BOOL FolderHasUnreadAreas(PAREAFOLDER pFolder)
  2998. {
  2999.    PAREADEFLIST pArea = arealiste.pFirstArea;
  3000.  
  3001.    while (pArea)
  3002.    {
  3003.       if (pArea->areadata.ulFolderID == pFolder->FolderID &&
  3004.           pArea->scanned &&
  3005.           pArea->currentmessage < pArea->maxmessages)
  3006.          return TRUE;
  3007.  
  3008.       pArea = pArea->next;
  3009.    }
  3010.  
  3011.    return FALSE;
  3012. }
  3013. /*--------------------------------- Modulende -------------------------------*/
  3014.  
  3015.