workbench/libs/popupmenu/pmcreate.c

   1 //
   2 // PopupMenu
   3 // ©1996-2002 Henrik Isaksson
   4 //
   5 // Menu creation/disposal & id list functions
   6 //
   7
   8 #include "pmpriv.h"
   9
  10 void FreeIDList(struct PM_IDLst *f)
  11 {
  12     if(f) {
  13         struct PM_IDLst *n;
  14
  15         while(f) {
  16             n=f->Next;
  17             PM_Mem_Free(f);
  18             f=n;
  19         }
  20     }
  21 }
  22
  23 void PM_FreeTitle(struct PopupMenu *p)
  24 {
  25     if(!p) return;
  26
  27     if(p->Title && GET_TXTMODE(p)==0) PM_Mem_Free(p->Title);
  28
  29     p->Title=NULL;
  30 }
  31
  32 void __saveds ASM PM_FreePopupMenu(register __a1 struct PopupMenu *p GNUCREG(a1))
  33 {
  34     if(p) {
  35         struct PopupMenu *n;
  36
  37         while(p) {
  38             n=p->Next;
  39             if(p->Sub) PM_FreePopupMenu(p->Sub);
  40             PM_FreeTitle(p);
  41             if(p->UserData && (p->Flags&NPM_UDATASTRING)) PM_Mem_Free(p->UserData);
  42             if(p->Exclude && !(p->Flags&NPM_EXCLUDE_SHARED)) {
  43                 FreeIDList(p->Exclude);
  44             }
  45             PM_Mem_Free(p);
  46             p=n;
  47         }
  48     }
  49 }
  50
  51 void __saveds ASM PM_FreeIDList(
  52     register __a0 struct PM_IDLst *f GNUCREG(a0))
  53 {
  54     FreeIDList(f);
  55 }
  56
  57 struct PopupMenu *__saveds ASM PM_MakeItemA(register __a1 struct TagItem *tags GNUCREG(a1))
  58 {
  59     struct PopupMenu *p;
  60
  61     p=PM_Mem_Alloc(sizeof(struct PopupMenu));
  62     if(p) {
  63         PM_SetItemAttrsA(p, tags);
  64
  65         return p;
  66     }
  67
  68     return NULL;
  69 }
  70
  71 struct PopupMenu * __saveds ASM PM_MakeMenuA(register __a1 struct TagItem *tags GNUCREG(a1))
  72 {
  73     struct TagItem *tag, *tstate;
  74     struct PopupMenu *first=0L, *last=0L;
  75     BOOL error=0;
  76
  77     tstate = tags;
  78     while((tag=NextTagItem(&tstate))) {
  79         switch(tag->ti_Tag) {
  80             case PM_Item:
  81                 if(tag->ti_Data) {
  82                     if(last) {
  83                         last->Next=(struct PopupMenu *)tag->ti_Data;
  84                         last=last->Next;
  85                     } else {
  86                         last=first=(struct PopupMenu *)tag->ti_Data;
  87                     }
  88                 } else error=1;
  89                 break;
  90         }
  91     }
  92
  93     if(error) {
  94         PM_FreePopupMenu(first);
  95         first=0L;
  96     }
  97
  98     return first;
  99 }
 100
 101 struct PM_IDLst * __saveds ASM PM_MakeIDListA(register __a1 struct TagItem *tags GNUCREG(a1))
 102 {
 103     struct TagItem *tag;
 104     struct TagItem *tstate;
 105     struct PM_IDLst *first=0L, *last=0L, *n=0L;
 106     BOOL error=0;
 107
 108     tstate = tags;
 109     while((tag=NextTagItem(&tstate))) {
 110         switch(tag->ti_Tag) {
 111             case PM_ExcludeID:
 112                 n=PM_Mem_Alloc(sizeof(struct PM_IDLst));
 113                 if(n) {
 114                     n->Next=0L;
 115                     n->ID=tag->ti_Data;
 116                     n->Kind=IDKND_EXCLUDE;
 117                     n->Flags=0L;
 118
 119                     if(last) {
 120                         last->Next=n;
 121                         last=last->Next;
 122                     } else {
 123                         last=first=n;
 124                     }
 125                 } else error=1;
 126                 break;
 127             case PM_IncludeID:
 128                 n=PM_Mem_Alloc(sizeof(struct PM_IDLst));
 129                 if(n) {
 130                     n->Next=0L;
 131                     n->ID=tag->ti_Data;
 132                     n->Kind=IDKND_INCLUDE;
 133                     n->Flags=0L;
 134
 135                     if(last) {
 136                         last->Next=n;
 137                         last=last->Next;
 138                     } else {
 139                         last=first=n;
 140                     }
 141                 } else error=1;
 142                 break;
 143             case PM_ReflectID:
 144                 n=PM_Mem_Alloc(sizeof(struct PM_IDLst));
 145                 if(n) {
 146                     n->Next=0L;
 147                     n->ID=tag->ti_Data;
 148                     n->Kind=IDKND_REFLECT;
 149                     n->Flags=0L;
 150
 151                     if(last) {
 152                         last->Next=n;
 153                         last=last->Next;
 154                     } else {
 155                         last=first=n;
 156                     }
 157                 } else error=1;
 158                 break;
 159             case PM_InverseID:
 160                 n=PM_Mem_Alloc(sizeof(struct PM_IDLst));
 161                 if(n) {
 162                     n->Next=0L;
 163                     n->ID=tag->ti_Data;
 164                     n->Kind=IDKND_INVERSE;
 165                     n->Flags=0L;
 166
 167                     if(last) {
 168                         last->Next=n;
 169                         last=last->Next;
 170                     } else {
 171                         last=first=n;
 172                     }
 173                 } else error=1;
 174                 break;
 175         }
 176     }
 177
 178     if(error) {
 179         PM_FreeIDList(first);
 180         first=0L;
 181     }
 182
 183     return first;
 184 }
 185
 186 struct PM_IDLst * __saveds ASM PM_ExLstA(register __a1 ULONG *id GNUCREG(a1))
 187 {
 188     struct PM_IDLst *first=0L, *last=0L, *n=0L;
 189     BOOL error=0;
 190     int i=0;
 191
 192     while(id[i]) {
 193         n=PM_Mem_Alloc(sizeof(struct PM_IDLst));
 194         if(n) {
 195             n->Next=0L;
 196             n->ID=id[i];
 197             n->Kind=IDKND_EXCLUDE;
 198             n->Flags=0L;
 199
 200             if(last) {
 201                 last->Next=n;
 202                 last=last->Next;
 203             } else {
 204                 last=first=n;
 205             }
 206         } else error=1;
 207         i++;
 208     }
 209
 210     if(error) {
 211         PM_FreeIDList(first);
 212         first=0L;
 213     }
 214
 215     return first;
 216 }
 217
 218 //
 219 // Allocate local variables to save stack
 220 //
 221 struct PM_Root *PM_AllocPMRoot(struct Window *w)
 222 {
 223         struct PM_Root *p;
 224
 225         p=PM_Mem_Alloc(sizeof(struct PM_Root));
 226         if(p) {
 227                 p->ShadowWidth=p->ShadowHeight=4;
 228                 p->ShadowAddX=p->ShadowAddY=2;
 229
 230                 p->BorderWidth=p->BorderHeight=1;
 231
 232                 p->DrawInfo=GetScreenDrawInfo(w->WScreen);
 233
 234                 p->PM=0L;
 235
 236                 return p;
 237         }
 238         return NULL;
 239 }