workbench/system/find/findgroup_class.c

   1 /*
   2     Copyright © 2016-2018, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/dos.h>
   7 #include <proto/muimaster.h>
   8 #include <proto/intuition.h>
   9 #include <proto/asl.h>
  10 #include <proto/utility.h>
  11 #include <proto/workbench.h>
  12 #include <proto/alib.h>
  13
  14 #include <libraries/mui.h>
  15 #include <mui/NList_mcc.h>
  16 #include <mui/NListview_mcc.h>
  17
  18 //#define DEBUG 1
  19 #include <aros/debug.h>
  20 #include <zune/customclasses.h>
  21
  22 #include <stdio.h>
  23
  24 #include "findgroup_class.h"
  25 #include "locale.h"
  26
  27 #define PATHNAMESIZE (1024)
  28
  29
  30 struct FindGroup_DATA
  31 {
  32     Object *str_path, *str_pattern, *str_contents;
  33     Object *btn_start, *btn_stop, *btn_open, *btn_view, *btn_parent;
  34     Object *lst_result;
  35     Object *txt_status;
  36     Object *scanproc;
  37     struct Hook openwbobj_hook;
  38     struct Hook view_hook;
  39     struct Hook parent_hook;
  40     struct Hook activeentry_hook;
  41 };
  42
  43
  44 struct Listentry
  45 {
  46     STRPTR fullname;
  47     ULONG namebuflen;
  48     struct FileInfoBlock fib;
  49 };
  50
  51 static struct Hook list_display_hook, list_constr_hook, list_destr_hook, list_compare_hook;
  52
  53
  54 // =======================================================================================
  55
  56 static void display_doserror(Object *app, ULONG error)
  57 {
  58     TEXT buffer[255];
  59     Fault(error, NULL, buffer, sizeof buffer);
  60     MUI_Request(app, NULL, 0, _(MSG_APP_TITLE), _(MSG_OK), _(MSG_ERR_DOS), buffer);
  61 }
  62
  63 // =======================================================================================
  64
  65 static BOOL checkfile(Object *app, struct AnchorPath *anchorpath, STRPTR pattern, STRPTR content)
  66 {
  67     D(bug("[Find::checkfile] name %s pattern %s content %s\n", anchorpath->ap_Info.fib_FileName, pattern, content));
  68
  69     // warning: this function is called from a sub process
  70
  71     LONG retval = FALSE;
  72
  73     if (anchorpath->ap_Info.fib_DirEntryType > 0) // ignore directories
  74     {
  75         return FALSE;
  76     }
  77
  78     if ((pattern[0] == '\0') || MatchPatternNoCase(pattern, anchorpath->ap_Info.fib_FileName))
  79     {
  80         if (content && (content[0] != '\0'))
  81         {
  82             D(bug("[Find::checkfile] content search\n"));
  83
  84             BPTR fh;
  85             LONG searchlen = strlen(content);
  86             LONG textlen = anchorpath->ap_Info.fib_Size;
  87             TEXT *text, *oldtext;
  88             LONG i;
  89
  90             if (textlen != 0)
  91             {
  92                 fh = Open(anchorpath->ap_Buf, MODE_OLDFILE);
  93                 if (fh)
  94                 {
  95                     text = oldtext = AllocVec(textlen, MEMF_ANY);
  96                     if (text)
  97                     {
  98                         if (Read(fh, text, textlen) == textlen)
  99                         {
 100                             textlen -= searchlen;
 101                             while (textlen >= 0)
 102                             {
 103                                 for(i = 0; i < searchlen; i++)
 104                                 {
 105                                     if (ToUpper(text[i]) !=
 106                                         ToUpper(content[i]))
 107                                     {
 108                                         break;
 109                                     }
 110                                 }
 111
 112                                 if (i == searchlen)
 113                                 {
 114                                     retval = TRUE;
 115                                     break;
 116                                 }
 117                                 text++;
 118                                 textlen--;
 119                             }
 120                         }
 121                         else
 122                         {
 123                             // Read() failed
 124                             // app must be NULL to avoid deadlocks
 125                             display_doserror(NULL, IoErr());
 126                         }
 127                         FreeVec(oldtext);
 128                     }
 129                     else
 130                     {
 131                         MUI_Request(NULL, NULL, 0, _(MSG_APP_TITLE),
 132                             _(MSG_OK), _(MSG_ERR_NO_MEM));
 133                     }
 134                     Close(fh);
 135                 }
 136                 else
 137                 {
 138                     // Open() failed
 139                     // app must be NULL to avoid deadlocks
 140                     display_doserror(NULL, IoErr());
 141                 }
 142             }
 143         }
 144         else
 145         {
 146             retval = TRUE;
 147         }
 148     }
 149     return retval;
 150 }
 151
 152 // =======================================================================================
 153
 154 AROS_UFH3(APTR, list_constr_func,
 155     AROS_UFHA(struct Hook *, h, A0),
 156     AROS_UFHA(APTR, pool, A2),
 157     AROS_UFHA(struct Listentry *, li, A1))
 158 {
 159     AROS_USERFUNC_INIT
 160
 161     struct Listentry *newentry = AllocPooled(pool, sizeof(struct Listentry));
 162     ULONG buflen;
 163     if (newentry)
 164     {
 165         buflen = strlen(li->fullname) + 1;
 166         newentry->fullname = AllocPooled(pool, buflen);
 167         if (newentry->fullname)
 168         {
 169             newentry->namebuflen = buflen;
 170             CopyMem(li->fullname, newentry->fullname, buflen);
 171         }
 172         newentry->fib = li->fib;
 173     }
 174     return newentry;
 175
 176     AROS_USERFUNC_EXIT
 177 }
 178
 179 // =======================================================================================
 180
 181 AROS_UFH3(void, list_destr_func,
 182     AROS_UFHA(struct Hook *, h, A0),
 183     AROS_UFHA(APTR, pool, A2),
 184     AROS_UFHA(struct Listentry *, li, A1))
 185 {
 186     AROS_USERFUNC_INIT
 187
 188     FreePooled(pool, li->fullname, li->namebuflen);
 189     FreePooled(pool, li, sizeof(struct Listentry));
 190
 191     AROS_USERFUNC_EXIT
 192 }
 193
 194 // =======================================================================================
 195
 196 AROS_UFH3S(LONG, list_display_func,
 197     AROS_UFHA(struct Hook *, h, A0),
 198     AROS_UFHA(char **, array, A2),
 199     AROS_UFHA(struct Listentry *, li, A1))
 200 {
 201     AROS_USERFUNC_INIT
 202
 203     if (li)
 204     {
 205         static TEXT protbuf[8], sizebuf[20];
 206         static TEXT datebuf[20], timebuf[20];
 207         struct DateTime dt;
 208
 209         // Protection bits
 210         protbuf[0] = li->fib.fib_Protection & FIBF_SCRIPT  ? 's' : '-';
 211         protbuf[1] = li->fib.fib_Protection & FIBF_PURE    ? 'p' : '-';
 212         protbuf[2] = li->fib.fib_Protection & FIBF_ARCHIVE ? 'a' : '-';
 213
 214         // Not set means action is allowed!
 215         protbuf[3] = li->fib.fib_Protection & FIBF_READ    ? '-' : 'r';
 216         protbuf[4] = li->fib.fib_Protection & FIBF_WRITE   ? '-' : 'w';
 217         protbuf[5] = li->fib.fib_Protection & FIBF_EXECUTE ? '-' : 'e';
 218         protbuf[6] = li->fib.fib_Protection & FIBF_DELETE  ? '-' : 'd';
 219         protbuf[7] = '\0';
 220
 221         // Size
 222         snprintf(sizebuf, sizeof sizebuf, "%lu", (long unsigned int)li->fib.fib_Size);
 223
 224         // Date
 225         datebuf[0] = '\0';
 226         timebuf[0] = '\0';
 227         dt.dat_Stamp = li->fib.fib_Date;
 228         dt.dat_Format = FORMAT_DEF;
 229         dt.dat_Flags = 0;
 230         dt.dat_StrDay = NULL;
 231         dt.dat_StrDate = datebuf;
 232         dt.dat_StrTime = timebuf;
 233         DateToStr(&dt);
 234
 235         *array++ = li->fullname;
 236         *array++ = sizebuf;
 237         *array++ = protbuf;
 238         *array++ = datebuf;
 239         *array++ = timebuf;
 240         *array++ = li->fib.fib_Comment;
 241     }
 242     else
 243     {
 244         *array++ = (STRPTR)_(MSG_LST_FULLPATH);
 245         *array++ = (STRPTR)_(MSG_LST_SIZE);
 246         *array++ = (STRPTR)_(MSG_LST_ATTRIBUTES);
 247         *array++ = (STRPTR)_(MSG_LST_DATE);
 248         *array++ = (STRPTR)_(MSG_LST_TIME);
 249         *array++ = (STRPTR)_(MSG_LST_COMMENT);
 250     }
 251
 252     return 0;
 253
 254     AROS_USERFUNC_EXIT
 255 }
 256
 257 // =======================================================================================
 258
 259 AROS_UFH3(LONG, list_compare_func,
 260     AROS_UFHA(struct Hook *, h, A0),
 261     AROS_UFHA(struct Listentry *, li1, A2),
 262     AROS_UFHA(struct Listentry *, li2, A1))
 263 {
 264     AROS_USERFUNC_INIT
 265
 266     return stricmp(li2->fullname, li1->fullname);
 267
 268     AROS_USERFUNC_EXIT
 269 }
 270
 271
 272 // =======================================================================================
 273
 274 AROS_UFH3S(void, openwbobj_func,
 275     AROS_UFHA(struct Hook *, h, A0),
 276     AROS_UFHA(Object *, obj, A2),
 277     AROS_UFHA(APTR, msg, A1))
 278 {
 279     AROS_USERFUNC_INIT
 280
 281     D(bug("[Find::openwbobject_func] called\n"));
 282
 283     // struct FindGroup_DATA *data = h->h_Data;
 284     struct Listentry *entry;
 285     BPTR filelock = (BPTR)-1;
 286     BPTR parentdirlock = (BPTR)-1;
 287     BPTR olddirlock = (BPTR)-1;
 288
 289     DoMethod(obj, MUIM_NList_GetEntry, MUIV_NList_GetEntry_Active, &entry);
 290     if (entry)
 291     {
 292         D(bug("[Find::openwbobj_func] name %s\n", entry->fullname));
 293
 294         // trying to change directory to file's parent directory
 295         filelock = Lock(entry->fullname, SHARED_LOCK);
 296         if (filelock)
 297         {
 298             parentdirlock = ParentDir(filelock);
 299             olddirlock = CurrentDir(parentdirlock);
 300         }
 301
 302         D(bug("[Find::openwbobj_func] file %p parent %p olddir %p\n", filelock, parentdirlock, olddirlock));
 303
 304         // execute program even if directory change failed
 305         if (OpenWorkbenchObject(entry->fullname, TAG_DONE) == FALSE)
 306         {
 307             MUI_Request(_app(obj), _win(obj), 0, _(MSG_APP_TITLE), _(MSG_OK), _(MSG_ERR_NO_FILE), entry->fullname);
 308         }
 309
 310         if (olddirlock != (BPTR)-1)
 311         {
 312             CurrentDir(olddirlock);
 313         }
 314         if (parentdirlock != (BPTR)-1)
 315         {
 316             UnLock(parentdirlock);
 317         }
 318         if (filelock != (BPTR)-1)
 319         {
 320             UnLock(filelock);
 321         }
 322     }
 323
 324     AROS_USERFUNC_EXIT
 325 }
 326
 327 // =======================================================================================
 328
 329 AROS_UFH3S(void, view_func,
 330     AROS_UFHA(struct Hook *, h, A0),
 331     AROS_UFHA(Object *, obj, A2),
 332     AROS_UFHA(APTR, msg, A1))
 333 {
 334     AROS_USERFUNC_INIT
 335
 336     D(bug("[Find::view_func] called\n"));
 337
 338     // struct FindGroup_DATA *data = h->h_Data;
 339     struct Listentry *entry;
 340     TEXT command[PATHNAMESIZE];
 341     BPTR con;
 342
 343     DoMethod(obj, MUIM_NList_GetEntry, MUIV_NList_GetEntry_Active, &entry);
 344     if (entry)
 345     {
 346         D(bug("[Find::view_func] viewing %s\n", entry->fullname));
 347         con = Open("CON:////Find Output/CLOSE/AUTO/WAIT", MODE_OLDFILE);
 348         snprintf(command, sizeof command, "SYS:Utilities/Multiview \"%s\"", entry->fullname);
 349         if (SystemTags(command,
 350             SYS_Asynch, TRUE,
 351             SYS_Input,  con,
 352             SYS_Output, NULL,
 353             SYS_Error, NULL,
 354             TAG_DONE) == -1)
 355         {
 356             display_doserror(_app(obj), IoErr());
 357             Close(con); // an error occured, we must close con: ourselves
 358         }
 359     }
 360
 361     AROS_USERFUNC_EXIT
 362 }
 363
 364 // =======================================================================================
 365
 366 AROS_UFH3S(void, parent_func,
 367     AROS_UFHA(struct Hook *, h, A0),
 368     AROS_UFHA(Object *, obj, A2),
 369     AROS_UFHA(APTR, msg, A1))
 370 {
 371     AROS_USERFUNC_INIT
 372
 373     D(bug("[Find::parent_func] called\n"));
 374
 375     // struct FindGroup_DATA *data = h->h_Data;
 376     struct Listentry *entry;
 377     BPTR filelock;
 378     BPTR parentdirlock;
 379     TEXT buffer[PATHNAMESIZE];
 380
 381     DoMethod(obj, MUIM_NList_GetEntry, MUIV_NList_GetEntry_Active, &entry);
 382     if (entry)
 383     {
 384         D(bug("[Find::parent_func] name %s\n", entry->fullname));
 385
 386         filelock = Lock(entry->fullname, SHARED_LOCK);
 387         if (filelock)
 388         {
 389             parentdirlock = ParentDir(filelock);
 390             if (NameFromLock(parentdirlock, buffer, PATHNAMESIZE))
 391             {
 392                 D(bug("[Find::parent_func] parent %s\n", buffer));
 393
 394                 if (OpenWorkbenchObject(buffer, TAG_DONE) == FALSE)
 395                 {
 396                     MUI_Request(_app(obj), _win(obj), 0, _(MSG_APP_TITLE), _(MSG_OK),
 397                         _(MSG_ERR_NO_DIR), buffer);
 398                 }
 399             }
 400             UnLock(parentdirlock);
 401             UnLock(filelock);
 402         }
 403     }
 404
 405     AROS_USERFUNC_EXIT
 406 }
 407
 408 // =======================================================================================
 409
 410 AROS_UFH3S(void, activeentry_func,
 411     AROS_UFHA(struct Hook *, h, A0),
 412     AROS_UFHA(Object *, obj, A2),
 413     AROS_UFHA(APTR, msg, A1))
 414 {
 415     AROS_USERFUNC_INIT
 416
 417     D(bug("[activeentry_func] called\n"));
 418
 419     struct FindGroup_DATA *data = h->h_Data;
 420     LONG entry;
 421
 422     entry = XGET(obj, MUIA_List_Active);
 423     if (entry == MUIV_NList_Active_Off)
 424     {
 425         SET(data->btn_open, MUIA_Disabled, TRUE);
 426         SET(data->btn_view, MUIA_Disabled, TRUE);
 427         SET(data->btn_parent, MUIA_Disabled, TRUE);
 428     }
 429     else
 430     {
 431         SET(data->btn_open, MUIA_Disabled, FALSE);
 432         SET(data->btn_view, MUIA_Disabled, FALSE);
 433         SET(data->btn_parent, MUIA_Disabled, FALSE);
 434     }
 435
 436     AROS_USERFUNC_EXIT
 437 }
 438
 439 // =======================================================================================
 440
 441 Object *FindGroup__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 442 {
 443     Object *str_path, *str_pattern, *str_contents;
 444     Object *btn_start, *btn_stop, *btn_open, *btn_view, *btn_parent;
 445     Object *lst_result;
 446     Object *txt_status;
 447     STRPTR path = NULL;
 448     STRPTR pattern = NULL;
 449     STRPTR contents = NULL;
 450
 451     struct TagItem *tstate = message->ops_AttrList;
 452     struct TagItem *tag = NULL;
 453
 454     while ((tag = NextTagItem(&tstate)) != NULL)
 455     {
 456         switch (tag->ti_Tag)
 457         {
 458             case MUIA_FindGroup_Path:
 459                 path = (STRPTR)tag->ti_Data;
 460                 break;
 461
 462             case MUIA_FindGroup_Pattern:
 463                 pattern = (STRPTR)tag->ti_Data;
 464                 break;
 465
 466             case MUIA_FindGroup_Contents:
 467                 contents = (STRPTR)tag->ti_Data;
 468                 break;
 469         }
 470     }
 471
 472     if (path == NULL) path = "SYS:";
 473     if (pattern == NULL) pattern = "";
 474     if (contents == NULL) contents = "";
 475
 476     list_constr_hook.h_Entry = (HOOKFUNC)list_constr_func;
 477     list_destr_hook.h_Entry = (HOOKFUNC)list_destr_func;
 478     list_display_hook.h_Entry = (HOOKFUNC)list_display_func;
 479     list_compare_hook.h_Entry = (HOOKFUNC)list_compare_func;
 480
 481
 482     self = (Object *) DoSuperNewTags
 483     (
 484         CLASS, self, NULL,
 485         Child, HGroup,
 486             Child, VGroup,
 487                 Child, VGroup,
 488                     GroupFrame,
 489                     Child, ColGroup(2),
 490                         GroupFrame,
 491                         Child, Label(_(MSG_LBL_PATH)),
 492                         Child, PopaslObject,
 493                             MUIA_Popasl_Type , ASL_FileRequest,
 494                             ASLFR_TitleText, _(MSG_LBL_PATH),
 495                             MUIA_Popstring_String, str_path = StringObject,
 496                                 StringFrame,
 497                                 MUIA_String_Contents, path,
 498                                 MUIA_CycleChain, 1,
 499                             End,
 500                             MUIA_Popstring_Button, PopButton(MUII_PopFile),
 501                         End,
 502                         Child, Label(_(MSG_LBL_PATTERN)),
 503                         Child, str_pattern = StringObject,
 504                             StringFrame,
 505                             MUIA_String_Contents, pattern,
 506                             MUIA_CycleChain, 1,
 507                         End,
 508                         Child, Label(_(MSG_LBL_CONTENTS)),
 509                         Child, str_contents = StringObject,
 510                             StringFrame,
 511                             MUIA_String_Contents, contents,
 512                             MUIA_CycleChain, 1,
 513                         End,
 514                     End,
 515                     Child, HGroup,
 516                         GroupFrame,
 517                         Child, HVSpace,
 518                         Child, btn_start = SimpleButton(_(MSG_BTN_START)),
 519                         Child, HVSpace,
 520                         Child, btn_stop = SimpleButton(_(MSG_BTN_STOP)),
 521                         Child, HVSpace,
 522                     End,
 523                 End,
 524                 Child, lst_result = NListviewObject,
 525                     MUIA_NListview_NList, NListObject,
 526                         MUIA_NList_Format, "BAR,P=\33r BAR,BAR,BAR,BAR,",
 527                         MUIA_NList_Title, TRUE,
 528                         MUIA_Frame, MUIV_Frame_InputList,
 529                         MUIA_NList_DisplayHook, &list_display_hook,
 530                         MUIA_NList_ConstructHook, &list_constr_hook,
 531                         MUIA_NList_DestructHook, &list_destr_hook,
 532                         MUIA_NList_CompareHook, &list_compare_hook,
 533                     End,
 534                 End,
 535                 Child, HGroup,
 536                     GroupFrame,
 537                     Child, HVSpace,
 538                     Child, btn_open = SimpleButton(_(MSG_BTN_OPEN)),
 539                     Child, HVSpace,
 540                     Child, btn_view = SimpleButton(_(MSG_BTN_VIEW)),
 541                     Child, HVSpace,
 542                     Child, btn_parent = SimpleButton(_(MSG_BTN_DRAWER)),
 543                     Child, HVSpace,
 544                 End,
 545                 Child, txt_status = TextObject,
 546                     TextFrame,
 547                 End,
 548             End,
 549         End,
 550         TAG_MORE, (IPTR)message->ops_AttrList,
 551         TAG_DONE
 552     );
 553
 554     if (self)
 555     {
 556         struct FindGroup_DATA *data = INST_DATA(CLASS, self);
 557
 558         // embed the process object
 559         data->scanproc = MUI_NewObject(MUIC_Process,
 560             MUIA_Process_SourceClass , CLASS,
 561             MUIA_Process_SourceObject, self,
 562             MUIA_Process_Priority    , -1,
 563             MUIA_Process_AutoLaunch  , FALSE,
 564             TAG_DONE);
 565
 566         data->str_path          = str_path;
 567         data->str_pattern       = str_pattern;
 568         data->str_contents      = str_contents;
 569         data->btn_start         = btn_start;
 570         data->btn_stop          = btn_stop;
 571         data->btn_open          = btn_open;
 572         data->btn_view          = btn_view;
 573         data->btn_parent        = btn_parent;
 574         data->lst_result        = lst_result;
 575         data->txt_status        = txt_status;
 576
 577         data->openwbobj_hook.h_Entry = (HOOKFUNC)openwbobj_func;
 578         data->openwbobj_hook.h_Data = data;
 579
 580         data->view_hook.h_Entry = (HOOKFUNC)view_func;
 581         data->view_hook.h_Data = data;
 582
 583         data->parent_hook.h_Entry = (HOOKFUNC)parent_func;
 584         data->parent_hook.h_Data = data;
 585
 586         data->activeentry_hook.h_Entry = (HOOKFUNC)activeentry_func;
 587         data->activeentry_hook.h_Data = data;
 588
 589         SET(data->btn_stop, MUIA_Disabled, TRUE);
 590
 591         SET(data->btn_open, MUIA_Disabled, TRUE);
 592         SET(data->btn_view, MUIA_Disabled, TRUE);
 593         SET(data->btn_parent, MUIA_Disabled, TRUE);
 594
 595         DoMethod
 596         (
 597             data->btn_start, MUIM_Notify, MUIA_Pressed, FALSE,
 598             self, 1, MUIM_FindGroup_Start
 599         );
 600
 601         DoMethod
 602         (
 603             data->btn_stop, MUIM_Notify, MUIA_Pressed, FALSE,
 604             self, 1, MUIM_FindGroup_Stop
 605         );
 606
 607         DoMethod
 608         (
 609             data->btn_open, MUIM_Notify, MUIA_Pressed, FALSE,
 610             self, 2, MUIM_CallHook, &data->openwbobj_hook
 611         );
 612
 613         DoMethod
 614         (
 615             data->btn_view, MUIM_Notify, MUIA_Pressed, FALSE,
 616             self, 2, MUIM_CallHook, &data->view_hook
 617         );
 618
 619         DoMethod
 620         (
 621             data->btn_parent, MUIM_Notify, MUIA_Pressed, FALSE,
 622             self, 2, MUIM_CallHook, &data->parent_hook
 623         );
 624
 625         DoMethod
 626         (
 627             data->lst_result, MUIM_Notify, MUIA_NList_DoubleClick, MUIV_EveryTime,
 628             self, 2, MUIM_CallHook, &data->openwbobj_hook
 629         );
 630
 631         DoMethod
 632         (
 633             data->lst_result, MUIM_Notify, MUIA_NList_Active, MUIV_EveryTime,
 634             self, 2, MUIM_CallHook, &data->activeentry_hook
 635         );
 636     }
 637     return self;
 638 }
 639
 640 // =======================================================================================
 641
 642 IPTR FindGroup__OM_DISPOSE(Class *CLASS, Object *self, Msg msg)
 643 {
 644     struct FindGroup_DATA *data = INST_DATA(CLASS, self);
 645     MUI_DisposeObject(data->scanproc);
 646     return DoSuperMethodA(CLASS, self, msg);
 647 }
 648
 649 // =======================================================================================
 650
 651 IPTR FindGroup__MUIM_Cleanup(Class *CLASS, Object *self, Msg msg)
 652 {
 653     struct FindGroup_DATA *data = INST_DATA(CLASS, self);
 654
 655     DoMethod(data->scanproc, MUIM_Process_Kill, 0);
 656
 657     return DoSuperMethodA(CLASS, self, msg);
 658 }
 659
 660 // =======================================================================================
 661
 662 IPTR FindGroup__MUIM_Process_Process(Class *CLASS, Object *self, struct MUIP_Process_Process *msg)
 663 {
 664     // this is our sub process
 665
 666     D(bug("[Find::search process] called\n"));
 667
 668     struct FindGroup_DATA *data = INST_DATA(CLASS, self);
 669
 670     struct AnchorPath *anchorpath;
 671     LONG error;
 672     ULONG destlen;
 673     STRPTR destpattern;
 674     ULONG methodid1 = 0, methodid2 = 0;
 675
 676     STRPTR path = (STRPTR)XGET(data->str_path, MUIA_String_Contents);
 677     STRPTR srcpattern = (STRPTR)XGET(data->str_pattern, MUIA_String_Contents);
 678     STRPTR content = (STRPTR)XGET(data->str_contents, MUIA_String_Contents);
 679
 680     destlen = strlen(srcpattern) * 2 + 2;
 681     destpattern = AllocVec(destlen, MEMF_ANY);
 682     if (destpattern)
 683     {
 684         if (ParsePatternNoCase(srcpattern, destpattern, destlen) < 0) // error
 685         {
 686             // app must be NULL to avoid deadlocks
 687             MUI_Request(NULL, NULL, 0, _(MSG_APP_TITLE), _(MSG_OK), _(MSG_ERR_PATTERN));
 688             FreeVec(destpattern);
 689             return 0;
 690         }
 691     }
 692
 693     // we must use PushMethod because we are in a sub process
 694     methodid1 = DoMethod(_app(self), MUIM_Application_PushMethod,  data->lst_result, 1, MUIM_NList_Clear);
 695
 696     if (anchorpath = AllocMem(sizeof(struct AnchorPath) + PATHNAMESIZE, MEMF_CLEAR))
 697     {
 698         anchorpath->ap_Strlen = PATHNAMESIZE;
 699         anchorpath->ap_Flags = APF_DODIR;
 700
 701         if ((error = MatchFirst(path, anchorpath)) == 0)
 702         {
 703             do
 704             {
 705                 if (*msg->kill)
 706                 {
 707                     // process stopped by user
 708                     break;
 709                 }
 710
 711                 if (anchorpath->ap_Flags & APF_DIDDIR)
 712                 {
 713                     anchorpath->ap_Flags &= ~(APF_DODIR | APF_DIDDIR);
 714                 }
 715                 else
 716                 {
 717                     struct Listentry *entry;
 718                     D(bug("found %s\n", anchorpath->ap_Buf));
 719                     if (checkfile(_app(self), anchorpath, destpattern, content))
 720                     {
 721                         entry = AllocVec(sizeof (struct Listentry), MEMF_CLEAR);
 722                         if (entry)
 723                         {
 724                             entry->fullname = StrDup(anchorpath->ap_Buf);
 725                             CopyMem(&anchorpath->ap_Info, &entry->fib,  sizeof (entry->fib));
 726
 727                             // we must use PushMethod because we are in a sub process
 728                             methodid2 = DoMethod(_app(self), MUIM_Application_PushMethod,
 729                                 self, 2, MUIM_FindGroup_AddEntry, entry);
 730                             if (!methodid2)
 731                             {
 732                                 FreeVec(entry->fullname);
 733                                 FreeVec(entry);
 734                             }
 735                         }
 736                     }
 737                     anchorpath->ap_Flags = APF_DODIR;
 738                 }
 739             } while ((error = MatchNext(anchorpath)) == 0);
 740         }
 741
 742         MatchEnd(anchorpath);
 743
 744         if (!*msg->kill && error != ERROR_NO_MORE_ENTRIES)
 745         {
 746             // app must be NULL to avoid deadlocks
 747             display_doserror(NULL, error);
 748         }
 749
 750         FreeMem(anchorpath, sizeof(struct AnchorPath) + PATHNAMESIZE);
 751     }
 752
 753     FreeVec(destpattern);
 754
 755     // prevent method execution after task has been killed
 756     DoMethod(_app(self), MUIM_Application_UnpushMethod, self, methodid1, 0);
 757     DoMethod(_app(self), MUIM_Application_UnpushMethod, self, methodid2, 0);
 758
 759     // Allow another start
 760     SET(data->btn_start, MUIA_Disabled, FALSE);
 761     SET(data->btn_stop, MUIA_Disabled, TRUE);
 762
 763     return 0;
 764 }
 765
 766 // =======================================================================================
 767
 768 IPTR FindGroup__MUIM_FindGroup_Start(Class *CLASS, Object *self, Msg msg)
 769 {
 770     struct FindGroup_DATA *data = INST_DATA(CLASS, self);
 771
 772     SET(data->btn_start, MUIA_Disabled, TRUE);
 773     SET(data->btn_stop, MUIA_Disabled, FALSE);
 774     DoMethod(data->scanproc, MUIM_Process_Launch);
 775
 776     return 0;
 777 }
 778
 779 // =======================================================================================
 780
 781 IPTR FindGroup__MUIM_FindGroup_Stop(Class *CLASS, Object *self, Msg msg)
 782 {
 783     struct FindGroup_DATA *data = INST_DATA(CLASS, self);
 784
 785     DoMethod(data->scanproc, MUIM_Process_Kill, 4);
 786     SET(data->btn_start, MUIA_Disabled, FALSE);
 787     SET(data->btn_stop, MUIA_Disabled, TRUE);
 788
 789     return 0;
 790 }
 791
 792 // =======================================================================================
 793
 794 IPTR FindGroup__MUIM_FindGroup_AddEntry(Class *CLASS, Object *self, struct MUIP_FindGroup_AddEntry *msg)
 795 {
 796     D(bug("[Find::MUIM_FindGroup_AddEntry] started\n"));
 797     struct FindGroup_DATA *data = INST_DATA(CLASS, self);
 798
 799     DoMethod(data->lst_result, MUIM_List_InsertSingle, msg->entry, MUIV_List_Insert_Sorted);
 800
 801     // we were called with PushMethod. After inserting the entry we can release the data
 802     FreeVec(msg->entry->fullname);
 803     FreeVec(msg->entry);
 804
 805     return TRUE;
 806 }
 807
 808 // =======================================================================================
 809
 810 ZUNE_CUSTOMCLASS_7
 811 (
 812     FindGroup, NULL, MUIC_Group, NULL,
 813     OM_NEW,                     struct opSet *,
 814     OM_DISPOSE,                 Msg,
 815     MUIM_Cleanup,               Msg,
 816     MUIM_Process_Process,       struct MUIP_Process_Process *,
 817     MUIM_FindGroup_Start,       Msg,
 818     MUIM_FindGroup_Stop,        Msg,
 819     MUIM_FindGroup_AddEntry,    struct MUIP_FindGroup_AddEntry *
 820 );