home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / attachcheck.c < prev    next >
C/C++ Source or Header  |  1999-02-14  |  19KB  |  486 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: ATTACHCHECK.C                                                      |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 06.01.1994                  |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x PM                                                       |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |  Prüfung der File-Attaches von FleetStreet                                |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18. #pragma strings(readonly)
  19.  
  20. #define INCL_BASE
  21. #define INCL_PM
  22. #include <os2.h>
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include "main.h"
  27. #include "resids.h"
  28. #include "structs.h"
  29. #include "msgheader.h"
  30. #include "areaman\areaman.h"
  31. #include "dialogids.h"
  32. #include "utility.h"
  33. #include "attachcheck.h"
  34.  
  35. /*--------------------------------- Defines ---------------------------------*/
  36.  
  37. #define SIZE_FINDBUFFER  2048
  38.  
  39. /*---------------------------------- Typen ----------------------------------*/
  40.  
  41. typedef struct _FILELIST {
  42.          struct _FILELIST *next;
  43.          char pchFileName[LEN_PATHNAME+1];
  44.          ULONG ulSize;
  45.          BOOL bFound;
  46.        } FILELIST, *PFILELIST;
  47.  
  48. typedef struct _CHECKATPAR {
  49.          USHORT cb;
  50.          PFILELIST pFileList;
  51.          ULONG ulCountRecords;
  52.        } CHECKATPAR, *PCHECKATPAR;
  53.  
  54. typedef struct {
  55.          MINIRECORDCORE RecordCore;
  56.          PCHAR pchFileName;
  57.          ULONG ulSize;
  58.          PCHAR pchStatus;
  59.       } ATTACHRECORD, *PATTACHRECORD;
  60.  
  61. /*---------------------------- Globale Variablen ----------------------------*/
  62.  
  63. extern HWND hwndhelp;
  64. extern HMODULE hmodLang;
  65.  
  66. PFNWP OldAttachContainerProc;
  67.  
  68. /*----------------------- interne Funktionsprototypen -----------------------*/
  69.  
  70. static PFILELIST CheckFileMask(char *pchFile);
  71. static MRESULT EXPENTRY AttachStatProc(HWND hwnd, ULONG message, MPARAM mp1,
  72.                                        MPARAM mp2);
  73. static MRESULT EXPENTRY NewAttachContainerProc(HWND hwnd, ULONG message,
  74.                                                MPARAM mp1, MPARAM mp2);
  75.  
  76.  
  77. /*---------------------------------------------------------------------------+
  78.  | Funktionsname: CheckAttaches                                              |
  79.  +---------------------------------------------------------------------------+
  80.  | Beschreibung: Prueft die Files, die in dem String enthalten sind          |
  81.  |                                                                           |
  82.  +---------------------------------------------------------------------------+
  83.  | Parameter: pchFiles: Filenamen, durch Leerzeichen getrennt                |
  84.  |                      (wie Subject)                                        |
  85.  |            hwndClient: Fensterhandle des Client-Windows                   |
  86.  +---------------------------------------------------------------------------+
  87.  | Rückgabewerte: 0    alle Files OK                                         |
  88.  |                1    keine Files                                           |
  89.  |                2    mindestens ein File nicht OK                          |
  90.  +---------------------------------------------------------------------------+
  91.  | Sonstiges:                                                                |
  92.  |                                                                           |
  93.  +---------------------------------------------------------------------------*/
  94.  
  95. int CheckAttaches(PCHAR pchFiles, HWND hwndClient)
  96. {
  97.    PFILELIST pFileList=NULL, pLast=NULL;
  98.    PFILELIST pTemp=NULL;
  99.    PCHAR pchSingleFile=NULL;
  100.    int returncode=0;
  101.    CHECKATPAR CheckAtPar;
  102.    ULONG ulCountRecords=0;
  103.  
  104.    if (pchFiles == NULL ||
  105.        !pchFiles[0])
  106.       return 1;
  107.  
  108.    pchSingleFile=strtok(pchFiles, " \t");
  109.  
  110.    if (!pchSingleFile)
  111.       return 1;
  112.  
  113.    /* Jetzt sind echt Files da */
  114.    do
  115.    {
  116.      /* Filedaten holen */
  117.      pTemp = CheckFileMask(pchSingleFile);
  118.  
  119.      if (pFileList)
  120.      {
  121.         /* hinten anhaengen */
  122.         pLast->next = pTemp;
  123.      }
  124.      else
  125.         pFileList = pLast = pTemp;
  126.  
  127.      /* letzten Record wieder suchen */
  128.      while(pLast->next)
  129.         pLast = pLast->next;
  130.  
  131.    } while (pchSingleFile=strtok(NULL, " \t"));
  132.  
  133.    /* Ergebnis zaehlen */
  134.    pLast = pFileList;
  135.    while (pLast)
  136.    {
  137.       ulCountRecords++;
  138.       pLast = pLast->next;
  139.    }
  140.  
  141.    /* Ergebnis anzeigen */
  142.    CheckAtPar.cb=sizeof(CHECKATPAR);
  143.    CheckAtPar.pFileList=pFileList;
  144.    CheckAtPar.ulCountRecords=ulCountRecords;
  145.  
  146.    WinDlgBox(HWND_DESKTOP, hwndClient, AttachStatProc, hmodLang,
  147.              IDD_ATTACHSTAT, &CheckAtPar);
  148.  
  149.    /* Ganzen Krempel wieder freigeben */
  150.    while (pFileList)
  151.    {
  152.       pTemp=pFileList->next;
  153.       free(pFileList);
  154.       pFileList=pTemp;
  155.    }
  156.  
  157.    return returncode;
  158. }
  159.  
  160.  
  161. /*---------------------------------------------------------------------------+
  162.  | Funktionsname: CheckFileMask                                              |
  163.  +---------------------------------------------------------------------------+
  164.  | Beschreibung: Prueft ein einzelnes File und traegt die Daten ein          |
  165.  |                                                                           |
  166.  +---------------------------------------------------------------------------+
  167.  | Parameter: pchFile: Filename (evtl. mit Wildcards)                        |
  168.  |                                                                           |
  169.  +---------------------------------------------------------------------------+
  170.  | Rückgabewerte: Liste der Files                                            |
  171.  |                                                                           |
  172.  +---------------------------------------------------------------------------+
  173.  | Sonstiges:                                                                |
  174.  |                                                                           |
  175.  +---------------------------------------------------------------------------*/
  176.  
  177. static PFILELIST CheckFileMask(char *pchFile)
  178. {
  179.    PFILELIST pFirst=NULL, pLast=NULL;
  180.    PFILEFINDBUF3 pfindbuf, pResult;
  181.    ULONG ulFindCount=SIZE_FINDBUFFER/sizeof(FILEFINDBUF3);
  182.    HDIR hdir=HDIR_CREATE;
  183.  
  184.    /* Zeichen f. Delete und Trucate uebergehen */
  185.    if (*pchFile == '^' ||
  186.        *pchFile == '#')
  187.       pchFile++;
  188.  
  189.    pfindbuf=malloc(SIZE_FINDBUFFER);
  190.  
  191.    if (DosFindFirst(pchFile, &hdir, FILE_ARCHIVED | FILE_READONLY, pfindbuf,
  192.                     SIZE_FINDBUFFER, &ulFindCount, FIL_STANDARD))
  193.    {
  194.       /* nichts gefunden */
  195.       pFirst = calloc(1, sizeof(FILELIST));
  196.  
  197.       strcpy(pFirst->pchFileName, pchFile);
  198.  
  199.       return pFirst;
  200.    }
  201.    do
  202.    {
  203.       pResult = pfindbuf;
  204.       do
  205.       {
  206.          /* gefundenes File einhaengen */
  207.          if (pFirst)
  208.          {
  209.             pLast->next = calloc(1, sizeof(FILELIST));
  210.             pLast = pLast->next;
  211.          }
  212.          else
  213.             pFirst = pLast = calloc(1, sizeof(FILELIST));
  214.  
  215.          strcpy(pLast->pchFileName, pResult->achName);
  216.          pLast->ulSize = pResult->cbFile;
  217.          pLast->bFound = TRUE;
  218.  
  219.          /* weiter im Suchpuffer */
  220.          if (pResult->oNextEntryOffset)
  221.             pResult = (PFILEFINDBUF3)(((PCHAR) pResult) + pResult->oNextEntryOffset);
  222.          else
  223.             pResult = NULL;
  224.       } while (pResult);
  225.  
  226.       ulFindCount=SIZE_FINDBUFFER/sizeof(FILEFINDBUF3);
  227.    } while (DosFindNext(hdir, pfindbuf, SIZE_FINDBUFFER, &ulFindCount)<ERROR_NO_MORE_FILES);
  228.  
  229.    DosFindClose(hdir);
  230.  
  231.    free(pfindbuf);
  232.  
  233.    return pFirst;
  234. }
  235.  
  236. /*---------------------------------------------------------------------------+
  237.  | Funktionsname: AttachStatProc                                             |
  238.  +---------------------------------------------------------------------------+
  239.  | Beschreibung: Fensterprozedur des Ergebnisfensters                        |
  240.  |                                                                           |
  241.  +---------------------------------------------------------------------------+
  242.  | Parameter: (Window-Procedure)                                             |
  243.  |                                                                           |
  244.  +---------------------------------------------------------------------------+
  245.  | Rückgabewerte: MRESULT                                                    |
  246.  |                                                                           |
  247.  +---------------------------------------------------------------------------+
  248.  | Sonstiges:                                                                |
  249.  |                                                                           |
  250.  +---------------------------------------------------------------------------*/
  251.  
  252. static MRESULT EXPENTRY AttachStatProc(HWND hwnd, ULONG message, MPARAM mp1,
  253.                                        MPARAM mp2)
  254. {
  255.    extern WINDOWPOSITIONS windowpositions;
  256.    extern WINDOWCOLORS windowcolors;
  257.    extern WINDOWFONTS windowfonts;
  258.    extern HWND frame;
  259.    extern HWND hwndhelp;
  260.    PCHECKATPAR pCheckPar=NULL;
  261.    PFIELDINFO pFieldInfo, pFirstFieldInfo;
  262.    FIELDINFOINSERT FieldInfoInsert;
  263.    CNRINFO CnrInfo;
  264.    PATTACHRECORD pRecord, pFirstRecord;
  265.    RECORDINSERT RecordInsert;
  266.    HWND hwndCnr;
  267.    PFILELIST pTemp;
  268.  
  269.    static char pchTitleFile[50];
  270.    static char pchTitleSize[50];
  271.    static char pchTitleStatus[50];
  272.    static char pchOK[50];
  273.    static char pchNotFound[50];
  274.  
  275.    switch(message)
  276.    {
  277.       case WM_INITDLG:
  278.          pCheckPar=(PCHECKATPAR) mp2;
  279.          LoadString(IDST_ATT_TITLEFILE,   50, pchTitleFile);
  280.          LoadString(IDST_ATT_TITLESIZE,   50, pchTitleSize);
  281.          LoadString(IDST_ATT_TITLESTATUS, 50, pchTitleStatus);
  282.          LoadString(IDST_ATT_OK,          50, pchOK);
  283.          LoadString(IDST_ATT_NOTF,        50, pchNotFound);
  284.  
  285.          WinAssociateHelpInstance(hwndhelp, hwnd);
  286.  
  287.          hwndCnr=WinWindowFromID(hwnd, IDD_ATTACHSTAT+2);
  288.          OldAttachContainerProc=WinSubclassWindow(hwndCnr,
  289.                                                   NewAttachContainerProc);
  290.  
  291.          SetFont(hwndCnr, windowfonts.attachfont);
  292.          SetForeground(hwndCnr, &windowcolors.attachfore);
  293.          SetBackground(hwndCnr, &windowcolors.attachback);
  294.  
  295.          /* Felder des Containers vorbereiten */
  296.          pFirstFieldInfo=(PFIELDINFO)SendMsg(hwndCnr,
  297.                                                 CM_ALLOCDETAILFIELDINFO,
  298.                                                 MPFROMLONG(3), NULL);
  299.  
  300.          pFieldInfo=pFirstFieldInfo;
  301.  
  302.          pFieldInfo->cb=sizeof(FIELDINFO);
  303.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  304.          pFieldInfo->flTitle=0;
  305.          pFieldInfo->pTitleData= pchTitleFile;
  306.          pFieldInfo->offStruct= FIELDOFFSET(ATTACHRECORD, pchFileName);
  307.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  308.  
  309.          pFieldInfo->cb=sizeof(FIELDINFO);
  310.          pFieldInfo->flData=CFA_ULONG | CFA_HORZSEPARATOR | CFA_SEPARATOR |
  311.                             CFA_RIGHT;
  312.          pFieldInfo->flTitle=0;
  313.          pFieldInfo->pTitleData= pchTitleSize;
  314.          pFieldInfo->offStruct= FIELDOFFSET(ATTACHRECORD, ulSize);
  315.          pFieldInfo=pFieldInfo->pNextFieldInfo;
  316.  
  317.          pFieldInfo->cb=sizeof(FIELDINFO);
  318.          pFieldInfo->flData=CFA_STRING | CFA_HORZSEPARATOR | CFA_SEPARATOR |
  319.                             CFA_CENTER;
  320.          pFieldInfo->flTitle=0;
  321.          pFieldInfo->pTitleData= pchTitleStatus;
  322.          pFieldInfo->offStruct= FIELDOFFSET(ATTACHRECORD, pchStatus);
  323.  
  324.          /* Felder des Containers einfuegen */
  325.          FieldInfoInsert.cb=sizeof(FIELDINFOINSERT);
  326.          FieldInfoInsert.pFieldInfoOrder=(PFIELDINFO) CMA_FIRST;
  327.          FieldInfoInsert.fInvalidateFieldInfo=TRUE;
  328.          FieldInfoInsert.cFieldInfoInsert=3;
  329.  
  330.          SendMsg(hwndCnr, CM_INSERTDETAILFIELDINFO,
  331.                     pFirstFieldInfo, &FieldInfoInsert);
  332.  
  333.          /* Container-Attribute setzen */
  334.          CnrInfo.cb=sizeof(CNRINFO);
  335.          CnrInfo.pFieldInfoLast=NULL;
  336.          CnrInfo.flWindowAttr=CV_DETAIL | CA_DETAILSVIEWTITLES;
  337.          CnrInfo.xVertSplitbar=0;
  338.  
  339.          SendMsg(hwndCnr, CM_SETCNRINFO, &CnrInfo,
  340.                     MPFROMLONG(CMA_FLWINDOWATTR));
  341.  
  342.          /* Elemente einfuegen */
  343.  
  344.          pFirstRecord=(PATTACHRECORD)SendMsg(hwndCnr, CM_ALLOCRECORD,
  345.                            MPFROMLONG(sizeof(ATTACHRECORD)-sizeof(MINIRECORDCORE)),
  346.                            MPFROMLONG(pCheckPar->ulCountRecords));
  347.          pRecord=pFirstRecord;
  348.          pTemp=pCheckPar->pFileList;
  349.          while(pTemp)
  350.          {
  351.             pRecord->pchFileName=pTemp->pchFileName;
  352.             pRecord->ulSize=pTemp->ulSize;
  353.             if (pTemp->bFound)
  354.                 pRecord->pchStatus = pchOK;
  355.             else
  356.                 pRecord->pchStatus = pchNotFound;
  357.  
  358.             pRecord=(PATTACHRECORD)pRecord->RecordCore.preccNextRecord;
  359.             pTemp=pTemp->next;
  360.          }
  361.  
  362.          RecordInsert.cb=sizeof(RECORDINSERT);
  363.          RecordInsert.pRecordOrder=(PRECORDCORE) CMA_FIRST;
  364.          RecordInsert.pRecordParent=NULL;
  365.          RecordInsert.fInvalidateRecord=TRUE;
  366.          RecordInsert.zOrder=CMA_TOP;
  367.          RecordInsert.cRecordsInsert=pCheckPar->ulCountRecords;
  368.  
  369.          SendMsg(hwndCnr, CM_INSERTRECORD, pFirstRecord, &RecordInsert);
  370.  
  371.          RestoreWinPos(hwnd, &windowpositions.attachpos, FALSE, TRUE);
  372.          break;
  373.  
  374.       case WM_DESTROY:
  375.          QueryWinPos(hwnd, &windowpositions.attachpos);
  376.          QueryFont(WinWindowFromID(hwnd, IDD_ATTACHSTAT+2),
  377.                    windowfonts.attachfont);
  378.          QueryForeground(WinWindowFromID(hwnd, IDD_ATTACHSTAT+2),
  379.                          &windowcolors.attachfore);
  380.          QueryBackground(WinWindowFromID(hwnd, IDD_ATTACHSTAT+2),
  381.                          &windowcolors.attachback);
  382.          WinAssociateHelpInstance(hwndhelp, frame);
  383.          break;
  384.  
  385.       default:
  386.          break;
  387.    }
  388.    return WinDefDlgProc(hwnd, message, mp1, mp2);
  389. }
  390.  
  391. /*---------------------------------------------------------------------------+
  392.  | Funktionsname: NewAttachContainerProc                                     |
  393.  +---------------------------------------------------------------------------+
  394.  | Beschreibung: Neue Window-Procedure f. Container (wg. OS/2-Bug)           |
  395.  +---------------------------------------------------------------------------+
  396.  | Parameter: (Window-Procedure)                                             |
  397.  +---------------------------------------------------------------------------+
  398.  | Rückgabewerte: MRESULT                                                    |
  399.  +---------------------------------------------------------------------------+
  400.  | Sonstiges:                                                                |
  401.  +---------------------------------------------------------------------------*/
  402.  
  403. static MRESULT EXPENTRY NewAttachContainerProc(HWND hwnd, ULONG message,
  404.                                                MPARAM mp1, MPARAM mp2)
  405. {
  406.    switch(message)
  407.    {
  408.       case DM_DRAGOVER:
  409.          DrgAccessDraginfo(mp1);
  410.          break;
  411.  
  412.       default:
  413.          break;
  414.    }
  415.    return OldAttachContainerProc(hwnd, message, mp1, mp2);
  416. }
  417.  
  418. /*---------------------------------------------------------------------------*/
  419. /* Funktionsname: GetAttachedFiles                                           */
  420. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  421. /* Beschreibung: Holt die Namen der Angehaengten Files per File-Dialog       */
  422. /*                                                                           */
  423. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  424. /* Parameter: hwndOwner: Owner-Window fuer File-Dialog.                      */
  425. /*                                                                           */
  426. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  427. /* Rückgabewerte: TRUE: Files angehaengt                                     */
  428. /*                FALSE: keine Files angehaengt (z.B. Abbruch)               */
  429. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  430. /* Sonstiges: -                                                              */
  431. /*                                                                           */
  432. /*---------------------------------------------------------------------------*/
  433.  
  434. BOOL GetAttachedFiles(HWND hwndOwner, char *pchSubject, char *pchDefaultDir)
  435. {
  436.    FILEDLG FileDlg;
  437.    BOOL rc=FALSE;
  438.  
  439.    memset(&FileDlg, 0, sizeof(FileDlg));
  440.  
  441.    FileDlg.cbSize = sizeof(FileDlg);
  442.    FileDlg.fl = FDS_CENTER | FDS_HELPBUTTON | FDS_MULTIPLESEL | FDS_OPEN_DIALOG;
  443.    FileDlg.pszTitle = calloc(1, 200);
  444.    LoadString(IDST_TITLE_ATTACHFILES, 200, FileDlg.pszTitle);
  445.  
  446.    if (pchDefaultDir[0])
  447.    {
  448.       strcpy(FileDlg.szFullFile, pchDefaultDir);
  449.       strcat(FileDlg.szFullFile, "\\*");
  450.    }
  451.  
  452.    if (WinFileDlg(HWND_DESKTOP, hwndOwner, &FileDlg) &&
  453.        FileDlg.lReturn == DID_OK)
  454.    {
  455.       if (FileDlg.ulFQFCount && FileDlg.papszFQFilename)
  456.       {
  457.          int iFile=0;
  458.  
  459.          while (iFile < FileDlg.ulFQFCount)
  460.          {
  461.             if (strlen(pchSubject) +
  462.                 strlen(*FileDlg.papszFQFilename[iFile]) +
  463.                 (*pchSubject ? 1:0) <= LEN_SUBJECT)  /* noch genug Platz */
  464.             {
  465.                /* Name anhaengen */
  466.                if (*pchSubject)
  467.                   strcat(pchSubject, " ");
  468.                strcat(pchSubject, *FileDlg.papszFQFilename[iFile]);
  469.                iFile++;
  470.             }
  471.             else
  472.                break; /* kein Platz, sofort beenden */
  473.          }
  474.  
  475.          WinFreeFileDlgList(FileDlg.papszFQFilename);
  476.          rc= TRUE;
  477.       }
  478.    }
  479.  
  480.    free(FileDlg.pszTitle);
  481.    return rc;
  482. }
  483.  
  484. /*-------------------------------- Modulende --------------------------------*/
  485.  
  486.