home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / templatedlg.c < prev    next >
C/C++ Source or Header  |  1999-02-14  |  82KB  |  2,107 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: TEMPLATEDLG.C                                                      |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 05.09.93                    |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x PM                                                       |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |    Template-Setup-Dialoge                                                 |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18. #pragma strings(readonly)
  19.  
  20. #define INCL_PM
  21. #include <os2.h>
  22. #include <string.h>
  23. #include <stdlib.h>
  24. #include "main.h"
  25. #include "resids.h"
  26. #include "messages.h"
  27. #include "structs.h"
  28. #include "msgheader.h"
  29. #include "areaman\areaman.h"
  30. #include "dialogids.h"
  31. #include "templatedlg.h"
  32. #include "setupdlg.h"
  33. #include "utility.h"
  34.  
  35. /*--------------------------------- Defines ---------------------------------*/
  36.  
  37. #ifndef CRA_SOURCE
  38. #define CRA_SOURCE  0x00004000L
  39. #endif
  40.  
  41. #define NUM_PAGES_TEMPLATE  11
  42. #define MAXLEN_STRING    512
  43.  
  44. #define UNREG_TEMPLATES  3
  45.  
  46. #define TPLDRAGTYPE "FleetStreet Template"
  47. #define TPLDRAGRMF  "(DRM_FLEET,DRM_DISCARD)x(DRF_FLEETTEMPLATE)"
  48. #define TPLDRAGRMFRO "<DRM_FLEET,DRF_FLEETTEMPLATE>"
  49.  
  50. typedef struct {
  51.            MINIRECORDCORE RecordCore;
  52.            HWND           hwndSettings;
  53.            PMSGTEMPLATE   pTemplate;
  54.         } TPLRECORD, *PTPLRECORD;
  55.  
  56. typedef struct {
  57.            USHORT        cb;
  58.            PMSGTEMPLATE  pTemplate;
  59.         } OPENTEMPLATE, *POPENTEMPLATE;
  60.  
  61. typedef struct {
  62.            PTPLRECORD    pPopupRecord;
  63.            PTPLRECORD    pDragRecord;
  64.            HWND          hwndPopup;
  65.            HWND          hwndPopup2;
  66.            HPOINTER      hptrTemplate;
  67.            HPOINTER      hptrDefTemplate;
  68.            HPOINTER      hptrTemplateFolder;
  69.            BOOL          bNotify;
  70.            HSWITCH       hSwitch;
  71.            BOOL          bForeground;
  72.         } TPLFOLDERDATA, *PTPLFOLDERDATA;
  73.  
  74. typedef struct {
  75.            PMSGTEMPLATE pTemplate;
  76.            HWND         notebook;
  77.            NBPAGE       PageTable[NUM_PAGES_TEMPLATE];
  78.            BOOL         bNotify;
  79.         } TEMPLATEBOOKDATA, *PTEMPLATEBOOKDATA;
  80.  
  81.  
  82. /*---------------------------- Globale Variablen ----------------------------*/
  83.  
  84. extern HMODULE hmodLang;
  85. extern HAB anchor;
  86. extern DIRTYFLAGS dirtyflags;
  87. extern HWND hwndTemplates;
  88.  
  89. static PFNWP OldTplProc;
  90.  
  91. /*--------------------------- Funktionsprototypen ---------------------------*/
  92.  
  93. static void InsertTemplatePages(HWND notebook, NBPAGE *Table);
  94. static MRESULT EXPENTRY TEQuoteProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  95. static MRESULT EXPENTRY TEHeaderProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  96. static MRESULT EXPENTRY TEFooterProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  97. static MRESULT EXPENTRY TEReplyProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  98. static MRESULT EXPENTRY TEDAreaProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  99. static MRESULT EXPENTRY TEForwardProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  100. static MRESULT EXPENTRY TEForwardFooterProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  101. static MRESULT EXPENTRY TEForwardOrderProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  102. static MRESULT EXPENTRY TEXPostProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  103. static MRESULT EXPENTRY TECCopyProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  104. static MRESULT EXPENTRY TEOriginProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2);
  105.  
  106. static PTPLRECORD AddEmptyTemplate(HWND hwndContainer, HPOINTER hptr);
  107. static int HaveTemplateName(PVOID pTemplateList, char *pchName);
  108. static PTPLRECORD CopyTemplate(HWND hwndContainer, HPOINTER hptr, PMSGTEMPLATE pOldTpl);
  109. static int FillTemplateFolder(HWND hwndContainer, HPOINTER hptr, HPOINTER hptrDef);
  110. static int OpenTemplate(HWND hwndContainer, PTPLRECORD pTplRecord);
  111. static int DeleteTemplate(HWND hwndContainer, PTPLRECORD pTplRecord);
  112. static int CleanupTemplateFolder(HWND hwndContainer);
  113. static int InitTemplateDrag(HWND hwndDlg, PCNRDRAGINIT pInit);
  114. static MRESULT EXPENTRY NewTplProc(HWND hwnd, ULONG message, MPARAM mp1, MPARAM mp2);
  115. static void TemplateClosed(HWND hwndCnr, ULONG ulTemplateID);
  116. static MRESULT TemplateDragover(HWND hwnd, PCNRDRAGINFO pDragOver);
  117. static void TemplateDrop(HWND hwnd, PCNRDRAGINFO pCnrDrop, PTPLFOLDERDATA pTplFolderData);
  118.  
  119.  
  120. static const struct pagedef
  121. {
  122.    ULONG ulStringID;
  123.    ULONG resID;
  124.    PFNWP DlgProc;
  125. } PageDef[] =
  126. {
  127.    { IDST_TAB_QUOTE,         IDD_TE_QUOTE,         TEQuoteProc},
  128.    { IDST_TAB_HEADER,        IDD_TE_HEADER,        TEHeaderProc},
  129.    { IDST_TAB_FOOTER,        IDD_TE_FOOTER,        TEFooterProc},
  130.    { IDST_TAB_REPLY,         IDD_TE_REPLY,         TEReplyProc},
  131.    { IDST_TAB_DAREA,         IDD_TE_DAREA,         TEDAreaProc},
  132.    { IDST_TAB_FORWARD,       IDD_TE_FORWARD,       TEForwardProc},
  133.    { IDST_TAB_FORWARDFOOTER, IDD_TE_FORWARDFOOTER, TEForwardFooterProc},
  134.    { IDST_TAB_FORWARDORDER,  IDD_TE_FORWARDORDER,  TEForwardOrderProc},
  135.    { IDST_TAB_XPOST,         IDD_TE_XPOST,         TEXPostProc},
  136.    { IDST_TAB_CCOPY,         IDD_TE_CCOPY,         TECCopyProc},
  137.    { IDST_TAB_ORIGIN,        IDD_TE_ORIGIN,        TEOriginProc}
  138. };
  139.  
  140. /*------------------------------ TemplateBookProc ---------------------------*/
  141. /* Notebook-Dialog des Message-Templates                                     */
  142. /*---------------------------------------------------------------------------*/
  143.  
  144. MRESULT EXPENTRY TemplateBookProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  145. {
  146.    extern HWND hwndhelp;
  147.  
  148.    POPENTEMPLATE pOpenTemplate;
  149.    extern TEMPLATELIST templatelist;
  150.    PTEMPLATEBOOKDATA pTplBookData = (PTEMPLATEBOOKDATA) WinQueryWindowULong(parent, QWL_USER);
  151.    MRESULT resultbuf=0;
  152.  
  153.    switch(message)
  154.    {
  155.       case WM_INITDLG:
  156.          /* Leere Seitentabelle */
  157.          pTplBookData = malloc(sizeof(TEMPLATEBOOKDATA));
  158.          memset(pTplBookData, 0, sizeof(TEMPLATEBOOKDATA));
  159.          WinSetWindowULong(parent, QWL_USER, (ULONG) pTplBookData);
  160.  
  161.          pTplBookData->notebook = WinWindowFromID(parent, IDD_TEMPLATE+1);
  162.  
  163.          /* Leere Seiten einfuegen */
  164.          InsertTemplatePages(pTplBookData->notebook, pTplBookData->PageTable);
  165.  
  166.          pOpenTemplate = (POPENTEMPLATE) mp2;
  167.          pTplBookData->pTemplate = pOpenTemplate->pTemplate;
  168.  
  169.          /* Titel */
  170.          WinSetWindowText(parent, pTplBookData->pTemplate->TName);
  171.  
  172.          /* erste Seite gleich anzeigen */
  173.          LoadPage(pTplBookData->notebook, &(pTplBookData->PageTable[0]), pOpenTemplate);
  174.  
  175.          RestoreWinPos(parent, &pTplBookData->pTemplate->TPos, TRUE, TRUE);
  176.          pTplBookData->bNotify = TRUE;
  177.          break;
  178.  
  179.       case WM_DESTROY:
  180.          free(pTplBookData);
  181.          break;
  182.  
  183.       case WM_ADJUSTFRAMEPOS:
  184.          SizeToClient(anchor, (PSWP) mp1, parent, IDD_TEMPLATE+1);
  185.          break;
  186.  
  187.       case WM_WINDOWPOSCHANGED:
  188.          if (pTplBookData && pTplBookData->bNotify)
  189.          {
  190.             if (SaveWinPos(parent, (PSWP) mp1, &pTplBookData->pTemplate->TPos, &pTplBookData->pTemplate->bDirty))
  191.                templatelist.bDirty = TRUE;
  192.          }
  193.          break;
  194.  
  195.       case WM_QUERYTRACKINFO:
  196.          /* Default-Werte aus Original-Prozedur holen */
  197.          resultbuf=WinDefDlgProc(parent,message,mp1,mp2);
  198.  
  199.          /* Minimale Fenstergroesse einstellen */
  200.          ((PTRACKINFO)mp2)->ptlMinTrackSize.x=490;
  201.          ((PTRACKINFO)mp2)->ptlMinTrackSize.y=350;
  202.  
  203.          return resultbuf;
  204.  
  205.       case WM_CLOSE:
  206.          WinPostMsg(hwndTemplates, TPL_CLOSE,
  207.                     MPFROMLONG(pTplBookData->pTemplate->ulID), NULL);
  208.          break;
  209.  
  210.       case WM_ACTIVATE:
  211.          if (mp1)
  212.             WinAssociateHelpInstance(hwndhelp, parent);
  213.          else
  214.             WinAssociateHelpInstance(hwndhelp, NULLHANDLE);
  215.          break;
  216.  
  217.       case WM_CONTROL:
  218.          if (SHORT1FROMMP(mp1)==IDD_TEMPLATE+1)
  219.             if (SHORT2FROMMP(mp1)==BKN_PAGESELECTED)
  220.             {
  221.                int i=0;
  222.                /* Seitenwechsel */
  223.                /* neue Seite in Seiten-Tabelle suchen */
  224.                while (i<NUM_PAGES_TEMPLATE)
  225.                {
  226.                   if (pTplBookData->PageTable[i].PageID == ((PPAGESELECTNOTIFY)mp2)->ulPageIdNew)
  227.                      break;
  228.                   else
  229.                      i++;
  230.                }
  231.  
  232.                /* Seite ggf. Laden */
  233.                if (i<NUM_PAGES_TEMPLATE && pTplBookData->PageTable[i].hwndPage==NULLHANDLE)
  234.                {
  235.                   OPENTEMPLATE OpenTemplate;
  236.  
  237.                   OpenTemplate.cb = sizeof(OpenTemplate);
  238.                   OpenTemplate.pTemplate = pTplBookData->pTemplate;
  239.                   LoadPage(pTplBookData->notebook, &(pTplBookData->PageTable[i]), &OpenTemplate);
  240.                }
  241.             }
  242.          break;
  243.  
  244.       default:
  245.          break;
  246.    }
  247.    return WinDefDlgProc(parent, message, mp1, mp2);
  248. }
  249.  
  250. /*---------------------------- InsertTemplatePages --------------------------*/
  251. /* Fuegt alle Seiten in das Notebook ein, Einstellung der Darstellungs-      */
  252. /* Parameter des Notebooks                                                   */
  253. /*---------------------------------------------------------------------------*/
  254.  
  255. #define NUM_INS_PAGES (sizeof(PageDef)/sizeof(PageDef[0]))
  256.  
  257. static void InsertTemplatePages(HWND notebook, NBPAGE *Table)
  258. {
  259.    int i;
  260.  
  261.    SetNotebookParams(notebook, 120);
  262.  
  263.    /* Leere Seiten einfuegen, Tabelle fuellen */
  264.    for (i=0; i<NUM_INS_PAGES; i++)
  265.    {
  266.       InsertEmptyPage(notebook, PageDef[i].ulStringID, &(Table[i]));
  267.       Table[i].resID=PageDef[i].resID;
  268.       Table[i].DlgProc=PageDef[i].DlgProc;
  269.    }
  270.  
  271.    return;
  272. }
  273.  
  274. /*------------------------------ TEQuoteProc      ---------------------------*/
  275. /* Dialogseite Quotes                                                        */
  276. /*---------------------------------------------------------------------------*/
  277.  
  278. static MRESULT EXPENTRY TEQuoteProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  279. {
  280.    BOOL bTemp;
  281.    LONG lTemp;
  282.    extern TEMPLATELIST templatelist;
  283.    POPENTEMPLATE pOpenTemplate;
  284.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  285.    static char *QuoteChars[] = {">", ":", "|"};
  286.  
  287.    switch (message)
  288.    {
  289.       case WM_INITDLG:
  290.          pOpenTemplate = (POPENTEMPLATE) mp2;
  291.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  292.          pTemplate = pOpenTemplate->pTemplate;
  293.  
  294.          WinSendDlgItemMsg(parent,IDD_TE_QUOTE+6, SPBM_SETLIMITS,
  295.                            MPFROMLONG(80), MPFROMLONG(50));
  296.          WinSendDlgItemMsg(parent, IDD_TE_QUOTE+6, SPBM_SETCURRENTVALUE,
  297.                            MPFROMLONG(pTemplate->quotelinelen), NULL);
  298.          WinSendDlgItemMsg(parent,IDD_TE_QUOTE+9, SPBM_SETLIMITS,
  299.                            MPFROMLONG(80), MPFROMLONG(50));
  300.          WinSendDlgItemMsg(parent, IDD_TE_QUOTE+9, SPBM_SETCURRENTVALUE,
  301.                            MPFROMLONG(pTemplate->joinlen), NULL);
  302.          WinCheckButton(parent, IDD_TE_QUOTE+2, pTemplate->useinitials);
  303.          WinCheckButton(parent, IDD_TE_QUOTE+3, !pTemplate->useinitials);
  304.  
  305.          /* Quote-Zeichen */
  306.          WinSendDlgItemMsg(parent, IDD_TE_QUOTE+11, SPBM_SETARRAY,
  307.                            QuoteChars,
  308.                            MPFROMSHORT(sizeof(QuoteChars)/sizeof(QuoteChars[0])));
  309.          for (lTemp = 0; lTemp <sizeof(QuoteChars)/sizeof(QuoteChars[0]); lTemp++)
  310.          {
  311.             if (QuoteChars[lTemp][0] == pTemplate->chQuoteChar)
  312.             {
  313.                WinSendDlgItemMsg(parent, IDD_TE_QUOTE+11, SPBM_SETCURRENTVALUE,
  314.                                  MPFROMLONG(lTemp), NULL);
  315.                break;
  316.             }
  317.          }
  318.  
  319.          SetFocusControl(parent, IDD_TE_QUOTE+6);
  320.          return (MRESULT) TRUE;
  321.  
  322.       case WM_COMMAND:
  323.          return (MRESULT) FALSE;
  324.  
  325.       case WM_CONTROL:
  326.          switch (SHORT1FROMMP(mp1))
  327.          {
  328.             /* Spin-Button */
  329.             case IDD_TE_QUOTE+9:
  330.             case IDD_TE_QUOTE+6:
  331.                if (!SendMsg((HWND)mp2, SPBM_QUERYVALUE,
  332.                                       MPFROMP(&lTemp),
  333.                                       MPFROM2SHORT((USHORT)0, SPBQ_ALWAYSUPDATE)))
  334.                   DosBeep(1000,100);
  335.                break;
  336.  
  337.             default:
  338.                break;
  339.          }
  340.          break;
  341.  
  342.       case WM_DESTROY:
  343.       case WM_CLOSE:
  344.          bTemp=WinQueryButtonCheckstate(parent, IDD_TE_QUOTE+2);
  345.          if (pTemplate->useinitials != bTemp)
  346.          {
  347.             pTemplate->useinitials = bTemp;
  348.             pTemplate->bDirty=TRUE;
  349.             templatelist.bDirty=TRUE;
  350.          }
  351.          WinSendDlgItemMsg(parent, IDD_TE_QUOTE+6, SPBM_QUERYVALUE,
  352.                        MPFROMP(&lTemp),
  353.                        MPFROM2SHORT((USHORT)0, SPBQ_ALWAYSUPDATE));
  354.          if (pTemplate->quotelinelen != lTemp)
  355.          {
  356.             pTemplate->quotelinelen = lTemp;
  357.             pTemplate->bDirty=TRUE;
  358.             templatelist.bDirty=TRUE;
  359.          }
  360.          WinSendDlgItemMsg(parent, IDD_TE_QUOTE+9, SPBM_QUERYVALUE,
  361.                        MPFROMP(&lTemp),
  362.                        MPFROM2SHORT((USHORT)0, SPBQ_ALWAYSUPDATE));
  363.          if (pTemplate->joinlen != lTemp)
  364.          {
  365.             pTemplate->joinlen = lTemp;
  366.             pTemplate->bDirty=TRUE;
  367.             templatelist.bDirty=TRUE;
  368.          }
  369.          {
  370.             char chNewChar[2];
  371.  
  372.             WinSendDlgItemMsg(parent, IDD_TE_QUOTE+11, SPBM_QUERYVALUE,
  373.                               chNewChar,
  374.                               MPFROM2SHORT(sizeof(chNewChar), SPBQ_ALWAYSUPDATE));
  375.  
  376.             if (pTemplate->chQuoteChar != chNewChar[0])
  377.             {
  378.                pTemplate->chQuoteChar = chNewChar[0];
  379.                pTemplate->bDirty=TRUE;
  380.                templatelist.bDirty=TRUE;
  381.             }
  382.          }
  383.          break;
  384.  
  385.       default:
  386.          break;
  387.    }
  388.    return WinDefDlgProc(parent, message, mp1, mp2);
  389. }
  390.  
  391. /*------------------------------ TEHeaderProc     ---------------------------*/
  392. /* Dialogseite Header                                                        */
  393. /*---------------------------------------------------------------------------*/
  394.  
  395. static MRESULT EXPENTRY TEHeaderProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  396. {
  397.    extern TEMPLATELIST templatelist;
  398.    POPENTEMPLATE pOpenTemplate;
  399.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  400.  
  401.    switch (message)
  402.    {
  403.       case WM_INITDLG:
  404.          pOpenTemplate = (POPENTEMPLATE) mp2;
  405.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  406.          pTemplate = pOpenTemplate->pTemplate;
  407.  
  408.          if (pTemplate->THeader)
  409.             WinSetDlgItemText(parent, IDD_TE_HEADER+3, pTemplate->THeader);
  410.          WinSendDlgItemMsg(parent, IDD_TE_HEADER+5, EM_SETTEXTLIMIT, MPFROMSHORT(LEN_USERNAME), NULL);
  411.          WinSetDlgItemText(parent, IDD_TE_HEADER+5, pTemplate->TAllSyn);
  412.          break;
  413.  
  414.       case WM_COMMAND:
  415.          return (MRESULT) FALSE;
  416.  
  417.       case WM_CONTROL:
  418.          break;
  419.  
  420.       case WM_DESTROY:
  421.       case WM_CLOSE:
  422.          {
  423.             ULONG textlen;
  424.             char *pchTemp;
  425.             char pchAllSyn[LEN_USERNAME+1]="";
  426.  
  427.             textlen=WinQueryDlgItemTextLength(parent, IDD_TE_HEADER+3);
  428.             if (textlen)
  429.             {
  430.                pchTemp=malloc(textlen+1);
  431.                WinQueryDlgItemText(parent, IDD_TE_HEADER+3, textlen+1, pchTemp);
  432.                if (strcmp(pchTemp, pTemplate->THeader))
  433.                {
  434.                   free(pTemplate->THeader);
  435.                   pTemplate->THeader=pchTemp;
  436.                   pTemplate->bDirty = TRUE;
  437.                   templatelist.bDirty=TRUE;
  438.                }
  439.                else
  440.                   free(pchTemp);
  441.             }
  442.             else
  443.             {
  444.                if (pTemplate->THeader[0])
  445.                {
  446.                   pTemplate->THeader[0]='\0';
  447.                   pTemplate->bDirty = TRUE;
  448.                   templatelist.bDirty=TRUE;
  449.                }
  450.             }
  451.  
  452.             WinQueryDlgItemText(parent, IDD_TE_HEADER+5, sizeof(pchAllSyn), pchAllSyn);
  453.             if (strcmp(pTemplate->TAllSyn, pchAllSyn))
  454.             {
  455.                strcpy(pTemplate->TAllSyn, pchAllSyn);
  456.                pTemplate->bDirty = TRUE;
  457.                templatelist.bDirty=TRUE;
  458.             }
  459.          }
  460.          break;
  461.  
  462.       default:
  463.          break;
  464.    }
  465.    return WinDefDlgProc(parent, message, mp1, mp2);
  466. }
  467.  
  468. /*------------------------------ TEFooterProc     ---------------------------*/
  469. /* Dialogseite Footer                                                        */
  470. /*---------------------------------------------------------------------------*/
  471.  
  472. static MRESULT EXPENTRY TEFooterProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  473. {
  474.    ULONG textlen;
  475.    char *pchTemp;
  476.    extern TEMPLATELIST templatelist;
  477.    POPENTEMPLATE pOpenTemplate;
  478.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  479.  
  480.    switch (message)
  481.    {
  482.       case WM_INITDLG:
  483.          pOpenTemplate = (POPENTEMPLATE) mp2;
  484.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  485.          pTemplate = pOpenTemplate->pTemplate;
  486.  
  487.          if (pTemplate->TFooter)
  488.             WinSetDlgItemText(parent, IDD_TE_FOOTER+3, pTemplate->TFooter);
  489.          break;
  490.  
  491.       case WM_COMMAND:
  492.          return (MRESULT) FALSE;
  493.  
  494.       case WM_CONTROL:
  495.          break;
  496.  
  497.       case WM_DESTROY:
  498.       case WM_CLOSE:
  499.          textlen=WinQueryDlgItemTextLength(parent, IDD_TE_FOOTER+3);
  500.          if (textlen)
  501.          {
  502.             pchTemp=malloc(textlen+1);
  503.             WinQueryDlgItemText(parent, IDD_TE_FOOTER+3, textlen+1, pchTemp);
  504.             if (strcmp(pchTemp, pTemplate->TFooter))
  505.             {
  506.                free(pTemplate->TFooter);
  507.                pTemplate->TFooter=pchTemp;
  508.                pTemplate->bDirty=TRUE;
  509.                templatelist.bDirty = TRUE;
  510.             }
  511.             else
  512.                free(pchTemp);
  513.          }
  514.          else
  515.          {
  516.             if (pTemplate->TFooter[0])
  517.             {
  518.                pTemplate->TFooter[0]='\0';
  519.                pTemplate->bDirty = TRUE;
  520.                templatelist.bDirty=TRUE;
  521.             }
  522.          }
  523.          break;
  524.  
  525.       default:
  526.          break;
  527.    }
  528.    return WinDefDlgProc(parent, message, mp1, mp2);
  529. }
  530.  
  531. /*------------------------------ TEReplyProc      ---------------------------*/
  532. /* Dialogseite Reply                                                         */
  533. /*---------------------------------------------------------------------------*/
  534.  
  535. static MRESULT EXPENTRY TEReplyProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  536. {
  537.    ULONG textlen;
  538.    char *pchTemp;
  539.    extern TEMPLATELIST templatelist;
  540.    POPENTEMPLATE pOpenTemplate;
  541.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  542.  
  543.    switch (message)
  544.    {
  545.       case WM_INITDLG:
  546.          pOpenTemplate = (POPENTEMPLATE) mp2;
  547.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  548.          pTemplate = pOpenTemplate->pTemplate;
  549.          if (pTemplate->TReply)
  550.             WinSetDlgItemText(parent, IDD_TE_REPLY+3, pTemplate->TReply);
  551.          break;
  552.  
  553.       case WM_COMMAND:
  554.          return (MRESULT) FALSE;
  555.  
  556.       case WM_CONTROL:
  557.          break;
  558.  
  559.       case WM_DESTROY:
  560.       case WM_CLOSE:
  561.          textlen=WinQueryDlgItemTextLength(parent, IDD_TE_REPLY+3);
  562.          if (textlen)
  563.          {
  564.             pchTemp=malloc(textlen+1);
  565.             WinQueryDlgItemText(parent, IDD_TE_REPLY+3, textlen+1, pchTemp);
  566.             if (strcmp(pchTemp, pTemplate->TReply))
  567.             {
  568.                free(pTemplate->TReply);
  569.                pTemplate->TReply=pchTemp;
  570.                pTemplate->bDirty=TRUE;
  571.                templatelist.bDirty = TRUE;
  572.             }
  573.             else
  574.                free(pchTemp);
  575.          }
  576.          else
  577.          {
  578.             if (pTemplate->TReply[0])
  579.             {
  580.                pTemplate->TReply[0]='\0';
  581.                pTemplate->bDirty = TRUE;
  582.                templatelist.bDirty=TRUE;
  583.             }
  584.          }
  585.          break;
  586.  
  587.       default:
  588.          break;
  589.    }
  590.    return WinDefDlgProc(parent, message, mp1, mp2);
  591. }
  592.  
  593. /*------------------------------ TEDAreaProc      ---------------------------*/
  594. /* Dialogseite DArea                                                         */
  595. /*---------------------------------------------------------------------------*/
  596.  
  597. static MRESULT EXPENTRY TEDAreaProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  598. {
  599.    ULONG textlen;
  600.    char *pchTemp;
  601.    extern TEMPLATELIST templatelist;
  602.    POPENTEMPLATE pOpenTemplate;
  603.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  604.  
  605.    switch (message)
  606.    {
  607.       case WM_INITDLG:
  608.          pOpenTemplate = (POPENTEMPLATE) mp2;
  609.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  610.          pTemplate = pOpenTemplate->pTemplate;
  611.  
  612.          WinSendDlgItemMsg(parent, IDD_TE_DAREA+3, EM_SETTEXTLIMIT,
  613.                            MPFROMSHORT(80), NULL);
  614.          if (pTemplate->TDArea)
  615.             WinSetDlgItemText(parent, IDD_TE_DAREA+3, pTemplate->TDArea);
  616.          break;
  617.  
  618.       case WM_COMMAND:
  619.          return (MRESULT) FALSE;
  620.  
  621.       case WM_CONTROL:
  622.          break;
  623.  
  624.       case WM_DESTROY:
  625.       case WM_CLOSE:
  626.          textlen=WinQueryDlgItemTextLength(parent, IDD_TE_DAREA+3);
  627.          if (textlen)
  628.          {
  629.             pchTemp=malloc(textlen+1);
  630.             WinQueryDlgItemText(parent, IDD_TE_DAREA+3, textlen+1, pchTemp);
  631.             if (strcmp(pchTemp, pTemplate->TDArea))
  632.             {
  633.                free(pTemplate->TDArea);
  634.                pTemplate->TDArea=pchTemp;
  635.                pTemplate->bDirty=TRUE;
  636.                templatelist.bDirty=TRUE;
  637.             }
  638.             else
  639.                free(pchTemp);
  640.          }
  641.          else
  642.          {
  643.             if (pTemplate->TDArea[0])
  644.             {
  645.                pTemplate->TDArea[0]='\0';
  646.                pTemplate->bDirty = TRUE;
  647.                templatelist.bDirty=TRUE;
  648.             }
  649.          }
  650.          break;
  651.  
  652.       default:
  653.          break;
  654.    }
  655.    return WinDefDlgProc(parent, message, mp1, mp2);
  656. }
  657.  
  658. /*------------------------------ TEForwardProc    ---------------------------*/
  659. /* Dialogseite Forward                                                       */
  660. /*---------------------------------------------------------------------------*/
  661.  
  662. static MRESULT EXPENTRY TEForwardProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  663. {
  664.    ULONG textlen;
  665.    char *pchTemp;
  666.    extern TEMPLATELIST templatelist;
  667.    POPENTEMPLATE pOpenTemplate;
  668.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  669.  
  670.    switch (message)
  671.    {
  672.       case WM_INITDLG:
  673.          pOpenTemplate = (POPENTEMPLATE) mp2;
  674.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  675.          pTemplate = pOpenTemplate->pTemplate;
  676.          if (pTemplate->TForward)
  677.             WinSetDlgItemText(parent, IDD_TE_FORWARD+3, pTemplate->TForward);
  678.          break;
  679.  
  680.       case WM_COMMAND:
  681.          return (MRESULT) FALSE;
  682.  
  683.       case WM_CONTROL:
  684.          break;
  685.  
  686.       case WM_DESTROY:
  687.       case WM_CLOSE:
  688.          textlen=WinQueryDlgItemTextLength(parent, IDD_TE_FORWARD+3);
  689.          if (textlen)
  690.          {
  691.             pchTemp=malloc(textlen+1);
  692.             WinQueryDlgItemText(parent, IDD_TE_FORWARD+3, textlen+1, pchTemp);
  693.             if (strcmp(pchTemp, pTemplate->TForward))
  694.             {
  695.                free(pTemplate->TForward);
  696.                pTemplate->TForward=pchTemp;
  697.                pTemplate->bDirty = TRUE;
  698.                templatelist.bDirty=TRUE;
  699.             }
  700.             else
  701.                free(pchTemp);
  702.          }
  703.          else
  704.          {
  705.             if (pTemplate->TForward[0])
  706.             {
  707.                pTemplate->TForward[0]='\0';
  708.                pTemplate->bDirty = TRUE;
  709.                templatelist.bDirty=TRUE;
  710.             }
  711.          }
  712.          break;
  713.  
  714.       default:
  715.          break;
  716.    }
  717.    return WinDefDlgProc(parent, message, mp1, mp2);
  718. }
  719.  
  720. /*------------------------------ TEForwardFooterProc-------------------------*/
  721. /* Dialogseite Forward-Footer                                                */
  722. /*---------------------------------------------------------------------------*/
  723.  
  724. static MRESULT EXPENTRY TEForwardFooterProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  725. {
  726.    ULONG textlen;
  727.    char *pchTemp;
  728.    extern TEMPLATELIST templatelist;
  729.    POPENTEMPLATE pOpenTemplate;
  730.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  731.  
  732.    switch (message)
  733.    {
  734.       case WM_INITDLG:
  735.          pOpenTemplate = (POPENTEMPLATE) mp2;
  736.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  737.          pTemplate = pOpenTemplate->pTemplate;
  738.  
  739.          if (pTemplate->TForwardFooter)
  740.             WinSetDlgItemText(parent, IDD_TE_FORWARDFOOTER+3, pTemplate->TForwardFooter);
  741.          break;
  742.  
  743.       case WM_COMMAND:
  744.          return (MRESULT) FALSE;
  745.  
  746.       case WM_CONTROL:
  747.          break;
  748.  
  749.       case WM_DESTROY:
  750.       case WM_CLOSE:
  751.          textlen=WinQueryDlgItemTextLength(parent, IDD_TE_FORWARDFOOTER+3);
  752.          if (textlen)
  753.          {
  754.             pchTemp=malloc(textlen+1);
  755.             WinQueryDlgItemText(parent, IDD_TE_FORWARDFOOTER+3, textlen+1, pchTemp);
  756.             if (strcmp(pchTemp, pTemplate->TForwardFooter))
  757.             {
  758.                free(pTemplate->TForwardFooter);
  759.                pTemplate->TForwardFooter=pchTemp;
  760.                pTemplate->bDirty = TRUE;
  761.                templatelist.bDirty=TRUE;
  762.             }
  763.             else
  764.                free(pchTemp);
  765.          }
  766.          else
  767.          {
  768.             if (pTemplate->TForwardFooter[0])
  769.             {
  770.                pTemplate->TForwardFooter[0]='\0';
  771.                pTemplate->bDirty = TRUE;
  772.                templatelist.bDirty=TRUE;
  773.             }
  774.          }
  775.          break;
  776.  
  777.       default:
  778.          break;
  779.    }
  780.    return WinDefDlgProc(parent, message, mp1, mp2);
  781. }
  782.  
  783. /*------------------------------ TEForwardOrderProc -------------------------*/
  784. /* Dialogseite Forward-Order                                                 */
  785. /*---------------------------------------------------------------------------*/
  786.  
  787. static MRESULT EXPENTRY TEForwardOrderProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  788. {
  789.    BOOL bTemp;
  790.    extern TEMPLATELIST templatelist;
  791.    POPENTEMPLATE pOpenTemplate;
  792.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  793.  
  794.    switch (message)
  795.    {
  796.       case WM_INITDLG:
  797.          pOpenTemplate = (POPENTEMPLATE) mp2;
  798.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  799.          pTemplate = pOpenTemplate->pTemplate;
  800.  
  801.          if (pTemplate->forwardfirst)
  802.          {
  803.             WinCheckButton(parent, IDD_TE_FORWARDORDER+3, FALSE);
  804.             WinCheckButton(parent, IDD_TE_FORWARDORDER+4, TRUE);
  805.          }
  806.          else
  807.          {
  808.             WinCheckButton(parent, IDD_TE_FORWARDORDER+3, TRUE);
  809.             WinCheckButton(parent, IDD_TE_FORWARDORDER+4, FALSE);
  810.          }
  811.          SetFocusControl(parent, IDD_TE_FORWARDORDER+3);
  812.          return (MRESULT) TRUE;
  813.  
  814.       case WM_DESTROY:
  815.          bTemp=WinQueryButtonCheckstate(parent, IDD_TE_FORWARDORDER+4);
  816.          if (pTemplate->forwardfirst != bTemp)
  817.          {
  818.             pTemplate->forwardfirst = bTemp;
  819.             pTemplate->bDirty = TRUE;
  820.             templatelist.bDirty=TRUE;
  821.          }
  822.          break;
  823.  
  824.       default:
  825.          break;
  826.    }
  827.    return WinDefDlgProc(parent, message, mp1, mp2);
  828. }
  829.  
  830. /*------------------------------ TEXPostProc      ---------------------------*/
  831. /* Dialogseite XPost                                                         */
  832. /*---------------------------------------------------------------------------*/
  833.  
  834. static MRESULT EXPENTRY TEXPostProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  835. {
  836.    ULONG textlen;
  837.    char *pchTemp;
  838.    extern TEMPLATELIST templatelist;
  839.    POPENTEMPLATE pOpenTemplate;
  840.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  841.  
  842.    switch (message)
  843.    {
  844.       case WM_INITDLG:
  845.          pOpenTemplate = (POPENTEMPLATE) mp2;
  846.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  847.          pTemplate = pOpenTemplate->pTemplate;
  848.  
  849.          WinSendDlgItemMsg(parent, IDD_TE_XPOST+3, EM_SETTEXTLIMIT,
  850.                            MPFROMSHORT(80), NULL);
  851.          if (pTemplate->TXPost)
  852.             WinSetDlgItemText(parent, IDD_TE_XPOST+3, pTemplate->TXPost);
  853.          break;
  854.  
  855.       case WM_COMMAND:
  856.          return (MRESULT) FALSE;
  857.  
  858.       case WM_CONTROL:
  859.          break;
  860.  
  861.       case WM_DESTROY:
  862.       case WM_CLOSE:
  863.          textlen=WinQueryDlgItemTextLength(parent, IDD_TE_XPOST+3);
  864.          if (textlen)
  865.          {
  866.             pchTemp=malloc(textlen+1);
  867.             WinQueryDlgItemText(parent, IDD_TE_XPOST+3, textlen+1, pchTemp);
  868.             if (strcmp(pchTemp, pTemplate->TXPost))
  869.             {
  870.                free(pTemplate->TXPost);
  871.                pTemplate->TXPost=pchTemp;
  872.                pTemplate->bDirty=TRUE;
  873.                templatelist.bDirty=TRUE;
  874.             }
  875.             else
  876.                free(pchTemp);
  877.          }
  878.          else
  879.          {
  880.             if (pTemplate->TXPost[0])
  881.             {
  882.                pTemplate->TXPost[0]='\0';
  883.                pTemplate->bDirty = TRUE;
  884.                templatelist.bDirty=TRUE;
  885.             }
  886.          }
  887.          break;
  888.  
  889.       default:
  890.          break;
  891.    }
  892.    return WinDefDlgProc(parent, message, mp1, mp2);
  893. }
  894.  
  895. /*------------------------------ TECCopyProc      ---------------------------*/
  896. /* Dialogseite CCopy                                                         */
  897. /*---------------------------------------------------------------------------*/
  898.  
  899. static MRESULT EXPENTRY TECCopyProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  900. {
  901.    ULONG textlen;
  902.    char *pchTemp;
  903.    extern TEMPLATELIST templatelist;
  904.    POPENTEMPLATE pOpenTemplate;
  905.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  906.  
  907.    switch (message)
  908.    {
  909.       case WM_INITDLG:
  910.          pOpenTemplate = (POPENTEMPLATE) mp2;
  911.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  912.          pTemplate = pOpenTemplate->pTemplate;
  913.  
  914.          WinSendDlgItemMsg(parent, IDD_TE_CCOPY+3, EM_SETTEXTLIMIT,
  915.                            MPFROMSHORT(80), NULL);
  916.          if (pTemplate->TCCopy)
  917.             WinSetDlgItemText(parent, IDD_TE_CCOPY+3, pTemplate->TCCopy);
  918.          break;
  919.  
  920.       case WM_COMMAND:
  921.          return (MRESULT) FALSE;
  922.  
  923.       case WM_CONTROL:
  924.          break;
  925.  
  926.       case WM_DESTROY:
  927.       case WM_CLOSE:
  928.          textlen=WinQueryDlgItemTextLength(parent, IDD_TE_CCOPY+3);
  929.          if (textlen)
  930.          {
  931.             pchTemp=malloc(textlen+1);
  932.             WinQueryDlgItemText(parent, IDD_TE_CCOPY+3, textlen+1, pchTemp);
  933.             if (strcmp(pchTemp, pTemplate->TCCopy))
  934.             {
  935.                free(pTemplate->TCCopy);
  936.                pTemplate->TCCopy=pchTemp;
  937.                pTemplate->bDirty = TRUE;
  938.                templatelist.bDirty=TRUE;
  939.             }
  940.             else
  941.                free(pchTemp);
  942.          }
  943.          else
  944.          {
  945.             if (pTemplate->TCCopy[0])
  946.             {
  947.                pTemplate->TCCopy[0]='\0';
  948.                pTemplate->bDirty = TRUE;
  949.                templatelist.bDirty=TRUE;
  950.             }
  951.          }
  952.          break;
  953.  
  954.       default:
  955.          break;
  956.    }
  957.    return WinDefDlgProc(parent, message, mp1, mp2);
  958. }
  959.  
  960. /*------------------------------ TEOriginProc     ---------------------------*/
  961. /* Dialogseite Origin                                                        */
  962. /*---------------------------------------------------------------------------*/
  963.  
  964. static MRESULT EXPENTRY TEOriginProc(HWND parent, ULONG message, MPARAM mp1, MPARAM mp2)
  965. {
  966.    extern TEMPLATELIST templatelist;
  967.    extern BOOL isregistered;
  968.    POPENTEMPLATE pOpenTemplate;
  969.    PMSGTEMPLATE pTemplate = (PMSGTEMPLATE) WinQueryWindowULong(parent, QWL_USER);
  970.    BOOL bTemp;
  971.    char pchTemp[LEN_PATHNAME+1];
  972.  
  973.    switch (message)
  974.    {
  975.       case WM_INITDLG:
  976.          pOpenTemplate = (POPENTEMPLATE) mp2;
  977.          WinSetWindowULong(parent, QWL_USER, (ULONG) pOpenTemplate->pTemplate);
  978.          pTemplate = pOpenTemplate->pTemplate;
  979.  
  980.          WinSendDlgItemMsg(parent, IDD_TE_ORIGIN+3, EM_SETTEXTLIMIT,
  981.                            MPFROMSHORT(LEN_ORIGIN), NULL);
  982.          WinSendDlgItemMsg(parent, IDD_TE_ORIGIN+6, EM_SETTEXTLIMIT,
  983.                            MPFROMSHORT(LEN_PATHNAME), NULL);
  984.          WinSetDlgItemText(parent, IDD_TE_ORIGIN+3, pTemplate->TOrigin);
  985.          WinSetDlgItemText(parent, IDD_TE_ORIGIN+6, pTemplate->TOriginFile);
  986.          if (pTemplate->randomorigin)
  987.          {
  988.             WinCheckButton(parent, IDD_TE_ORIGIN+5, TRUE);
  989.             WinEnableControl(parent, IDD_TE_ORIGIN+8, TRUE); /* Text */
  990.             WinEnableControl(parent, IDD_TE_ORIGIN+6, TRUE); /* File */
  991.             WinEnableControl(parent, IDD_TE_ORIGIN+7, TRUE); /* Button */
  992.  
  993.             WinEnableControl(parent, IDD_TE_ORIGIN+3, FALSE); /* Origin-Text */
  994.          }
  995.          break;
  996.  
  997.       case WM_COMMAND:
  998.          if (SHORT1FROMMP(mp1) == IDD_TE_ORIGIN+7)
  999.          {
  1000.             WinQueryDlgItemText(parent, IDD_TE_ORIGIN+6, sizeof(pchTemp), pchTemp);
  1001.             if (GetPathname(parent, pchTemp) == DID_OK)
  1002.                WinSetDlgItemText(parent, IDD_TE_ORIGIN+6, pchTemp);
  1003.          }
  1004.          return (MRESULT) FALSE;
  1005.  
  1006.       case WM_CONTROL:
  1007.          if (SHORT1FROMMP(mp1) == IDD_TE_ORIGIN+5 &&
  1008.              (SHORT2FROMMP(mp1) == BN_CLICKED ||
  1009.               SHORT2FROMMP(mp1) == BN_DBLCLICKED))
  1010.          {
  1011.             bTemp= WinQueryButtonCheckstate(parent, IDD_TE_ORIGIN+5);
  1012.  
  1013.             WinEnableControl(parent, IDD_TE_ORIGIN+8, bTemp); /* Text */
  1014.             WinEnableControl(parent, IDD_TE_ORIGIN+6, bTemp); /* File */
  1015.             WinEnableControl(parent, IDD_TE_ORIGIN+7, bTemp); /* Button */
  1016.  
  1017.             WinEnableControl(parent, IDD_TE_ORIGIN+3, !bTemp); /* Origin-Text */
  1018.          }
  1019.          break;
  1020.  
  1021.       case WM_DESTROY:
  1022.          bTemp = WinQueryButtonCheckstate(parent, IDD_TE_ORIGIN+5);
  1023.          if (pTemplate->randomorigin != bTemp)
  1024.          {
  1025.             pTemplate->randomorigin = bTemp;
  1026.             pTemplate->bDirty = TRUE;
  1027.             templatelist.bDirty=TRUE;
  1028.          }
  1029.          WinQueryDlgItemText(parent, IDD_TE_ORIGIN+3, LEN_ORIGIN+1, pchTemp);
  1030.          if (strcmp(pTemplate->TOrigin, pchTemp))
  1031.          {
  1032.             strcpy(pTemplate->TOrigin, pchTemp);
  1033.             pTemplate->bDirty = TRUE;
  1034.             templatelist.bDirty=TRUE;
  1035.          }
  1036.          WinQueryDlgItemText(parent, IDD_TE_ORIGIN+6, LEN_PATHNAME+1, pchTemp);
  1037.          if (strcmp(pTemplate->TOriginFile, pchTemp))
  1038.          {
  1039.             strcpy(pTemplate->TOriginFile, pchTemp);
  1040.             pTemplate->bDirty = TRUE;
  1041.             templatelist.bDirty=TRUE;
  1042.          }
  1043.          break;
  1044.  
  1045.       default:
  1046.          break;
  1047.    }
  1048.    return WinDefDlgProc(parent, message, mp1, mp2);
  1049. }
  1050.  
  1051.  
  1052. /*---------------------------------------------------------------------------*/
  1053. /* Funktionsname: AddEmptyTemplate                                           */
  1054. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1055. /* Beschreibung: Erzeugt ein neues Template                                  */
  1056. /*                                                                           */
  1057. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1058. /* Parameter: hwndContainer: Container mit Templates                         */
  1059. /*            hptr: verwendetes Icon                                         */
  1060. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1061. /* Rückgabewerte: Pointer auf neuen Template-Record                          */
  1062. /*                NULL: Fehler                                               */
  1063. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1064. /* Sonstiges:                                                                */
  1065. /*                                                                           */
  1066. /*---------------------------------------------------------------------------*/
  1067.  
  1068. static PTPLRECORD AddEmptyTemplate(HWND hwndContainer, HPOINTER hptr)
  1069. {
  1070.    extern TEMPLATELIST templatelist;
  1071.    PMSGTEMPLATE pTemplate, pNewTemplate;
  1072.    RECORDINSERT RecordInsert;
  1073.    PTPLRECORD pNewRecord;
  1074.    ULONG ulNewID=0;
  1075.    int iCount=0;
  1076.    extern BOOL isregistered;
  1077.  
  1078.    /* Ende der Templatekette suchen */
  1079.    pTemplate = templatelist.pTemplates;
  1080.    while (pTemplate)
  1081.    {
  1082.       iCount++;
  1083.  
  1084.       if (pTemplate->ulID > ulNewID)
  1085.          ulNewID = pTemplate->ulID;
  1086.       pTemplate = pTemplate->next;
  1087.    }
  1088.    ulNewID++;
  1089.  
  1090.    /* neues Template erzeugen */
  1091.    pNewTemplate = calloc(1, sizeof(MSGTEMPLATE));
  1092.  
  1093.    pNewTemplate->TName=malloc(MAXLEN_STRING);
  1094.    CreateUniqueName(IDST_TPL_NEWNAME, &templatelist, HaveTemplateName, MAXLEN_STRING, pNewTemplate->TName);
  1095.  
  1096.    /* vorne anhaengen */
  1097.    pNewTemplate->next = templatelist.pTemplates;
  1098.    pNewTemplate->prev = NULL;
  1099.    templatelist.pTemplates->prev = pNewTemplate;
  1100.    templatelist.pTemplates = pNewTemplate;
  1101.  
  1102.    templatelist.ulNumTemplates++;
  1103.    templatelist.bDirty = TRUE;
  1104.  
  1105.    /* Default-Daten setzen */
  1106.    LoadDefaultTemplate(pNewTemplate);
  1107.    pNewTemplate->ulID = ulNewID;
  1108.  
  1109.    /* Record vom Container anfordern */
  1110.    pNewRecord = SendMsg(hwndContainer, CM_ALLOCRECORD,
  1111.                            MPFROMLONG(sizeof(TPLRECORD) - sizeof(MINIRECORDCORE)),
  1112.                            MPFROMLONG(1));
  1113.  
  1114.    if (pNewRecord)
  1115.    {
  1116.       pNewRecord->hwndSettings = NULLHANDLE;
  1117.       pNewRecord->pTemplate    = pNewTemplate;
  1118.  
  1119.       pNewRecord->RecordCore.flRecordAttr = 0;
  1120.       pNewRecord->RecordCore.pszIcon = pNewTemplate->TName;
  1121.       pNewRecord->RecordCore.hptrIcon = hptr;
  1122.  
  1123.       /* Record einfuegen */
  1124.       RecordInsert.cb = sizeof(RECORDINSERT);
  1125.       RecordInsert.pRecordOrder = (PRECORDCORE) CMA_END;
  1126.       RecordInsert.pRecordParent = NULL;
  1127.       RecordInsert.fInvalidateRecord = TRUE;
  1128.       RecordInsert.zOrder = CMA_TOP;
  1129.       RecordInsert.cRecordsInsert = 1;
  1130.  
  1131.       SendMsg(hwndContainer, CM_INSERTRECORD, pNewRecord, &RecordInsert);
  1132.  
  1133.       return pNewRecord;
  1134.    }
  1135.    else
  1136.       return NULL;
  1137. }
  1138.  
  1139. void LoadDefaultTemplate(PMSGTEMPLATE pTemplate)
  1140. {
  1141.    extern USERDATAOPT userdaten;
  1142.  
  1143.    pTemplate->bDirty = TRUE;
  1144.  
  1145.    pTemplate->quotelinelen=75;
  1146.    pTemplate->joinlen=65;
  1147.    pTemplate->useinitials=TRUE;
  1148.    pTemplate->chQuoteChar = '>';
  1149.  
  1150.    pTemplate->THeader=malloc(MAXLEN_STRING);
  1151.    LoadString(IDST_TPL_HEADER, MAXLEN_STRING, pTemplate->THeader);
  1152.    pTemplate->TFooter=malloc(MAXLEN_STRING);
  1153.    LoadString(IDST_TPL_FOOTER, MAXLEN_STRING, pTemplate->TFooter);
  1154.    pTemplate->TReply=malloc(MAXLEN_STRING);
  1155.    LoadString(IDST_TPL_REPLY, MAXLEN_STRING, pTemplate->TReply);
  1156.    pTemplate->TDArea=malloc(MAXLEN_STRING);
  1157.    LoadString(IDST_TPL_DAREA, MAXLEN_STRING, pTemplate->TDArea);
  1158.    pTemplate->TForward=malloc(MAXLEN_STRING);
  1159.    LoadString(IDST_TPL_FORWARD, MAXLEN_STRING, pTemplate->TForward);
  1160.    pTemplate->TForwardFooter=malloc(MAXLEN_STRING);
  1161.    LoadString(IDST_TPL_FORWARDFOOTER, MAXLEN_STRING, pTemplate->TForwardFooter);
  1162.    pTemplate->TXPost=malloc(MAXLEN_STRING);
  1163.    LoadString(IDST_TPL_XPOST, MAXLEN_STRING, pTemplate->TXPost);
  1164.    pTemplate->TCCopy=malloc(MAXLEN_STRING);
  1165.    LoadString(IDST_TPL_CCOPY, MAXLEN_STRING, pTemplate->TCCopy);
  1166.    LoadString(IDST_TPL_ALLSYN, LEN_USERNAME+1, pTemplate->TAllSyn);
  1167.    strcpy(pTemplate->TOrigin, userdaten.defaultorigin);
  1168.  
  1169.    return;
  1170. }
  1171.  
  1172. static int HaveTemplateName(PVOID pTemplateList, char *pchName)
  1173. {
  1174.    PMSGTEMPLATE pTemplate = ((TEMPLATELIST*)pTemplateList)->pTemplates;
  1175.  
  1176.    while (pTemplate)
  1177.       if (!strcmp(pTemplate->TName, pchName))
  1178.          return TRUE;
  1179.       else
  1180.          pTemplate = pTemplate->next;
  1181.  
  1182.    return FALSE;
  1183. }
  1184.  
  1185. /*---------------------------------------------------------------------------*/
  1186. /* Funktionsname: CopyTemplate                                               */
  1187. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1188. /* Beschreibung: Erzeugt ein neues Template aus einem alten                  */
  1189. /*                                                                           */
  1190. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1191. /* Parameter: hwndContainer: Container mit Templates                         */
  1192. /*            hptr: verwendetes Icon                                         */
  1193. /*            pOldTpl: Zeiger auf altes Template                             */
  1194. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1195. /* Rückgabewerte: Pointer auf neuen Template-Record                          */
  1196. /*                NULL: Fehler                                               */
  1197. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1198. /* Sonstiges:                                                                */
  1199. /*                                                                           */
  1200. /*---------------------------------------------------------------------------*/
  1201.  
  1202. static PTPLRECORD CopyTemplate(HWND hwndContainer, HPOINTER hptr, PMSGTEMPLATE pOldTpl)
  1203. {
  1204.    extern TEMPLATELIST templatelist;
  1205.    PMSGTEMPLATE pTemplate, pNewTemplate;
  1206.    RECORDINSERT RecordInsert;
  1207.    PTPLRECORD pNewRecord;
  1208.    ULONG ulNewID=0;
  1209.    int iCount=0;
  1210.    extern BOOL isregistered;
  1211.  
  1212.    /* Ende der Templatekette suchen */
  1213.    pTemplate = templatelist.pTemplates;
  1214.    while (pTemplate)
  1215.    {
  1216.       iCount++;
  1217.       if (pTemplate->ulID > ulNewID)
  1218.          ulNewID = pTemplate->ulID;
  1219.       pTemplate = pTemplate->next;
  1220.    }
  1221.    ulNewID++;
  1222.  
  1223.    /* neues Template erzeugen */
  1224.    pNewTemplate = malloc(sizeof(MSGTEMPLATE));
  1225.    memset(pNewTemplate, 0, sizeof(MSGTEMPLATE));
  1226.  
  1227.    /* vorne anhaengen */
  1228.    pNewTemplate->next = templatelist.pTemplates;
  1229.    pNewTemplate->prev = NULL;
  1230.    templatelist.pTemplates->prev = pNewTemplate;
  1231.    templatelist.pTemplates = pNewTemplate;
  1232.  
  1233.    templatelist.ulNumTemplates++;
  1234.    templatelist.bDirty = TRUE;
  1235.  
  1236.    /* Daten setzen */
  1237.    pNewTemplate->bDirty = TRUE;
  1238.    pNewTemplate->quotelinelen = pOldTpl->quotelinelen;
  1239.    pNewTemplate->joinlen = pOldTpl->joinlen;
  1240.    pNewTemplate->useinitials = pOldTpl->useinitials;
  1241.    pNewTemplate->forwardfirst = pOldTpl->forwardfirst;
  1242.    pNewTemplate->randomorigin = pOldTpl->randomorigin;
  1243.    pNewTemplate->ulID = ulNewID;
  1244.  
  1245.    /* Strings kopieren */
  1246.    pNewTemplate->TFooter=strdup(pOldTpl->TFooter);
  1247.    pNewTemplate->THeader=strdup(pOldTpl->THeader);
  1248.    pNewTemplate->TReply=strdup(pOldTpl->TReply);
  1249.    pNewTemplate->TDArea=strdup(pOldTpl->TDArea);
  1250.    pNewTemplate->TForward=strdup(pOldTpl->TForward);
  1251.    pNewTemplate->TForwardFooter=strdup(pOldTpl->TForwardFooter);
  1252.    pNewTemplate->TXPost=strdup(pOldTpl->TXPost);
  1253.    pNewTemplate->TCCopy=strdup(pOldTpl->TCCopy);
  1254.    pNewTemplate->TName=malloc(MAXLEN_STRING);
  1255.    LoadString(IDST_TPL_NEWNAME, MAXLEN_STRING, pNewTemplate->TName);
  1256.    strcpy(pNewTemplate->TOrigin, pOldTpl->TOrigin);
  1257.    strcpy(pNewTemplate->TOriginFile, pOldTpl->TOriginFile);
  1258.    strcpy(pNewTemplate->TAllSyn, pOldTpl->TAllSyn);
  1259.  
  1260.    /* Record vom Container anfordern */
  1261.    pNewRecord = SendMsg(hwndContainer, CM_ALLOCRECORD,
  1262.                            MPFROMLONG(sizeof(TPLRECORD) - sizeof(MINIRECORDCORE)),
  1263.                            MPFROMLONG(1));
  1264.  
  1265.    if (pNewRecord)
  1266.    {
  1267.       pNewRecord->hwndSettings = NULLHANDLE;
  1268.       pNewRecord->pTemplate    = pNewTemplate;
  1269.  
  1270.       pNewRecord->RecordCore.flRecordAttr = 0;
  1271.       pNewRecord->RecordCore.pszIcon = pNewTemplate->TName;
  1272.       pNewRecord->RecordCore.hptrIcon = hptr;
  1273.  
  1274.       /* Record einfuegen */
  1275.       RecordInsert.cb = sizeof(RECORDINSERT);
  1276.       RecordInsert.pRecordOrder = (PRECORDCORE) CMA_END;
  1277.       RecordInsert.pRecordParent = NULL;
  1278.       RecordInsert.fInvalidateRecord = TRUE;
  1279.       RecordInsert.zOrder = CMA_TOP;
  1280.       RecordInsert.cRecordsInsert = 1;
  1281.  
  1282.       SendMsg(hwndContainer, CM_INSERTRECORD, pNewRecord, &RecordInsert);
  1283.  
  1284.       return pNewRecord;
  1285.    }
  1286.    else
  1287.       return NULL;
  1288. }
  1289.  
  1290. /*---------------------------------------------------------------------------*/
  1291. /* Funktionsname: FillTemplateFolder                                         */
  1292. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1293. /* Beschreibung: Fuegt alle Objekte in den Template-Folder ein               */
  1294. /*                                                                           */
  1295. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1296. /* Parameter: hwndContainer: Container mit Templates                         */
  1297. /*            hptr: verwendetes Icon                                         */
  1298. /*            hptrDef: verwendetes Icon f. Default-Template                  */
  1299. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1300. /* Rückgabewerte: 0   OK                                                     */
  1301. /*                -1  Fehler                                                 */
  1302. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1303. /* Sonstiges:                                                                */
  1304. /*                                                                           */
  1305. /*---------------------------------------------------------------------------*/
  1306.  
  1307. static int FillTemplateFolder(HWND hwndContainer, HPOINTER hptr, HPOINTER hptrDef)
  1308. {
  1309.    extern TEMPLATELIST templatelist;
  1310.    PMSGTEMPLATE pTemplate = templatelist.pTemplates;
  1311.    RECORDINSERT RecordInsert;
  1312.    PTPLRECORD pRecord, pFirstRecord;
  1313.  
  1314.    if (templatelist.ulNumTemplates == 0)
  1315.       return -1;
  1316.  
  1317.    /* Records vom Container anfordern */
  1318.    pFirstRecord = SendMsg(hwndContainer, CM_ALLOCRECORD,
  1319.                              MPFROMLONG(sizeof(TPLRECORD) - sizeof(MINIRECORDCORE)),
  1320.                              MPFROMLONG(templatelist.ulNumTemplates));
  1321.    pRecord = pFirstRecord;
  1322.  
  1323.    pTemplate = templatelist.pTemplates;
  1324.    while (pRecord)
  1325.    {
  1326.       pRecord->hwndSettings = NULLHANDLE;
  1327.       pRecord->pTemplate    = pTemplate;
  1328.  
  1329.       pRecord->RecordCore.flRecordAttr = 0;
  1330.       pRecord->RecordCore.pszIcon = pTemplate->TName;
  1331.  
  1332.       if (pTemplate->ulID == 0)
  1333.          pRecord->RecordCore.hptrIcon = hptrDef;
  1334.       else
  1335.          pRecord->RecordCore.hptrIcon = hptr;
  1336.  
  1337.       pRecord = (PTPLRECORD) pRecord->RecordCore.preccNextRecord;
  1338.       pTemplate = pTemplate->next;
  1339.    }
  1340.  
  1341.    /* Records einfuegen */
  1342.    RecordInsert.cb = sizeof(RECORDINSERT);
  1343.    RecordInsert.pRecordOrder = (PRECORDCORE) CMA_END;
  1344.    RecordInsert.pRecordParent = NULL;
  1345.    RecordInsert.fInvalidateRecord = TRUE;
  1346.    RecordInsert.zOrder = CMA_TOP;
  1347.    RecordInsert.cRecordsInsert = templatelist.ulNumTemplates;
  1348.  
  1349.    SendMsg(hwndContainer, CM_INSERTRECORD, pFirstRecord, &RecordInsert);
  1350.  
  1351.    return 0;
  1352. }
  1353.  
  1354. /*---------------------------------------------------------------------------*/
  1355. /* Funktionsname: OpenTemplate                                               */
  1356. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1357. /* Beschreibung: Oeffnet ein Template-Objekt                                 */
  1358. /*                                                                           */
  1359. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1360. /* Parameter: hwndContainer: Container mit Objekt                            */
  1361. /*            pTplRecord: Record-Pointer des Templates                       */
  1362. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1363. /* Rückgabewerte: 0 OK                                                       */
  1364. /*                                                                           */
  1365. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1366. /* Sonstiges: Ein bereits offenes Template bekommt lediglich den Fokus       */
  1367. /*                                                                           */
  1368. /*---------------------------------------------------------------------------*/
  1369.  
  1370. static int OpenTemplate(HWND hwndContainer, PTPLRECORD pTplRecord)
  1371. {
  1372.    if (pTplRecord->hwndSettings)  /* schon offen ? */
  1373.       SetFocus(pTplRecord->hwndSettings);
  1374.    else
  1375.    {
  1376.       OPENTEMPLATE OpenTemplate;
  1377.  
  1378.       /* in-use-emphasis setzen */
  1379.       SendMsg(hwndContainer, CM_SETRECORDEMPHASIS, pTplRecord,
  1380.                  MPFROM2SHORT(TRUE, CRA_INUSE));
  1381.  
  1382.       OpenTemplate.cb = sizeof(OpenTemplate);
  1383.       OpenTemplate.pTemplate = pTplRecord->pTemplate;
  1384.  
  1385.       /* Notebook oeffnen */
  1386.       pTplRecord->hwndSettings= WinLoadDlg(HWND_DESKTOP,
  1387.                                            HWND_DESKTOP,
  1388.                                            TemplateBookProc,
  1389.                                            hmodLang,
  1390.                                            IDD_TEMPLATE,
  1391.                                            &OpenTemplate);
  1392.    }
  1393.  
  1394.    return 0;
  1395. }
  1396.  
  1397. /*---------------------------------------------------------------------------*/
  1398. /* Funktionsname: DeleteTemplate                                             */
  1399. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1400. /* Beschreibung: Loescht ein Template-Objekt                                 */
  1401. /*                                                                           */
  1402. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1403. /* Parameter: hwndContainer: Container mit Objekt                            */
  1404. /*            pTplRecord: Record-Pointer des Templates                       */
  1405. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1406. /* Rückgabewerte: 0 OK                                                       */
  1407. /*                -1 Default-Template nicht loeschbar                        */
  1408. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1409. /* Sonstiges:                                                                */
  1410. /*                                                                           */
  1411. /*---------------------------------------------------------------------------*/
  1412.  
  1413. static int DeleteTemplate(HWND hwndContainer, PTPLRECORD pTplRecord)
  1414. {
  1415.    extern TEMPLATELIST templatelist;
  1416.  
  1417.    if (pTplRecord->pTemplate->ulID == 0)
  1418.       return -1;  /* Default nicht loeschbar */
  1419.  
  1420.    /* offenes Notebook schliessen */
  1421.    if (pTplRecord->hwndSettings)
  1422.       WinDestroyWindow(pTplRecord->hwndSettings);
  1423.  
  1424.    /* Record im Container loeschen */
  1425.    SendMsg(hwndContainer, CM_REMOVERECORD, &pTplRecord,
  1426.               MPFROM2SHORT(1, CMA_INVALIDATE));
  1427.  
  1428.    /* Template-Felder freigeben */
  1429.    if (pTplRecord->pTemplate->THeader)
  1430.       free(pTplRecord->pTemplate->THeader);
  1431.    if (pTplRecord->pTemplate->TFooter)
  1432.       free(pTplRecord->pTemplate->TFooter);
  1433.    if (pTplRecord->pTemplate->TReply)
  1434.       free(pTplRecord->pTemplate->TReply);
  1435.    if (pTplRecord->pTemplate->TDArea)
  1436.       free(pTplRecord->pTemplate->TDArea);
  1437.    if (pTplRecord->pTemplate->TForward)
  1438.       free(pTplRecord->pTemplate->TForward);
  1439.    if (pTplRecord->pTemplate->TForwardFooter)
  1440.       free(pTplRecord->pTemplate->TForwardFooter);
  1441.    if (pTplRecord->pTemplate->TXPost)
  1442.       free(pTplRecord->pTemplate->TXPost);
  1443.    if (pTplRecord->pTemplate->TCCopy)
  1444.       free(pTplRecord->pTemplate->TCCopy);
  1445.    if (pTplRecord->pTemplate->TName)
  1446.       free(pTplRecord->pTemplate->TName);
  1447.  
  1448.    /* Template selbst loeschen */
  1449.    if (pTplRecord->pTemplate->prev)
  1450.       pTplRecord->pTemplate->prev->next = pTplRecord->pTemplate->next;
  1451.    else
  1452.       templatelist.pTemplates = pTplRecord->pTemplate->next;
  1453.    if (pTplRecord->pTemplate->next)
  1454.      pTplRecord->pTemplate->next->prev = pTplRecord->pTemplate->prev;
  1455.  
  1456.    templatelist.ulNumTemplates--;
  1457.    templatelist.bDirty = TRUE;
  1458.  
  1459.    free(pTplRecord->pTemplate);
  1460.  
  1461.    /* endgueltig aus Container entfernen */
  1462.    SendMsg(hwndContainer, CM_FREERECORD, &pTplRecord, MPFROMLONG(1));
  1463.  
  1464.    return 0;
  1465. }
  1466.  
  1467. /*---------------------------------------------------------------------------*/
  1468. /* Funktionsname: CleanupTemplateFolder                                      */
  1469. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1470. /* Beschreibung: Entfernt alle Objekte aus dem Template-Folder               */
  1471. /*                                                                           */
  1472. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1473. /* Parameter: hwndContainer: Container mit Objekt                            */
  1474. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1475. /* Rückgabewerte: 0 OK                                                       */
  1476. /*                -1  Fehler                                                 */
  1477. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1478. /* Sonstiges: Schliesst auch alle offenen Templates                          */
  1479. /*                                                                           */
  1480. /*---------------------------------------------------------------------------*/
  1481.  
  1482. static int CleanupTemplateFolder(HWND hwndContainer)
  1483. {
  1484.    PTPLRECORD pRecord = NULL;
  1485.  
  1486.    /* alle offenen Templates schliessen */
  1487.    while (pRecord = SendMsg(hwndContainer, CM_QUERYRECORD, pRecord,
  1488.                                MPFROM2SHORT(pRecord ? CMA_NEXT : CMA_FIRST,
  1489.                                             CMA_ITEMORDER)))
  1490.    {
  1491.       if (pRecord->hwndSettings)
  1492.          WinDestroyWindow(pRecord->hwndSettings);
  1493.    }
  1494.  
  1495.    /* Folder leeren */
  1496.    SendMsg(hwndContainer, CM_REMOVERECORD, NULL, MPFROM2SHORT(0, CMA_FREE));
  1497.  
  1498.    return 0;
  1499. }
  1500.  
  1501. /*---------------------------------------------------------------------------*/
  1502. /* Funktionsname: TemplateFolderProc                                         */
  1503. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1504. /* Beschreibung: Fensterprozedur des Template-Folders                        */
  1505. /*                                                                           */
  1506. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1507. /* Parameter: (WinProc)                                                      */
  1508. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1509. /* Rückgabewerte: MRESULT                                                    */
  1510. /*                                                                           */
  1511. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1512. /* Sonstiges:                                                                */
  1513. /*                                                                           */
  1514. /*---------------------------------------------------------------------------*/
  1515.  
  1516. MRESULT EXPENTRY TemplateFolderProc(HWND hwnd, ULONG message, MPARAM mp1, MPARAM mp2)
  1517. {
  1518.    extern TEMPLATELIST templatelist;
  1519.    extern WINDOWCOLORS windowcolors;
  1520.    extern WINDOWFONTS  windowfonts;
  1521.    extern GENERALOPT generaloptions;
  1522.    extern HWND hwndhelp, client;
  1523.    PTPLFOLDERDATA pTplFolderData = (PTPLFOLDERDATA) WinQueryWindowULong(hwnd, QWL_USER);
  1524.  
  1525.    switch (message)
  1526.    {
  1527.       case WM_INITDLG:
  1528.          /* Instanzdaten anfordern */
  1529.          pTplFolderData = malloc(sizeof(TPLFOLDERDATA));
  1530.          memset(pTplFolderData, 0, sizeof(TPLFOLDERDATA));
  1531.          WinSetWindowULong(hwnd, QWL_USER, (ULONG) pTplFolderData);
  1532.  
  1533.          OldTplProc = WinSubclassWindow(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1534.                                         NewTplProc);
  1535.  
  1536.          /* Icon laden */
  1537.          pTplFolderData->hptrTemplate = LoadIcon(IDIC_TEMPLATE);
  1538.          pTplFolderData->hptrDefTemplate = LoadIcon(IDIC_DEFTEMPLATE);
  1539.          pTplFolderData->hptrTemplateFolder = LoadIcon(IDIC_TEMPLATEFOLDER);
  1540.          SendMsg(hwnd, WM_SETICON, (MPARAM) pTplFolderData->hptrTemplateFolder, NULL);
  1541.  
  1542.          /* Switch-Entry */
  1543.          pTplFolderData->hSwitch=AddToWindowList(hwnd);
  1544.  
  1545.          /* Menues laden */
  1546.          pTplFolderData->hwndPopup = WinLoadMenu(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1547.                                                  hmodLang, IDM_TPLF_POPUP);
  1548.          pTplFolderData->hwndPopup2 = WinLoadMenu(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1549.                                                   hmodLang, IDM_TPLF_POPUP2);
  1550.  
  1551.          if (pTplFolderData->hwndPopup2)
  1552.             ReplaceSysMenu(hwnd, pTplFolderData->hwndPopup2, 1);
  1553.  
  1554.          if (templatelist.ulFlags & TEMPLATE_FOREGROUND)
  1555.          {
  1556.             pTplFolderData->bForeground = TRUE;
  1557.             WinCheckMenuItem(pTplFolderData->hwndPopup2, IDM_TPLF_FGROUND, TRUE);
  1558.             WinSetOwner(hwnd, client);
  1559.          }
  1560.          else
  1561.          {
  1562.             pTplFolderData->bForeground = FALSE;
  1563.             WinCheckMenuItem(pTplFolderData->hwndPopup2, IDM_TPLF_FGROUND, FALSE);
  1564.             WinSetOwner(hwnd, HWND_DESKTOP);
  1565.          }
  1566.  
  1567.          /* Farben und Font setzen */
  1568.          SetBackground(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), &windowcolors.tplfolderback);
  1569.          SetForeground(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), &windowcolors.tplfolderfore);
  1570.          SetFont(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), windowfonts.tplfolderfont);
  1571.  
  1572.          /* Icons einfuegen */
  1573.          FillTemplateFolder(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1574.                             pTplFolderData->hptrTemplate,
  1575.                             pTplFolderData->hptrDefTemplate);
  1576.          RestoreWinPos(hwnd, &templatelist.FolderPos, TRUE, TRUE);
  1577.          pTplFolderData->bNotify = TRUE;
  1578.          break;
  1579.  
  1580.       case WM_DESTROY:
  1581.          /* Farben und Font */
  1582.          CleanupTemplateFolder(WinWindowFromID(hwnd, IDD_TPLFOLDER+1));
  1583.          RemoveFromWindowList(pTplFolderData->hSwitch);
  1584.          QueryBackground(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), &windowcolors.tplfolderback);
  1585.          QueryForeground(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), &windowcolors.tplfolderfore);
  1586.          QueryFont(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), windowfonts.tplfolderfont);
  1587.          if (pTplFolderData->hptrTemplate)
  1588.             WinDestroyPointer(pTplFolderData->hptrTemplate);
  1589.          if (pTplFolderData->hptrTemplateFolder)
  1590.             WinDestroyPointer(pTplFolderData->hptrTemplateFolder);
  1591.          if (pTplFolderData->hptrDefTemplate)
  1592.             WinDestroyPointer(pTplFolderData->hptrDefTemplate);
  1593.          if (pTplFolderData->hwndPopup)
  1594.             WinDestroyWindow(pTplFolderData->hwndPopup);
  1595.          if (pTplFolderData->hwndPopup2)
  1596.             WinDestroyWindow(pTplFolderData->hwndPopup2);
  1597.          if (pTplFolderData->bForeground)
  1598.          {
  1599.             if (!(templatelist.ulFlags & TEMPLATE_FOREGROUND))
  1600.             {
  1601.                templatelist.ulFlags |= TEMPLATE_FOREGROUND;
  1602.                templatelist.bDirty = TRUE;
  1603.             }
  1604.          }
  1605.          else
  1606.          {
  1607.             if (templatelist.ulFlags & TEMPLATE_FOREGROUND)
  1608.             {
  1609.                templatelist.ulFlags &= ~TEMPLATE_FOREGROUND;
  1610.                templatelist.bDirty = TRUE;
  1611.             }
  1612.          }
  1613.          free(pTplFolderData);
  1614.          break;
  1615.  
  1616.       case WM_CONTROL:
  1617.          if (SHORT1FROMMP(mp1) == IDD_TPLFOLDER+1)
  1618.          {
  1619.             switch(SHORT2FROMMP(mp1))
  1620.             {
  1621.                PCNREDITDATA pEdit;
  1622.                PTPLRECORD pRecord;
  1623.                PNOTIFYRECORDENTER pEnter;
  1624.  
  1625.                case CN_ENTER:
  1626.                   pEnter = (PNOTIFYRECORDENTER) mp2;
  1627.                   if (pEnter->pRecord)
  1628.                      OpenTemplate(pEnter->hwndCnr,
  1629.                                   (PTPLRECORD) pEnter->pRecord);
  1630.                   break;
  1631.  
  1632.                case CN_REALLOCPSZ:
  1633.                   pEdit = (PCNREDITDATA) mp2;
  1634.                   pRecord = (PTPLRECORD) pEdit->pRecord;
  1635.                   free (pRecord->pTemplate->TName);
  1636.                   pRecord->pTemplate->TName = malloc(pEdit->cbText+1);
  1637.                   pRecord->pTemplate->TName[0] = '\0';
  1638.                   pRecord->RecordCore.pszIcon = pRecord->pTemplate->TName;
  1639.                   pRecord->pTemplate->bDirty = TRUE;
  1640.                   templatelist.bDirty = TRUE;
  1641.                   return (MRESULT) TRUE;
  1642.  
  1643.                case CN_ENDEDIT:
  1644.                   /* Template offen ? */
  1645.                   pEdit = (PCNREDITDATA) mp2;
  1646.                   if (((PTPLRECORD)pEdit->pRecord)->hwndSettings)
  1647.                      WinSetWindowText(((PTPLRECORD)pEdit->pRecord)->hwndSettings, *pEdit->ppszText);
  1648.                   break;
  1649.  
  1650.                case CN_INITDRAG:
  1651.                   pTplFolderData->pDragRecord = (PTPLRECORD) ((PCNRDRAGINIT) mp2)->pRecord;
  1652.                   InitTemplateDrag(hwnd, (PCNRDRAGINIT) mp2);
  1653.                   break;
  1654.  
  1655.                case CN_DRAGOVER:
  1656.                   return TemplateDragover(hwnd, (PCNRDRAGINFO) mp2);
  1657.  
  1658.                case CN_DROP:
  1659.                   TemplateDrop(hwnd, (PCNRDRAGINFO) mp2, pTplFolderData);
  1660.                   break;
  1661.  
  1662.                case CN_CONTEXTMENU:
  1663.                   pTplFolderData->pPopupRecord = (PTPLRECORD) mp2;
  1664.                   if (pTplFolderData->pPopupRecord)
  1665.                   {
  1666.                      /* Popup-Menue eines Templates */
  1667.                      RECTL rcl;
  1668.                      POINTL ptl;
  1669.                      QUERYRECORDRECT QRecord;
  1670.  
  1671.                      if (pTplFolderData->pPopupRecord->pTemplate->ulID == 0)
  1672.                         WinEnableMenuItem(pTplFolderData->hwndPopup, IDM_TPLF_DELETE, FALSE);
  1673.                      else
  1674.                         WinEnableMenuItem(pTplFolderData->hwndPopup, IDM_TPLF_DELETE, TRUE);
  1675.  
  1676.                      QRecord.cb = sizeof(QUERYRECORDRECT);
  1677.                      QRecord.pRecord = (PRECORDCORE) pTplFolderData->pPopupRecord;
  1678.                      QRecord.fRightSplitWindow = FALSE;
  1679.                      QRecord.fsExtent = CMA_ICON;
  1680.                      WinSendDlgItemMsg(hwnd, IDD_TPLFOLDER+1, CM_QUERYRECORDRECT,
  1681.                                        &rcl, &QRecord);
  1682.                      ptl.x = rcl.xRight;
  1683.                      ptl.y = rcl.yBottom;
  1684.                      WinMapWindowPoints(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1685.                                         HWND_DESKTOP, &ptl, 1);
  1686.                      WinPopupMenu(HWND_DESKTOP, hwnd, pTplFolderData->hwndPopup,
  1687.                                   ptl.x, ptl.y, 0,
  1688.                                   PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD |
  1689.                                   PU_MOUSEBUTTON1);
  1690.                   }
  1691.                   else
  1692.                   {
  1693.                      /* Popup-Menue des Folders */
  1694.                      POINTL ptl;
  1695.  
  1696.                      WinQueryPointerPos(HWND_DESKTOP, &ptl);
  1697.                      WinPopupMenu(HWND_DESKTOP, hwnd, pTplFolderData->hwndPopup2,
  1698.                                   ptl.x, ptl.y, 0,
  1699.                                   PU_HCONSTRAIN | PU_VCONSTRAIN | PU_KEYBOARD |
  1700.                                   PU_MOUSEBUTTON1);
  1701.                   }
  1702.                   break;
  1703.  
  1704.                case CN_HELP:
  1705.                   SendMsg(hwnd, WM_HELP, MPFROMSHORT(IDD_TPLFOLDER+1), NULL);
  1706.                   break;
  1707.  
  1708.                default:
  1709.                   break;
  1710.             }
  1711.          }
  1712.          break;
  1713.  
  1714.       case DM_DISCARDOBJECT:
  1715.          if (mp1)
  1716.          {
  1717.             DrgAccessDraginfo((PDRAGINFO) mp1);
  1718.             DeleteTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1719.                            pTplFolderData->pDragRecord);
  1720.             DrgFreeDraginfo((PDRAGINFO) mp1);
  1721.          }
  1722.          else
  1723.             WinAlarm(HWND_DESKTOP, WA_ERROR);
  1724.          return (MRESULT) DRR_SOURCE;
  1725.  
  1726.       case WM_MENUEND:
  1727.          if ((HWND) mp2 == pTplFolderData->hwndPopup ||
  1728.              (HWND) mp2 == pTplFolderData->hwndPopup2)
  1729.          {
  1730.             /* Emphasis wegnehmen */
  1731.             WinSendDlgItemMsg(hwnd, IDD_TPLFOLDER+1, CM_SETRECORDEMPHASIS,
  1732.                               pTplFolderData->pPopupRecord,
  1733.                               MPFROM2SHORT(FALSE, CRA_SOURCE));
  1734.             if ( (HWND) mp2 == pTplFolderData->hwndPopup2)
  1735.                ResetMenuStyle(pTplFolderData->hwndPopup2, hwnd);
  1736.          }
  1737.          break;
  1738.  
  1739.       case WM_INITMENU:
  1740.          if ((HWND) mp2 == pTplFolderData->hwndPopup2)
  1741.             pTplFolderData->pPopupRecord=NULL;
  1742.          if ((HWND) mp2 == pTplFolderData->hwndPopup ||
  1743.              (HWND) mp2 == pTplFolderData->hwndPopup2)
  1744.          {
  1745.             /* Emphasis setzen */
  1746.             WinSendDlgItemMsg(hwnd, IDD_TPLFOLDER+1, CM_SETRECORDEMPHASIS,
  1747.                               pTplFolderData->pPopupRecord,
  1748.                               MPFROM2SHORT(TRUE, CRA_SOURCE));
  1749.          }
  1750.          break;
  1751.  
  1752.       case WM_ACTIVATE:
  1753.          if (mp1)
  1754.             WinAssociateHelpInstance(hwndhelp, hwnd);
  1755.          else
  1756.             WinAssociateHelpInstance(hwndhelp, NULLHANDLE);
  1757.          break;
  1758.  
  1759.       case WM_CONTEXTMENU:
  1760.       case WM_TEXTEDIT:
  1761.          if (!SHORT1FROMMP(mp1) &&
  1762.              WinQueryFocus(HWND_DESKTOP) == WinWindowFromID(hwnd, IDD_TPLFOLDER+1))
  1763.          {
  1764.             WinSendDlgItemMsg(hwnd, IDD_TPLFOLDER+1, message,
  1765.                               mp1, mp2);
  1766.          }
  1767.          break;
  1768.  
  1769.       case WM_CLOSE:
  1770.          WinPostMsg(client, TPLF_CLOSE, NULL, NULL);
  1771.          break;
  1772.  
  1773.       case WM_ADJUSTWINDOWPOS:
  1774.          if (((PSWP)mp1)->fl & SWP_MINIMIZE)
  1775.             WinShowWindow(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), FALSE);
  1776.          if (((PSWP)mp1)->fl & (SWP_MAXIMIZE|SWP_RESTORE))
  1777.             WinShowWindow(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), TRUE);
  1778.          break;
  1779.  
  1780.       case WM_ADJUSTFRAMEPOS:
  1781.          SizeToClient(anchor, (PSWP) mp1, hwnd, IDD_TPLFOLDER+1);
  1782.          break;
  1783.  
  1784.       case WM_WINDOWPOSCHANGED:
  1785.          if (pTplFolderData && pTplFolderData->bNotify)
  1786.             SaveWinPos(hwnd, (PSWP) mp1, &templatelist.FolderPos, &templatelist.bDirty);
  1787.          break;
  1788.  
  1789.       case WM_COMMAND:
  1790.          switch(SHORT1FROMMP(mp1))
  1791.          {
  1792.             PTPLRECORD pNewTemplate;
  1793.  
  1794.             case IDM_TPLF_OPEN:
  1795.                OpenTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1796.                             pTplFolderData->pPopupRecord);
  1797.                return (MRESULT) FALSE;
  1798.  
  1799.             case IDM_TPLF_CREATE:
  1800.                if (pNewTemplate = AddEmptyTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1801.                                                    pTplFolderData->hptrTemplate))
  1802.                   OpenTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1803.                                pNewTemplate);
  1804.                return (MRESULT) FALSE;
  1805.  
  1806.             case IDM_TPLF_COPY:
  1807.                if (pNewTemplate = CopyTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1808.                                                pTplFolderData->hptrTemplate,
  1809.                                                pTplFolderData->pPopupRecord->pTemplate))
  1810.                   OpenTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1811.                                pNewTemplate);
  1812.                return (MRESULT) FALSE;
  1813.  
  1814.             case IDM_TPLF_DELETE:
  1815.                if (generaloptions.safety & SAFETY_CHANGESETUP)
  1816.                   if (MessageBox(hwnd, IDST_MSG_DELTEMPLATE, IDST_TITLE_DELTEMPLATE,
  1817.                                  IDD_DELTEMPLATE, MB_YESNO | MB_WARNING) != MBID_YES)
  1818.                      return (MRESULT) FALSE;
  1819.                DeleteTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1820.                               pTplFolderData->pPopupRecord);
  1821.                return (MRESULT) FALSE;
  1822.  
  1823.             case IDM_TPLF_FGROUND:
  1824.                if (pTplFolderData->bForeground)
  1825.                {
  1826.                   pTplFolderData->bForeground = FALSE;
  1827.                   WinCheckMenuItem(pTplFolderData->hwndPopup2, IDM_TPLF_FGROUND, FALSE);
  1828.                   WinSetOwner(hwnd, HWND_DESKTOP);
  1829.                }
  1830.                else
  1831.                {
  1832.                   pTplFolderData->bForeground = TRUE;
  1833.                   WinCheckMenuItem(pTplFolderData->hwndPopup2, IDM_TPLF_FGROUND, TRUE);
  1834.                   WinSetOwner(hwnd, client);
  1835.                }
  1836.                return (MRESULT) FALSE;
  1837.  
  1838.             case DID_CANCEL:
  1839.                break;
  1840.  
  1841.             default:
  1842.                return (MRESULT) FALSE;
  1843.          }
  1844.          return (MRESULT) FALSE;
  1845.  
  1846.       case TPL_CLOSE:
  1847.          TemplateClosed(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  1848.                         (ULONG) mp1);
  1849.          break;
  1850.  
  1851.       default:
  1852.          break;
  1853.    }
  1854.    return WinDefDlgProc(hwnd, message, mp1, mp2);
  1855. }
  1856.  
  1857. /*---------------------------------------------------------------------------*/
  1858. /* Funktionsname: InitTemplateDrag                                           */
  1859. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1860. /* Beschreibung: Startet Drag für ein Template                               */
  1861. /*                                                                           */
  1862. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1863. /* Parameter: hwndDlg: Dialog-Window-Handle                                  */
  1864. /*            pInit:   Drag-Init-Infos vom Container                         */
  1865. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1866. /* Rückgabewerte: 0  OK                                                      */
  1867. /*                -1 Fehler                                                  */
  1868. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1869. /* Sonstiges:                                                                */
  1870. /*                                                                           */
  1871. /*---------------------------------------------------------------------------*/
  1872.  
  1873. static int InitTemplateDrag(HWND hwndDlg, PCNRDRAGINIT pInit)
  1874. {
  1875.    PDRAGINFO pDraginfo;
  1876.    DRAGITEM dItem;
  1877.    DRAGIMAGE dImage;
  1878.  
  1879.    if (!pInit->pRecord)
  1880.       return -1;
  1881.  
  1882.    WinSendDlgItemMsg(hwndDlg, IDD_TPLFOLDER+1, CM_SETRECORDEMPHASIS,
  1883.                      pInit->pRecord, MPFROM2SHORT(TRUE, CRA_SOURCE));
  1884.  
  1885.    pDraginfo = DrgAllocDraginfo(1);
  1886.    pDraginfo->usOperation=DO_LINK;
  1887.    pDraginfo->hwndSource=hwndDlg;
  1888.  
  1889.    /* Drag-Item vorbereiten*/
  1890.    dItem.hwndItem=hwndDlg;
  1891.    dItem.ulItemID= ((PTPLRECORD) pInit->pRecord)->pTemplate->ulID;
  1892.    dItem.hstrType=DrgAddStrHandle(TPLDRAGTYPE);
  1893.    if (((PTPLRECORD) pInit->pRecord)->pTemplate->ulID == 0)
  1894.       dItem.hstrRMF=DrgAddStrHandle(TPLDRAGRMFRO);
  1895.    else
  1896.       dItem.hstrRMF=DrgAddStrHandle(TPLDRAGRMF);
  1897.    dItem.hstrSourceName=DrgAddStrHandle(pInit->pRecord->pszIcon);
  1898.    dItem.hstrTargetName=DrgAddStrHandle(pInit->pRecord->pszIcon);
  1899.    if (((PTPLRECORD) pInit->pRecord)->hwndSettings)
  1900.       dItem.fsControl= DC_OPEN;
  1901.    else
  1902.       dItem.fsControl=0;
  1903.    dItem.fsSupportedOps=DO_LINKABLE|DO_COPYABLE;
  1904.    DrgSetDragitem(pDraginfo, &dItem, sizeof(dItem), 0);
  1905.  
  1906.    /* Drag-Image vorbereiten */
  1907.    dImage.cb=sizeof(DRAGIMAGE);
  1908.    dImage.hImage=pInit->pRecord->hptrIcon;
  1909.    dImage.fl=DRG_ICON;
  1910.    dImage.cxOffset=0;
  1911.    dImage.cyOffset=0;
  1912.  
  1913.    /* Und los gehts */
  1914. #if 0
  1915.    if (!DrgDrag(hwndDlg, pDraginfo, &dImage, 1, VK_ENDDRAG, NULL))
  1916.       DrgDeleteDraginfoStrHandles(pDraginfo);
  1917. #else
  1918.    DrgDrag(hwndDlg, pDraginfo, &dImage, 1, VK_ENDDRAG, NULL);
  1919. #endif
  1920.    DrgFreeDraginfo(pDraginfo);
  1921.  
  1922.    WinSendDlgItemMsg(hwndDlg, IDD_TPLFOLDER+1, CM_SETRECORDEMPHASIS,
  1923.                      pInit->pRecord, MPFROM2SHORT(FALSE, CRA_SOURCE));
  1924.  
  1925.    return 0;
  1926. }
  1927.  
  1928. /*---------------------------------------------------------------------------*/
  1929. /* Funktionsname: NewTplProc                                                 */
  1930. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1931. /* Beschreibung: Neue Window-Procedure f. Container wg. Dragover-Bug         */
  1932. /*                                                                           */
  1933. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1934. /* Parameter: (WinProc)                                                      */
  1935. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1936. /* Rückgabewerte: MRESULT                                                    */
  1937. /*                                                                           */
  1938. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1939. /* Sonstiges:                                                                */
  1940. /*                                                                           */
  1941. /*---------------------------------------------------------------------------*/
  1942.  
  1943. static MRESULT EXPENTRY NewTplProc(HWND hwnd, ULONG message, MPARAM mp1, MPARAM mp2)
  1944. {
  1945.    switch (message)
  1946.    {
  1947.       case DM_DRAGOVER:
  1948.          DrgAccessDraginfo((PDRAGINFO) mp1);
  1949.          break;
  1950.  
  1951.       case WM_BUTTON2DOWN:
  1952.          return (MRESULT) FALSE;
  1953.  
  1954.       default:
  1955.          break;
  1956.    }
  1957.  
  1958.    return OldTplProc(hwnd, message, mp1, mp2);
  1959. }
  1960.  
  1961. /*---------------------------------------------------------------------------*/
  1962. /* Funktionsname: TemplateClosed                                             */
  1963. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1964. /* Beschreibung: Raeumt nach dem Schliessen eines Templates wieder auf       */
  1965. /*                                                                           */
  1966. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1967. /* Parameter: hwndCnr: Container-Window                                      */
  1968. /*            ulTemplateID: Template-ID                                      */
  1969. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1970. /* Rückgabewerte: -                                                          */
  1971. /*                                                                           */
  1972. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  1973. /* Sonstiges:                                                                */
  1974. /*                                                                           */
  1975. /*---------------------------------------------------------------------------*/
  1976.  
  1977. static void TemplateClosed(HWND hwndCnr, ULONG ulTemplateID)
  1978. {
  1979.    PTPLRECORD pRecord = NULL;
  1980.  
  1981.    while (pRecord = SendMsg(hwndCnr, CM_QUERYRECORD, pRecord,
  1982.                                MPFROM2SHORT(pRecord ? CMA_NEXT : CMA_FIRST,
  1983.                                             CMA_ITEMORDER)))
  1984.    {
  1985.       if (pRecord->pTemplate->ulID == ulTemplateID)
  1986.       {
  1987.          if (pRecord->hwndSettings)
  1988.             WinDestroyWindow(pRecord->hwndSettings);
  1989.          pRecord->hwndSettings = NULLHANDLE;
  1990.  
  1991.          SendMsg(hwndCnr, CM_SETRECORDEMPHASIS, pRecord,
  1992.                     MPFROM2SHORT(FALSE, CRA_INUSE));
  1993.          break;
  1994.       }
  1995.    }
  1996.  
  1997.    return;
  1998. }
  1999.  
  2000. /*---------------------------------------------------------------------------*/
  2001. /* Funktionsname: TemplateDragover                                           */
  2002. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2003. /* Beschreibung: Behandelt Drag-Over eines Templates                         */
  2004. /*                                                                           */
  2005. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2006. /* Parameter: hwnd: Template-Folder                                          */
  2007. /*            pDragOver: Drag-Infos vom Container                            */
  2008. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2009. /* Rückgabewerte: MRESULT wie fuer DM_DRAGOVER                               */
  2010. /*                                                                           */
  2011. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2012. /* Sonstiges: -                                                              */
  2013. /*                                                                           */
  2014. /*---------------------------------------------------------------------------*/
  2015.  
  2016. static MRESULT TemplateDragover(HWND hwnd, PCNRDRAGINFO pDragOver)
  2017. {
  2018.    USHORT usDrop = DOR_NEVERDROP;
  2019.    USHORT usDefaultOp = DO_UNKNOWN;
  2020.  
  2021.    hwnd = hwnd;
  2022.  
  2023.    if (!pDragOver->pRecord)
  2024.    {
  2025.       DrgAccessDraginfo(pDragOver->pDragInfo);
  2026.       if (pDragOver->pDragInfo->usOperation == DO_COPY)
  2027.       {
  2028.          if (WinQueryAnchorBlock(pDragOver->pDragInfo->hwndSource) == anchor)
  2029.          {
  2030.             DRAGITEM dItem;
  2031.             DrgQueryDragitem(pDragOver->pDragInfo, sizeof(dItem), &dItem, 0);
  2032.  
  2033.             if (DrgVerifyType(&dItem, "FleetStreet Template"))
  2034.                usDrop = DOR_DROP;
  2035.          }
  2036.       }
  2037.       else
  2038.          usDrop = DOR_NODROP;
  2039.  
  2040.       DrgFreeDraginfo(pDragOver->pDragInfo);
  2041.    }
  2042.    else
  2043.       usDrop = DOR_NODROP;
  2044.  
  2045.    return MRFROM2SHORT(usDrop, usDefaultOp);
  2046. }
  2047.  
  2048. /*---------------------------------------------------------------------------*/
  2049. /* Funktionsname: TemplateDrop                                               */
  2050. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2051. /* Beschreibung: Behandelt Drop eines Templates (kopiert Template)           */
  2052. /*                                                                           */
  2053. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2054. /* Parameter: hwnd: Template-Folder                                          */
  2055. /*            pCnrDrop: Drop-Infos vom Container                             */
  2056. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2057. /* Rückgabewerte: -                                                          */
  2058. /*                                                                           */
  2059. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  2060. /* Sonstiges: -                                                              */
  2061. /*                                                                           */
  2062. /*---------------------------------------------------------------------------*/
  2063.  
  2064. static void TemplateDrop(HWND hwnd, PCNRDRAGINFO pCnrDrop, PTPLFOLDERDATA pTplFolderData)
  2065. {
  2066.    PTPLRECORD pNewTemplate;
  2067.  
  2068.    if (!pCnrDrop->pRecord)
  2069.    {
  2070.       DrgAccessDraginfo(pCnrDrop->pDragInfo);
  2071.       if (pCnrDrop->pDragInfo->usOperation == DO_COPY)
  2072.       {
  2073.          if (WinQueryAnchorBlock(pCnrDrop->pDragInfo->hwndSource) == anchor)
  2074.          {
  2075.             DRAGITEM dItem;
  2076.             DrgQueryDragitem(pCnrDrop->pDragInfo, sizeof(dItem), &dItem, 0);
  2077.  
  2078.             if (DrgVerifyType(&dItem, "FleetStreet Template"))
  2079.             {
  2080.                /* Template suchen */
  2081.                extern TEMPLATELIST templatelist;
  2082.                PMSGTEMPLATE pTemplate = templatelist.pTemplates;
  2083.  
  2084.                while(pTemplate)
  2085.                {
  2086.                   if (pTemplate->ulID == dItem.ulItemID)
  2087.                      break;
  2088.                   pTemplate = pTemplate->next;
  2089.                }
  2090.                /* Template kopieren */
  2091.                pNewTemplate = CopyTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1),
  2092.                                            pTplFolderData->hptrTemplate,
  2093.                                            pTemplate);
  2094.                if (pNewTemplate)
  2095.                   OpenTemplate(WinWindowFromID(hwnd, IDD_TPLFOLDER+1), pNewTemplate);
  2096.             }
  2097.          }
  2098.       }
  2099.  
  2100.       DrgFreeDraginfo(pCnrDrop->pDragInfo);
  2101.    }
  2102.  
  2103.    return;
  2104. }
  2105. /*-------------------------------- Modulende --------------------------------*/
  2106.  
  2107.