home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / ccmanage.c < prev    next >
C/C++ Source or Header  |  1999-02-14  |  12KB  |  288 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: CCMANAGE.C                                                         |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 28.07.1994                  |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x                                                          |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |   Funktionen zur Behandlung von CC-Listen                                 |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18.  
  19. #include <os2.h>
  20. #include <string.h>
  21. #include <stdlib.h>
  22. #include "main.h"
  23. #include "structs.h"
  24. #include "ccmanage.h"
  25.  
  26. /*---------------------------------------------------------------------------*/
  27. /* Funktionsname: QueryCCList                                                */
  28. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  29. /* Beschreibung: Sucht die CC-Liste nach ID und liefert Zeiger auf Liste     */
  30. /*                                                                           */
  31. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  32. /* Parameter: pAnchor: Anker der Listen                                      */
  33. /*            ulListID: gesuchte ID                                          */
  34. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  35. /* Rückgabewerte: NULL  nicht gefunden                                       */
  36. /*                sonst Zeiger auf Liste                                     */
  37. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  38. /* Sonstiges:                                                                */
  39. /*                                                                           */
  40. /*---------------------------------------------------------------------------*/
  41.  
  42. PCCLIST QueryCCList(PCCANCHOR pAnchor, ULONG ulListID)
  43. {
  44.    PCCLIST pList = pAnchor->pLists;
  45.  
  46.    while(pList && pList->ulListID != ulListID)
  47.       pList = pList->next;
  48.  
  49.    return pList;
  50. }
  51.  
  52. /*---------------------------------------------------------------------------*/
  53. /* Funktionsname: HaveCCListName                                             */
  54. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  55. /* Beschreibung: Stellt fest, ob eine Liste mit dem gegebenen Namen existiert*/
  56. /*                                                                           */
  57. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  58. /* Parameter: pAnchor: Anker der Listen                                      */
  59. /*            pchName: gesuchter Name                                        */
  60. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  61. /* Rückgabewerte: TRUE  Liste mit Name existiert                             */
  62. /*                FALSE Liste existiert nicht                                */
  63. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  64. /* Sonstiges: Wird fuer Erzeugen eines Names gebraucht                       */
  65. /*                                                                           */
  66. /*---------------------------------------------------------------------------*/
  67.  
  68. int HaveCCListName(void *pAnchor, char *pchName)
  69. {
  70.    PCCLIST pList = ((PCCANCHOR)pAnchor)->pLists;
  71.  
  72.    while(pList)
  73.       if (!strcmp(pList->pchListName, pchName))
  74.          return TRUE;
  75.       else
  76.          pList = pList->next;
  77.  
  78.    return FALSE;
  79. }
  80.  
  81. /*---------------------------------------------------------------------------*/
  82. /* Funktionsname: AddCCList                                                  */
  83. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  84. /* Beschreibung: Erzeugt eine neue, leere CC-Liste                           */
  85. /*                                                                           */
  86. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  87. /* Parameter: pAnchor: Anker aller Listen                                    */
  88. /*            pchListName: Name fuer die neue Liste                          */
  89. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  90. /* Rückgabewerte: Zeiger auf die neue Liste                                  */
  91. /*                                                                           */
  92. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  93. /* Sonstiges:                                                                */
  94. /*                                                                           */
  95. /*---------------------------------------------------------------------------*/
  96.  
  97. PCCLIST AddCCList(PCCANCHOR pAnchor, PCHAR pchListName)
  98. {
  99.    PCCLIST pNewList;
  100.    PCCLIST pTemp;
  101.    ULONG   ulNewID = 0;
  102.  
  103.    pNewList = calloc(1, sizeof(CCLIST));
  104.    if (!pNewList)
  105.       return NULL;
  106.  
  107.    /* Daten vorbelegen */
  108.    pNewList->bDirty = TRUE;
  109.    if (pchListName)
  110.       pNewList->pchListName = strdup(pchListName);
  111.  
  112.    /* neue ID suchen */
  113.    pTemp = pAnchor->pLists;
  114.    while (pTemp)
  115.    {
  116.       if (pTemp->ulListID > ulNewID)
  117.          ulNewID = pTemp->ulListID;
  118.       pTemp = pTemp->next;
  119.    }
  120.    ulNewID++;   /* ist beim ersten Mal 1, danach groesser */
  121.  
  122.    pNewList->ulListID = ulNewID;
  123.  
  124.    if (pAnchor->pLists)
  125.    {
  126.       /* Liste vorne einhaengen */
  127.       pNewList->next = pAnchor->pLists;
  128.       pAnchor->pLists->prev = pNewList;
  129.       pAnchor->pLists = pNewList;
  130.    }
  131.    else
  132.    {
  133.       /* erste Liste */
  134.       pAnchor->pLists = pNewList;
  135.    }
  136.  
  137.    /* Eine mehr */
  138.    pAnchor->ulNumLists++;
  139.    pAnchor->bDirty = TRUE;
  140.  
  141.    return pNewList;
  142. }
  143.  
  144. /*---------------------------------------------------------------------------*/
  145. /* Funktionsname: DeleteCCList                                               */
  146. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  147. /* Beschreibung: Loescht eine Liste, ggf. mit allen anhängenden              */
  148. /*               Eintraegen                                                  */
  149. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  150. /* Parameter: pAnchor: Anker aller Listen                                    */
  151. /*            pList: Zeiger der zu loeschenden Liste                         */
  152. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  153. /* Rückgabewerte: TRUE  Erfolg                                               */
  154. /*                FALSE Fehler                                               */
  155. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  156. /* Sonstiges:                                                                */
  157. /*                                                                           */
  158. /*---------------------------------------------------------------------------*/
  159.  
  160. BOOL DeleteCCList(PCCANCHOR pAnchor, PCCLIST pList)
  161. {
  162.    PCCENTRY pEntry, pEntry2;
  163.  
  164.    /* Erst auf Eintraege pruefen */
  165.    pEntry = pList->pEntries;
  166.  
  167.    while (pEntry)
  168.    {
  169.       pEntry2 = pEntry;
  170.       pEntry = pEntry->next;
  171.       free(pEntry2);
  172.    }
  173.  
  174.    /* erste Liste? */
  175.    if (pList == pAnchor->pLists)
  176.       pAnchor->pLists = pList->next;
  177.  
  178.    /* Liste loeschen */
  179.    if (pList->prev)
  180.       pList->prev->next = pList->next;
  181.    if (pList->next)
  182.       pList->next->prev = pList->prev;
  183.    if (pList->pchListName)
  184.       free(pList->pchListName);
  185.    free(pList);
  186.  
  187.    /* eine weniger */
  188.    pAnchor->ulNumLists--;
  189.    pAnchor->bDirty = TRUE;
  190.  
  191.    return TRUE;
  192. }
  193.  
  194. /*---------------------------------------------------------------------------*/
  195. /* Funktionsname: AddCCEntry                                                 */
  196. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  197. /* Beschreibung: Erzeugt neuen Eintrag in der Liste, kopiert vorgegebene     */
  198. /*               Daten                                                       */
  199. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  200. /* Parameter: pAnchor: Anker aller Listen                                    */
  201. /*            pList: Zeiger auf Liste                                        */
  202. /*            pEntry: Default-Daten                                          */
  203. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  204. /* Rückgabewerte: Zeiger auf neuen Eintrag                                   */
  205. /*                                                                           */
  206. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  207. /* Sonstiges:                                                                */
  208. /*                                                                           */
  209. /*---------------------------------------------------------------------------*/
  210.  
  211. PCCENTRY AddCCEntry(PCCANCHOR pAnchor, PCCLIST pList, PCCENTRY pEntry)
  212. {
  213.    PCCENTRY pNewEntry;
  214.  
  215.    pNewEntry = calloc(1, sizeof(CCENTRY));
  216.  
  217.    if (pList->pEntries)
  218.    {
  219.       /* vorne Anhaengen */
  220.       pNewEntry->next = pList->pEntries;
  221.       pList->pEntries->prev = pNewEntry;
  222.       pList->pEntries = pNewEntry;
  223.    }
  224.    else
  225.    {
  226.       /* erster Eintrag */
  227.       pList->pEntries = pNewEntry;
  228.    }
  229.  
  230.    /* Default setzen */
  231.    pNewEntry->ulFlags = CCENTRY_MENTION;
  232.  
  233.    /* evtl. Daten uebernehmen */
  234.    if (pEntry)
  235.    {
  236.       strncpy(pNewEntry->pchName, pEntry->pchName, LEN_USERNAME);
  237.       strncpy(pNewEntry->pchAddress, pEntry->pchAddress, LEN_5DADDRESS);
  238.       strncpy(pNewEntry->pchFirstLine, pEntry->pchFirstLine, LEN_FIRSTLINE);
  239.       pNewEntry->ulFlags = pEntry->ulFlags;
  240.    }
  241.  
  242.    pList->bDirty = TRUE;
  243.    if (pAnchor)
  244.       pAnchor->bDirty = TRUE;
  245.  
  246.    return pNewEntry;
  247. }
  248.  
  249. /*---------------------------------------------------------------------------*/
  250. /* Funktionsname: DeleteCCEntry                                              */
  251. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  252. /* Beschreibung: Loescht einen Eintrag                                       */
  253. /*                                                                           */
  254. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  255. /* Parameter: pAnchor: Anker aller Listen                                    */
  256. /*            pList: Zeiger auf Listen-Anfang                                */
  257. /*            pEntry: zu loeschender Eintrag                                 */
  258. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  259. /* Rückgabewerte: TRUE   Erfolg                                              */
  260. /*                FALSE  Fehler                                              */
  261. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  262. /* Sonstiges:                                                                */
  263. /*                                                                           */
  264. /*---------------------------------------------------------------------------*/
  265.  
  266. BOOL DeleteCCEntry(PCCANCHOR pAnchor, PCCLIST pList, PCCENTRY pEntry)
  267. {
  268.    /* erster Eintrag ? */
  269.    if (pList->pEntries == pEntry)
  270.       pList->pEntries = pEntry->next;
  271.  
  272.    /* freigeben */
  273.    if (pEntry->prev)
  274.       pEntry->prev->next = pEntry->next;
  275.    if (pEntry->next)
  276.       pEntry->next->prev = pEntry->prev;
  277.    free(pEntry);
  278.  
  279.    pList->bDirty = TRUE;
  280.    if (pAnchor)
  281.       pAnchor->bDirty = TRUE;
  282.  
  283.    return TRUE;
  284. }
  285.  
  286. /*-------------------------------- Modulende --------------------------------*/
  287.  
  288.