workbench/libs/asl/basicfuncs.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Basic helpfuncs for Asl.
   6     Lang: english
   7 */
   8
   9 #include <proto/alib.h>
  10 #include <proto/exec.h>
  11 #include <proto/utility.h>
  12 #include <proto/intuition.h>
  13 #include <proto/iffparse.h>
  14 #include <proto/diskfont.h>
  15 #include <proto/graphics.h>
  16 #include <proto/gadtools.h>
  17 #include <proto/dos.h>
  18 #include <proto/locale.h>
  19 #include <proto/workbench.h>
  20
  21 #include <exec/lists.h>
  22 #include <exec/memory.h>
  23 #include <intuition/intuition.h>
  24 #include <intuition/screens.h>
  25 #include <intuition/classusr.h>
  26 #include <intuition/imageclass.h>
  27 #include <graphics/gfxbase.h>
  28 #include <devices/rawkeycodes.h>
  29 #include <prefs/prefhdr.h>
  30 #include <prefs/font.h>
  31 #include <libraries/iffparse.h>
  32
  33 #include <string.h>
  34
  35 #include "asl_intern.h"
  36 #include "filereqsupport.h"
  37 #include "filereqhooks.h"
  38 #include "layout.h"
  39
  40 #define SDEBUG 0
  41 #define DEBUG 0
  42
  43 #include <aros/debug.h>
  44
  45 /*****************************************************************************************/
  46
  47 STATIC BOOL GetRequesterFont(struct LayoutData *, struct AslBase_intern *);
  48
  49 #if 0
  50 STATIC struct FontPrefs *GetFontPrefs(struct AslBase_intern *);
  51 STATIC VOID FreeFontPrefs(struct FontPrefs *, struct AslBase_intern *);
  52 #endif
  53
  54 /*****************************************************************************************/
  55
  56 /* Finds the internal requester data for a requester */
  57
  58 struct ReqNode *FindReqNode(APTR req, struct AslBase_intern *AslBase)
  59 {
  60     struct ReqNode *reqnode, *foundreqnode = NULL;
  61
  62     ObtainSemaphoreShared( &(AslBase->ReqListSem) );
  63
  64     ForeachNode( &(AslBase->ReqList), reqnode)
  65     {
  66         if (reqnode->rn_Req == req)
  67         {
  68             foundreqnode = reqnode;
  69             break;
  70         }
  71     }
  72
  73     ReleaseSemaphore( &(AslBase->ReqListSem) );
  74
  75     return (foundreqnode);
  76 }
  77
  78 /*****************************************************************************************/
  79
  80 VOID ParseCommonTags
  81 (
  82     struct IntReq               *intreq,
  83     struct TagItem              *taglist,
  84     struct AslBase_intern       *AslBase
  85 )
  86 {
  87     struct TagItem *tag;
  88     struct TagItem *tstate = taglist;
  89
  90     while ((tag = NextTagItem(&tstate)) != NULL)
  91     {
  92         IPTR tidata = tag->ti_Data;
  93
  94         /* The tags that are put "in a row" are defined as the same value,
  95                 and therefore we only use one of them, but the effect is for all of them
  96         */
  97
  98         switch (tag->ti_Tag)
  99         {
 100             case ASLFR_Window:
 101 /*          case ASLFO_Window:
 102             case ASLSM_Window:
 103             case ASL_Window: */  /* Obsolete */
 104                 intreq->ir_Window = (struct Window *)tidata;
 105                 break;
 106
 107             case ASLFR_Screen:
 108 /*          case ASLFO_Screen:
 109             case ASLSM_Screen: */
 110                 intreq->ir_Screen = (struct Screen *)tidata;
 111                 break;
 112
 113             case ASLFR_PubScreenName:
 114 /*          case ASLFO_PubScreenName:
 115             case ASLSM_PubScreenName: */
 116                 if (tidata)
 117                     intreq->ir_PubScreenName = (STRPTR)tidata;
 118                 break;
 119
 120             case ASLFR_PrivateIDCMP:
 121 /*          case ASLFO_PrivateIDCMP:
 122             case ASLSM_PrivateIDCMP: */
 123                 if (tidata)
 124                     intreq->ir_Flags |= IF_PRIVATEIDCMP;
 125                 else
 126                     intreq->ir_Flags &= ~IF_PRIVATEIDCMP;
 127                 break;
 128
 129
 130             case ASLFR_IntuiMsgFunc:
 131 /*          case ASLFO_IntuiMsgFunc:
 132             case ASLSM_IntuiMsgFunc: */
 133                 intreq->ir_IntuiMsgFunc = (struct Hook *)tidata;
 134                 break;
 135
 136             case ASLFR_SleepWindow:
 137 /*          case ASLFO_SleepWindow:
 138             case ASLSM_SleepWindow: */
 139                 if (tidata)
 140                     intreq->ir_Flags |= IF_SLEEPWINDOW;
 141                 else
 142                     intreq->ir_Flags &= ~IF_SLEEPWINDOW;
 143                 break;
 144
 145             case ASLFR_PopToFront:
 146 /*          case ASLFO_PopToFront:
 147             case ASLSM_PopToFront: */
 148                 if (tidata)
 149                     intreq->ir_Flags |= IF_POPTOFRONT;
 150                 else
 151                     intreq->ir_Flags &= ~IF_POPTOFRONT;
 152                 break;
 153
 154             case ASLFR_Activate:
 155 /*          case ASLFO_Activate:
 156             case ASLSM_Activate: */
 157                 if (tidata)
 158                     intreq->ir_Flags &= ~IF_OPENINACTIVE;
 159                 else
 160                     intreq->ir_Flags |= IF_OPENINACTIVE;
 161                 break;
 162
 163             case ASLFR_TextAttr:
 164 /*          case ASLFO_TextAttr:
 165             case ASLSM_TextAttr: */
 166                 intreq->ir_TextAttr = (struct TextAttr *)tidata;
 167                 break;
 168
 169             case ASLFR_Locale:
 170 /*          case ASLFO_Locale:
 171             case ASLSM_Locale: */
 172                 intreq->ir_Locale = (struct Locale *)tidata;
 173                 break;
 174
 175             case ASLFR_TitleText:
 176 /*          case ASLFO_TitleText:
 177             case ASLSM_TitleText:
 178             case ASL_Hail: */ /* Obsolete */
 179                 if (tidata)
 180                     intreq->ir_TitleText = (STRPTR)tidata;
 181                 break;
 182
 183
 184             case ASLFR_PositiveText:
 185 /*          case ASLFO_PositiveText:
 186             case ASLSM_PositiveText:
 187             case ASL_OKText: */ /* Obsolete */
 188                 if (tidata)
 189                 {
 190                     intreq->ir_PositiveText = (STRPTR)tidata;
 191                     intreq->ir_Flags |= IF_USER_POSTEXT;
 192                 }
 193                 break;
 194
 195             case ASLFR_NegativeText:
 196 /*          case ASLFO_NegativeText:
 197             case ASLSM_NegativeText:
 198             case ASL_CancelText: */ /* Obsolete */
 199                 if (tidata)
 200                 {
 201                     intreq->ir_NegativeText = (STRPTR)tidata;
 202                     intreq->ir_Flags |= IF_USER_NEGTEXT;
 203                 }
 204                 break;
 205
 206             case ASLFR_InitialLeftEdge:
 207 /*          case ASLFO_InitialLeftEdge:
 208             case ASLSM_InitialLeftEdge:
 209             case ASL_LeftEdge: */ /* Obsolete */
 210                 intreq->ir_LeftEdge = (UWORD)tidata;
 211                 break;
 212
 213             case ASLFR_InitialTopEdge:
 214 /*          case ASLFO_InitialTopEdge:
 215             case ASLSM_InitialTopEdge:
 216             case ASL_TopEdge: */ /* Obsolete */
 217                 intreq->ir_TopEdge = (UWORD)tidata;
 218                 break;
 219
 220             case ASLFR_InitialWidth:
 221 /*          case ASLFO_InitialWidth:
 222             case ASLSM_InitialWidth:
 223             case ASL_Width: */ /* Obsolete */
 224                 intreq->ir_Width = (UWORD)tidata;
 225                 break;
 226
 227             case ASLFR_InitialHeight:
 228 /*          case ASLFO_InitialHeight:
 229             case ASLSM_InitialHeight:
 230             case ASL_Height: */ /* Obsolete */
 231                 intreq->ir_Height = (UWORD)tidata;
 232                 break;
 233
 234             default:
 235                 break;
 236
 237         } /* switch (tag->ti_Tag) */
 238
 239     } /* while ((tag = NextTagItem(&tstate)) != NULL) */
 240 }
 241
 242 /*****************************************************************************************/
 243
 244 VOID FreeCommon(struct LayoutData *ld, struct AslBase_intern *AslBase)
 245 {
 246     if (ld)
 247     {
 248
 249         if (ld->ld_IntReq->ir_Catalog) CloseCatalog(ld->ld_IntReq->ir_Catalog);
 250
 251         if (ld->ld_Menu)
 252         {
 253             if (ld->ld_Window)
 254                 ClearMenuStrip(ld->ld_Window);
 255
 256             FreeMenus(ld->ld_Menu);
 257         }
 258
 259         if (ld->ld_Window)
 260         {
 261             if (ld->ld_AppWindow)
 262                 RemoveAppWindow(ld->ld_AppWindow);
 263             if (ld->ld_AppMsgPort)
 264                 DeleteMsgPort(ld->ld_AppMsgPort);
 265
 266             if (ld->ld_IntReq->ir_Flags & IF_POPPEDTOFRONT)
 267             {
 268                 ld->ld_IntReq->ir_Flags &= ~IF_POPPEDTOFRONT;
 269                 ScreenToBack(ld->ld_Window->WScreen);
 270             }
 271
 272             if ((ld->ld_IntReq->ir_Flags & IF_PRIVATEIDCMP) || (!ld->ld_IntReq->ir_Window))
 273             {
 274                 CloseWindow(ld->ld_Window);
 275             }
 276             else
 277             {
 278                 CloseWindowSafely(ld->ld_Window, AslBase);
 279             }
 280         }
 281
 282         D(bug("Window freed\n"));
 283
 284         if (ld->ld_VisualInfo) FreeVisualInfo(ld->ld_VisualInfo);
 285         if (ld->ld_Dri) FreeScreenDrawInfo(ld->ld_Screen, ld->ld_Dri);
 286
 287         if (ld->ld_ScreenLocked)
 288             UnlockPubScreen(NULL, ld->ld_Screen);
 289
 290         if (ld->ld_UserData)
 291             FreeVec(ld->ld_UserData);
 292
 293         if (ld->ld_Font)
 294             CloseFont(ld->ld_Font);
 295
 296         if (ld->ld_TextAttr.ta_Name)
 297             FreeVec(ld->ld_TextAttr.ta_Name);
 298
 299         FreeMem(ld, sizeof (struct LayoutData));
 300     }
 301 }
 302
 303 /*****************************************************************************************/
 304
 305 struct LayoutData *AllocCommon
 306 (
 307     ULONG                       udatasize,
 308     struct IntReq               *intreq,
 309     APTR                        requester,
 310     struct AslBase_intern       *AslBase
 311 )
 312 {
 313     struct Screen       *screen = NULL;
 314     struct LayoutData   *ld;
 315
 316
 317     ld = AllocMem(sizeof (struct LayoutData), MEMF_ANY|MEMF_CLEAR);
 318     if (!ld)
 319         goto failure;
 320
 321     /* Save the internal and public requester struct, so that the
 322       requester type specific hook may find them */
 323     ld->ld_IntReq       = intreq;
 324     ld->ld_Req          = requester;
 325
 326     InitRastPort(&(ld->ld_DummyRP));
 327
 328     /* We need to lock the screen we should open on to be sure it
 329     doesn't go away
 330     */
 331
 332     /* Find screen on which to open window */
 333
 334     screen = intreq->ir_Screen;
 335     if (!screen && intreq->ir_PubScreenName)
 336     {
 337         if ((screen = LockPubScreen(intreq->ir_PubScreenName)))
 338         {
 339             ld->ld_ScreenLocked = TRUE;
 340         }
 341     }
 342     if (!screen && intreq->ir_Window)
 343     {
 344         screen = intreq->ir_Window->WScreen;
 345     }
 346     if (!screen && !intreq->ir_PubScreenName)
 347     {
 348         if ((screen = LockPubScreen(NULL)))
 349         {
 350             ld->ld_ScreenLocked = TRUE;
 351         }
 352     }
 353
 354     if (!screen) goto failure;
 355
 356     ld->ld_Screen = screen;
 357
 358     if (!(ld->ld_Dri = GetScreenDrawInfo(screen))) goto failure;
 359
 360     if (!(ld->ld_VisualInfo = GetVisualInfoA(screen, NULL))) goto failure;
 361
 362     ld->ld_WBorLeft  = screen->WBorLeft;
 363     ld->ld_WBorTop   = screen->WBorTop + screen->Font->ta_YSize + 1;
 364     ld->ld_WBorRight = screen->WBorRight;
 365     ld->ld_WBorBottom = 16;
 366
 367     {
 368         struct TagItem sysi_tags[] =
 369         {
 370             {SYSIA_DrawInfo     , (IPTR)ld->ld_Dri      },
 371             {SYSIA_Which        , SIZEIMAGE             },
 372             {TAG_DONE                                   }
 373         };
 374
 375         Object *im;
 376
 377         if ((im = NewObjectA(NULL, SYSICLASS, sysi_tags)))
 378         {
 379             IPTR height;
 380
 381             if (GetAttr(IA_Height, im, &height))
 382             {
 383                 ld->ld_WBorBottom = height;
 384             }
 385             DisposeObject(im);
 386         }
 387
 388     }
 389
 390     if(GetBitMapAttr(screen->RastPort.BitMap, BMA_DEPTH) > 8) ld->ld_TrueColor = TRUE;
 391
 392     if (!(ld->ld_UserData = AllocVec(udatasize, MEMF_ANY|MEMF_CLEAR)))
 393         goto failure;
 394
 395     if (!GetRequesterFont(ld, ASLB(AslBase)))
 396         goto failure;
 397
 398     SetFont( &(ld->ld_DummyRP), ld->ld_Font );
 399
 400     if (LocaleBase)
 401     {
 402         struct TagItem tags[] =
 403         {
 404             {OC_BuiltInLanguage , (IPTR)"english"},
 405             {OC_Version         , 2              },
 406             {TAG_DONE                            }
 407         };
 408
 409         intreq->ir_Catalog = OpenCatalogA(intreq->ir_Locale, "System/Libs/asl.catalog", tags);
 410     }
 411
 412     return (ld);
 413
 414 failure:
 415     FreeCommon(ld, ASLB(AslBase));
 416
 417     return (NULL);
 418 }
 419
 420
 421 /*****************************************************************************************/
 422
 423 #define SKIPLONG(ptr, num) ptr += sizeof (LONG) * num
 424
 425 #define CONVBYTE(ptr, dest) dest = *ptr ++
 426
 427 #define SKIPBYTE(ptr) ptr ++;
 428
 429 #define CONVWORD(ptr, dest) dest = ptr[0] << 8 | ptr[1]; \
 430                 ptr += sizeof (WORD);
 431
 432 /*****************************************************************************************/
 433
 434 #if 0
 435
 436 STATIC struct FontPrefs *GetFontPrefs(struct AslBase_intern *AslBase)
 437 {
 438     struct IFFHandle            *iff;
 439     struct Library              *IFFParseBase;
 440
 441     struct StoredProperty       *sp;
 442
 443     struct FontPrefs            *fp = NULL;
 444
 445     IFFParseBase = OpenLibrary("iffparse.library", 0);
 446     if (IFFParseBase)
 447     {
 448         iff = AllocIFF();
 449         if (iff)
 450         {
 451
 452             iff->iff_Stream = (IPTR)Open("ENV:Sys/font.prefs", MODE_OLDFILE);
 453             if (iff->iff_Stream)
 454             {
 455                 InitIFFasDOS(iff);
 456
 457                 if (OpenIFF(iff, IFFF_READ) == 0)
 458                 {
 459                     PropChunk(iff, ID_PREF, ID_FONT);
 460
 461
 462                     if (ParseIFF(iff, IFFPARSE_SCAN) != 0)
 463                     {
 464
 465                         sp = FindProp(iff, ID_PREF, ID_FONT);
 466                         if (sp)
 467                         {
 468
 469                             fp = AllocMem(sizeof (struct FontPrefs), MEMF_ANY);
 470                             if (fp)
 471                             {
 472                                 UBYTE *ptr;
 473                                 STRPTR fontname;
 474
 475
 476                                 /* Set ptr to start of struct FontPrefs */
 477                                 ptr = sp->sp_Data;
 478
 479                                 /* Skip 4 first reserved longs */
 480                                 SKIPLONG(ptr, 4);
 481                                 CONVBYTE(ptr, fp->fp_FrontPen);
 482                                 CONVBYTE(ptr, fp->fp_BackPen);
 483                                 CONVBYTE(ptr, fp->fp_DrawMode);
 484
 485                                 CONVWORD(ptr, fp->fp_TextAttr.ta_YSize);
 486                                 CONVBYTE(ptr, fp->fp_TextAttr.ta_Style);
 487                                 CONVBYTE(ptr, fp->fp_TextAttr.ta_Flags);
 488
 489
 490                                 fontname =  AllocVec( strlen(ptr) + 1, MEMF_ANY);
 491                                 if (fontname)
 492                                 {
 493                                     strcpy(fontname, ptr);
 494
 495                                     fp->fp_TextAttr.ta_Name = fontname;
 496                                 }
 497                                 else
 498                                 {
 499                                     FreeMem(fp, sizeof (struct FontPrefs));
 500                                     fp = NULL;
 501                                 }
 502
 503                             } /* if (tattr) */
 504
 505                         } /* if (sp) */
 506
 507                     } /* if (ParseIFF(iff, IFFPARSE_SCAN) != 0) */
 508                     CloseIFF(iff);
 509
 510                 } /* if (OpenIFF(iff)) */
 511                 Close( (BPTR)iff->iff_Stream );
 512
 513             } /* if (iff->iff_Stream) */
 514             FreeIFF(iff);
 515
 516         } /* if (iff) */
 517         CloseLibrary(IFFParseBase);
 518
 519     } /* if (IFFParseBase) */
 520
 521     return (fp);
 522
 523 } /* GetFontPrefs() */
 524
 525 #endif
 526
 527 /*****************************************************************************************/
 528
 529 #if 0
 530
 531 STATIC VOID FreeFontPrefs(struct FontPrefs *fp, struct AslBase_intern *AslBase)
 532 {
 533
 534     FreeVec(fp->fp_TextAttr.ta_Name);
 535     FreeMem(fp, sizeof (struct FontPrefs));
 536
 537 }
 538
 539 #endif
 540
 541 /*****************************************************************************************/
 542
 543 BOOL GetRequesterFont(struct LayoutData *ld, struct AslBase_intern *AslBase)
 544 {
 545     struct TextFont     *font = NULL;
 546
 547     struct TextAttr     *usedattr, askattr;
 548
 549     BOOL                success = FALSE;
 550
 551     static struct TextAttr         topaz8 = {"topaz.font", 8, 0, 0 };
 552
 553     /* Default to satisfy GCC */
 554     usedattr = &topaz8;
 555
 556     /*
 557         Open the font we should use in the GUI.
 558         First look for a user supplied TextAttr.
 559         If not present, try to get the font preferences from ENV:Sys/font.prefs
 560         If this fails, we fall back to topaz 8
 561     */
 562
 563     /* Is there a user supplied font */
 564     usedattr = ld->ld_IntReq->ir_TextAttr;
 565
 566     if (usedattr)
 567     {
 568         font = OpenDiskFont (usedattr);
 569     }
 570
 571     /* If not, try screen font */
 572
 573     if (!font)
 574     {
 575         usedattr = ld->ld_Screen->Font;
 576         if (usedattr)
 577         {
 578             font = OpenDiskFont (usedattr);
 579         }
 580     }
 581
 582 #if 0
 583     /* If no font has been opened yet, try the preferences one */
 584     if (!font)
 585     {
 586         struct FontPrefs        *fprefs;
 587
 588         fprefs = GetFontPrefs(ASLB(AslBase));
 589         if (fprefs)
 590         {
 591             D(bug("Fontprefs found\n"));
 592
 593             D(bug("Name: %s, YSize :%d", fprefs->fp_TextAttr.ta_Name, fprefs->fp_TextAttr.ta_YSize));
 594
 595             usedattr = &(fprefs->fp_TextAttr);
 596             font = OpenDiskFont(usedattr);
 597
 598             if (!font)
 599             {
 600                 FreeFontPrefs(fprefs, ASLB(AslBase));
 601             }
 602         }
 603     }
 604 #endif
 605
 606     /* No success, so try system default font */
 607
 608     if (!font)
 609     {
 610         usedattr = &askattr;
 611
 612         SetFont(&(ld->ld_DummyRP), GfxBase->DefaultFont);
 613         AskFont(&(ld->ld_DummyRP), usedattr);
 614
 615         font = OpenDiskFont(usedattr);
 616     }
 617
 618     /* Yet no font, try topaz 8 */
 619
 620     if (!font)
 621     {
 622         usedattr = &topaz8;
 623
 624         /* Here we should really use OpenDiskFont, but
 625          * since AROS can't render diskfonts yet, we must use OpenFont()
 626          */
 627
 628         font = OpenFont(usedattr);
 629     }
 630
 631     if (font)
 632     {
 633         STRPTR fontname;
 634         /* We have to store the used textattr for later */
 635
 636         fontname = AllocVec (strlen (usedattr->ta_Name) + 1, MEMF_ANY);
 637
 638         if (fontname)
 639         {
 640             strcpy (fontname, usedattr->ta_Name);
 641
 642             ld->ld_TextAttr.ta_Name  = fontname;
 643             ld->ld_TextAttr.ta_YSize = usedattr->ta_YSize;
 644             ld->ld_TextAttr.ta_Style = usedattr->ta_Style;
 645             ld->ld_TextAttr.ta_Flags = usedattr->ta_Flags;
 646
 647             ld->ld_Font = font;
 648
 649             success = TRUE;
 650         }
 651     }
 652     return (success);
 653 }
 654
 655 /*****************************************************************************************/
 656
 657 BOOL HandleEvents(struct LayoutData *ld, struct AslReqInfo *reqinfo, struct AslBase_intern *AslBase)
 658 {
 659     struct IntReq       *intreq = ld->ld_IntReq;
 660     APTR                req = ld->ld_Req;
 661     struct IntuiMessage *imsg;
 662     struct MsgPort      *port;
 663     BOOL                success = TRUE;
 664     BOOL                terminated = FALSE;
 665
 666     EnterFunc(bug("HandleEvents(ld=%p, reqinfo=%p)\n", ld, reqinfo));
 667     port = ld->ld_Window->UserPort;
 668
 669     if (!port)
 670         port = ld->ld_Window->WindowPort;
 671
 672     while (!terminated)
 673     {
 674         if (ld->ld_AppMsgPort)
 675             Wait((1L << port->mp_SigBit) | (1L << ld->ld_AppMsgPort->mp_SigBit));
 676         else
 677             Wait((1L << port->mp_SigBit));
 678
 679         while ((imsg = (struct IntuiMessage *)GetMsg(port)))
 680         {
 681             if ((imsg->IDCMPWindow == ld->ld_Window) ||
 682                 (imsg->IDCMPWindow == ld->ld_Window2))
 683             {
 684                 switch (imsg->Class)
 685                 {
 686                     case IDCMP_MOUSEMOVE:
 687                         break;
 688
 689                     case IDCMP_NEWSIZE:
 690                         ld->ld_Command = LDCMD_LAYOUT;
 691                         CallHookPkt(&(reqinfo->GadgetryHook), ld, ASLB(AslBase));
 692                         break;
 693
 694                     case IDCMP_REFRESHWINDOW:
 695                         BeginRefresh(imsg->IDCMPWindow);
 696                         EndRefresh(imsg->IDCMPWindow, TRUE);
 697                         break;
 698
 699                     default:
 700                         /* Call the requester specific hook to handle events */
 701                         ld->ld_Command = LDCMD_HANDLEEVENTS;
 702                         ld->ld_Event = imsg;
 703
 704                         success = CallHookPkt( &(reqinfo->GadgetryHook), ld, ASLB(AslBase));
 705                         if (success == LDRET_FINISHED)
 706                         {
 707                             success    = TRUE;
 708                             terminated = TRUE;
 709                         }
 710                         if (!success)
 711                         {
 712                             success = FALSE;
 713                             terminated = TRUE;
 714                         }
 715                         break;
 716
 717
 718                 } /* switch (imsg->Class) */
 719
 720             } /* if (imsg->IDCMPWindow is ld->ld_Window or ld->ld_Window2) */
 721             else if (intreq->ir_IntuiMsgFunc)
 722             {
 723 #ifdef __MORPHOS__
 724                 REG_A4 = (ULONG)intreq->ir_BasePtr;     /* Compatability */
 725                 REG_A0 = (ULONG)intreq->ir_IntuiMsgFunc;
 726                 REG_A2 = (ULONG)req;
 727                 REG_A1 = (ULONG)imsg;
 728                 (*MyEmulHandle->EmulCallDirect68k)(intreq->ir_IntuiMsgFunc->h_Entry);
 729 #else
 730                 CallHookPkt(intreq->ir_IntuiMsgFunc, req, imsg);
 731 #endif
 732             }
 733             ReplyMsg((struct Message *)imsg);
 734
 735         } /* while ((imsg = (struct IntuiMessage *)GetMsg(port))) */
 736
 737         while ((ld->ld_AppMsgPort) && (ld->ld_AppMsg = (struct AppMessage *) GetMsg(ld->ld_AppMsgPort)))
 738         {
 739             ld->ld_Command = LDCMD_HANDLEAPPWINDOW;
 740             success = CallHookPkt( &(reqinfo->GadgetryHook), ld, ASLB(AslBase));
 741             ReplyMsg ((struct Message *) ld->ld_AppMsg);
 742
 743             /* Do Intuition stuff only now, so we can have replied message quite early */
 744             RefreshGadgets(((struct Gadget *)((struct FRUserData *)ld->ld_UserData)->Listview), ld->ld_Window, (struct Requester *)ld->ld_Req);
 745             ActivateWindow(ld->ld_Window);
 746
 747             if (ld->ld_ForeignerFiles)
 748             {
 749                 FRDropFromDifferentDrawersRequester(ld, AslBase);
 750                 MyFreeVecPooled(ld->ld_ForeignerFiles, AslBase);
 751                 ld->ld_ForeignerFiles = NULL;
 752             }
 753
 754             if (success == LDRET_FINISHED)
 755             {
 756                 success    = TRUE;
 757                 terminated = TRUE;
 758             }
 759             if (!success)
 760             {
 761                 success = FALSE;
 762                 terminated = TRUE;
 763             }
 764         } /* while ((ld->ld_AppMsgPort) && (ld->ld_AppMsg = (struct AppMessage *) GetMsg(ld->ld_AppMsgPort))) */
 765     } /* while (!terminated) */
 766
 767     ReturnBool ("HandleEvents", success);
 768
 769 } /* HandleEvents() */
 770
 771 /*****************************************************************************************/
 772
 773 UWORD BiggestTextLength(STRPTR          *strarray,
 774                         UWORD           numstrings,
 775                         struct RastPort *rp,
 776                         struct AslBase_intern * AslBase)
 777 {
 778
 779     UWORD i, w = 0, new_w;
 780
 781     for (i = 0; strarray[i] && i < numstrings; i ++)
 782     {
 783         new_w = TextLength(rp, strarray[i], strlen(strarray[i]));
 784         if (new_w > w)
 785         {
 786             w = new_w;
 787         }
 788     }
 789     return (w);
 790 }
 791
 792 /*****************************************************************************************/
 793
 794 /* Strip special info from the requester structure */
 795
 796 VOID StripRequester(APTR req, UWORD reqtype, struct AslBase_intern *AslBase)
 797 {
 798     switch (reqtype)
 799     {
 800         case ASL_FileRequest:
 801
 802             #undef GetFR
 803             #define GetFR(r) ((struct FileRequester *)r)
 804
 805 /*
 806  * We can`t free it here, because it`s called by FreeAslRequest
 807  * and AslRequest may have been overtaken by some other patch.
 808  * Original FreeAslRequest doesn't free them.
 809  * With MFR+mungwall it crashed here.
 810  * It's freeed anyway when the Pool is deleted.
 811  */
 812 //          dprintf("StripRequester: drawer 0x%lx\n",GetFR(req)->fr_Drawer);
 813 //          MyFreeVecPooled(GetFR(req)->fr_Drawer, AslBase);
 814             GetFR(req)->fr_Drawer = NULL;
 815
 816 //          dprintf("StripRequester: file 0x%lx\n",GetFR(req)->fr_File);
 817 //          MyFreeVecPooled(GetFR(req)->fr_File, AslBase);
 818             GetFR(req)->fr_File = NULL;
 819
 820 //          dprintf("StripRequester: pattern 0x%lx\n",GetFR(req)->fr_Pattern);
 821 //          MyFreeVecPooled(GetFR(req)->fr_Pattern, AslBase);
 822             GetFR(req)->fr_Pattern = NULL;
 823
 824 //          dprintf("StripRequester: arglist 0x%lx\n",GetFR(req)->fr_ArgList);
 825             if (GetFR(req)->fr_ArgList)
 826             {
 827                 struct WBArg *wbarg;
 828                 BPTR lock = GetFR(req)->fr_ArgList->wa_Lock;
 829
 830 //              dprintf("StripRequester: lock 0x%lx\n",lock);
 831                 if (lock) UnLock(lock);
 832
 833 //              dprintf("StripRequester: numargs 0x%lx\n",GetFR(req)->fr_NumArgs);
 834
 835                 for (wbarg = GetFR(req)->fr_ArgList; GetFR(req)->fr_NumArgs --; wbarg ++)
 836                 {
 837 //                  dprintf("StripRequester: wbarg 0x%lx\n",wbarg);
 838                     MyFreeVecPooled(wbarg->wa_Name, AslBase);
 839                 }
 840
 841 //              dprintf("StripRequester: free arglist\n");
 842                 MyFreeVecPooled(GetFR(req)->fr_ArgList, AslBase);
 843                 GetFR(req)->fr_ArgList = NULL;
 844             }
 845
 846
 847             break;
 848
 849         case ASL_FontRequest:
 850
 851             #undef GetFO
 852             #define GetFO(r) ((struct FontRequester *)r)
 853
 854             MyFreeVecPooled(GetFO(req)->fo_TAttr.tta_Name, AslBase);
 855             GetFO(req)->fo_TAttr.tta_Name = NULL;
 856
 857             break;
 858
 859         case ASL_ScreenModeRequest:
 860             break;
 861
 862     }
 863 }
 864
 865 /*****************************************************************************************/
 866
 867 WORD CountNodes(struct List *list, WORD flag)
 868 {
 869     struct Node *node;
 870     WORD        result = 0;
 871
 872     ForeachNode(list, node)
 873     {
 874         if ((node->ln_Pri & flag) == flag) result++;
 875     }
 876
 877     return result;
 878 }
 879
 880 /*****************************************************************************************/
 881
 882 struct Node *FindListNode(struct List *list, WORD which)
 883 {
 884     struct Node *node = NULL;
 885
 886     if (which >= 0)
 887     {
 888         for(node = list->lh_Head; node->ln_Succ && which; node = node->ln_Succ, which--)
 889         {
 890         }
 891         if (!node->ln_Succ) node = NULL;
 892     }
 893
 894     return node;
 895 }
 896
 897 /*****************************************************************************************/
 898
 899 void SortInNode(APTR req, struct List *list, struct Node *node,
 900                 WORD (*compare)(APTR req, APTR node1, APTR node2, struct AslBase_intern *AslBase),
 901                 struct AslBase_intern *AslBase)
 902 {
 903     struct Node *prevnode = NULL;
 904     struct Node *checknode;
 905
 906     ForeachNode(list, checknode)
 907     {
 908         if (compare(req, node, checknode, AslBase) < 0) break;
 909
 910         prevnode = checknode;
 911     }
 912
 913     Insert(list, node, prevnode);
 914 }
 915
 916 /*****************************************************************************************/
 917
 918 APTR MyAllocVecPooled(APTR pool, IPTR size, struct AslBase_intern *AslBase)
 919 {
 920     IPTR *mem;
 921
 922     //dprintf("MyAllocVecPooled: pool 0x%lx size %ld\n",pool,size);
 923
 924     size += sizeof(APTR) * 2;
 925
 926     if ((mem = AllocPooled(pool, size)))
 927     {
 928         //dprintf("MyAllocVecPooled: pool 0x%lx mem 0x%lx size %ld\n",pool,mem,size);
 929         *mem++ = (IPTR)pool;
 930         *mem++ = size;
 931         //dprintf("MyAllocVecPooled: mem 0x%lx\n");
 932     }
 933
 934     return mem;
 935 }
 936
 937 /*****************************************************************************************/
 938
 939 void MyFreeVecPooled(APTR mem, struct AslBase_intern *AslBase)
 940 {
 941     IPTR *imem = (IPTR *)mem;
 942
 943     if (mem)
 944     {
 945         IPTR size = *--imem;
 946         APTR pool = (APTR)*--imem;
 947
 948         //dprintf("MyFreeVecPooled: pool 0x%lx imem 0x%lx size %ld\n",pool,imem,size);
 949
 950         FreePooled(pool, imem, size);
 951     }
 952 }
 953
 954 /*****************************************************************************************/
 955
 956 char *PooledCloneString(const char *name1, const char *name2, APTR pool,
 957                         struct AslBase_intern *AslBase)
 958 {
 959     char *clone;
 960     WORD len1 = strlen(name1) + 1;
 961     WORD len2 = name2 ? strlen(name2) : 0;
 962
 963     if ((clone = AllocPooled(pool, len1 + len2)))
 964     {
 965         CopyMem(name1, clone, len1);
 966         if (name2) CopyMem(name2, clone + len1 - 1, len2 + 1);
 967     }
 968
 969     return clone;
 970 }
 971
 972 /*****************************************************************************************/
 973
 974 char *PooledCloneStringLen(const char *name1, ULONG len1, const char *name2, ULONG len2, APTR pool,
 975                            struct AslBase_intern *AslBase)
 976 {
 977     char *clone;
 978     if ((clone = AllocPooled(pool, len1 + len2 + 1)))
 979     {
 980         CopyMem(name1, clone, len1);
 981         clone[len1] = '\0';
 982         if (name2)
 983         {
 984             CopyMem(name2, clone + len1, len2);
 985         }
 986         clone[len1+len2] = '\0';
 987     }
 988     return clone;
 989 }
 990
 991 /*****************************************************************************************/
 992
 993 char *VecCloneString(const char *name1, const char *name2, struct AslBase_intern *AslBase)
 994 {
 995     char *clone;
 996     WORD len1 = strlen(name1) + 1;
 997     WORD len2 = name2 ? strlen(name2) : 0;
 998
 999     if ((clone = AllocVec(len1 + len2, MEMF_PUBLIC)))
1000     {
1001         CopyMem(name1, clone, len1);
1002         if (name2) CopyMem(name2, clone + len1 - 1, len2 + 1);
1003     }
1004
1005     return clone;
1006 }
1007
1008 /*****************************************************************************************/
1009
1010 char *VecPooledCloneString(const char *name1, const char *name2, APTR pool, struct AslBase_intern *AslBase)
1011 {
1012     char *clone;
1013     WORD len1 = strlen(name1) + 1;
1014     WORD len2 = name2 ? strlen(name2) : 0;
1015
1016     if ((clone = MyAllocVecPooled(pool, len1 + len2, AslBase)))
1017     {
1018         CopyMem(name1, clone, len1);
1019         if (name2) CopyMem(name2, clone + len1 - 1, len2 + 1);
1020     }
1021
1022     return clone;
1023 }
1024
1025 /*****************************************************************************************/
1026
1027 AROS_UFH2 (void, puttostr,
1028         AROS_UFHA(UBYTE, chr, D0),
1029         AROS_UFHA(STRPTR *,strPtrPtr,A3)
1030 )
1031 {
1032     AROS_USERFUNC_INIT
1033     *(*strPtrPtr)= chr;
1034     (*strPtrPtr) ++;
1035     AROS_USERFUNC_EXIT
1036 }
1037
1038 /*****************************************************************************************/
1039
1040 /* This is used for printing out fib_Size, which is why
1041  * is takes a IPTR instead of a ULONG
1042  */
1043 char *PooledUIntegerToString(IPTR value, APTR pool, struct AslBase_intern *AslBase)
1044 {
1045     char buffer[30];
1046     char *str = buffer;
1047     char *clone;
1048     WORD len;
1049
1050     /* Create the text */
1051
1052     RawDoFmt("%iu", (RAWARG)&value, (VOID_FUNC)AROS_ASMSYMNAME(puttostr), &str);
1053
1054     len = strlen(buffer) + 1;
1055
1056     if ((clone = AllocPooled(pool, len)))
1057     {
1058         CopyMem(buffer, clone, len);
1059     }
1060
1061     return clone;
1062 }
1063
1064 /*****************************************************************************************/
1065
1066 void CloseWindowSafely(struct Window *window, struct AslBase_intern *AslBase)
1067 {
1068     struct IntuiMessage *msg;
1069     struct Node         *succ;
1070
1071     Forbid();
1072
1073     if(window->UserPort != NULL)
1074     {
1075         msg = (struct IntuiMessage *)window->UserPort->mp_MsgList.lh_Head;
1076
1077         while((succ = msg->ExecMessage.mn_Node.ln_Succ))
1078         {
1079             if(msg->IDCMPWindow == window)
1080             {
1081                 Remove((struct Node *)msg);
1082                 ReplyMsg((struct Message *)msg);
1083             }
1084
1085             msg = (struct IntuiMessage *)succ;
1086         }
1087     }
1088
1089     window->UserPort = NULL;
1090
1091     ModifyIDCMP(window, 0);
1092
1093     Permit();
1094
1095     CloseWindow(window);
1096 }
1097
1098 /*****************************************************************************************/
1099
1100 AROS_UFH3(ULONG, StringEditFunc,
1101     AROS_UFHA(struct Hook *,            hook,           A0),
1102     AROS_UFHA(struct SGWork *,          sgw,            A2),
1103     AROS_UFHA(ULONG *,                  command,        A1))
1104 {
1105     AROS_USERFUNC_INIT
1106
1107     ULONG retcode = 0;
1108
1109     switch(*command)
1110     {
1111         case SGH_KEY:
1112             retcode = 1;
1113             switch(sgw->IEvent->ie_Code)
1114             {
1115                 case RAWKEY_PAGEUP:
1116                 case RAWKEY_PAGEDOWN:
1117                 case RAWKEY_HOME:
1118                 case RAWKEY_END:
1119                 case RAWKEY_ESCAPE:
1120                 case RAWKEY_NM_WHEEL_UP:
1121                 case RAWKEY_NM_WHEEL_DOWN:
1122                     sgw->Code = STRINGCODE_NOP;
1123                     sgw->Actions = SGA_END | SGA_REUSE;
1124                     break;
1125
1126                 case CURSORUP:
1127                     sgw->EditOp  = EO_SPECIAL;
1128                     sgw->Code    = STRINGCODE_CURSORUP;
1129                     sgw->Actions = SGA_END;
1130                     break;
1131
1132                 case CURSORDOWN:
1133                     sgw->EditOp  = EO_SPECIAL;
1134                     sgw->Code    = STRINGCODE_CURSORDOWN;
1135                     sgw->Actions = SGA_END;
1136                     break;
1137             }
1138             break;
1139
1140     }
1141
1142     return retcode;
1143
1144     AROS_USERFUNC_EXIT
1145 }
1146
1147
1148 /*****************************************************************************************/
1149
1150 void PaintInnerFrame(struct RastPort *rp, struct DrawInfo *dri, Object *frameobj,
1151                      struct IBox *framebox, struct IBox *innerbox, ULONG pen,
1152                      struct AslBase_intern *AslBase)
1153 {
1154     struct impFrameBox  fmsg;
1155     struct IBox         cbox;
1156     struct IBox         fbox;
1157     WORD                x1, y1, x2, y2;
1158     WORD                ix1, iy1, ix2, iy2;
1159
1160     cbox.Left   = framebox->Left;
1161     cbox.Top    = framebox->Top;
1162     cbox.Width  = framebox->Width;
1163     cbox.Height = framebox->Height;
1164
1165     fmsg.MethodID        = IM_FRAMEBOX;
1166     fmsg.imp_ContentsBox = &cbox;
1167     fmsg.imp_FrameBox    = &fbox;
1168     fmsg.imp_DrInfo      = dri;
1169     fmsg.imp_FrameFlags  = 0;
1170
1171     DoMethodA(frameobj, (Msg)&fmsg);
1172
1173     SetABPenDrMd(rp, pen, 0, JAM1);
1174
1175     x1 = fbox.Left;
1176     y1 = fbox.Top;
1177     x2 = x1 + fbox.Width - 1;
1178     y2 = y1 + fbox.Height - 1;
1179
1180     ix1 = cbox.Left;
1181     iy1 = cbox.Top;
1182     ix2 = ix1 + cbox.Width - 1;
1183     iy2 = iy1 + cbox.Height - 1;
1184
1185     ix1 += (ix1 - x1);
1186     iy1 += (iy1 - y1);
1187     ix2 += (ix2 - x2);
1188     iy2 += (iy2 - y2);
1189
1190     x1 = innerbox->Left - 1;
1191     y1 = innerbox->Top - 1;
1192     x2 = innerbox->Left + innerbox->Width;
1193     y2 = innerbox->Top + innerbox->Height;
1194
1195     RectFill(rp, ix1, iy1, ix2, y1);
1196     RectFill(rp, ix1, iy1, x1, iy2);
1197     RectFill(rp, x2, iy1, ix2, iy2);
1198     RectFill(rp, ix1, y2, ix2, iy2);
1199
1200 }
1201
1202 /*****************************************************************************************/
1203
1204 void PaintBoxFrame(struct RastPort *rp, struct IBox *outerbox, struct IBox *innerbox,
1205                    ULONG pen, struct AslBase_intern *AslBase)
1206 {
1207     WORD x1, y1, x2, y2;
1208     WORD ix1, iy1, ix2, iy2;
1209
1210     ix1 = outerbox->Left;
1211     iy1 = outerbox->Top - 1;
1212     ix2 = outerbox->Left + outerbox->Width - 1;
1213     iy2 = outerbox->Top + outerbox->Height - 1;
1214
1215     x1 = innerbox->Left - 1;
1216     y1 = innerbox->Top - 1;
1217     x2 = innerbox->Left + innerbox->Width;
1218     y2 = innerbox->Top + innerbox->Height;
1219
1220     SetABPenDrMd(rp, pen, 0, JAM1);
1221
1222     RectFill(rp, ix1, iy1, ix2, y1);
1223     RectFill(rp, ix1, iy1, x1, iy2);
1224     RectFill(rp, x2, iy1, ix2, iy2);
1225     RectFill(rp, ix1, y2, ix2, iy2);
1226
1227 }
1228
1229 /*****************************************************************************************/