home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / fsrc1241.zip / nickmanage.c < prev    next >
C/C++ Source or Header  |  1999-02-14  |  11KB  |  232 lines
  1. /*---------------------------------------------------------------------------+
  2.  | Titel: NICKMANAGE.C                                                       |
  3.  +-----------------------------------------+---------------------------------+
  4.  | Erstellt von: Michael Hohner            | Am: 09.04.1995                  |
  5.  +-----------------------------------------+---------------------------------+
  6.  | System: OS/2 2.x                                                          |
  7.  +---------------------------------------------------------------------------+
  8.  | Beschreibung:                                                             |
  9.  |                                                                           |
  10.  |   Verwaltung der Nicknames                                                |
  11.  |                                                                           |
  12.  |                                                                           |
  13.  +---------------------------------------------------------------------------+
  14.  | Bemerkungen:                                                              |
  15.  +---------------------------------------------------------------------------*/
  16.  
  17. /*----------------------------- Header-Dateien ------------------------------*/
  18. #pragma strings(readonly)
  19.  
  20. #include <os2.h>
  21. #include <string.h>
  22. #include <stdlib.h>
  23. #include "main.h"
  24. #include "structs.h"
  25. #include "nickmanage.h"
  26.  
  27. /*--------------------------------- Defines ---------------------------------*/
  28.  
  29. /*---------------------------------- Typen ----------------------------------*/
  30.  
  31. /*---------------------------- Globale Variablen ----------------------------*/
  32.  
  33. /*--------------------------- Funktionsprototypen ---------------------------*/
  34.  
  35. /*----------------------- interne Funktionsprototypen -----------------------*/
  36.  
  37. /*---------------------------------------------------------------------------*/
  38. /* Funktionsname: AddNickname                                                */
  39. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  40. /* Beschreibung: Fuegt einen Nickname zur Liste hinzu                        */
  41. /*                                                                           */
  42. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  43. /* Parameter: pList: Listenkopf                                              */
  44. /*            pNickname: neuer Nickname, wird kopiert                        */
  45. /*            bMarkDirty: TRUE: Dirty-Flag wird beim neuen Eintrag gesetzt   */
  46. /*                        FALSE: Flag wird nicht gesetzt                     */
  47. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  48. /* Rückgabewerte: Zeiger auf neuen Eintrag                                   */
  49. /*                NULL  Fehler                                               */
  50. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  51. /* Sonstiges: -                                                              */
  52. /*                                                                           */
  53. /*---------------------------------------------------------------------------*/
  54.  
  55. PNICKNAME AddNickname(PNICKNAMELIST pList, PNICKNAME pNickname, BOOL bMarkDirty)
  56. {
  57.    PNICKNAME pNewEntry;
  58.  
  59.    pNewEntry = calloc(1, sizeof(NICKNAME));
  60.  
  61.    if (pNewEntry)
  62.    {
  63.       /* vorne einhaengen */
  64.       pNewEntry->next = pList->pFirstEntry;
  65.       if (pNewEntry->next)
  66.          pNewEntry->next->prev = pNewEntry;
  67.       pList->pFirstEntry = pNewEntry;
  68.  
  69.       /* Daten uebernehmen */
  70.       memcpy(pNewEntry->usertag, pNickname->usertag, LEN_USERNAME);
  71.       strlwr(pNewEntry->usertag);
  72.       memcpy(pNewEntry->username, pNickname->username, LEN_USERNAME);
  73.       memcpy(pNewEntry->address, pNickname->address, LEN_5DADDRESS);
  74.       memcpy(pNewEntry->subjectline, pNickname->subjectline, LEN_SUBJECT);
  75.       memcpy(pNewEntry->firstline, pNickname->firstline, LEN_FIRSTLINE);
  76.       if (pNickname->pchComment)
  77.          pNewEntry->pchComment = strdup(pNickname->pchComment);
  78.       pNewEntry->ulAttrib = pNickname->ulAttrib;
  79.       pNewEntry->ulFlags = pNickname->ulFlags;
  80.  
  81.       /* Dirty-Flags */
  82.       if (bMarkDirty)
  83.       {
  84.          pNewEntry->bDirty = TRUE;
  85.          pList->bDirty = TRUE;
  86.       }
  87.       pList->ulNumEntries++;
  88.    }
  89.  
  90.    return pNewEntry;
  91. }
  92.  
  93. /*---------------------------------------------------------------------------*/
  94. /* Funktionsname: FindNickname                                               */
  95. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  96. /* Beschreibung: Sucht einen Nickname in der Liste                           */
  97. /*                                                                           */
  98. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  99. /* Parameter: pList: Listenkopf                                              */
  100. /*            pchNickname: Kurzname, nach dem gesucht werden soll            */
  101. /*                         NULL: naechster Eintrag nach pSearchAfter         */
  102. /*            pSearchAfter: Zeiger auf den Eintrag, ab dem gesucht werden    */
  103. /*                          soll (excl. diesem Eintrag). NULL: Vom Anfang    */
  104. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  105. /* Rückgabewerte: Zeiger auf Nickname                                        */
  106. /*                NULL: nicht gefunden oder Liste zu Ende                    */
  107. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  108. /* Sonstiges: Man kann leicht alle Eintraege aufzaehlen durch:               */
  109. /*                                                                           */
  110. /*            PNICKNAME pNick=NULL;                                          */
  111. /*            while (pNick = FindNickname(&List, NULL, pNick))               */
  112. /*            {                                                              */
  113. /*                bearbeiten                                                 */
  114. /*            }                                                              */
  115. /*---------------------------------------------------------------------------*/
  116.  
  117. PNICKNAME FindNickname(PNICKNAMELIST pList, PCHAR pchNickname, PNICKNAME pSearchAfter)
  118. {
  119.    if (!pSearchAfter)
  120.       pSearchAfter = pList->pFirstEntry;
  121.    else
  122.       pSearchAfter = pSearchAfter->next;
  123.  
  124.    while (pSearchAfter && pchNickname && stricmp(pSearchAfter->usertag, pchNickname))
  125.       pSearchAfter = pSearchAfter->next;
  126.  
  127.    return pSearchAfter;
  128. }
  129.  
  130. PNICKNAME FindNicknameSens(PNICKNAMELIST pList, PCHAR pchNickname)
  131. {
  132.    PNICKNAME pSearchAfter = pSearchAfter = pList->pFirstEntry;
  133.  
  134.    while (pSearchAfter && strcmp(pSearchAfter->usertag, pchNickname))
  135.       pSearchAfter = pSearchAfter->next;
  136.  
  137.    return pSearchAfter;
  138. }
  139.  
  140. /*---------------------------------------------------------------------------*/
  141. /* Funktionsname: DeleteNickname                                             */
  142. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  143. /* Beschreibung: Loescht einen Nickname aus der Liste                        */
  144. /*                                                                           */
  145. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  146. /* Parameter: pList: Listen-Kopf                                             */
  147. /*            pchNickname: zu loeschender Nickname                           */
  148. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  149. /* Rückgabewerte: 0   OK                                                     */
  150. /*                sonst  nicht gefunden                                      */
  151. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  152. /* Sonstiges: Dirty-Flag der Liste wird gesetzt                              */
  153. /*                                                                           */
  154. /*---------------------------------------------------------------------------*/
  155.  
  156. int DeleteNickname(PNICKNAMELIST pList, PCHAR pchNickname)
  157. {
  158.    PNICKNAME pDel;
  159.  
  160.    pDel = FindNickname(pList, pchNickname, NULL);
  161.  
  162.    if (pDel)
  163.    {
  164.       if (pDel->pchComment)
  165.          free(pDel->pchComment);
  166.  
  167.       if (pDel->next)
  168.          pDel->next->prev = pDel->prev;
  169.       if (pDel->prev)
  170.          pDel->prev->next = pDel->next;
  171.  
  172.       if (pList->pFirstEntry == pDel)
  173.          pList->pFirstEntry = pDel->next;
  174.  
  175.       free(pDel);
  176.  
  177.       pList->bDirty = TRUE;
  178.       pList->ulNumEntries--;
  179.  
  180.       return 0;
  181.    }
  182.    else
  183.       return -1;
  184. }
  185.  
  186. /*---------------------------------------------------------------------------*/
  187. /* Funktionsname: ChangeNickname                                             */
  188. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  189. /* Beschreibung: Ändert die Daten eines Nicknames                            */
  190. /*                                                                           */
  191. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  192. /* Parameter: pList: Listen-Kopf                                             */
  193. /*            pNickToChange: Zeiger auf Eintrag, der geändert werden soll.   */
  194. /*            pNewNickname: neue Daten, werden kopiert.                      */
  195. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  196. /* Rückgabewerte: 0   OK                                                     */
  197. /*                1   Fehler                                                 */
  198. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  199. /* Sonstiges: Dirty-Flags werden gesetzt                                     */
  200. /*                                                                           */
  201. /*---------------------------------------------------------------------------*/
  202.  
  203. int ChangeNickname(PNICKNAMELIST pList, PNICKNAME pNickToChange, PNICKNAME pNewNickname)
  204. {
  205.    /* Daten uebernehmen */
  206.    memcpy(pNickToChange->usertag, pNewNickname->usertag, LEN_USERNAME);
  207.    strlwr(pNickToChange->usertag);
  208.    memcpy(pNickToChange->username, pNewNickname->username, LEN_USERNAME);
  209.    memcpy(pNickToChange->address, pNewNickname->address, LEN_5DADDRESS);
  210.    memcpy(pNickToChange->subjectline, pNewNickname->subjectline, LEN_SUBJECT);
  211.    memcpy(pNickToChange->firstline, pNewNickname->firstline, LEN_FIRSTLINE);
  212.    if (pNickToChange->pchComment)
  213.    {
  214.       free(pNickToChange->pchComment);
  215.       pNickToChange->pchComment = NULL;
  216.    }
  217.    if (pNewNickname->pchComment)
  218.       pNickToChange->pchComment = strdup(pNewNickname->pchComment);
  219.    pNickToChange->ulAttrib = pNewNickname->ulAttrib;
  220.    pNickToChange->ulFlags = pNewNickname->ulFlags;
  221.  
  222.    /* Dirty-Flags */
  223.    pNickToChange->bDirty = TRUE;
  224.    pList->bDirty = TRUE;
  225.  
  226.    return 0;
  227. }
  228.  
  229.  
  230. /*-------------------------------- Modulende --------------------------------*/
  231.  
  232.