scalos/main/ToolTypes.c

   1 // ToolTypes.c
   2 // $Date$
   3 // $Revision$
   4
   5 #include <exec/types.h>
   6 #include <graphics/gels.h>
   7 #include <graphics/rastport.h>
   8 #include <intuition/classes.h>
   9 #include <intuition/classusr.h>
  10 #include <utility/hooks.h>
  11 #include <intuition/gadgetclass.h>
  12 #include <workbench/workbench.h>
  13 #include <workbench/startup.h>
  14 #include <dos/dostags.h>
  15 #include <dos/datetime.h>
  16
  17 #define __USE_SYSBASE
  18
  19 #include <proto/dos.h>
  20 #include <proto/exec.h>
  21 #include <proto/layers.h>
  22 #include <proto/intuition.h>
  23 #include <proto/graphics.h>
  24 #include <proto/utility.h>
  25 #include <proto/iconobject.h>
  26 #include "debug.h"
  27 #include <proto/scalos.h>
  28
  29 #include <clib/alib_protos.h>
  30
  31 #include <defs.h>
  32 #include <datatypes/iconobject.h>
  33 #include <scalos/scalos.h>
  34
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38
  39 #include "scalos_structures.h"
  40 #include "functions.h"
  41 #include "Variables.h"
  42
  43 //----------------------------------------------------------------------------
  44
  45 // local data structures
  46
  47 //----------------------------------------------------------------------------
  48
  49 // local functions
  50
  51 static size_t CountToolTypeEntries(CONST_STRPTR *ToolTypeArray);
  52 static size_t GetToolTypeLength(CONST_STRPTR *ToolTypeArray);
  53 static STRPTR *scaFindToolType(STRPTR *ToolTypeArray, CONST_STRPTR typeName);
  54
  55 //----------------------------------------------------------------------------
  56
  57 LONG SetToolType(Object *iconObj, CONST_STRPTR ToolTypeName, CONST_STRPTR ToolTypeValue, BOOL SaveIcon)
  58 {
  59         LONG Result = RETURN_OK;
  60         STRPTR newTT = NULL;
  61         STRPTR *ttClone = NULL;
  62
  63         d1(kprintf("%s/%s/%ld: iconObj=%08lx  ttName=<%s>  ttValue=<%s>\n", \
  64                 __FILE__, __FUNC__, __LINE__, iconObj, ToolTypeName, ToolTypeValue));
  65
  66         do      {
  67                 STRPTR *ToolTypeArray = NULL;
  68                 STRPTR *ptt;
  69                 STRPTR iconName;
  70                 size_t length;
  71
  72                 if (NULL == iconObj)
  73                         break;
  74
  75                 GetAttr(IDTA_ToolTypes, iconObj, (APTR) &ToolTypeArray);
  76                 GetAttr(DTA_Name, iconObj, (APTR) &iconName);
  77
  78                 d1(kprintf("%s/%s/%ld: ToolTypeArray=%08lx  iconName=<%s>\n", \
  79                         __FILE__, __FUNC__, __LINE__, ToolTypeArray, iconName));
  80
  81                 // ToolTypeArray may be NULL if there are no tooltypes attached to the icon!
  82
  83                 d1(for (ptt=ToolTypeArray; *ptt; ptt++)\
  84                         kprintf("%s/%s/%ld: old ToolType=<%s>\n", __FILE__, __FUNC__, __LINE__, *ptt));
  85
  86                 length = 1 + strlen(ToolTypeName) + 1 + strlen(ToolTypeValue);
  87                 newTT = (STRPTR) ScalosAlloc(length);
  88                 if (NULL == newTT)
  89                         break;
  90
  91                 if (strlen(ToolTypeValue) > 0)
  92                         snprintf(newTT, length, "%s=%s", ToolTypeName, ToolTypeValue);
  93                 else
  94                         stccpy(newTT, ToolTypeName, length);
  95
  96                 ttClone = CloneToolTypeArray((CONST_STRPTR *) ToolTypeArray, 1);
  97                 if (NULL == ttClone)
  98                         break;
  99
 100                 ptt = scaFindToolType(ttClone, ToolTypeName);
 101                 if (ptt)
 102                         {
 103                         // overwrite old tooltype
 104                         d1(kprintf("%s/%s/%ld: ToolType=<%s>\n", __FILE__, __FUNC__, __LINE__, *ptt));
 105                         *ptt = newTT;
 106                         }
 107                 else
 108                         {
 109                         // append new tooltype
 110                         for (ptt=ttClone; *ptt; ptt++)
 111                                 ;
 112
 113                         *ptt = newTT;
 114                         }
 115
 116                 for (ptt=ttClone; *ptt; ptt++)
 117                         d1(kprintf("%s/%s/%ld: new ToolType=<%s>\n", __FILE__, __FUNC__, __LINE__, *ptt));
 118
 119                 SetAttrs(iconObj,
 120                         IDTA_ToolTypes, (IPTR) ttClone,
 121                         TAG_END);
 122
 123                 if (SaveIcon)
 124                         {
 125                         Result = PutIconObjectTags(iconObj, iconName,
 126                                 ICONA_NoNewImage, TRUE,
 127                                 TAG_END);
 128                         }
 129                 } while (0);
 130
 131         if (newTT)
 132                 ScalosFree(newTT);
 133         if (ttClone)
 134                 ScalosFree(ttClone);
 135
 136         return Result;
 137 }
 138
 139 //----------------------------------------------------------------------------
 140
 141 LONG RemoveToolType(Object *iconObj, CONST_STRPTR ToolTypeName, BOOL SaveIcon)
 142 {
 143         LONG Result = RETURN_OK;
 144         STRPTR *ttClone = NULL;
 145
 146         d1(kprintf("%s/%s/%ld: iconObj=%08lx  ttName=<%s>  ttValue=<%s>\n", \
 147                 __FILE__, __FUNC__, __LINE__, iconObj, ToolTypeName, ToolTypeValue));
 148
 149         do      {
 150                 STRPTR *ToolTypeArray = NULL;
 151                 STRPTR *ptt;
 152                 STRPTR iconName;
 153
 154                 if (NULL == iconObj)
 155                         break;
 156
 157                 GetAttr(IDTA_ToolTypes, iconObj, (APTR) &ToolTypeArray);
 158                 GetAttr(DTA_Name, iconObj, (APTR) &iconName);
 159
 160                 d1(kprintf("%s/%s/%ld: ToolTypeArray=%08lx  iconName=<%s>\n", \
 161                         __FILE__, __FUNC__, __LINE__, ToolTypeArray, iconName));
 162
 163                 if (NULL == ToolTypeArray)
 164                         break;
 165
 166                 for (ptt=ToolTypeArray; *ptt; ptt++)
 167                         d1(kprintf("%s/%s/%ld: old ToolType=<%s>\n", __FILE__, __FUNC__, __LINE__, *ptt));
 168
 169                 ttClone = CloneToolTypeArray((CONST_STRPTR *) ToolTypeArray, 0);
 170                 if (NULL == ttClone)
 171                         break;
 172
 173                 ptt = scaFindToolType(ttClone, ToolTypeName);
 174                 if (ptt)
 175                         {
 176                         // old tooltype found - remove it
 177                         d1(kprintf("%s/%s/%ld: ToolType=<%s>\n", __FILE__, __FUNC__, __LINE__, *ptt));
 178                         while (*ptt)
 179                                 {
 180                                 *ptt = ptt[1];
 181                                 if (NULL == *ptt)
 182                                         break;
 183                                 ptt++;
 184                                 }
 185
 186                         d1(for (ptt=ttClone; *ptt; ptt++) \
 187                                 kprintf("%s/%s/%ld: new ToolType=<%s>\n", __FILE__, __FUNC__, __LINE__, *ptt));
 188
 189                         SetAttrs(iconObj,
 190                                 IDTA_ToolTypes, (IPTR) ttClone,
 191                                 TAG_END);
 192
 193                         if (SaveIcon)
 194                                 {
 195                                 Result = PutIconObjectTags(iconObj, iconName,
 196                                         ICONA_NoNewImage, TRUE,
 197                                         TAG_END);
 198                                 }
 199                         }
 200                 } while (0);
 201
 202         if (ttClone)
 203                 ScalosFree(ttClone);
 204
 205         return Result;
 206 }
 207
 208 //----------------------------------------------------------------------------
 209
 210 static size_t CountToolTypeEntries(CONST_STRPTR *ToolTypeArray)
 211 {
 212         size_t ttCount;
 213
 214         for (ttCount=0; ToolTypeArray && ToolTypeArray[ttCount]; ttCount++);
 215
 216         return ttCount;
 217 }
 218
 219 //----------------------------------------------------------------------------
 220
 221 static size_t GetToolTypeLength(CONST_STRPTR *ToolTypeArray)
 222 {
 223         size_t Length = sizeof(STRPTR);
 224
 225         while (ToolTypeArray && *ToolTypeArray)
 226                 {
 227                 Length += sizeof(STRPTR) + strlen(*ToolTypeArray) + 1;
 228                 ToolTypeArray++;
 229                 }
 230
 231         return Length;
 232 }
 233
 234 //----------------------------------------------------------------------------
 235
 236 STRPTR *CloneToolTypeArray(CONST_STRPTR *ToolTypeArray, ULONG AdditionalEntries)
 237 {
 238         size_t ttLength;
 239         STRPTR *newTT, *newTTalloc;
 240         STRPTR stringSpace;
 241         ULONG ttCount;
 242
 243         d1(kprintf("%s/%s/%ld: AdditionalEntries=%ld\n", __FILE__, __FUNC__, __LINE__, AdditionalEntries));
 244
 245         ttLength = GetToolTypeLength(ToolTypeArray) + AdditionalEntries * sizeof(STRPTR);
 246         ttCount = CountToolTypeEntries(ToolTypeArray);
 247
 248         d1(kprintf("%s/%s/%ld: ttLength=%ld  ttCount=%ld\n", __FILE__, __FUNC__, __LINE__, ttLength, ttCount));
 249
 250         newTT = newTTalloc = ScalosAlloc(ttLength);
 251         if (NULL == newTT)
 252                 return NULL;
 253
 254         stringSpace = (STRPTR) &newTT[1 + ttCount + AdditionalEntries];
 255
 256         d1(kprintf("%s/%s/%ld: newTT=%08lx  stringSpace=%08lx\n", __FILE__, __FUNC__, __LINE__, newTT, stringSpace));
 257
 258         while (ToolTypeArray && *ToolTypeArray)
 259                 {
 260                 *newTT = stringSpace;
 261
 262                 strcpy(stringSpace, *ToolTypeArray);
 263                 stringSpace += strlen(stringSpace) + 1;
 264
 265                 newTT++;
 266                 ToolTypeArray++;
 267                 }
 268
 269         while (AdditionalEntries--)
 270                 *newTT++ = NULL;
 271
 272         *newTT = NULL;
 273
 274         return newTTalloc;
 275 }
 276
 277 //----------------------------------------------------------------------------
 278
 279 static STRPTR *scaFindToolType(STRPTR *ToolTypeArray, CONST_STRPTR typeName)
 280 {
 281         if (NULL == ToolTypeArray)
 282                 return NULL;
 283
 284         while (*ToolTypeArray)
 285                 {
 286                 STRPTR lp = strchr(*ToolTypeArray, '=');
 287                 STRPTR CompEnd;
 288                 size_t CompLen;
 289
 290                 if (lp)
 291                         {
 292                         CompEnd = lp;
 293
 294                         if (CompEnd != *ToolTypeArray)
 295                                 CompEnd--;              // skip "="
 296                         while (CompEnd != *ToolTypeArray && ' ' == *CompEnd)
 297                                 CompEnd--;              // skip all " " before "="
 298
 299 //                      lp = stpblk(++lp);              // skip "=" and trailing blanks
 300
 301                         CompLen = CompEnd - *ToolTypeArray;
 302                         }
 303                 else
 304                         {
 305                         CompLen = strlen(*ToolTypeArray);
 306 //                      lp = (STRPTR) "";
 307                         }
 308
 309                 if (0 == Strnicmp(*ToolTypeArray, (STRPTR) typeName, CompLen))
 310                         {
 311                         return ToolTypeArray;
 312                         }
 313
 314                 ToolTypeArray++;
 315                 }
 316
 317         return NULL;
 318 }
 319
 320 //----------------------------------------------------------------------------
 321
 322