rom/filesys/console_handler/completion.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <exec/memory.h>
  10 #include <dos/dos.h>
  11 #include <utility/utility.h>
  12 #include <intuition/intuition.h>
  13 #include <graphics/rastport.h>
  14 #include <libraries/gadtools.h>
  15 #include <libraries/asl.h>
  16 #include <devices/rawkeycodes.h>
  17
  18 #include <proto/exec.h>
  19 #include <proto/dos.h>
  20 #include <proto/intuition.h>
  21 #include <proto/graphics.h>
  22 #include <proto/utility.h>
  23 #include <proto/alib.h>
  24 #include <proto/gadtools.h>
  25 #include <proto/asl.h>
  26 #include "con_handler_intern.h"
  27 #include "support.h"
  28 #include "completion.h"
  29
  30 #include <string.h>
  31 #include <stdlib.h>
  32
  33 #define DEBUG 0
  34 #include <aros/debug.h>
  35
  36 /****************************************************************************************/
  37
  38 struct matchnode
  39 {
  40     struct Node node;
  41     UBYTE       name[1];
  42 };
  43
  44 /****************************************************************************************/
  45
  46 struct completioninfo
  47 {
  48     struct filehandle   *fh;
  49     struct List         matchlist;
  50     APTR                pool;
  51     WORD                nummatchnodes;
  52     WORD                wordstart;
  53     BOOL                wordquoted;
  54     UBYTE               filepart[256];
  55     UBYTE               dirpart[256];
  56     UBYTE               pattern[256 * 2 + 3];
  57     UBYTE               match[256];
  58     BOOL                withinfo;
  59 };
  60
  61 /****************************************************************************************/
  62
  63 /* Delay opening of the gadtools.library to the first time InitCompletion is called */
  64
  65 static struct completioninfo *InitCompletion(struct filehandle *fh, BOOL withinfo)
  66 {
  67     struct completioninfo *ci = NULL;
  68     APTR pool;
  69
  70     if (fh->gtbase == NULL)
  71         fh->gtbase = OpenLibrary("gadtools.library", 39);
  72
  73     if (fh->gfxbase == NULL)
  74         fh->gfxbase = (APTR) OpenLibrary("graphics.library", 39);
  75
  76     if (fh->lastwritetask && GadToolsBase)
  77         if (fh->lastwritetask->tc_Node.ln_Type == NT_PROCESS)
  78         {
  79             if ((pool = CreatePool(MEMF_CLEAR, 1024, 1024)))
  80             {
  81                 BOOL ok = FALSE;
  82
  83                 if ((ci = (struct completioninfo *) AllocPooled(pool, sizeof(*ci))))
  84                 {
  85                     ci->pool = pool;
  86                     ci->fh = fh;
  87                     ci->withinfo = withinfo;
  88                     NewList(&ci->matchlist);
  89
  90                     ok = TRUE;
  91                 }
  92
  93                 if (!ok)
  94                 {
  95                     DeletePool(pool);
  96                     ci = NULL;
  97                 }
  98             }
  99         }
 100
 101     return ci;
 102 }
 103
 104 /****************************************************************************************/
 105
 106 static void CleanupCompletion(struct completioninfo *ci)
 107 {
 108     DeletePool(ci->pool);
 109 }
 110
 111 /****************************************************************************************/
 112
 113 static void PrepareCompletion(struct filehandle *fh, struct completioninfo *ci)
 114 {
 115     WORD i;
 116     BOOL in_quotes = FALSE;
 117
 118     /* Find word start */
 119
 120     ci->wordstart = i = ci->fh->inputstart;
 121
 122     while (i != ci->fh->inputpos)
 123     {
 124         switch (ci->fh->inputbuffer[i++])
 125         {
 126         case '"':
 127             in_quotes = !in_quotes;
 128             if (in_quotes)
 129                 ci->wordstart = i;
 130             break;
 131
 132         case ' ':
 133         case '>':
 134         case '<':
 135             if (!in_quotes)
 136                 ci->wordstart = i;
 137             break;
 138         }
 139     }
 140
 141     strncpy(ci->dirpart, &ci->fh->inputbuffer[ci->wordstart], ci->fh->inputpos - ci->wordstart);
 142     strcpy(ci->filepart, FilePart(ci->dirpart));
 143
 144     *(PathPart(ci->dirpart)) = '\0';
 145
 146     ci->wordquoted = in_quotes;
 147
 148     D(bug("PrepareCompletion: dirpart = \"%s\"  filepart = \"%s\"\n", ci->dirpart, ci->filepart));
 149 }
 150
 151 /****************************************************************************************/
 152
 153 static void AddQuotes(struct completioninfo *ci, STRPTR s, LONG s_size)
 154 {
 155     LONG len = strlen(s);
 156
 157     if (!ci->wordquoted)
 158     {
 159         if (len < s_size - 1)
 160             memmove(s + 1, s, len + 1);
 161         s[0] = '"';
 162     }
 163     else
 164     {
 165         len--;
 166     }
 167
 168     if (len < s_size - 3)
 169     {
 170         if ((s[len] != '/') && (s[len] != ':'))
 171         {
 172             s[len + 1] = '"';
 173             s[len + 2] = '\0';
 174         }
 175     }
 176 }
 177
 178 /****************************************************************************************/
 179
 180 static void InsertIntoConBuffer(struct completioninfo *ci, STRPTR s)
 181 {
 182     WORD i = ci->fh->conbufferpos;
 183
 184     /* Lame code, but speed is no issue here */
 185     while ((ci->fh->conbuffersize < CONSOLEBUFFER_SIZE) && *s)
 186     {
 187         memmove(&ci->fh->consolebuffer[i + 1], &ci->fh->consolebuffer[i], ci->fh->conbuffersize - i);
 188
 189         ci->fh->consolebuffer[i++] = *s++;
 190         ci->fh->conbuffersize++;
 191     }
 192 }
 193
 194 /****************************************************************************************/
 195
 196 static void DoFileReq(struct filehandle *fh, struct completioninfo *ci)
 197 {
 198     struct Library *AslBase;
 199     BPTR lock, olddir;
 200
 201     if ((lock = DupLock(((struct Process *) ci->fh->lastwritetask)->pr_CurrentDir)))
 202     {
 203         olddir = CurrentDir(lock);
 204
 205         if ((AslBase = OpenLibrary("asl.library", 36)))
 206         {
 207             struct FileRequester *fr;
 208             struct TagItem tags[] =
 209             {
 210             { ASLFR_Window, (IPTR) ci->fh->window },
 211             { ASLFR_DoPatterns, (IPTR) TRUE },
 212             { ASLFR_InitialPattern, 0 },
 213             { TAG_DONE } };
 214
 215             tags[2].ti_Data = (IPTR) (ci->withinfo ? "#?" : "~(#?.info)");
 216
 217             if ((fr = AllocAslRequest(ASL_FileRequest, tags)))
 218             {
 219                 if (AslRequest(fr, NULL))
 220                 {
 221                     UBYTE c;
 222
 223                     strcpy(ci->match, fr->fr_Drawer);
 224                     AddPart(ci->match, fr->fr_File, sizeof(ci->match));
 225
 226                     if (ci->match[0])
 227                     {
 228                         if (strchr(ci->match, ' '))
 229                             AddQuotes(ci, ci->match, sizeof(ci->match));
 230
 231                         c = ci->match[strlen(ci->match) - 1];
 232                         if ((c != '/') && (c != ':'))
 233                         {
 234                             strncat(ci->match, " ", sizeof(ci->match));
 235                         }
 236
 237                         InsertIntoConBuffer(ci, ci->match);
 238                     }
 239
 240                 }
 241                 FreeAslRequest(fr);
 242             }
 243
 244             CloseLibrary(AslBase);
 245
 246         } /* if ((AslBase = OpenLibrary("asl.library", 36))) */
 247
 248         CurrentDir(olddir);
 249         UnLock(lock);
 250     }
 251 }
 252
 253 /****************************************************************************************/
 254
 255 static BOOL PreparePattern(struct filehandle *fh, struct completioninfo *ci)
 256 {
 257     WORD parsecode;
 258
 259     parsecode = ParsePatternNoCase(ci->filepart, ci->pattern, sizeof(ci->pattern));
 260     if (parsecode != -1)
 261     {
 262         if (parsecode == 0)
 263         {
 264             if (ci->withinfo)
 265             {
 266                 strncat(ci->filepart, "#?", sizeof(ci->filepart));
 267             }
 268             else
 269             {
 270                 strncat(ci->filepart, "~(#?.info)", sizeof(ci->filepart));
 271             }
 272             parsecode = ParsePatternNoCase(ci->filepart, ci->pattern, sizeof(ci->pattern));
 273         }
 274     }
 275
 276     return (parsecode == 1);
 277
 278 }
 279
 280 /****************************************************************************************/
 281
 282 static void AddMatchNode(struct filehandle *fh, struct completioninfo *ci, STRPTR name, WORD type)
 283 {
 284     struct matchnode *mn;
 285     struct Node *prev, *check;
 286     WORD size;
 287     BOOL exists = FALSE;
 288
 289     size = strlen(name) + 1 + sizeof(struct matchnode) + ((type > 0) ? 1 : 0);
 290
 291     if ((mn = AllocPooled(ci->pool, size)))
 292     {
 293         strcpy(mn->name, name);
 294         mn->node.ln_Name = mn->name;
 295
 296         if (type == 1)
 297             strcat(mn->name, "/");
 298         if (type == 2)
 299             strcat(mn->name, ":");
 300
 301         /* Sort into matchlist */
 302
 303         prev = NULL;
 304         ForeachNode(&ci->matchlist, check)
 305         {
 306             WORD match;
 307
 308             match = Stricmp(mn->name, ((struct matchnode *) check)->name);
 309             if (match < 0)
 310                 break;
 311             if (match == 0)
 312             {
 313                 exists = TRUE;
 314                 break;
 315             }
 316
 317             prev = check;
 318         }
 319
 320         if (!exists)
 321         {
 322             Insert(&ci->matchlist, (struct Node *) mn, prev);
 323             ci->nummatchnodes++;
 324         }
 325         else
 326         {
 327             FreePooled(ci->pool, mn, size);
 328         }
 329     }
 330 }
 331
 332 /****************************************************************************************/
 333
 334 static void ScanDir(struct filehandle *fh, struct completioninfo *ci)
 335 {
 336     struct FileInfoBlock *fib;
 337     BPTR lock;
 338
 339     if ((fib = AllocDosObject(DOS_FIB, 0)))
 340     {
 341         if ((lock = Lock(ci->dirpart, SHARED_LOCK)))
 342         {
 343             if (Examine(lock, fib))
 344             {
 345                 while (ExNext(lock, fib))
 346                 {
 347                     if (MatchPatternNoCase(ci->pattern, fib->fib_FileName))
 348                     {
 349                         BOOL isdir = (fib->fib_DirEntryType > 0);
 350
 351                         AddMatchNode(fh, ci, fib->fib_FileName, (isdir ? 1 : 0));
 352                     }
 353                 }
 354             }
 355
 356             UnLock(lock);
 357         }
 358
 359         FreeDosObject(DOS_FIB, fib);
 360     }
 361 }
 362
 363 /****************************************************************************************/
 364
 365 static void ScanVol(struct filehandle *fh, struct completioninfo *ci)
 366 {
 367     struct DosList *dlist;
 368
 369     dlist = LockDosList(LDF_READ | LDF_VOLUMES | LDF_DEVICES | LDF_ASSIGNS);
 370
 371     while ((dlist = NextDosEntry(dlist, LDF_VOLUMES | LDF_ASSIGNS | LDF_DEVICES)) != NULL)
 372     {
 373         STRPTR devname = AROS_BSTR_ADDR(dlist->dol_Name);
 374
 375         if (MatchPatternNoCase(ci->pattern, devname))
 376         {
 377             AddMatchNode(fh, ci, devname, 2);
 378
 379         }
 380     }
 381     UnLockDosList(LDF_READ | LDF_VOLUMES | LDF_DEVICES | LDF_ASSIGNS);
 382 }
 383
 384 static void DoScan(struct filehandle *fh, struct completioninfo *ci)
 385 {
 386     BPTR lock, olddir;
 387
 388     if ((lock = DupLock(((struct Process *) ci->fh->lastwritetask)->pr_CurrentDir)))
 389     {
 390         olddir = CurrentDir(lock);
 391
 392         if (ci->dirpart[0] == 0)
 393             ScanVol(fh, ci);
 394         ScanDir(fh, ci);
 395
 396         CurrentDir(olddir);
 397         UnLock(lock);
 398     }
 399 }
 400
 401 /****************************************************************************************/
 402
 403 #define BUTTON_EXTRA_WIDTH      16
 404 #define BUTTON_EXTRA_HEIGHT     6
 405 #define BORDER_X                4
 406 #define BORDER_Y                4
 407 #define BUTTON_SPACING_X        8
 408 #define LV_BUTTON_SPACING_Y     4
 409 #define LV_EXTRA_HEIGHT         4
 410
 411 #define ID_LISTVIEW 1
 412 #define ID_OK       2
 413 #define ID_CANCEL   3
 414
 415 /****************************************************************************************/
 416
 417 static BOOL DoChooseReq(struct filehandle *fh, struct completioninfo *ci)
 418 {
 419     static const char oktext[] = "Ok";
 420     static const char canceltext[] = "Cancel";
 421     static const char titletext[] = "Select filename";
 422
 423     struct RastPort temprp;
 424     struct DrawInfo *dri;
 425     struct Window *win;
 426     struct Gadget *gadlist, *gad, *lvgad;
 427     struct NewGadget ng;
 428     APTR vi;
 429     WORD i, buttonwidth, buttonheight, visible_lv_lines;
 430     WORD winwidth, winheight, winleft, wintop;
 431     LONG sec, micro, secold, microold;
 432     BOOL retval = FALSE;
 433
 434     if ((dri = GetScreenDrawInfo(ci->fh->window->WScreen)))
 435     {
 436         if ((vi = GetVisualInfoA(ci->fh->window->WScreen, NULL)))
 437         {
 438             InitRastPort(&temprp);
 439             SetFont(&temprp, dri->dri_Font);
 440
 441             buttonwidth = TextLength(&temprp, oktext, strlen(oktext));
 442             i = TextLength(&temprp, canceltext, strlen(canceltext));
 443             buttonwidth = (buttonwidth > i) ? buttonwidth : i;
 444             buttonwidth += BUTTON_EXTRA_WIDTH;
 445
 446             buttonheight = dri->dri_Font->tf_YSize + BUTTON_EXTRA_HEIGHT;
 447
 448             i = ci->nummatchnodes > 15 ? 15 : ci->nummatchnodes;
 449             if (i < 4)
 450                 i = 4;
 451
 452             winheight = i * (dri->dri_Font->tf_YSize + 1) + LV_EXTRA_HEIGHT + LV_BUTTON_SPACING_Y + buttonheight
 453                     + BORDER_Y * 2;
 454
 455             winwidth = buttonwidth * 2 + BUTTON_SPACING_X + BORDER_X * 2;
 456             i = ci->fh->window->WScreen->Width * 1 / 3;
 457             if (i > winwidth)
 458                 winwidth = i;
 459
 460             winleft = ci->fh->window->WScreen->MouseX
 461                     - (winwidth + ci->fh->window->WScreen->WBorLeft + ci->fh->window->WScreen->WBorRight) / 2;
 462             wintop = ci->fh->window->WScreen->MouseY
 463                     - (winheight + ci->fh->window->WScreen->WBorTop + dri->dri_Font->tf_YSize + 1
 464                             + ci->fh->window->WScreen->WBorBottom) / 2;
 465
 466             gad = CreateContext(&gadlist);
 467
 468             ng.ng_LeftEdge = ci->fh->window->WScreen->WBorLeft + BORDER_X;
 469             ng.ng_TopEdge = ci->fh->window->WScreen->WBorTop + dri->dri_Font->tf_YSize + 1 + BORDER_Y;
 470             ng.ng_Width = winwidth - BORDER_X * 2;
 471             ng.ng_Height = winheight - BORDER_Y * 2 - buttonheight - LV_BUTTON_SPACING_Y;
 472             ng.ng_GadgetText = NULL;
 473             ng.ng_TextAttr = NULL;
 474             ng.ng_GadgetID = ID_LISTVIEW;
 475             ng.ng_Flags = 0;
 476             ng.ng_VisualInfo = vi;
 477             ng.ng_UserData = 0;
 478
 479             {
 480                 struct TagItem lvtags[] =
 481                 {
 482                 { GTLV_Labels, (IPTR) &ci->matchlist },
 483                 { GTLV_ShowSelected, 0 },
 484                 { GTLV_Selected, 0 },
 485                 { TAG_DONE } };
 486
 487                 gad = lvgad = CreateGadgetA(LISTVIEW_KIND, gad, &ng, lvtags);
 488
 489                 visible_lv_lines = (ng.ng_Height - LV_EXTRA_HEIGHT) / (dri->dri_Font->tf_YSize + 1);
 490             }
 491
 492             ng.ng_TopEdge += ng.ng_Height + LV_BUTTON_SPACING_Y;
 493             ng.ng_Width = buttonwidth;
 494             ng.ng_Height = buttonheight;
 495             ng.ng_GadgetText = oktext;
 496             ng.ng_GadgetID = ID_OK;
 497
 498             gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 499
 500             ng.ng_LeftEdge += winwidth - buttonwidth - BORDER_X * 2;
 501             ng.ng_GadgetText = canceltext;
 502             ng.ng_GadgetID = ID_CANCEL;
 503
 504             gad = CreateGadgetA(BUTTON_KIND, gad, &ng, NULL);
 505
 506             if (gad)
 507             {
 508                 struct TagItem wintags[] =
 509                 {
 510                     { WA_CustomScreen, (IPTR) ci->fh->window->WScreen   },
 511                     { WA_Title, (IPTR) titletext                        },
 512                     { WA_CloseGadget, TRUE                              },
 513                     { WA_DragBar, TRUE                                  },
 514                     { WA_DepthGadget, TRUE                              },
 515                     { WA_Activate, TRUE                                 },
 516                     { WA_AutoAdjust, TRUE                               },
 517                     { WA_Left, winleft                                  },
 518                     { WA_Top, wintop                                    },
 519                     { WA_InnerWidth, winwidth                           },
 520                     { WA_InnerHeight, winheight                         },
 521                     { WA_IDCMP, IDCMP_CLOSEWINDOW | IDCMP_RAWKEY | IDCMP_VANILLAKEY | LISTVIEWIDCMP | BUTTONIDCMP },
 522                     { WA_Gadgets, (IPTR) gadlist                        },
 523                     { TAG_DONE                                          }
 524                 };
 525
 526                 if ((win = OpenWindowTagList(NULL, wintags)))
 527                 {
 528                     BOOL done = FALSE;
 529                     BOOL doit = FALSE;
 530
 531                     CurrentTime(&secold, &microold);
 532
 533                     while (!done && !doit)
 534                     {
 535                         struct IntuiMessage *msg;
 536
 537                         WaitPort(win->UserPort);
 538
 539                         while ((msg = GT_GetIMsg(win->UserPort)))
 540                         {
 541                             switch (msg->Class)
 542                             {
 543                             case IDCMP_CLOSEWINDOW:
 544                                 done = TRUE;
 545                                 break;
 546
 547                             case IDCMP_VANILLAKEY:
 548                                 switch (msg->Code)
 549                                 {
 550                                 case 27:
 551                                     done = TRUE;
 552                                     break;
 553
 554                                 case 13:
 555                                     doit = TRUE;
 556                                     break;
 557                                 }
 558                                 break;
 559
 560                             case IDCMP_RAWKEY:
 561                             {
 562                                 WORD scroll = 0;
 563                                 BOOL page = FALSE;
 564                                 BOOL extreme = FALSE;
 565
 566                                 switch (msg->Code)
 567                                 {
 568                                 case RAWKEY_UP:
 569                                     scroll = -1;
 570                                     break;
 571
 572                                 case RAWKEY_DOWN:
 573                                     scroll = 1;
 574                                     break;
 575
 576                                 case RAWKEY_PAGEUP:
 577                                     scroll = -1;
 578                                     page = TRUE;
 579                                     break;
 580
 581                                 case RAWKEY_PAGEDOWN:
 582                                     scroll = 1;
 583                                     page = TRUE;
 584                                     break;
 585
 586                                 case RAWKEY_HOME:
 587                                     scroll = -1;
 588                                     extreme = TRUE;
 589                                     break;
 590
 591                                 case RAWKEY_END:
 592                                     scroll = 1;
 593                                     extreme = TRUE;
 594                                     break;
 595
 596                                 case RAWKEY_NM_WHEEL_UP:
 597                                     scroll = -1;
 598                                     break;
 599
 600                                 case RAWKEY_NM_WHEEL_DOWN:
 601                                     scroll = 1;
 602                                     break;
 603                                 }
 604
 605                                 if (msg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
 606                                 {
 607                                     page = TRUE;
 608                                 }
 609
 610                                 if (msg->Qualifier & (IEQUALIFIER_LALT | IEQUALIFIER_RALT | IEQUALIFIER_CONTROL))
 611                                 {
 612                                     extreme = TRUE;
 613                                 }
 614
 615                                 if (scroll)
 616                                 {
 617                                     IPTR getsel;
 618                                     struct TagItem tags[] =
 619                                     {
 620                                     { GTLV_Selected, (IPTR) &getsel },
 621                                     { TAG_IGNORE, TRUE },
 622                                     { TAG_DONE } };
 623                                     WORD sel;
 624
 625                                     GT_GetGadgetAttrsA(lvgad, win, NULL, tags);
 626                                     sel = (WORD) getsel;
 627
 628                                     if (extreme)
 629                                     {
 630                                         scroll *= ci->nummatchnodes;
 631                                     }
 632                                     else if (page)
 633                                     {
 634                                         scroll *= visible_lv_lines;
 635                                     }
 636
 637                                     sel += scroll;
 638                                     if (sel < 0)
 639                                         sel = ci->nummatchnodes - 1;
 640                                     if (sel >= ci->nummatchnodes)
 641                                         sel = 0;
 642
 643                                     tags[0].ti_Data = (IPTR) sel;
 644                                     tags[1].ti_Tag = GTLV_MakeVisible;
 645                                     tags[1].ti_Data = (IPTR) sel;
 646
 647                                     GT_SetGadgetAttrsA(lvgad, win, NULL, tags);
 648                                 }
 649                             }
 650                                 break;
 651
 652                             case IDCMP_GADGETUP:
 653                                 gad = (struct Gadget *) msg->IAddress;
 654
 655                                 switch (gad->GadgetID)
 656                                 {
 657                                 case ID_OK:
 658                                     doit = TRUE;
 659                                     break;
 660
 661                                 case ID_CANCEL:
 662                                     done = TRUE;
 663                                     break;
 664
 665                                 case ID_LISTVIEW:
 666                                     CurrentTime(&sec, &micro);
 667                                     if (DoubleClick(secold, microold, sec, micro))
 668                                         doit = TRUE;
 669                                     secold = sec;
 670                                     microold = micro;
 671                                     break;
 672                                 }
 673                                 break;
 674
 675                             } /* switch(msg->Class) */
 676
 677                             GT_ReplyIMsg(msg);
 678
 679                         } /* while((msg = GT_GetIMsg(win->UserPort))) */
 680
 681                     } /* while (!done && !doit) */
 682
 683                     if (doit)
 684                     {
 685                         struct Node *node;
 686                         IPTR sel;
 687
 688                         struct TagItem gettags[] =
 689                         {
 690                         { GTLV_Selected, (IPTR) &sel },
 691                         { TAG_DONE } };
 692
 693                         GT_GetGadgetAttrsA(lvgad, win, NULL, gettags);
 694
 695                         i = 0;
 696                         ForeachNode(&ci->matchlist, node)
 697                         {
 698                             if ((WORD) sel == i)
 699                             {
 700                                 AddPart(ci->match, node->ln_Name, sizeof(ci->match));
 701
 702                                 retval = TRUE;
 703                                 break;
 704                             }
 705                             i++;
 706                         }
 707
 708                     } /* if (doit) */
 709
 710                     CloseWindow(win);
 711
 712                 } /* if ((win = OpenWindowTagList(NULL, wintags))) */
 713
 714             } /* if (gad) */
 715
 716             FreeGadgets(gadlist);
 717             FreeVisualInfo(vi);
 718
 719         } /* if ((vi = GetVisualInfoA(ci->fh->window->WScreen, NULL))) */
 720
 721         FreeScreenDrawInfo(ci->fh->window->WScreen, dri);
 722
 723     } /* if ((dri = GetScreenDrawInfo(fh->window->WScreen))) */
 724
 725     return retval;
 726 }
 727
 728 /****************************************************************************************/
 729
 730 void Completion(struct filehandle *fh, BOOL withinfo)
 731 {
 732     struct completioninfo *ci;
 733
 734     if ((ci = InitCompletion(fh, withinfo)))
 735     {
 736         PrepareCompletion(fh, ci);
 737
 738         if (!ci->dirpart[0] && !ci->filepart[0])
 739         {
 740             DoFileReq(fh, ci);
 741         }
 742         else
 743         {
 744             if (PreparePattern(fh, ci))
 745             {
 746                 BOOL doprint = FALSE;
 747
 748                 DoScan(fh, ci);
 749
 750                 strncpy(ci->match, ci->dirpart, sizeof(ci->match));
 751
 752                 if (ci->nummatchnodes == 1)
 753                 {
 754                     AddPart(ci->match, ((struct matchnode *) GetHead(&ci->matchlist))->name, sizeof(ci->match));
 755
 756                     doprint = TRUE;
 757                 }
 758                 else if (ci->nummatchnodes > 1)
 759                 {
 760                     doprint = DoChooseReq(fh, ci);
 761                 }
 762
 763                 if (doprint)
 764                 {
 765                     WORD backspaces;
 766                     UBYTE c;
 767
 768                     if (strchr(ci->match, ' '))
 769                         AddQuotes(ci, ci->match, sizeof(ci->match));
 770
 771                     /* Insert as many backspaces in front of the string,
 772                      to erase whole "word" first (starting at ci->wordstart)
 773                      before reprinting expanded filename */
 774
 775                     backspaces = ci->fh->inputpos - ci->wordstart;
 776
 777                     memmove(ci->match + backspaces, ci->match, sizeof(ci->match) - backspaces);
 778                     memset(ci->match, 8, backspaces);
 779
 780                     c = ci->match[strlen(ci->match) - 1];
 781                     if ((c != '/') && (c != ':'))
 782                     {
 783                         strncat(ci->match, " ", sizeof(ci->match));
 784                     }
 785
 786                     InsertIntoConBuffer(ci, ci->match);
 787
 788                 }
 789             }
 790         }
 791
 792         CleanupCompletion(ci);
 793
 794     } /* if ((ci = InitCompletion())) */
 795
 796 }
 797
 798 /****************************************************************************************/