rom/hidds/graphics/BM_Class.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics bitmap class implementation.
   6     Lang: english
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #define SDEBUG 0
  12 #define DEBUG 0
  13 #define DPUTPATTERN(x)
  14
  15 #include <aros/debug.h>
  16 #include <proto/exec.h>
  17 #include <proto/utility.h>
  18 #include <proto/oop.h>
  19 #include <exec/memory.h>
  20 #include <utility/tagitem.h>
  21 #include <oop/oop.h>
  22 #include <oop/static_mid.h>
  23 #include <graphics/text.h>
  24 #include <graphics/scale.h>
  25 #include <hidd/graphics.h>
  26
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30
  31 #include "graphics_intern.h"
  32
  33 /****************************************************************************************/
  34
  35 #define POINT_OUTSIDE_CLIP(gc, x, y)    \
  36         (  (x) < GC_CLIPX1(gc)          \
  37         || (x) > GC_CLIPX2(gc)          \
  38         || (y) < GC_CLIPY1(gc)          \
  39         || (y) > GC_CLIPY2(gc) )
  40
  41 /*****************************************************************************************
  42
  43     NAME
  44         --background_bitmap--
  45
  46     LOCATION
  47         hidd.graphics.bitmap
  48
  49     NOTES
  50         Every display driver should implement at least one bitmap class for displayable
  51         bitmaps.
  52
  53         Normally this class doesn't need to have public ID. In order to use it the driver
  54         should pass class pointer as aoHidd_BitMap_ClassPtr value to the graphics base class
  55         in its moHidd_Gfx_NewBitMap implementation.
  56
  57         BitMap base class is in C++ terminology a pure virtual
  58         baseclass. It will not allocate any bitmap data at all;
  59         that is up to the subclass to do.
  60
  61         The main task of the BitMap baseclass is to store some information about the bitmap
  62         like its size and pixelformat. A pixelformat is an object of private class which
  63         stores the actual information about the format.
  64
  65         There are two ways that we can find out the pixfmt in our moHidd_Gfx_NewBitMap
  66         implementation:
  67
  68         Displayable bitmap -
  69             The tags will contain a modeid.
  70             One can use this modeid to get a pointer to an
  71             already registered pixfmt.
  72
  73         Non-displayable bitmap -
  74             The aoHidd_BitMap_StdPixFmt or aoHidd_BitMap_Friend attribute will always be
  75             passed.
  76
  77 *****************************************************************************************/
  78
  79 #define PIXBUFBYTES 16384
  80
  81 static BOOL DoBufferedOperation(OOP_Class *cl, OOP_Object *o, UWORD startx, UWORD starty, UWORD width, UWORD height,
  82                                 BOOL getimage, HIDDT_StdPixFmt stdpf, VOID_FUNC operation, void *userdata)
  83 {
  84     struct HIDDBitMapData *data = OOP_INST_DATA(cl, o);
  85     ULONG bytesperline = width * sizeof(ULONG);
  86     UWORD buflines     = PIXBUFBYTES / 4; /* Remove slow division */
  87     ULONG bufsize;
  88     UWORD endy = starty + height;
  89     UWORD y;
  90     UBYTE *buf;
  91
  92     if (buflines == 0)
  93         buflines = 1;
  94     else if (buflines > height)
  95         buflines = height;
  96
  97     bufsize = buflines * bytesperline;
  98     buf = AllocMem(bufsize, MEMF_PUBLIC);
  99     if (!buf && (buflines > 1))
 100     {
 101         /* Try to allocate single-line buffer */
 102         buflines = 1;
 103         bufsize  = bytesperline;
 104         buf = AllocMem(bufsize, MEMF_PUBLIC);
 105     }
 106     if (!buf)
 107         return FALSE;
 108
 109     for (y = starty; y < endy; y += buflines)
 110     {
 111         if (y + buflines > endy)
 112         {
 113             /* This prevents overflow on last pass, buffer may be used only partially */
 114             buflines = endy - y;
 115         }
 116
 117         if (getimage)
 118         {
 119             /* For some operations this can be optimized away */
 120             HIDD_BM_GetImage(o, buf, bytesperline, startx, y, width, buflines, stdpf);
 121         }
 122
 123         operation(buf, y, width, buflines, userdata);
 124
 125         HIDD_BM_PutImage(o, data->gc, buf, bytesperline, startx, y, width, buflines, stdpf);
 126     }
 127
 128     FreeMem(buf, bufsize);
 129     return TRUE;
 130 }
 131
 132 /*****************************************************************************************
 133
 134     NAME
 135         aoHidd_BitMap_Width
 136
 137     SYNOPSIS
 138         [ISG], UWORD
 139
 140     LOCATION
 141         hidd.graphics.bitmap
 142
 143     FUNCTION
 144         Specifies bitmap width in pixels.
 145
 146         Setting this attribute does not cause actual bitmap resize, just updates the information
 147         about it. Use this only from within subclasses only if you know what you do. For example
 148         SDL hosted driver sets it when framebufer changes the resolution.
 149
 150     NOTES
 151
 152     EXAMPLE
 153
 154     BUGS
 155
 156     SEE ALSO
 157         aoHidd_BitMap_Height
 158
 159     INTERNALS
 160
 161 *****************************************************************************************/
 162
 163 /*****************************************************************************************
 164
 165     NAME
 166         aoHidd_BitMap_Height
 167
 168     SYNOPSIS
 169         [ISG], UWORD
 170
 171     LOCATION
 172         hidd.graphics.bitmap
 173
 174     FUNCTION
 175         Specifies bitmap height in pixels.
 176
 177         Setting this attribute does not cause actual bitmap resize, just updates the information
 178         about it. Use this only from within subclasses only if you know what you do. For example
 179         SDL hosted driver sets it when framebufer changes the resolution.
 180
 181     NOTES
 182
 183     EXAMPLE
 184
 185     BUGS
 186
 187     SEE ALSO
 188         aoHidd_BitMap_Width
 189
 190     INTERNALS
 191
 192 *****************************************************************************************/
 193
 194 /*****************************************************************************************
 195
 196     NAME
 197         aoHidd_BitMap_Displayable
 198
 199     SYNOPSIS
 200         [I.G], BOOL
 201
 202     LOCATION
 203         hidd.graphics.bitmap
 204
 205     FUNCTION
 206         The bitmap is displayable. A displayable bitmap is always managed by a display
 207         driver and must have valid display mode ID specification.
 208
 209         If this attribute is not supplied during bitmap creation, its value defaults
 210         to FALSE.
 211
 212     NOTES
 213
 214     EXAMPLE
 215
 216     BUGS
 217
 218     SEE ALSO
 219         aoHidd_BitMap_ModeID
 220
 221     INTERNALS
 222
 223 *****************************************************************************************/
 224
 225 /*****************************************************************************************
 226
 227     NAME
 228         aoHidd_BitMap_Visible
 229
 230     SYNOPSIS
 231         [..G], BOOL
 232
 233     LOCATION
 234         hidd.graphics.bitmap
 235
 236     FUNCTION
 237         Check if the bitmap is currently visible on screen
 238
 239     NOTES
 240
 241     EXAMPLE
 242
 243     BUGS
 244         Not all display drivers implement this attribute. No AROS components currently rely
 245         on its value.
 246
 247     SEE ALSO
 248
 249     INTERNALS
 250         Some drivers may choose to have this attribute internally setable. Do not rely on it
 251         in any way and do not attempt to set it manually from within applications, this will
 252         not do any nice things.
 253
 254 *****************************************************************************************/
 255
 256 /*****************************************************************************************
 257
 258     NAME
 259         aoHidd_BitMap_IsLinearMem
 260
 261     SYNOPSIS
 262         [..G], BOOL
 263
 264     LOCATION
 265         hidd.graphics.bitmap
 266
 267     FUNCTION
 268         Check if the bitmap provides linear memory access. This means that bitmap's
 269         pixelbuffer is directly addressable by the CPU.
 270
 271         Bitmaps with no linear memory may implement moHidd_BitMap_ObtainDirectAccess,
 272         but this means that this method will rely on mirrored buffer. In such a case
 273         the user must call moHidd_BitMap_UpdateRect after modifying bitmap's contents.
 274
 275     NOTES
 276         Used by cybergraphics.library/GetCyberMapAttr() for providing CYBRMATTR_ISLINEARMEM
 277         value.
 278
 279     EXAMPLE
 280
 281     BUGS
 282         Currently no display drivers implement this attribute despite many native mode
 283         drivers actually provide linear memory.
 284
 285     SEE ALSO
 286         moHidd_BitMap_ObtainDirectAccess, moHidd_BitMap_ReleaseDirectAccess,
 287         moHidd_BitMap_UpdateRect
 288
 289     INTERNALS
 290
 291 *****************************************************************************************/
 292
 293 /*****************************************************************************************
 294
 295     NAME
 296         aoHidd_BitMap_BytesPerRow
 297
 298     SYNOPSIS
 299         [ISG], ULONG
 300
 301     LOCATION
 302         hidd.graphics.bitmap
 303
 304     FUNCTION
 305         Specify or query number of bytes per row in the bitmap storage buffer.
 306
 307         Setting this attribute doesn't actually cause changing buffer layout, just updates
 308         the information about it. Use this only from within subclasses and only if you
 309         exactly know why you do this.
 310
 311         Specifying this attribute during object creation overrides the value calculated
 312         based on aoHidd_BitMap_Width and aoHidd_BitMap_Align values. Useful for wrapping
 313         own buffers into bitmap objects, for example, in conjunction with
 314         aoHidd_ChunkyBM_Buffer.
 315
 316     NOTES
 317         The returned value includes possible padding needed for alignment.
 318
 319     EXAMPLE
 320
 321     BUGS
 322
 323     SEE ALSO
 324         aoHidd_BitMap_Align
 325
 326     INTERNALS
 327
 328 *****************************************************************************************/
 329
 330 /*****************************************************************************************
 331
 332     NAME
 333         aoHidd_BitMap_ColorMap
 334
 335     SYNOPSIS
 336         [..G], OOP_Object *
 337
 338     LOCATION
 339         hidd.graphics.bitmap
 340
 341     FUNCTION
 342         Return associated colormap (palette) object.
 343
 344         By default only displayable bitmaps have colormaps. However a colormap can be attached
 345         to any bitmap using moHidd_BitMap_SetColors or moHidd_BitMap_SetColorMap.
 346
 347         Note that manual attaching of a colormap to a nondisplayable bitmap may cause undesired
 348         side-effects on graphics.library behavior. It's better not to do this at all. The system
 349         knows what it does better than you.
 350
 351     NOTES
 352
 353     EXAMPLE
 354
 355     BUGS
 356
 357     SEE ALSO
 358         moHidd_BitMap_SetColorMap, moHidd_BitMap_SetColors.
 359
 360     INTERNALS
 361
 362 *****************************************************************************************/
 363
 364 /*****************************************************************************************
 365
 366     NAME
 367         aoHidd_BitMap_Friend
 368
 369     SYNOPSIS
 370         [I.G], OOP_Object *
 371
 372     LOCATION
 373         hidd.graphics.bitmap
 374
 375     FUNCTION
 376         Specify a friend bitmap. The bitmap will be allocated so that it
 377         is optimized for blitting to this bitmap.
 378
 379         Display drivers may query this attribute and then query friend bitmap
 380         for anything they want (like pixelformat, mode ID, etc).
 381
 382         Note that explicit specification of mode ID and/or standard pixelformat
 383         should override defaults provided by friend bitmap (i.e. actually breaking
 384         the friendship).
 385
 386     NOTES
 387
 388     EXAMPLE
 389
 390     BUGS
 391
 392     SEE ALSO
 393
 394     INTERNALS
 395
 396 *****************************************************************************************/
 397
 398 /*****************************************************************************************
 399
 400     NAME
 401         aoHidd_BitMap_GfxHidd
 402
 403     SYNOPSIS
 404         [I.G], OOP_Object *
 405
 406     LOCATION
 407         hidd.graphics.bitmap
 408
 409     FUNCTION
 410         Specify display driver object this bitmap was created with.
 411
 412         Normally the user doesn't have to supply this attribute. Instead you should use
 413         driver's moHidd_Gfx_NewBitMap method in order to create bitmaps. In this case
 414         aoHidd_BitMap_GfxHidd attribute will be provided by graphics driver base class
 415         with the correct value.
 416
 417         It is illegal to manually create bitmap objects with no driver associated.
 418         graphics.library maintains at least a memory driver for nondisplayable
 419         bitmaps in system RAM without any acceleration.
 420
 421     NOTES
 422
 423     EXAMPLE
 424
 425     BUGS
 426
 427     SEE ALSO
 428         CLID_Hidd_Gfx/moHidd_Gfx_NewBitMap
 429
 430     INTERNALS
 431
 432 *****************************************************************************************/
 433
 434 /*****************************************************************************************
 435
 436     NAME
 437         aoHidd_BitMap_StdPixFmt
 438
 439     SYNOPSIS
 440         [I..], HIDDT_StdPixFmt
 441
 442     LOCATION
 443         hidd.graphics.bitmap
 444
 445     FUNCTION
 446         Specify standard pixelformat code (one of vHidd_StdPixFmt_... values) for the
 447         bitmap.
 448
 449         Values less than num_Hidd_PseudoStdPixFmt are illegal for this attribute.
 450
 451         Actually the bitmap class itself ignores this attribute. It is processed by
 452         CLID_Hidd_Gfx/moHidd_Gfx_NewBitMap method in order to look up a corresponding
 453         pixelformat object in the system's database.
 454
 455     NOTES
 456         Bitmaps with this attribute set should be created as RAM bitmaps with direct CPU
 457         access. It is not recommended to replace them with, for example, virtual surfaces on
 458         hosted AROS. Such bitmaps are expected to be directly addressable and breaking
 459         this may cause undesired side effects.
 460
 461     EXAMPLE
 462
 463     BUGS
 464
 465     SEE ALSO
 466         aoHidd_BitMap_PixFmt, CLID_Hidd_Gfx/moHidd_Gfx_NewBitMap
 467
 468     INTERNALS
 469         Currently all display drivers omit specifying own bitmap class for bitmaps with this
 470         attribute set, letting base class (actually memory driver) to select an appropriate
 471         class for it. This way it ends up in a bitmap of CLID_Hidd_ChunkyBM or CLID_Hidd_PlanarBM
 472         class. It is recommended to follow this rule. It's not prohibited, however, to do some
 473         adjustments to the bitmap (like alignment) in order to optimize blitting to/from it.
 474         In fact if the display driver was asked to create such a bitmap, this means that
 475         the standard bitmap is being created as a friend of some bitmap which was allocated
 476         using this driver. This way the bitmap is expected to be friendly to this driver.
 477
 478 *****************************************************************************************/
 479
 480 /*****************************************************************************************
 481
 482     NAME
 483         aoHidd_BitMap_PixFmt
 484
 485     SYNOPSIS
 486         [I.G], OOP_Object *
 487
 488     LOCATION
 489         hidd.graphics.bitmap
 490
 491     FUNCTION
 492         Specify or query pixelformat descriptor object associated with the bitmap.
 493
 494         Every bitmap has some associated pixelformat object. Pixelformat objects are
 495         shared data storages, so many bitmaps may refer to the same pixelformat objects.
 496
 497     NOTES
 498         This attribute is internally specified during bitmap creation, but it's illegal
 499         to do this for the user. NewBitMap method of graphics driver performs an explicit
 500         check against this. It's up to graphics base classes to figure out its value.
 501
 502     EXAMPLE
 503
 504     BUGS
 505
 506     SEE ALSO
 507
 508     INTERNALS
 509
 510 *****************************************************************************************/
 511
 512 /*****************************************************************************************
 513
 514     NAME
 515         aoHidd_BitMap_ModeID
 516
 517     SYNOPSIS
 518         [ISG], HIDDT_ModeID
 519
 520     LOCATION
 521         hidd.graphics.bitmap
 522
 523     FUNCTION
 524         Specify display mode ID for displayable bitmap.
 525
 526         A displayable bitmap must have this attribute supplied with valid value. A nondisplayable
 527         one may miss it, however it may remember it if it was created as a friend of displayable
 528         one. This way you may create another displayable bitmap as a friend of nondisplayable
 529         one which in turn is a friend of displayable one.
 530
 531         This attribute can be set on a framebuffer bitmap. Doing so means an explicit request
 532         for the driver to change current display mode on the hardware. Dependent parameters
 533         (width, height and pixelformat) will be automatically adjusted, if not explicitly
 534         specified in the attributes list.
 535
 536     NOTES
 537         If the given ModeID is not supported, the operation causes an error. You can check
 538         for this by checking return value of OOP_SetAttrs() function. It will be TRUE in
 539         case of success and FALSE upon failure. In case of failure none of bitmap attributes
 540         will be changed.
 541
 542     EXAMPLE
 543
 544     BUGS
 545
 546     SEE ALSO
 547
 548     INTERNALS
 549
 550 *****************************************************************************************/
 551
 552 /*****************************************************************************************
 553
 554     NAME
 555         aoHidd_BitMap_ClassPtr
 556
 557     SYNOPSIS
 558         [I..], OOP_Class *
 559
 560     LOCATION
 561         hidd.graphics.bitmap
 562
 563     FUNCTION
 564         Explicitly specify bitmap's class pointer.
 565
 566         This attribute is not actually a bitmap's attribute. Your display driver class can
 567         supply it to base class' moHidd_Gfx_NewBitMap method in order to select a class on
 568         which to call OOP_NewObject().
 569
 570         If neither this attribute nor aoHidd_BitMap_ClassID attribute is provided for
 571         moHidd_Gfx_NewBitMap, graphics base class will do its best in order to find out the
 572         correct class based on aoHidd_StdPixFmt attribute value or friend bitmap.
 573
 574     NOTES
 575         If a friend bitmap is given, the new bitmap will have the same class, if your driver
 576         doesn't override it by supplying explicit class specification (using either
 577         aoHidd_BitMap_ClassPtr or aoHidd_BitMap_ClassID attribute).
 578
 579     EXAMPLE
 580
 581     BUGS
 582
 583     SEE ALSO
 584         aoHidd_BitMap_ClassID, CLID_Hidd_Gfx/moHidd_Gfx_NewBitMap
 585
 586     INTERNALS
 587
 588 *****************************************************************************************/
 589
 590 /*****************************************************************************************
 591
 592     NAME
 593         aoHidd_BitMap_ClassID
 594
 595     SYNOPSIS
 596         [I..]
 597
 598     LOCATION
 599         hidd.graphics.bitmap
 600
 601     FUNCTION
 602         Explicitly specify bitmap's class ID.
 603
 604         The purpose of this attribute is to let graphics driver base class to select a class
 605         on which to call OOP_NewObject() in its moHidd_Gfx_NewBitMap implementation.
 606
 607         If neither this attribute nor aoHidd_BitMap_ClassPtr attribute is provided for
 608         moHidd_Gfx_NewBitMap, graphics base class will do its best in order to find out the
 609         correct class based on aoHidd_StdPixFmt attribute value or aoHidd_BitMap_ClassPtr value
 610         of friend bitmap.
 611
 612     NOTES
 613
 614     EXAMPLE
 615
 616     BUGS
 617         The pointer to a given class will not be remembered as aoHidd_BitMap_ClassPtr value.
 618
 619     SEE ALSO
 620         aoHidd_BitMap_ClassPtr, CLID_Hidd_Gfx/moHidd_Gfx_NewBitMap
 621
 622     INTERNALS
 623
 624 *****************************************************************************************/
 625
 626 /*****************************************************************************************
 627
 628     NAME
 629         aoHidd_BitMap_PixFmtTags
 630
 631     SYNOPSIS
 632         [...]
 633
 634     LOCATION
 635         hidd.graphics.bitmap
 636
 637     FUNCTION
 638         Private, very obsolete and currently has no function. Considered reserved.
 639
 640     NOTES
 641
 642     EXAMPLE
 643
 644     BUGS
 645
 646     SEE ALSO
 647
 648     INTERNALS
 649
 650 *****************************************************************************************/
 651
 652 /*****************************************************************************************
 653
 654     NAME
 655         aoHidd_BitMap_FrameBuffer
 656
 657     SYNOPSIS
 658         [I.G], BOOL
 659
 660     LOCATION
 661         hidd.graphics.bitmap
 662
 663     FUNCTION
 664         Specifies that the bitmap is a framebuffer bitmap.
 665
 666         A detailed description of a framebuffer is given in CLID_Hidd_Gfx/moHidd_Gfx_NewBitMap
 667         and in CLID_Hidd_Gfx/moHidd_Gfx_Show documentation.
 668
 669         Specifying this attribute causes also implicit setting of aoHidd_BitMap_Displayable
 670         to TRUE.
 671
 672     NOTES
 673
 674     EXAMPLE
 675
 676     BUGS
 677
 678     SEE ALSO
 679
 680     INTERNALS
 681
 682 *****************************************************************************************/
 683
 684 /*****************************************************************************************
 685
 686     NAME
 687         aoHidd_BitMap_LeftEdge
 688
 689     SYNOPSIS
 690         [.SG]
 691
 692     LOCATION
 693         hidd.graphics.bitmap
 694
 695     FUNCTION
 696         Controls horizontal position of a scrollable screen bitmap.
 697
 698         Size of displayable bitmaps may differ from actual screen size. In this case the
 699         bitmap can be scrolled around the whole display area. If the bitmap is larger than
 700         the display, only its part can be visible.
 701
 702         Setting this attribute causes changing left origin point of the bitmap. The value
 703         of this attribute represents an offset from the physical edge of the display to the
 704         logical edge of the bitmap. This means that if a large bitmap scrolls to the left in
 705         order to reveal its right part, the offset will be negative. If the bitmap scrolls
 706         to the left (possibly revealing another bitmap behind it), the offset will be positive.
 707
 708         It's up to the display driver to set scroll limits. If the value of the attribute
 709         becomes unacceptable for any reason, the driver should adjust it and provide the real
 710         resulting value back.
 711
 712     NOTES
 713         Implementing screen scrolling does not enforce to implement screen composition, despite
 714         the composition is really based on scrolling (in case of composition scrolling a bitmap
 715         off-display is expected to reveal another bitmap behing it instead of empty space).
 716
 717     EXAMPLE
 718
 719     BUGS
 720
 721     SEE ALSO
 722         aoHidd_BitMap_TopEdge
 723
 724     INTERNALS
 725         Base class will always provide zero value for this attribute and ignore all attempts
 726         to set it. This means that by default bitmaps don't scroll and this needs explicit
 727         implementation in the display driver.
 728
 729 *****************************************************************************************/
 730
 731 /*****************************************************************************************
 732
 733     NAME
 734         aoHidd_BitMap_TopEdge
 735
 736     SYNOPSIS
 737         [.SG]
 738
 739     LOCATION
 740         hidd.graphics.bitmap
 741
 742     FUNCTION
 743         Controls vertical position of a scrollable screen bitmap.
 744
 745         Size of displayable bitmaps may differ from actual screen size. In this case the
 746         bitmap can be scrolled around the whole display area. If the bitmap is larger than
 747         the display, only its part can be visible.
 748
 749         Setting this attribute causes changing top origin point of the bitmap. The value
 750         of this attribute represents an offset from the physical edge of the display to the
 751         logical edge of the bitmap. This means that if a large bitmap scrolls upwards in
 752         order to reveal its bottom part, the offset will be negative. If the bitmap scrolls
 753         downdards (possibly revealing another bitmap behind it), the offset will be positive.
 754
 755         It's up to the display driver to set scroll limits. If the value of the attribute
 756         becomes unacceptable for any reason, the driver should adjust it and provide the real
 757         resulting value back.
 758
 759     NOTES
 760         Implementing screen scrolling does not enforce to implement screen composition, despite
 761         the composition is really based on scrolling (in case of composition scrolling a bitmap
 762         off-display is expected to reveal another bitmap behing it instead of empty space).
 763
 764     EXAMPLE
 765
 766     BUGS
 767
 768     SEE ALSO
 769
 770     INTERNALS
 771
 772 *****************************************************************************************/
 773
 774 /*****************************************************************************************
 775
 776     NAME
 777         aoHidd_BitMap_Align
 778
 779     SYNOPSIS
 780         [I.G]
 781
 782     LOCATION
 783         hidd.graphics.bitmap
 784
 785     FUNCTION
 786         Specify number of pixels to align bitmap data width to.
 787
 788         This attribute can be added in order to enforce alignment needed for example by
 789         blitting hardware. It will have an impact on default aoHidd_BitMap_BytesPerRow
 790         value.
 791
 792         Direct specification of aoHidd_BitMap_BytesPerRow attribute overrides any value
 793         of this attribute.
 794
 795     NOTES
 796         Default value of this attribute is 16. This alignment is required by graphics.library
 797         for AmigaOS(tm) compatibility reasons.
 798
 799     EXAMPLE
 800
 801     BUGS
 802
 803     SEE ALSO
 804         aoHidd_BitMap_BytesPerRow
 805
 806     INTERNALS
 807
 808 *****************************************************************************************/
 809
 810 /*****************************************************************************************
 811
 812     NAME
 813         aoHidd_BitMap_Depth
 814
 815     SYNOPSIS
 816         [G.I]
 817
 818     LOCATION
 819         hidd.graphics.bitmap
 820
 821     FUNCTION
 822         Specify or query the actual bitmap depth.
 823
 824         This a convenience attribute to simplify handling planar bitmaps, whose actual depth
 825         may vary. Default implementation in base class simply returns depth of bitmap's
 826         pixelformat, and is ignored during initialization. Planar bitmap class returns the
 827         actual depth here. If your specific bitmap class also operates on bitmaps with variable
 828         depths, you need to implement this attribute in it.
 829
 830     NOTES
 831
 832     EXAMPLE
 833
 834     BUGS
 835
 836     SEE ALSO
 837
 838     INTERNALS
 839
 840 *****************************************************************************************/
 841
 842 /****************************************************************************************/
 843
 844 #undef csd
 845
 846 /*
 847  * Calculate suggested bytes per row value based on bitmap's default alignment
 848  * and pixelformat's bytes per pixel value.
 849  */
 850 static ULONG GetBytesPerRow(struct HIDDBitMapData *data, struct class_static_data *csd)
 851 {
 852     struct Library *OOPBase = csd->cs_OOPBase;
 853     UWORD align = data->align - 1;
 854     UWORD width = (data->width + align) & ~align;
 855     IPTR bytesperpixel, stdpf;
 856
 857     OOP_GetAttr(data->prot.pixfmt, aHidd_PixFmt_BytesPerPixel, &bytesperpixel);
 858     OOP_GetAttr(data->prot.pixfmt, aHidd_PixFmt_StdPixFmt, &stdpf);
 859
 860     if (stdpf == vHidd_StdPixFmt_Plane)
 861     {
 862         /*
 863          * Planar format actually have 8 pixels per one byte.
 864          * However bytesperpixel == 1 for them. Perhaps this should
 865          * be changed to 0 ?
 866          */
 867         return width >> 3;
 868     }
 869     else
 870     {
 871         return width * bytesperpixel;
 872     }
 873 }
 874
 875 #define csd CSD(cl)
 876
 877 OOP_Object *BM__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
 878 {
 879     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
 880     struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
 881
 882     EnterFunc(bug("BitMap::New()\n"));
 883
 884     obj  = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg) msg);
 885
 886     if (NULL != obj)
 887     {
 888         struct TagItem colmap_tags[] =
 889         {
 890             { aHidd_ColorMap_NumEntries , 16    },
 891             { TAG_DONE                          }
 892         };
 893         struct TagItem *tag, *tstate;
 894         BOOL ok = TRUE;
 895         struct HIDDBitMapData *data = OOP_INST_DATA(cl, obj);
 896
 897         /* Set some default values */
 898         data->modeid = vHidd_ModeID_Invalid;
 899         data->align  = 16;
 900
 901         tstate = msg->attrList;
 902         while ((tag = NextTagItem(&tstate)))
 903         {
 904             ULONG idx;
 905
 906             if (IS_BITMAP_ATTR(tag->ti_Tag, idx))
 907             {
 908                 switch (idx)
 909                 {
 910                 case aoHidd_BitMap_Width:
 911                     data->width = tag->ti_Data;
 912                     break;
 913
 914                 case aoHidd_BitMap_Height:
 915                     data->height = tag->ti_Data;
 916                     break;
 917
 918                 case aoHidd_BitMap_Align:
 919                     data->align = tag->ti_Data;
 920                     break;
 921
 922                 case aoHidd_BitMap_BytesPerRow:
 923                     data->bytesPerRow = tag->ti_Data;
 924                     break;
 925
 926                 case aoHidd_BitMap_GfxHidd:
 927                     data->gfxhidd = (OOP_Object *)tag->ti_Data;
 928                     break;
 929
 930                 case aoHidd_BitMap_Friend:
 931                     data->friend = (OOP_Object *)tag->ti_Data;
 932                     break;
 933
 934                 case aoHidd_BitMap_Displayable:
 935                     data->displayable = tag->ti_Data;
 936                     break;
 937
 938                 case aoHidd_BitMap_FrameBuffer:
 939                     data->framebuffer = tag->ti_Data;
 940                     break;
 941
 942                 case aoHidd_BitMap_ModeID:
 943                     data->modeid = tag->ti_Data;
 944                     break;
 945
 946                 case aoHidd_BitMap_PixFmt:
 947                     data->prot.pixfmt = (OOP_Object *)tag->ti_Data;
 948                     break;
 949                 }
 950             }
 951         }
 952
 953         /* aoHidd_BitMap_GfxHidd is mandatory */
 954         if (!data->gfxhidd)
 955         {
 956             D(bug("!!!! BM CLASS DID NOT GET GFX HIDD !!!\n"));
 957             D(bug("!!!! The reason for this is that the gfxhidd subclass NewBitmap() method\n"));
 958             D(bug("!!!! has not left it to the baseclass to actually create the object,\n"));
 959             D(bug("!!!! but rather done it itself. This MUST be corrected in the gfxhidd subclass\n"));
 960
 961             ok = FALSE;
 962         }
 963
 964         /* FrameBuffer implies Displayable */
 965         if (data->framebuffer)
 966             data->displayable = TRUE;
 967
 968         if (ok && data->displayable)
 969         {
 970             /* We should allways get modeid, but we check anyway */
 971             if (data->modeid == vHidd_ModeID_Invalid)
 972             {
 973                 D(bug("!!! BitMap:New() DID NOT GET MODEID FOR DISPLAYABLE BITMAP !!!\n"));
 974                 ok = FALSE;
 975             }
 976             else
 977             {
 978                 OOP_Object *sync, *pf;
 979
 980                 if (!HIDD_Gfx_GetMode(data->gfxhidd, data->modeid, &sync, &pf))
 981                 {
 982                     D(bug("!!! BitMap::New() RECEIVED INVALID MODEID 0x%08X\n", data->modeid));
 983                     ok = FALSE;
 984                 }
 985                 else
 986                 {
 987                     /* Update the missing bitmap data from the modeid */
 988                     if (!data->width)
 989                     {
 990                         IPTR width;
 991
 992                         OOP_GetAttr(sync, aHidd_Sync_HDisp, &width);
 993                         data->width = width;
 994                     }
 995
 996                     if (!data->height)
 997                     {
 998                         IPTR height;
 999
1000                         OOP_GetAttr(sync, aHidd_Sync_VDisp, &height);
1001                         data->height = height;
1002                     }
1003
1004                     if (!data->prot.pixfmt)
1005                     {
1006                         /* The PixFmt is allready registered and locked in the PixFmt database */
1007                         data->prot.pixfmt = pf;
1008                     }
1009                 }
1010             }
1011         } /* if (ok) */
1012
1013         if (ok)
1014         {
1015             /* * PixFmt will be NULL in case of e. g. planarbm late initialization. */
1016             if (data->prot.pixfmt)
1017             {
1018                 ULONG bytesPerRow = GetBytesPerRow(data, CSD(cl));
1019
1020                 if (data->bytesPerRow)
1021                 {
1022                     /* If we have user-supplied BytesPerRow value, make sure it's suitable */
1023                     if (data->bytesPerRow < bytesPerRow)
1024                         ok = FALSE;
1025                 }
1026                 else
1027                 {
1028                     /* Otherwise we have what we calculated */
1029                     data->bytesPerRow = bytesPerRow;
1030                 }
1031             }
1032         }
1033
1034         if (ok)
1035         {
1036             /* Cache default GC */
1037             OOP_GetAttr(data->gfxhidd, aHidd_Gfx_DefaultGC, (IPTR *)&data->gc);
1038
1039             /*
1040              * Initialize the direct method calling.
1041              * We don't check against errors because our base class contains all
1042              * these functions.
1043              */
1044 #if USE_FAST_PUTPIXEL
1045             data->putpixel = OOP_GetMethod(obj, HiddBitMapBase + moHidd_BitMap_PutPixel, &data->putpixel_Class);
1046 #endif
1047 #if USE_FAST_GETPIXEL
1048             data->getpixel = OOP_GetMethod(obj, HiddBitMapBase + moHidd_BitMap_GetPixel, &data->getpixel_Class);
1049 #endif
1050 #if USE_FAST_DRAWPIXEL
1051             data->drawpixel = OOP_GetMethod(obj, HiddBitMapBase + moHidd_BitMap_DrawPixel, &data->drawpixel_Class);
1052 #endif
1053
1054             /*
1055              * Try to create the colormap.
1056              *
1057              * stegerg: Only add a ColorMap for a visible bitmap (screen). This
1058              *          is important because one can create for example a bitmap
1059              *          in PIXFMT_LUT8 without friend bitmap and then copy this
1060              *          bitmap to a 16 bit screen. During copy the screen bitmap
1061              *          CLUT must be used, which would not happen if our PIXFMT_LUT8
1062              *          also had a colormap itself because then bltbitmap would use the
1063              *          colormap of the PIXFMT_LUT8 bitmap as lookup, which in this
1064              *          case would just cause everything to become black in the
1065              *          destination (screen) bitmap, because noone ever sets up the
1066              *          colormap of the PIXFMT_LUT8 bitmap
1067              *
1068              * sonic: CHECKME: Why does the colormap always have 16 colors? May be calculate this
1069              *        based on depth ? The colormap auto-enlarges itself if SetColors method requests
1070              *        missing entries, but is it so good?
1071              */
1072
1073             if (data->displayable)
1074             {
1075                 data->colmap = OOP_NewObject(NULL, CLID_Hidd_ColorMap, colmap_tags);
1076                 if (NULL == data->colmap)
1077                     ok = FALSE;
1078             }
1079         }
1080
1081
1082         if (!ok)
1083         {
1084             ULONG dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
1085
1086             OOP_CoerceMethod(cl, obj, &dispose_mid);
1087             obj = NULL;
1088
1089         } /* if(obj) */
1090
1091     } /* if (NULL != obj) */
1092
1093     ReturnPtr("BitMap::New", OOP_Object *, obj);
1094 }
1095
1096 /****************************************************************************************/
1097
1098 void BM__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg *msg)
1099 {
1100     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
1101     struct HIDDBitMapData *data = OOP_INST_DATA(cl, obj);
1102
1103     EnterFunc(bug("BitMap::Dispose()\n"));
1104
1105     if (NULL != data->colmap)
1106         OOP_DisposeObject(data->colmap);
1107
1108     D(bug("Calling super\n"));
1109
1110     /* Release the previously registered pixel format */
1111     if (data->pf_registered)
1112         GFX__Hidd_Gfx__ReleasePixFmt(CSD(cl)->gfxhiddclass, data->prot.pixfmt);
1113
1114     OOP_DoSuperMethod(cl, obj, (OOP_Msg) msg);
1115
1116     ReturnVoid("BitMap::Dispose");
1117 }
1118
1119 /****************************************************************************************/
1120
1121 VOID BM__Root__Get(OOP_Class *cl, OOP_Object *obj, struct pRoot_Get *msg)
1122 {
1123     struct HIDDBitMapData *data = OOP_INST_DATA(cl, obj);
1124     ULONG                  idx;
1125
1126     EnterFunc(bug("BitMap::Get() attrID: %i  storage: %p\n", msg->attrID, msg->storage));
1127
1128     if (IS_BITMAP_ATTR(msg->attrID, idx))
1129     {
1130         switch(idx)
1131         {
1132         case aoHidd_BitMap_Width:
1133             *msg->storage = data->width;
1134              D(bug("  width: %i\n", data->width));
1135              return;
1136
1137         case aoHidd_BitMap_Height:
1138             *msg->storage = data->height;
1139             return;
1140
1141         case aoHidd_BitMap_Depth:
1142             /*
1143              * Generally our bitmaps have a fixed depth, which depends on pixelformat.
1144              * If this is not true for your bitmap, overload aoHidd_BitMap_Depth in your class.
1145              */
1146             *msg->storage = ((HIDDT_PixelFormat *)data->prot.pixfmt)->depth;
1147             return;
1148
1149         case aoHidd_BitMap_Displayable:
1150             *msg->storage = data->displayable;
1151             return;
1152
1153         case aoHidd_BitMap_FrameBuffer:
1154             *msg->storage = data->framebuffer;
1155             return;
1156
1157         case aoHidd_BitMap_PixFmt:
1158             *msg->storage = (IPTR)data->prot.pixfmt;
1159             return;
1160
1161         case aoHidd_BitMap_Friend:
1162             *msg->storage = (IPTR)data->friend;
1163             return;
1164
1165         case aoHidd_BitMap_ColorMap:
1166             *msg->storage = (IPTR)data->colmap;
1167             return;
1168
1169         case aoHidd_BitMap_GfxHidd:
1170             *msg->storage = (IPTR)data->gfxhidd;
1171             return;
1172
1173         case aoHidd_BitMap_ModeID:
1174             *msg->storage = data->modeid;
1175             return;
1176
1177         case aoHidd_BitMap_Align:
1178             *msg->storage = data->align;
1179             return;
1180
1181         case aoHidd_BitMap_BytesPerRow:
1182             *msg->storage = data->bytesPerRow;
1183             return;
1184
1185         /* Generic bitmaps don't scroll. This has to be implemented in the subclass. */
1186         case aoHidd_BitMap_LeftEdge:
1187         case aoHidd_BitMap_TopEdge:
1188             *msg->storage = 0;
1189             return;
1190
1191         D(default: bug("UNKNOWN ATTR IN BITMAP BASECLASS: %d\n", idx);)
1192         }
1193     }
1194
1195     OOP_DoSuperMethod(cl, obj, &msg->mID);
1196     ReturnVoid("BitMap::Get");
1197 }
1198
1199 /****************************************************************************************/
1200
1201 #define UB(x) ((UBYTE *)x)
1202
1203 /*****************************************************************************************
1204
1205     NAME
1206         moHidd_BitMap_SetColors
1207
1208     SYNOPSIS
1209         BOOL OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_SetColors *msg);
1210
1211         BOOL HIDD_BM_SetColors (OOP_Object *obj, HIDDT_Color *colors,
1212                                 UWORD firstColor, UWORD numColors);
1213
1214     LOCATION
1215         hidd.graphics.bitmap
1216
1217     FUNCTION
1218         Sets values for one or more colors in the colormap object associated with the
1219         bitmap.
1220
1221         The colormap will be created if it does not exist.
1222
1223         Only ARGB values from the source array are taken into account. pixval member is
1224         updated with the real pixel value for every color.
1225
1226     INPUTS
1227         obj        - A bitmap object whose colormap needs to be set
1228         colors     - A pointer to source data array
1229         firstColor - Number of the first color to set
1230         numColors  - Number of subsequent colors to set
1231
1232     RESULT
1233         TRUE on success, FALSE in case of some error (like out of memory)
1234
1235     NOTES
1236
1237     EXAMPLE
1238
1239     BUGS
1240
1241     SEE ALSO
1242         CLID_Hidd_ColorMap/moHidd_ColorMap_SetColors
1243
1244     INTERNALS
1245
1246 *****************************************************************************************/
1247
1248 BOOL BM__Hidd_BitMap__SetColors(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_SetColors *msg)
1249 {
1250     /* Copy the colors into the internal buffer */
1251     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
1252     struct HIDDBitMapData *data;
1253
1254     data = OOP_INST_DATA(cl, o);
1255
1256     /* Subclass has initialized HIDDT_Color->pixelVal field and such.
1257        Just copy it into the colortab.
1258     */
1259
1260     if (NULL == data->colmap)
1261     {
1262         struct TagItem colmap_tags[] =
1263         {
1264             { aHidd_ColorMap_NumEntries, 0  },
1265             { TAG_DONE                      }
1266         };
1267
1268         colmap_tags[0].ti_Data = msg->firstColor + msg->numColors;
1269         data->colmap = OOP_NewObject(NULL, CLID_Hidd_ColorMap, colmap_tags);
1270     }
1271
1272     if (NULL == data->colmap)
1273     {
1274         return FALSE;
1275     }
1276
1277     /* Use the colormap class to set the colors */
1278     return HIDD_CM_SetColors(data->colmap, msg->colors,
1279                              msg->firstColor, msg->numColors,
1280                              data->prot.pixfmt);
1281
1282 }
1283
1284 /*****************************************************************************************
1285
1286     NAME
1287         moHidd_BitMap_DrawPixel
1288
1289     SYNOPSIS
1290         ULONG OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawPixel *msg);
1291
1292         ULONG HIDD_BM_DrawPixel(OOP_Object *obj, OOP_Object *gc, WORD x, WORD y);
1293
1294     LOCATION
1295         hidd.graphics.bitmap
1296
1297     FUNCTION
1298         Changes the pixel at (x,y). The color of the pixel depends on the
1299         attributes of gc, eg. colors, drawmode, colormask etc.
1300         This function does not check the coordinates.
1301
1302     INPUTS
1303         obj  - A bitmap to draw on
1304         gc   - A GC (graphics context) object to use for drawing
1305         x, y - Coordinates of the pixel to draw
1306
1307     RESULT
1308         Undefined. Many drivers declare this method as void.
1309
1310     NOTES
1311
1312     EXAMPLE
1313
1314     BUGS
1315
1316     SEE ALSO
1317
1318     INTERNALS
1319
1320     TODO
1321         - Support for shapeplane.
1322         - Optimize
1323
1324 *****************************************************************************************/
1325
1326 ULONG BM__Hidd_BitMap__DrawPixel(OOP_Class *cl, OOP_Object *obj,
1327                                  struct pHidd_BitMap_DrawPixel *msg)
1328 {
1329     HIDDT_Pixel                     src, dest, val;
1330     HIDDT_DrawMode                  mode;
1331     HIDDT_Pixel                     writeMask;
1332     OOP_Object                      *gc;
1333
1334 /*    EnterFunc(bug("BitMap::DrawPixel() x: %i, y: %i\n", msg->x, msg->y));
1335 */
1336     /*
1337         Example: Pixels which bits are set to 0 in the colMask must be
1338                  unchanged
1339
1340           data->colMask = 001111
1341           dest          = 101100
1342                           --
1343
1344           writeMask = ~data->colMask & dest
1345                     =   110000       & 101100
1346                     =   100000
1347
1348           dest = data->fg && dest = 010100
1349                                     --
1350
1351           dest      = dest   & (writeMask | data->ColMask)
1352                     = 010100 & (100000   | 001111)
1353                     = 010100 & (101111)
1354                     = 000100
1355                       --
1356
1357           dest      = dest   | writeMask;
1358                     = 000100   100000
1359                     = 100100
1360                       --
1361     */
1362
1363     gc = msg->gc;
1364
1365     src       = GC_FG(gc);
1366     mode      = GC_DRMD(gc);
1367
1368 #if OPTIMIZE_DRAWPIXEL_FOR_COPY
1369     if (vHidd_GC_DrawMode_Copy == mode && GC_COLMASK(gc) == ~0)
1370     {
1371         val = src;
1372     }
1373     else
1374 #endif
1375     {
1376         dest      = GETPIXEL(cl, obj, msg->x, msg->y);
1377         writeMask = ~GC_COLMASK(gc) & dest;
1378
1379         val = 0;
1380
1381         if(mode & 1) val = ( src &  dest);
1382         if(mode & 2) val = ( src & ~dest) | val;
1383         if(mode & 4) val = (~src &  dest) | val;
1384         if(mode & 8) val = (~src & ~dest) | val;
1385
1386         val = (val & (writeMask | GC_COLMASK(gc) )) | writeMask;
1387
1388     }
1389
1390     PUTPIXEL(cl, obj, msg->x, msg->y, val);
1391
1392 /*    ReturnInt("BitMap::DrawPixel ", ULONG, 1); */ /* in quickmode return always 1 */
1393
1394     return 1;
1395 }
1396
1397 /*****************************************************************************************
1398
1399     NAME
1400         moHidd_BitMap_DrawLine
1401
1402     SYNOPSIS
1403         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawPixel *msg);
1404
1405         VOID HIDD_BM_DrawLine(OOP_Object *obj, OOP_Object *gc, WORD x1, WORD y1,
1406                               WORD x2, WORD y2);
1407
1408     LOCATION
1409         hidd.graphics.bitmap
1410
1411     FUNCTION
1412         Draws a line from (x1,y1) to (x2,y2) in the specified gc.
1413         The function does not clip the line against the drawing area.
1414
1415     INPUTS
1416         obj   - A bitmap to draw on
1417         gc    - A graphics context object to use
1418         x1,y1 - start point of the line in pixels
1419         x2,y2 - end point of the line in pixels
1420
1421     RESULT
1422         None.
1423
1424     NOTES
1425
1426     EXAMPLE
1427
1428     BUGS
1429
1430     SEE ALSO
1431
1432     INTERNALS
1433         Uses midpoint line ("Bresenham") algorithm([FOL90] 3.2.2)
1434
1435     TODO Support for line pattern
1436          Optimize remove if t == 1 ...
1437          Implement better clipping: Should be no reason to calculate
1438          more than the part of the line that is inside the cliprect
1439
1440 *****************************************************************************************/
1441
1442 VOID BM__Hidd_BitMap__DrawLine
1443 (
1444     OOP_Class *cl, OOP_Object *obj, struct pHidd_BitMap_DrawLine *msg
1445 )
1446 {
1447     WORD        dx, dy, incrE, incrNE, d, x, y, s1, s2, t, i;
1448     WORD        x1, y1, x2, y2;
1449     UWORD       maskLine;  /* for line pattern */
1450     ULONG       fg;   /* foreground pen   */
1451     APTR        doclip;
1452     BOOL        opaque;
1453     OOP_Object  *gc;
1454
1455
1456 /* bug("BitMap::DrawLine()\n");
1457 */    EnterFunc(bug("BitMap::DrawLine() x1: %i, y1: %i x2: %i, y2: %i\n", msg->x1, msg->y1, msg->x2, msg->y2));
1458
1459     gc = msg->gc;
1460     doclip = GC_DOCLIP(gc);
1461     opaque = (GC_COLEXP(gc) & vHidd_GC_ColExp_Opaque) ? TRUE : FALSE;
1462     fg = GC_FG(gc);
1463
1464     maskLine = 1 << GC_LINEPATCNT(gc);
1465
1466     if (doclip)
1467     {
1468         /* If line is not inside cliprect, then just return */
1469         /* Normalize coords */
1470         if (msg->x1 > msg->x2)
1471         {
1472             x1 = msg->x2; x2 = msg->x1;
1473         }
1474         else
1475         {
1476             x1 = msg->x1; x2 = msg->x2;
1477         }
1478
1479         if (msg->y1 > msg->y2)
1480         {
1481             y1 = msg->y2; y2 = msg->y1;
1482         }
1483         else
1484         {
1485             y1 = msg->y1; y2 = msg->y2;
1486         }
1487
1488         if (    x1 > GC_CLIPX2(gc)
1489              || x2 < GC_CLIPX1(gc)
1490              || y1 > GC_CLIPY2(gc)
1491              || y2 < GC_CLIPY1(gc) )
1492         {
1493
1494              /* Line is not inside cliprect, so just return */
1495              return;
1496
1497         }
1498     }
1499
1500     x1 = msg->x1;
1501     y1 = msg->y1;
1502     x2 = msg->x2;
1503     y2 = msg->y2;
1504
1505     if (y1 == y2)
1506     {
1507         /*
1508             Horizontal line drawing code.
1509         */
1510         y = y1;
1511
1512         /* Don't swap coordinates if x2 < x1! Because of linepattern! */
1513
1514         if (x1 < x2)
1515         {
1516             x2++;
1517             dx = 1;
1518         }
1519         else
1520         {
1521             x2--;
1522             dx = -1;
1523         }
1524
1525         for(i = x1; i != x2; i += dx)
1526         {
1527             /* Pixel inside ? */
1528
1529             if (!doclip || !POINT_OUTSIDE_CLIP(gc, i, y ))
1530             {
1531                 if(GC_LINEPAT(gc) & maskLine)
1532                 {
1533                     HIDD_BM_DrawPixel(obj, gc, i, y);
1534                 }
1535                 else if (opaque)
1536                 {
1537                     GC_FG(gc) = GC_BG(gc);
1538                     HIDD_BM_DrawPixel(obj, gc, i, y);
1539                     GC_FG(gc) = fg;
1540                 }
1541             }
1542
1543             maskLine = maskLine >> 1;
1544             if (!maskLine) maskLine = 1L << 15;
1545         }
1546     }
1547     else if (x1 == x2)
1548     {
1549         /*
1550             Vertical line drawing code.
1551         */
1552         x = x1;
1553
1554         /* Don't swap coordinates if y2 < y1! Because of linepattern! */
1555
1556         if (y1 < y2)
1557         {
1558             y2++;
1559             dy = 1;
1560         }
1561         else
1562         {
1563             y2--;
1564             dy = -1;
1565         }
1566
1567         for(i = y1; i != y2; i += dy)
1568         {
1569             /* Pixel inside ? */
1570             if (!doclip || !POINT_OUTSIDE_CLIP(gc, x, i ))
1571             {
1572                 if(GC_LINEPAT(gc) & maskLine)
1573                 {
1574                     HIDD_BM_DrawPixel(obj, gc, x, i);
1575                 }
1576                 else if (opaque)
1577                 {
1578                     GC_FG(gc) = GC_BG(gc);
1579                     HIDD_BM_DrawPixel(obj, gc, x, i);
1580                     GC_FG(gc) = fg;
1581                 }
1582             }
1583
1584             maskLine = maskLine >> 1;
1585             if (!maskLine) maskLine = 1L << 15;
1586
1587         }
1588     }
1589     else
1590     {
1591         /*
1592             Generic line drawing code.
1593         */
1594         /* Calculate slope */
1595         dx = abs(x2 - x1);
1596         dy = abs(y2 - y1);
1597
1598         /* which direction? */
1599         if((x2 - x1) > 0) s1 = 1; else s1 = - 1;
1600         if((y2 - y1) > 0) s2 = 1; else s2 = - 1;
1601
1602         /* change axes if dx < dy */
1603         if(dx < dy)
1604         {
1605             d = dx;
1606             dx = dy;
1607             dy = d;
1608             t = 0;
1609         }
1610         else
1611         {
1612            t = 1;
1613         }
1614
1615         d  = 2 * dy - dx;        /* initial value of d */
1616
1617         incrE  = 2 * dy;         /* Increment use for move to E  */
1618         incrNE = 2 * (dy - dx);  /* Increment use for move to NE */
1619
1620         x = x1; y = y1;
1621
1622         for(i = 0; i <= dx; i++)
1623         {
1624             /* Pixel inside ? */
1625             if (!doclip || !POINT_OUTSIDE_CLIP(gc, x, y ))
1626             {
1627                 if(GC_LINEPAT(gc) & maskLine)
1628                 {
1629                     HIDD_BM_DrawPixel(obj, gc, x, y);
1630                 }
1631                 else if (opaque)
1632                 {
1633                     GC_FG(gc) = GC_BG(gc);
1634                     HIDD_BM_DrawPixel(obj, gc, x, y);
1635                     GC_FG(gc) = fg;
1636                 }
1637             }
1638
1639             if(d <= 0)
1640             {
1641                 if(t == 1)
1642                 {
1643                     x = x + s1;
1644                 }
1645                 else
1646                 {
1647                     y = y + s2;
1648                 }
1649
1650                 d = d + incrE;
1651             }
1652             else
1653             {
1654                 x = x + s1;
1655                 y = y + s2;
1656                 d = d + incrNE;
1657             }
1658
1659             maskLine = maskLine >> 1;
1660             if (!maskLine) maskLine = 1L << 15;
1661
1662         }
1663     }
1664
1665     ReturnVoid("BitMap::DrawLine ");
1666 }
1667
1668 /*****************************************************************************************
1669
1670     NAME
1671         moHidd_BitMap_DrawRect
1672
1673     SYNOPSIS
1674         OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawRect *msg);
1675
1676         VOID HIDD_BM_DrawRect (OOP_Object *obj, OOP_Object *gc, WORD minX, WORD minY,
1677                           WORD maxX, WORD maxY);
1678
1679     LOCATION
1680         hidd.graphics.bitmap
1681
1682     FUNCTION
1683         Draws a hollow rectangle. minX and minY specifies the upper
1684         left corner of the rectangle. minY and maxY specifies the lower
1685         right corner of the rectangle.
1686         The function does not clip the rectangle against the drawing area.
1687
1688     INPUTS
1689         obj        - A bitmap to draw on
1690         gc         - A GC object to use for drawing
1691         minX, minY - upper left corner of the rectangle in pixels
1692         maxX, maxY - lower right corner of the rectangle in pixels
1693
1694     RESULT
1695         None.
1696
1697     NOTES
1698         This method is not used by the system and considered reserved.
1699
1700     EXAMPLE
1701
1702     BUGS
1703
1704     SEE ALSO
1705
1706     INTERNALS
1707
1708     TODO
1709
1710 *****************************************************************************************/
1711
1712 VOID BM__Hidd_BitMap__DrawRect(OOP_Class *cl, OOP_Object *obj,
1713                                struct pHidd_BitMap_DrawRect *msg)
1714 {
1715 #ifdef __RESERVED__
1716     OOP_Object *gc = msg->gc;
1717     WORD        addX, addY;
1718
1719     EnterFunc(bug("BitMap::DrawRect()"));
1720
1721     if(msg->minX == msg->maxX) addX = 0; else addX = 1;
1722     if(msg->minY == msg->maxY) addY = 0; else addY = 1;
1723
1724     HIDD_BM_DrawLine(obj, gc, msg->minX, msg->minY       , msg->maxX, msg->minY);
1725     HIDD_BM_DrawLine(obj, gc, msg->maxX, msg->minY + addY, msg->maxX, msg->maxY);
1726     HIDD_BM_DrawLine(obj, gc, msg->maxX - addX, msg->maxY, msg->minX, msg->maxY);
1727     HIDD_BM_DrawLine(obj, gc, msg->minX, msg->maxY - addY, msg->minX, msg->minY + addY);
1728 #endif
1729
1730     ReturnVoid("BitMap::DrawRect");
1731 }
1732
1733 /*****************************************************************************************
1734
1735     NAME
1736         moHidd_BitMap_FillRect
1737
1738     SYNOPSIS
1739         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawRect *msg);
1740
1741         VOID HIDD_BM_FillRect (OOP_Object *obj, OOP_Object *gc, WORD minX, WORD minY,
1742                                WORD maxX, WORD maxY);
1743
1744     LOCATION
1745         hidd.graphics.bitmap
1746
1747     FUNCTION
1748
1749         Draws a solid rectangle. minX and minY specifies the upper
1750         left corner of the rectangle. minY and maxY specifies the lower
1751         right corner of the rectangle.
1752         The function does not clip the rectangle against the drawing area.
1753
1754     INPUTS
1755         obj        - A bitmap to draw on
1756         gc         - A GC object to use for drawing
1757         minX, minY - upper left corner of the rectangle in pixels
1758         maxX, maxY - lower right corner of the rectangle in pixels
1759
1760     RESULT
1761         None.
1762
1763     NOTES
1764
1765     EXAMPLE
1766
1767     BUGS
1768
1769     SEE ALSO
1770
1771     INTERNALS
1772
1773     TODO
1774         Fill with pattern
1775
1776 *****************************************************************************************/
1777
1778 VOID BM__Hidd_BitMap__FillRect(OOP_Class *cl, OOP_Object *obj,
1779                                struct pHidd_BitMap_DrawRect *msg)
1780 {
1781     OOP_Object *gc = msg->gc;
1782     WORD        y = msg->minY;
1783     UWORD       linepat;
1784
1785     EnterFunc(bug("BitMap::FillRect()"));
1786
1787     linepat = GC_LINEPAT(gc);
1788     GC_LINEPAT(gc) = ~0;
1789
1790     for(; y <= msg->maxY; y++)
1791     {
1792         HIDD_BM_DrawLine(obj, gc, msg->minX, y, msg->maxX, y);
1793     }
1794
1795     GC_LINEPAT(gc) = linepat;
1796
1797     ReturnVoid("BitMap::FillRect");
1798 }
1799
1800 /*****************************************************************************************
1801
1802     NAME
1803         moHidd_BitMap_DrawEllipse
1804
1805     SYNOPSIS
1806         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawEllipse *msg);
1807
1808         VOID HIDD_BM_DrawEllipse (OOP_Object *obj, OOP_Object *gc, WORD x, WORD y,
1809                                   WORD rx, WORD ry);
1810
1811     LOCATION
1812         hidd.graphics.bitmap
1813
1814     FUNCTION
1815         Draws a hollow ellipse from the center point (x,y) with the radii
1816         rx and ry in the specified bitmap.
1817         The function does not clip the ellipse against the drawing area.
1818
1819     INPUTS
1820         obj   - A bitmap to draw on
1821         gc    - A GC object to use for drawing
1822         x,y   - Coordinates of center point in pixels
1823         rx,ry - ry and ry radius in pixels
1824
1825     RESULT
1826         None.
1827
1828     NOTES
1829
1830     EXAMPLE
1831
1832     BUGS
1833         Because of overflow the current code do not work with big
1834         values of rx and ry.
1835
1836     SEE ALSO
1837
1838     INTERNALS
1839
1840     TODO
1841         Bugfix
1842
1843 *****************************************************************************************/
1844
1845 /* TODO: Try to opimize clipping here */
1846
1847 VOID BM__Hidd_BitMap__DrawEllipse(OOP_Class *cl, OOP_Object *obj,
1848                                   struct pHidd_BitMap_DrawEllipse *msg)
1849 {
1850     OOP_Object *gc = msg->gc;
1851     WORD        x = msg->rx, y = 0;     /* ellipse points */
1852
1853     /* intermediate terms to speed up loop */
1854     WORD        t1 = msg->rx * msg->rx, t2 = t1 << 1, t3 = t2 << 1;
1855     WORD        t4 = msg->ry * msg->ry, t5 = t4 << 1, t6 = t5 << 1;
1856     WORD        t7 = msg->rx * t5, t8 = t7 << 1, t9 = 0L;
1857     WORD        d1 = t2 - t7 + (t4 >> 1);    /* error terms */
1858     WORD        d2 = (t1 >> 1) - t8 + t5;
1859
1860     APTR        doclip = GC_DOCLIP(gc);
1861
1862
1863     EnterFunc(bug("BitMap::DrawEllipse()"));
1864
1865     while (d2 < 0)                  /* til slope = -1 */
1866     {
1867         /* draw 4 points using symmetry */
1868
1869         if  (doclip)
1870         {
1871
1872             if (!POINT_OUTSIDE_CLIP(gc, msg->x + x, msg->y + y))
1873                 HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y + y);
1874
1875             if (!POINT_OUTSIDE_CLIP(gc, msg->x + x, msg->y - y))
1876                 HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y - y);
1877
1878             if (!POINT_OUTSIDE_CLIP(gc, msg->x - x, msg->y + y))
1879                 HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y + y);
1880
1881             if (!POINT_OUTSIDE_CLIP(gc, msg->x - x, msg->y - y))
1882                 HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y - y);
1883
1884         }
1885         else
1886         {
1887             HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y + y);
1888             HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y - y);
1889             HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y + y);
1890             HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y - y);
1891         }
1892
1893         y++;            /* always move up here */
1894         t9 = t9 + t3;
1895         if (d1 < 0)     /* move straight up */
1896         {
1897             d1 = d1 + t9 + t2;
1898             d2 = d2 + t9;
1899         }
1900         else            /* move up and left */
1901         {
1902             x--;
1903             t8 = t8 - t6;
1904             d1 = d1 + t9 + t2 - t8;
1905             d2 = d2 + t9 + t5 - t8;
1906         }
1907     }
1908
1909     do                              /* rest of top right quadrant */
1910     {
1911         /* draw 4 points using symmetry */
1912     #if 1
1913         if  (doclip)
1914         {
1915
1916             if (!POINT_OUTSIDE_CLIP(gc, msg->x + x, msg->y + y))
1917                 HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y + y);
1918
1919             if (!POINT_OUTSIDE_CLIP(gc, msg->x + x, msg->y - y))
1920                 HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y - y);
1921
1922             if (!POINT_OUTSIDE_CLIP(gc, msg->x - x, msg->y + y))
1923                 HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y + y);
1924
1925             if (!POINT_OUTSIDE_CLIP(gc, msg->x - x, msg->y - y))
1926                 HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y - y);
1927
1928         }
1929         else
1930         {
1931
1932             HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y + y);
1933             HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y - y);
1934             HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y + y);
1935             HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y - y);
1936         }
1937     #else
1938
1939         HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y + y);
1940         HIDD_BM_DrawPixel(obj, gc, msg->x + x, msg->y - y);
1941         HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y + y);
1942         HIDD_BM_DrawPixel(obj, gc, msg->x - x, msg->y - y);
1943     #endif
1944         x--;            /* always move left here */
1945         t8 = t8 - t6;
1946         if (d2 < 0)     /* move up and left */
1947         {
1948             y++;
1949             t9 = t9 + t3;
1950             d2 = d2 + t9 + t5 - t8;
1951         }
1952         else            /* move straight left */
1953         {
1954             d2 = d2 + t5 - t8;
1955         }
1956
1957     } while (x >= 0);
1958
1959
1960     ReturnVoid("BitMap::DrawEllipse");
1961 }
1962
1963 /*****************************************************************************************
1964
1965     NAME
1966         moHidd_BitMap_FillEllipse
1967
1968     SYNOPSIS
1969         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawEllipse *msg);
1970
1971         VOID HIDD_BM_FillEllipse (OOP_Object *obj, OOP_Object *gc, WORD x, WORD y,
1972                                   WORD ry, WORD rx);
1973
1974     LOCATION
1975         hidd.graphics.bitmap
1976
1977     FUNCTION
1978         Draws a solid ellipse from the center point (x,y) with the radii
1979         rx and ry in the specified bitmap.
1980         The function does not clip the ellipse against the drawing area.
1981
1982     INPUTS
1983         obj   - A bitmap to draw on
1984         gc    - A GC object to use for drawing
1985         x,y   - Coordinates of center point in pixels
1986         rx,ry - ry and ry radius in pixels
1987
1988     RESULT
1989         None.
1990
1991     NOTES
1992         This method is not used by the system and considered reserved.
1993
1994     EXAMPLE
1995
1996         Because of overflow the current code do not work with big
1997         values of rx and ry.
1998
1999     SEE ALSO
2000
2001     INTERNALS
2002
2003     TODO
2004         Bugfix
2005
2006 *****************************************************************************************/
2007
2008 VOID BM__Hidd_BitMap__FillEllipse(OOP_Class *cl, OOP_Object *obj,
2009                                   struct pHidd_BitMap_DrawEllipse *msg)
2010 {
2011 #ifdef __RESERVED__
2012     OOP_Object *gc = msg->gc;
2013     WORD        x = msg->rx, y = 0;     /* ellipse points */
2014
2015     /* intermediate terms to speed up loop */
2016     WORD        t1 = msg->rx * msg->rx, t2 = t1 << 1, t3 = t2 << 1;
2017     WORD        t4 = msg->ry * msg->ry, t5 = t4 << 1, t6 = t5 << 1;
2018     WORD        t7 = msg->rx * t5, t8 = t7 << 1, t9 = 0L;
2019     WORD        d1 = t2 - t7 + (t4 >> 1);    /* error terms */
2020     WORD        d2 = (t1 >> 1) - t8 + t5;
2021
2022     EnterFunc(bug("BitMap::FillEllipse()"));
2023
2024     while (d2 < 0)                  /* til slope = -1 */
2025     {
2026         /* draw 4 points using symmetry */
2027         HIDD_BM_DrawLine(obj, gc, msg->x - x, msg->y + y, msg->x + x, msg->y + y);
2028         HIDD_BM_DrawLine(obj, gc, msg->x - x, msg->y - y, msg->x + x, msg->y - y);
2029
2030         y++;            /* always move up here */
2031         t9 = t9 + t3;
2032         if (d1 < 0)     /* move straight up */
2033         {
2034             d1 = d1 + t9 + t2;
2035             d2 = d2 + t9;
2036         }
2037         else            /* move up and left */
2038         {
2039             x--;
2040             t8 = t8 - t6;
2041             d1 = d1 + t9 + t2 - t8;
2042             d2 = d2 + t9 + t5 - t8;
2043         }
2044     }
2045
2046     do                              /* rest of top right quadrant */
2047     {
2048         /* draw 4 points using symmetry */
2049         HIDD_BM_DrawLine(obj, gc, msg->x - x, msg->y + y, msg->x + x, msg->y + y);
2050         HIDD_BM_DrawLine(obj, gc, msg->x - x, msg->y - y, msg->x + x, msg->y - y);
2051
2052         x--;            /* always move left here */
2053         t8 = t8 - t6;
2054         if (d2 < 0)     /* move up and left */
2055         {
2056             y++;
2057             t9 = t9 + t3;
2058             d2 = d2 + t9 + t5 - t8;
2059         }
2060         else            /* move straight left */
2061         {
2062             d2 = d2 + t5 - t8;
2063         }
2064
2065     } while (x >= 0);
2066 #endif
2067
2068     ReturnVoid("BitMap::FillEllipse");
2069 }
2070
2071 /*****************************************************************************************
2072
2073     NAME
2074         moHidd_BitMap_DrawPolygon
2075
2076     SYNOPSIS
2077         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawPolygon *msg);
2078
2079         VOID HIDD_BM_DrawPolygon (OOP_Object *obj, OOP_Object *gc, UWORD n, WORD *coords);
2080
2081     LOCATION
2082         hidd.graphics.bitmap
2083
2084     FUNCTION
2085         Draws a hollow polygon from the list of coordinates in coords[].
2086         The function does not clip the polygon against the drawing area.
2087
2088     INPUTS
2089         obj    - A bitmap to draw on
2090         gc     - A GC object to use for drawing
2091         n      - number of coordinate pairs
2092         coords - array of n (x, y) coordinates in pixels
2093
2094     RESULT
2095         None.
2096
2097     NOTES
2098         This method is not used by the system and considered reserved.
2099
2100     EXAMPLE
2101
2102     BUGS
2103
2104     SEE ALSO
2105
2106     INTERNALS
2107
2108     TODO
2109
2110 *****************************************************************************************/
2111
2112 VOID BM__Hidd_BitMap__DrawPolygon(OOP_Class *cl, OOP_Object *obj,
2113                                   struct pHidd_BitMap_DrawPolygon *msg)
2114 {
2115 #ifdef __RESERVED__
2116     OOP_Object *gc = msg->gc;
2117     WORD        i;
2118
2119     EnterFunc(bug("BitMap::DrawPolygon()"));
2120
2121     for(i = 2; i < (2 * msg->n); i = i + 2)
2122     {
2123         HIDD_BM_DrawLine(obj, gc, msg->coords[i - 2], msg->coords[i - 1],
2124                               msg->coords[i], msg->coords[i + 1]);
2125     }
2126 #endif
2127
2128     ReturnVoid("BitMap::DrawPolygon");
2129 }
2130
2131 /*****************************************************************************************
2132
2133     NAME
2134         moHidd_BitMap_FillPolygon
2135
2136     SYNOPSIS
2137         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawPolygon *msg);
2138
2139         VOID HIDD_BM_FillPolygon (OOP_Object *obj, OOP_Object *gc, UWORD n, WORD *coords);
2140
2141     LOCATION
2142         hidd.graphics.bitmap
2143
2144     FUNCTION
2145         This method was initially designed for drawing solid polygons, however it was never
2146         used and implemented. At the moment it is considered reserved, its synopsis and
2147         semantics may change in future.
2148
2149     INPUTS
2150         obj    - A bitmap to draw on
2151         gc     - A GC object to use for drawing
2152         n      - number of coordinate pairs
2153         coords - array of n (x, y) coordinates in pixels
2154
2155     RESULT
2156         None
2157
2158     NOTES
2159
2160     EXAMPLE
2161
2162     BUGS
2163         Never used and implemented
2164
2165     SEE ALSO
2166
2167     INTERNALS
2168
2169     TODO
2170
2171 *****************************************************************************************/
2172
2173 VOID BM__Hidd_BitMap__FillPolygon(OOP_Class *cl, OOP_Object *obj, struct pHidd_BitMap_DrawPolygon *msg)
2174 {
2175     D(bug("Sorry, FillPolygon() not implemented yet in bitmap baseclass\n"));
2176 }
2177
2178 /*****************************************************************************************
2179
2180     NAME
2181         moHidd_BitMap_DrawText
2182
2183     SYNOPSIS
2184         OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawText *msg);
2185
2186         VOID HIDD_BM_DrawText (OOP_Object *obj, OOP_Object *gc, WORD x, WORD y,
2187                                STRPTR text, UWORD length);
2188
2189     LOCATION
2190         hidd.graphics.bitmap
2191
2192     FUNCTION
2193         Draws the first length characters of text at (x, y).
2194         The function does not clip the text against the drawing area.
2195
2196     INPUTS
2197         obj    - A bitmap to draw on
2198         gc     - A GC object to use for drawing and font specification
2199         x, y   - Position to start drawing in pixels. The x
2200                  coordinate is relativ to the left side of the
2201                  first character.
2202                  The y coordinate is relative to the baseline of the font.
2203         text   - Pointer to a Latin 1 string
2204         length - Number of characters to draw
2205
2206     RESULT
2207         None.
2208
2209     NOTES
2210         At the moment text drawing is processed entirely by graphics.library
2211         using BltTemplate(), which in turn uses moHodd_BitMap_PutTemplate.
2212         This method is considered obsolete.
2213
2214     EXAMPLE
2215
2216     BUGS
2217         The default implementation in the base class does not process styles,
2218         color and alpha-blended fonts.
2219
2220     SEE ALSO
2221
2222     INTERNALS
2223
2224     TODO
2225
2226 *****************************************************************************************/
2227
2228 VOID BM__Hidd_BitMap__DrawText(OOP_Class *cl, OOP_Object *obj,
2229                                struct pHidd_BitMap_DrawText *msg)
2230 {
2231 #ifdef __RESERVED__
2232     OOP_Object      *gc = msg->gc;
2233     struct TextFont *font  = GC_FONT(gc);
2234     UBYTE           *charPatternPtr = font->tf_CharData;
2235     UWORD           modulo          = font->tf_Modulo;
2236     ULONG           charLog;
2237     UBYTE           ch;              /* current character to print               */
2238     WORD            fx, fx2, fy, fw; /* position and length of character in the  */
2239                             /* character bitmap                         */
2240     WORD            xMem = msg->x;   /* position in bitmap                       */
2241     WORD            yMem = msg->y - font->tf_Baseline;
2242     WORD            x, y, i;
2243
2244
2245     EnterFunc(bug("BitMap::DrawText()"));
2246
2247     for(i = 0; i < msg->length; i++)
2248     {
2249         ch = msg->text[i];
2250
2251         if((ch < font->tf_LoChar) || (ch > font->tf_HiChar))
2252         {
2253             ch = font->tf_HiChar - font->tf_LoChar + 1;
2254         }
2255         else
2256         {
2257             ch = ch - font->tf_LoChar;
2258         }
2259
2260         if(font->tf_Flags & FPF_PROPORTIONAL)
2261         {
2262             xMem = xMem + ((UWORD *) font->tf_CharKern)[ch];
2263         }
2264
2265         charLog = ((ULONG *) font->tf_CharLoc)[ch];
2266         fx2 = charLog >> 16;   /* x position of character pattern in character bitmap */
2267         fw  = (UWORD) charLog; /* width of character pattern in character bitmap */
2268
2269         y = yMem;
2270
2271         for(fy = 0; fy < font->tf_YSize; fy ++)
2272         {
2273             x = xMem;
2274
2275             for(fx = fx2; fx < fw + fx2; fx++)
2276             {
2277                 if(*(charPatternPtr + fx / 8 + fy * modulo) & (128 >> (fx % 8)))
2278                 {
2279                     HIDD_BM_DrawPixel(obj, msg->gc, x, y);
2280                 }
2281                 x++;
2282             }
2283
2284             y++;
2285         }
2286
2287         if(font->tf_Flags & FPF_PROPORTIONAL)
2288         {
2289             xMem = xMem + ((UWORD *) font->tf_CharSpace)[ch];
2290         }
2291         else
2292         {
2293             xMem = xMem + font->tf_XSize;
2294         }
2295     }
2296 #endif
2297     ReturnVoid("BitMap::DrawText");
2298 }
2299
2300 /*****************************************************************************************
2301
2302     NAME
2303         moHidd_BitMap_FillText
2304
2305     SYNOPSIS
2306         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawText *msg);
2307
2308         VOID HIDD_BM_FillText (OOP_Object *obj, OOP_Object *gc, WORD x, WORD y,
2309                                STRPTR text, UWORD length);
2310
2311     LOCATION
2312         hidd.graphics.bitmap
2313
2314     FUNCTION
2315         Historically this method was designed to draw a text with background.
2316         It was never implemented.
2317
2318         Currently this method is considered reserved. Its synopsis and semantics
2319         may change in future.
2320
2321     INPUTS
2322         obj    - A bitmap to draw on
2323         gc     - A GC object to use for drawing
2324         x, y   - Position to start drawing in pixels. The x
2325                  coordinate is relative to the left side of the
2326                  first character.
2327                  The y coordinate is relative to the baseline of the font.
2328         text   - Pointer to a Latin 1 string
2329         length - Number of characters to draw
2330
2331     RESULT
2332
2333     NOTES
2334
2335     EXAMPLE
2336
2337     BUGS
2338
2339     SEE ALSO
2340
2341     INTERNALS
2342
2343     TODO
2344
2345 *****************************************************************************************/
2346
2347 VOID BM__Hidd_BitMap__FillText(OOP_Class *cl, OOP_Object *obj, struct pHidd_BitMap_DrawText *msg)
2348 {
2349     D(bug("Sorry, FillText() not implemented yet in bitmap baseclass\n"));
2350 }
2351
2352 /*****************************************************************************************
2353
2354     NAME
2355         moHidd_BitMap_FillSpan
2356
2357     SYNOPSIS
2358         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_DrawText *msg);
2359
2360     LOCATION
2361         hidd.graphics.bitmap
2362
2363     FUNCTION
2364         Reserved, never implemented method. The definition will change in future.
2365
2366     INPUTS
2367
2368     RESULT
2369         None.
2370
2371     NOTES
2372
2373     EXAMPLE
2374
2375     BUGS
2376
2377     SEE ALSO
2378
2379     INTERNALS
2380
2381     TODO
2382
2383 *****************************************************************************************/
2384
2385 VOID BM__Hidd_BitMap__FillSpan(OOP_Class *cl, OOP_Object *obj, struct pHidd_BitMap_DrawText *msg)
2386 {
2387     D(bug("Sorry, FillSpan() not implemented yet\n"));
2388 }
2389
2390 /*****************************************************************************************
2391
2392     NAME
2393         moHidd_BitMap_Clear
2394
2395     SYNOPSIS
2396         OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_Clear *msg);
2397
2398         VOID HIDD_BM_Clear (OOP_Object *obj, OOP_Object *gc);
2399
2400     LOCATION
2401         hidd.graphics.bitmap
2402
2403     FUNCTION
2404         Sets all pixels of the drawing area to the background color.
2405
2406     INPUTS
2407         obj - A bitmap to clear.
2408         gc  - A GC object, specifies background color value
2409
2410     RESULT
2411
2412     NOTES
2413         This method is not used by the system and considered reserved. However it can
2414         be useful for display driver's own needs.
2415
2416     EXAMPLE
2417
2418     BUGS
2419         Default implementation in the base class sets all pixels to zero color instead of
2420         the background color from GC
2421
2422     SEE ALSO
2423
2424     INTERNALS
2425
2426     TODO
2427
2428 *****************************************************************************************/
2429
2430 VOID BM__Hidd_BitMap__Clear(OOP_Class *cl, OOP_Object *obj, struct pHidd_BitMap_Clear *msg)
2431 {
2432     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
2433     WORD  x, y;
2434     IPTR width, height;
2435
2436     EnterFunc(bug("BitMap::Clear()\n"));
2437
2438     OOP_GetAttr(obj, aHidd_BitMap_Width, &width);
2439     OOP_GetAttr(obj, aHidd_BitMap_Height, &height);
2440
2441     for(y = 0; y < height; y++)
2442     {
2443         for(x = 0; x < width; x++)
2444         {
2445             HIDD_BM_PutPixel(obj, x, y, 0);
2446         }
2447     }
2448
2449     ReturnVoid("BitMap::Clear");
2450 }
2451
2452 /****************************************************************************************/
2453
2454 static LONG inline getpixfmtbpp(OOP_Class *cl, OOP_Object *o, HIDDT_StdPixFmt stdpf)
2455 {
2456     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
2457     OOP_Object *pf;
2458     struct HIDDBitMapData *data;
2459     SIPTR bpp = -1;
2460
2461     data = OOP_INST_DATA(cl, o);
2462
2463     switch (stdpf)
2464     {
2465         case vHidd_StdPixFmt_Native:
2466             OOP_GetAttr(data->prot.pixfmt, aHidd_PixFmt_BytesPerPixel, &bpp);
2467             break;
2468
2469         case vHidd_StdPixFmt_Native32:
2470             bpp = sizeof (HIDDT_Pixel);
2471             break;
2472
2473         default:
2474             pf = HIDD_Gfx_GetPixFmt(data->gfxhidd, stdpf);
2475
2476             if (NULL == pf)
2477             {
2478                 D(bug("!!! INVALID PIXFMT IN BitMap::PutImage(): %d !!!\n", stdpf));
2479             }
2480             else
2481             {
2482                 OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &bpp);
2483             }
2484             break;
2485     }
2486
2487     return bpp;
2488 }
2489
2490 /*****************************************************************************************
2491
2492     NAME
2493         moHidd_BitMap_GetImage
2494
2495     SYNOPSIS
2496         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_GetImage *msg);
2497
2498         VOID HIDD_BM_GetImage (OOP_Object *obj, UBYTE *pixels, ULONG modulo, WORD x, WORD y,
2499                                WORD width, WORD height, HIDDT_StdPixFmt pixFmt);
2500
2501     LOCATION
2502         hidd.graphics.bitmap
2503
2504     FUNCTION
2505
2506     INPUTS
2507         obj    -
2508         pixels -
2509         modulo -
2510         x, y   -
2511         width  -
2512         height -
2513         pixFmt -
2514
2515     RESULT
2516
2517     NOTES
2518
2519     EXAMPLE
2520
2521     BUGS
2522
2523     SEE ALSO
2524
2525     INTERNALS
2526
2527 *****************************************************************************************/
2528
2529 VOID BM__Hidd_BitMap__GetImage(OOP_Class *cl, OOP_Object *o,
2530                                struct pHidd_BitMap_GetImage *msg)
2531 {
2532     WORD                    x, y;
2533     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
2534     APTR                    ppixarray = &pixarray;
2535     WORD                    bpp;
2536     struct HIDDBitMapData   *data;
2537
2538     data = OOP_INST_DATA(cl, o);
2539
2540     EnterFunc(bug("BitMap::GetImage(x=%d, y=%d, width=%d, height=%d)\n"
2541                 , msg->x, msg->y, msg->width, msg->height));
2542
2543
2544     bpp = getpixfmtbpp(cl, o, msg->pixFmt);
2545     if (-1 == bpp)
2546     {
2547         D(bug("!!! INVALID PIXFMT IN BitMap::GetImage(): %d !!!\n", msg->pixFmt));
2548         return;
2549     }
2550
2551
2552     switch(msg->pixFmt)
2553     {
2554         case vHidd_StdPixFmt_Native:
2555         case vHidd_StdPixFmt_Native32:
2556             for (y = 0; y < msg->height; y ++)
2557             {
2558                 for (x = 0; x < msg->width; x ++)
2559                 {
2560                     register HIDDT_Pixel pix;
2561
2562                     pix = HIDD_BM_GetPixel(o, x + msg->x , y + msg->y);
2563
2564                     switch (bpp)
2565                     {
2566                         case 1:
2567                             *pixarray++ = pix;
2568                             break;
2569
2570                         case 2:
2571                             *((UWORD *)pixarray) = pix;
2572                             pixarray += 2;
2573                             break;
2574
2575                         case 3:
2576                         #if AROS_BIG_ENDIAN
2577                             pixarray[0] = (pix >> 16) & 0xFF;
2578                             pixarray[1] = (pix >> 8) & 0xFF;
2579                             pixarray[2] =  pix & 0xFF;
2580                         #else
2581                             pixarray[0] =  pix & 0xFF;
2582                             pixarray[1] = (pix >> 8) & 0xFF;
2583                             pixarray[2] = (pix >> 16) & 0xFF;
2584                         #endif
2585                             pixarray += 3;
2586                             break;
2587
2588                         case 4:
2589                             *(ULONG *)pixarray = pix;
2590                             pixarray += 4;
2591                             break;
2592                     }
2593
2594                 }
2595
2596                 pixarray += (msg->modulo - msg->width * bpp);
2597             }
2598
2599             break;
2600
2601         default:
2602             {
2603                 OOP_Object *dstpf;
2604                 APTR        buf, srcPixels;
2605
2606                 dstpf = HIDD_Gfx_GetPixFmt(data->gfxhidd, msg->pixFmt);
2607
2608                 buf = srcPixels = AllocVec(msg->width * sizeof(HIDDT_Pixel), MEMF_PUBLIC);
2609                 if (buf)
2610                 {
2611                     for(y = 0; y < msg->height; y++)
2612                     {
2613                         HIDD_BM_GetImage(o,
2614                                          buf,
2615                                          0,
2616                                          msg->x,
2617                                          msg->y + y,
2618                                          msg->width,
2619                                          1,
2620                                          vHidd_StdPixFmt_Native);
2621
2622                         HIDD_BM_ConvertPixels(o,
2623                                               &srcPixels,
2624                                               (HIDDT_PixelFormat *)data->prot.pixfmt,
2625                                               0,
2626                                               (APTR *)ppixarray,
2627                                               (HIDDT_PixelFormat *)dstpf,
2628                                               msg->modulo,
2629                                               msg->width,
2630                                               1,
2631                                               NULL);
2632
2633                     }
2634                     FreeVec(buf);
2635                 }
2636             }
2637             break;
2638
2639     } /* switch(msg->pixFmt) */
2640
2641     ReturnVoid("BitMap::GetImage");
2642 }
2643
2644 /*****************************************************************************************
2645
2646     NAME
2647         moHidd_BitMap_PutImage
2648
2649     SYNOPSIS
2650         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_PutImage *msg);
2651
2652         VOID HIDD_BM_PutImage (OOP_Object *obj, OOP_Object *gc, UBYTE *pixels, ULONG modulo,
2653                                WORD x, WORD y, WORD width, WORD height, HIDDT_StdPixFmt pixFmt);
2654
2655     LOCATION
2656         hidd.graphics.bitmap
2657
2658     FUNCTION
2659
2660     INPUTS
2661         obj    -
2662         gc     -
2663         pixels -
2664         modulo -
2665         x, y   -
2666         width  -
2667         height -
2668         pixFmt -
2669
2670     RESULT
2671
2672     NOTES
2673
2674     EXAMPLE
2675
2676     BUGS
2677
2678     SEE ALSO
2679
2680     INTERNALS
2681
2682 *****************************************************************************************/
2683
2684 VOID BM__Hidd_BitMap__PutImage(OOP_Class *cl, OOP_Object *o,
2685                                struct pHidd_BitMap_PutImage *msg)
2686 {
2687     WORD                    x, y;
2688     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
2689     APTR                    ppixarray = &pixarray;
2690     ULONG                   old_fg;
2691     WORD                    bpp;
2692     struct HIDDBitMapData   *data;
2693     OOP_Object              *gc = msg->gc;
2694
2695     data = OOP_INST_DATA(cl, o);
2696
2697     EnterFunc(bug("BitMap::PutImage(x=%d, y=%d, width=%d, height=%d)\n"
2698                 , msg->x, msg->y, msg->width, msg->height));
2699
2700     if (msg->width <= 0 || msg->height <= 0)
2701         return;
2702
2703     bpp = getpixfmtbpp(cl, o, msg->pixFmt);
2704     if (-1 == bpp)
2705     {
2706         D(bug("!!! INVALID PIXFMT IN BitMap::PutImage(): %d !!!\n", msg->pixFmt));
2707         return;
2708     }
2709
2710     switch(msg->pixFmt)
2711     {
2712         case vHidd_StdPixFmt_Native:
2713         case vHidd_StdPixFmt_Native32:
2714
2715             /* Preserve old fg pen */
2716             old_fg = GC_FG(gc);
2717
2718             for (y = 0; y < msg->height; y ++)
2719             {
2720                 for (x = 0; x < msg->width; x ++)
2721                 {
2722                     register HIDDT_Pixel pix = 0;
2723
2724                     switch (bpp)
2725                     {
2726                         case 1:
2727                             pix = *((UBYTE *)pixarray);
2728                             pixarray ++;
2729                             break;
2730
2731                         case 2:
2732                             pix = *((UWORD *)pixarray);
2733                             pixarray += 2;
2734                             break;
2735
2736                         case 3:
2737                         #if AROS_BIG_ENDIAN
2738                             pix = ((UBYTE *)pixarray)[0] << 16;
2739                             pix |= ((UBYTE *)pixarray)[1] << 8;
2740                             pix |= ((UBYTE *)pixarray)[2];
2741                         #else
2742                             pix = ((UBYTE *)pixarray)[2] << 16;
2743                             pix |= ((UBYTE *)pixarray)[1] << 8;
2744                             pix |= ((UBYTE *)pixarray)[0];
2745                         #endif
2746                             pixarray += 3;
2747                             break;
2748
2749                         case 4:
2750                             pix = *((ULONG *)pixarray); pixarray += 4;
2751                             break;
2752
2753                     }
2754
2755                     GC_FG(gc) = pix;
2756
2757                     HIDD_BM_DrawPixel(o, gc, x + msg->x , y + msg->y);
2758                 }
2759                 pixarray += (msg->modulo - msg->width * bpp);
2760             }
2761
2762             GC_FG(gc) = old_fg;
2763             break;
2764
2765         default:
2766             {
2767                 OOP_Object *srcpf;
2768                 APTR        buf, destPixels;
2769
2770                 srcpf = HIDD_Gfx_GetPixFmt(data->gfxhidd, msg->pixFmt);
2771
2772                 buf = destPixels = AllocVec(msg->width * sizeof(HIDDT_Pixel), MEMF_PUBLIC);
2773                 if (buf)
2774                 {
2775                     for(y = 0; y < msg->height; y++)
2776                     {
2777                         HIDD_BM_ConvertPixels(o,
2778                                               (APTR *)ppixarray,
2779                                               (HIDDT_PixelFormat *)srcpf,
2780                                               msg->modulo,
2781                                               &destPixels,
2782                                               (HIDDT_PixelFormat *)data->prot.pixfmt,
2783                                               0,
2784                                               msg->width,
2785                                               1,
2786                                               NULL);
2787
2788                         HIDD_BM_PutImage(o,
2789                                          msg->gc,
2790                                          buf,
2791                                          0,
2792                                          msg->x,
2793                                          msg->y + y,
2794                                          msg->width,
2795                                          1,
2796                                          vHidd_StdPixFmt_Native);
2797                     }
2798                     FreeVec(buf);
2799                 }
2800             }
2801             break;
2802
2803     } /* switch(msg->pixFmt) */
2804
2805     ReturnVoid("BitMap::PutImage");
2806 }
2807
2808 /****************************************************************************************/
2809
2810 int static inline
2811 __attribute__((always_inline, const)) do_alpha(int a, int v)
2812 {
2813     int tmp  = (a*v);
2814     return ((tmp<<8) + tmp + 32768)>>16;
2815 }
2816
2817 #if AROS_BIG_ENDIAN
2818
2819 #define RGB32_DECOMPOSE(red, green, blue, pix) \
2820     red   = ((pix) & 0x00FF0000) >> 16;        \
2821     green = ((pix) & 0x0000FF00) >> 8;         \
2822     blue  = ((pix) & 0x000000FF);
2823
2824 #define ARGB32_ALPHA(pix) ((pix) & 0xFF000000)
2825
2826 #define ARGB32_DECOMPOSE(alpha, red, green, blue, pix) \
2827     alpha = ((pix) & 0xFF000000) >> 24;                \
2828     red   = ((pix) & 0x00FF0000) >> 16;                \
2829     green = ((pix) & 0x0000FF00) >> 8;                 \
2830     blue  = ((pix) & 0x000000FF);
2831
2832 #define ARGB32_COMPOSE(red, green, blue, old) (((old) & 0xFF000000) + ((red) << 16) + ((green) << 8) + (blue))
2833
2834 #else
2835
2836 #define RGB32_DECOMPOSE(red, green, blue, pix) \
2837     red   = (pix & 0x0000FF00) >> 8;           \
2838     green = (pix & 0x00FF0000) >> 16;          \
2839     blue  = (pix & 0xFF000000) >> 24
2840
2841 #define ARGB32_ALPHA(pix) ((pix) & 0x000000FF)
2842
2843 #define ARGB32_DECOMPOSE(alpha, red, green, blue, pix) \
2844     alpha = (pix & 0x000000FF);                        \
2845     red   = (pix & 0x0000FF00) >> 8;                   \
2846     green = (pix & 0x00FF0000) >> 16;                  \
2847     blue  = (pix & 0xFF000000) >> 24
2848
2849 #define ARGB32_COMPOSE(red, green, blue, old) (((blue) << 24) + ((green) << 16) + ((red) << 8) + ((old) & 0x000000FF))
2850
2851 #endif
2852
2853 /*****************************************************************************************
2854
2855     NAME
2856         moHidd_BitMap_PutAlphaImage
2857
2858     SYNOPSIS
2859         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_PutAlphaImage *msg);
2860
2861         VOID HIDD_BM_PutAlphaImage (OOP_Object *obj, OOP_Object *gc, UBYTE *pixels, ULONG modulo,
2862                                     WORD x, WORD y, WORD width, WORD height);
2863
2864     LOCATION
2865         hidd.graphics.bitmap
2866
2867     FUNCTION
2868         Perform an alpha-blending operation between a bitmap and ARGB pixel array.
2869
2870     INPUTS
2871         obj    - A bitmap to operate on
2872         gc     - A GC object, internally needed to perform the operation. All its attributes
2873                  are ignored.
2874         pixels - A pointer to an array of pixels
2875         modulo - Number of bytes per row in pixel array
2876         x, y   - Top-left corner of affected bitmap's region
2877         width  - Width of the modified rectangle.
2878         height - Height of the modified rectangle.
2879
2880     RESULT
2881         None.
2882
2883     NOTES
2884         Do not rely on 'gc' parameter being valid when implementing this method in own
2885         display driver. This parameter is actually obsolete, and will be set to NULL in
2886         future AROS versions. Current base class implementation ignores it.
2887
2888     EXAMPLE
2889
2890     BUGS
2891
2892     SEE ALSO
2893
2894     INTERNALS
2895
2896 *****************************************************************************************/
2897
2898 struct paib_data
2899 {
2900     void *pixels;
2901     ULONG modulo;
2902 };
2903
2904 /*
2905  * TODOs:
2906  * 1. Merge buffered and slow versions of PutAlphaImage(), use the same processing algorithm
2907  *    (convert array's pixels to bitmap's format, not vice versa)
2908  * 2. Make DoBufferedOperation() public, to be used for cybergraphics.library/ProcessPixelArray()
2909  *    implementation, and for some other functions in graphics.library and cybergraphics.library,
2910  *    currently using own implementation of pixel buffer.
2911  * 3. Reuse the new code for other buffered operations (currently using old macros).
2912  */
2913
2914 static void PutAlphaImageBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct paib_data *data)
2915 {
2916     UWORD x, y;
2917
2918     for (y = 0; y < height; y++)
2919     {
2920         ULONG *pixarray = data->pixels;
2921
2922         for (x = 0; x < width; x++)
2923         {
2924             ULONG destpix;
2925             ULONG srcpix;
2926             ULONG src_red, src_green, src_blue, src_alpha;
2927             ULONG dst_red, dst_green, dst_blue;
2928
2929             srcpix = *pixarray++;
2930
2931             if (ARGB32_ALPHA(srcpix) == ARGB32_ALPHA(0xFFFFFFFF))
2932             {
2933                 xbuf[x] = srcpix;
2934             }
2935             else if (ARGB32_ALPHA(srcpix) != 0)
2936             {
2937                 ARGB32_DECOMPOSE(src_alpha, src_red, src_green, src_blue, srcpix);
2938
2939                 destpix = xbuf[x];
2940                 RGB32_DECOMPOSE(dst_red, dst_green, dst_blue, destpix);
2941
2942                 dst_red   += do_alpha(src_alpha, src_red - dst_red);
2943                 dst_green += do_alpha(src_alpha, src_green - dst_green);
2944                 dst_blue  += do_alpha(src_alpha, src_blue - dst_blue);
2945
2946                 xbuf[x] = ARGB32_COMPOSE(dst_red, dst_green, dst_blue, destpix);
2947             }
2948         }
2949
2950         xbuf += width;
2951         data->pixels += data->modulo;
2952     }
2953 }
2954
2955 VOID BM__Hidd_BitMap__PutAlphaImage(OOP_Class *cl, OOP_Object *o,
2956                                     struct pHidd_BitMap_PutAlphaImage *msg)
2957 {
2958     WORD x, y;
2959     struct paib_data data = {msg->pixels, msg->modulo};
2960
2961     EnterFunc(bug("BitMap::PutAlphaImage(x=%d, y=%d, width=%d, height=%d)\n"
2962                 , msg->x, msg->y, msg->width, msg->height));
2963
2964     if (msg->width <= 0 || msg->height <= 0)
2965         return;
2966
2967     if (!DoBufferedOperation(cl, o, msg->x, msg->y, msg->width, msg->height, TRUE, vHidd_StdPixFmt_ARGB32,
2968                             (VOID_FUNC)PutAlphaImageBuffered, &data))
2969     {
2970         /* Buffered method failed, use slow pixel-by-pixel method */
2971         for (y = msg->y; y < msg->y + msg->height; y++)
2972         {
2973             ULONG *pixarray = data.pixels;
2974
2975             for (x = msg->x; x < msg->x + msg->width; x++)
2976             {
2977                 HIDDT_Pixel destpix;
2978                 HIDDT_Color col;
2979                 ULONG       srcpix;
2980                 LONG        src_red, src_green, src_blue, src_alpha;
2981                 LONG        dst_red, dst_green, dst_blue;
2982
2983                 destpix = HIDD_BM_GetPixel(o, x, y);
2984                 HIDD_BM_UnmapPixel(o, destpix, &col);
2985
2986                 srcpix = *pixarray++;
2987                 ARGB32_DECOMPOSE(src_alpha, src_red, src_green, src_blue, srcpix);
2988
2989                 dst_red   = col.red   >> 8;
2990                 dst_green = col.green >> 8;
2991                 dst_blue  = col.blue  >> 8;
2992
2993                 dst_red   += do_alpha(src_alpha, src_red - dst_red);
2994                 dst_green += do_alpha(src_alpha, src_green - dst_green);
2995                 dst_blue  += do_alpha(src_alpha, src_blue - dst_blue);
2996
2997                 col.red   = dst_red << 8;
2998                 col.green = dst_green << 8;
2999                 col.blue  = dst_blue << 8;
3000
3001                 HIDD_BM_PutPixel(o, x, y, HIDD_BM_MapColor(o, &col));
3002
3003             } /* for(x = msg->x; x < msg->x + msg->width; x++) */
3004
3005            data.pixels += msg->modulo;
3006
3007         } /* for(y = msg->y; y < msg->y + msg->height; y++) */
3008     }
3009     ReturnVoid("BitMap::PutAlphaImage");
3010 }
3011
3012 /*****************************************************************************************
3013
3014     NAME
3015         moHidd_BitMap_PutTemplate
3016
3017     SYNOPSIS
3018         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_PutTemplate *msg);
3019
3020         VOID HIDD_BM_PutTemplate (OOP_Object *obj, OOP_Object *gc, UBYTE *masktemplate, ULONG modulo,
3021                                   WORD srcx, WORD x, WORD y, WORD width, WORD height, BOOL inverttemplate);
3022
3023     LOCATION
3024         hidd.graphics.bitmap
3025
3026     FUNCTION
3027         Apply a single-bit mask to the given portion of the bitmap. Pixels set to 1 in the mask will be filled
3028         by foreground color. Pixels set to 0 in the mask will be filled by background color or left unchanged,
3029         according to the following GC attributes:
3030             Foreground     - a foreground color
3031             Background     - a background color
3032             DrawMode       - if set to Invert, foreground and background colors will be ignored. Instead,
3033                              pixels which are set to 1 in the mask, will be inverted. Other pixels will be
3034                              left unchanged.
3035             ColorExpansion - if set to Transparent, only pixels which are set to 1 in the mask, will be modified.
3036                              Other pixels will not be changed (background color will be ignored).
3037
3038     INPUTS
3039         obj            - A bitmap to draw on
3040         gc             - A GC object, holding operation parameters
3041         masktemplate       - A pointer to a bit mask
3042         modulo         - Number of bytes per line in the mask
3043         srcx           - Horizontal offset of the mask
3044         x, y           - Top-left corner of the bitmap's region to affect
3045         width          - Width of the affected region
3046         height         - Height of the affected region
3047         inverttemplate - If set to TRUE, bit mask will be interpreted in inverted form
3048
3049     RESULT
3050         None
3051
3052     NOTES
3053
3054     EXAMPLE
3055
3056     BUGS
3057
3058     SEE ALSO
3059
3060     INTERNALS
3061
3062 *****************************************************************************************/
3063
3064 struct ptb_data
3065 {
3066     void *bitarray;
3067     ULONG bitmask;
3068     ULONG modulo;
3069     ULONG fg;
3070     ULONG bg;
3071     UWORD invert;
3072 };
3073
3074 static void JAM1TemplateBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ptb_data *data)
3075 {
3076     UWORD x, y;
3077
3078     for (y = 0; y < height; y++)
3079     {
3080         ULONG  mask    = data->bitmask;
3081         UWORD *array   = data->bitarray;
3082         UWORD  bitword = AROS_BE2WORD(*array);
3083
3084         for (x = 0; x < width; x++)
3085         {
3086             if ((bitword & mask) == (data->invert & mask))
3087                 xbuf[x] = data->fg;
3088
3089             mask >>= 1;
3090             if (!mask)
3091             {
3092                 mask = 0x8000;
3093                 array++;
3094                 bitword = AROS_BE2WORD(*array);
3095             }
3096         }
3097
3098         xbuf += width;
3099         data->bitarray += data->modulo;
3100     }
3101 }
3102
3103 static void ComplementTemplateBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ptb_data *data)
3104 {
3105     UWORD x, y;
3106
3107     for (y = 0; y < height; y++)
3108     {
3109         ULONG  mask    = data->bitmask;
3110         UWORD *array   = data->bitarray;
3111         UWORD  bitword = AROS_BE2WORD(*array);
3112
3113         for (x = 0; x < width; x++)
3114         {
3115             if ((bitword & mask) == (data->invert & mask))
3116                  xbuf[x] = ~xbuf[x];
3117
3118             mask >>= 1;
3119             if (!mask)
3120             {
3121                 mask = 0x8000;
3122                 array++;
3123                 bitword = AROS_BE2WORD(*array);
3124             }
3125         }
3126
3127         xbuf += width;
3128         data->bitarray += data->modulo;
3129     }
3130 }
3131
3132 static void JAM2TemplateBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ptb_data *data)
3133 {
3134     UWORD x, y;
3135
3136     for (y = 0; y < height; y++)
3137     {
3138         ULONG  mask    = data->bitmask;
3139         UWORD *array   = data->bitarray;
3140         UWORD  bitword = AROS_BE2WORD(*array);
3141
3142         for (x = 0; x < width; x++)
3143         {
3144             if ((bitword & mask) == (data->invert & mask))
3145                 xbuf[x] = data->fg;
3146             else
3147                 xbuf[x] = data->bg;
3148
3149             mask >>= 1;
3150             if (!mask)
3151             {
3152                 mask = 0x8000;
3153                 array++;
3154                 bitword = AROS_BE2WORD(*array);
3155             }
3156         }
3157
3158         xbuf += width;
3159         data->bitarray += data->modulo;
3160     }
3161 }
3162
3163 VOID BM__Hidd_BitMap__PutTemplate(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutTemplate *msg)
3164 {
3165     OOP_Object *gc = msg->gc;
3166     BOOL get = TRUE;
3167     void (*op)(ULONG *, UWORD, UWORD, UWORD, struct ptb_data *);
3168     struct ptb_data data;
3169
3170     EnterFunc(bug("BitMap::PutTemplate(x=%d, y=%d, width=%d, height=%d)\n"
3171                 , msg->x, msg->y, msg->width, msg->height));
3172
3173     if (msg->width <= 0 || msg->height <= 0)
3174         return;
3175
3176     if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
3177     {
3178         op = JAM1TemplateBuffered;
3179     }
3180     else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
3181     {
3182         op = ComplementTemplateBuffered;
3183     }
3184     else
3185     {
3186         op  = JAM2TemplateBuffered;
3187         get = FALSE;
3188     }
3189
3190     data.bitarray = msg->masktemplate + ((msg->srcx / 16) * 2);
3191     data.bitmask  = 0x8000 >> (msg->srcx & 0xF);
3192     data.modulo   = msg->modulo;
3193     data.fg       = GC_FG(msg->gc);
3194     data.bg       = GC_BG(msg->gc);
3195     data.invert   = msg->inverttemplate ? 0 : 0xFFFF;
3196
3197     DoBufferedOperation(cl, o, msg->x, msg->y, msg->width, msg->height, get, vHidd_StdPixFmt_Native32, (VOID_FUNC)op, &data);
3198
3199     /* TODO: write fallback */
3200
3201     ReturnVoid("BitMap::PutTemplate");
3202 }
3203
3204 /*****************************************************************************************
3205
3206     NAME
3207         moHidd_BitMap_PutAlphaTemplate
3208
3209     SYNOPSIS
3210         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_PutAlphaTemplate *msg);
3211
3212         VOID HIDD_BM_PutAlphaTemplate (OOP_Object *obj, OOP_Object *gc, UBYTE *alpha, ULONG modulo,
3213                                        WORD x, WORD y, WORD width, WORD height, BOOL invertalpha);
3214
3215     LOCATION
3216         hidd.graphics.bitmap
3217
3218     FUNCTION
3219         Perform a drawing with current foreground color, using 8-bit alpha channel mask. The following
3220         GC attributes are considered:
3221             Foreground     - a foreground color
3222             Background     - a background color
3223             DrawMode       - if set to Invert, foreground and background colors will be ignored. Instead,
3224                              pixels, for which alpha channel value is greater than 127, will be inverted.
3225                              Other pixels will be left unchanged.
3226             ColorExpansion - if set to Opaque, alpha blending will happen between foreground and background
3227                              colors, instead of between foreground color and old bitmap contents.
3228
3229     INPUTS
3230         obj         - A bitmap to draw on
3231         gc          - A GC object specifying drawing parameters
3232         alpha       - A pointer to a 8-bit per pixel alpha channel mask
3233         modulo      - Number of bytes per line in the mask
3234         x, y        - Top-left corner of the affected bitmap's region
3235         width       - Width of the affected bitmap's region
3236         height      - Height of the affected bitmap's region
3237         invertalpha - If set to TRUE, alpha mask values will be treated in inverted form
3238
3239     RESULT
3240         None
3241
3242     NOTES
3243
3244     EXAMPLE
3245
3246     BUGS
3247
3248     SEE ALSO
3249
3250     INTERNALS
3251
3252 *****************************************************************************************/
3253
3254 struct patb_data
3255 {
3256     UBYTE *pixarray;
3257     ULONG  modulo;
3258     LONG   a_red, a_green, a_blue;
3259     LONG   b_red, b_green, b_blue;
3260     UBYTE  invert;
3261 };
3262
3263 static void JAM1AlphaTemplateBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct patb_data *data)
3264 {
3265     UWORD x, y;
3266
3267     for (y = 0; y < height; y++)
3268     {
3269         UBYTE *pixarray = data->pixarray;
3270
3271         for (x = 0; x < width; x++)
3272         {
3273             LONG dst_red, dst_green, dst_blue, alpha;
3274
3275             alpha = (*pixarray++) ^ data->invert;
3276             RGB32_DECOMPOSE(dst_red, dst_green, dst_blue, xbuf[x]);
3277
3278             dst_red   += do_alpha(alpha, data->a_red - dst_red);
3279             dst_green += do_alpha(alpha, data->a_green - dst_green);
3280             dst_blue  += do_alpha(alpha, data->a_blue - dst_blue);
3281
3282             xbuf[x] = ARGB32_COMPOSE(dst_red, dst_green, dst_blue, 0);
3283         }
3284
3285         xbuf += width;
3286         data->pixarray += data->modulo;
3287     }
3288 }
3289
3290 static void ComplementAlphaTemplateBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct patb_data *data)
3291 {
3292     UWORD x, y;
3293
3294     for (y = 0; y < height; y++)
3295     {
3296         UBYTE *pixarray = data->pixarray;
3297
3298         for (x = 0; x < width; x++)
3299         {
3300             UBYTE alpha = (*pixarray++) ^ data->invert;
3301
3302             if (alpha >= 0x80)
3303                 xbuf[x] = ~xbuf[x];
3304         }
3305
3306         xbuf += width;
3307         data->pixarray += data->modulo;
3308     }
3309 }
3310
3311 static void JAM2AlphaTemplateBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct patb_data *data)
3312 {
3313     UWORD x, y;
3314
3315     for (y = 0; y < height; y++)
3316     {
3317         UBYTE *pixarray = data->pixarray;
3318
3319         for (x = 0; x < width; x++)
3320         {
3321             LONG dst_red, dst_green, dst_blue, alpha;
3322
3323             alpha = (*pixarray++) ^ data->invert;
3324
3325             dst_red   = data->b_red   + ((data->a_red   - data->b_red)   * alpha) / 256;
3326             dst_green = data->b_green + ((data->a_green - data->b_green) * alpha) / 256;
3327             dst_blue  = data->b_blue  + ((data->a_blue  - data->b_blue)  * alpha) / 256;
3328
3329             xbuf[x] = ARGB32_COMPOSE(dst_red, dst_green, dst_blue, 0);
3330         }
3331
3332         xbuf += width;
3333         data->pixarray += data->modulo;
3334     }
3335 }
3336
3337 VOID BM__Hidd_BitMap__PutAlphaTemplate(OOP_Class *cl, OOP_Object *o,
3338                                        struct pHidd_BitMap_PutAlphaTemplate *msg)
3339 {
3340     OOP_Object *gc = msg->gc;
3341     BOOL get = TRUE;
3342     void (*op)(ULONG *, UWORD, UWORD, UWORD, struct patb_data *);
3343     struct patb_data data;
3344     HIDDT_Color color;
3345
3346     EnterFunc(bug("BitMap::PutAlphaTemplate(x=%d, y=%d, width=%d, height=%d)\n"
3347                 , msg->x, msg->y, msg->width, msg->height));
3348
3349     if (msg->width <= 0 || msg->height <= 0)
3350         return;
3351
3352     HIDD_BM_UnmapPixel(o, GC_FG(gc), &color);
3353     data.a_red   = color.red   >> 8;
3354     data.a_green = color.green >> 8;
3355     data.a_blue  = color.blue  >> 8;
3356
3357     if (GC_COLEXP(gc) == vHidd_GC_ColExp_Transparent)
3358     {
3359         op = JAM1AlphaTemplateBuffered;
3360     }
3361     else if (GC_DRMD(gc) == vHidd_GC_DrawMode_Invert)
3362     {
3363         op = ComplementAlphaTemplateBuffered;
3364     }
3365     else
3366     {
3367         op  = JAM2AlphaTemplateBuffered;
3368         get = FALSE;
3369
3370         HIDD_BM_UnmapPixel(o, GC_BG(gc), &color);
3371         data.b_red   = color.red   >> 8;
3372         data.b_green = color.green >> 8;
3373         data.b_blue  = color.blue  >> 8;
3374     }
3375
3376     data.pixarray = msg->alpha;
3377     data.modulo   = msg->modulo;
3378     data.invert   = msg->invertalpha ? 255 : 0;
3379
3380     DoBufferedOperation(cl, o, msg->x, msg->y, msg->width, msg->height, get, vHidd_StdPixFmt_ARGB32, (VOID_FUNC)op, &data);
3381
3382     /* TODO: write fallback */
3383
3384     ReturnVoid("BitMap::PutAlphaTemplate");
3385 }
3386
3387 /*****************************************************************************************
3388
3389     NAME
3390         moHidd_BitMap_PutPattern
3391
3392     SYNOPSIS
3393         VOID OOP_DoMethod(OOP_Object *o, struct pHidd_BitMap_PutPattern *msg);
3394
3395         VOID HIDD_BM_PutPattern(OOP_Object *obj, OOP_Object *gc, UBYTE *pattern,
3396                                 WORD patternsrcx, WORD patternsrcy, WORD patternheight, WORD patterndepth,
3397                                 HIDDT_PixelLUT *patternlut, BOOL invertpattern, UBYTE *mask,
3398                                 ULONG maskmodulo, WORD masksrcx, WORD x, WORD y,
3399                                 WORD width, WORD height);
3400
3401     LOCATION
3402         hidd.graphics.bitmap
3403
3404     FUNCTION
3405
3406     INPUTS
3407         obj           - A bitmap to draw on
3408         gc            - A GC object to use for drawing
3409         pattern       -
3410         patternsrcx   -
3411         patternsrcy   -
3412         patternheight -
3413         patterndepth  -
3414         patternlut    -
3415         invertpattern -
3416         mask          -
3417         maskmodulo    -
3418         masksrcx      -
3419         x, y          -
3420         width         -
3421         height        -
3422
3423     RESULT
3424         None
3425
3426     NOTES
3427
3428     EXAMPLE
3429
3430     BUGS
3431
3432     SEE ALSO
3433
3434     INTERNALS
3435
3436 *****************************************************************************************/
3437
3438 struct ppb_data
3439 {
3440     UWORD *patarray;
3441     void  *maskarray;
3442     ULONG *patternlut;
3443     UWORD  patternsrcy;
3444     UWORD  desty;
3445     UWORD  patternheight;
3446     ULONG  maskmodulo;
3447     ULONG  fg;
3448     ULONG  bg;
3449     UWORD  patmask;
3450     UWORD  maskmask;
3451     UWORD  patterndepth;
3452     UWORD  invert;
3453 };
3454
3455 static void JAM1PatternBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ppb_data *data)
3456 {
3457     UWORD x, y;
3458
3459     for (y = 0; y < height; y++)
3460     {
3461         UWORD  pmask    = data->patmask;
3462         UWORD  mmask    = data->maskmask;
3463         UWORD *parray   = data->patarray + ((y + starty + data->patternsrcy - data->desty) % data->patternheight);
3464         UWORD  patword  = AROS_BE2WORD(*parray);
3465         UWORD *marray   = data->maskarray;
3466         UWORD  maskword = marray ? AROS_BE2WORD(*marray) : 0xFFFF;
3467
3468         for (x = 0; x < width; x++)
3469         {
3470             if (maskword & mmask)
3471             {
3472                 if ((patword & pmask) == (data->invert & pmask))
3473                     xbuf[x] = data->fg;
3474             }
3475
3476             if (marray)
3477             {
3478                 mmask >>= 1;
3479                 if (!mmask)
3480                 {
3481                     mmask = 0x8000;
3482                     marray++;
3483                     maskword = AROS_BE2WORD(*marray);
3484                 }
3485             }
3486
3487             pmask >>= 1;
3488             if (!pmask)
3489                 pmask = 0x8000;
3490
3491         } /* for (x) */
3492
3493         xbuf += width;
3494         if (data->maskarray)
3495             data->maskarray += data->maskmodulo;
3496
3497     } /* for (y) */
3498 }
3499
3500 static void ComplementPatternBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ppb_data *data)
3501 {
3502     UWORD x, y;
3503
3504     for (y = 0; y < height; y++)
3505     {
3506         UWORD  pmask    = data->patmask;
3507         UWORD  mmask    = data->maskmask;
3508         UWORD *parray   = data->patarray + ((y + starty + data->patternsrcy - data->desty) % data->patternheight);
3509         UWORD  patword  = AROS_BE2WORD(*parray);
3510         UWORD *marray   = data->maskarray;
3511         UWORD  maskword = marray ? AROS_BE2WORD(*marray) : 0xFFFF;
3512
3513         for (x = 0; x < width; x++)
3514         {
3515             if (maskword & mmask)
3516             {
3517                 if ((patword & pmask) == (data->invert & pmask))
3518                     xbuf[x] = ~xbuf[x];
3519             }
3520
3521             if (marray)
3522             {
3523                 mmask >>= 1;
3524                 if (!mmask)
3525                 {
3526                     mmask = 0x8000;
3527                     marray++;
3528                     maskword = AROS_BE2WORD(*marray);
3529                 }
3530             }
3531
3532             pmask >>= 1;
3533             if (!pmask)
3534                 pmask = 0x8000;
3535
3536         } /* for (x) */
3537
3538         xbuf += width;
3539         if (data->maskarray)
3540             data->maskarray += data->maskmodulo;
3541
3542     } /* for (y) */
3543 }
3544
3545 static void JAM2PatternBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ppb_data *data)
3546 {
3547     UWORD x, y;
3548
3549     for (y = 0; y < height; y++)
3550     {
3551         UWORD  pmask    = data->patmask;
3552         UWORD  mmask    = data->maskmask;
3553         UWORD *parray   = data->patarray + ((y + starty + data->patternsrcy - data->desty) % data->patternheight);
3554         UWORD  patword  = AROS_BE2WORD(*parray);
3555         UWORD *marray   = data->maskarray;
3556         UWORD  maskword = marray ? AROS_BE2WORD(*marray) : 0xFFFF;
3557
3558         for (x = 0; x < width; x++)
3559         {
3560             if (maskword & mmask)
3561             {
3562                 if ((patword & pmask) == (data->invert & pmask))
3563                     xbuf[x] = data->fg;
3564                 else
3565                     xbuf[x] = data->bg;
3566             }
3567
3568             if (marray)
3569             {
3570                 mmask >>= 1;
3571                 if (!mmask)
3572                 {
3573                     mmask = 0x8000;
3574                     marray++;
3575                     maskword = AROS_BE2WORD(*marray);
3576                 }
3577             }
3578
3579             pmask >>= 1;
3580             if (!pmask)
3581                 pmask = 0x8000;
3582
3583         } /* for (x) */
3584
3585         xbuf += width;
3586         if (data->maskarray)
3587             data->maskarray += data->maskmodulo;
3588
3589     } /* for (y) */
3590 }
3591
3592 static void ColorPatternBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ppb_data *data)
3593 {
3594     UWORD x, y;
3595
3596     for (y = 0; y < height; y++)
3597     {
3598         UWORD  pmask    = data->patmask;
3599         UWORD  mmask    = data->maskmask;
3600         UWORD *parray   = data->patarray + ((y + starty + data->patternsrcy - data->desty) % data->patternheight);
3601         UWORD  patword  = AROS_BE2WORD(*parray);
3602         UWORD *marray   = data->maskarray;
3603         UWORD  maskword = marray ? AROS_BE2WORD(*marray) : 0xFFFF;
3604
3605         for (x = 0; x < width; x++)
3606         {
3607             if (maskword & mmask)
3608             {
3609                 UWORD plane;
3610                 ULONG pixel = (patword & pmask) ? 1 : 0; /* CHECKME: Shouldn't we handle INVERSVID here too ? */
3611
3612                 for (plane = 1; plane < data->patterndepth; plane++)
3613                 {
3614                     UWORD *_parray = parray + plane * data->patternheight;
3615                     UWORD _patword = AROS_BE2WORD(*_parray);
3616
3617                     if (_patword & pmask)
3618                         pixel |= 1L << plane;
3619                 }
3620
3621                 if (data->patternlut)
3622                     pixel = data->patternlut[pixel];
3623
3624                 xbuf[x] = pixel;
3625             }
3626
3627             if (marray)
3628             {
3629                 mmask >>= 1;
3630                 if (!mmask)
3631                 {
3632                     mmask = 0x8000;
3633                     marray++;
3634                     maskword = AROS_BE2WORD(*marray);
3635                 }
3636             }
3637
3638             pmask >>= 1;
3639             if (!pmask)
3640                 pmask = 0x8000;
3641
3642         } /* for (x) */
3643
3644         xbuf += width;
3645         if (data->maskarray)
3646             data->maskarray += data->maskmodulo;
3647
3648     } /* for (y) */
3649 }
3650
3651 VOID BM__Hidd_BitMap__PutPattern(OOP_Class *cl, OOP_Object *o,
3652                                  struct pHidd_BitMap_PutPattern *msg)
3653 {
3654     void (*op)(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ppb_data *data);
3655     BOOL get = TRUE;
3656     struct ppb_data data;
3657
3658     DPUTPATTERN(bug("BitMap::PutPattern(x=%d, y=%d, width=%d, height=%d)\n",
3659                     msg->x, msg->y, msg->width, msg->height));
3660
3661     if (msg->width <= 0 || msg->height <= 0)
3662         return;
3663
3664     if (msg->patterndepth > 1)
3665     {
3666         DPUTPATTERN(bug("[PutPattern] Color\n"));
3667         op  = ColorPatternBuffered;
3668         get = FALSE;
3669     }
3670     else if (GC_COLEXP(msg->gc) == vHidd_GC_ColExp_Transparent)
3671     {
3672         DPUTPATTERN(bug("[PutPattern] JAM1\n"));
3673         op = JAM1PatternBuffered;
3674     }
3675     else if (GC_DRMD(msg->gc) == vHidd_GC_DrawMode_Invert)
3676     {
3677         DPUTPATTERN(bug("[PutPattern] Complement\n"));
3678         op = ComplementPatternBuffered;
3679     }
3680     else
3681     {
3682         DPUTPATTERN(bug("[PutPattern] JAM2\n"));
3683         op  = JAM2PatternBuffered;
3684         get = FALSE;
3685     }
3686
3687     data.patarray      = (UWORD *)msg->pattern;
3688     data.patmask       = 0x8000 >> (msg->patternsrcx & 0xF);
3689     data.maskarray     = msg->mask;
3690     data.patternlut    = msg->patternlut ? msg->patternlut->pixels : NULL;
3691     data.patternsrcy   = msg->patternsrcy;
3692     data.desty         = msg->y;
3693     data.patternheight = msg->patternheight;
3694     data.patterndepth  = msg->patterndepth;
3695     data.maskmodulo    = msg->maskmodulo;
3696     data.fg            = GC_FG(msg->gc);
3697     data.bg            = GC_BG(msg->gc);
3698     data.invert        = msg->invertpattern ? 0 : 0xFFFF;
3699
3700     if (data.maskarray)
3701     {
3702         data.maskarray += (msg->masksrcx / 16) * 2;
3703         data.maskmask   = 0x8000 >> (msg->masksrcx & 0xF);
3704         get = TRUE;
3705     }
3706     else
3707         data.maskmask = 0xFFFF;
3708
3709     DPUTPATTERN(bug("[PutPattern] MaskArray 0x%p, MaskMask 0x%04X\n", data.maskarray, data.maskmask));
3710
3711     DoBufferedOperation(cl, o, msg->x, msg->y, msg->width, msg->height, get, vHidd_StdPixFmt_Native32, (VOID_FUNC)op, &data);
3712
3713     /* TODO: Write fallback */
3714
3715     ReturnVoid("BitMap::PutPattern");
3716 }
3717
3718 /*****************************************************************************************
3719
3720     NAME
3721         moHidd_BitMap_PutImageLUT
3722
3723     SYNOPSIS
3724         VOID OOP_DoMethod(OOP_Object *o, struct pHidd_BitMap_PutImageLUT *msg);
3725
3726         VOID HIDD_BM_PutImageLUT (OOP_Object *obj, OOP_Object *gc, UBYTE *pixels, ULONG modulo,
3727                                   WORD x, WORD y, WORD width, WORD height, HIDDT_PixelLUT *pixlut);
3728
3729     LOCATION
3730         hidd.graphics.bitmap
3731
3732     FUNCTION
3733
3734     INPUTS
3735         obj    -
3736         gc     -
3737         pixels -
3738         modulo -
3739         x, y   -
3740         width  -
3741         height -
3742         pixlut -
3743
3744     RESULT
3745
3746     NOTES
3747
3748     EXAMPLE
3749
3750     BUGS
3751
3752     SEE ALSO
3753
3754     INTERNALS
3755
3756 *****************************************************************************************/
3757
3758 VOID BM__Hidd_BitMap__PutImageLUT(OOP_Class *cl, OOP_Object *o,
3759                                   struct pHidd_BitMap_PutImageLUT *msg)
3760 {
3761     WORD                    x, y;
3762     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
3763     HIDDT_PixelLUT          *pixlut = msg->pixlut;
3764     HIDDT_Pixel             *lut = pixlut ? pixlut->pixels : NULL;
3765     HIDDT_Pixel             *linebuf;
3766     OOP_Object              *gc = msg->gc;
3767
3768     EnterFunc(bug("BitMap::PutImageLUT(x=%d, y=%d, width=%d, height=%d)\n"
3769                 , msg->x, msg->y, msg->width, msg->height));
3770
3771     if (msg->width <= 0 || msg->height <= 0)
3772         return;
3773
3774     linebuf = AllocVec(msg->width * sizeof(HIDDT_Pixel), MEMF_PUBLIC);
3775
3776     for(y = 0; y < msg->height; y++)
3777     {
3778         if (linebuf)
3779         {
3780             if (lut)
3781             {
3782                 for(x = 0; x < msg->width; x++)
3783                 {
3784                     linebuf[x] = lut[pixarray[x]];
3785                 }
3786             }
3787             else
3788             {
3789                 for(x = 0; x < msg->width; x++)
3790                 {
3791                     linebuf[x] = pixarray[x];
3792                 }
3793             }
3794             pixarray += msg->modulo;
3795
3796             HIDD_BM_PutImage(o,
3797                              msg->gc,
3798                              (UBYTE *)linebuf,
3799                              0,
3800                              msg->x,
3801                              msg->y + y,
3802                              msg->width,
3803                              1,
3804                              vHidd_StdPixFmt_Native32);
3805
3806         } /* if (linebuf) */
3807         else
3808         {
3809             ULONG old_fg;
3810
3811             /* Preserve old fg pen */
3812             old_fg = GC_FG(gc);
3813
3814             if (lut)
3815             {
3816                 for(x = 0; x < msg->width; x++)
3817                 {
3818                     GC_FG(gc) = lut[pixarray[x]];
3819                     HIDD_BM_DrawPixel(o, gc, msg->x + x, msg->y + y);
3820                 }
3821             }
3822             else
3823             {
3824                 for(x = 0; x < msg->width; x++)
3825                 {
3826                     GC_FG(gc) = pixarray[x];
3827                     HIDD_BM_DrawPixel(o, gc, msg->x + x, msg->y + y);
3828                 }
3829             }
3830             GC_FG(gc) = old_fg;
3831
3832             pixarray += msg->modulo;
3833
3834         } /* if (linebuf) else ... */
3835
3836     } /* for(y = 0; y < msg->height; y++) */
3837
3838     FreeVec(linebuf);
3839
3840     ReturnVoid("BitMap::PutImageLUT");
3841 }
3842 /*****************************************************************************************
3843
3844     NAME
3845         moHidd_BitMap_PutTranspImageLUT
3846
3847     SYNOPSIS
3848         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_PutTranspImageLUT *msg);
3849
3850         VOID HIDD_BM_PutTranspImageLUT (OOP_Object *obj, OOP_Object *gc, UBYTE *pixels,
3851                                         ULONG modulo, WORD x, WORD y, WORD width, WORD height,
3852                                         HIDDT_PixelLUT *pixlut, UBYTE transparent);
3853
3854     LOCATION
3855         hidd.graphics.bitmap
3856
3857     FUNCTION
3858         Copy an array of 8-bit LUT pixels to the bitmap at the specified position making
3859         one of colors transparent.
3860
3861         Pixels are converted to bitmap's native format using either user-supplied LUT (if
3862         given) or bitmap's own colormap.
3863
3864         Draw mode of the supplied GC is ignored, the operation is always bulk copy.
3865
3866     INPUTS
3867         obj         - A bitmap to draw image on
3868         gc          - A GC used for drawing
3869         pixels      - A pointer to source pixel array
3870         modulo      - Total number of bytes per line in the source array
3871         x, y        - Top-left corner of the destination rectangle
3872         width       - Width of the image to draw
3873         height      - Height of the image to draw
3874         pixlut      - An optional pointer to a LUT to use. NULL means using bitmap's
3875                       own colormap (if available)
3876         transparent - Value of pixels in the source array which will be made
3877                       transparent
3878
3879     RESULT
3880         None
3881
3882     NOTES
3883
3884     EXAMPLE
3885
3886     BUGS
3887
3888     SEE ALSO
3889
3890     INTERNALS
3891
3892 *****************************************************************************************/
3893
3894 #undef csd /* Bad hack, but there's no other way */
3895
3896 struct ptilb_data
3897 {
3898     UBYTE                    *pixarray;
3899     ULONG                    *lut;
3900     OOP_Object               *colmap;
3901     struct class_static_data *csd;
3902     ULONG                     modulo;
3903     UBYTE                     transparent;
3904 };
3905
3906 static void PutTranspImageLUTBuffered(ULONG *xbuf, UWORD starty, UWORD width, UWORD height, struct ptilb_data *data)
3907 {
3908     struct class_static_data *csd = data->csd;
3909     UWORD x, y;
3910
3911     for (y = 0; y < height; y++)
3912     {
3913         UBYTE *pixarray = data->pixarray;
3914
3915         if (data->lut)
3916         {
3917             for (x = 0; x < width; x++)
3918             {
3919                 UBYTE pix = *pixarray++;
3920
3921                 if (pix != data->transparent)
3922                     xbuf[x] = data->lut[pix];
3923
3924             } /* for (x) */
3925         }
3926         else
3927         {
3928             for (x = 0; x < width; x++)
3929             {
3930                 UBYTE pix = *pixarray++;
3931
3932                 if (pix != data->transparent)
3933                 {
3934                     if (data->colmap)
3935                         pix = HIDD_CM_GetPixel(data->colmap, pix);
3936
3937                     xbuf[x] = pix;
3938                 }
3939
3940             } /* for (x) */
3941         }
3942
3943         xbuf += width;
3944         data->pixarray += data->modulo;
3945     } /* for (y) */
3946 }
3947
3948 VOID BM__Hidd_BitMap__PutTranspImageLUT(OOP_Class *cl, OOP_Object *o,
3949                                         struct pHidd_BitMap_PutTranspImageLUT *msg)
3950 {
3951     struct HIDDBitMapData *data = OOP_INST_DATA(cl, o);
3952     struct ptilb_data userdata =
3953     {
3954         msg->pixels,
3955         NULL,
3956         data->colmap,
3957         CSD(cl),
3958         msg->modulo,
3959         msg->transparent
3960     };
3961
3962     EnterFunc(bug("BitMap::PutTranspImageLUT(x=%d, y=%d, width=%d, height=%d)\n"
3963                 , msg->x, msg->y, msg->width, msg->height));
3964
3965     if (msg->width <= 0 || msg->height <= 0)
3966         return;
3967
3968     if (msg->pixlut)
3969         userdata.lut = msg->pixlut->pixels;
3970
3971     DoBufferedOperation(cl, o, msg->x, msg->y, msg->width, msg->height, TRUE, vHidd_StdPixFmt_Native32,
3972                         (VOID_FUNC)PutTranspImageLUTBuffered, &userdata);
3973
3974     /* TODO: Write fallback */
3975
3976     ReturnVoid("BitMap::PutTranspImageLUT");
3977 }
3978
3979 #define csd CSD(cl)
3980
3981 /*****************************************************************************************
3982
3983     NAME
3984         moHidd_BitMap_GetImageLUT
3985
3986     SYNOPSIS
3987         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_GetImageLUT *msg);
3988
3989         VOID HIDD_BM_GetImageLUT (OOP_Object *obj, UBYTE *pixels, ULONG modulo, WORD x, WORD y,
3990                                   WORD width, WORD height, HIDDT_PixelLUT *pixlut);
3991
3992     LOCATION
3993         hidd.graphics.bitmap
3994
3995     FUNCTION
3996
3997     INPUTS
3998         obj    -
3999         pixels -
4000         modulo -
4001         x, y   -
4002         width  -
4003         height -
4004         pixlut -
4005
4006     RESULT
4007
4008     NOTES
4009
4010     EXAMPLE
4011
4012     BUGS
4013
4014     SEE ALSO
4015
4016     INTERNALS
4017
4018 *****************************************************************************************/
4019
4020 VOID BM__Hidd_BitMap__GetImageLUT(OOP_Class *cl, OOP_Object *o,
4021                                   struct pHidd_BitMap_GetImageLUT *msg)
4022 {
4023     WORD                    x, y;
4024     UBYTE                   *pixarray = (UBYTE *)msg->pixels;
4025     HIDDT_PixelLUT          *pixlut = msg->pixlut;
4026     HIDDT_Pixel             *lut = pixlut ? pixlut->pixels : NULL;
4027     HIDDT_Pixel             *linebuf;
4028
4029     EnterFunc(bug("BitMap::GetImageLUT(x=%d, y=%d, width=%d, height=%d)\n"
4030                 , msg->x, msg->y, msg->width, msg->height));
4031
4032     linebuf = AllocVec(msg->width * sizeof(HIDDT_Pixel), MEMF_PUBLIC);
4033
4034     for(y = 0; y < msg->height; y++)
4035     {
4036         if (linebuf)
4037         {
4038             HIDD_BM_GetImage(o,
4039                             (UBYTE *)linebuf,
4040                             0,
4041                             msg->x,
4042                             msg->y + y,
4043                             msg->width,
4044                             1,
4045                             vHidd_StdPixFmt_Native32);
4046             if (lut)
4047             {
4048                 /* FIXME: This is wrong, but HIDD_BM_GetImageLUT on hi/truecolor screens does not really make sense anyway */
4049                 for(x = 0; x < msg->width; x++)
4050                 {
4051                     pixarray[x] = (UBYTE)linebuf[x];
4052                 }
4053             }
4054             else
4055             {
4056                 for(x = 0; x < msg->width; x++)
4057                 {
4058                     pixarray[x] = (UBYTE)linebuf[x];
4059                 }
4060             }
4061             pixarray += msg->modulo;
4062
4063         } /* if (linebuf) */
4064         else
4065         {
4066             if (lut)
4067             {
4068                 /* FIXME: This is wrong, but HIDD_BM_GetImageLUT on hi/truecolor screens does not really make sense anyway */
4069                 for(x = 0; x < msg->width; x++)
4070                 {
4071                     pixarray[x] = (UBYTE)HIDD_BM_GetPixel(o, msg->x + x, msg->y + y);
4072                 }
4073             }
4074             else
4075             {
4076                 for(x = 0; x < msg->width; x++)
4077                 {
4078                     pixarray[x] = (UBYTE)HIDD_BM_GetPixel(o, msg->x + x, msg->y + y);
4079                 }
4080             }
4081
4082             pixarray += msg->modulo;
4083
4084         } /* if (linebuf) else ... */
4085
4086     } /* for(y = 0; y < msg->height; y++) */
4087
4088     if (linebuf) FreeVec(linebuf);
4089
4090     ReturnVoid("BitMap::GetImageLUT");
4091 }
4092
4093 /*****************************************************************************************
4094
4095     NAME
4096         moHidd_BitMap_BlitColorExpansion
4097
4098     SYNOPSIS
4099         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_BlitColorExpansion *msg);
4100
4101         VOID HIDD_BM_BlitColorExpansion (OOP_Object *obj, OOP_Object *gc, OOP_Object *srcBitMap,
4102                                          WORD srcX, WORD srcY, WORD destX, WORD destY,
4103                                          UWORD width, UWORD height);
4104
4105     LOCATION
4106         hidd.graphics.bitmap
4107
4108     FUNCTION
4109         Perform a color expansion of the mask in srcBitMap according to foreground and background
4110         colors and expansion mode specified by the supplied GC. Pixels which are set to zero in
4111         the mask bitmap will be either painted by background (in opaque mode) or left without
4112         change (in transparent mode). Pixels which are set to nonzero in the mask will be painted
4113         by foreground color.
4114
4115         The result of expansion is blitted onto the destination bitmap accorging to GC's draw mode.
4116
4117     INPUTS
4118         obj           - A bitmap to draw on
4119         gc            - A GC object to use for drawing
4120         srcBitMap     - A bitmap object containing mask image.
4121         srcX, srcY    - A top-left coordinate of the used rectangle in the source bitmap
4122         destX, destY  - A top-left coordinate of the destination rectangle to draw in
4123         width, height - A size of the rectangle to blit
4124
4125     RESULT
4126         None.
4127
4128     NOTES
4129         This method was previously used by graphics.library/Text() to draw fonts with no
4130         styles specified. Currently graphics.library always uses BltTemplate() and this
4131         method is considered obsolete.
4132
4133     EXAMPLE
4134
4135     BUGS
4136
4137     SEE ALSO
4138
4139     INTERNALS
4140
4141 *****************************************************************************************/
4142
4143 VOID BM__Hidd_BitMap__BlitColorExpansion(OOP_Class *cl, OOP_Object *o,
4144                                          struct pHidd_BitMap_BlitColorExpansion *msg)
4145 {
4146 #ifdef __RESERVED__
4147     ULONG   cemd;
4148     ULONG   fg, bg;
4149     WORD    x, y;
4150
4151     OOP_Object *gc = msg->gc;
4152
4153     EnterFunc(bug("BitMap::BlitColorExpansion(srcBM=%p, srcX=%d, srcY=%d, destX=%d, destY=%d, width=%d, height=%d)\n",
4154                 msg->srcBitMap, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height));
4155
4156     cemd = GC_COLEXP(gc);
4157     fg   = GC_FG(gc);
4158     bg   = GC_BG(gc);
4159
4160 /* bug("------------- Blit_ColExp: (%d, %d, %d, %d, %d, %d) cemd=%d, fg=%p, bg=%p -------------\n"
4161     , msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height
4162     , cemd, fg, bg);
4163 */
4164     for (y = 0; y < msg->height; y ++)
4165     {
4166         for (x = 0; x < msg->width; x ++)
4167         {
4168             ULONG is_set;
4169
4170             /* Pixel value is either 0 or 1 for BM of depth 1 */
4171             is_set = HIDD_BM_GetPixel(msg->srcBitMap, x + msg->srcX, y + msg->srcY);
4172
4173 /*
4174 if (is_set)
4175     bug("#");
4176 else
4177     bug(" ");
4178 */
4179             if (is_set)
4180             {
4181                 HIDD_BM_DrawPixel(o, gc, x + msg->destX, y + msg->destY);
4182             }
4183             else
4184             {
4185                 if (cemd & vHidd_GC_ColExp_Opaque)
4186                 {
4187                     /* Write bixel with BG pen */
4188                     GC_FG(gc) = bg;
4189                     HIDD_BM_DrawPixel(o, gc, x + msg->destX, y + msg->destY);
4190                     /* Reset to FG pen */
4191                     GC_FG(gc) = fg;
4192                 }
4193
4194             } /* if () */
4195
4196         } /* for (each x) */
4197 /*
4198     bug("\n");
4199 */
4200     } /* for ( each y ) */
4201 #endif
4202
4203     ReturnVoid("BitMap::BlitColorExpansion");
4204 }
4205
4206 /*****************************************************************************************
4207
4208     NAME
4209         moHidd_BitMap_BytesPerLine
4210
4211     SYNOPSIS
4212         ULONG OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_BytesPerLine *msg);
4213
4214         ULONG HIDD_BM_BytesPerLine(OOP_Object *obj, HIDDT_StdPixFmt pixFmt, UWORD width);
4215
4216     LOCATION
4217         hidd.graphics.bitmap
4218
4219     FUNCTION
4220         This method is currently not used and reserved.
4221
4222     INPUTS
4223         obj    -
4224         pixFmt -
4225         width  -
4226
4227     RESULT
4228
4229     NOTES
4230
4231     EXAMPLE
4232
4233     BUGS
4234
4235     SEE ALSO
4236
4237     INTERNALS
4238
4239 *****************************************************************************************/
4240
4241 ULONG BM__Hidd_BitMap__BytesPerLine(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_BytesPerLine *msg)
4242 {
4243 #ifdef __RESERVED__
4244      ULONG bpl;
4245
4246      switch (msg->pixFmt)
4247      {
4248          case vHidd_StdPixFmt_Native32:
4249              bpl = sizeof (HIDDT_Pixel) * msg->width;
4250              break;
4251
4252          case vHidd_StdPixFmt_Native:
4253          {
4254              struct HIDDBitMapData *data;
4255
4256              data = OOP_INST_DATA(cl, o);
4257
4258              bpl = ((HIDDT_PixelFormat *)data->prot.pixfmt)->bytes_per_pixel * msg->width;
4259              break;
4260         }
4261
4262         default:
4263         {
4264             OOP_Object              *pf;
4265             struct HIDDBitMapData   *data;
4266
4267             data = OOP_INST_DATA(cl, o);
4268
4269             pf = HIDD_Gfx_GetPixFmt(data->gfxhidd, msg->pixFmt);
4270
4271             if (NULL == pf)
4272             {
4273                 D(bug("!!! COULD NOT GET STD PIXFMT IN BitMap::BytesPerLine() !!!\n"));
4274                 return 0;
4275             }
4276
4277             bpl = ((HIDDT_PixelFormat *)pf)->bytes_per_pixel * msg->width;
4278             break;
4279         }
4280      }
4281
4282      return bpl;
4283 #else
4284     return 0;
4285 #endif
4286
4287 }
4288
4289 /****************************************************************************************/
4290
4291 /*
4292    This makes it easier to create a subclass of the graphics hidd.
4293    It is only allowed to use this method in the p_RootNew method of a
4294    bitmap subclass.
4295 */
4296
4297 /****************************************************************************************/
4298
4299 IPTR BM__Root__Set(OOP_Class *cl, OOP_Object *obj, struct pRoot_Set *msg)
4300 {
4301     struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
4302     struct Library *OOPBase = CSD(cl)->cs_OOPBase;
4303     struct HIDDBitMapData *data = OOP_INST_DATA(cl, obj);
4304
4305     if (data->framebuffer)
4306     {
4307         /*
4308          * If this is a framebuffer, we can process ModeID change.
4309          * We do it before parsing the rest of tags, because here we retrieve
4310          * defaults for new bitmap parameters (size and pixelformat).
4311          * They can be overriden by other tags. For example we can imagine
4312          * a hardware scrollable framebuffer whose width and height are larger
4313          * than visible part.
4314          */
4315         HIDDT_ModeID modeid = GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
4316         OOP_Object *sync, *pixfmt;
4317
4318         if (HIDD_Gfx_GetMode(data->gfxhidd, modeid, &sync, &pixfmt))
4319         {
4320             data->modeid = modeid;
4321             /*
4322              * Set defaults based on the ModeID.
4323              * They can be overriden lated, in SetBitMapTags.
4324              */
4325             data->width       = OOP_GET(sync, aHidd_Sync_HDisp);
4326             data->height      = OOP_GET(sync, aHidd_Sync_VDisp);
4327             data->bytesPerRow = GetBytesPerRow(data, CSD(cl));
4328             data->prot.pixfmt = pixfmt;
4329         }
4330         else
4331         {
4332             /* Bad ModeID given, request rejected */
4333             return FALSE;
4334         }
4335     }
4336     /* Process the rest of tags. */
4337     BM__Hidd_BitMap__SetBitMapTags(cl, obj, msg->attrList);
4338
4339     /* There's no superclass above us */
4340     return TRUE;
4341 }
4342
4343 /*****************************************************************************************
4344
4345     NAME
4346         moHidd_BitMap_SetColorMap
4347
4348     SYNOPSIS
4349         OOP_Object * OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_SetColorMap *msg);
4350
4351         OOP_Object * HIDD_BM_SetColorMap(OOP_Object *obj, OOP_Object *colorMap);
4352
4353     LOCATION
4354         hidd.graphics.bitmap
4355
4356     FUNCTION
4357
4358     INPUTS
4359         obj      -
4360         colorMap -
4361
4362     RESULT
4363
4364     NOTES
4365
4366     EXAMPLE
4367
4368     BUGS
4369
4370     SEE ALSO
4371
4372     INTERNALS
4373
4374 *****************************************************************************************/
4375
4376 OOP_Object *BM__Hidd_BitMap__SetColorMap(OOP_Class *cl, OOP_Object *o,
4377                                          struct pHidd_BitMap_SetColorMap *msg)
4378 {
4379     struct HIDDBitMapData   *data;
4380     OOP_Object              *old;
4381
4382     data = OOP_INST_DATA(cl, o);
4383
4384     old = data->colmap;
4385     data->colmap = msg->colorMap;
4386
4387     return old;
4388 }
4389
4390 /*****************************************************************************************
4391
4392     NAME
4393         moHidd_BitMap_MapColor
4394
4395     SYNOPSIS
4396         HIDDT_Pixel OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_MapColor *msg);
4397
4398         HIDDT_Pixel HIDD_BM_MapColor(OOP_Object *obj, HIDDT_Color *color);
4399
4400     LOCATION
4401         hidd.graphics.bitmap
4402
4403     FUNCTION
4404
4405     INPUTS
4406         obj   -
4407         color -
4408
4409     RESULT
4410
4411     NOTES
4412
4413     EXAMPLE
4414
4415     BUGS
4416
4417     SEE ALSO
4418
4419     INTERNALS
4420
4421 *****************************************************************************************/
4422
4423 /* We only care about magnitudes here, so we don't
4424  * have to perform the square root operation to get
4425  * the real distance.
4426  */
4427 static ULONG colorDistance(HIDDT_Color *a, HIDDT_Color *b)
4428 {
4429 #define SQR(x) ((x) * (x))
4430     return SQR((int)a->red - (int)b->red) +
4431            SQR((int)a->blue - (int)b->blue) +
4432            SQR((int)a->green - (int)b->green) +
4433            SQR((int)a->alpha - (int)b->alpha);
4434 #undef SQR
4435 }
4436
4437 HIDDT_Pixel BM__Hidd_BitMap__MapColor(OOP_Class *cl, OOP_Object *o,
4438                                       struct pHidd_BitMap_MapColor *msg)
4439 {
4440     HIDDT_PixelFormat *pf = BM_PIXFMT(o);
4441
4442     HIDDT_Pixel red     = msg->color->red;
4443     HIDDT_Pixel green   = msg->color->green;
4444     HIDDT_Pixel blue    = msg->color->blue;
4445     HIDDT_Pixel alpha   = msg->color->alpha;
4446
4447     /* This code assumes that sizeof(HIDDT_Pixel) is a multiple of sizeof(col->#?),
4448        which should be true for most (all?) systems. I have never heard
4449        of any system with for example 3 byte types.
4450     */
4451
4452     if (IS_TRUECOLOR(pf))
4453     {
4454         if (HIDD_PF_SWAPPIXELBYTES(pf))
4455         {
4456             /* FIXME: BM__Hidd_BitMap__MapColor assuming that SwapPixelBytes flag only set for 2-byte/16-bit pixel formats */
4457
4458             HIDDT_Pixel pixel = MAP_RGBA(red, green, blue, alpha, pf);
4459
4460             msg->color->pixval = SWAPBYTES_WORD(pixel);
4461         }
4462         else
4463         {
4464             msg->color->pixval = MAP_RGBA(red, green, blue, alpha, pf);
4465         }
4466     }
4467     else
4468     {
4469         struct HIDDBitMapData   *data = OOP_INST_DATA(cl, o);
4470         HIDDT_Color             *ctab;
4471         HIDDT_ColorLUT          *cmap;
4472         UWORD i;
4473         ULONG best_ndx = ~0, best_dist = ~0;
4474
4475         cmap = (HIDDT_ColorLUT *)data->colmap;
4476         ctab = cmap->colors;
4477         /* Search for the best match in the color table */
4478         for (i = 0; i < cmap->entries; i++) {
4479             ULONG dist;
4480
4481             dist = colorDistance(&ctab[i], msg->color);
4482             if (dist < best_dist) {
4483                 best_dist = dist;
4484                 best_ndx = i;
4485             }
4486         }
4487
4488         if (best_dist != ~0)
4489             msg->color->pixval = ctab[best_ndx].pixval;
4490     }
4491
4492     return msg->color->pixval;
4493 }
4494
4495 /*****************************************************************************************
4496
4497     NAME
4498         moHidd_BitMap_UnmapPixel
4499
4500     SYNOPSIS
4501         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_UnmapPixel *msg);
4502
4503         VOID HIDD_BM_UnmapPixel(OOP_Object *obj, HIDDT_Pixel pixel, HIDDT_Color *color);
4504
4505     LOCATION
4506         hidd.graphics.bitmap
4507
4508     FUNCTION
4509
4510     INPUTS
4511         obj   -
4512         pixel -
4513         color -
4514
4515     RESULT
4516
4517     NOTES
4518
4519     EXAMPLE
4520
4521     BUGS
4522
4523     SEE ALSO
4524
4525     INTERNALS
4526
4527 *****************************************************************************************/
4528
4529 VOID BM__Hidd_BitMap__UnmapPixel(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_UnmapPixel *msg)
4530 {
4531
4532     HIDDT_PixelFormat *pf = BM_PIXFMT(o);
4533
4534     if (IS_TRUECOLOR(pf))
4535     {
4536         HIDDT_Pixel pixel = msg->pixel;
4537
4538         if (HIDD_PF_SWAPPIXELBYTES(pf))
4539         {
4540             /* FIXME: bitmap_unmappixel assuming that SwapPixelBytes flag only set for 2-byte/16-bit pixel formats */
4541             pixel = SWAPBYTES_WORD(pixel);
4542         }
4543
4544         msg->color->red         = RED_COMP      (pixel, pf);
4545         msg->color->green       = GREEN_COMP    (pixel, pf);
4546         msg->color->blue        = BLUE_COMP     (pixel, pf);
4547         msg->color->alpha       = ALPHA_COMP    (pixel, pf);
4548     }
4549     else
4550     {
4551         struct HIDDBitMapData   *data = OOP_INST_DATA(cl, o);
4552         HIDDT_ColorLUT          *clut;
4553
4554         clut = (HIDDT_ColorLUT *)data->colmap;
4555
4556
4557
4558         /* FIXME: Use CLUT shift and CLUT mask here */
4559         if (msg->pixel < 0 || msg->pixel >= clut->entries)
4560             return;
4561
4562         *msg->color = clut->colors[msg->pixel];
4563
4564     }
4565
4566     /* Unnecessary, but... */
4567     msg->color->pixval  = msg->pixel;
4568 }
4569
4570 /*****************************************************************************************
4571
4572     NAME
4573         moHidd_BitMap_ObtainDirectAccess
4574
4575     SYNOPSIS
4576         BOOL OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_ObtainDirectAccess *msg);
4577
4578         BOOL HIDD_BM_ObtainDirectAccess(OOP_Object *obj, UBYTE **addressReturn,
4579                                         ULONG *widthReturn, ULONG *heightReturn,
4580                                         ULONG *bankSizeReturn, ULONG *memSizeReturn);
4581
4582     LOCATION
4583         hidd.graphics.bitmap
4584
4585     FUNCTION
4586
4587     INPUTS
4588         obj            -
4589         addressReturn  -
4590         widthReturn    -
4591         heightReturn   -
4592         bankSizeReturn -
4593         memSizeReturn  -
4594
4595     RESULT
4596         BOOL
4597
4598     NOTES
4599
4600     EXAMPLE
4601
4602     BUGS
4603
4604     SEE ALSO
4605
4606     INTERNALS
4607
4608 *****************************************************************************************/
4609
4610 BOOL BM__Hidd_BitMap__ObtainDirectAccess(OOP_Class *cl, OOP_Object *o,
4611                                          struct pHidd_BitMap_ObtainDirectAccess *msg)
4612 {
4613     /* Default implementation of direct access funcs. Just return FALSE */
4614     return FALSE;
4615 }
4616
4617 /*****************************************************************************************
4618
4619     NAME
4620         moHidd_BitMap_ReleaseDirectAccess
4621
4622     SYNOPSIS
4623         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_ReleaseDirectAccess *msg);
4624
4625         VOID HIDD_BM_ReleaseDirectAccess(OOP_Object *obj);
4626
4627     LOCATION
4628         hidd.graphics.bitmap
4629
4630     FUNCTION
4631
4632     INPUTS
4633         obj -
4634
4635     RESULT
4636
4637     NOTES
4638
4639     EXAMPLE
4640
4641     BUGS
4642
4643     SEE ALSO
4644
4645     INTERNALS
4646
4647 *****************************************************************************************/
4648
4649 VOID BM__Hidd_BitMap__ReleaseDirectAccess(OOP_Class *cl, OOP_Object *o,
4650                                           struct pHidd_BitMap_ReleaseDirectAccess *msg)
4651 {
4652      D(bug("!!! BitMap BaseClasse ReleaseDirectAccess() called !!!\n"));
4653      D(bug("!!! This should never happen and is probably due to a buggy implementation in the subclass !!!\n"));
4654
4655      return;
4656 }
4657
4658 /*****************************************************************************************
4659
4660     NAME
4661         moHidd_BitMap_BitMapScale
4662
4663     SYNOPSIS
4664         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_BitMapScale * msg);
4665
4666         VOID HIDD_BM_BitMapScale(OOP_Object *obj, OOP_Object *src, OOP_Object *dest,
4667                                  struct BitScaleArgs * bsa, OOP_Object *gc);
4668
4669     LOCATION
4670         hidd.graphics.bitmap
4671
4672     FUNCTION
4673
4674     INPUTS
4675         obj  -
4676         src  -
4677         dest -
4678         bsa  -
4679         gc   -
4680
4681     RESULT
4682
4683     NOTES
4684
4685     EXAMPLE
4686
4687     BUGS
4688
4689     SEE ALSO
4690
4691     INTERNALS
4692
4693 *****************************************************************************************/
4694
4695 VOID BM__Hidd_BitMap__BitMapScale(OOP_Class * cl, OOP_Object *o,
4696                                   struct pHidd_BitMap_BitMapScale * msg)
4697 {
4698     struct BitScaleArgs *bsa = msg->bsa;
4699     ULONG *srcbuf, *dstbuf;
4700     WORD srcline = -1;
4701     UWORD *linepattern;
4702     UWORD count;
4703     UWORD ys = bsa->bsa_SrcY;
4704     UWORD xs = bsa->bsa_SrcX;
4705     UWORD dyd = bsa->bsa_DestHeight;
4706     UWORD dxd = bsa->bsa_DestWidth;
4707     LONG accuys = dyd;
4708     LONG accuxs = dxd;
4709     UWORD dxs = bsa->bsa_SrcWidth;
4710     UWORD dys = bsa->bsa_SrcHeight;
4711     LONG accuyd = - (dys >> 1);
4712     LONG accuxd = - (dxs >> 1);
4713     UWORD x;
4714
4715     if ((srcbuf = AllocVec(bsa->bsa_SrcWidth * sizeof(ULONG), 0)) == NULL)
4716         return;
4717
4718     if ((dstbuf = AllocVec(bsa->bsa_DestWidth * sizeof(ULONG), 0)) == NULL) {
4719         FreeVec(srcbuf);
4720         return;
4721     }
4722
4723     if ((linepattern = (UWORD *) AllocVec(bsa->bsa_DestWidth * sizeof(UWORD), 0)) == NULL) {
4724         FreeVec(dstbuf);
4725         FreeVec(srcbuf);
4726         return;
4727     }
4728
4729     count = 0;
4730     while (count < bsa->bsa_DestWidth) {
4731         accuxd += dxs;
4732         while (accuxd > accuxs) {
4733             xs++;
4734             accuxs += dxd;
4735         }
4736
4737         linepattern[count] = xs;
4738
4739         count++;
4740     }
4741
4742     count = bsa->bsa_DestY;
4743     while (count < bsa->bsa_DestHeight + bsa->bsa_DestY) {
4744         accuyd += dys;
4745         while (accuyd > accuys) {
4746             ys++;
4747             accuys += dyd;
4748         }
4749
4750         if (srcline != ys) {
4751             HIDD_BM_GetImage(msg->src, (UBYTE *) srcbuf, bsa->bsa_SrcWidth * sizeof(ULONG), bsa->bsa_SrcX, bsa->bsa_SrcY + ys, bsa->bsa_SrcWidth, 1, vHidd_StdPixFmt_Native32);
4752             srcline = ys;
4753
4754             for (x = 0; x < bsa->bsa_DestWidth; x++)
4755                 dstbuf[x] = srcbuf[linepattern[x]];
4756         }
4757
4758         HIDD_BM_PutImage(msg->dst, msg->gc, (UBYTE *) dstbuf, bsa->bsa_DestWidth * sizeof(ULONG), bsa->bsa_DestX, count, bsa->bsa_DestWidth, 1, vHidd_StdPixFmt_Native32);
4759
4760         count++;
4761     }
4762
4763     FreeVec(linepattern);
4764
4765     FreeVec(dstbuf);
4766     FreeVec(srcbuf);
4767 }
4768
4769 /*****************************************************************************************
4770
4771     NAME
4772         moHidd_BitMap_SetRGBConversionFunction
4773
4774     SYNOPSIS
4775         HIDDT_RGBConversionFunction
4776         OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_SetRGBConversionFunction *msg);
4777
4778         HIDDT_RGBConversionFunction
4779         HIDD_BM_SetRGBConversionFunction(OOP_Object *obj, HIDDT_StdPixFmt srcPixFmt,
4780                                          HIDDT_StdPixFmt dstPixFmt,
4781                                          HIDDT_RGBConversionFunction function);
4782
4783     LOCATION
4784         hidd.graphics.bitmap
4785
4786     FUNCTION
4787
4788     INPUTS
4789
4790     RESULT
4791
4792     NOTES
4793
4794     EXAMPLE
4795
4796     BUGS
4797
4798     SEE ALSO
4799
4800     INTERNALS
4801
4802 *****************************************************************************************/
4803
4804 HIDDT_RGBConversionFunction BM__Hidd_BitMap__SetRGBConversionFunction(OOP_Class * cl, OOP_Object *o,
4805                                                                       struct pHidd_BitMap_SetRGBConversionFunction * msg)
4806 {
4807     HIDDT_RGBConversionFunction old;
4808
4809     if ((msg->srcPixFmt < FIRST_RGB_STDPIXFMT) ||
4810         (msg->dstPixFmt < FIRST_RGB_STDPIXFMT) ||
4811         (msg->srcPixFmt > LAST_RGB_STDPIXFMT) ||
4812         (msg->dstPixFmt > LAST_RGB_STDPIXFMT))
4813     {
4814         return (HIDDT_RGBConversionFunction)-1;
4815     }
4816     else
4817     {
4818         ObtainSemaphore(&CSD(cl)->rgbconvertfuncs_sem);
4819         old = CSD(cl)->rgbconvertfuncs[msg->srcPixFmt - FIRST_RGB_STDPIXFMT][msg->dstPixFmt - FIRST_RGB_STDPIXFMT];
4820         CSD(cl)->rgbconvertfuncs[msg->srcPixFmt - FIRST_RGB_STDPIXFMT][msg->dstPixFmt - FIRST_RGB_STDPIXFMT] = msg->function;
4821         ReleaseSemaphore(&CSD(cl)->rgbconvertfuncs_sem);
4822
4823         return old;
4824     }
4825 }
4826
4827 /*****************************************************************************************
4828
4829     NAME
4830         moHidd_BitMap_UpdateRect
4831
4832     SYNOPSIS
4833         VOID OOP_DoMethod(OOP_Object *obj, struct pHidd_BitMap_UpdateRect *msg);
4834
4835         VOID HIDD_BM_UpdateRect(OOP_Object *obj, WORD x, WORD y, WORD width, WORD height);
4836
4837     LOCATION
4838         hidd.graphics.bitmap
4839
4840     FUNCTION
4841         Update displayed image of the given rectangle.
4842
4843         Some drivers (like VGA and VESA) may work not with VRAM directly, but with a mirrored
4844         copy of it. Usually it is done in case if VRAM reading is slow. This method is called
4845         by the system after it completes any drawing operation, in order to make sure that
4846         changes made are visible on the actual screen. If your driver uses mirroring, this method
4847         should copy the given rectangle (at least) from the mirror buffer to the actual VRAM.
4848
4849         This method is also called after changing currently visible bitmap (after moHidd_Gfx_Show
4850         method call) in order to allow the mirroring driver to refresh the screen after current bitmap
4851         changed. Note that moHidd_Gfx_ShowViewPorts is very different and moHidd_BitMap_UpdateRect
4852         will not be called if it succeeded!
4853
4854     INPUTS
4855         obj    - an object whose image to refresh
4856         x, y   - A top-left edge of the rectangle to refresh
4857         width  - Width of the rectangle to refresh
4858         height - Height of the rectangle to refresh
4859
4860     RESULT
4861         None.
4862
4863     NOTES
4864         This method is called also on offscreen bitmaps. You should track visible state of your bitmap
4865         and ignore these calls if it's not currently visible on the screen.
4866
4867     EXAMPLE
4868
4869     BUGS
4870
4871     SEE ALSO
4872
4873     INTERNALS
4874
4875 *****************************************************************************************/
4876
4877 VOID BM__Hidd_BitMap__UpdateRect(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_UpdateRect *msg) {
4878     /* baseclass version does nothing */
4879     return;
4880 }
4881
4882 /****************************************************************************************/
4883
4884 /*
4885  * Private methods follow.
4886  * They are implemented as non-virtual, for speed up.
4887  */
4888
4889 /* This is a private form of Set method. Doesn't need a standard message. */
4890 void BM__Hidd_BitMap__SetBitMapTags(OOP_Class *cl, OOP_Object *o, struct TagItem *bitMapTags)
4891 {
4892     struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
4893     struct HIDDBitMapData *data = OOP_INST_DATA(cl, o);
4894     struct TagItem *tag;
4895
4896     while ((tag = NextTagItem(&bitMapTags)))
4897     {
4898         ULONG idx;
4899
4900         if (IS_BITMAP_ATTR(tag->ti_Tag, idx))
4901         {
4902             switch (idx)
4903             {
4904             case aoHidd_BitMap_Width:
4905                 data->width = tag->ti_Data;
4906                 break;
4907
4908             case aoHidd_BitMap_Height:
4909                 data->height = tag->ti_Data;
4910                 break;
4911
4912             case aoHidd_BitMap_BytesPerRow:
4913                 data->bytesPerRow = tag->ti_Data;
4914                 break;
4915             }
4916         }
4917     }
4918 }
4919
4920 /*
4921  * Updates bitmap's pixelformat.
4922  * Used from within planarbm subclass, and would be extremely dangerous to expose
4923  * as setable aHidd_BitMap_PixFmt, so implemented as a separate method.
4924  */
4925 void BM__Hidd_BitMap__SetPixFmt(OOP_Class *cl, OOP_Object *o, OOP_Object *pf)
4926 {
4927     struct HIDDBitMapData *data = OOP_INST_DATA(cl, o);
4928
4929     /* Already a pixfmt registered? */
4930     if (data->pf_registered)
4931         GFX__Hidd_Gfx__ReleasePixFmt(CSD(cl)->gfxhiddclass, data->prot.pixfmt);
4932
4933     /* Remember the new pixelformat */
4934     data->prot.pixfmt = pf;
4935
4936     /*
4937      * This pixelformat was obtained using GFX__Hidd_Gfx__RegisterPixFmt().
4938      * It increases number of pixfmt users, so we'll need to release it when
4939      * not used any more.
4940      */
4941     data->pf_registered = TRUE;
4942 }