workbench/libs/reqtools/general.c

   1
   2 /* INCLUDES */
   3
   4 #include <exec/types.h>
   5 #include <exec/memory.h>
   6 #include <exec/execbase.h>
   7 #include <libraries/dos.h>
   8 #include <libraries/dosextens.h>
   9 #include <graphics/gfxmacros.h>
  10 #include <graphics/videocontrol.h>
  11 #include <graphics/view.h>
  12 #include <graphics/gfxbase.h>
  13 #include <libraries/gadtools.h>
  14 #include <intuition/intuition.h>
  15 #include <intuition/intuitionbase.h>
  16 #include <intuition/imageclass.h>
  17 #include <proto/graphics.h>
  18 #include <proto/exec.h>
  19 #include <proto/intuition.h>
  20 #include <proto/dos.h>
  21 #include <proto/gadtools.h>
  22 #include <proto/utility.h>
  23 #include <clib/macros.h>
  24 #include <string.h>
  25
  26 #include <libraries/reqtools.h>
  27 #include <proto/reqtools.h>
  28
  29 #ifdef __AROS__
  30 #include <aros/asmcall.h>
  31 #endif
  32
  33 #include "filereq.h"
  34
  35 /****************************************************************************************/
  36
  37 /* Use ColorMap.Count to find out number of palette entried on screen */
  38 //#define DO_CM_DEPTH
  39
  40 /****************************************************************************************/
  41
  42 UWORD CHIP waitpointer[] =
  43 {
  44     0x0000,0x0000,
  45     0x0400,0x07C0,0x0000,0x07C0,0x0100,0x0380,0x0000,0x07E0,
  46     0x07C0,0x1FF8,0x1FF0,0x3FEC,0x3FF8,0x7FDE,0x3FF8,0x7FBE,
  47     0x7FFC,0xFF7F,0x7EFC,0xFFFF,0x7FFC,0xFFFF,0x3FF8,0x7FFE,
  48     0x3FF8,0x7FFE,0x1FF0,0x3FFC,0x07C0,0x1FF8,0x0000,0x07E0,
  49     0x0000,0x0000,
  50 };
  51
  52 /****************************************************************************************/
  53
  54 extern struct Library           *GadToolsBase;
  55 extern struct DosLibrary        *DOSBase;
  56 extern struct IntuitionBase     *IntuitionBase;
  57 extern struct GfxBase           *GfxBase;
  58 extern struct ReqToolsBase      *ReqToolsBase;
  59 #if defined(__AROS__) || defined(__GNUC__)
  60 extern struct UtilityBase       *UtilityBase;
  61 #else
  62 extern struct Library           *UtilityBase;
  63 #endif
  64
  65 /****************************************************************************************/
  66
  67 int ASM SAVEDS GetVScreenSize (
  68         REGPARAM(a0, struct Screen *, scr),
  69         REGPARAM(a1, int *, width),
  70         REGPARAM(a2, int *, height))
  71 {
  72     struct ViewPortExtra        *vpe;
  73     struct Rectangle            dispclip, *clip;
  74     IPTR                        getvpetags[3];
  75     int                         ht;
  76 #ifndef USE_FORBID
  77     struct Screen               *pubscr;
  78     ULONG                       ilock = 0L;
  79     BOOL                        isfirst;
  80 #endif
  81
  82
  83     getvpetags[0] = VTAG_VIEWPORTEXTRA_GET;
  84     getvpetags[1] = (IPTR)&vpe;
  85     getvpetags[2] = TAG_END;
  86
  87 #ifdef USE_FORBID
  88
  89     Forbid();
  90
  91     if (IntuitionBase->FirstScreen == scr &&
  92         VideoControl (scr->ViewPort.ColorMap, (struct TagItem *)getvpetags) == 0)
  93     {
  94         clip = &((struct ViewPortExtra *)getvpetags[1])->DisplayClip;
  95     }
  96     else
  97     {
  98         QueryOverscan (GetVPModeID (&scr->ViewPort), &dispclip, OSCAN_TEXT);
  99         clip = &dispclip;
 100     }
 101
 102     Permit();
 103
 104 #else
 105
 106     if ((pubscr = LockPubScreenByAddr(scr)))
 107     {
 108         /* Cool, we got a lock on the screen, we don't need to Forbid() */
 109         ilock = LockIBase(0);
 110     }
 111     else
 112     {
 113         /* damn it, not a pubscreen, Forbid() as a last resort */
 114         Forbid();
 115     }
 116
 117     isfirst = (IntuitionBase->FirstScreen == scr);
 118
 119     if (pubscr)
 120     {
 121         UnlockIBase(ilock);
 122     }
 123
 124     if (isfirst &&
 125         VideoControl (scr->ViewPort.ColorMap, (struct TagItem *)getvpetags) == 0)
 126     {
 127         clip = &((struct ViewPortExtra *)getvpetags[1])->DisplayClip;
 128     }
 129     else
 130     {
 131         QueryOverscan (GetVPModeID (&scr->ViewPort), &dispclip, OSCAN_TEXT);
 132         clip = &dispclip;
 133     }
 134     if (pubscr)
 135     {
 136         UnlockPubScreen(NULL, pubscr);
 137     }
 138     else
 139     {
 140         Permit();
 141     }
 142
 143 #endif
 144
 145     *width = clip->MaxX - clip->MinX + 1;
 146     *height = ht = clip->MaxY - clip->MinY + 1;
 147
 148     if (scr->Width < *width) *width = scr->Width;
 149     if (scr->Height < *height) *height = scr->Height;
 150
 151     return ((ht >= 400) ? 4 : 2);
 152 }
 153
 154 /****************************************************************************************/
 155
 156 struct Screen *REGARGS LockPubScreenByAddr (struct Screen *scr)
 157 {
 158     struct List *pubscreenlist;
 159     struct PubScreenNode *pubscreennode;
 160     UBYTE pubscreenname[MAXPUBSCREENNAME + 1];
 161
 162     pubscreenname[0] = '\0';
 163
 164     pubscreenlist = LockPubScreenList();
 165     pubscreennode = (struct PubScreenNode *) pubscreenlist->lh_Head;
 166     while (pubscreennode->psn_Node.ln_Succ)
 167     {
 168         if (pubscreennode->psn_Screen == scr)
 169         {
 170             strcpy(pubscreenname, pubscreennode->psn_Node.ln_Name);
 171             break;
 172         }
 173         pubscreennode = (struct PubScreenNode *) pubscreennode->psn_Node.ln_Succ;
 174     }
 175     UnlockPubScreenList();
 176
 177     /* If we found a matching pubscreen try to lock it (note: can fail) */
 178     if (pubscreenname[0])
 179     {
 180         scr = LockPubScreen(pubscreenname);
 181     }
 182     else
 183     {
 184         scr = NULL;
 185     }
 186
 187     return scr;
 188 }
 189
 190 /****************************************************************************************/
 191
 192
 193 #undef ThisProcess
 194 #define ThisProcess()           ( ( APTR ) FindTask( NULL ) )
 195
 196 /****************************************************************************************/
 197
 198 struct Screen *REGARGS GetReqScreen (
 199         struct NewWindow *nw, struct Window **prwin, struct Screen *scr, char *pubname)
 200 {
 201     struct Window  *win = *prwin;
 202     struct Process *proc;
 203
 204     if (!pubname && !scr && !win)
 205     {
 206         proc = ThisProcess();
 207         if (proc->pr_Task.tc_Node.ln_Type == NT_PROCESS) win = proc->pr_WindowPtr;
 208     }
 209
 210     nw->Type = CUSTOMSCREEN;
 211     if (scr && !win)
 212     {
 213         struct Screen *pubscr;
 214
 215         /* Try to lock the screen as a public screen */
 216         if ((pubscr = LockPubScreenByAddr(scr)))
 217         {
 218             scr = pubscr;
 219             nw->Type = PUBLICSCREEN;
 220         }
 221         /* FIXME: probably should do something smart if the locking fail.
 222            RT_Screen is more than dangerous if you ask me... - Piru */
 223     }
 224     else
 225     {
 226         if (win && (IPTR)win != ~0) scr = win->WScreen;
 227         else
 228         {
 229             if (!(scr = LockPubScreen (pubname)))
 230                 if (!(scr = LockPubScreen (NULL))) return (NULL);
 231
 232             nw->Type = PUBLICSCREEN;
 233             win = NULL;
 234         }
 235     }
 236     *prwin = win;
 237     return (nw->Screen = scr);
 238 }
 239
 240 /****************************************************************************************/
 241
 242 #ifndef DO_CM_DEPTH
 243 static int VpDepth (struct ViewPort *vp)
 244 {
 245     ULONG       modeid = GetVPModeID (vp);
 246     int         depth;
 247
 248     depth = vp->RasInfo->BitMap->Depth;
 249
 250     if (modeid & HAM_KEY) depth -= 2;
 251     if (modeid & EXTRAHALFBRITE_KEY) depth = 5;
 252
 253     if( depth > 8 )
 254     {
 255         depth = 8;
 256     }
 257
 258     return (depth);
 259 }
 260 #endif
 261
 262 /****************************************************************************************/
 263
 264 int REGARGS
 265 GetVpCM( struct ViewPort *vp, APTR *cmap)
 266 {
 267
 268 #ifdef DO_CM_DEPTH
 269     int numcols;
 270
 271     if( !vp->ColorMap )
 272     {
 273             return( 0 );
 274     }
 275
 276     numcols = vp->ColorMap->Count;
 277 #else
 278     int depth, numcols;
 279
 280     if( !vp->ColorMap )
 281     {
 282         return( 0 );
 283     }
 284
 285     depth = VpDepth (vp);
 286     numcols = (1 << depth);
 287 #endif
 288     if( GfxBase->LibNode.lib_Version >= 39 )
 289     {
 290         if( ( *cmap = AllocVec( ( numcols * 3 + 2 ) * 4, MEMF_PUBLIC | MEMF_CLEAR ) ) )
 291         {
 292             ( ( UWORD * ) ( *cmap ) )[ 0 ] = numcols;
 293         }
 294     }
 295     else
 296     {
 297         *cmap = AllocVec( numcols * 2, MEMF_PUBLIC | MEMF_CLEAR );
 298     }
 299
 300     if( *cmap )
 301     {
 302         RefreshVpCM( vp, *cmap );
 303         return( depth );
 304     }
 305     else
 306     {
 307         return( 0 );
 308     }
 309 }
 310
 311 /****************************************************************************************/
 312
 313 void REGARGS
 314 RefreshVpCM( struct ViewPort *vp, APTR cmap )
 315 {
 316 #ifdef DO_CM_DEPTH
 317     int numcols, i;
 318
 319     numcols = vp->ColorMap->Count;
 320 #else
 321     int i, depth, numcols;
 322
 323     depth = VpDepth( vp );
 324     numcols = ( 1 << depth );
 325 #endif
 326     if( GfxBase->LibNode.lib_Version >= 39 )
 327     {
 328         GetRGB32( vp->ColorMap, 0, numcols, ( ( ULONG * ) cmap ) + 1 );
 329     }
 330     else
 331     {
 332         for( i = 0; i < numcols; i++ )
 333         {
 334             ( ( UWORD * ) cmap )[ i ] = GetRGB4( vp->ColorMap, i );
 335         }
 336     }
 337 }
 338
 339 /****************************************************************************************/
 340
 341 void REGARGS LoadCMap (struct ViewPort *vp, APTR cmap)
 342 {
 343     if (GfxBase->LibNode.lib_Version >= 39) LoadRGB32 (vp, cmap);
 344 #ifdef DO_CM_DEPTH
 345     else LoadRGB4 (vp, cmap, vp->ColorMap->Count);
 346 #else
 347     else LoadRGB4 (vp, cmap, (1 << VpDepth (vp)));
 348 #endif
 349 }
 350
 351 /****************************************************************************************/
 352
 353 void REGARGS FreeVpCM (struct ViewPort *vp, APTR cmap, BOOL restore)
 354 {
 355     if (restore && cmap) LoadCMap (vp, cmap);
 356     FreeVec (cmap);
 357 }
 358
 359 /****************************************************************************************/
 360
 361 void REGARGS InitNewGadget (struct NewGadget *ng,
 362                 int x, int y, int w, int h, char *s, UWORD id)
 363 {
 364     ng->ng_LeftEdge = x; ng->ng_TopEdge = y; ng->ng_Width = w; ng->ng_Height = h;
 365     ng->ng_GadgetText = s; ng->ng_GadgetID = id;
 366 }
 367
 368 /****************************************************************************************/
 369
 370 struct TextFont * REGARGS GetReqFont (struct TextAttr *attr,
 371                 struct TextFont *deffont, int *fontheight, int *fontwidth, int allowprop)
 372 {
 373     struct TextFont     *ft;
 374     int                 forcedef;
 375
 376     forcedef = (rtLockPrefs()->Flags & RTPRF_DEFAULTFONT);
 377     rtUnlockPrefs();
 378
 379     ft = OpenFont (attr);
 380     if (!ft || forcedef || (!allowprop && (ft->tf_Flags & FPF_PROPORTIONAL)))
 381     {
 382         if (ft) CloseFont (ft);
 383         if (deffont) ft = deffont;
 384         else ft = GfxBase->DefaultFont;
 385
 386         attr->ta_Name = ft->tf_Message.mn_Node.ln_Name;
 387         attr->ta_YSize = ft->tf_YSize;
 388         attr->ta_Style = ft->tf_Style;
 389         attr->ta_Flags = ft->tf_Flags;
 390         ft = OpenFont (attr);
 391     }
 392
 393     if (ft)
 394     {
 395         *fontheight = ft->tf_YSize;
 396         *fontwidth = ft->tf_XSize;
 397     }
 398
 399     return (ft);
 400 }
 401
 402 /****************************************************************************************/
 403
 404 struct IntuiMessage *REGARGS GetWin_GT_Msg (struct Window *win,
 405                                             struct Hook *hook, APTR req)
 406 {
 407     struct IntuiMessage *imsg, *reqmsg;
 408
 409     while ((imsg = (struct IntuiMessage *)GetMsg (win->UserPort)))
 410         if ((reqmsg = ProcessWin_Msg (win, imsg, hook, req))) return (reqmsg);
 411
 412     return (NULL);
 413 }
 414
 415 /****************************************************************************************/
 416
 417 struct IntuiMessage *REGARGS ProcessWin_Msg (struct Window *win,
 418                                             struct IntuiMessage *imsg, struct Hook *hook, APTR req)
 419 {
 420     struct IntuiMessage *reqmsg;
 421
 422     if (imsg->IDCMPWindow == win)
 423     {
 424         reqmsg = GT_FilterIMsg (imsg);
 425         if (reqmsg) return (reqmsg);
 426         ReplyMsg ((struct Message *)imsg);
 427     }
 428     else
 429     {
 430         if (hook) CallHookPkt (hook, req, imsg);
 431         ReplyMsg ((struct Message *)imsg);
 432     }
 433
 434     return (NULL);
 435 }
 436
 437 /****************************************************************************************/
 438
 439 void REGARGS Reply_GT_Msg (struct IntuiMessage *reqmsg)
 440 {
 441     ReplyMsg ((struct Message *)GT_PostFilterIMsg (reqmsg));
 442 }
 443
 444 /****************************************************************************************/
 445
 446 void REGARGS DoScreenToFront (struct Screen *scr, int nopop, int popup)
 447 {
 448     ULONG noscrtofront;
 449
 450     if (nopop) return;
 451
 452     noscrtofront = (rtLockPrefs()->Flags & RTPRF_NOSCRTOFRONT);
 453     rtUnlockPrefs();
 454
 455     if (noscrtofront) return;
 456     if (popup)
 457             ScreenToFront (scr);
 458     else
 459             rtScreenToFrontSafely (scr);
 460 }
 461
 462
 463 /****************************************************************************************/
 464
 465 void REGARGS DoCloseWindow (struct Window *win, int idcmpshared)
 466 {
 467     if (idcmpshared) rtCloseWindowSafely (win);
 468     else CloseWindow (win);
 469 }
 470
 471 /****************************************************************************************/
 472
 473 struct BackFillMsg
 474 {
 475     struct Layer *layer;
 476     struct Rectangle bounds;
 477     LONG offsetx;
 478     LONG offsety;
 479 };
 480
 481 /****************************************************************************************/
 482
 483 #ifdef __AROS__
 484 AROS_UFH3(void, WinBackFill,
 485     AROS_UFHA(struct Hook *, hook, A0),
 486     AROS_UFHA(struct RastPort *, the_rp, A2),
 487     AROS_UFHA(struct BackFillMsg *, msg, A1))
 488 {
 489     AROS_USERFUNC_INIT
 490 #else
 491 void SAVEDS ASM WinBackFill (
 492         REGPARAM(a0, struct Hook *, hook),
 493         REGPARAM(a2, struct RastPort *, the_rp),
 494         REGPARAM(a1, struct BackFillMsg *, msg))
 495 {
 496 #endif
 497     struct RastPort rp;
 498
 499     memcpy( &rp, the_rp, sizeof( rp ) );
 500     rp.Layer = NULL;
 501     SetAPen (&rp, ((UWORD *)hook->h_Data)[BACKGROUNDPEN]);
 502     mySetWriteMask (&rp, ~0);
 503     RectFill (&rp, msg->bounds.MinX, msg->bounds.MinY,
 504                    msg->bounds.MaxX, msg->bounds.MaxY);
 505
 506 #ifdef __AROS__
 507     AROS_USERFUNC_EXIT
 508 #endif
 509 }
 510
 511 /****************************************************************************************/
 512
 513 #ifdef __AROS__
 514
 515 AROS_UFH3(void, PatternWinBackFill,
 516     AROS_UFHA(struct Hook *, hook, A0),
 517     AROS_UFHA(struct RastPort *, the_rp, A2),
 518     AROS_UFHA(struct BackFillMsg *, msg, A1))
 519 {
 520     AROS_USERFUNC_INIT
 521
 522     struct RastPort rp;
 523     UWORD pattern[] = {0xAAAA,0x5555};
 524
 525     memcpy( &rp, the_rp, sizeof( rp ) );
 526     rp.Layer = NULL;
 527
 528     SetAPen (&rp, ((UWORD *)hook->h_Data)[BACKGROUNDPEN]);
 529     SetBPen (&rp, ((UWORD *)hook->h_Data)[SHINEPEN]);
 530     SetDrMd (&rp, JAM2);
 531
 532     mySetWriteMask (&rp, ~0);
 533
 534     SetAfPt(&rp, pattern, 1);
 535
 536     RectFill (&rp, msg->bounds.MinX, msg->bounds.MinY,
 537                    msg->bounds.MaxX, msg->bounds.MaxY);
 538
 539     SetAfPt(&rp, NULL, 0);
 540
 541     AROS_USERFUNC_EXIT
 542 }
 543
 544 #endif
 545
 546 /****************************************************************************************/
 547
 548 void REGARGS mySetWriteMask (struct RastPort *rp, ULONG mask)
 549 {
 550     if (GfxBase->LibNode.lib_Version >= 39) SetWriteMask (rp, mask);
 551     else SetWrMsk (rp, (UBYTE)mask);
 552 }
 553
 554 /****************************************************************************************/
 555
 556 struct Window *REGARGS OpenWindowBF (struct NewWindow *nw,
 557                         struct Hook *hook, UWORD *pens, ULONG *maskptr, WORD *zoom,
 558                         BOOL backfillpattern)
 559 {
 560     struct RastPort *rp;
 561     struct Window *win;
 562     IPTR tags[5], mask;
 563     UWORD maxpen = 0;
 564     int i;
 565
 566 #ifdef __AROS__
 567     if (backfillpattern)
 568     {
 569         hook->h_Entry = (HOOKFUNC)PatternWinBackFill;
 570     } else
 571 #endif
 572     hook->h_Entry = (HOOKFUNC)WinBackFill;
 573
 574     hook->h_Data = (void *)pens;
 575
 576     tags[0] = WA_BackFill;
 577     tags[1] = (IPTR)hook;
 578     tags[2] = WA_Zoom;
 579     tags[3] = (IPTR)zoom;
 580     tags[4] = TAG_END;
 581
 582     if( zoom )
 583     {
 584         if (IntuitionBase->LibNode.lib_Version >= 39)
 585             zoom[0] = zoom[1] = ~0;
 586         else
 587         {
 588             zoom[0] = nw->LeftEdge;
 589             zoom[1] = nw->TopEdge;
 590         }
 591     }
 592     else
 593     {
 594         tags[2] = TAG_IGNORE;
 595     }
 596
 597     if ((win = OpenWindowTagList (nw, (struct TagItem *)tags)))
 598     {
 599         rp = win->RPort;
 600         for (i = 0; i <= HIGHLIGHTTEXTPEN; i++)
 601                 if (pens[i] > maxpen) maxpen = pens[i];
 602
 603         mask = 1;
 604         while (mask < maxpen)
 605         {
 606             mask <<= 1;
 607             mask |= 1;
 608         }
 609
 610         mySetWriteMask (rp, mask);
 611         if (maskptr) *maskptr = mask;
 612     }
 613
 614     return (win);
 615
 616 }
 617
 618 /****************************************************************************************/
 619
 620 int CheckReqPos (int reqpos, int reqdefnum, struct NewWindow *newwin)
 621 {
 622     struct ReqDefaults *reqdefs;
 623
 624     if (reqpos == REQPOS_DEFAULT)
 625     {
 626         reqdefs = &rtLockPrefs()->ReqDefaults[reqdefnum];
 627         reqpos = reqdefs->ReqPos;
 628
 629         if (reqpos <= REQPOS_CENTERSCR)
 630         {
 631             newwin->LeftEdge = 0;
 632             newwin->TopEdge = 0;
 633         }
 634         else
 635         {
 636             newwin->LeftEdge = reqdefs->LeftOffset;
 637             newwin->TopEdge = reqdefs->TopOffset;
 638         }
 639
 640         rtUnlockPrefs();
 641     }
 642
 643     return (reqpos);
 644 }
 645
 646 /****************************************************************************************/
 647
 648 /*********
 649 * Layout *
 650 *********/
 651
 652 /****************************************************************************************/
 653
 654 int REGARGS StrWidth_noloc (struct IntuiText *itxt, UBYTE *str)
 655 {
 656     char labstr[100], *l;
 657
 658     if (!str) return (0);
 659
 660     /* Copy string, remove underscore */
 661     l = labstr;
 662     while (*str && *str != '_') *l++ = *str++;
 663
 664     if (*str) while ((*l++ = *++str)); else *l = 0;
 665
 666     itxt->IText = labstr;
 667
 668     return (IntuiTextLength (itxt));
 669 }
 670
 671 /****************************************************************************************/
 672
 673 static int ObjectWidth (struct NewGadget *ng, int normalw, int normalh)
 674 {
 675     if ((GadToolsBase->lib_Version >= 39) && (ng->ng_TextAttr->ta_YSize > normalh))
 676         return (normalw + (ng->ng_TextAttr->ta_YSize - normalh) * 2);
 677
 678     return (normalw);
 679 }
 680
 681 /****************************************************************************************/
 682
 683 static int ObjectHeight (struct NewGadget *ng, int normalh)
 684 {
 685     if ((GadToolsBase->lib_Version >= 39) && (ng->ng_TextAttr->ta_YSize > normalh))
 686         return (ng->ng_TextAttr->ta_YSize);
 687
 688     return (normalh);
 689 }
 690
 691 /****************************************************************************************/
 692
 693 int CheckBoxWidth (struct NewGadget *ng)
 694 {
 695     return (ObjectWidth (ng, CHECKBOX_WIDTH, CHECKBOX_HEIGHT));
 696 }
 697
 698 /****************************************************************************************/
 699
 700 int CheckBoxHeight (struct NewGadget *ng)
 701 {
 702     return (ObjectHeight (ng, CHECKBOX_HEIGHT));
 703 }
 704
 705 /****************************************************************************************/
 706
 707 /*
 708  * SIZEGAD HEIGHT
 709  */
 710 LONG BottomBorderHeight (struct Screen *scr)
 711 {
 712     struct DrawInfo     *dri;
 713     APTR                obj;
 714     LONG                h = 10;
 715
 716     if ((dri = GetScreenDrawInfo (scr)))
 717     {
 718         if((obj = NewObject (NULL, "sysiclass", SYSIA_DrawInfo, (IPTR) dri,
 719                                                 /* Must be SYSISIZE_MEDRES! */
 720                                                 SYSIA_Size, SYSISIZE_MEDRES,
 721                                                 SYSIA_Which, SIZEIMAGE,
 722                                                 TAG_DONE)))
 723         {
 724             if (!GetAttr (IA_Height, obj, (IPTR *)&h))
 725                     h = 10;  // Probably not needed.. Or?
 726             DisposeObject( obj );
 727         }
 728         FreeScreenDrawInfo (scr, dri);
 729     }
 730     return (h);
 731 }
 732
 733 /****************************************************************************************/