workbench/classes/zune/betterstring/mcc/FileNameCompl.c

   1 /***************************************************************************
   2
   3  BetterString.mcc - A better String gadget MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2013 by BetterString.mcc Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  BetterString class Support Site:  http://www.sf.net/projects/bstring-mcc/
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include <string.h>
  24 #include <stdio.h>
  25
  26 #include <dos/dosextens.h>
  27 #include <clib/alib_protos.h>
  28 #include <proto/exec.h>
  29 #include <proto/intuition.h>
  30 #include <proto/utility.h>
  31 #include <proto/dos.h>
  32
  33 #if defined(__amigaos4__)
  34 #include <dos/obsolete.h>
  35 #endif
  36
  37 #ifdef AROS_ABI_V1
  38 #include <aros/config.h>
  39 #endif
  40
  41 #include "private.h"
  42
  43 #include "Debug.h"
  44
  45 BOOL OverwriteA(STRPTR text, UWORD x, UWORD length, UWORD ptrn_length, struct InstData *data)
  46 {
  47   BOOL result = TRUE;
  48
  49   ENTER();
  50
  51   if(length < ptrn_length)
  52   {
  53     ULONG expand = ptrn_length-length;
  54
  55     if(data->MaxLength && strlen(data->Contents)+expand > (unsigned int)(data->MaxLength-1))
  56     {
  57       ptrn_length -= expand;
  58       ptrn_length += (data->MaxLength-1)-strlen(data->Contents);
  59       result = FALSE;
  60     }
  61     if(ExpandContentString(&data->Contents, expand) == TRUE)
  62       memmove(data->Contents+x+ptrn_length, data->Contents+x+length, strlen(data->Contents+x+length)+1);
  63     else
  64       E(DBF_ALWAYS, "content expansion by %ld bytes failed", expand);
  65   }
  66   else
  67   {
  68     memmove(data->Contents+x+ptrn_length, data->Contents+x+length, strlen(data->Contents+x+length)+1);
  69   }
  70   CopyMem(text, data->Contents+x, ptrn_length);
  71
  72   if(data->BufferPos >= x)
  73   {
  74     data->BufferPos += ptrn_length-length;
  75     if(data->BufferPos < x)
  76       data->BufferPos = x;
  77   }
  78
  79   if(result == FALSE)
  80     DisplayBeep(NULL);
  81
  82   RETURN(result);
  83   return result;
  84 }
  85
  86 BOOL Overwrite(STRPTR text, UWORD x, UWORD length, struct InstData *data)
  87 {
  88   BOOL result;
  89
  90   ENTER();
  91
  92   result = OverwriteA(text, x, length, strlen(text), data);
  93
  94   RETURN(result);
  95   return result;
  96 }
  97
  98 WORD VolumeStart(STRPTR text, WORD pos)
  99 {
 100   BOOL searching = TRUE;
 101
 102   ENTER();
 103
 104   while(pos > 0 && searching)
 105   {
 106     switch(*(text+pos-1))
 107     {
 108       case '"':
 109       case '>':
 110       case ' ':
 111       case '=':
 112         searching = FALSE;
 113         break;
 114
 115       default:
 116         pos--;
 117         break;
 118     }
 119   }
 120
 121   RETURN(pos);
 122   return pos;
 123 }
 124
 125 LONG mFileNameStart(struct MUIP_BetterString_FileNameStart *msg)
 126 {
 127   STRPTR buffer = msg->buffer;
 128   LONG pos = msg->pos;
 129
 130   ENTER();
 131
 132   while(pos && buffer[pos] != ':')
 133     pos--;
 134
 135   if(buffer[pos] == ':')
 136     pos = VolumeStart(buffer, pos);
 137   else
 138     pos = MUIR_BetterString_FileNameStart_Volume;
 139
 140   RETURN(pos);
 141   return pos;
 142 }
 143
 144 VOID InsertFileName(UWORD namestart, struct InstData *data)
 145 {
 146   struct ExAllData *ead1 = &data->FNCBuffer->buffer;
 147   struct ExAllData *ead2;
 148   struct FNCData *fncframe;
 149   struct FNCData *fncframe1 = data->FNCBuffer;
 150   UWORD entrynum;
 151   UWORD findnum = data->FileNumber;
 152   char tmpname[32];
 153
 154   ENTER();
 155
 156   do
 157   {
 158     entrynum = 0;
 159     fncframe = data->FNCBuffer;
 160     ead2 = &fncframe->buffer;
 161     while(ead2 != NULL)
 162     {
 163       //if(CmpStrings(ead1->ed_Name, ead2->ed_Name) > 0)
 164       if(strcmp((const char *)ead1->ed_Name, (const char *)ead2->ed_Name) > 0)
 165         entrynum++;
 166
 167       ead2 = ead2->ed_Next;
 168       if(ead2 == NULL && fncframe->next != NULL)
 169       {
 170         fncframe = fncframe->next;
 171         ead2 = &fncframe->buffer;
 172       }
 173     }
 174
 175     if(entrynum != findnum)
 176       ead1 = ead1->ed_Next;
 177     if(ead1 == NULL && fncframe1->next != NULL)
 178     {
 179       fncframe1 = fncframe1->next;
 180       ead1 = &fncframe1->buffer;
 181     }
 182   }
 183   while(entrynum != findnum);
 184
 185   snprintf(tmpname, sizeof(tmpname), "%s%s", ead1->ed_Name, ead1->ed_Type == 2 ? "/" : " ");
 186
 187   Overwrite(tmpname, namestart, data->BufferPos-namestart, data);
 188
 189   LEAVE();
 190 }
 191
 192 BOOL FileNameComplete(Object *obj, BOOL backwards, struct InstData *data)
 193 {
 194   BOOL edited = FALSE;
 195
 196   ENTER();
 197
 198   if(data->FNCBuffer != NULL)
 199   {
 200     if(data->FileEntries == 1)
 201     {
 202       DisplayBeep(NULL);
 203     }
 204     else
 205     {
 206       if(backwards)
 207       {
 208         if(--data->FileNumber < 0)
 209           data->FileNumber = data->FileEntries-1;
 210       }
 211       else
 212       {
 213         if(++data->FileNumber >= data->FileEntries)
 214           data->FileNumber = 0;
 215       }
 216     }
 217     InsertFileName(data->FileNameStart, data);
 218     edited = TRUE;
 219   }
 220   else
 221   {
 222     LONG pos = DoMethod(obj, MUIM_BetterString_FileNameStart, data->Contents, data->BufferPos);
 223
 224     switch(pos)
 225     {
 226       case MUIR_BetterString_FileNameStart_Volume:
 227       {
 228         struct DosList *dl;
 229         STRPTR volumeName = NULL;
 230         char tmpBuffer[256];
 231         UWORD cut;
 232
 233         pos = VolumeStart(data->Contents, data->BufferPos);
 234         if((cut = data->BufferPos-pos) != 0)
 235         {
 236           dl = LockDosList(LDF_READ|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS);
 237           while((dl = NextDosEntry(dl, LDF_READ|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS)) != NULL)
 238           {
 239             #ifdef __AROS__
 240               #ifdef AROS_ABI_V1
 241               strlcpy(tmpBuffer, AROS_BSTR_ADDR(dl->dol_Name), AROS_BSTR_strlen(dl->dol_Name));
 242               #else
 243               strlcpy(tmpBuffer, dl->dol_Ext.dol_AROS.dol_DevName, sizeof tmpBuffer);
 244               #endif
 245             #else
 246             // dol_Name is a BSTR, we have to convert it to a regular C string
 247             char *bstr = BADDR(dl->dol_Name);
 248
 249             // a BSTR cannot exceed 255 characters, hence the buffer size of 256 is enough in any case
 250             strlcpy(tmpBuffer, &bstr[1], (unsigned char)bstr[0]);
 251             #endif
 252
 253             if(Strnicmp(tmpBuffer, data->Contents+pos, cut) == 0)
 254             {
 255               volumeName = tmpBuffer;
 256               break;
 257             }
 258           }
 259
 260           if(volumeName != NULL)
 261           {
 262             if(OverwriteA(volumeName, pos, cut, strlen(volumeName)+1, data))
 263               data->Contents[data->BufferPos-1] = ':';
 264             edited = TRUE;
 265           }
 266           UnLockDosList(LDF_READ|LDF_DEVICES|LDF_VOLUMES|LDF_ASSIGNS);
 267         }
 268       }
 269       break;
 270
 271       default:
 272       {
 273         struct FNCData *fncbuffer;
 274         struct FNCData *fncframe;
 275         struct ExAllControl *control;
 276         BPTR dirlock;
 277         char pattern[42];
 278         UWORD namestart = data->BufferPos;
 279         char oldletter = '\0';
 280         BOOL filename = TRUE;
 281
 282         while(filename)
 283         {
 284           switch(*(data->Contents+namestart-1))
 285           {
 286             case '/':
 287             case ':':
 288               filename = FALSE;
 289               break;
 290
 291             default:
 292               namestart--;
 293               break;
 294           }
 295         }
 296
 297         if((data->BufferPos-namestart) < 32)
 298         {
 299           strlcpy(pattern, data->Contents+namestart, sizeof(pattern));
 300           strlcat(pattern, "~(#?.info)", sizeof(pattern));
 301
 302           oldletter = data->Contents[namestart];
 303           data->Contents[namestart] = '\0';
 304
 305           if((fncbuffer = (struct FNCData *)SharedPoolAlloc(4100)) != NULL)
 306           {
 307             fncbuffer->next = NULL;
 308
 309             if((control = (struct ExAllControl *)AllocDosObject(DOS_EXALLCONTROL, NULL)))
 310             {
 311               char tokenized[sizeof(pattern) * 2 + 2];
 312
 313               if(ParsePatternNoCase(pattern, tokenized, sizeof(tokenized)) != -1)
 314                 control->eac_MatchString = tokenized;
 315
 316               if((dirlock = Lock(data->Contents+pos, ACCESS_READ)))
 317               {
 318                 UWORD entries = 0;
 319
 320                 fncframe = fncbuffer;
 321                 while(fncframe && ExAll(dirlock, &fncframe->buffer, 4096, ED_TYPE, control))
 322                 {
 323                   entries += control->eac_Entries;
 324
 325                   if((fncframe->next = (struct FNCData *)SharedPoolAlloc(4100)))
 326                     fncframe->next->next = NULL;
 327
 328                   fncframe = fncframe->next;
 329                 }
 330                 control->eac_Entries += entries;
 331
 332                 data->FileNumber = backwards ? control->eac_Entries-1 : 0;
 333                 data->FileEntries = control->eac_Entries;
 334                 data->FileNameStart = namestart;
 335                 data->FNCBuffer = fncbuffer;
 336
 337                 if(control->eac_Entries)
 338                 {
 339                   data->Contents[namestart] = oldletter;
 340                   InsertFileName(namestart, data);
 341                   edited = TRUE;
 342                 }
 343                 UnLock(dirlock);
 344               }
 345               else
 346               {
 347                 SharedPoolFree(fncbuffer);
 348               }
 349
 350               FreeDosObject(DOS_EXALLCONTROL, (APTR)control);
 351             }
 352           }
 353         }
 354
 355         if(edited == FALSE)
 356           data->Contents[namestart] = oldletter;
 357       }
 358       break;
 359     }
 360   }
 361
 362   RETURN(edited);
 363   return edited;
 364 }