chiark - git - mdw - ssr/blob - StraySrc/Libraries/Sapphire/s/viewer

   1 ;
   2 ; viewer.s
   3 ;
   4 ; Filer-like windows with re-arranging icons (MDW)
   5 ;
   6 ; © 1995-1998 Straylight
   7 ;
   8
   9 ;----- Licensing note -------------------------------------------------------
  10 ;
  11 ; This file is part of Straylight's Sapphire library.
  12 ;
  13 ; Sapphire is free software; you can redistribute it and/or modify
  14 ; it under the terms of the GNU General Public License as published by
  15 ; the Free Software Foundation; either version 2, or (at your option)
  16 ; any later version.
  17 ;
  18 ; Sapphire is distributed in the hope that it will be useful,
  19 ; but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ; GNU General Public License for more details.
  22 ;
  23 ; You should have received a copy of the GNU General Public License
  24 ; along with Sapphire.  If not, write to the Free Software Foundation,
  25 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26
  27 ;----- Standard header ------------------------------------------------------
  28
  29                 GET     libs:header
  30                 GET     libs:swis
  31
  32                 GET     libs:stream
  33
  34 ;----- External dependencies ------------------------------------------------
  35
  36                 GET     sapphire:akbd
  37                 GET     sapphire:alloc
  38                 GET     sapphire:divide
  39                 GET     sapphire:drag
  40                 GET     sapphire:fastMove
  41                 GET     sapphire:msgs
  42                 GET     sapphire:sapphire
  43                 GET     sapphire:screen
  44                 GET     sapphire:wimp
  45                 GET     sapphire:win
  46                 GET     sapphire:winUtils
  47
  48 ;----- Macros ---------------------------------------------------------------
  49
  50                 MACRO
  51 $label          MSGB    $msg,$branch
  52 $label          DCD     $msg
  53                 B       $branch
  54                 MEND
  55
  56 ;----- Main code ------------------------------------------------------------
  57
  58                 AREA    |Sapphire$$Code|,CODE,READONLY
  59
  60 ;----- Creating and deleting viewers ----------------------------------------
  61
  62 ; --- viewer_create ---
  63 ;
  64 ; On entry:     R0 == pointer to a viewer definition block
  65 ;               R1 == pointer to a list
  66 ;               R2 == sprite area for window
  67 ;
  68 ; On exit:      R0 == viewer handle
  69 ;               May return an error
  70 ;
  71 ; Use:          Creates a viewer window.  The viewer definition block
  72 ;               contains various interesting bits of information about the
  73 ;               viewer which are likely to be known at assembly time:
  74 ;
  75 ;               (word)   address of a list manager definition block
  76 ;               (word)   address of a shape handler function (or 0)
  77 ;               (word)   standard width of icons
  78 ;               (word)   standard height of icons
  79 ;               (string) banner text message tag, or empty
  80 ;
  81 ;               The shape function is used to allow viewer icons to have a
  82 ;               non-rectangular shape.  The function is called with a reason
  83 ;               code in R0; entry and exit conditions depend on this:
  84 ;
  85 ;                                                       vwShape_size
  86 ;               On entry
  87 ;                 R1 == pointer to list item
  88 ;                 R2 == standard width of icon
  89 ;                 R3 == standard height of icon
  90 ;
  91 ;               On exit
  92 ;                 R2 == width of this icon
  93 ;                 R3 == height of this icon
  94 ;
  95 ;               Use
  96 ;                 This routine is used to find the actual size of an icon.
  97 ;                 The icons are aligned on a grid according to the largest
  98 ;                 one: this routine is used to find out which one that is.
  99 ;
 100 ;                                                       vwShape_intersects
 101 ;               On entry
 102 ;                 R1 == pointer to list item
 103 ;                 R2 == address of bounding box of this icon
 104 ;                 R3 == address of bounding box to compare
 105 ;
 106 ;               On exit
 107 ;                 CS if boxes intersect, else CC
 108 ;
 109 ;               Use
 110 ;                 For detecting mouse clicks etc. on an icon.  viewer has
 111 ;                 already ensured that the box in R3 intersects with the
 112 ;                 bounding box, so for rectangular icons, you can just return
 113 ;                 with C set always.  This entry is provided so that you
 114 ;                 can check against the sprite and text of a text+sprite
 115 ;                 icon separately.
 116 ;
 117 ;               More reason codes may be added later; it will always be
 118 ;               sensible to return immediately preserving all registers and
 119 ;               flags.
 120
 121                 EXPORT  viewer_create
 122 viewer_create   ROUT
 123
 124                 STMFD   R13!,{R1-R5,R10,R14}    ;Save some registers
 125
 126                 ; --- Move arguments into other registers ---
 127
 128                 MOV     R5,R0                   ;Look after block def
 129                 MOV     R4,R2                   ;And the sprite area
 130
 131                 ; --- Allocate a viewer block ---
 132
 133                 MOV     R0,#vw__size            ;Get the block size
 134                 BL      alloc                   ;Allocate the memory
 135                 BLCS    alloc_error             ;If it failed, get error
 136                 BCS     %99viewer_create        ;And return to caller
 137                 MOV     R10,R0                  ;Look after the pointer
 138
 139                 ; --- Fill in bits of the block ---
 140
 141                 STR     R1,[R10,#vw__list]      ;Store the list address
 142                 LDMIA   R5!,{R0-R3}             ;Load regs from def block
 143                 STR     R0,[R10,#vw__listDef]   ;Store list definition addr
 144                 CMP     R1,#0                   ;Is the shape function 0?
 145                 ADREQ   R1,vw__dummyShape       ;Yes -- use default one
 146                 STR     R1,[R10,#vw__shape]     ;Store that away nicely
 147                 ADD     R14,R10,#vw__stdDimens  ;Point to standard icon sz
 148                 STMIA   R14,{R2,R3}             ;Store them away nicely
 149                 LDRB    R0,[R5,#0]              ;Load first byte of banner
 150                 CMP     R0,#0                   ;Is it actually defined?
 151                 MOVNE   R0,R5                   ;Yes -- point to it then
 152                 BLNE    msgs_lookup             ;And translate the tag
 153                 STR     R0,[R10,#vw__banner]    ;Store that away nicely
 154
 155                 ; --- Now create a window ---
 156
 157                 MOV     R0,R11                  ;Copy definition to scratch
 158                 ADR     R1,vw__windDef          ;Point to my definition
 159                 MOV     R2,#88                  ;Size of window definition
 160                 BL      fastMove                ;Copy the data over
 161
 162                 STR     R4,[R11,#64]            ;Store caller's sprite area
 163                 ADD     R14,R10,#vw__title      ;Point to title buffer
 164                 STR     R14,[R11,#72]           ;Save this in window block
 165                 MOV     R1,R11                  ;Point to window definition
 166                 SWI     XWimp_CreateWindow      ;Try to do that then
 167                 BVS     %98viewer_create        ;If it failed, tidy up
 168                 STR     R0,[R10,#vw__window]    ;Save the window handle
 169
 170                 ; --- Set up the event handler ---
 171
 172                 ADR     R1,vw__events           ;Point to event handler
 173                 MOV     R2,R10                  ;Use viewer handle as R10
 174                 MOV     R3,R12                  ;Pass workspace in R12 (*)
 175                 BL      win_eventHandler        ;Set up the event handler
 176                 BVS     %97viewer_create        ;If it failed, tidy up
 177
 178                 ; --- Fix up rest of viewer block ---
 179
 180                 MOV     R14,#0                  ;No handler defined yet
 181                 STR     R14,[R10,#vw__handler]  ;Save that in my block
 182                 STR     R14,[R10,#vw__flags]    ;Clear the flags too
 183                 STR     R14,[R10,#vw__tempSel]  ;No temporary selection
 184
 185                 ; --- Now return to caller ---
 186
 187                 MOV     R0,R10                  ;Get the viewer handle
 188                 LDMFD   R13!,{R1-R5,R10,R14}    ;Restore registers
 189                 BICS    PC,R14,#V_flag          ;And return to caller
 190
 191                 ; --- Handle minor mishaps ---
 192
 193 97viewer_create MOV     R5,R0                   ;Look after error pointer
 194                 ADD     R1,R10,#vw__window      ;Point to window handle
 195                 SWI     Wimp_DeleteWindow       ;Destroy the window
 196                 MOV     R0,R5                   ;And get the error back
 197
 198 98viewer_create MOV     R5,R0                   ;Look after error pointer
 199                 MOV     R0,R10                  ;Point to viewer block
 200                 BL      free                    ;Free the block up
 201                 MOV     R0,R5                   ;And get the error back
 202
 203 99viewer_create ADD     R2,R0,#4                ;Point to error text
 204                 ADR     R0,vw__createErr        ;Point to error skeleton
 205                 BL      msgs_error              ;Translate and substitute
 206                 LDMFD   R13!,{R1-R5,R10,R14}    ;Restore registers
 207                 ORRS    PC,R14,#V_flag          ;And return the error
 208
 209 vw__dummyShape  ORRS    PC,R14,#C_flag          ;Dummy shape function
 210
 211 vw__createErr   DCD     1
 212                 DCB     "vwCRTE",0
 213
 214 vw__windDef     DCD     0,0,0,0
 215                 DCD     0,0
 216                 DCD     0
 217                 DCD     &BF000002
 218                 DCB     7,2,7,1,3,1,12,0
 219                 DCD     0,0,0,0
 220                 DCD     &1700013D
 221                 DCD     &0000A000
 222                 DCD     1
 223                 DCW     1,0
 224                 DCD     0,-1,256
 225                 DCD     0
 226
 227                 LTORG
 228
 229 ; --- viewer_destroy ---
 230 ;
 231 ; On entry:     R0 == viewer handle
 232 ;
 233 ; On exit:      --
 234 ;
 235 ; Use:          Destroys a viewer, removing it from the screen etc.
 236
 237                 EXPORT  viewer_destroy
 238 viewer_destroy  ROUT
 239
 240                 STMFD   R13!,{R0,R1,R10,R14}    ;Save some registers
 241                 MOV     R10,R0                  ;Look after the handle
 242                 LDR     R0,[R10,#vw__window]    ;Load the window handle
 243                 BL      win_windowDeleted       ;Say it's been deleted
 244                 ADD     R1,R10,#vw__window      ;Find the window handle
 245                 SWI     Wimp_DeleteWindow       ;Destroy the window
 246                 MOV     R0,R10                  ;Point to the viewer block
 247                 BL      free                    ;Release the memory
 248                 LDMFD   R13!,{R0,R1,R10,PC}^    ;And return to caller
 249
 250                 LTORG
 251
 252 ;----- Opening and closing --------------------------------------------------
 253
 254 ; --- viewer_open ---
 255 ;
 256 ; On entry:     R0 == viewer handle
 257 ;               R1 == opening style
 258 ;               R2,R3 == extra arguments
 259 ;
 260 ; On exit:      --
 261 ;
 262 ; Use:          Opens a viewer window on the screen.
 263
 264                 EXPORT  viewer_open
 265 viewer_open     ROUT
 266
 267                 STMFD   R13!,{R0,R1,R4,R10,R14} ;Save some registers
 268                 MOV     R10,R0                  ;Get the viewer handle
 269                 MOV     R4,R1                   ;Look after opening style
 270
 271                 SUB     R13,R13,#36             ;Make a window state block
 272                 LDR     R14,[R10,#vw__window]   ;Load the window handle
 273                 STR     R14,[R13,#0]            ;Save it in the block
 274                 MOV     R1,R13                  ;Point to the block
 275                 SWI     Wimp_GetWindowState     ;And read the window state
 276
 277                 ; --- If window is open, skip on ---
 278
 279                 BL      vw__open                ;Is the window open?
 280                 BCS     %10viewer_open          ;Yes -- skip onwards then
 281
 282                 ; --- Open the window onto the screen ---
 283
 284                 LDR     R1,[R10,#vw__listDef]   ;Find the list definition
 285                 LDR     R0,[R10,#vw__list]      ;And the list base
 286                 MOV     R14,PC                  ;Set up return address
 287                 ADD     PC,R1,#vw__items        ;Find how many items
 288                 STR     R1,[R10,#vw__icons]     ;Store this away
 289
 290                 MOV     R1,R13                  ;Point at window state blk
 291                 BL      vw__tWidth              ;Work out title width
 292                 BL      vw__rescanSize          ;Rescan the item size
 293                 BL      vw__extend              ;Yes -- make it big then
 294                 BL      vw__resize              ;Work out new arrangement
 295                 BL      vw__setExtent           ;Set the window's extent
 296
 297                 ; --- Finally work out where to open it ---
 298
 299 10viewer_open   MOV     R0,R4                   ;Get the opening style
 300                 BL      winUtils_setPosition    ;Set the window position
 301                 BL      vw__openWindow          ;Open the window there
 302                 ADD     R13,R13,#36             ;Reclaim the stack space
 303                 LDR     R14,[R10,#vw__flags]    ;Load the flags word
 304                 ORR     R14,R14,#vwFlag__opened ;We've now opened it
 305                 STR     R14,[R10,#vw__flags]    ;Store the flags back
 306                 LDMFD   R13!,{R0,R1,R4,R10,PC}^ ;And return to caller
 307
 308                 LTORG
 309
 310 ; --- viewer_close ---
 311 ;
 312 ; On entry:     R0 == viewer handle
 313 ;
 314 ; On exit:      --
 315 ;
 316 ; Use:          Closes a viewer window.
 317
 318                 EXPORT  viewer_close
 319 viewer_close    ROUT
 320
 321                 STMFD   R13!,{R0,R1,R14}        ;Save some registers
 322                 ADD     R1,R0,#vw__window       ;Find the window handle
 323                 SWI     Wimp_CloseWindow        ;Close the window
 324                 LDMFD   R13!,{R0,R1,PC}^        ;And return to caller
 325
 326                 LTORG
 327
 328 ;----- Event handling -------------------------------------------------------
 329
 330 ; --- viewer_eventHandler ---
 331 ;
 332 ; On entry:     R0 == viewer handle
 333 ;               R1 == pointer to event handler
 334 ;               R2 == value to pass in R10
 335 ;               R3 == value to pass in R12
 336 ;
 337 ; On exit:      R1-R3 == old values
 338 ;
 339 ; Use:          Sets up the event handle for the viewer.
 340
 341                 EXPORT  viewer_eventHandler
 342 viewer_eventHandler ROUT
 343
 344                 STMFD   R13!,{R4-R6,R14}        ;Save some registers
 345                 ADD     R14,R0,#vw__handler     ;Point to handler block
 346                 LDMIA   R14,{R4-R6}             ;Load the old handler
 347                 STMIA   R14,{R1-R3}             ;Save the new one
 348                 MOV     R1,R4                   ;Transfer information over
 349                 MOV     R2,R5                   ;All of it, don't let it
 350                 MOV     R3,R6                   ;Get away!
 351                 LDMFD   R13!,{R4-R6,PC}^        ;And return to caller
 352
 353                 LTORG
 354
 355 ; --- vw__events ---
 356 ;
 357 ; On entry:     R0 == event code
 358 ;               R1 == pointer to event block
 359 ;
 360 ; On exit:      CS if handled, else CC
 361 ;
 362 ; Use:          Handles events for a viewer window.
 363
 364 vw__events      ROUT
 365
 366                 CMP     R0,#17                  ;Is this a message?
 367                 CMPNE   R0,#18                  ;Check *both* types
 368                 BEQ     %10vw__events           ;Yes -- handle them
 369                 CMP     R0,#9                   ;Is the event interesting?
 370                 ADDCC   PC,PC,R0,LSL #2         ;Yes -- dispatch it then
 371                 MOVS    PC,R14                  ;Otherwise ignore it
 372
 373                 ; --- Branch table ---
 374
 375                 MOVS    PC,R14
 376                 B       vw__evRedraw
 377                 B       vw__evOpen
 378                 B       vw__evClose
 379                 MOVS    PC,R14
 380                 MOVS    PC,R14
 381                 B       vw__evMouse
 382                 MOVS    PC,R14
 383                 B       vw__evKey
 384
 385                 ; --- Handle messages ---
 386                 ;
 387                 ; This is a little odd, in the interests of expandability.
 388
 389 10vw__events    STMFD   R13!,{R2-R4,R14}        ;Save some registers
 390                 LDR     R2,[R1,#16]             ;Load the message code
 391                 ADR     R3,vw__msgTable         ;Point to the message table
 392 00              LDR     R4,[R3],#8              ;Load the message code
 393                 CMP     R4,R2                   ;Do I recognise this event?
 394                 SUBEQ   R3,R3,#4                ;Yes -- point to branch instr
 395                 STREQ   R3,[R13,#12]            ;Store as return address
 396                 CMPNE   R4,#-1                  ;Is it the end of the list?
 397                 BNE     %b00                    ;No -- keep looping then
 398                 LDMFD   R13!,{R2-R4,PC}^        ;Call the routine
 399
 400                 ; --- Message table ---
 401
 402 vw__msgTable    MSGB    &1,vw__mDataSave
 403                 MSGB    &3,vw__mDataLoad
 404                 MSGB    &502,vw__mHelpRq
 405                 MSGB    &400CF,vw__mFontChnge
 406                 DCD     -1,-1
 407
 408                 LTORG
 409
 410 ; --- vw__dispatch ---
 411 ;
 412 ; On entry:     R0 == event code
 413 ;               R1-R5 set up for event
 414 ;
 415 ; On exit:      CS or CC according to event handler
 416 ;
 417 ; Use:          Dispatches an event to the user's handler.
 418
 419                 EXPORT  vw__dispatch
 420 vw__dispatch    ROUT
 421
 422                 STMFD   R13!,{R8-R10,R12,R14}   ;Save some registers
 423                 ADD     R14,R10,#vw__handler    ;Find the handler routine
 424                 MOV     R9,R10                  ;Pass viewer handle in R9
 425                 LDMIA   R14,{R8,R10,R12}        ;Load the things out
 426                 ADDS    R0,R0,#0                ;Clear the carry flag
 427                 TEQ     R8,#0                   ;Is there a routine?
 428                 MOVNE   R14,PC                  ;Yes -- set up return addr
 429                 MOVNE   PC,R8                   ;And call the routine
 430                 LDMFD   R13!,{R8-R10,R12,R14}   ;Restore registers
 431                 ORRCSS  PC,R14,#C_flag          ;If it set C, we do too
 432                 BICCCS  PC,R14,#C_flag          ;Otherwise we clear it
 433
 434                 LTORG
 435
 436 ; --- vw_evRedraw ---
 437 ;
 438 ; On entry:     R1 == pointer to window handle in block
 439 ;
 440 ; On exit:      CS
 441 ;
 442 ; Use:          Redraws a viewer window.
 443
 444 vw__evRedraw    ROUT
 445
 446                 STMFD   R13!,{R0-R7,R14}        ;Save some registers
 447                 SWI     Wimp_RedrawWindow       ;Start the redraw job
 448                 CMP     R0,#0                   ;Is this the end yet?
 449                 BEQ     %90vw__evRedraw         ;Yes -- do nothing then
 450
 451                 ; --- Find the window origin ---
 452
 453                 MOV     R7,R1                   ;Remember the block pointer
 454                 LDR     R2,[R7,#4]              ;Load the left hand side
 455                 ADD     R14,R7,#16              ;Point to top and scroll pos
 456                 LDMIA   R14,{R3-R5}             ;Load those positions out
 457                 SUB     R6,R3,R5                ;Find the top position
 458                 SUB     R5,R2,R4                ;And the left side
 459                 SUB     R13,R13,#32             ;Space for rectangle block
 460
 461                 ; --- The main redraw loop ---
 462                 ;
 463                 ; First of all, handle the banner.
 464
 465 10vw__evRedraw  LDR     R14,[R10,#vw__banner]   ;Load the banner address
 466                 CMP     R14,#0                  ;Is there one defined?
 467                 BEQ     %f00                    ;No -- skip ahead then
 468
 469                 ; --- See if we need to do this ---
 470
 471                 LDR     R14,[R7,#28+16]         ;Load the top coordinate
 472                 CMP     R14,R6                  ;Is this above the line?
 473                 BLT     %f00                    ;No -- don't bother then
 474
 475                 ; --- Render the banner's background ---
 476
 477                 MOV     R0,#3                   ;Get the banner colour
 478                 SWI     Wimp_SetColour          ;Set this as the colour
 479
 480                 MOV     R0,#4                   ;Move the graphics cursor
 481                 LDR     R1,[R7,#28+0]           ;Find left side of window
 482                 MOV     R2,R6                   ;Baseline on window origin
 483                 SWI     OS_Plot                 ;Do the cursor move
 484                 MOV     R0,#101                 ;Rectangle fill absolute
 485                 LDR     R1,[R7,#28+8]           ;Load right side of window
 486                 ADD     R2,R6,#vw__banHeight    ;Get the banner height
 487                 SWI     OS_Plot                 ;Do that too
 488
 489                 ; --- Now plot the banner text ---
 490
 491                 MOV     R14,R13                 ;Point at the stack block
 492
 493                 MOV     R0,#28                  ;We have an odd left side
 494                 MOV     R1,#0                   ;Baseline is along origin
 495                 LDR     R2,[R10,#vw__fixedWidth] ;Load width of the banner
 496                 MOV     R3,#vw__banHeight       ;Get the banner's height
 497                 STMIA   R14!,{R0-R3}            ;Save the coordinates
 498
 499                 LDR     R0,=&37000131           ;Get the icon flags word
 500                 LDR     R1,[R10,#vw__banner]    ;Load the banner pointer
 501                 MOV     R2,#-1                  ;No validation string
 502                 MOV     R3,#1                   ;Bogus string length
 503                 STMIA   R14!,{R0-R3}            ;Save the other bits
 504
 505                 MOV     R1,R13                  ;Point to the block
 506                 SWI     Wimp_PlotIcon           ;Plot the text as an icon
 507
 508                 ; --- Now alter the graphics rectangle ---
 509
 510 00              ADD     R14,R7,#28              ;Find the clipping rectangle
 511                 LDMIA   R14,{R0-R3}             ;Load the rectangle out
 512                 SUB     R0,R0,R5                ;Convert to window coords
 513                 SUB     R1,R1,R6                ;This isn't terribly hard
 514                 SUB     R2,R2,R5                ;Just subtract origin posn
 515                 SUB     R3,R3,R6                ;For all the coordinates
 516                 STMIA   R14,{R0-R3}             ;Store those in the block
 517
 518                 ; --- Plot each interesting icon ---
 519
 520                 MOV     R0,#vwEvent_redraw      ;Say this is a redraw event
 521                 MOV     R1,#0                   ;Start at the beginning
 522                 MOV     R2,R13                  ;Use my stack buffer
 523                 ADD     R3,R7,#28               ;Point to the clip block
 524 00              BL      vw__enum                ;Get next icon ready
 525                 BCC     %f00                    ;If no more, skip onwards
 526                 BL      vw__intSimple           ;Do quick clipping check
 527                 BLCS    vw__dispatch            ;Yes -- package off the event
 528                 B       %b00                    ;Loop round for the rest
 529
 530                 ; --- Finish off the redraw loop ---
 531
 532 00              MOV     R1,R7                   ;Point at the event block
 533                 BL      drag_redraw             ;Draw the drag box if reqd
 534                 SWI     Wimp_GetRectangle       ;Get another rectangle
 535                 CMP     R0,#0                   ;Is there more to do?
 536                 BNE     %10vw__evRedraw         ;Yes -- loop back to do it
 537
 538                 ADD     R13,R13,#32             ;Restore the stack pointer
 539
 540 90vw__evRedraw  LDMFD   R13!,{R0-R7,R14}        ;Unstack the registers
 541                 ORRS    PC,R14,#C_flag          ;And *claim the event*
 542
 543                 LTORG
 544
 545 ; --- vw__evOpen ---
 546 ;
 547 ; On entry:     R1 == pointer to an open-window block
 548 ;
 549 ; On exit:      CS
 550 ;
 551 ; Use:          Opens a viewer window.
 552
 553 vw__evOpen      ROUT
 554
 555                 STMFD   R13!,{R0,R14}           ;Save some registers
 556                 MOV     R14,#0                  ;Force horizontal scroll
 557                 STR     R14,[R1,#20]            ;To stop it looking odd
 558                 BL      screen_justChangedMode  ;Just had a mode change?
 559                 BCS     %50vw__evOpen           ;Yes -- handle that
 560
 561                 ; --- Just rescan the size like nice people ---
 562
 563                 BL      vw__resize              ;Modify the arrangement
 564                 BLCS    vw__setExtent           ;Maybe modify the extent too
 565                 BLCS    vw__refresh             ;If so, force a redraw
 566                 BL      vw__openWindow          ;Whatever, open the window
 567                 LDMFD   R13!,{R0,R14}           ;Restore the registers
 568                 ORRS    PC,R14,#C_flag          ;And claim the event
 569
 570                 ; --- Just changed mode -- anything could have happened ---
 571
 572 50vw__evOpen    BL      vw__tWidth              ;Rescan the title width
 573                 BL      vw__rescanSize          ;Rescan the icon sizes
 574                 BL      vw__resize              ;Rearrange the icons
 575                 BL      vw__setExtent           ;Rework the extent
 576                 BL      vw__refresh             ;Redraw the work area
 577                 BL      vw__openWindow          ;And reopen the window
 578                 LDMFD   R13!,{R0,R14}           ;Restore the registers
 579                 ORRS    PC,R14,#C_flag          ;And claim the event
 580
 581                 LTORG
 582
 583 ; --- vw__evClose ---
 584 ;
 585 ; On entry:     R1 == pointer to block
 586 ;
 587 ; On exit:      CC or CS
 588 ;
 589 ; Use:          Handles a close request for a viewer,
 590
 591 vw__evClose     ROUT
 592
 593                 STMFD   R13!,{R0,R14}           ;Save some registers
 594                 MOV     R0,#vwEvent_close       ;Get the event code
 595                 BL      vw__dispatch            ;Send it to the user
 596                 LDMFD   R13!,{R0,PC}            ;And return this state
 597
 598                 LTORG
 599
 600 ; --- vw__evMouse ---
 601 ;
 602 ; On entry:     R1 == pointer to pointer info block
 603 ;
 604 ; On exit:      CS
 605 ;
 606 ; Use:          Handles a mouse click on the viewer.
 607
 608 vw__evMouse     ROUT
 609
 610                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
 611                 MOV     R4,R1                   ;Look after this pointer
 612                 LDMIA   R4,{R2,R3}              ;Load the coordinates out
 613                 BL      vw__whichIcon           ;Which icon is that?
 614
 615                 LDR     R2,[R4,#8]              ;Load the button state
 616                 TST     R2,#&002                ;Is this a menu click?
 617                 MOVNE   R0,#vwEvent_menu        ;Yes -- pass that event
 618                 TST     R2,#&005                ;Another normal click?
 619                 MOVNE   R0,#vwEvent_double      ;Yes -- that's a double
 620                 TST     R2,#&050                ;Is it a drag?
 621                 MOVNE   R0,#vwEvent_drag        ;Yes -- use that event then
 622                 TST     R2,#&500                ;Or a normal click?
 623                 MOVNE   R0,#vwEvent_click       ;Yes -- that's a real one
 624                 BL      vw__dispatch            ;Sent the event on
 625                 LDMFD   R13!,{R0-R4,R14}        ;Save some registers
 626                 ORRS    PC,R14,#C_flag          ;We dealt with it
 627
 628                 LTORG
 629
 630 ; --- vw__evKey ---
 631 ;
 632 ; On entry:     R1 == pointer to caret info block
 633 ;
 634 ; On exit:      CC if unclaimed, else CS
 635 ;
 636 ; Use:          Handles a keypress while the viewer has the input focus.
 637
 638 vw__evKey       ROUT
 639
 640                 STMFD   R13!,{R0,R1,R14}        ;Save some registers
 641                 LDR     R0,[R1,#24]             ;Load the character code
 642                 BL      akbd_translate          ;Try translating the key
 643                 MOV     R1,R0                   ;Put this back in R1
 644                 MOV     R0,#vwEvent_key         ;Get the event code
 645                 BL      vw__dispatch            ;Dispatch the event
 646                 LDMFD   R13!,{R0,R1,R14}        ;Restore registers
 647                 ORRCSS  PC,R14,#C_flag          ;Claim if he claimed it
 648                 BICCCS  PC,R14,#C_flag          ;Don't claim if he didn't
 649
 650                 LTORG
 651
 652 ; --- vw__mDataSave ---
 653 ;
 654 ; On entry:     R0 == message code
 655 ;               R1 == pointer to message block
 656 ;
 657 ; On exit:      --
 658 ;
 659 ; Use:          Handles a file dropped on the viewer.
 660
 661 vw__mDataSave   ROUT
 662
 663                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
 664                 MOV     R4,#vwDrop_save         ;Say it's a save event
 665                 ADD     R3,R1,#44               ;Point to the filename
 666                 LDR     R2,[R1,#36]             ;Load the estimated size
 667                 LDR     R1,[R1,#40]             ;And the filetype
 668                 MOV     R0,#vwEvent_drop        ;Get the event code
 669                 BL      vw__dispatch            ;And send it to the client
 670                 LDMFD   R13!,{R0-R4,PC}^        ;And return to caller
 671
 672                 LTORG
 673
 674 ; --- vw__mDataLoad ---
 675 ;
 676 ; On entry:     R0 == message code
 677 ;               R1 == pointer to message block
 678 ;
 679 ; On exit:      --
 680 ;
 681 ; Use:          Handles a file dropped on the viewer.
 682
 683 vw__mDataLoad   ROUT
 684
 685                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
 686                 MOV     R4,#vwDrop_load         ;Say it's a load event
 687                 ADD     R3,R1,#44               ;Point to the filename
 688                 LDR     R2,[R1,#36]             ;Load the estimated size
 689                 LDR     R1,[R1,#40]             ;And the filetype
 690                 MOV     R0,#vwEvent_drop        ;Get the event code
 691                 BL      vw__dispatch            ;And send it to the client
 692                 LDMFD   R13!,{R0-R4,PC}^        ;And return to caller
 693
 694                 LTORG
 695
 696 ; --- vw__mHelpRq ---
 697 ;
 698 ; On entry:     R0 == message code
 699 ;               R1 == pointer to message block
 700 ;
 701 ; On exit:      --
 702 ;
 703 ; Use:          Handles a help request for the viewer.
 704
 705 vw__mHelpRq     ROUT
 706
 707                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
 708                 ADD     R14,R1,#20              ;Find the mouse position
 709                 LDMIA   R14,{R2,R3}             ;Load the coordinates
 710                 BL      vw__whichIcon           ;Find the icon pointed at
 711                 MOV     R0,#vwEvent_help        ;It's a help request
 712                 BL      vw__dispatch            ;Send it to the client
 713                 LDMFD   R13!,{R0-R3,PC}^        ;And return to caller
 714
 715                 LTORG
 716
 717 ; --- vw__mFontChnge ---
 718 ;
 719 ; On entry:     R0 == message code
 720 ;               R1 == pointer to message block
 721 ;
 722 ; On exit:      --
 723 ;
 724 ; Use:          Handles font changed events for the viewer.
 725
 726 vw__mFontChnge  ROUT
 727
 728                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
 729                 SUB     R13,R13,#36             ;Make a window state block
 730                 LDR     R14,[R10,#vw__window]   ;Load viewer's window handle
 731                 STR     R14,[R13,#0]            ;Store it in the block
 732                 MOV     R1,R13                  ;Point to this block
 733                 SWI     Wimp_GetWindowState     ;Read the window information
 734                 BL      vw__tWidth              ;Rescan the title width
 735                 BL      vw__rescanSize          ;Rescan the icon sizes
 736                 BL      vw__resize              ;Rearrange the icons
 737                 BL      vw__setExtent           ;Rework the extent
 738                 BL      vw__refresh             ;Redraw the work area
 739                 BL      vw__openWindow          ;And reopen the window
 740                 ADD     R13,R13,#36             ;Restore the stack pointer
 741                 LDMFD   R13!,{R0-R4,PC}^        ;Return to caller
 742
 743                 LTORG
 744
 745 ;----- Icon position handling -----------------------------------------------
 746
 747 ; --- vw__callShape ---
 748 ;
 749 ; On entry:     R0 == reason code
 750 ;               R1-R? == other arguments
 751 ;               R10 == pointer to viewer block
 752 ;
 753 ; On exit:      R0-R? and C returned from shape function
 754 ;
 755 ; Use:          Calls a shape function and returns the result.
 756
 757                 EXPORT  vw__callShape
 758 vw__callShape   ROUT
 759
 760                 STMFD   R13!,{R8-R10,R12,R14}   ;Save some registers
 761                 LDR     R8,[R10,#vw__shape]     ;Load the shape function addr
 762                 MOV     R9,R10                  ;Point to the viewer block
 763                 ADD     R14,R10,#vw__handler+4  ;Find owner's R10 and R12
 764                 LDMIA   R14,{R10,R12}           ;Load them out nicely too
 765                 CMP     R0,R0                   ;Set the C flag on entry
 766                 MOV     R14,PC                  ;Set up the return address
 767                 MOV     PC,R8                   ;Call the shape function
 768                 LDMFD   R13!,{R8-R10,R12,R14}   ;Restore registers
 769                 ORRCSS  PC,R14,#C_flag          ;If it set C, return C set
 770                 BICCCS  PC,R14,#C_flag          ;Otherwise return C clear
 771
 772                 LTORG
 773
 774 ; --- vw__whichIcon ---
 775 ;
 776 ; On entry:     R2,R3 == mouse coordinates (screen relative)
 777 ;               R10 == pointer to viewer block
 778 ;
 779 ; On exit:      R1 == icon beneath the mouse pointer
 780 ;
 781 ; Use:          Works out which icon the user is pointing at, should this be
 782 ;               interesting.
 783
 784 vw__whichIcon   ROUT
 785
 786                 STMFD   R13!,{R0,R2-R6,R14}     ;Save lots of registers
 787
 788                 ; --- Find the window's state ---
 789
 790                 SUB     R13,R13,#36             ;Drop the stack to make a blk
 791                 LDR     R14,[R10,#vw__window]   ;Get the window handle
 792                 STR     R14,[R13,#0]            ;Store that in the block
 793                 MOV     R1,R13                  ;Point to the block
 794                 SWI     Wimp_GetWindowState     ;Read the window state
 795
 796                 LDR     R0,[R13,#4]             ;Load the left hand side
 797                 ADD     R14,R13,#16             ;Point to the top edge
 798                 LDMIA   R14,{R4-R6}             ;Load those values out
 799                 SUB     R5,R0,R5                ;Work out x origin position
 800                 SUB     R6,R4,R6                ;And the y origin position
 801
 802                 ; --- Find the click position ---
 803
 804                 SUB     R2,R2,R5                ;Translate click coordinates
 805                 SUB     R3,R3,R6                ;Do that nicely
 806                 MOV     R14,R13                 ;Point to my nice block
 807                 STMIA   R14!,{R2,R3}            ;Save coordinates away
 808                 STMIA   R14!,{R2,R3}            ;And do it again
 809
 810                 ; --- Now do the enumeration ---
 811
 812                 MOV     R1,#0                   ;Start at the beginning
 813                 ADD     R2,R13,#16              ;Point to spare bit of block
 814                 MOV     R3,R13                  ;Point to my coordinates
 815                 BL      vw__withinBox           ;Try to find a match
 816                 MOVCC   R1,#0                   ;No match -- no icon
 817                 ADD     R13,R13,#36             ;Recover stack space
 818                 LDMFD   R13!,{R0,R2-R6,PC}^     ;And return to caller
 819
 820                 LTORG
 821
 822 ; --- vw__rescanSize ---
 823 ;
 824 ; On entry:     R10 == pointer to viewer block
 825 ;
 826 ; On exit:      --
 827 ;
 828 ; Use:          Recalculates the sizes of icons in the viewer.
 829
 830 vw__rescanSize  ROUT
 831
 832                 STMFD   R13!,{R0-R7,R14}        ;Save some registers
 833
 834                 ; --- Set up for the loop ---
 835
 836                 LDR     R6,[R10,#vw__listDef]   ;Find the list block
 837                 MOV     R1,#0                   ;No item found yet
 838                 ADD     R7,R10,#vw__stdDimens   ;Find standard dimensions
 839                 LDMIA   R7,{R4,R5}              ;These are minimum sizes
 840
 841                 ; --- Now read all the items ---
 842
 843 00              LDR     R0,[R10,#vw__list]      ;Find the list head
 844                 MOV     R2,#0                   ;Match any flags
 845                 MOV     R3,#0                   ;Still match any flags
 846                 MOV     R14,PC                  ;Set up return address
 847                 ADD     PC,R6,#vw__enumerate    ;Read the next list item
 848                 BCC     %10vw__rescanSize       ;If no more, skip on
 849                 LDMIA   R7,{R2,R3}              ;Load standard sizes
 850                 MOV     R0,#vwShape_size        ;Get the reason code
 851                 BL      vw__callShape           ;And call the shape function
 852                 CMP     R4,R2                   ;Now update the sizes
 853                 MOVCC   R4,R2                   ;Use the biggest on both
 854                 CMP     R5,R3                   ;Check the height too
 855                 MOVCC   R5,R3                   ;Use the biggest again
 856                 B       %b00                    ;Now loop round for more
 857
 858                 ; --- Finished -- store result away ---
 859
 860 10              ADD     R14,R10,#vw__iconWidth  ;Find current sizes
 861                 STMIA   R14,{R4,R5}             ;Store these new sizes
 862                 LDMFD   R13!,{R0-R7,PC}^        ;And return to caller
 863
 864                 LTORG
 865
 866 ; --- vw__intSimple ---
 867 ;
 868 ; On entry:     R2 == pointer to a box
 869 ;               R3 == pointer to another box
 870 ;
 871 ; On exit:      CS if boxes intersect, else CC
 872 ;
 873 ; Use:          Informs you whether boxes intersect.  Saves lots of
 874 ;               registers.  This is typically used before calling the
 875 ;               caller's shape routine to see if it's really worth it.
 876
 877                 EXPORT  vw__intSimple
 878 vw__intSimple   ROUT
 879
 880                 STMFD   R13!,{R0-R6,R14}        ;Save some registers
 881                 LDMIA   R3,{R4-R6,R14}          ;Load second box out
 882                 LDMIA   R2,{R0-R3}              ;Load first box out
 883                 CMP     R2,R4                   ;Now do the compare
 884                 CMPGE   R3,R5
 885                 CMPGE   R6,R0
 886                 CMPGE   R14,R1
 887                 LDMFD   R13!,{R0-R6,R14}        ;Restore registers
 888                 ORRGES  PC,R14,#C_flag          ;Return C set if OK
 889                 BICLTS  PC,R14,#C_flag          ;Otherwise return CC
 890
 891                 LTORG
 892
 893 ; --- vw__enum ---
 894 ;
 895 ; On entry:     R1 == 0 for first call, or item pointer
 896 ;               R2 == pointer to 16-byte coordinate buffer
 897 ;               R4 == continuation value from old call
 898 ;               R10 == pointer to viewer block
 899 ;
 900 ; On exit:      CS if more icons, and
 901 ;                 R1 == item handle
 902 ;                 R4 == new continuation value
 903 ;               else CC and
 904 ;                 R1,R4 corrupted
 905 ;
 906 ; Use:          Scans through icons, returning their coordinates in the
 907 ;               block.
 908 ;
 909 ;               This routine is exported, although it isn't for user
 910 ;               consumption.  People using it in application code will be
 911 ;               shot.
 912
 913                 EXPORT  vw__enum
 914 vw__enum        ROUT
 915
 916                 STMFD   R13!,{R0,R2,R3,R5-R8,R14} ;Save some registers
 917
 918                 ; --- Set up for first go round ---
 919
 920                 CMP     R1,#0                   ;Is this the first go?
 921                 BNE     %05vw__enum             ;No -- skip onwards then
 922
 923                 MOV     R4,#0                   ;Yes -- start at top left
 924
 925                 ADD     R14,R10,#vw__iconWidth  ;Find the icon dimensions
 926                 LDMIA   R14,{R7,R14}            ;Load them out of the block
 927                 MOV     R5,#vw__iconGap         ;Set up the gap nicely
 928                 ADD     R7,R5,R7                ;Work out right hand side
 929                 MOV     R8,#-vw__iconGap        ;Work out top edge
 930                 SUB     R6,R8,R14               ;And set up the bottom
 931                 STMIA   R2,{R5-R8}              ;Save all of those away
 932                 B       %10vw__enum             ;Now skip on to next bit
 933
 934                 ; --- Sort out a subsequent round ---
 935
 936 05vw__enum      LDMIA   R2,{R5,R6}              ;Load bottom left of icon
 937                 ADD     R14,R10,#vw__iconWidth  ;Find the icon dimensions
 938                 LDMIA   R14,{R7,R8}             ;Load them out of the block
 939                 ADD     R4,R4,#1                ;Bump horizontal position
 940                 LDR     R14,[R10,#vw__across]   ;How many icons going across?
 941                 CMP     R4,R14                  ;Reached the edge yet?
 942                 ADDCC   R5,R5,R7                ;No -- move along then
 943                 ADDCC   R5,R5,#vw__iconGap      ;Add on our extra spacing
 944                 MOVCS   R5,#vw__iconGap         ;Otherwise go back to left
 945                 MOVCS   R4,#0                   ;Return left side position
 946                 SUBCS   R6,R6,R8                ;Drop down one row
 947                 SUBCS   R6,R6,#vw__iconGap      ;And add on the spacing
 948                 ADD     R7,R5,R7                ;Work out other box position
 949                 ADD     R8,R6,R8                ;To make the box right
 950                 STMIA   R2,{R5-R8}              ;Store all that away
 951
 952                 ; --- Now advance the icon pointer ---
 953
 954 10vw__enum      LDR     R0,[R10,#vw__list]      ;Load the list base
 955                 MOV     R2,#0                   ;Give me all the icons
 956                 MOV     R3,#0                   ;I really mean that
 957                 LDR     R5,[R10,#vw__listDef]   ;Find the list block
 958                 MOV     R14,PC                  ;Set up return address
 959                 ADD     PC,R5,#vw__enumerate    ;Get the next item
 960                 LDMFD   R13!,{R0,R2,R3,R5-R8,R14} ;Unstack registers
 961                 ORRCSS  PC,R14,#C_flag          ;If more to come, OK
 962                 BICCCS  PC,R14,#C_flag          ;Otherwise return the end
 963
 964                 LTORG
 965
 966 ; --- vw__withinBox ---
 967 ;
 968 ; On entry:     R1 == 0 for first call, or pointer from previous
 969 ;               R2 == pointer to 16-byte buffer
 970 ;               R3 == pointer to coordinate box (window relative)
 971 ;               R4 == value from previous call
 972 ;               R10 == pointer to viewer block
 973 ;
 974 ; On exit:      CS if match found, and
 975 ;                 R1 == item handle of match
 976 ;                 R4 == continuation value
 977 ;               else CC and
 978 ;                 R1,R4 corrupted
 979 ;
 980 ; Use:          Enumerates icons which intersect a given rectangle.  The
 981 ;               coordinates of a matching icon are left in the block; these
 982 ;               must be set up correctly for the next call.
 983
 984 vw__withinBox   ROUT
 985
 986                 STMFD   R13!,{R0,R14}           ;Save some registers
 987                 MOV     R0,#vwShape_intersects  ;Get shape fn reason code
 988 00              BL      vw__enum                ;Get another icon
 989                 BCC     %10vw__withinBox        ;If no more, return now
 990                 BL      vw__intSimple           ;Check simple intersection
 991                 BLCS    vw__callShape           ;And then the complex one
 992                 BCC     %b00                    ;If no match, skip back
 993                 LDMFD   R13!,{R0,R14}           ;Restore registers
 994                 ORRS    PC,R14,#C_flag          ;And return match
 995
 996 10vw__withinBox LDMFD   R13!,{R0,R14}           ;Restore registers
 997                 BICS    PC,R14,#C_flag          ;Return no match
 998
 999                 LTORG
1000
1001 ; --- vw__iconBox ---
1002 ;
1003 ; On entry:     R1 == item pointer
1004 ;               R2 == pointer to a block to fill in
1005 ;               R10 == viewer handle
1006 ;
1007 ; On exit:      --
1008 ;
1009 ; Use:          Works out the bounding box of an icon (within the window).
1010
1011 vw__iconBox     ROUT
1012
1013                 STMFD   R13!,{R0-R5,R14}        ;Save some registers
1014
1015                 ; --- First, get the icon index ---
1016
1017                 LDR     R0,[R10,#vw__list]      ;Load the list head pointer
1018                 LDR     R5,[R10,#vw__listDef]   ;Find the definition too
1019                 MOV     R14,PC                  ;Set up return address
1020                 ADD     PC,R5,#vw__itemToIndex  ;Find the item's index
1021
1022                 ; --- Now work out its across and down position ---
1023
1024                 MOV     R0,R1                   ;Get the item index
1025                 LDR     R1,[R10,#vw__across]    ;Find icons going across
1026                 BL      divide                  ;Do the division
1027
1028                 ; --- Finally find the actual position ---
1029
1030                 ADD     R14,R10,#vw__iconWidth  ;Point to icon dimens
1031                 LDMIA   R14,{R4,R5}             ;Load the width and height
1032                 ADD     R3,R4,#vw__iconGap      ;Add on the gap here
1033                 ADD     R14,R5,#vw__iconGap     ;And again, please
1034                 MUL     R14,R0,R14              ;Work out vertical placing
1035                 MUL     R0,R1,R3                ;And the horizontal placing
1036                 RSB     R14,R14,#0              ;Make vertical position -ve
1037                 ADD     R0,R0,#vw__iconGap      ;Push the icon in a little
1038                 SUB     R14,R14,#vw__iconGap    ;And push it down a little
1039                 ADD     R3,R0,R4                ;Work out the right side
1040                 SUB     R1,R14,R5               ;And the bottom edge
1041                 STMIA   R2,{R0,R1,R3,R14}       ;Save them in my block
1042                 LDMFD   R13!,{R0-R5,PC}^        ;And return to caller
1043
1044                 LTORG
1045
1046 ;----- Default selection model ----------------------------------------------
1047
1048 ; --- viewer_select ---
1049 ;
1050 ; On entry:     R0 == viewer handle
1051 ;               R1 == icon handle
1052 ;               R2 == 0 to unselect, 1 to select or 2 to toggle
1053 ;
1054 ; On exit:      --
1055 ;
1056 ; Use:          Selects an icon, or maybe unselects it.  Whatever, it doesn't
1057 ;               flicker if it doesn't need to.
1058
1059                 EXPORT  viewer_select
1060 viewer_select   ROUT
1061
1062                 CMP     R1,#0                   ;Is there an icon?
1063                 MOVEQS  PC,R14                  ;No -- do nothing then
1064
1065                 STMFD   R13!,{R0-R5,R10,R14}    ;Save some registers
1066                 MOV     R10,R0                  ;Get the viewer block pointer
1067
1068                 ; --- Read the current flags ---
1069
1070                 LDR     R4,[R10,#vw__listDef]   ;Get the list definition
1071                 MOV     R5,R2                   ;And get the argument
1072                 MOV     R3,#0                   ;Don't toggle flags
1073                 MOV     R2,#0                   ;Don't clear any flags
1074                 LDR     R0,[R10,#vw__list]      ;Load the list base address
1075                 MOV     R14,PC                  ;Set up return address
1076                 ADD     PC,R4,#vw__setFlags     ;Read the current flags
1077
1078                 ; --- Work out the new ones ---
1079
1080                 AND     R2,R2,#1                ;Leave only selected flag
1081                 CMP     R5,#1                   ;What is the operation?
1082                 MOVLT   R3,#0                   ;Clear -- clear the flag
1083                 MOVEQ   R3,#1                   ;Set -- set the flag
1084                 EORGT   R3,R2,#1                ;Toggle -- toggle the flag
1085                 CMP     R3,R2                   ;Have we made a difference?
1086                 LDMEQFD R13!,{R0-R5,R10,PC}^    ;No -- return now then
1087
1088                 ; --- Set the new flags now ---
1089
1090                 MOV     R2,#1                   ;Clear the selected bit
1091                 MOV     R14,PC                  ;Set up return address
1092                 ADD     PC,R4,#vw__setFlags     ;Set the new flags
1093                 MOV     R0,R10                  ;Get handle in R0
1094                 BL      viewer_update           ;Update the icon
1095                 LDMFD   R13!,{R0-R5,R10,PC}^    ;Return to caller
1096
1097                 LTORG
1098
1099 ; --- viewer_isSelected ---
1100 ;
1101 ; On entry:     R0 == viewer handle
1102 ;               R1 == icon handle
1103 ;
1104 ; On exit:      CS if icon is selected, else CC
1105 ;
1106 ; Use:          Informs you whether an icon is selected.
1107
1108                 EXPORT  viewer_isSelected
1109 viewer_isSelected ROUT
1110
1111                 CMP     R1,#0                   ;Is there an icon?
1112                 BICEQS  PC,R14,#C_flag          ;No -- not selected then
1113                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
1114                 MOV     R2,#0                   ;Don't clear any flags
1115                 MOV     R3,#0                   ;Don't toggle any either
1116                 LDR     R4,[R0,#vw__listDef]    ;Find the list block
1117                 LDR     R0,[R0,#vw__list]       ;Find the list base
1118                 MOV     R14,PC                  ;Set up return address
1119                 ADD     PC,R4,#vw__setFlags     ;Read the current flags
1120                 TST     R2,#1                   ;Is it selected then?
1121                 LDMFD   R13!,{R0-R4,R14}        ;Restore caller's registers
1122                 ORRNES  PC,R14,#C_flag          ;If selected, return C set
1123                 BICEQS  PC,R14,#C_flag          ;Otherwise clear C on exit
1124
1125                 LTORG
1126
1127 ; --- viewer_selectAll ---
1128 ;
1129 ; On entry:     R0 == viewer handle
1130 ;               R2 == 0 to deselect, or 1 to select
1131 ;
1132 ; On exit:      --
1133 ;
1134 ; Use:          Selects or deselects all the icons in a viewer.
1135
1136                 EXPORT  viewer_selectAll
1137 viewer_selectAll ROUT
1138
1139                 STMFD   R13!,{R0-R5,R10,R14}    ;Save some registers
1140                 MOV     R10,R0                  ;Look after the handle
1141                 MOV     R1,#0                   ;Start at the beginning
1142                 MOV     R4,R2                   ;Look after selection state
1143                 LDR     R5,[R10,#vw__listDef]   ;Find the list block
1144
1145 00              LDR     R0,[R10,#vw__list]      ;Find the list head
1146                 MOV     R2,#1                   ;Check the selected bit
1147                 EOR     R3,R4,#1                ;Find interesting icons
1148                 MOV     R14,PC                  ;Set up return address
1149                 ADD     PC,R5,#vw__enumerate    ;Find next icon
1150                 BCC     %f00                    ;If all done, skip on
1151                 MOV     R0,R10                  ;Get viewer handle
1152                 MOV     R2,R4                   ;Get selection state
1153                 BL      viewer_select           ;Do the selection
1154                 B       %b00                    ;And skip back for the rest
1155
1156 00              MOV     R14,#0                  ;Clear temporary selection
1157                 STR     R14,[R10,#vw__tempSel]  ;Store that in the block
1158                 LDMFD   R13!,{R0-R5,R10,PC}^    ;Return to caller when done
1159
1160                 LTORG
1161
1162 ; --- viewer_click ---
1163 ;
1164 ; On entry:     R0 == viewer handle
1165 ;               R1 == icon handle (or 0)
1166 ;               R2 == mouse button state
1167 ;
1168 ; On exit:      --
1169 ;
1170 ; Use:          Handles a click, drag etc. according to the standard
1171 ;               selection model.
1172
1173                 EXPORT  viewer_click
1174 viewer_click    ROUT
1175
1176                 TST     R2,#&002                ;Is this a menu click?
1177                 BNE     %20viewer_click         ;Yes -- handle it then
1178                 TST     R2,#&400                ;Is this a SELECT click?
1179                 BNE     %10viewer_click         ;Yes -- handle that
1180                 TST     R2,#&050                ;Is this a drag?
1181                 BNE     %50viewer_click         ;Yes -- start a drag box
1182                 TST     R2,#&100                ;Is this an ADJUST click?
1183                 MOVEQS  PC,R14                  ;No -- do nothing then
1184
1185                 ; --- Handle an ADJUST click ---
1186
1187                 STMFD   R13!,{R2,R14}           ;Save some registers
1188                 BL      viewer_clearTemp        ;Clear temporary selection
1189                 MOV     R2,#2                   ;Now select interesting icon
1190                 BL      viewer_select           ;Do the selection op
1191                 LDMFD   R13!,{R2,PC}^           ;And return to caller
1192
1193                 ; --- Handle a SELECT click ---
1194
1195 10viewer_click  STMFD   R13!,{R2,R14}           ;Save some registers
1196                 BL      viewer_clearTemp        ;Clear temporary selection
1197                 BL      viewer_isSelected       ;Is the icon selected?
1198                 LDMCSFD R13!,{R2,PC}^           ;Yes -- do nothing then
1199                 MOV     R2,#0                   ;Clear entire selection
1200                 BL      viewer_selectAll        ;Do that then
1201                 MOV     R2,#1                   ;Now select my icon
1202                 BL      viewer_select           ;Go do that then
1203                 LDMFD   R13!,{R2,PC}^           ;And return to caller
1204
1205                 ; --- Handle a MENU click ---
1206
1207 20viewer_click  STMFD   R13!,{R0-R5,R10,R14}    ;Save some registers
1208                 MOV     R10,R0                  ;Look after the handle
1209                 BL      viewer_clearTemp        ;Clear temporary selection
1210                 MOV     R4,R1                   ;Look after icon handle
1211                 LDR     R5,[R10,#vw__listDef]   ;Find the list definition
1212                 LDR     R0,[R10,#vw__list]      ;Find the list base
1213                 MOV     R1,#0                   ;Start at the beginning
1214                 MOV     R2,#1                   ;Check selected bit
1215                 MOV     R3,#1                   ;Any with it set?
1216                 MOV     R14,PC                  ;Set return address
1217                 ADD     PC,R5,#vw__enumerate    ;Find first selected icon
1218                 LDMCSFD R13!,{R0-R5,R10,PC}^    ;Robust selection -- quit now
1219                 MOV     R0,R10                  ;Get the handle back
1220                 MOV     R1,R4                   ;Get clicked icon
1221                 MOV     R2,#1                   ;Select the icon
1222                 BL      viewer_select           ;Go select it then
1223                 STR     R1,[R10,#vw__tempSel]   ;This is temporary selection
1224                 LDMFD   R13!,{R0-R5,R10,PC}^    ;Return to caller
1225
1226                 ; --- Handle a drag ---
1227
1228 50viewer_click  CMP     R1,#0                   ;Is there actually an icon?
1229                 BNE     %60viewer_click         ;Yes -- handle that
1230                 STMFD   R13!,{R0-R5,R14}        ;Save some registers
1231                 MOV     R4,R0                   ;Pass viewer handle in R10
1232                 MOV     R5,#0                   ;I have no workspace
1233                 LDR     R0,[R4,#vw__window]     ;Load the window handle
1234                 MOV     R1,#0                   ;No flags to set
1235                 ADR     R2,vw__dragSel          ;Point to drag handler
1236                 MOV     R3,#0                   ;No magic number in R9
1237                 BL      drag_start              ;Start the drag operation
1238                 LDMFD   R13!,{R0-R5,PC}^        ;And return to caller
1239
1240                 ; --- Handle drag on an icon -- select it ---
1241
1242 60viewer_click  STMFD   R13!,{R2,R14}           ;Save some registers
1243                 MOV     R2,#1                   ;Select the icon
1244                 BL      viewer_select           ;Do that then
1245                 LDMFD   R13!,{R2,PC}^           ;And return to caller
1246
1247                 LTORG
1248
1249 ; --- vw__dragSel ---
1250 ;
1251 ; On entry:     R0 == drag op event code
1252 ;               Other registers depend on this
1253 ;
1254 ; On exit:      --
1255 ;
1256 ; Use:          Handles events during a marquee-select drag operation.
1257
1258 vw__dragSel     ROUT
1259
1260                 CMP     R0,#7                   ;Is this a kosher event?
1261                 ADDCC   PC,PC,R0,LSL #2         ;Yes -- then dispatch it
1262                 MOVS    PC,R14                  ;Otherwise ignore it
1263
1264                 B       vw__dragRender          ;Draw the drag box
1265                 B       vw__dragRender          ;Undraw the drag box
1266                 B       vw__dragRender          ;Rotate the drag box
1267                 MOVS    PC,R14                  ;Do no coordinate conversion
1268                 B       vw__dragScroll          ;Auto-scroll the viewer
1269                 B       vw__dragDone            ;Completed the drag OK
1270                 MOVS    PC,R14                  ;Drag operation cancelled
1271
1272                 ; --- Draw the drag box ---
1273
1274 vw__dragRender  STMFD   R13!,{R0-R5,R14}        ;Save some registers
1275
1276                 ; --- Set the colour up ---
1277
1278                 MOV     R0,#1                   ;Background colour is 1
1279                 MOV     R1,#7                   ;Make lines black, please
1280                 BL      drag_eorColour          ;Set the colour up
1281
1282                 ; --- Now render the drag box ---
1283
1284                 SUB     R4,R4,R2                ;Get the box width
1285                 SUB     R5,R5,R3                ;And the box height
1286
1287                 MOV     R0,#4                   ;Move cursor absolute
1288                 ADD     R1,R6,R2                ;Find the start position
1289                 ADD     R2,R7,R3                ;Set up the y position too
1290                 SWI     OS_Plot                 ;Move the graphics cursor
1291
1292                 MOV     R0,#17                  ;Relative dotted plot
1293                 MOV     R1,R4                   ;Plot bottom line
1294                 MOV     R2,#0                   ;Keep y constant
1295                 SWI     OS_Plot
1296                 MOV     R0,#49                  ;Relative dotted plot
1297                 MOV     R1,#0                   ;Keep x constant
1298                 MOV     R2,R5                   ;Plot right hand side
1299                 SWI     OS_Plot
1300                 MOV     R0,#49                  ;Relative dotted plot
1301                 RSB     R1,R4,#0                ;Plot top line
1302                 MOV     R2,#0                   ;Keep y constant
1303                 SWI     OS_Plot
1304                 MOV     R0,#57                  ;Relative dotted plot
1305                 MOV     R1,#0                   ;Keep x constant
1306                 RSB     R2,R5,#0                ;Plot left hand side
1307                 SWI     OS_Plot                 ;Plot that too
1308
1309                 LDMFD   R13!,{R0-R5,PC}^        ;And return to caller
1310
1311                 ; --- Scroll the window during the drag ---
1312
1313 vw__dragScroll  STMFD   R13!,{R0-R3,R14}        ;Save some registers
1314                 BL      drag_scroll             ;Get the scroll position
1315                 STR     R3,[R1,#24]             ;Save vertical scroll posn
1316                 BL      vw__openWindow          ;Reopen the window
1317                 LDMFD   R13!,{R0-R3,PC}^        ;And return to caller
1318
1319                 ; --- Handle the end of the drag ---
1320
1321 vw__dragDone    STMFD   R13!,{R0-R5,R14}        ;Save some registers
1322
1323                 ; --- Fiddle the coordinates ---
1324
1325                 CMP     R2,R4                   ;Are these the right way?
1326                 EORGT   R2,R2,R4                ;No -- swap them round then
1327                 EORGT   R4,R2,R4
1328                 EORGT   R2,R2,R4
1329
1330                 CMP     R3,R5                   ;Are these the right way?
1331                 EORGT   R3,R3,R5                ;No -- swap them round then
1332                 EORGT   R5,R3,R5
1333                 EORGT   R3,R3,R5
1334
1335                 ; --- Now enumerate matching boxes ---
1336
1337                 STMFD   R13!,{R2-R5}            ;Stuff the drag box on stack
1338                 SUB     R13,R13,#16             ;And make another block
1339
1340                 MOV     R0,R10                  ;Get the viewer handle
1341                 MOV     R1,#0                   ;Start at the beginning
1342                 ADD     R3,R13,#16              ;Point at the drag box
1343
1344 00              MOV     R2,R13                  ;Point to my spare block
1345                 BL      vw__withinBox           ;Get next matching icon
1346                 MOVCS   R2,#1                   ;Select this icon please
1347                 BLCS    viewer_select           ;Please do that
1348                 BCS     %b00                    ;And loop back
1349
1350                 ; --- Finished -- return ---
1351
1352                 ADD     R13,R13,#32             ;Restore the stack block
1353                 LDMFD   R13!,{R0-R5,PC}^        ;And return to caller
1354
1355                 LTORG
1356
1357 ; --- viewer_clearTemp ---
1358 ;
1359 ; On entry:     R0 == viewer handle
1360 ;
1361 ; On exit:      --
1362 ;
1363 ; Use:          Clears the temporary selection (use when you receive a
1364 ;               menu closed event).
1365
1366 viewer_clearTemp ROUT
1367
1368                 STMFD   R13!,{R1,R2,R14}        ;Save some registers
1369                 LDR     R1,[R0,#vw__tempSel]    ;Find temporary selection
1370                 CMP     R1,#0                   ;Is that defined?
1371                 LDMEQFD R13!,{R1,R2,PC}^        ;No -- return now
1372                 MOV     R2,#0                   ;Yes -- deselect the icon
1373                 BL      viewer_select           ;Go do that then
1374                 MOV     R14,#0                  ;And also clear temp select
1375                 STR     R14,[R0,#vw__tempSel]   ;Store that in the block
1376                 LDMFD   R13!,{R1,R2,PC}^        ;Return to caller when done
1377
1378                 LTORG
1379
1380 ; --- viewer_dragSelection ---
1381 ;
1382 ; On entry:     R0 == viewer handle
1383 ;
1384 ; On exit:      --
1385 ;
1386 ; Use:          Starts a drag of the icons within the viewer.  When the drag
1387 ;               is finished, you get sent a vwEvent_dragged event.
1388
1389                 EXPORT  viewer_dragSelection
1390 viewer_dragSelection ROUT
1391
1392                 STMFD   R13!,{R0-R10,R14}       ;Save lots of registers
1393                 MOV     R10,R0                  ;Look after the viewer handle
1394                 LDR     R9,[R10,#vw__listDef]   ;Find the list definition
1395
1396                 ; --- First, see if we need DragASprite ---
1397
1398                 MOV     R0,#161                 ;Read CMOS locations
1399                 MOV     R1,#28                  ;Various strange status flags
1400                 SWI     OS_Byte                 ;Do the read op
1401                 TST     R2,#2                   ;Is the bit set?
1402                 BEQ     %50viewer_dragSelection ;No -- use normal Wimp box
1403
1404                 ; --- Work out what sprite to use ---
1405                 ;
1406                 ; We need to ask the client here.
1407
1408                 LDR     R0,[R10,#vw__list]      ;Load the list base pointer
1409                 MOV     R1,#0                   ;Start at the beginning
1410                 MOV     R2,#1                   ;Check the selected bit
1411                 MOV     R3,#1                   ;Make sure it's on
1412                 MOV     R14,PC                  ;Set up return address
1413                 ADD     PC,R9,#vw__enumerate    ;Read first matching item
1414                 BCC     %90viewer_dragSelection ;No selection -- no drag
1415                 MOVCS   R4,R1                   ;Match -- get icon handle
1416                 MOVCS   R14,PC                  ;And set up again
1417                 ADDCS   PC,R9,#vw__enumerate    ;Read next matching iten
1418                 MOVCS   R4,#-1                  ;If more than one, say `many'
1419
1420                 MOV     R1,R4                   ;Give this to the client
1421                 MOV     R0,#vwEvent_sprite      ;Pretend it's an event
1422                 BL      vw__dispatch            ;And send it off nicely
1423                 BCC     %50viewer_dragSelection ;Told to use Wimp box
1424
1425                 ; --- Now use DragASprite nicely ---
1426
1427                 MOV     R2,R1                   ;Look after the name
1428                 MOV     R3,R0                   ;And the sprite area
1429                 SUB     R13,R13,#20             ;Make a small block
1430                 MOV     R1,R13                  ;Point to the block
1431                 SWI     Wimp_GetPointerInfo     ;Read the pointer position
1432                 MOV     R14,R13                 ;Point to the block
1433                 LDMIA   R14,{R0,R1}             ;Load the coordinates out
1434                 SUB     R0,R0,#64               ;Turn into a little box
1435                 SUB     R1,R1,#64               ;Chop off a little bit
1436                 STMIA   R14!,{R0,R1}            ;Store them back
1437                 ADD     R0,R0,#128              ;Work out the other side
1438                 ADD     R1,R1,#128              ;Add on quite a lot actually
1439                 STMIA   R14!,{R0,R1}            ;Store them back
1440
1441                 MOV     R0,#&C5                 ;DragASprite flags
1442                 MOV     R1,R3                   ;Get the sprite area
1443                 MOV     R3,R13                  ;Point to my rectangle block
1444                 SWI     XDragASprite_Start      ;Start the drag operation
1445                 ADD     R13,R13,#20             ;Reclaim the stack pointer
1446                 BVC     %70viewer_dragSelection ;If it worked, set up handler
1447
1448                 ; --- Try and do a dotted outline ---
1449
1450 50              SUB     R13,R13,#40             ;Make a small block
1451                 LDR     R0,[R10,#vw__list]      ;Find the list definition
1452                 MOV     R1,#0                   ;Start at the beginning
1453                 MOV     R2,#1                   ;Check selected bits
1454                 MOV     R3,#1                   ;Make sure they're on
1455                 MOV     R14,PC                  ;Set up return address
1456                 ADD     PC,R9,#vw__enumerate    ;Do the enumeration
1457                 ADDCC   R13,R13,#40             ;Restore stack pointer
1458                 BCC     %90viewer_dragSelection ;No selection -- no drag
1459
1460                 MOV     R2,R13                  ;Point to a block
1461                 BL      vw__iconBox             ;Find the icon's bounding box
1462                 LDMIA   R2,{R4-R7}              ;Load the bounding box
1463
1464                 ; --- Now work out the bounding box of selected icons ---
1465
1466 00              MOV     R2,#1                   ;Check selected bits
1467                 MOV     R3,#1                   ;Make sure they're on
1468                 MOV     R14,PC                  ;Set up return address
1469                 ADD     PC,R9,#vw__enumerate    ;Do the enumeration
1470                 BCC     %f00                    ;No more -- skip onwards
1471                 MOV     R2,R13                  ;Point to a block
1472                 BL      vw__iconBox             ;Find the bounding box
1473                 LDMIA   R2,{R2,R3,R8,R14}       ;Load these coordinates
1474
1475                 CMP     R4,R2
1476                 MOVGT   R4,R2
1477                 CMP     R5,R3
1478                 MOVGT   R5,R3
1479                 CMP     R6,R8
1480                 MOVLT   R6,R8
1481                 CMP     R7,R14
1482                 MOVLT   R7,R14
1483
1484                 B       %b00                    ;Loop back for the rest now
1485
1486                 ; --- Translate coordinates to screen relative ---
1487
1488 00              MOV     R1,R13                  ;Point to my block
1489                 SWI     Wimp_GetPointerInfo     ;Read the pointer position
1490                 LDMIA   R13,{R8,R9}             ;Load the position out
1491
1492                 LDR     R14,[R10,#vw__window]   ;Load the window handle
1493                 STR     R14,[R13,#0]            ;Store it in the block
1494                 SWI     Wimp_GetWindowState     ;Read the window position
1495                 LDR     R0,[R13,#4]             ;Load the left hand side
1496                 ADD     R14,R13,#16             ;Point to top edge/scroll
1497                 LDMIA   R14,{R1-R3}             ;Load those out nicely
1498                 SUB     R2,R0,R2                ;Work out x origin pos
1499                 SUB     R3,R1,R3                ;And the y origin pos
1500
1501                 ADD     R4,R4,R2
1502                 ADD     R5,R5,R3
1503                 ADD     R6,R6,R2
1504                 ADD     R7,R7,R3
1505
1506                 SUB     R4,R4,#vw__iconGap /2
1507                 SUB     R5,R5,#vw__iconGap /2
1508                 ADD     R6,R6,#vw__iconGap /2
1509                 ADD     R7,R7,#vw__iconGap /2
1510
1511                 ADD     R14,R13,#8              ;Point to bit of block
1512                 STMIA   R14,{R4-R7}             ;Save the drag box position
1513
1514                 ; --- Work out the parent box position ---
1515
1516                 SUB     R4,R4,R8                ;Work out min x position
1517                 SUB     R5,R5,R9                ;And the min y position
1518                 SUB     R6,R6,R8                ;Fiddle with max x
1519                 SUB     R7,R7,R9                ;And max y
1520                 BL      screen_getInfo          ;Read the screen information
1521                 ADD     R14,R0,#screen_width    ;Find the screen dimensions
1522                 LDMIA   R14,{R8,R9}             ;Load them out nicely
1523                 ADD     R6,R6,R8                ;Work out max x position
1524                 ADD     R7,R7,R9                ;And the max y position
1525                 ADD     R14,R0,#screen_dx       ;Get the pixel sizes
1526                 LDMIA   R14,{R8,R9}             ;Load those out too
1527                 SUB     R6,R6,R8                ;Subtract a pixel off
1528                 SUB     R7,R7,R9                ;To make things nice
1529                 ADD     R14,R13,#24             ;Point to parent box area
1530                 STMIA   R14,{R4-R7}             ;Save that lot away
1531
1532                 ; --- Start the drag (phew...) ---
1533
1534                 MOV     R14,#5                  ;Drag fixed sized box
1535                 STR     R14,[R13,#4]            ;Store it in the block
1536                 MOV     R1,R13                  ;Point to the block
1537                 SWI     Wimp_DragBox            ;And start the drag op
1538                 ADD     R13,R13,#40             ;Reclaim my drag box block
1539
1540                 ; --- Set up my handler at the end of it ---
1541
1542 70              ADR     R0,vw__dragIcn          ;Point to my handler
1543                 MOV     R2,R10                  ;Pass viewer handle in R10
1544                 MOV     R3,R12                  ;And workspace (?) in R12
1545                 BL      win_unknownHandler      ;Register that routine please
1546 90              LDMFD   R13!,{R0-R10,PC}^       ;And return to caller
1547
1548                 LTORG
1549
1550 ; --- vw__dragIcn ---
1551 ;
1552 ; On entry:     R0 == event code
1553 ;               R1 == pointer to event block
1554 ;
1555 ; On exit:      --
1556 ;
1557 ; Use:          Handles events during a selection drag.
1558
1559 vw__dragIcn     ROUT
1560
1561                 CMP     R0,#7                   ;Is it a drag end event?
1562                 MOVNES  PC,R14                  ;Nope -- nothing to do
1563
1564                 STMFD   R13!,{R0-R2,R14}        ;Save some registers
1565                 SWI     XDragASprite_Stop       ;Turn off any sprite drags
1566                 SUB     R13,R13,#20             ;Make a little block
1567                 MOV     R1,R13                  ;Point to the block
1568                 SWI     Wimp_GetPointerInfo     ;Read the pointer position
1569                 ADD     R14,R1,#12              ;Point to window handle
1570                 LDMIA   R14,{R1,R2}             ;Load window and icon
1571                 ADD     R13,R13,#20             ;Restore stack block
1572                 MOV     R0,#vwEvent_dragged     ;Get the event code
1573                 BL      vw__dispatch            ;Send it the event
1574                 LDMFD   R13!,{R0-R2,PC}^        ;And return to caller
1575
1576                 LTORG
1577
1578 ;----- Miscellaneous --------------------------------------------------------
1579
1580 ; --- viewer_window ---
1581 ;
1582 ; On entry:     R0 == viewer handle
1583 ;
1584 ; On exit:      R0 == window handle
1585 ;
1586 ; Use:          Returns the window handle of the viewer.
1587
1588                 EXPORT  viewer_window
1589 viewer_window   ROUT
1590
1591                 LDR     R0,[R0,#vw__window]     ;Load the window handle
1592                 MOVS    PC,R14                  ;And return to caller
1593
1594                 LTORG
1595
1596 ; --- viewer_update ---
1597 ;
1598 ; On entry:     R0 == viewer handle
1599 ;               R1 == icon handle
1600 ;
1601 ; On exit:      --
1602 ;
1603 ; Use:          Updates (redraws) a given icon.
1604
1605                 EXPORT  viewer_update
1606 viewer_update   ROUT
1607
1608                 STMFD   R13!,{R2,R14}           ;Save some registers
1609                 MOV     R2,#vwEvent_redraw      ;Normal is redraw event
1610                 BL      vw__doUpdate            ;Go and do the update
1611                 LDMFD   R13!,{R2,PC}^           ;And return to caller
1612
1613                 LTORG
1614
1615 ; --- vw__doUpdate ---
1616 ;
1617 ; On entry:     R0 == viewer handle
1618 ;               R1 == icon handle
1619 ;               R2 == event code to send
1620 ;
1621 ; On exit:      --
1622 ;
1623 ; Use:          Updates an item, passing a given event to the client.  This
1624 ;               is purely for the use of gallery ;-)
1625
1626                 EXPORT  vw__doUpdate
1627 vw__doUpdate    ROUT
1628
1629                 STMFD   R13!,{R0-R7,R10,R14}    ;Save some registers
1630                 MOV     R10,R0                  ;Get the viewer handle in R10
1631                 MOV     R7,R2                   ;Find the event code
1632
1633                 ; --- Start the update job ---
1634
1635                 SUB     R13,R13,#32+44          ;Make a rectangle block
1636                 MOV     R2,R13                  ;Point to space for box
1637                 BL      vw__iconBox             ;Find the icon's box
1638
1639                 LDMIA   R2,{R2-R5}              ;Load the box coordinates
1640                 ADD     R14,R13,#32+4           ;Find the update block
1641                 STMIA   R14,{R2-R5}             ;Store the rectangle there
1642                 LDR     R14,[R10,#vw__window]   ;Load the window handle
1643                 STR     R14,[R13,#32+0]         ;Store in my nice block
1644                 MOV     R4,R1                   ;Look after icon handle
1645                 ADD     R1,R13,#32              ;Point to update block
1646                 SWI     Wimp_UpdateWindow       ;Start the update job
1647                 CMP     R0,#0                   ;Anything to do?
1648                 BEQ     %90vw__doUpdate         ;No -- skip to end then
1649
1650                 ; --- Read the window origin ---
1651
1652                 LDR     R2,[R13,#32+4]          ;Load the left hand side
1653                 ADD     R14,R13,#32+16          ;Find top and scroll offsets
1654                 LDMIA   R14,{R3,R5,R6}          ;Load those out too
1655                 SUB     R6,R3,R6                ;Find the y origin position
1656                 SUB     R5,R2,R5                ;And the x origin position
1657
1658                 ; --- Now embark on the main loop ---
1659
1660 00              ADD     R14,R13,#32+28          ;Point to graphics rectangle
1661                 LDMIA   R14,{R0-R3}             ;Load that out
1662                 SUB     R0,R0,R5                ;Adjust the block by origin
1663                 SUB     R1,R1,R6                ;This is just to keep the
1664                 SUB     R2,R2,R5                ;User's event handler happy
1665                 SUB     R3,R3,R6                ;I know what needs to be done
1666                 STMIA   R14,{R0-R3}             ;Store that lot back
1667
1668                 MOV     R0,R7                   ;Get the redraw event ready
1669                 MOV     R1,R4                   ;Point to the item
1670                 MOV     R2,R13                  ;Point to his icon block
1671                 ADD     R3,R13,#32+28           ;Point to clipping block
1672                 BL      vw__dispatch            ;Send to the handler
1673
1674                 ; --- Do any other bits of drawing ---
1675
1676                 ADD     R1,R13,#32              ;Point to update block
1677                 CMP     R7,#vwEvent_draw        ;Gallery redraw event? (yuk)
1678                 BLEQ    drag_redraw             ;Yes -- update drag rectangle
1679                 SWI     Wimp_GetRectangle       ;Do that rectangle
1680                 CMP     R0,#0                   ;Any more to do?
1681                 BNE     %b00                    ;Yes -- do it then
1682
1683                 ; --- Wrap up and return ---
1684
1685 90              ADD     R13,R13,#32+44          ;Restore the stack
1686                 LDMFD   R13!,{R0-R7,R10,PC}^    ;And return to caller
1687
1688                 LTORG
1689
1690 ; --- viewer_setTitle ---
1691 ;
1692 ; On entry:     R0 == viewer handle
1693 ;               R1 == title string
1694 ;
1695 ; On exit:      --
1696 ;
1697 ; Use:          Sets the viewer window's title.
1698
1699                 EXPORT  viewer_setTitle
1700 viewer_setTitle ROUT
1701
1702                 STMFD   R13!,{R0-R2,R10,R14}    ;Save some registers
1703                 MOV     R10,R0                  ;Get the viewer handle
1704                 LDR     R2,[R10,#vw__window]    ;Load the window handle
1705                 MOV     R0,R1                   ;Get the string to set
1706                 ADD     R1,R10,#vw__title       ;Point to title bar buffer
1707                 BL      winUtils_setTitle       ;Do the title setting
1708                 BL      vw__open                ;Is the window open?
1709                 LDMCCFD R13!,{R0-R2,R10,PC}^    ;No -- do nothing then
1710
1711                 SUB     R13,R13,#36             ;Make a window state block
1712                 LDR     R14,[R10,#vw__window]   ;Load the window handle
1713                 STR     R14,[R13,#0]            ;Store it in the block
1714                 MOV     R1,R13                  ;Point to the block
1715                 SWI     Wimp_GetWindowState     ;Read the current position
1716
1717                 BL      vw__tWidth              ;Yes -- reset the width
1718                 BL      vw__setExtent           ;And reset the extent
1719                 BL      vw__openWindow          ;Open the window, in case
1720                 ADD     R13,R13,#36             ;And reset the stack pointer
1721                 LDMFD   R13!,{R0-R2,R10,PC}^    ;And return to caller
1722
1723                 LTORG
1724
1725 ; --- vw__open ---
1726 ;
1727 ; On entry:     R10 == pointer to viewer block
1728 ;
1729 ; On exit:      CS if window is open, else CC
1730 ;
1731 ; Use:          Sees if a viewer window is currently open.
1732
1733 vw__open        ROUT
1734
1735                 STMFD   R13!,{R0,R1,R14}        ;Save some registers
1736                 SUB     R13,R13,#36             ;Make some space
1737                 LDR     R14,[R10,#vw__window]   ;Load the window handle
1738                 STR     R14,[R13,#0]            ;Save it in the block
1739                 MOV     R1,R13                  ;Point to the block
1740                 SWI     Wimp_GetWindowState     ;Read the information
1741                 LDR     R14,[R13,#32]           ;Load the flags word
1742                 TST     R14,#1<<16              ;Is the window open?
1743                 ADD     R13,R13,#36             ;Reclaim the stack space
1744                 LDMFD   R13!,{R0,R1,R14}        ;Restore registers
1745                 ORRNES  PC,R14,#C_flag          ;Return with C set if so
1746                 BICEQS  PC,R14,#C_flag          ;Otherwise clear C
1747
1748                 LTORG
1749
1750 ; --- vw__openWindow ---
1751 ;
1752 ; On entry:     R1 == pointer to window state block
1753 ;               R10 == pointer to viewer block
1754 ;
1755 ; On exit:      R0 corrupted (just like Wimp_OpenWindow)
1756 ;
1757 ; Use:          Opens a viewer window, and informs the user through the
1758 ;               vwEvent_open event.
1759
1760 vw__openWindow  ROUT
1761
1762                 SWI     Wimp_OpenWindow         ;Reopen the window as ordered
1763                 MOV     R0,#vwEvent_open        ;Send the event along nicely
1764                 B       vw__dispatch            ;And report, and return
1765
1766                 LTORG
1767
1768 ; --- vw__tWidth ---
1769 ;
1770 ; On entry:     R10 == pointer to viewer block
1771 ;
1772 ; On exit:      --
1773 ;
1774 ; Use:          Updates the window's fixed width parameter.
1775
1776 vw__tWidth      ROUT
1777
1778                 STMFD   R13!,{R0,R1,R14}        ;Save some registers
1779                 ADD     R0,R10,#vw__title       ;Point to title buffer
1780                 BL      wimp_strWidth           ;Get the string width
1781                 ADD     R1,R0,#vw__titleAdd     ;Add on a fudge factor
1782                 LDR     R0,[R10,#vw__banner]    ;Load the banner address
1783                 CMP     R0,#0                   ;Is the banner there?
1784                 BLNE    wimp_strWidth           ;Yes -- get its width
1785                 ADDNE   R0,R0,#vw__banAdd       ;And add on its fudge
1786                 CMP     R1,R0                   ;Which is bigger?
1787                 MOVCC   R1,R0                   ;Use the biggest one
1788                 STR     R1,[R10,#vw__fixedWidth] ;Store the new width
1789                 LDMFD   R13!,{R0,R1,PC}^        ;And return to caller
1790
1791                 LTORG
1792
1793 ; --- viewer_rescan ---
1794 ;
1795 ; On entry:     R0 == viewer handle
1796 ;
1797 ; On exit:      --
1798 ;
1799 ; Use:          Rescans all the icons in the viewer and forces a redraw,
1800 ;               in case icons have been added or deleted (or renamed).  Note
1801 ;               that the redraw is done *anyway* -- it's your responsibility
1802 ;               to avoid calling this routine when you don't need to.
1803
1804                 EXPORT  viewer_rescan
1805 viewer_rescan   ROUT
1806
1807                 STMFD   R13!,{R0,R1,R10,R14}    ;Save some registers
1808                 MOV     R10,R0                  ;Get the viewer handle
1809                 BL      vw__open                ;Is the window open at all?
1810                 LDMCCFD R13!,{R0,R1,R10,PC}^    ;No -- handle on open then
1811
1812                 SUB     R13,R13,#36             ;Make a window state block
1813                 LDR     R14,[R10,#vw__window]   ;Load the window handle
1814                 STR     R14,[R13,#0]            ;Save it in the block
1815                 MOV     R1,R13                  ;Point to the block
1816                 SWI     Wimp_GetWindowState     ;And read the window state
1817
1818                 ; --- Open the window onto the screen ---
1819
1820                 LDR     R1,[R10,#vw__listDef]   ;Find the list definition
1821                 LDR     R0,[R10,#vw__list]      ;And the list base
1822                 MOV     R14,PC                  ;Set up return address
1823                 ADD     PC,R1,#vw__items        ;Find how many items
1824                 STR     R1,[R10,#vw__icons]     ;Store this away
1825
1826                 MOV     R1,R13                  ;Point at window state blk
1827                 BL      vw__rescanSize          ;Rescan the item size
1828                 BL      vw__extend              ;Yes -- make it big then
1829                 BL      vw__resize              ;Work out new arrangement
1830                 BL      vw__setExtent           ;Set the window's extent
1831                 BL      vw__refresh             ;Force update of display
1832                 BL      vw__openWindow          ;And open the window
1833                 ADD     R13,R13,#36             ;Reclaim my stack space
1834                 LDMFD   R13!,{R0,R1,R10,PC}^    ;And return to caller
1835
1836                 LTORG
1837
1838 ;----- Icon rearrangement routines ------------------------------------------
1839
1840 ; --- vw__resize ---
1841 ;
1842 ; On entry:     R1 == pointer to window state block
1843 ;               R10 == pointer to viewer block
1844 ;
1845 ; On exit:      CS if the size has changed, else CC
1846 ;
1847 ; Use:          Updates the icon arrangement within a window, returning
1848 ;               whether the arrangement is different now.  Note that this
1849 ;               doesn't redraw the window; it just recaches the extent.
1850 ;               If the size has changed, you'll probably need to call
1851 ;               vw__setExtent and vw__refresh to get everything looking nice.
1852
1853 vw__resize      ROUT
1854
1855                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
1856
1857                 ; --- Now work out how many icons we should have ---
1858
1859                 LDMIB   R1,{R1-R3}              ;Load the x coords from win
1860                 SUB     R0,R3,R1                ;Work out the window width
1861                 SUB     R0,R0,#vw__iconGap      ;Subtract off extra border
1862                 LDR     R2,[R10,#vw__iconWidth] ;Load the icon width out
1863                 ADD     R1,R2,#vw__iconGap      ;Add on the gap
1864                 BL      divide                  ;Divide one by the other
1865                 MOV     R3,R0                   ;Icons which fit across win
1866
1867                 BL      screen_getInfo          ;Find the screen information
1868                 LDR     R0,[R0,#screen_width]   ;Load the screen width
1869                 SUB     R0,R0,#40+vw__iconGap   ;Fudge for scroll bar
1870                 ADD     R1,R2,#vw__iconGap      ;Get icon width+gap again
1871                 BL      divide                  ;Divide one by the other
1872                 MOV     R2,R0                   ;Icons which fit across scrn
1873
1874                 ; --- Fiddle these numbers appropriately ---
1875
1876                 LDR     R0,[R10,#vw__icons]     ;Load number of icons
1877                 CMP     R3,R0                   ;Too many across window?
1878                 MOVCS   R3,R0                   ;Yes -- use number we have
1879                 CMP     R2,R0                   ;Too many across screen?
1880                 MOVCS   R2,R0                   ;Yes -- use number we have
1881                 CMP     R2,R3                   ;More than fit across screen?
1882                 MOVCS   R2,R3                   ;Use -- use that then (erk)
1883                 CMP     R2,#0                   ;No icons at all?
1884                 MOVEQ   R2,#1                   ;Then have at least one
1885
1886                 ; --- Work out how many go down ---
1887
1888                 MOV     R1,R2                   ;Get number going across
1889                 BL      divide                  ;Do the division
1890                 CMP     R1,#0                   ;Any extra ones on bottom?
1891                 ADDNE   R0,R0,#1                ;Yes -- add an extra row
1892                 MOVS    R3,R0                   ;Look after this value
1893                 MOVEQ   R3,#0                   ;If it's zero, use one
1894
1895                 ; --- Now see if anything's changed ---
1896
1897                 ADD     R14,R10,#vw__across     ;Find old across counter
1898                 LDMIA   R14,{R0,R1}             ;Load across and down values
1899                 CMP     R0,R2                   ;Compare with old ones
1900                 CMPEQ   R1,R3                   ;Are they the same?
1901                 STMNEIA R14,{R2,R3}             ;If not, store new ones
1902                 LDMFD   R13!,{R0-R3,R14}        ;Restore caller's registers
1903                 ORRNES  PC,R14,#C_flag          ;If changed, return C set
1904                 BICEQS  PC,R14,#C_flag          ;Otherwise return C clear
1905
1906                 LTORG
1907
1908 ; --- vw__setExtent ---
1909 ;
1910 ; On entry:     R10 == pointer to viewer block
1911 ;
1912 ; On exit:      --
1913 ;
1914 ; Use:          Resets the extent of a viewer window, in case the
1915 ;               arrangement of icons or banner/title text has changed.
1916 ;               If the window is currently open, you should follow this
1917 ;               call with a Wimp_OpenWindow SWI.
1918
1919 vw__setExtent   ROUT
1920
1921                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
1922
1923                 ; --- Work out correct horizontal extent ---
1924
1925                 BL      screen_getInfo          ;Find the screen information
1926                 LDR     R0,[R0,#screen_width]   ;Load the screen width
1927                 SUB     R0,R0,#40+vw__iconGap   ;Fudge for scroll bar
1928                 MOV     R2,R0                   ;Look after this value
1929                 LDR     R3,[R10,#vw__iconWidth] ;Load the icon width
1930                 ADD     R3,R3,#vw__iconGap      ;Add on the inter-icon gap
1931                 MOV     R1,R3                   ;Divide by this
1932                 BL      divide                  ;Divide one by the other
1933                 LDR     R14,[R10,#vw__icons]    ;Load the number of icons
1934                 CMP     R0,R14                  ;Is this bigger?
1935                 MOVCS   R0,R14                  ;Yes -- then use that
1936                 CMP     R0,#0                   ;Unless there's none
1937                 MOVEQ   R0,#1                   ;In which case use one
1938                 MUL     R2,R3,R0                ;Work out the correct width
1939                 ADD     R2,R2,#vw__iconGap      ;Add on extra border around
1940                 LDR     R14,[R10,#vw__fixedWidth] ;Load width of title/banner
1941                 CMP     R2,R14                  ;Do we have enough here?
1942                 MOVCC   R2,R14                  ;No -- then use more
1943
1944                 ; --- And now the vertical extent ---
1945
1946                 LDR     R1,[R10,#vw__iconHeight] ;Load the icon height
1947                 ADD     R1,R1,#vw__iconGap      ;Add on the gap
1948                 LDR     R14,[R10,#vw__down]     ;Load vertical number of icns
1949                 MUL     R1,R14,R1               ;Work out the size
1950                 ADD     R1,R1,#vw__iconGap      ;Add on extra border
1951
1952                 ; --- Work out the other two ---
1953
1954                 RSB     R1,R1,#0                ;And vertical extent -ve
1955                 LDR     R3,[R10,#vw__banner]    ;Load banner pointer
1956                 CMP     R3,#0                   ;Do we have a banner?
1957                 MOVNE   R3,#vw__banHeight       ;Yes -- then add above origin
1958                 MOV     R0,#0                   ;Start at the left side
1959
1960                 ; --- Make sure the extent is big enough ---
1961
1962                 SUBS    R14,R2,#vw__minWidth    ;Get the minimum width
1963                 SUBCC   R2,R2,R14               ;Make bigger if needs be
1964                 SUB     R14,R3,R1               ;Work out extent height
1965                 SUBS    R14,R14,#vw__minHeight  ;Get the minimum height
1966                 ADDCC   R1,R1,R14               ;Make bigger if needs be
1967
1968                 ; --- Finally set up the extent ---
1969
1970                 ADD     R14,R10,#vw__extent     ;Set the window extent
1971                 STMIA   R14,{R0-R3}             ;Save the values in there
1972                 LDR     R0,[R10,#vw__window]    ;Load the window handle
1973                 ADD     R1,R10,#vw__extent      ;Point to the extent block
1974                 SWI     Wimp_SetExtent          ;Set the window's extent
1975                 LDMFD   R13!,{R0-R3,PC}^        ;And return to caller
1976
1977                 LTORG
1978
1979 ; --- vw__refresh ---
1980 ;
1981 ; On entry:     R10 == pointer to a viewer block
1982 ;
1983 ; On exit:      --
1984 ;
1985 ; Use:          Forces a redraw of the contents of a viewer.  Use in
1986 ;               conjunction with vw__resize.
1987
1988 vw__refresh     ROUT
1989
1990                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
1991                 LDR     R0,[R10,#vw__window]    ;Load the window handle
1992                 MOV     R1,#-&FFFFFFF           ;Force a redraw of the world
1993                 MOV     R2,#-&FFFFFFF           ;This hack prevents problems
1994                 MOV     R3,#&FFFFFFF            ;with the extent being bodged
1995                 MOV     R4,#&FFFFFFF            ;by the Wimp.
1996                 SWI     Wimp_ForceRedraw        ;Redraw the whole lot
1997                 LDMFD   R13!,{R0-R4,PC}^        ;And return to caller
1998
1999                 LTORG
2000
2001 ; --- vw__extend ---
2002 ;
2003 ; On entry:     R1 == pointer to window open block
2004 ;               R10 == pointer to a viewer block
2005 ;
2006 ; On exit:      --
2007 ;
2008 ; Use:          Extends the viewer window if necessary to accomodate new
2009 ;               items.  The new coordinates to open are written back to the
2010 ;               window open block.  Correct procedure for adding items is
2011 ;               as follows:
2012 ;
2013 ;               1. Get window state
2014 ;               2. Call vw__extend
2015 ;               3. Call vw__resize
2016 ;               4. Call vw__setExtent
2017 ;               5. Call vw__refresh
2018
2019 vw__extend      ROUT
2020
2021                 STMFD   R13!,{R0-R8,R14}        ;Save some registers
2022
2023                 ; --- Load current and maximum width and height ---
2024
2025                 MOV     R8,R1                   ;Look after this address
2026                 LDMIB   R8,{R4-R7}              ;Load the window dimensions
2027                 SUB     R6,R6,R4                ;Find the window width
2028                 SUB     R7,R7,R5                ;And its height
2029
2030                 ADD     R14,R10,#vw__extent     ;Find the current extent
2031                 LDMIA   R14,{R0-R3}             ;Load the dimensions out
2032                 SUB     R4,R2,R0                ;Find the maximum width
2033                 SUB     R5,R3,R1                ;And the maximum height
2034                 LDR     R14,[R10,#vw__flags]    ;Load the flags word
2035                 TST     R14,#vwFlag__opened     ;Has viewer ever been opened?
2036                 BNE     %f00                    ;Yes -- skip onwards
2037
2038                 ; --- Set up special values for first time ---
2039
2040                 MOV     R4,#0                   ;No -- force width to max
2041                 MOV     R5,#0                   ;And height forced to max
2042                 LDR     R6,[R10,#vw__fixedWidth] ;Set a default width though
2043                 CMP     R6,#vw__minWidth        ;Get the minimum width
2044                 MOVCC   R6,#vw__minWidth        ;If too small, use this
2045                 MOV     R7,#vw__minHeight       ;Use the minimum height too
2046
2047                 ; --- Find out if we have anything to do horizontally ---
2048                 ;
2049                 ; We only try to extend if the window is currently as wide
2050                 ; as it will go.
2051
2052 00              CMP     R6,R4                   ;Does the width shape up?
2053                 BCC     %50vw__extend           ;No -- skip to vertical
2054
2055                 ; --- Extend the width ---
2056                 ;
2057                 ; We ensure that the width of the window is the smaller
2058                 ; of the maximum width we allow and the width of the number
2059                 ; of icons in the window.
2060
2061                 MOV     R0,#vw__maxWidth        ;Get the maximum width
2062                 LDR     R3,[R10,#vw__iconWidth] ;Find the icon width
2063                 ADD     R3,R3,#vw__iconGap      ;And add on the gap as usual
2064                 MOV     R1,R3                   ;Divide by this
2065                 BL      divide                  ;Divide one by the other
2066                 LDR     R1,[R10,#vw__icons]     ;Load total number of icns
2067                 CMP     R0,R1                   ;Which one is bigger?
2068                 MOVCS   R0,R1                   ;Use the smaller
2069                 CMP     R0,#0                   ;Are there no icons at all?
2070                 MOVEQ   R0,#1                   ;None -- make space for one
2071                 MUL     R0,R3,R0                ;Work out new improved width
2072                 ADD     R0,R0,#vw__iconGap      ;Add on the extra border
2073                 CMP     R6,R0                   ;Which is bigger?
2074                 MOVCC   R6,R0                   ;Use the bigger of the two
2075
2076                 ; --- Now do things vertically ---
2077                 ;
2078                 ; This is basically the same.  We only extend if the window
2079                 ; is as tall at it will go.
2080
2081 50vw__extend    CMP     R7,R5                   ;Does the height shape up?
2082                 BCC     %90vw__extend           ;No -- skip on then
2083
2084                 ; --- Extend the height ---
2085                 ;
2086                 ; This is trickier, because we have to work out how many
2087                 ; icons there will be vertically.
2088
2089                 LDR     R3,[R10,#vw__iconHeight] ;Load the icon height
2090                 ADD     R3,R3,#vw__iconGap      ;Add on the inter-icon gap
2091                 SUB     R0,R6,#vw__iconGap      ;Get the current width
2092                 LDR     R1,[R10,#vw__iconWidth] ;Find the icon width
2093                 ADD     R1,R1,#vw__iconGap      ;And add on the gap as usual
2094                 BL      divide                  ;Find how many will fit
2095
2096                 MOV     R1,R0                   ;We will divide by this
2097                 LDR     R0,[R10,#vw__icons]     ;Load the number of icons
2098                 BL      divide                  ;Work out number down
2099                 CMP     R1,#0                   ;Is there a remainder?
2100                 ADDNE   R0,R0,#1                ;Yes -- extra one then
2101                 CMP     R0,#0                   ;Are there no icons?
2102                 MOVEQ   R0,#1                   ;None -- make space for one
2103                 MOV     R2,R0                   ;Look after this value
2104
2105                 MOV     R0,#vw__maxHeight       ;Get the maximum height
2106                 MOV     R1,R3                   ;And the icon height
2107                 BL      divide                  ;Do the division again
2108                 CMP     R0,R2                   ;Which one is bigger?
2109                 MOVCS   R0,R2                   ;Use the smaller
2110                 MUL     R0,R3,R0                ;Work out new improved height
2111                 ADD     R0,R0,#vw__iconGap      ;Add on the extra border
2112                 LDR     R14,[R10,#vw__banner]   ;Do we have a banner string?
2113                 CMP     R14,#0                  ;Quick check for that...
2114                 ADDNE   R0,R0,#vw__banHeight    ;Yes -- add that on too
2115                 CMP     R7,R0                   ;Which is bigger?
2116                 MOVCC   R7,R0                   ;Use the bigger
2117
2118                 ; --- Now update the window block ---
2119
2120 90vw__extend    LDMIB   R8,{R0-R3}              ;Load the current values
2121                 ADD     R2,R0,R6                ;Work out new right side
2122                 SUBS    R1,R3,R7                ;And the new bottom
2123                 SUBLT   R3,R3,R1                ;Move the top if hit bottom
2124                 SUBLT   R1,R1,R1                ;And move the bottom too
2125                 STMIB   R8,{R0-R3}              ;Save that lot back again
2126                 LDMFD   R13!,{R0-R8,PC}^        ;And return to caller
2127
2128                 LTORG
2129
2130 ;----- Viewer block structure -----------------------------------------------
2131 ;
2132 ; This is shadowed by gallery.s -- keep them in step.
2133
2134                 ^       0
2135
2136                 ; --- Information about the window ---
2137
2138 vw__window      #       4                       ;Window handle
2139 vw__extent      #       16                      ;Current window extent
2140 vw__flags       #       4                       ;Any flags of interest
2141 vw__list        #       4                       ;Pointer to list head
2142 vw__listDef     #       4                       ;Pointer to list handler
2143 vw__handler     #       12                      ;Viewer's event handler
2144 gl__handler     #       4                       ;Gallery's event handler
2145 vw__shape       #       4                       ;Shape handler function
2146 vw__banner      #       4                       ;Pointer to banner string
2147 vw__fixedWidth  #       4                       ;Width of banner/title
2148
2149                 ; --- Icon sizing information ---
2150
2151 vw__icons       #       4                       ;Cache number of icons
2152 vw__stdDimens   #       8                       ;`Standard' width and height
2153 vw__iconWidth   #       4                       ;Width of icons currently
2154 vw__iconHeight  #       4                       ;Height of icons currently
2155 vw__across      #       4                       ;Number of icons across
2156 vw__down        #       4                       ;Number of icons down
2157
2158                 ; --- Data for default selection model ---
2159
2160 vw__tempSel     #       4                       ;Temporary selected icon
2161
2162                 ; --- Big buffers at the end ---
2163
2164 vw__title       #       256                     ;Title bar buffer
2165
2166 vw__size        #       0                       ;Size of a viewer block
2167
2168                 ; --- Flags bits ---
2169                 ;
2170                 ; Gallery `borrows' top-end flags bits here
2171
2172 vwFlag__opened  EQU     (1<<0)                  ;Has the window been opened?
2173
2174 ;----- Constants ------------------------------------------------------------
2175
2176 vw__iconGap     EQU     16                      ;Gap between icons
2177 vw__banHeight   EQU     48                      ;Height of viewer banner
2178
2179 vw__minWidth    EQU     380                     ;Minimum width for a viewer
2180 vw__minHeight   EQU     160                     ;Minimum height
2181
2182 vw__titleAdd    EQU     164                     ;Fudge factor to add to title
2183 vw__banAdd      EQU     64                      ;Fudge factor for the banner
2184
2185 vw__maxWidth    EQU     900-vw__iconGap         ;Maximum width of a viewer
2186 vw__maxHeight   EQU     700-vw__iconGap         ;Maximum height of a viewer
2187
2188 ;----- List definition format -----------------------------------------------
2189
2190                 ^       0
2191 vw__itemToIndex #       4                       ;Item to index routine
2192                                                 ;Entry: R0 == pointer to list
2193                                                 ;       R1 == pointer to item
2194                                                 ;Exit:  R1 == index, or -1
2195
2196 vw__indexToItem #       4                       ;Index to item routine
2197                                                 ;Entry: R0 == pointer to list
2198                                                 ;       R1 == index of item
2199                                                 ;Exit:  R1 == item ptr, or 0
2200
2201 vw__enumerate   #       4                       ;Enumeration function
2202                                                 ;Entry: R0 == list pointer
2203                                                 ;       R1 == item, or 0
2204                                                 ;       R2 == BIC mask
2205                                                 ;       R3 == test mask
2206                                                 ;Exit:  CS if match, and
2207                                                 ;       R1 == item ptr
2208
2209 vw__items       #       4                       ;Function to return items
2210                                                 ;Entry: R0 == list pointer
2211                                                 ;Exit:  R1 == number of items
2212
2213 vw__setFlags    #       4                       ;Function to set/read flags
2214                                                 ;Entry: R1 == pointer to item
2215                                                 ;       R2 == BIC mask
2216                                                 ;       R3 == EOR mask
2217                                                 ;Exit:  R2 == new flags
2218
2219 ;----- Shape function reason codes ------------------------------------------
2220
2221                 ^       0
2222 vwShape_size    #       1                       ;Read an icon's size
2223                                                 ;Entry: R1 == list item
2224                                                 ;       R2,R3 == std size
2225                                                 ;Exit:  R2,R3 == actual size
2226
2227 vwShape_intersects #    1                       ;Does icon intersect box?
2228                                                 ;Entry: R1 == list item
2229                                                 ;       R2 == ptr to icon box
2230                                                 ;       R3 == ptr to box
2231                                                 ;Exit:  CS if intersect
2232
2233 vwShape_slowBit #       1                       ;Does slow bit need redraw?
2234                                                 ;Entry: R1 == list item
2235                                                 ;       R2 == ptr to icon box
2236                                                 ;       R3 == ptr to box
2237                                                 ;Exit:  CS if intersect
2238
2239 ;----- Viewer event codes ---------------------------------------------------
2240
2241                 ^       0
2242 vwEvent_close   #       1                       ;User has closed the window
2243
2244 vwEvent_click   #       1                       ;User has clicked an icon
2245                                                 ;R1 == icon handle (or 0)
2246                                                 ;R2 == mouse status
2247
2248 vwEvent_double  #       1                       ;User has double-clicked
2249                                                 ;R1 == icon handle (or 0)
2250                                                 ;R2 == mouse status
2251
2252 vwEvent_drag    #       1                       ;User has dragged the mouse
2253                                                 ;R1 == icon handle (or 0)
2254                                                 ;R2 == mouse status
2255
2256 vwEvent_menu    #       1                       ;User has clicked menu
2257                                                 ;R1 == icon handle (or 0)
2258                                                 ;R2 == mouse status
2259
2260 vwEvent_redraw  #       1                       ;Redraw a viewer icon
2261                                                 ;R1 == icon handle
2262                                                 ;R2 == pointer to coords blk
2263                                                 ;R3 == pointer to clip blk
2264                                                 ;R5,R6 == window origin
2265
2266 vwEvent_drop    #       1                       ;File dropped on the viewer
2267                                                 ;R1 == filetype of data
2268                                                 ;R2 == estimated size
2269                                                 ;R3 == address of filename
2270                                                 ;R4 == drop type
2271
2272 vwEvent_help    #       1                       ;Help request for the viewer
2273                                                 ;R1 == icon handle, or 0
2274
2275 vwEvent_key     #       1                       ;Key pressed
2276                                                 ;R1 == key code (translated)
2277                                                 ;Return CS if used, else CC
2278
2279 vwEvent_dragged #       1                       ;Icons dropped on a window
2280                                                 ;R1 == destination window
2281                                                 ;R2 == destination icon
2282
2283 vwEvent_sprite  #       1                       ;Return sprite name to use
2284                                                 ;Entry: R1 == icon handle
2285                                                 ;         (-1 for many)
2286                                                 ;Exit:  CS if sprite found,
2287                                                 ;       R0 == ptr to spr area
2288                                                 ;       R1 == pointer to name
2289                                                 ;       else CC
2290
2291 vwEvent_open    #       1                       ;The viewer has been moved
2292                                                 ;R1 == ptr to open/state blk
2293
2294 vwEvent_draw    #       1                       ;Slowly redraw icon
2295                                                 ;R1 == icon handle
2296                                                 ;R2 == pointer to coords blk
2297                                                 ;R3 == pointer to clip blk
2298                                                 ;R5,R6 == window origin
2299                                                 ;(Event only used by gallery)
2300
2301 vwEvent_unDraw  #       1                       ;Undraw temporary part
2302                                                 ;R1 == icon handle
2303                                                 ;R2 == pointer to coords blk
2304                                                 ;R3 == pointer to clip blk
2305                                                 ;R5,R6 == window origin
2306                                                 ;(Event only used by gallery)
2307
2308                 ; --- Drop event subreason codes ---
2309
2310                 ^       0
2311 vwDrop_save     #       1                       ;File from another app
2312 vwDrop_load     #       1                       ;File from filing system
2313
2314 ;----- That's all, folks ----------------------------------------------------
2315
2316                 END