chiark - git - mdw - ssr/blob - StraySrc/SapphToys/!ColDemo/s/rgb

   1 ;
   2 ; rgb.s
   3 ;
   4 ; Handling the RGB colour model dialogue box
   5 ;
   6 ; © 1994 Straylight
   7 ;
   8
   9 ;----- Standard header ------------------------------------------------------
  10
  11                 GET     libs:header
  12                 GET     libs:swis
  13
  14                 GET     libs:stream
  15
  16 ;----- External dependencies ------------------------------------------------
  17
  18                 GET     sapphire:dbox
  19                 GET     sapphire:divide
  20                 GET     sapphire:idle
  21                 GET     sapphire:roVersion
  22                 GET     sapphire:screen
  23                 GET     sapphire:win
  24
  25                 GET     sapphire:dbx.dbx
  26                 GET     sapphire:dbx.arrow
  27                 GET     sapphire:dbx.numWrite
  28                 GET     sapphire:dbx.slider
  29
  30                 GET     sapphire:_cs.kernel
  31                 GET     sapphire:_cs.vars
  32
  33 ;----- Main code ------------------------------------------------------------
  34
  35                 AREA    |Sapphire$$Code|,CODE,READONLY
  36
  37 ; --- rgb_open ---
  38 ;
  39 ; On entry:     --
  40 ;
  41 ; On exit:      --
  42 ;
  43 ; Use:          Called by the colour picker
  44
  45                 EXPORT  rgb_open
  46 rgb_open        ROUT
  47
  48                 STMFD   R13!,{R1-R3,R14}        ;Stack the link register
  49                 ADR     R0,rgb__dbName          ;Point to dialogue box name
  50                 BL      dbox_create             ;Create the dialogue box
  51                 LDMVSFD R13!,{R1-R3,PC}         ;Return now if it failed
  52                 STR     R0,[R13,#-4]!           ;Return dialogue handle in R0
  53
  54                 ; --- Attach event handlers and things ---
  55
  56                 ADR     R1,rgb__dbHandler       ;Point to my handler code
  57                 MOV     R2,R10                  ;Pass colour workspace in R10
  58                 MOV     R3,R12                  ;Pass my workspace in R12
  59                 BL      dbox_eventHandler       ;Register my event handler
  60                 ADR     R1,rgb__dbxDef          ;Point to the control defn
  61                 BL      dbx_declare             ;Declare it to dbx nicely
  62
  63                 ; --- Set up the workspace ---
  64
  65                 MOV     R0,#0                   ;Set the Red mapping
  66                 BL      rgb__setMapping         ;Set this as the mapping
  67
  68                 ; --- Set up the dialogue box ---
  69
  70                 LDR     R0,[R13,#0]             ;Load the dialogue handle
  71                 LDR     R1,rgb__mapping         ;Get the current mapping
  72                 ADD     R1,R1,R1,LSL #2         ;Multiply by icon offset (5)
  73                 ADD     R1,R1,#rgbIcon__radioR  ;Add on to get icon number
  74                 MOV     R2,#1                   ;Please select this icon
  75                 BL      dbox_select             ;Select the right one
  76
  77                 MOV     R1,#rgbIcon__writeR     ;Get the red writable icon
  78                 LDR     R2,rgb__red             ;Find the red value
  79                 LDR     R2,[R2,#0]              ;Load the red value
  80                 BL      numWrite_set            ;Set it in the icon
  81
  82                 MOV     R1,#rgbIcon__writeG     ;Get the green writable icon
  83                 LDR     R2,rgb__green           ;Find the green value
  84                 LDR     R2,[R2,#0]              ;Load the green value
  85                 BL      numWrite_set            ;Set it in the icon
  86
  87                 MOV     R1,#rgbIcon__writeB     ;Get the blue writable icon
  88                 LDR     R2,rgb__blue            ;Find the blue value
  89                 LDR     R2,[R2,#0]              ;Load the blue value
  90                 BL      numWrite_set            ;Set it in the icon
  91                 LDMFD   R13!,{R0-R3,R14}        ;Return to caller
  92
  93 rgb__dbName     DCB     "rgb",0
  94
  95 rgb__dbxDef     CONTROL rgbIcon__square,rgbSquare,R10,0,0
  96                 ECTRL
  97
  98                 SLIDER  rgbIcon__slide1,R10,:INDEX: rgb__sl1Val,                                        slFlag_horizontal + slFlag_colData,0,0,1,100
  99                 NUMWRT  rgbIcon__writeR,0,100
 100                 ARROW   rgbIcon__upR,1
 101                 ARROW   rgbIcon__downR,-1
 102
 103                 SLIDER  rgbIcon__slide2,R10,:INDEX: rgb__sl2Val,                                        slFlag_vertical + slFlag_colData,0,0,1,100
 104                 NUMWRT  rgbIcon__writeG,0,100
 105                 ARROW   rgbIcon__upG,1
 106                 ARROW   rgbIcon__downG,-1
 107
 108                 SLIDER  rgbIcon__slide3,R10,:INDEX: rgb__sl3Val,                                        slFlag_vertical + slFlag_colData,0,0,1,100
 109                 NUMWRT  rgbIcon__writeB,0,100
 110                 ARROW   rgbIcon__upB,1
 111                 ARROW   rgbIcon__downB,-1
 112
 113                 DBXEND
 114
 115 ; --- rgb__dbHandler ---
 116 ;
 117 ; On entry:     R0 == dialogue box event code
 118 ;               R1-R7 == depend on the event
 119 ;               R9 == dialogue box handle of RGB panel
 120 ;               R10 == pointer to colour selector workspace
 121 ;               R12 == nothing much
 122 ;
 123 ; On exit:      --
 124 ;
 125 ; Use:          Handles events for the RGB panel.
 126
 127 rgb__dbHandler  ROUT
 128
 129                 ; --- Dispatch events to their destinations ---
 130
 131                 CMP     R0,#rgbIcon__radioR     ;Is it the red view button?
 132                 CMPNE   R0,#rgbIcon__radioG     ;Or the green view button?
 133                 CMPNE   R0,#rgbIcon__radioB     ;Or the blue view button?
 134                 BEQ     rgb__setView            ;Yes -- set the new view
 135
 136                 CMP     R0,#csEvent__close      ;Is it a close panel event?
 137                 BEQ     rgb__closePanel         ;Yes -- destroy the dialogue
 138
 139                 CMP     R0,#csEvent__newRes     ;Is it a resolution change?
 140                 BEQ     rgb__newRes             ;Yes -- update the piccy then
 141
 142                 CMP     R0,#slider_event        ;Is it a slider event?
 143                 BEQ     rgb__slChange           ;Yes -- do something then
 144
 145                 CMP     R0,#numWrite_event      ;Is it a writable event?
 146                 BEQ     rgb__wrChange           ;Yes -- do something then
 147
 148                 CMP     R0,#arrow_event         ;Is it an arrow event?
 149                 BEQ     rgb__arChange           ;Yes -- do something then
 150
 151                 STMFD   R13!,{R14}              ;Save a register
 152                 SUB     R14,R0,#rgbIcon__wCols  ;Is it a WIMP colour box?
 153                 CMP     R14,#16                 ;Check it's in range
 154                 BLO     rgb__wimpCol            ;Yes -- handle it then
 155
 156                 LDMFD   R13!,{PC}^              ;Unknown -- return to caller
 157
 158                 ; --- Change the panel view ---
 159
 160 rgb__setView    ROUT
 161
 162                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
 163                 CMP     R0,#rgbIcon__radioG     ;Is it the green button?
 164                 MOVLT   R3,#0                   ;Lower -- it must be red
 165                 MOVEQ   R3,#1                   ;Equal -- must be green
 166                 MOVGT   R3,#2                   ;Greater -- must be blue
 167                 LDR     R1,rgb__mapping         ;Get the current mapping
 168                 CMP     R3,R1                   ;Is it the same?
 169                 LDMEQFD R13!,{R0-R3,PC}^        ;Yes -- return now then
 170
 171                 ; --- Select the correct icon ---
 172
 173                 MOV     R0,R9                   ;Load the dialogue handle
 174                 ADD     R1,R1,R1,LSL #2         ;Multiply by icon offset (5)
 175                 ADD     R1,R1,#rgbIcon__radioR  ;Add on to get icon number
 176                 MOV     R2,#0                   ;Please deselect this icon
 177                 BL      dbox_select             ;Select the right one
 178
 179                 ADD     R1,R3,R3,LSL #2         ;Multiply by icon offset (5)
 180                 ADD     R1,R1,#rgbIcon__radioR  ;Add on to get icon number
 181                 MOV     R2,#1                   ;Please select this icon
 182                 BL      dbox_select             ;Select the right one
 183
 184                 ; --- Update the dialogue box sliders etc. ---
 185
 186                 MOV     R0,R9                   ;Get the dialogue box handle
 187                 MOV     R1,#rgbIcon__square     ;Get the colour square
 188                 BL      dbx_qUpdate             ;Get rid of the crosshair
 189                 MOV     R0,R3                   ;Pass mapping number
 190                 BL      rgb__setMapping         ;Redo all the mappings
 191                 BL      rgb__updateSliders      ;And redraw the sliders
 192                 MOV     R0,R9                   ;Get the dialogue box handle
 193                 MOV     R1,#rgbIcon__square     ;Get the colour square
 194                 BL      dbx_update              ;Redraw it nicely
 195                 LDMFD   R13!,{R0-R3,PC}^        ;Return to caller
 196
 197                 ; --- Update the RGB colour cube view ---
 198
 199 rgb__newRes     ROUT
 200
 201                 STMFD   R13!,{R0,R1,R14}        ;Save some registers
 202                 MOV     R0,R9                   ;Get the dialogue handle
 203                 MOV     R1,#rgbIcon__square     ;Get the colour square
 204                 BL      dbx_qUpdate             ;Get rid of the crosshair
 205                 BL      dbx_update              ;Redraw it nicely
 206                 LDMFD   R13!,{R0,R1,PC}^        ;And return to caller
 207
 208                 ; --- Update colour values ---
 209
 210 rgb__slChange   ROUT
 211
 212                 STMFD   R13!,{R0-R2,R4,R14}     ;Save some registers
 213
 214                 ; --- Update the main dialogue's colour pot ---
 215
 216                 BL      rgb__colUpdate          ;Update the colour pot
 217
 218                 ; --- Now update the writable icon ---
 219
 220                 LDR     R2,[R13,#8]             ;Load the slider icon
 221                 SUB     R4,R2,#rgbIcon__slide1  ;Get the slider axis number
 222                 LDR     R14,rgb__mapping        ;Load the mapping number
 223                 SUB     R1,R14,R4               ;Find the table index
 224                 ADR     R14,rgb__writeTbl+2     ;Point to the table
 225                 LDRB    R1,[R14,R1]             ;Load the icon number
 226                 MOV     R0,R9                   ;Put dialogue handle in R0
 227                 MOV     R2,R3                   ;Put slider value in R2
 228                 BL      numWrite_set            ;And put it in the icon
 229
 230                 ; --- Now work out what else to update ---
 231
 232                 CMP     PC,#0                   ;Clear the Z flag
 233                 BL      cs_immediate            ;Are we doing immediate ops?
 234                 LDRCC   R14,[R13,#4]            ;Load the subreason code
 235                 CMPCC   R14,#slider_sliding     ;Is the slider going still?
 236                 BLNE    rgb__zUpdate            ;No -- redraw colour square
 237
 238                 BL      rgb__xyUpdate           ;Now move the crosshair
 239
 240 90rgb__slChange LDMFD   R13!,{R0-R2,R4,PC}^     ;Return to caller
 241
 242 rgb__writeTbl   DCB     rgbIcon__writeR
 243                 DCB     rgbIcon__writeG
 244                 DCB     rgbIcon__writeB
 245                 DCB     rgbIcon__writeR
 246                 DCB     rgbIcon__writeG
 247
 248                 ; --- He typed something into one of our icons ---
 249
 250 rgb__wrChange   ROUT
 251
 252                 STMFD   R13!,{R0-R5,R14}        ;Save some registers
 253
 254                 ; --- First, find the value this writable applies to ---
 255
 256                 CMP     R1,#rgbIcon__writeG     ;Which writable icon is it?
 257                 MOVLT   R1,#0                   ;Red -- remember this map
 258                 MOVEQ   R1,#1                   ;Green -- remember this
 259                 MOVGT   R1,#2                   ;Blue -- remember this
 260                 ADR     R14,rgb__red            ;Point to the mappings
 261                 LDR     R14,[R14,R1,LSL #2]     ;Translate the colour
 262                 LDR     R0,[R14,#0]             ;Load the actual value
 263                 SUBS    R5,R0,R3                ;Is this our value?
 264
 265                 ; --- He's changed the value -- update slider/colour ---
 266
 267                 STRNE   R3,[R14,#0]             ;Save the new value away
 268                 BLNE    rgb__colUpdate          ;Redraw the colour pot
 269                 LDR     R0,rgb__mapping         ;Load the mapping number
 270                 SUB     R3,R1,R0                ;Work out the table index
 271                 ADR     R14,rgb__slideTbl+2     ;Point to slider icon table
 272                 LDRB    R1,[R14,R3]             ;Load the icon number
 273                 LDR     R0,cs__modelDb          ;Load the panel dialogue
 274                 BLNE    dbx_update              ;Redraw the slider nicely
 275
 276                 ; --- Update the main piccy ---
 277
 278                 CMPEQ   PC,#0                   ;Clear the Z flag
 279                 BL      cs_immediate            ;Are we doing immediate ops?
 280                 CMPCC   R2,#numWrite_change     ;Is he just typing numbers?
 281                 BLNE    rgb__zUpdate            ;No -- redraw colour square
 282
 283                 BL      rgb__xyUpdate           ;Now move the crosshair
 284
 285 90rgb__wrChange LDMFD   R13!,{R0-R5,PC}^        ;Return to caller
 286
 287 rgb__slideTbl   DCB     rgbIcon__slide2
 288                 DCB     rgbIcon__slide1
 289                 DCB     rgbIcon__slide3
 290                 DCB     rgbIcon__slide2
 291                 DCB     rgbIcon__slide1
 292
 293 rgb__arChange   ROUT
 294
 295                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
 296                 MOV     R4,R2                   ;Look after the bump
 297
 298                 ; --- First, find the value this arrow applies to ---
 299
 300                 CMP     R1,#rgbIcon__upG        ;Which writable icon is it?
 301                 CMPGT   R1,#rgbIcon__downG      ;There's two for green
 302                 MOVLT   R3,#0                   ;Red -- remember this map
 303                 MOVEQ   R3,#1                   ;Green -- remember this
 304                 MOVGT   R3,#2                   ;Blue -- remember this
 305
 306                 ; --- Now bump the required writable icon ---
 307
 308                 ADR     R14,rgb__writeTbl       ;Point to the icon table
 309                 LDRB    R1,[R14,R3]             ;Load the correct icon
 310                 MOV     R0,R9                   ;Pass dialogue in R0
 311                 BL      numWrite_bump           ;Apply the bump value
 312
 313                 ; --- Now perform the update operation ---
 314
 315                 CMPEQ   PC,#0                   ;Clear the Z flag
 316                 BL      cs_immediate            ;Are we doing immediates?
 317                 TEQCS   R4,#0                   ;And is the bump sensible?
 318                 BEQ     %90rgb__arChange        ;Immediate/end ==> return
 319                 MOV     R3,R2                   ;Get value in R3 nicely
 320                 MOVCS   R2,#1                   ;Update always if immediate
 321                 MOVCC   R2,#0                   ;Default is no update if not
 322                 TEQ     R4,#0                   ;And is the bump sensible?
 323                 MOVEQ   R2,#1                   ;No -- then force update
 324                 BL      rgb__wrChange           ;Handle writable update then
 325
 326 90rgb__arChange LDMFD   R13!,{R0-R4,PC}^        ;And return to caller
 327
 328                 LTORG
 329
 330                 ; --- Close the panel to open a new one ---
 331
 332 rgb__closePanel ROUT
 333
 334                 STMFD   R13!,{R0,R14}           ;Save some registers
 335                 MOV     R0,R9                   ;Get the dialogue handle
 336                 BL      dbox_destroy            ;Kill off the dialogue
 337                 LDMFD   R13!,{R0,PC}^           ;And return to caller
 338
 339                 ; --- Handle a click on one of the WIMP colours ---
 340                 ;
 341                 ; The WIMP colour number resides in R14 at the moment :-/
 342
 343 rgb__wimpCol    ROUT
 344
 345                 STMFD   R13!,{R0,R1}            ;Save some registers
 346                 SUB     R13,R13,#80             ;Make space for palette block
 347                 MOV     R1,R13                  ;Point to my block
 348                 SWI     Wimp_ReadPalette        ;Read the WIMP palette
 349                 LDR     R1,[R13,R14,LSL #2]     ;Load the one we want
 350                 ADD     R13,R13,#80             ;Don't need this now
 351
 352                 ; --- Under RISC OS <3.50, bodge palette entry ---
 353                 ;
 354                 ; Because of Acorn stupidity, the ReadPalette values have
 355                 ; blank lower nibbles.  According to Acorn, I must copy the
 356                 ; top nibbles into the bottom ones for ColourTrans to be
 357                 ; happy.  I assume that this has been sorted out on 3.50 and
 358                 ; later.
 359
 360                 BL      rov_version             ;Get the RISC OS version
 361                 CMP     R0,#340                 ;It's almost 350 :-)
 362                 LDRLO   R14,=&F0F0F000          ;A nibble mask
 363                 ANDLO   R1,R1,R14               ;Clear bottom nibbles
 364                 ORRLO   R1,R1,R1,LSR #4         ;And duplicate top in bottom
 365
 366                 STR     R1,cs__colour+col_rgb   ;Save this new colour
 367                 BL      rgb__setValues          ;And redo everything nicely
 368                 LDMFD   R13!,{R0,R1,PC}^        ;And return to caller
 369
 370                 LTORG
 371
 372 ; --- rgb__setValues ---
 373 ;
 374 ; On entry:     R10 == address of colour selector instance data
 375 ;
 376 ; On exit:      --
 377 ;
 378 ; Use:          Updates all the values in the dialogue box from the colour
 379 ;               word in the workspace (which is assumed to have changed).
 380 ;               The colour mapping is assumed to still be valid, though.
 381
 382 rgb__setValues  ROUT
 383
 384                 STMFD   R13!,{R0-R2,R14}        ;Save some registers
 385
 386                 ; --- Unpack the value from the colour RGB word ---
 387
 388                 BL      rgb__unpack             ;Get the percentages out
 389
 390                 ; --- Do the writable icons ---
 391
 392                 LDR     R0,cs__modelDb          ;Get the dialogue handle
 393                 MOV     R1,#rgbIcon__writeR     ;Get the red writable icon
 394                 LDR     R2,rgb__red             ;Find the red value
 395                 LDR     R2,[R2,#0]              ;Load the red value
 396                 BL      numWrite_set            ;Set it in the icon
 397
 398                 MOV     R1,#rgbIcon__writeG     ;Get the green writable icon
 399                 LDR     R2,rgb__green           ;Find the green value
 400                 LDR     R2,[R2,#0]              ;Load the green value
 401                 BL      numWrite_set            ;Set it in the icon
 402
 403                 MOV     R1,#rgbIcon__writeB     ;Get the blue writable icon
 404                 LDR     R2,rgb__blue            ;Find the blue value
 405                 LDR     R2,[R2,#0]              ;Load the blue value
 406                 BL      numWrite_set            ;Set it in the icon
 407
 408                 ; --- Now do the other controls ---
 409
 410                 BL      rgb__updateSliders      ;Do the slider update
 411                 BL      cs_colChange            ;Redraw main colour pot
 412                 BL      rgb__zUpdate            ;Force a recache of z
 413                 BL      rgb__xyUpdate           ;And a recache of x and y
 414                 LDMFD   R13!,{R0-R2,PC}^        ;And return to caller
 415
 416                 LTORG
 417
 418 ; --- rgb__updateSliders ---
 419 ;
 420 ; On entry:     R10 == address of colour selector instance data
 421 ;
 422 ; On exit:      --
 423 ;
 424 ; Use:          Redraws all the sliders.  Because the slider code is so
 425 ;               amazingly intelligent, if the values haven't changed, the
 426 ;               picture you see won't change either.
 427
 428 rgb__updateSliders ROUT
 429
 430                 STMFD   R13!,{R0,R1,R14}        ;Save some registers
 431                 LDR     R0,cs__modelDb          ;Get the dialogue handle
 432                 MOV     R1,#rgbIcon__slide1     ;Get slider 1's number
 433                 BL      dbx_update              ;Redraw it quickly
 434                 MOV     R1,#rgbIcon__slide2     ;Get slider 2's number
 435                 BL      dbx_update              ;Redraw it quickly
 436                 MOV     R1,#rgbIcon__slide3     ;Get slider 3's number
 437                 BL      dbx_update              ;Redraw it quickly
 438                 LDMFD   R13!,{R0,R1,PC}^        ;And return to caller
 439
 440                 LTORG
 441
 442 ; --- rgb__setMapping ---
 443 ;
 444 ; On entry:     R0 == rotation number (i.e. which colour is on z azis)
 445 ;
 446 ; On exit:      --
 447 ;
 448 ; Use:          Sets up the workspace so that the dialogue box displays the
 449 ;               correct mapping.
 450
 451 rgb__setMapping ROUT
 452
 453                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
 454
 455                 ; --- Reset the mapping number and table ---
 456
 457                 STR     R0,rgb__mapping         ;Save the mapping number
 458                 ADR     R1,rgb__mappingTbl      ;Point to the table
 459                 ADD     R1,R1,R0                ;Index it nicely
 460
 461                 LDRB    R14,[R1],#1             ;Load the blue offset
 462                 ADD     R14,R10,R14             ;Add it to workspace ptr
 463                 STR     R14,rgb__blue           ;And store nicely
 464                 MOV     R2,#8                   ;The blue slider colour
 465                 STR     R2,[R14,#4]             ;Save it in the table
 466
 467                 LDRB    R14,[R1],#1             ;Load the green offset
 468                 ADD     R14,R10,R14             ;Add it to workspace ptr
 469                 STR     R14,rgb__green          ;And store nicely
 470                 MOV     R2,#10                  ;The green slider colour
 471                 STR     R2,[R14,#4]             ;Save it in the table
 472
 473                 LDRB    R14,[R1],#1             ;Load the red offset
 474                 ADD     R14,R10,R14             ;Add it to workspace ptr
 475                 STR     R14,rgb__red            ;And store nicely
 476                 MOV     R2,#11                  ;The red slider colour
 477                 STR     R2,[R14,#4]             ;Save it in the table
 478
 479                 BL      rgb__unpack             ;Unpack colour def now
 480
 481                 ; --- Set up the cached values for the diagram ---
 482
 483                 LDR     R14,rgb__sl1Val         ;Load the x value
 484                 STR     R14,rgb__xPos           ;Save it in the cache
 485                 LDR     R14,rgb__sl2Val         ;Load the y value
 486                 STR     R14,rgb__yPos           ;Save it in the cache
 487                 LDR     R14,rgb__sl3Val         ;Load the z value
 488                 STR     R14,rgb__zPos           ;Save it in the cache
 489
 490                 LDMFD   R13!,{R0-R3,PC}^        ;Return to caller
 491
 492                 LTORG
 493
 494                 ; --- The mapping table ---
 495                 ;
 496                 ; The table is done twice, to give it a `wraparound' effect.
 497
 498 rgb__mappingTbl DCB     :INDEX: rgb__sl1Val
 499                 DCB     :INDEX: rgb__sl2Val
 500                 DCB     :INDEX: rgb__sl3Val
 501                 DCB     :INDEX: rgb__sl1Val
 502                 DCB     :INDEX: rgb__sl2Val
 503
 504 ; --- rgb__unpack ---
 505 ;
 506 ; On entry:     R10 == address of colour selector instance data
 507 ;
 508 ; On exit:      --
 509 ;
 510 ; Use:          Unpacks the colour definition in the cs data into the
 511 ;               slider values.
 512
 513 rgb__unpack     ROUT
 514
 515                 STMFD   R13!,{R0-R2,R14}        ;Save some workspace
 516                 LDR     R2,cs__colour+col_rgb   ;Get the colour nicely
 517
 518                 ; --- Set up the blue slider ---
 519
 520                 MOV     R0,R2,LSR #24           ;Get the blue colour value
 521                 BL      rgb__colToPerC          ;Convert it to a percentage
 522                 LDR     R14,rgb__blue           ;Load the blue entry address
 523                 STR     R0,[R14]                ;Save the blue value in it
 524
 525                 ; --- Now set up the green one ---
 526
 527                 MOV     R0,R2,LSR #16           ;Get the green colour value
 528                 BL      rgb__colToPerC          ;Convert it to a percentage
 529                 LDR     R14,rgb__green          ;Load the green entry address
 530                 STR     R0,[R14]                ;Save the green value in it
 531
 532                 ; --- Now set up the red one ---
 533
 534                 MOV     R0,R2,LSR #8            ;Get the red colour value
 535                 BL      rgb__colToPerC          ;Convert it to a percentage
 536                 LDR     R14,rgb__red            ;Load the red entry address
 537                 STR     R0,[R14]                ;Save the red value in it
 538                 LDMFD   R13!,{R0-R2,PC}^        ;And return to caller
 539
 540                 LTORG
 541
 542 ; --- rgb__colToPerC ---
 543 ;
 544 ; On entry:     R0 == colour to convert, from 0 to 255
 545 ;
 546 ; On exit:      R0 == colour as a percentage
 547 ;
 548 ; Use:          Converts a colour to a percentage.
 549 ;
 550 ; [Generated by Straylight divc]
 551 ; Modified by MDW to (a) be unsigned, and (b) round to nearest.
 552
 553 rgb__colToPerC  ROUT
 554
 555                 STMFD   R13!,{R1,R14}           ;Save some registers
 556                 AND     R0,R0,#&FF              ;Mask off any other bits
 557                 ADD     R0,R0,R0,LSL #2         ;Multiply by 5 (x5)
 558                 ADD     R0,R0,R0,LSL #2         ;And by 5 again (x25)
 559                 MOV     R0,R0,LSL #2            ;And now by 4 (x100)
 560                 MOV     R1,R0                   ;Keep copy of dividend
 561                 ADD     R0,R0,#127              ;Make it round to nearest
 562                 ADD     R0,R0,R0,LSR #8         ;R0 = R0 x 256/255
 563                 ADD     R0,R0,R0,LSR #16        ;...
 564                 MOV     R0,R0,LSR #8            ;Div by 256 -- R0 = R0 / 255
 565                 RSB     R14,R0,R0,LSL #8        ;Multiply by 255
 566                 SUB     R1,R1,R14               ;Find the difference
 567                 SUBS    R1,R1,#255              ;This is the remainder
 568                 ADDGE   R0,R0,#1                ;If we overshot, bump quot
 569                 ADDLT   R1,R1,#255              ;And chop off remainder
 570                 LDMFD   R13!,{R1,PC}^           ;Return to caller
 571
 572                 LTORG
 573
 574 ; --- rgb__perCToCol ---
 575 ;
 576 ; On entry:     R0 == colour percentage to convert
 577 ;
 578 ; On exit:      R0 == colour value, from 0-255
 579 ;
 580 ; Use:          Converts a percentage to a colour.
 581
 582 rgb__perCToCol  ROUT
 583
 584                 STMFD   R13!,{R1,R14}           ;Save some registers
 585                 RSB     R0,R0,R0,LSL #8         ;Multiply it by 255
 586                 ADD     R0,R0,#50               ;Add 50 to round to nearest
 587                 BL      div10                   ;Divide by 10
 588                 BL      div10                   ;And again (by 100)
 589                 LDMFD   R13!,{R1,PC}^           ;And return to caller
 590
 591                 LTORG
 592
 593 ; --- rgb__colUpdate ---
 594 ;
 595 ; On entry:     --
 596 ;
 597 ; On exit:      --
 598 ;
 599 ; Use:          Updates the main dialogue's colour pot.
 600
 601 rgb__colUpdate  ROUT
 602
 603                 STMFD   R13!,{R0,R2,R14}        ;Save some registers
 604                 MOV     R2,#0                   ;Clear prospective colour
 605
 606                 LDR     R0,rgb__blue            ;Get the blue colour address
 607                 LDR     R0,[R0,#0]              ;Load the blue percentage
 608                 BL      rgb__perCToCol          ;Convert it to a real colour
 609                 ORR     R2,R2,R0,LSL #24        ;Move into R2 nicely
 610
 611                 LDR     R0,rgb__green           ;Get the green colour address
 612                 LDR     R0,[R0,#0]              ;Load the green percentage
 613                 BL      rgb__perCToCol          ;Convert it to a real colour
 614                 ORR     R2,R2,R0,LSL #16        ;Move into R2 nicely
 615
 616                 LDR     R0,rgb__red             ;Get the red colour address
 617                 LDR     R0,[R0,#0]              ;Load the red percentage
 618                 BL      rgb__perCToCol          ;Convert it to a real colour
 619                 ORR     R2,R2,R0,LSL #8         ;Move into R2 nicely
 620
 621                 STR     R2,cs__colour+col_rgb   ;Save this as the new colour
 622                 LDMFD   R13!,{R0,R2,R14}        ;Restore registers
 623                 B       cs_colChange            ;Update the main box's colour
 624
 625                 LTORG
 626
 627 ; --- rgb__zUpdate ---
 628 ;
 629 ; On entry:     --
 630 ;
 631 ; On exit:      --
 632 ;
 633 ; Use:          Updates everything following a change to the current z
 634 ;               value.  It doesn't change the writable icon, but it does
 635 ;               most other things.
 636
 637 rgb__zUpdate    ROUT
 638
 639                 STMFD   R13!,{R0-R2,R14}        ;Save some registers
 640
 641                 ; --- Make sure that the z coordinate changed ---
 642
 643                 LDR     R2,rgb__sl3Val          ;Load current z slider pos
 644                 LDR     R0,rgb__zPos            ;Load the cached position
 645                 CMP     R0,R2                   ;Do they match?
 646                 LDMEQFD R13!,{R0-R2,PC}^        ;Yes -- nothing doing then
 647
 648                 ; --- Remove crosshairs -- it looks nicer ---
 649
 650                 LDR     R0,cs__modelDb          ;Load the model dialogue
 651                 MOV     R1,#rgbIcon__square     ;Get the colour square
 652                 BL      dbx_qUpdate             ;Get rid of the crosshair
 653
 654                 ; --- Now recache the x and y coords to prevent flicker ---
 655
 656                 STR     R2,rgb__zPos            ;Update the cache value
 657                 LDR     R14,rgb__sl1Val         ;Load the current x value
 658                 STR     R14,rgb__xPos           ;Save it away
 659                 LDR     R14,rgb__sl2Val         ;Load the current y value
 660                 STR     R14,rgb__yPos           ;Save it away
 661
 662                 ; --- Redraw the main square ---
 663
 664                 BL      dbx_update              ;Force a redraw of it
 665                 LDMFD   R13!,{R0-R2,PC}^        ;And return to caller
 666
 667                 LTORG
 668
 669 ; --- rgb__xyUpdate ---
 670 ;
 671 ; On entry:     --
 672 ;
 673 ; On exit:      --
 674 ;
 675 ; Use:          Updates things following a change to either the x or y
 676 ;               value.
 677
 678 rgb__xyUpdate   ROUT
 679
 680                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
 681                 LDR     R0,rgb__xPos            ;Load cached x position
 682                 LDR     R1,rgb__yPos            ;Load cached y position
 683                 LDR     R2,rgb__sl1Val          ;And the current x pos
 684                 LDR     R3,rgb__sl2Val          ;And the current y pos
 685                 CMP     R0,R2                   ;Is the cached x right?
 686                 CMPEQ   R1,R3                   ;And is the cached y right?
 687                 LDMEQFD R13!,{R0-R3,PC}^        ;Yes -- return then
 688
 689                 LDR     R0,cs__modelDb          ;Load the dialogue box handle
 690                 MOV     R1,#rgbIcon__square     ;Load the square icon
 691                 BL      dbx_qUpdate             ;Quickly redraw it
 692                 STR     R2,rgb__xPos            ;Recache the x position
 693                 STR     R3,rgb__yPos            ;Recache the y position
 694                 BL      dbx_qUpdate             ;Quickly redraw it
 695                 LDMFD   R13!,{R0-R3,PC}^        ;Return to caller
 696
 697                 LTORG
 698
 699 ;----- Plotting the colour square -------------------------------------------
 700
 701 ; --- rgb_plotSquare ---
 702 ;
 703 ; On entry:     R0 == left hand side of colour square to plot
 704 ;               R1 == bottom edge of colour square to plot
 705 ;               R2 == which rotation we're plotting
 706 ;               R3 == x step to plot in
 707 ;               R4 == y step to plot in
 708 ;               R5 == z-coordinate value (in 16.16 form)
 709 ;               R6 == pointer to graphics window block
 710 ;
 711 ; On exit:      --
 712 ;
 713 ; Use:          Plots a cross-section through the RGB colour cube.
 714
 715                 EXPORT  rgb_plotSquare
 716 rgb_plotSquare  ROUT
 717
 718                 STMFD   R13!,{R0-R12,R14}       ;Save a job-lot of registers
 719
 720                 ; --- Work out the minimum coordinates ---
 721
 722                 LDMIA   R6,{R8,R9,R11,R12}      ;Load the coordinates out
 723                 SUB     R7,R12,R1               ;Translate max y to relative
 724                 SUB     R12,R9,R1               ;Translate min y too
 725                 SUB     R10,R8,R0               ;Translate min x too
 726                 SUB     R11,R11,R0              ;Translate max x
 727
 728                 ; --- See if we can do really clever things ---
 729
 730                 STMFD   R13!,{R0,R11}           ;Save our R11 value
 731                 LDR     R11,[R13,#52]           ;Load the system R11 value
 732                 BL      screen_getInfo          ;Load the screen information
 733                 MOV     R8,R0                   ;Look after this address
 734                 LDMFD   R13!,{R0,R11}           ;Reload our local value
 735                 LDR     R14,[R8,#screen_bpp]    ;Load current bits/pixel
 736                 CMP     R14,#16                 ;Is this a 2byte/pixel mode?
 737                 BEQ     rgb__plot32k            ;Yes -- branch to special bit
 738                 CMP     R14,#32                 ;Is this a 4byte/pixel mode?
 739                 BEQ     rgb__plot16m            ;Yes -- branch to special bit
 740
 741                 ; --- Work out rectangle edges ---
 742
 743                 CMP     R10,#0                  ;Is min x too small?
 744                 MOVLT   R10,#0                  ;Yes -- raise it to 0
 745                 CMP     R12,#0                  ;Is min y too small?
 746                 MOVLT   R12,#0                  ;Yes --- raise that too
 747                 CMP     R11,#255                ;Is the max x too large?
 748                 MOVGT   R11,#255                ;Yes -- reduce it then
 749                 CMP     R7,#255                 ;Is the max y too large?
 750                 MOVGT   R7,#255                 ;Yes -- reduce it then
 751
 752                 SUB     R8,R3,#1                ;Turn the x step to bitmask
 753                 SUB     R9,R4,#1                ;And the same for y step
 754                 BIC     R10,R10,R8              ;Round min x down to step
 755                 BIC     R12,R12,R9              ;And round min y down too
 756                 BIC     R11,R11,R8              ;Round max x down too
 757                 BIC     R7,R7,R9                ;And round down max y
 758
 759                 STMFD   R13!,{R7,R10}           ;Save rel. min x and max y
 760
 761                 ADD     R10,R10,R0              ;Now make min x absolute
 762                 ADD     R12,R12,R1              ;And make min y absolute
 763                 ADD     R11,R11,R0              ;And make max x absolute
 764                 ADD     R7,R7,R1                ;And make max y absolute
 765
 766                 ; --- Now work out the z-value ---
 767
 768                 RSB     R5,R5,R5,LSL #8         ;Multiply value by 255
 769                 ADD     R5,R5,#&8000            ;Make sure we round nicely
 770                 MOV     R5,R5,LSR #16           ;And make it 0-255
 771
 772                 ; --- Work out the exclusive rectangle sizes ---
 773
 774                 STMFD   R13!,{R11}              ;Save our R11 value
 775                 LDR     R11,[R13,#56]           ;Load the system R11 value
 776                 BL      screen_getInfo          ;Load the screen information
 777                 LDMFD   R13!,{R11}              ;Reload our local value
 778
 779                 LDMIA   R0,{R8,R9}              ;Load the eigen factors out
 780                 MOV     R14,#1                  ;This will be shifted around
 781                 SUB     R8,R3,R14,LSL R8        ;Subtract x pixel from x step
 782                 SUB     R9,R4,R14,LSL R9        ;Subtract y pixel from y step
 783
 784                 ; --- Work out all the shift values ---
 785
 786                 CMP     R2,#0                   ;Is this the red rotation?
 787                 MOVEQ   R0,#24                  ;Yes -- then x is blue
 788                 MOVEQ   R1,#16                  ;And y is green
 789                 MOVEQ   R5,R5,LSL #8            ;And z is red
 790
 791                 CMP     R2,#1                   ;Is this the green rotation?
 792                 MOVEQ   R0,#8                   ;Yes -- then x is red
 793                 MOVEQ   R1,#24                  ;And y is blue
 794                 MOVEQ   R5,R5,LSL #16           ;And z is green
 795
 796                 CMP     R2,#2                   ;Is this the blue rotation?
 797                 MOVEQ   R0,#16                  ;Yes -- then x is green
 798                 MOVEQ   R1,#8                   ;And y is red
 799                 MOVEQ   R5,R5,LSL #24           ;And z is blue
 800
 801                 ; --- Set up the initial palette word ---
 802
 803                 LDMFD   R13!,{R14}              ;Load maximum y palette val
 804                 ORR     R5,R5,R14,LSL R1        ;Fit that into the palette
 805
 806                 LDMFD   R13!,{R2}               ;Load minimum x palette val
 807
 808                 ; --- Now for the main plotting loop ---
 809
 810 00              MOV     R6,R10                  ;Start on the left hand side
 811                 MOV     R14,#255                ;Clear out nasty x palette
 812                 BIC     R5,R5,R14,LSL R0        ;Clear out the right byte
 813                 ORR     R5,R5,R2,LSL R0         ;And set up the min value
 814
 815                 ; --- Plot the rectangle nicely ---
 816
 817 10              STMFD   R13!,{R0-R4}            ;Save some registers for this
 818
 819                 ; --- Nothing for it but to use ColourTrans ---
 820
 821                 MOV     R0,R5                   ;Get the palette entry
 822                 MOV     R3,#&100                ;Please try to dither it
 823                 MOV     R4,#0                   ;And have normal GCOL action
 824                 SWI     XColourTrans_SetGCOL    ;Try to set the colour up
 825                 MOVVS   R3,#0                   ;Try again without dithering
 826                 MOVVS   R0,R5                   ;Set the palette word again
 827                 SWIVS   ColourTrans_SetGCOL     ;Set the colour the old way
 828
 829 15              MOV     R0,#4                   ;Move cursor absolute
 830                 MOV     R1,R6                   ;Get the current x coordinate
 831                 MOV     R2,R7                   ;And the current y coordinate
 832                 SWI     OS_Plot                 ;Move the cursor there
 833                 MOV     R0,#97                  ;Rectangle fill relative
 834                 MOV     R1,R8                   ;Rectangle width thingy
 835                 MOV     R2,R9                   ;Rectangle height thingy
 836                 SWI     OS_Plot                 ;Plot the rectangle
 837                 LDMFD   R13!,{R0-R4}            ;Restore a load of registers
 838
 839                 ; --- Now move on to the next square ---
 840
 841                 ADD     R6,R6,R3                ;Add on the x increment
 842                 CMP     R6,R11                  ;Have we gone too far?
 843                 ADDLE   R5,R5,R3,LSL R0         ;No -- add on the palette val
 844                 BLE     %10rgb_plotSquare       ;And go round again
 845
 846                 SUB     R7,R7,R4                ;Subtract the y increment
 847                 CMP     R7,R12                  ;Have we gone too far?
 848                 SUBGE   R5,R5,R4,LSL R1         ;No -- subtract palette val
 849                 BGE     %00rgb_plotSquare       ;And do the next row nicely
 850
 851                 LDMFD   R13!,{R0-R12,PC}^       ;Return to caller
 852
 853                 ; --- Fast colour setting routines ---
 854
 855 20              MOV     R1,R5,LSR #8            ;Get hardware colour value
 856                 MOV     R0,#0                   ;Set the colour
 857                 SWI     OS_SetColour            ;Set the colour really
 858                 B       %15rgb_plotSquare       ;And return to main loop
 859
 860 25              AND     R0,R5,#&F800            ;Get the red bits out
 861                 MOV     R1,R0,LSR #11           ;Shift them down
 862                 AND     R0,R5,#&F80000          ;Get the green bits
 863                 ORR     R1,R1,R0,LSR #14        ;Move them in nicely
 864                 AND     R0,R5,#&F8000000        ;Get the blue bits too
 865                 ORR     R1,R1,R0,LSR #17        ;Move them in too
 866                 MOV     R0,#0                   ;Set a raw colour
 867                 SWI     OS_SetColour            ;Set the colour nicely
 868                 B       %15rgb_plotSquare       ;And return to main loop
 869
 870 30              MOV     R14,#3                  ;Mask bits off quickly
 871                 AND     R0,R14,R5,LSR #12       ;Get the red bits
 872                 AND     R1,R14,R5,LSR #20       ;Get the green bits
 873                 AND     R2,R14,R5,LSR #28       ;And the blue bits
 874                 ADD     R1,R1,R1,LSL #2         ;Multiply green by 5
 875                 ADD     R2,R2,R0,LSL #1         ;Mult red by 2 and add in
 876                 ADD     R2,R2,R1                ;And add in weighted green
 877                 MOV     R1,R2,LSR #3            ;Get weighted average
 878
 879                 AND     R0,R5,#&00C00000        ;Get top two green bits
 880                 ORR     R1,R1,R0,LSR #17        ;Shift into position
 881                 TST     R5,#&00004000           ;Get red bit two
 882                 ORRNE   R1,R1,#&4               ;If set, set in colour
 883                 TST     R5,#&40000000           ;Get blue bit two
 884                 ORRNE   R1,R1,#&8               ;If set, set in colour
 885                 TST     R5,#&00008000           ;Get red bit three
 886                 ORRNE   R1,R1,#&10              ;If set, set in colour
 887                 TST     R5,#&80000000           ;Get blue bit three
 888                 ORRNE   R1,R1,#&80              ;If set, set in colour
 889
 890                 MOV     R0,#0                   ;Set raw colour
 891                 SWI     OS_SetColour            ;Do the colour setting
 892                 B       %15rgb_plotSquare       ;And return to main loop
 893
 894                 LTORG
 895
 896 ; --- rgb__plot32k ---
 897 ;
 898 ; On entry:     R0 == left side of square to plot
 899 ;               R1 == bottom of square to plot
 900 ;               R2 == rotation number
 901 ;               R3 == x step for rectangles
 902 ;               R4 == y step for rectangles
 903 ;               R5 == current z-value (in 16.16)
 904 ;               R6 == pointer to graphics window block
 905 ;               R7 == unlimited relative max y position to plot
 906 ;               R8 == pointer to screen info block
 907 ;               R10 == unlimited relative min x position to plot
 908 ;               R11 == unlimited relative max x position to plot
 909 ;               R12 == unlimited relative min y position to plot
 910 ;               On stack: saved {R0-R12,R14}
 911 ;
 912 ; On exit:      --
 913 ;
 914 ; Use:          Displays an RGB square on the screen at a given location,
 915 ;               in a 16bpp mode, using direct screen access (TM).
 916
 917 rgb__plot32k    ROUT
 918
 919                 ; --- Prologue: Limit the relative box positions ---
 920
 921                 ADD     R8,R8,#screen_dx        ;Find the pixel positions
 922                 LDMIA   R8,{R8,R9}              ;Load them into registers
 923
 924                 CMP     R10,#0                  ;Is min x too small?
 925                 MOVLT   R10,#0                  ;Yes -- raise it to 0
 926                 CMP     R12,#0                  ;Is min y too small?
 927                 MOVLT   R12,#0                  ;Yes --- raise that too
 928                 CMP     R11,#256                ;Is the max x too large?
 929                 MOVGT   R11,#256                ;Yes -- reduce it then
 930                 CMP     R7,#256                 ;Is the max y too large?
 931                 MOVGT   R7,#256                 ;Yes -- reduce it then
 932                 SUB     R11,R11,R8              ;Make this inclusive
 933                 SUB     R7,R7,R9                ;Make this inclusive too
 934
 935                 ; --- Act 1: Find addresses of things on the screen ---
 936
 937                 ADD     R9,R0,R10               ;Work out left hand side
 938                 ADD     R8,R1,R7                ;Work out top of area
 939                 SUB     R10,R11,R10             ;Work out width of area
 940                 SUB     R7,R7,R12               ;And the height too
 941
 942                 SUB     R12,R9,R0               ;Work out left offset again
 943                 SUB     R11,R8,R1               ;And the top offset too
 944
 945                 SUB     R13,R13,#20             ;Space for our vdu vars
 946                 ADR     R0,rgb__vduVars         ;Point to the var numbers
 947                 MOV     R1,R13                  ;Point to our output block
 948                 SWI     OS_ReadVduVariables     ;Get the values nicely
 949
 950                 ; --- Interlude: Set up rectangle sizes ---
 951
 952                 CMP     R3,#8                   ;Make sure rectangles are >8
 953                 MOVCC   R3,#8                   ;If not, make them bigger
 954                 MOVCC   R4,#8                   ;(Width and height the same)
 955                 MOV     R14,R3,LSR #3           ;Work out colour increment
 956
 957                 ; --- Reprise: Convert measurements to pixels ---
 958
 959                 LDMIA   R13!,{R0,R1}            ;Load the x and y eig things
 960                 MOV     R3,R3,LSR R0            ;Convert pixel counters
 961                 MOV     R4,R4,LSR R1            ;Convert other pixel counter
 962                 MOV     R9,R9,LSR R0            ;Convert left hand side
 963                 MOV     R10,R10,LSR R0          ;Convert width of area
 964                 MOV     R7,R7,LSR R1            ;Convert area height
 965                 MOV     R8,R8,LSR R1            ;And the top position
 966
 967                 ; --- Intermission: Pack up pixel counters ---
 968                 ;
 969                 ; We pack all this into a word containing the following:
 970                 ;
 971                 ; bits 31-24 == x counter reset value
 972                 ; bits 23-20 == y counter initial value
 973                 ; bits 19-16 == x counter initial value
 974                 ; bits 15- 8 == y counter reset value
 975                 ; bits  7- 0 == colour step value
 976                 ;
 977                 ; Can anyone say `Z80 programming techniques'?
 978
 979                 MOV     R12,R12,LSR R0          ;Get left offset in pixels
 980                 SUB     R6,R3,#1                ;Get the h pixel count -1
 981                 AND     R0,R12,R6               ;Get the remainder thing
 982                 SUB     R0,R3,R0                ;And get the correct offset
 983
 984                 ORR     R3,R4,R3,LSL #16        ;Pack x and y counters
 985                 ORR     R3,R14,R3,LSL #8        ;And move in the colour inc
 986
 987                 RSB     R14,R11,#256            ;Get offset from top
 988                 MOV     R11,R11,LSR R1          ;Turn offset into pixels
 989                 MOV     R1,R14,LSR R1           ;Get top offset in pixels
 990                 SUB     R1,R1,#1                ;Subtract one for niceness
 991                 SUB     R6,R4,#1                ;Get the v pixel count -1
 992                 AND     R1,R1,R6                ;Get the remainder thing
 993                 SUB     R1,R4,R1                ;And get the correct offset
 994                 ORR     R0,R0,R1,LSL #4         ;Pack into 1 byte
 995
 996                 ORR     R3,R3,R0,LSL #16        ;Put in initial values too
 997
 998                 LDMIA   R13!,{R0,R1,R6}         ;Load other vdu vars
 999                 SUB     R14,R1,R8               ;Shift origin to top left
1000                 MLA     R0,R14,R6,R0            ;Work out address of row
1001                 ADD     R9,R0,R9,LSL #1         ;Work out left address
1002                 ADD     R8,R9,R10,LSL #1        ;Work out right hand side too
1003
1004                 ; --- Act 2: Set up colour information ---
1005
1006                 AND     R14,R3,#&FF             ;Get the colour step value
1007                 BIC     R10,R3,#&FF             ;Move packed init values away
1008
1009                 RSB     R5,R5,R5,LSL #8         ;Multiply z value by 255
1010                 MOV     R5,R5,LSR #19           ;And make it 0-31
1011
1012                 AND     R3,R10,#&FF000000       ;Get the x pixel count reinit
1013                 SUB     R3,R3,#&01000000        ;Turn it into a bitmask
1014                 BIC     R3,R12,R3,LSR #24       ;Round colour down nicely
1015                 LDR     R12,[R13,#-20]          ;Get the xeig factor
1016                 MOV     R3,R3,LSL R12           ;Shift colour up to OS units
1017                 MOV     R3,R3,LSR #3            ;Get the x colour in 0-31
1018
1019                 AND     R4,R10,#&0000FF00       ;Get the y pixel count reinit
1020                 SUB     R4,R4,#&00000100        ;Turn it into a bitmask
1021                 BIC     R4,R11,R4,LSR #8        ;Round colour down nicely
1022                 LDR     R11,[R13,#-16]          ;Get the yeig factor
1023                 MOV     R4,R4,LSL R11           ;Shift colour up to OS units
1024                 MOV     R4,R4,LSR #3            ;And the y one too please
1025
1026                 MOV     R12,#&1F                ;This is a useful value
1027
1028                 CMP     R2,#0                   ;Is this the red rotation?
1029                 MOVEQ   R0,R5,LSL #16           ;Build the colour up...
1030                 ORREQ   R0,R0,R4,LSL #21        ;Still doing that...
1031                 ORREQ   R0,R0,R3,LSL #26        ;Almost finished now...
1032                 MOVEQ   R1,R3,LSL #26           ;And the x-init value
1033                 MOVEQ   R3,R14,LSL #21          ;Get the y increment right
1034                 MOVEQ   R4,R14,LSL #26          ;And the x increment
1035                 MOVEQ   R5,R12,LSL #26          ;Get the x-clear mask
1036
1037                 CMP     R2,#1                   ;Is this the green rotation?
1038                 MOVEQ   R0,R3,LSL #16           ;Build the colour up...
1039                 ORREQ   R0,R0,R5,LSL #21        ;Still doing that...
1040                 ORREQ   R0,R0,R4,LSL #26        ;Almost finished now...
1041                 MOVEQ   R1,R3,LSL #16           ;And the x-init value
1042                 MOVEQ   R3,R14,LSL #26          ;Get the y increment right
1043                 MOVEQ   R4,R14,LSL #16          ;And the x increment
1044                 MOVEQ   R5,R12,LSL #16          ;Get the x-clear mask
1045
1046                 CMP     R2,#2                   ;Is this the blue rotation?
1047                 MOVEQ   R0,R4,LSL #16           ;Build the colour up...
1048                 ORREQ   R0,R0,R3,LSL #21        ;Still doing that...
1049                 ORREQ   R0,R0,R5,LSL #26        ;Almost finished now...
1050                 MOVEQ   R1,R3,LSL #21           ;Get the x-init value
1051                 MOVEQ   R3,R14,LSL #16          ;Get the y increment right
1052                 MOVEQ   R4,R14,LSL #21          ;And the x increment
1053                 MOVEQ   R5,R12,LSL #21          ;Get the x-clear mask
1054
1055                 ; --- Act 3. Initialise the pixel counts ---
1056
1057                 MOV     R14,#&F                 ;For reading nibbles
1058                 AND     R12,R14,R10,LSR #16     ;Get the initial x value
1059                 AND     R2,R14,R10,LSR #20      ;Get the initial y value too
1060                 ORR     R2,R10,R2               ;Put that into the count reg
1061                 SWI     OS_EnterOS              ;Avoid problems with PhysMem
1062
1063                 ; --- Act 4. Plot the bloody thing ---
1064
1065 10rgb__plot32k  MOV     R10,R9                  ;Get the current address
1066                 MOV     R11,#0                  ;Clear the buffer value
1067                 STMFD   R13!,{R12}              ;Save the x count value
1068
1069                 ; --- Start plotting this row ---
1070
1071                 TST     R10,#2                  ;Is this address aligned?
1072                 BEQ     %20rgb__plot32k         ;Yes -- start at main loop
1073                 LDR     R14,[R10,#-2]           ;No -- load word from here
1074                 MOV     R14,R14,LSL #16         ;Shift all the way up
1075                 ORR     R14,R0,R14,LSR #16      ;Build the replacement word
1076                 STR     R14,[R10,#-2]           ;And store in frame buffer
1077                 B       %25rgb__plot32k         ;Jump to end of loop
1078
1079                 ; --- Main row plotting loop (time critical :-) ) ---
1080
1081 20rgb__plot32k  ORR     R11,R0,R11,LSR #16      ;Add colour into buffer
1082                 TST     R10,#2                  ;Is this an odd address?
1083                 STRNE   R11,[R10,#-2]           ;Yes -- done both halfwords
1084
1085 25rgb__plot32k  ADD     R10,R10,#2              ;Move on to next pixel
1086                 CMP     R10,R8                  ;Have we finished yet?
1087                 BHI     %30rgb__plot32k         ;No -- do the rest then
1088                 SUBS    R12,R12,#1              ;Decrement pixel counter
1089                 ADDEQ   R0,R0,R4                ;If cleared, add on colour
1090                 MOVEQ   R12,R2,LSR #24          ;And reinitialise counter
1091                 B       %20rgb__plot32k         ;Go round for more
1092
1093                 ; --- We've finished; do we have a halfword left over? ---
1094
1095 30rgb__plot32k  TST     R10,#2                  ;Is the address odd?
1096                 LDRNE   R14,[R10,#-2]           ;Yes -- read the old word
1097                 MOVNE   R11,R11,LSR #16         ;Get buffer value in low hw
1098                 MOVNE   R14,R14,LSR #16         ;Get screen value in low hw
1099                 ORRNE   R14,R11,R14,LSL #16     ;Build correct word to write
1100                 STRNE   R14,[R10,#-2]           ;Store this word away
1101
1102                 ; --- Now move on to the next row ---
1103
1104                 LDMFD   R13!,{R12}              ;Unstack initial x counter
1105                 ADD     R9,R9,R6                ;Move start address down 1
1106                 ADD     R8,R8,R6                ;Move end address down 1
1107                 BIC     R0,R0,R5                ;Clear the x colour section
1108                 ORR     R0,R0,R1                ;Reintialise the x colour
1109                 SUB     R2,R2,#1                ;Decrement y counter
1110                 TST     R2,#&FF                 ;Is it now zero?
1111                 BICEQ   R2,R2,#&00FF0000        ;Clear unused byte in word
1112                 ORREQ   R2,R2,R2,LSR #8         ;Yes -- reinitialise
1113                 SUBEQ   R0,R0,R3                ;And increment the y colour
1114                 SUBS    R7,R7,#1                ;Decrement scan line counter
1115                 BCS     %10rgb__plot32k         ;And go back up again
1116
1117                 TEQP    PC,#0                   ;Return to user mode
1118                 MOV     R0,R0                   ;Keep ARM ecstatically happy
1119                 LDMFD   R13!,{R0-R12,PC}^       ;Return to caller
1120
1121 rgb__vduVars    DCD     4,5                     ;X and Y eigen factors
1122                 DCD     149                     ;Start of display memory
1123                 DCD     12                      ;How high is the screen
1124                 DCD     6                       ;Width of scan line in pixels
1125                 DCD     -1
1126
1127                 LTORG
1128
1129 ; --- rgb__plot16m ---
1130 ;
1131 ; On entry:     R0 == left side of square to plot
1132 ;               R1 == bottom of square to plot
1133 ;               R2 == rotation number
1134 ;               R3 == x step for rectangles
1135 ;               R4 == y step for rectangles
1136 ;               R5 == current z-value (in 16.16)
1137 ;               R6 == pointer to graphics window block
1138 ;               R7 == unlimited relative max y position to plot
1139 ;               R8 == pointer to screen info block
1140 ;               R10 == unlimited relative min x position to plot
1141 ;               R11 == unlimited relative max x position to plot
1142 ;               R12 == unlimited relative min y position to plot
1143 ;               On stack: saved {R0-R12,R14}
1144 ;
1145 ; On exit:      --
1146 ;
1147 ; Use:          Displays an RGB square on the screen at a given location,
1148 ;               in a 32bpp mode, using direct screen access (TM).
1149
1150 rgb__plot16m    ROUT
1151
1152                 ; --- Prologue: Limit the relative box positions ---
1153
1154                 ADD     R8,R8,#screen_dx        ;Find the pixel positions
1155                 LDMIA   R8,{R8,R9}              ;Load them into registers
1156
1157                 CMP     R10,#0                  ;Is min x too small?
1158                 MOVLT   R10,#0                  ;Yes -- raise it to 0
1159                 CMP     R12,#0                  ;Is min y too small?
1160                 MOVLT   R12,#0                  ;Yes --- raise that too
1161                 CMP     R11,#256                ;Is the max x too large?
1162                 MOVGT   R11,#256                ;Yes -- reduce it then
1163                 CMP     R7,#256                 ;Is the max y too large?
1164                 MOVGT   R7,#256                 ;Yes -- reduce it then
1165                 SUB     R11,R11,R8              ;Make this inclusive
1166                 SUB     R7,R7,R9                ;Make this inclusive too
1167
1168                 ; --- Act 1: Find addresses of things on the screen ---
1169
1170                 ADD     R9,R0,R10               ;Work out left hand side
1171                 ADD     R8,R1,R7                ;Work out top of area
1172                 SUB     R10,R11,R10             ;Work out width of area
1173                 SUB     R7,R7,R12               ;And the height too
1174
1175                 SUB     R12,R9,R0               ;Work out left offset again
1176                 SUB     R11,R8,R1               ;And the top offset too
1177
1178                 SUB     R13,R13,#20             ;Space for our vdu vars
1179                 ADR     R0,rgb__vduVars         ;Point to the var numbers
1180                 MOV     R1,R13                  ;Point to our output block
1181                 SWI     OS_ReadVduVariables     ;Get the values nicely
1182
1183                 ; --- Reprise: Convert measurements to pixels ---
1184
1185                 LDMIA   R13!,{R0,R1}            ;Load the x and y eig things
1186                 MOV     R3,R3,LSR R0            ;Convert pixel counters
1187                 MOV     R4,R4,LSR R1            ;Convert other pixel counter
1188                 MOV     R9,R9,LSR R0            ;Convert left hand side
1189                 MOV     R10,R10,LSR R0          ;Convert width of area
1190                 MOV     R7,R7,LSR R1            ;Convert area height
1191                 MOV     R8,R8,LSR R1            ;And the top position
1192
1193                 ; --- Intermission: Pack up pixel counters ---
1194                 ;
1195                 ; We pack all this into a word containing the following:
1196                 ;
1197                 ; bits 31-24 == x counter reset value
1198                 ; bits 23-20 == y counter initial value
1199                 ; bits 19-16 == x counter initial value
1200                 ; bits 15- 8 == y counter reset value
1201                 ; bits  7- 0 == colour step value
1202                 ;
1203                 ; Can anyone say `Z80 programming techniques'?
1204
1205                 MOV     R12,R12,LSR R0          ;Get left offset in pixels
1206                 SUB     R6,R3,#1                ;Get the h pixel count -1
1207                 AND     R0,R12,R6               ;Get the remainder thing
1208                 SUB     R0,R3,R0                ;And get the correct offset
1209
1210                 ORR     R3,R4,R3,LSL #16        ;Pack x and y counters
1211                 MOV     R3,R3,LSL #8            ;Move that up one byte
1212
1213                 RSB     R14,R11,#256            ;Get offset from top
1214                 MOV     R11,R11,LSR R1          ;Turn offset into pixels
1215                 MOV     R1,R14,LSR R1           ;Get top offset in pixels
1216                 SUB     R1,R1,#1                ;Subtract one for niceness
1217                 SUB     R6,R4,#1                ;Get the v pixel count -1
1218                 AND     R1,R1,R6                ;Get the remainder thing
1219                 SUB     R1,R4,R1                ;And get the correct offset
1220                 ORR     R0,R0,R1,LSL #4         ;Pack into 1 byte
1221
1222                 ORR     R3,R3,R0,LSL #16        ;Put in initial values too
1223
1224                 LDMIA   R13!,{R0,R1,R6}         ;Load other vdu vars
1225                 SUB     R14,R1,R8               ;Shift origin to top left
1226                 MLA     R0,R14,R6,R0            ;Work out address of row
1227                 ADD     R9,R0,R9,LSL #2         ;Work out left address
1228                 ADD     R8,R9,R10,LSL #2        ;Work out right hand side too
1229
1230                 ; --- Act 2: Set up colour information ---
1231
1232                 BIC     R10,R3,#&FF             ;Move packed init values away
1233
1234                 RSB     R5,R5,R5,LSL #8         ;Multiply z value by 255
1235                 MOV     R5,R5,LSR #16           ;And make it 0-255
1236
1237                 AND     R3,R10,#&FF000000       ;Get the x pixel count reinit
1238                 SUB     R3,R3,#&01000000        ;Turn it into a bitmask
1239                 BIC     R3,R12,R3,LSR #24       ;Round colour down nicely
1240                 LDR     R12,[R13,#-20]          ;Get the xeig factor
1241                 MOV     R3,R3,LSL R12           ;Shift colour up to OS units
1242                 AND     R14,R10,#&FF000000      ;Get the x reinit value
1243                 MOV     R14,R14,LSR #24         ;Bring it down to earth
1244                 MOV     R14,R14,LSL R12         ;And turn into OS units
1245
1246                 AND     R4,R10,#&0000FF00       ;Get the y pixel count reinit
1247                 SUB     R4,R4,#&00000100        ;Turn it into a bitmask
1248                 BIC     R4,R11,R4,LSR #8        ;Round colour down nicely
1249                 LDR     R12,[R13,#-16]          ;Get the yeig factor
1250                 MOV     R4,R4,LSL R12           ;Shift colour up to OS units
1251                 AND     R11,R10,#&0000FF00      ;Get the y reinit value
1252                 MOV     R11,R11,LSR #8          ;Bring it down to earth
1253                 MOV     R11,R11,LSL R12         ;And turn into OS units
1254
1255                 MOV     R12,#&FF                ;This is a useful value
1256
1257                 CMP     R2,#0                   ;Is this the red rotation?
1258                 MOVEQ   R0,R5,LSL #0            ;Build the colour up...
1259                 ORREQ   R0,R0,R4,LSL #8         ;Still doing that...
1260                 ORREQ   R0,R0,R3,LSL #16        ;Almost finished now...
1261                 MOVEQ   R1,R3,LSL #16           ;And the x-init value
1262                 MOVEQ   R3,R11,LSL #8           ;Get the y increment right
1263                 MOVEQ   R4,R14,LSL #16          ;And the x increment
1264                 MOVEQ   R5,R12,LSL #16          ;Get the x-clear mask
1265
1266                 CMP     R2,#1                   ;Is this the green rotation?
1267                 MOVEQ   R0,R3,LSL #0            ;Build the colour up...
1268                 ORREQ   R0,R0,R5,LSL #8         ;Still doing that...
1269                 ORREQ   R0,R0,R4,LSL #16        ;Almost finished now...
1270                 MOVEQ   R1,R3,LSL #0            ;And the x-init value
1271                 MOVEQ   R3,R11,LSL #16          ;Get the y increment right
1272                 MOVEQ   R4,R14,LSL #0           ;And the x increment
1273                 MOVEQ   R5,R12,LSL #0           ;Get the x-clear mask
1274
1275                 CMP     R2,#2                   ;Is this the blue rotation?
1276                 MOVEQ   R0,R4,LSL #0            ;Build the colour up...
1277                 ORREQ   R0,R0,R3,LSL #8         ;Still doing that...
1278                 ORREQ   R0,R0,R5,LSL #16        ;Almost finished now...
1279                 MOVEQ   R1,R3,LSL #8            ;Get the x-init value
1280                 MOVEQ   R3,R11,LSL #0           ;Get the y increment right
1281                 MOVEQ   R4,R14,LSL #8           ;And the x increment
1282                 MOVEQ   R5,R12,LSL #8           ;Get the x-clear mask
1283
1284                 ; --- Act 3. Initialise the pixel counts ---
1285
1286                 MOV     R14,#&F                 ;For reading nibbles
1287                 AND     R12,R14,R10,LSR #16     ;Get the initial x value
1288                 AND     R2,R14,R10,LSR #20      ;Get the initial y value too
1289                 ORR     R2,R10,R2               ;Put that into the count reg
1290
1291                 ; --- Act 4. Plot the bloody thing ---
1292
1293                 SWI     OS_EnterOS              ;Avoid problems with PhysMem
1294
1295 10rgb__plot16m  MOV     R10,R9                  ;Get the current address
1296                 MOV     R11,R12                 ;Initialise the x counter
1297
1298                 ; --- Main row plotting loop (time critical :-) ) ---
1299
1300 20rgb__plot16m  STR     R0,[R10],#4             ;Store this pixel
1301
1302 25rgb__plot16m  CMP     R10,R8                  ;Have we finished yet?
1303                 BHI     %30rgb__plot16m         ;No -- do the rest then
1304                 SUBS    R11,R11,#1              ;Decrement pixel counter
1305                 ADDEQ   R0,R0,R4                ;If cleared, add on colour
1306                 MOVEQ   R11,R2,LSR #24          ;And reinitialise counter
1307                 B       %20rgb__plot16m         ;Go round for more
1308
1309                 ; --- We've finished; move on to next row ---
1310
1311 30rgb__plot16m  ADD     R9,R9,R6                ;Move start address down 1
1312                 ADD     R8,R8,R6                ;Move end address down 1
1313                 BIC     R0,R0,R5                ;Clear the x colour section
1314                 ORR     R0,R0,R1                ;Reintialise the x colour
1315                 SUB     R2,R2,#1                ;Decrement y counter
1316                 TST     R2,#&FF                 ;Is it now zero?
1317                 BICEQ   R2,R2,#&00FF0000        ;Clear unused byte in word
1318                 ORREQ   R2,R2,R2,LSR #8         ;Yes -- reinitialise
1319                 SUBEQ   R0,R0,R3                ;And increment the y colour
1320                 SUBS    R7,R7,#1                ;Decrement scan line counter
1321                 BCS     %10rgb__plot16m         ;And go back up again
1322
1323                 TEQP    PC,#0                   ;Return to user mode
1324                 MOV     R0,R0                   ;Keep ARM ecstatically happy
1325                 LDMFD   R13!,{R0-R12,PC}^       ;Return to caller
1326
1327                 LTORG
1328
1329 ; --- rgb__plotHair ---
1330 ;
1331 ; On entry:     R2 == x coordinate of cross
1332 ;               R3 == y coordinate of cross
1333 ;
1334 ; On exit:      --
1335 ;
1336 ; Use:          Plots the crosshair on an RGB colour square to mark the
1337 ;               current position nicely.
1338
1339 rgb__plotHair   ROUT
1340
1341                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
1342                 MOV     R0,#4                   ;Move cursor absolute
1343                 MOV     R1,R2                   ;Get the x coordinate
1344                 SUB     R2,R3,#256              ;Move down a little bit
1345                 SWI     OS_Plot                 ;Move the cursor there
1346                 MOV     R0,#2                   ;Plot in logical inverse (!)
1347                 MOV     R1,#0                   ;No x movement please
1348                 MOV     R2,#512                 ;And plot upwards
1349                 SWI     OS_Plot                 ;Plot the vertical line
1350
1351                 MOV     R0,#0                   ;Move cursor relative
1352                 MOV     R1,#-256                ;Move back a bit
1353                 MOV     R2,#-256                ;Move down a bit
1354                 SWI     OS_Plot                 ;Move the cursor there
1355                 MOV     R0,#2                   ;Plot in logical inverse (!)
1356                 MOV     R1,#512                 ;Plot the cross beam
1357                 MOV     R2,#0                   ;No y movement please
1358                 SWI     OS_Plot                 ;Plot the horizontal line
1359
1360                 MOV     R0,#0                   ;Move cursor relative
1361                 MOV     R1,#-256                ;Move back a bit
1362                 MOV     R2,#0                   ;Move back to centre
1363                 SWI     OS_Plot                 ;Move the cursor there
1364                 MOV     R0,#146                 ;Circle relative
1365                 MOV     R1,#16                  ;Radius 16
1366                 MOV     R2,#0                   ;Don't screw up calculation
1367                 SWI     OS_Plot                 ;Plot the circle
1368
1369                 LDMFD   R13!,{R0-R3,PC}^        ;And return to caller
1370
1371                 LTORG
1372
1373 ;----- Custom dbx controls --------------------------------------------------
1374
1375 ; --- rgbSquare ---
1376
1377 rgbSquare       ROUT
1378
1379                 DCD     0,0
1380                 DCD     dbxMask_redraw + dbxMask_update + dbxMask_click
1381
1382                 CMP     R0,#dbxEvent_update     ;Is it an update event?
1383                 BEQ     %10rgbSquare            ;Yes -- handle it
1384                 CMP     R0,#dbxEvent_click      ;Is it a click event?
1385                 BEQ     %20rgbSquare            ;Yes -- handle it
1386
1387                 ; --- Deal with a redraw event ---
1388
1389                 STMFD   R13!,{R0-R6,R10,R14}    ;Save some registers
1390                 MOV     R10,R8                  ;Get dbox data in R10
1391                 STMFD   R13!,{R2,R3}            ;Save bottom left corner
1392
1393                 ; --- Sort out the resolution ---
1394
1395                 BL      cs_resolution           ;Get the current resolution
1396                 CMP     R0,#0                   ;Is it pixel-level?
1397                 BLEQ    screen_getInfo          ;Yes -- get screen info
1398                 ADDEQ   R0,R0,#screen_dx        ;Point to the pixel size
1399                 LDMEQIA R0,{R3,R4}              ;And load the values
1400                 ADRNE   R14,rgb__resTable       ;Otherwise point at the table
1401                 ADDNE   R14,R14,R0              ;Find the correct entry
1402                 LDRNEB  R3,[R14,#0]             ;Load the square size
1403                 MOVNE   R4,R3                   ;And do it in both directions
1404
1405                 ; --- Sort out the z value too ---
1406
1407                 LDR     R0,rgb__zPos            ;Get the z slider value
1408                 MOV     R0,R0,LSL #16           ;Convert to 16.16 form
1409                 ADD     R0,R0,#50               ;Make it round to nearest
1410                 BL      div10                   ;Divide it by 10
1411                 BL      div10                   ;And again -- div by 100
1412                 MOV     R5,R0                   ;This is the z coordinate
1413
1414                 ; --- Call the main plot code ---
1415
1416                 LDMFD   R13!,{R0,R1}            ;Load the bottom left corner
1417                 LDR     R2,rgb__mapping         ;Get the colour mapping
1418                 BL      rgb_plotSquare          ;Do the plotting
1419                 LDMFD   R13!,{R0-R6,R10,R14}    ;Drop through to update code
1420
1421                 ; --- Plot the crosshair as part of update ---
1422
1423 10rgbSquare     STMFD   R13!,{R0-R5,R10,R14}    ;Save some registers
1424                 MOV     R10,R8                  ;Find my workspace address
1425                 SUB     R4,R4,R2                ;Get the icon width
1426                 SUB     R5,R5,R3                ;And the height
1427                 LDR     R0,rgb__xPos            ;Load cached x position
1428                 MUL     R0,R4,R0                ;Scale it to the width
1429                 ADD     R0,R0,#50               ;Round to nearest on divide
1430                 BL      div10                   ;And divide down
1431                 BL      div10                   ;And divide down again
1432                 ADD     R2,R2,R0                ;Find the x cross position
1433                 LDR     R0,rgb__yPos            ;Load cached y position
1434                 MUL     R0,R5,R0                ;Scale it to the height
1435                 ADD     R0,R0,#50               ;Round to nearest on divide
1436                 BL      div10                   ;And divide down
1437                 BL      div10                   ;And divide down again
1438                 ADD     R3,R3,R0                ;Find the y cross position
1439                 BL      rgb__plotHair           ;Plot the crosshair nicely
1440                 LDMFD   R13!,{R0-R5,R10,PC}^    ;And return to caller
1441
1442 rgb__resTable   DCB     0,4,8,16
1443
1444                 ; --- Handle click events on the square ---
1445
1446 20rgbSquare     TST     R2,#5                   ;Is it a real button click?
1447                 MOVEQS  PC,R14                  ;No -- ignore it then
1448                 STMFD   R13!,{R0-R5,R10,R14}    ;Save some registers
1449
1450                 ; --- Start the drag operation ---
1451
1452                 MOV     R0,R10                  ;Get dialogue handle
1453                 BL      dbx_controlBBox         ;Get the bonding box nicely
1454                 BL      dbox_window             ;Get the window handle
1455                 MOV     R1,#7                   ;User drag type
1456                 SUB     R13,R13,#56             ;Make a drag box on the stack
1457                 STMIA   R13,{R0,R1}             ;Save them away nicely
1458                 ADD     R14,R13,#24             ;Point to parent box
1459                 STMIA   R14,{R2-R5}             ;Save the bounding box here
1460                 MOV     R1,R13                  ;Point to my block
1461                 SWI     Wimp_DragBox            ;Set up the drag nicely
1462                 ADD     R13,R13,#56             ;Reclaim the stack space
1463
1464                 ; --- Set up the handlers nicely ---
1465
1466                 MOV     R10,R8                  ;Point to dbox data in R10
1467                 ADR     R0,rgb__ukEvents        ;Point to unknown handler
1468                 MOV     R1,#0                   ;Don't care about R4
1469                 MOV     R2,R10                  ;Pass dbox data in R10
1470                 MOV     R3,R12                  ;Pass workspace in R12
1471                 BL      win_unknownHandler      ;Register the handler
1472                 MOVVC   R0,#2                   ;Call every TV frame
1473                 ADRVC   R1,rgb__idles           ;Point to the idle handler
1474                 BLVC    idle_handler            ;Register that too
1475                 BL      rgb__idles              ;Call idle handler now
1476                 LDMFD   R13!,{R0-R5,R10,PC}^    ;Return to caller
1477
1478                 LTORG
1479
1480 ; --- rgb__idles ---
1481 ;
1482 ; On entry:     --
1483 ;
1484 ; On exit:      --
1485 ;
1486 ; Use:          Handles idle events during a drag in the colour square.
1487
1488 rgb__idles      ROUT
1489
1490                 STMFD   R13!,{R0-R5,R10,R14}    ;Save some registers
1491                 LDR     R0,cs__modelDb          ;Get the dialogue box
1492                 MOV     R1,#rgbIcon__square     ;Get my icon handle
1493                 BL      dbx_controlBBox         ;Get my bounding box nicely
1494                 SUB     R13,R13,#20             ;Get a pointer block
1495                 MOV     R1,R13                  ;Point at it nicely
1496                 SWI     Wimp_GetPointerInfo     ;Find the pointer posn
1497                 LDMIA   R13,{R0,R1}             ;Load pointer coordinates
1498                 ADD     R13,R13,#20             ;Recover that block
1499
1500                 ; --- Work out the new cross position ---
1501
1502                 SUB     R4,R4,R2                ;Work out the icon width
1503                 SUB     R5,R5,R3                ;And the icon height
1504                 SUB     R2,R0,R2                ;Work out the x offset
1505                 SUB     R3,R1,R3                ;And the y offset
1506
1507                 ADD     R2,R2,R2,LSL #2         ;Multiply x by 5
1508                 ADD     R2,R2,R2,LSL #2         ;Multiply x by 5 (x25)
1509                 MOV     R2,R2,LSL #2            ;Multiply x by 4 (x100)
1510
1511                 ADD     R3,R3,R3,LSL #2         ;Multiply y by 5
1512                 ADD     R3,R3,R3,LSL #2         ;Multiply y by 5 (x25)
1513                 MOV     R3,R3,LSL #2            ;Multiply y by 4 (x100)
1514
1515                 MOV     R0,R2                   ;Get the x value
1516                 MOV     R1,R4                   ;And the icon width
1517                 BL      div_round               ;Divide to get percentage
1518                 STR     R0,rgb__sl1Val          ;Save the x position
1519
1520                 MOV     R0,R3                   ;Get the y value
1521                 MOV     R1,R5                   ;And the icon height
1522                 BL      div_round               ;Divide to get percentage
1523                 STR     R0,rgb__sl2Val          ;Save the y position
1524
1525                 BL      rgb__xyUpdate           ;Redraw crosshairs if reqd
1526                 LDR     R0,cs__modelDb          ;Get the dialogue handle
1527                 MOV     R1,#rgbIcon__slide1     ;Get slider 1's number
1528                 BL      dbx_update              ;Redraw it quickly
1529                 MOV     R1,#rgbIcon__slide2     ;Get slider 2's number
1530                 BL      dbx_update              ;Redraw it quickly
1531                 BL      rgb__colUpdate          ;Redraw the colour button
1532
1533                 ; --- Now update the correct icons ---
1534
1535                 ADRL    R5,rgb__writeTbl+2      ;Point to icon number table
1536                 LDR     R14,rgb__mapping        ;And get the current mappiing
1537                 ADD     R5,R5,R14               ;Find the correct entry
1538
1539                 LDRB    R1,[R5,#0]              ;Load the x icon
1540                 LDR     R2,rgb__sl1Val          ;Get the new x value
1541                 BL      numWrite_set            ;Put it in the icon
1542                 LDRB    R1,[R5,#-1]             ;Load the y icon
1543                 LDR     R2,rgb__sl2Val          ;Get the new y value
1544                 BL      numWrite_set            ;Put it in the icon
1545                 LDMFD   R13!,{R0-R5,R10,PC}^    ;And return to caller
1546
1547                 LTORG
1548
1549 ; --- rgb__ukEvents ---
1550 ;
1551 ; On entry:     R0 == event code
1552 ;
1553 ; On exit:      CS if handled
1554 ;
1555 ; Use:          Handles unknown events during a drag in the RGB colour
1556 ;               square.
1557
1558 rgb__ukEvents   ROUT
1559
1560                 CMP     R0,#7                   ;Is it a drag over event?
1561                 MOVNES  PC,R14                  ;No -- then return to caller
1562                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
1563                 BL      rgb__idles              ;Get one last drag position
1564                 ADR     R0,rgb__ukEvents        ;Point to unknown handler
1565                 MOV     R1,#0                   ;Don't care about R4
1566                 MOV     R2,R10                  ;Pass dbox data in R10
1567                 MOV     R3,R12                  ;Pass workspace in R12
1568                 BL      win_removeUnknownHandler ;Deregister the handler
1569                 MOVVC   R0,#2                   ;Call every TV frame
1570                 ADRVC   R1,rgb__idles           ;Point to the idle handler
1571                 BLVC    idle_removeHandler      ;Deregister that too
1572                 LDMFD   R13!,{R0-R3,PC}^        ;And return to caller
1573
1574                 LTORG
1575
1576 ;----- Icon numbers ---------------------------------------------------------
1577
1578 rgbIcon__square EQU     0                       ;The main colour square
1579 rgbIcon__slide1 EQU     1                       ;The x slider (slider 1)
1580 rgbIcon__slide2 EQU     2                       ;The y slider (slider 2)
1581 rgbIcon__slide3 EQU     3                       ;The z slider (slider 3)
1582
1583 rgbIcon__radioR EQU     4                       ;The `Red' radio button
1584 rgbIcon__writeR EQU     5                       ;The `Red' writable area
1585 rgbIcon__upR    EQU     6                       ;The `Red' up arrow button
1586 rgbIcon__downR  EQU     7                       ;The `Red' down arrow button
1587
1588 rgbIcon__radioG EQU     9                       ;The `Green' radio button
1589 rgbIcon__writeG EQU     10                      ;The `Green' writable area
1590 rgbIcon__upG    EQU     11                      ;The `Green' up arrow button
1591 rgbIcon__downG  EQU     12                      ;The `Green' down arrow buttn
1592
1593 rgbIcon__radioB EQU     14                      ;The `Blue' radio button
1594 rgbIcon__writeB EQU     15                      ;The `Blue' writable area
1595 rgbIcon__upB    EQU     16                      ;The `Blue' up arrow button
1596 rgbIcon__downB  EQU     17                      ;The `Blue' down arrow button
1597
1598 rgbIcon__wCols  EQU     20                      ;Base of the WIMP colours
1599
1600 ;----- That's all, folks ----------------------------------------------------
1601
1602                 END