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

   1 ;
   2 ; listbox.s
   3 ;
   4 ; Nice listbox handling routines (TMA)
   5 ;
   6 ; © 1994-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 ;----- External dependencies ------------------------------------------------
  33
  34                 GET     sapphire:alloc
  35                 GET     sapphire:fastMove
  36                 GET     sapphire:idle
  37                 GET     sapphire:divide
  38                 GET     sapphire:pane
  39                 GET     sapphire:resspr
  40                 GET     sapphire:sapphire
  41                 GET     sapphire:screen
  42                 GET     sapphire:tspr
  43                 GET     sapphire:win
  44
  45 ;----- Main code ------------------------------------------------------------
  46
  47                 AREA    |Sapphire$$Code|,CODE,READONLY
  48
  49 ; --- lb_create ---
  50 ;
  51 ; On entry:     R0 == pointer to list manager description block
  52 ;               R1 == pointer to the list
  53 ;               R2 == pointer to a width function
  54 ;               R3 == The height of each item
  55 ;               R4 == parent window handle or
  56 ;                     pointer to window block if R5 == -1
  57 ;               R5 == parent icon handle or -1 if not a pane
  58 ;
  59 ; On exit:      R0 == listbox handle
  60 ;               R1 == window handle of list box
  61 ;               May return an error (R1 corrupted)
  62
  63                 EXPORT  lb_create
  64 lb_create       ROUT
  65
  66                 STMFD   R13!,{R2,R3,R10,R14}    ;Stack some registers
  67
  68                 ; --- First, create the block ---
  69
  70                 MOV     R10,R0                  ;Preserve R0
  71                 MOV     R0,#lb__size            ;The structure size
  72                 BL      alloc                   ;Get the block
  73                 BLCS    alloc_error             ;Get a message if no memory
  74                 BCS     %99lb_create            ;Return on error
  75
  76                 MOV     R14,R10                 ;Do a swap type thing
  77                 MOV     R10,R0                  ;Point to the block
  78                 MOV     R0,R14                  ;Confused yet?
  79                 STMIA   R10,{R0-R5}             ;Store information in block
  80                 MOV     R0,#0                   ;No flags set yet
  81                 STR     R0,[R10,#lb__flags]     ;Store this word
  82                 STR     R0,[R10,#lb__handler]   ;No handler either
  83                 BL      lb__getMaxWidth         ;Find length of longest item
  84
  85                 ; --- Calculate the minimum width and height of the box ---
  86
  87                 CMP     R5,#-1                  ;Is this a pane listbox?
  88                 BNE     %10lb_create            ;No -- use icon then
  89
  90                 MOV     R14,#176                ;A minimum height
  91                 STR     R14,[R10,#lb__height]   ;Store the width
  92                 LDR     R0,[R4,#0]              ;Load the minimum x position
  93                 LDR     R14,[R4,#8]             ;Load the maximum x position
  94                 SUB     R0,R14,R0               ;Get the initial width
  95                 STR     R0,[R10,#lb__width]     ;Store the width
  96                 B       %20lb_create            ;And jump ahead a bit
  97
  98 10lb_create     SUB     R13,R13,#40             ;Get another block
  99                 STR     R4,[R13,#0]             ;Store parent window handle
 100                 STR     R5,[R13,#4]             ;And icon handle
 101                 MOV     R1,R13                  ;Point to the block
 102                 SWI     Wimp_GetIconState       ;Get the icon's state
 103
 104                 LDR     R2,[R1,#16]             ;Get the x1 coord
 105                 LDR     R14,[R1,#8]             ;And x0 coord
 106                 SUB     R2,R2,R14               ;Calculate the icon width
 107                 STR     R2,[R10,#lb__width]     ;Store the width
 108                 LDR     R2,[R1,#20]             ;Get the y1 coord
 109                 LDR     R14,[R1,#12]            ;And y0 coord
 110                 SUB     R2,R2,R14               ;Calculate the icon height
 111                 STR     R2,[R10,#lb__height]    ;Store the height
 112                 ADD     R13,R13,#40             ;Get the block back
 113
 114                 ; --- Now create the window ---
 115
 116 20lb_create     SUB     R13,R13,#88             ;Get a block
 117                 MOV     R0,R13                  ;Point to it
 118                 CMP     R5,#-1                  ;Is this a pane listbox?
 119                 ADRNE   R1,lb__windowDef        ;No -- point to my window def
 120                 MOVEQ   R1,R4                   ;Yes -- use theirs then
 121                 MOV     R2,#lb__defSize         ;Copy this much
 122                 BL      fastMove                ;Copy the definition across
 123                 LDR     R1,[R10,#lb__height]    ;y0
 124                 RSB     R1,R1,#0                ;Negate it
 125                 LDR     R2,[R10,#lb__width]     ;x1
 126                 ADD     R14,R13,#44             ;The workarea extent block
 127                 STMIA   R14,{R1,R2}             ;Store the desired extent
 128                 BL      resspr_area             ;Find the sprite area
 129                 STR     R0,[R13,#64]            ;Store this in the block
 130                 MOV     R1,R13                  ;Point to the block
 131                 SWI     Wimp_CreateWindow       ;Try to create the window
 132                 ADD     R13,R13,#88             ;Get the stack back
 133                 BVS     %98lb_create            ;Return on error
 134                 STR     R0,[R10,#lb__wHandle]   ;Store my window handle
 135
 136                 ; --- Set up the event handler ---
 137
 138                 ADR     R1,lb__eventHandler     ;Point to the event handler
 139                 MOV     R2,R10                  ;R10 value to call with
 140                 MOV     R3,#0                   ;R12 value to call with
 141                 BL      win_eventHandler        ;Add in the event handler
 142
 143                 ; --- Add it as a pane to the parent (if we need to) ---
 144
 145                 MOV     R2,R0                   ;The window handle
 146                 MOV     R0,R4                   ;Parent window handle
 147                 MOVS    R1,R5                   ;Parent icon handle
 148                 BLPL    pane_add                ;Register the pane (if reqd)
 149
 150                 ; --- Add scroll bars if we need too ---
 151
 152                 ORR     R10,R10,#(1<<31)        ;Don't open the window
 153                 BL      lb__rescanSize          ;Re-scan the size nicely
 154                 BIC     R10,R10,#(1<<31)        ;Clear silly bit again
 155                 BVS     %98lb_create            ;Return om error
 156
 157                 LDR     R1,[R10,#lb__wHandle]   ;Return window handle in R1
 158                 MOV     R0,R10                  ;Return the listbox handle
 159                 B       %99lb_create            ;Return to caller
 160
 161 98lb_create     MOV     R0,R10                  ;Point to the allocated block
 162                 BL      free                    ;Free the block
 163 99lb_create     LDMFD   R13!,{R2,R3,R10,R14}    ;Get registers back
 164                 ORRVSS  PC,R14,#V_flag          ;And return either with...
 165                 BICVCS  PC,R14,#V_flag          ;...or without error
 166
 167                 LTORG
 168
 169 lb__windowDef   DCD     320,256,960,768
 170                 DCD     0,0
 171                 DCD     -1
 172                 DCD     &80000122
 173                 DCB     7,2,7,255,3,1,12,0
 174                 DCD     0,0,0,0
 175                 DCD     &39,10<<12
 176                 DCD     0,0
 177                 DCB     "ListBox",0,0
 178                 DCD     0
 179
 180 lb__defSize     EQU     {PC}-lb__windowDef
 181
 182 ; --- lb__rescanSize ---
 183 ;
 184 ; On entry:     R10 == pointer to listbox
 185 ;                 Bit 31 == don't call open the window
 186 ;
 187 ; On exit:      VS and R0 == pointer to error or
 188 ;               VC and R0 == window handle
 189 ;
 190 ; Use:          Scans the list, and adds/removes scroll bars if necessary
 191
 192 lb__rescanSize  ROUT
 193
 194                 STMFD   R13!,{R1-R10,R14}       ;Stack some registers
 195                 BIC     R10,R10,#(1<<31)        ;Clear the top bit
 196
 197                 ; --- First get the window state of the current window ---
 198
 199                 SUB     R13,R13,#36             ;Get a block
 200                 LDR     R0,[R10,#lb__wHandle]   ;Get the window handle
 201                 STR     R0,[R13,#0]             ;Store in the block
 202                 MOV     R1,R13                  ;Point to the block
 203                 SWI     Wimp_GetWindowState     ;Get the window state
 204                 LDR     R6,[R1,#32]             ;Get the window flags
 205                 ADD     R13,R13,#36             ;Get the block back again
 206                 LDR     R9,[R10,#lb__descriptor] ;Point to descriptor block
 207                 LDR     R0,[R10,#lb__list]      ;Point to the list itself
 208                 MOV     R14,PC                  ;Set up the return address
 209                 ADD     PC,R9,#lb_items         ;Call the function
 210                 LDR     R7,[R10,#lb__iHeight]   ;The height of each item
 211                 MUL     R7,R1,R7                ;The required box y extent
 212                 LDR     R4,[R10,#lb__width]     ;Overall box width
 213                 LDR     R5,[R10,#lb__height]    ;Overall box height
 214                 BL      tspr_borderWidths       ;Get the border widths
 215                 BL      screen_getInfo          ;Get pixel sizes
 216                 LDR     R14,[R0,#screen_dx]     ;x pixel size
 217                 SUB     R4,R4,R14,LSL#1         ;Correct overall width
 218                 ADD     R1,R1,R14               ;Set up border width
 219                 LDR     R14,[R0,#screen_dy]     ;y pixel size
 220                 SUB     R5,R5,R14,LSL#1         ;Correct overall height
 221                 SUB     R2,R2,R14               ;Set up border height
 222                 LDR     R14,[R10,#lb__pIHandle] ;Get the parent icon handle
 223                 CMP     R14,#-1                 ;Is this a pane dialogue?
 224                 BEQ     %50lb__rescanSize       ;Yes -- jump ahead then
 225
 226                 ; --- Which scroll bars do we want? ---
 227
 228                 MOV     R14,#0                  ;No flags so far
 229                 LDR     R0,[R10,#lb__maxWidth]  ;Get the width required
 230                 CMP     R0,R4                   ;Is width>overall?
 231                 ORRGT   R14,R14,#(1<<30)        ;Yes -- we need horz. scr bar
 232                 SUBGT   R5,R5,R2                ;Reduce overall height
 233
 234                 CMP     R7,R5                   ;Do we need a vertical bar?
 235                 ORRGT   R14,R14,#(1<<28)        ;Yes -- make a note of this
 236                 SUBGT   R4,R4,R1                ;Reduce overall width
 237
 238                 TST     R14,#(1<<30)            ;Do we have a horz. bar?
 239                 BNE     %00lb__rescanSize       ;Yes -- jump ahead
 240                 CMP     R0,R4                   ;Is width>overall?
 241                 ORRGT   R14,R14,#(1<<30)        ;Yes -- we need horz. scr bar
 242                 SUBGT   R5,R5,R2                ;Reduce overall height
 243
 244                 ; --- Do we need to add/remove scroll bars? ---
 245
 246 00              AND     R0,R6,#&50000000        ;The scroll bars we have
 247                 CMP     R0,R14                  ;Are the flags the same
 248                 BEQ     %50lb__rescanSize       ;Yes -- jump ahead
 249
 250                 ; --- Now we need to recreate the window ---
 251
 252                 BIC     R6,R6,#&50000000        ;No scroll bars at all
 253                 ORR     R6,R6,R14               ;Just the ones we want please
 254
 255                 ; --- Now create the new window ---
 256
 257                 SUB     R13,R13,#88             ;Get a block
 258                 MOV     R0,R13                  ;Point to it
 259                 ADR     R1,lb__windowDef        ;Point to window definition
 260                 MOV     R2,#lb__defSize         ;Copy this much
 261                 BL      fastMove                ;Copy the definition across
 262                 RSB     R1,R7,#0                ;y0
 263                 LDR     R2,[R10,#lb__maxWidth]  ;x1
 264                 ADD     R14,R13,#44             ;The workarea extent block
 265                 STMIA   R14,{R1,R2}             ;Store the desired extent
 266                 STR     R6,[R13,#28]            ;Store the flags word
 267                 BL      resspr_area             ;Find the sprite area
 268                 STR     R0,[R13,#64]            ;Store this in the block
 269                 MOV     R1,R13                  ;Point to the block
 270                 SWI     Wimp_CreateWindow       ;Try to create the window
 271                 ADD     R13,R13,#88             ;Get the block back
 272                 LDRVS   R0,[R10,#lb__pWHandle]  ;On error, get window handle
 273                 LDRVS   R1,[R10,#lb__pIHandle]  ;...get the icon handle
 274                 BLVS    pane_remove             ;...remove the pane
 275                 BVS     %99lb__rescanSize       ;...and Barf with error
 276
 277                 MOV     R1,R0                   ;Look after the window handle
 278                 LDR     R0,[R10,#lb__wHandle]   ;Load the old handle
 279                 BL      win_swapWindow          ;Tell win the handle changed
 280                 MOV     R2,R1                   ;Look after new handle
 281                 ADD     R1,R10,#lb__wHandle     ;Point to the old handle
 282                 SWI     Wimp_DeleteWindow       ;Destroy the old window
 283                 STR     R2,[R10,#lb__wHandle]   ;Store the new window handle
 284
 285                 LDR     R0,[R10,#lb__pWHandle]  ;Parent window handle
 286                 LDR     R1,[R10,#lb__pIHandle]  ;Parent icon handle
 287                 BL      pane_swap               ;Swap the pane
 288                 B       %50lb__rescanSize       ;Jump ahead a little
 289
 290 50              ; --- Work out the correct extents ---
 291
 292                 BL      screen_getInfo          ;Get pixel sizes
 293                 LDR     R14,[R0,#screen_dx]     ;x pixel size
 294                 ADD     R4,R4,R14,LSL#1         ;Correct overall width
 295
 296                 CMP     R7,R5                   ;Is required<overall height?
 297                 MOVLT   R7,R5                   ;Yes -- make them the same
 298                 LDR     R3,[R10,#lb__maxWidth]  ;Get the width required
 299                 CMP     R3,R4                   ;Is required<overall width?
 300                 MOVLT   R3,R4                   ;Yes -- make them the same
 301                 SUB     R13,R13,#16             ;Get a small block
 302                 MOV     R1,#0                   ;x0 extent
 303                 RSB     R2,R7,#0                ;y0 extent
 304                 MOV     R4,#0                   ;y1 extent
 305                 STMIA   R13,{R1-R4}             ;Store the required extent
 306                 MOV     R1,R13                  ;Point to the block
 307                 LDR     R5,[R10,#lb__wHandle]   ;Load the window handle
 308                 MOV     R0,R5                   ;Put it in R0
 309                 SWI     Wimp_SetExtent          ;Set the window extent
 310                 ADD     R13,R13,#16             ;Reclaim the block again
 311
 312                 LDR     R14,[R13,#36]           ;Load R10 value
 313                 TST     R14,#(1<<31)            ;Should we return here
 314                 BNE     %90lb__rescanSize       ;Yes -- return then
 315                 LDR     R14,[R10,#lb__pIHandle] ;Get the parent icon
 316                 CMP     R14,#-1                 ;Is the listbox attached?
 317                 STREQ   R5,[R13,#-36]!          ;Yes -- store window handle
 318                 MOVEQ   R1,R13                  ;Point at the block
 319                 SWIEQ   Wimp_GetWindowState     ;Find the current position
 320                 SWIEQ   Wimp_OpenWindow         ;And open it again
 321                 ADDEQ   R13,R13,#36             ;Restore the stack
 322                 LDRNE   R0,[R10,#lb__pWHandle]  ;Parent window handle
 323                 BLNE    pane_open               ;Open the listbox cunningly
 324 90              MOV     R0,R5                   ;Get the window handle back
 325
 326                 ; --- Return to caller ---
 327
 328 99              LDMFD   R13!,{R1-R10,R14}       ;Load registers
 329                 ORRVSS  PC,R14,#V_flag          ;And return with...
 330                 BICVCS  PC,R14,#V_flag          ;...or without error
 331
 332                 LTORG
 333
 334 ; --- lb_destroy ---
 335 ;
 336 ; On entry:     R0 == listbox handle
 337 ;
 338 ; On exit:      --
 339 ;
 340 ; Use:          Destroys the given listbox.
 341
 342                 EXPORT  lb_destroy
 343 lb_destroy      ROUT
 344
 345                 STMFD   R13!,{R0-R3,R10,R14}    ;Stack some registers
 346                 MOV     R10,R0                  ;Keep the pointer
 347                 ADD     R1,R10,#lb__wHandle     ;Point to the window handle
 348                 SWI     XWimp_CloseWindow       ;Close the window
 349                 SWI     Wimp_DeleteWindow       ;And the delete it
 350
 351                 ; --- Remove the pane attachment ---
 352
 353                 LDR     R0,[R10,#lb__pWHandle]  ;Get the parent window handle
 354                 LDR     R1,[R10,#lb__wHandle]   ;Get the listbox window hnd
 355                 BL      pane_remove             ;Remove the pane
 356
 357                 ; --- Remove the event handler ---
 358
 359                 MOV     R0,R1                   ;The window handle
 360                 BL      win_windowDeleted       ;Remove the handler
 361
 362                 ; --- Finally, free the block ---
 363
 364                 MOV     R0,R10                  ;Point to the block
 365                 BL      free                    ;Free it
 366
 367                 LDMFD   R13!,{R0-R3,R10,PC}^    ;Return to caller
 368
 369 ; --- lb_eventHandler ---
 370 ;
 371 ; On entry:     R0 == listbox handle
 372 ;               R1 == handler function
 373 ;               R2 == R10 value to pass
 374 ;               R3 == R12 value to pass
 375 ;
 376 ; On exit:      --
 377 ;
 378 ; Use:          Registers an event handler for the given listbox.
 379
 380                 EXPORT  lb_eventHandler
 381 lb_eventHandler ROUT
 382
 383                 STMFD   R13!,{R14}              ;Stack some registers
 384                 ADD     R14,R0,#lb__handler     ;Point to nice block
 385                 STMIA   R14,{R1-R3}             ;Store the information
 386                 LDMFD   R13!,{PC}^              ;Return to caller
 387
 388                 LTORG
 389
 390 ; --- lb__getMaxWidth ---
 391 ;
 392 ; On entry:     R10 == pointer to listbox structure
 393 ;
 394 ; On exit:      R0 == longest item width in the list
 395
 396 lb__getMaxWidth ROUT
 397
 398                 STMFD   R13!,{R1-R7,R14}        ;Stack some registers
 399
 400                 MOV     R4,#0                   ;The longest width so far
 401                 LDR     R5,[R10,#lb__widthFun]  ;Get the width function ptr
 402                 LDR     R6,[R10,#lb__descriptor] ;Point to the descriptor blk
 403                 LDR     R0,[R10,#lb__list]      ;Get the list head
 404                 MOV     R1,#0                   ;From the first item
 405                 MOV     R2,#0                   ;No mask word
 406                 MOV     R3,#0                   ;Or test word
 407 00              MOV     R14,PC                  ;Set up the return address
 408                 ADD     PC,R6,#lb_enumerate     ;Get a list item
 409                 BCC     %99lb__getMaxWidth      ;No more items -- return
 410                 MOV     R7,R1                   ;Remember the R1 value
 411                 MOV     R14,PC                  ;Set up return address
 412                 MOV     PC,R5                   ;Call the width function
 413                 CMP     R1,R4                   ;Is the the longest width?
 414                 MOVGT   R4,R1                   ;Yes -- remember this fact
 415                 MOV     R1,R7                   ;Put R1 back again
 416                 B       %00lb__getMaxWidth      ;Check other items
 417
 418 99              MOV     R0,R4                   ;Put width in R0
 419                 STR     R0,[R10,#lb__maxWidth]  ;And store in the listbox
 420                 LDMFD   R13!,{R1-R7,PC}^        ;And return to caller
 421
 422                 LTORG
 423
 424 ; --- lb__eventHandler ---
 425 ;
 426 ; On entry:     R0 == event type
 427 ;               R1 == pointer to event block
 428 ;
 429 ; On exit:      --
 430 ;
 431 ; Use:          Called to deal with events on the listbox window
 432
 433 lb__eventHandler ROUT
 434
 435                 CMP     R0,#1                   ;Is it a redraw event?
 436                 BEQ     lb__redraw              ;Yes -- handle it then
 437                 CMP     R0,#3                   ;Is it a close event?
 438                 BEQ     lb__close               ;Yes -- report it then
 439                 CMP     R0,#10                  ;Scroll request?
 440                 BEQ     lb__scroll              ;Yes -- let's hope we cope
 441                 CMP     R0,#6                   ;Is it a click event?
 442                 BEQ     lb__click               ;Yes -- handle that
 443                 CMP     R0,#17                  ;Is it a message (normal)?
 444                 CMPNE   R0,#18                  ;Or a rubber message?
 445                 BEQ     lb__message             ;Yes -- handle it then
 446
 447                 BICS    PC,R14,#C_flag          ;Return -- didn't understand
 448
 449                 LTORG
 450
 451 ; --- lb__dispatch ---
 452 ;
 453 ; On entry:     R0 == a list box event code
 454 ;               R1-R8 == arguments for the client's event handler
 455 ;               R10 == list box handle
 456 ;
 457 ; On exit:      CC or CS, from the event handler
 458 ;
 459 ; Use:          Sends an event to the user event handler for the list box.
 460
 461 lb__dispatch    ROUT
 462
 463                 STMFD   R13!,{R9,R10,R12,R14}   ;Save some useful registers
 464                 ADD     R14,R10,#lb__handler    ;Point to the handler stuff
 465                 LDMIA   R14,{R9,R10,R12}        ;Load the appropriate bits
 466                 ADDS    R0,R0,#0                ;Clear the carry flag
 467                 TEQ     R9,#0                   ;Is there a handler defined?
 468                 MOV     R14,PC                  ;Set up a return address
 469                 MOVNE   PC,R9                   ;Yes -- call the handler
 470                 LDMFD   R13!,{R9,R10,R12,R14}   ;Unstack the registers again
 471                 BICCCS  PC,R14,#C_flag          ;If C clear then clear C
 472                 ORRCSS  PC,R14,#C_flag          ;If C set then set C
 473
 474                 LTORG
 475
 476 ; --- lb__message ---
 477 ;
 478 ; On entry:     R0 == message type (17 or 18)
 479 ;               R1 == event block
 480 ;
 481 ; On exit:      --
 482 ;
 483 ; Use:          Called when the listbox recieves a message
 484
 485 lb__message     ROUT
 486
 487                 STMFD   R13!,{R0-R5,R14}        ;Stack some messages
 488                 LDR     R0,[R1,#16]             ;Get the message type
 489                 CMP     R0,#1                   ;Is it a save message?
 490                 CMPNE   R0,#3                   ;Or a load message?
 491                 BEQ     %10lb__message          ;Yes -- handle them the same
 492                 LDR     R14,=&502               ;The help message code
 493                 CMP     R0,R14                  ;Is that the message?
 494                 BEQ     %05lb__message          ;Yes -- deal with it
 495
 496                 ; --- Check for mode/font changes ---
 497
 498                 CMP     R0,R14                  ;Are they the same
 499                 LDRNE   R14,=&400CF             ;Also get a FontChange msg
 500                 CMPNE   R0,R14                  ;Does this match?
 501                 BLEQ    lb__getMaxWidth         ;Yes -- calculate max width
 502                 BLEQ    lb__rescanSize          ;...and rescan the size
 503                 LDMFD   R13!,{R0-R5,PC}^        ;And return to caller
 504
 505                 ; --- Handle a help request ---
 506
 507 05lb__message   ADD     R1,R1,#20               ;Point to mouse info
 508                 BL      lb__getItem             ;Get the item under pointer
 509                 MOV     R0,#lbEvent_help        ;Set up the event type
 510                 BL      lb__dispatch            ;Dispatch the event
 511                 LDMFD   R13!,{R0-R5,PC}^        ;Return to caller
 512
 513                 ; --- Handle data saves and loads ---
 514
 515 10lb__message   CMP     R0,#1                   ;Is it a save message?
 516                 MOVEQ   R5,#lbDrop_save         ;Set up the subreason code
 517                 MOVNE   R5,#lbDrop_load
 518
 519                 MOV     R6,R1                   ;Remember the block pointer
 520                 SUB     R13,R13,#52             ;Get a nice block
 521                 MOV     R1,R13                  ;Point to it
 522                 SWI     Wimp_GetPointerInfo     ;Get pointer information
 523                 BL      lb__getItem             ;Get the item under pointer
 524                 ADD     R13,R13,#52             ;Get the stack back
 525
 526                 LDR     R2,[R6,#40]             ;Load the file type
 527                 ADD     R3,R6,#44               ;Point to the filename
 528                 LDR     R4,[R6,#36]             ;Load the estimated size
 529                 MOV     R0,#lbEvent_drop        ;The event type
 530                 BL      lb__dispatch            ;Dispatch the event
 531                 LDMFD   R13!,{R0-R5,PC}^        ;Return to caller
 532
 533                 LTORG
 534
 535 ; --- lb__getItem ---
 536 ;
 537 ; On entry:     R1 == pointer to a mouse info block
 538 ;               R10 == pointer to the listbox
 539 ;
 540 ; On exit:      R1 == the item
 541 ;
 542 ; Use:          Returns the item the pointer is over
 543
 544 lb__getItem     ROUT
 545
 546                 STMFD   R13!,{R0,R2-R4,R9,R14}  ;Stack some registers
 547                 MOV     R9,R1                   ;Keep the mouse info block
 548                 SUB     R13,R13,#36             ;Get me a nice block
 549                 LDR     R0,[R9,#12]             ;The window handle
 550                 STR     R0,[R13,#0]             ;Store it in the block
 551                 MOV     R1,R13                  ;Point to the block
 552                 SWI     Wimp_GetWindowState     ;Get the window state
 553
 554                 LDR     R2,[R13,#16]            ;y1 coord
 555                 LDR     R14,[R13,#24]           ;Scroll y position
 556                 SUB     R2,R2,R14               ;Screen coord of origin
 557                 LDR     R14,[R9,#4]             ;Mouse y position
 558                 SUB     R2,R14,R2               ;Window relative position
 559                 ADD     R13,R13,#36             ;Get stack back
 560                 BL      screen_getInfo          ;Get screen information
 561                 LDR     R14,[R0,#screen_dy]     ;Get y pixel size
 562                 ADD     R0,R2,R14               ;Prepare for division
 563                 LDR     R1,[R10,#lb__iHeight]   ;By the item height
 564                 RSB     R1,R1,#0                ;Negate it
 565                 BL      divide                  ;Perform the division
 566                 MOV     R1,R0                   ;Put index in R1
 567                 LDR     R0,[R10,#lb__list]      ;And list head in R0
 568                 LDR     R4,[R10,#lb__descriptor] ;Get the descriptor block
 569                 MOV     R14,PC                  ;Set up the return address
 570                 ADD     PC,R4,#lb_indexToItem   ;Get the item itself
 571                 LDMFD   R13!,{R0,R2-R4,R9,PC}^  ;Return to caller
 572
 573                 LTORG
 574
 575 ; --- lb__redraw ---
 576 ;
 577 ; On entry:     R1 == pointer to a window handle
 578 ;
 579 ; On exit:      CS
 580 ;
 581 ; Use:          Redraws a list box, by sending redraw events to the client.
 582
 583 lb__redraw      ROUT
 584
 585                 STMFD   R13!,{R0-R9,R14}        ;Save masses of registers
 586
 587                 ; --- Start a redraw job ---
 588
 589                 SWI     Wimp_RedrawWindow       ;Start the redraw
 590                 CMP     R0,#0                   ;Is there anything to do?
 591                 BEQ     %90lb__redraw           ;No -- don't do it then
 592
 593                 ; --- Do some setting up ---
 594
 595                 ADD     R14,R1,#16              ;Point to the top edge
 596                 LDMIA   R14,{R0,R9,R14}         ;Load that and the scroll pos
 597                 SUB     R7,R0,R14               ;Work out the y origin pos
 598
 599                 ; --- Get the left and right sides set up ---
 600
 601                 LDR     R4,[R10,#lb__maxWidth]  ;Get the width of the items
 602                 LDR     R14,[R10,#lb__width]    ;Get the window width
 603                 CMP     R14,R4                  ;Is the window width bigger?
 604                 MOVGT   R4,R14                  ;Yes -- use that instead
 605
 606                 LDR     R9,[R10,#lb__descriptor] ;Load his list descriptor
 607                 LDR     R8,[R10,#lb__list]      ;Find the list block
 608
 609                 ; --- Work out which bits need drawing ---
 610
 611 10lb__redraw    LDR     R6,[R1,#40]             ;Load the top y coordinate
 612                 SUB     R6,R6,R7                ;Convert to window coords
 613                 LDR     R14,[R10,#lb__iHeight]  ;Get the item height
 614                 ADD     R6,R6,R14               ;Get height thingy value
 615
 616                 MOV     R5,#0                   ;Top of the first item
 617                 MOV     R1,#0                   ;Start at item -1 (sort of)
 618
 619                 ; --- Get items until one is visible ---
 620
 621 15lb__redraw    MOV     R0,R8                   ;Point to the list block
 622                 MOV     R2,#0                   ;Don't care about the flags
 623                 MOV     R3,#0                   ;I *really* don't care at all
 624                 MOV     R14,PC                  ;Set up the return address
 625                 ADD     PC,R9,#lb_enumerate     ;Get a new item in R1
 626                 BCC     %70lb__redraw           ;Run out -- 76 for 3
 627
 628                 CMP     R5,R6                   ;Is this item visible?
 629                 LDRGT   R14,[R10,#lb__iHeight]  ;No -- get the item height
 630                 SUBGT   R5,R5,R14               ;Move to the next one down
 631                 BGT     %15lb__redraw           ;And find one that is then
 632
 633                 ; --- Now draw items until they stop being visible ---
 634
 635                 LDR     R6,[R13,#4]             ;Get the redraw block pointer
 636                 LDR     R6,[R6,#32]             ;Load the bottom y coordinate
 637                 SUB     R6,R6,R7                ;And convert to window coords
 638
 639                 ; --- The main plotting loop ---
 640
 641 20lb__redraw    CMP     R5,R6                   ;Is this one visible?
 642                 BLE     %80lb__redraw           ;No -- then stop plotting
 643
 644                 MOV     R0,#lbEvent_redraw      ;Send a redraw event on
 645                 LDR     R14,[R10,#lb__iHeight]  ;Get the item height
 646                 SUB     R3,R5,R14               ;Get the item bottom bit
 647                 MOV     R2,#0                   ;Left hand side is at 0
 648                 BL      lb__dispatch            ;Send the event on then
 649
 650                 MOV     R5,R3                   ;Move to the next item down
 651                 MOV     R0,R8                   ;Point to the list block
 652                 MOV     R2,#0                   ;Don't care about the flags
 653                 MOV     R3,#0                   ;I *really* don't care at all
 654                 MOV     R14,PC                  ;Set up the return address
 655                 ADD     PC,R9,#lb_enumerate     ;Get a new item in R1
 656                 BCS     %20lb__redraw           ;More to do -- go round again
 657
 658                 ; --- Fill in the rest in grey ---
 659
 660                 CMP     R5,R6                   ;Do we really have to draw it
 661                 BLE     %80lb__redraw           ;No -- then stop plotting
 662
 663 70lb__redraw    MOV     R0,#1                   ;The background colour
 664                 SWI     Wimp_SetColour          ;Set the colour up
 665                 ADD     R2,R5,R7                ;Get the top of the area
 666                 BL      screen_getInfo          ;Read some screen information
 667                 MOV     R14,#1                  ;This will be shifty
 668                 LDR     R0,[R0,#screen_yEig]    ;Load the y eigen factor
 669                 SUB     R2,R2,R14,LSL R0        ;S*dding thing's exclusive
 670                 LDR     R3,[R13,#4]             ;Load the redraw block addr
 671                 LDR     R1,[R3,#28]             ;Load the left hand side
 672                 MOV     R0,#4                   ;Move cursor absolute
 673                 SWI     OS_Plot                 ;Do the plotting bit
 674                 MOV     R0,#101                 ;Rectangle fill absolute
 675                 LDR     R1,[R3,#36]             ;Get the right hand side
 676                 LDR     R2,[R3,#32]             ;And the bottom edge
 677                 SWI     OS_Plot                 ;Fill in the remaining bit
 678
 679                 ; --- Go round and get another rectangle ---
 680
 681 80lb__redraw    LDR     R1,[R13,#4]             ;Get the redraw block pointer
 682                 SWI     Wimp_GetRectangle       ;Get the next rectangle
 683                 CMP     R0,#0                   ;Is there more to draw?
 684                 BNE     %10lb__redraw           ;Yes -- go round again
 685
 686                 ; --- We finished at last ---
 687
 688 90lb__redraw    LDMFD   R13!,{R0-R9,R14}        ;Unstack the registers again
 689                 ORRS    PC,R14,#C_flag          ;More redraws cause flicker
 690
 691                 LTORG
 692
 693 ; --- lb__close ---
 694 ;
 695 ; On entry:     --
 696 ;
 697 ; On exit:      --
 698 ;
 699 ; Use:          Informs the user when the listbox has been closed.
 700
 701 lb__close       ROUT
 702
 703                 STMFD   R13!,{R0,R14}           ;Stack some register
 704                 MOV     R0,#lbEvent_close       ;Send this event code
 705                 BL      lb__dispatch            ;And dispatch the event
 706                 LDMFD   R13!,{R0,PC}            ;Return to caller
 707
 708                 LTORG
 709
 710 ; --- lb__scroll ---
 711 ;
 712 ; On entry:     R0 == 10
 713 ;               R1 == event block
 714 ;
 715 ; On exit:      --
 716
 717 lb__scroll      ROUT
 718
 719                 STMFD   R13!,{R0-R4,R14}        ;Stack some registers
 720                 MOV     R4,R1                   ;Keep the block pointer
 721
 722                 ; --- First, try to scroll vertically ---
 723
 724                 LDR     R0,[R4,#24]             ;Load the y scroll offset
 725                 ADD     R14,R4,#8               ;Find the bottom edge
 726                 LDMIA   R14,{R2,R3,R14}         ;Load the y positions
 727                 SUB     R3,R14,R2               ;R3 is the window height now
 728                 LDR     R2,[R10,#lb__iHeight]   ;Get the item height
 729
 730                 LDR     R14,[R1,#36]            ;Get vertical scroll value
 731                 ADD     R14,R14,#1              ;Convert into range -1..3
 732                 ADD     PC,PC,R14,LSL #2        ;And jump to right routine
 733
 734                 B       %10lb__scroll           ;Y scroll page down
 735                 B       %20lb__scroll           ;Y scroll line down
 736                 B       %50lb__scroll           ;No y scrolling
 737                 B       %40lb__scroll           ;Y scroll line up
 738                 B       %30lb__scroll           ;Y scroll page up
 739
 740                 ; --- Do a y scroll page down ---
 741
 742 10lb__scroll    SUB     R0,R0,R3                ;Find the window bottom
 743                 MOV     R1,R2                   ;Now prepare to divide by it
 744                 SUB     R0,R0,R2                ;Make it round towards 0
 745                 BL      divide                  ;Get the quotient value
 746                 MUL     R0,R2,R0                ;And multiply it up again
 747                 ADD     R0,R0,R2,LSL #1         ;Find the appropriate top
 748                 STR     R0,[R4,#24]             ;Store the scroll offset back
 749                 B       %50lb__scroll           ;And now do the x bit
 750
 751                 ; --- Do a y scroll line down ---
 752
 753 20lb__scroll    SUB     R0,R0,R3                ;Find the window bottom
 754                 MOV     R1,R2                   ;Now prepare to divide by it
 755                 SUB     R0,R0,R2                ;Make it round towards 0
 756                 BL      divide                  ;Get the quotient value
 757                 MUL     R0,R2,R0                ;And multiply it up again
 758                 ADD     R0,R0,R3                ;Find the appropriate top
 759                 STR     R0,[R4,#24]             ;Store the scroll offset back
 760                 B       %50lb__scroll           ;And now do the x bit
 761
 762                 ; --- Do a y scroll page up ---
 763
 764 30lb__scroll    MOV     R1,R2                   ;Now prepare to divide by it
 765                 ADD     R0,R0,#1                ;Make it round towards 0
 766                 BL      divide                  ;Get the quotient value
 767                 MUL     R0,R2,R0                ;And multiply it up again
 768                 ADD     R0,R0,R3                ;Scroll the whole window up
 769                 SUB     R0,R0,R2,LSL #1         ;And scroll back two items
 770                 STR     R0,[R4,#24]             ;Store the scroll offset back
 771                 B       %50lb__scroll           ;And now do the x bit
 772
 773                 ; --- Do a y scroll line up ---
 774
 775 40lb__scroll    MOV     R1,R2                   ;Now prepare to divide by it
 776                 ADD     R0,R0,#1                ;Make it round towards 0
 777                 BL      divide                  ;Get the quotient value
 778                 MUL     R0,R2,R0                ;And multiply it up again
 779                 STR     R0,[R4,#24]             ;Store the scroll offset back
 780                 B       %50lb__scroll           ;And now do the x bit
 781
 782                 ; --- Now do the x scrolling ---
 783
 784 50lb__scroll    LDR     R0,[R4,#20]             ;Load the x scroll offset
 785                 ADD     R14,R4,#4               ;Find the left hand side
 786                 LDMIA   R14,{R2,R3,R14}         ;Load the x positions
 787                 SUB     R3,R14,R2               ;Get the current window width
 788
 789                 LDR     R14,[R4,#32]            ;Get horizontal scroll value
 790                 CMP     R14,#-2                 ;Scroll left by a page?
 791                 SUBEQ   R0,R0,R3                ;Yes -- do it then
 792                 CMP     R14,#-1                 ;Scroll left by a column?
 793                 SUBEQ   R0,R0,#32               ;Yes -- do it then
 794                 CMP     R14,#1                  ;Scroll right by a column?
 795                 ADDEQ   R0,R0,#32               ;Yes -- do it then
 796                 CMP     R14,#2                  ;Scroll right by a page?
 797                 ADDEQ   R0,R0,R3                ;Yes -- do it then
 798                 STR     R0,[R4,#20]             ;Save the x scroll offset
 799
 800 99lb__scroll    MOV     R1,R4                   ;Point to the block again
 801                 SWI     Wimp_OpenWindow         ;Actually do the scrolling
 802                 LDMFD   R13!,{R0-R4,R14}        ;Return to caller
 803                 ORRS    PC,R14,#C_flag
 804
 805                 LTORG
 806
 807 ; --- lb_plotString ---
 808 ;
 809 ; On entry:     R0 == pointer to a string
 810 ;               R1 == pointer to the list item
 811 ;               R2-R5 == window coordinates to plot it
 812 ;               R10 == pointer to the listbox
 813 ;
 814 ; On exit:      --
 815 ;
 816 ; Use:          Plots a list item consisting of a single string.  It assumes
 817 ;               the default selection model.
 818
 819                 EXPORT  lb_plotString
 820 lb_plotString   ROUT
 821
 822                 STMFD   R13!,{R0-R4,R14}        ;Save a lot of registers
 823                 SUB     R13,R13,#32             ;Make an icon block
 824                 STMIA   R13,{R2-R5}             ;Save the coordinates in it
 825                 MOV     R2,#-1                  ;No validation string
 826                 MOV     R3,#1                   ;Put in a silly buffer size
 827                 ADD     R14,R13,#20             ;Point to icon data section
 828                 STMIA   R14,{R0,R2,R3}          ;Save the icon data away
 829                 LDR     R4,[R10,#lb__descriptor] ;Get the descriptor block
 830                 LDR     R0,[R10,#lb__list]      ;Point to the list head
 831                 MOV     R2,#0                   ;Don't alter the flags
 832                 MOV     R3,#0                   ;Don't alter them at all
 833                 MOV     R14,PC                  ;Set up return address
 834                 ADD     PC,R4,#lb_setFlags      ;Read the item's flags
 835                 LDR     R0,=&07000131           ;Set up default flags
 836                 TST     R2,#3                   ;Is it selected?
 837                 ORRNE   R0,R0,#&00200000        ;Yes -- set the selected bit
 838                 STR     R0,[R13,#16]            ;Store the flags in the blk
 839                 MOV     R1,R13                  ;Point to the icon block
 840                 SWI     Wimp_PlotIcon           ;Plot the icon then
 841                 ADD     R13,R13,#32             ;Recover the icon block
 842                 LDMFD   R13!,{R0-R4,PC}^        ;Return to caller
 843
 844                 LTORG
 845
 846 ; --- lb_update ---
 847 ;
 848 ; On entry:     R0 == listbox handle
 849 ;
 850 ; On exit:      May return an error
 851 ;
 852 ; Use:          Updates the entire listbox prettily
 853
 854                 EXPORT  lb_update
 855 lb_update       ROUT
 856
 857                 STMFD   R13!,{R0-R4,R10,R14}    ;Stack sonme registers
 858
 859                 MOV     R10,R0                  ;Put list box handle in R10
 860                 BL      lb__getMaxWidth         ;Get the maximum width
 861                 BL      lb__rescanSize          ;Ensure windows right size
 862                 BVS     %90lb_update            ;Barf on error
 863                 LDR     R0,[R10,#lb__wHandle]   ;Get the window handle
 864                 MOV     R1,#0                   ;x0
 865                 LDR     R2,[R10,#lb__height]    ;Overall height
 866                 RSB     R2,R2,#0                ;Negate it
 867                 LDR     R3,[R10,#lb__width]     ;Overall width -- x1
 868                 LDR     R14,[R10,#lb__maxWidth] ;And the widest item width
 869                 CMP     R14,R3                  ;Which one is bigger?
 870                 MOVGT   R3,R14                  ;Make R3 biggest
 871                 MOV     R4,#0                   ;y1
 872                 SWI     Wimp_ForceRedraw        ;Force a redraw
 873
 874                 LDMFD   R13!,{R0-R4,R10,PC}^    ;Return to caller
 875
 876 90lb_update     ADD     R13,R13,#4              ;Point past R0
 877                 LDMFD   R13!,{R1-R4,R10,R14}    ;Get back some registers
 878                 ORRS    PC,R14,#V_flag          ;Return with error
 879
 880                 LTORG
 881
 882 ; --- lb_updateItem ---
 883 ;
 884 ; On entry:     R0 == list box handle
 885 ;               R1 == list item handle
 886 ;
 887 ; On exit:      --
 888 ;
 889 ; Use:          Redraws a list item to reflect a change in its state.
 890
 891                 EXPORT  lb_updateItem
 892 lb_updateItem   ROUT
 893
 894                 STMFD   R13!,{R0-R5,R10,R14}    ;Save a load of registers
 895
 896                 ; --- Find the item's index ---
 897
 898                 MOV     R10,R0                  ;Keep the list box handle
 899                 LDR     R0,[R10,#lb__list]      ;Find the list block
 900                 LDR     R2,[R10,#lb__descriptor] ;Find the list descriptor
 901                 MOV     R14,PC                  ;Set up the return address
 902                 ADD     PC,R2,#lb_itemToIndex   ;Get the item's index
 903
 904                 ; --- Now set up the update block ---
 905
 906                 SUB     R13,R13,#44             ;Make space for update blk
 907                 LDR     R0,[R10,#lb__wHandle]   ;Get the window handle
 908                 LDR     R14,[R10,#lb__iHeight]  ;Get the item height
 909                 RSB     R14,R14,#0              ;Negate it
 910                 MUL     R5,R14,R1               ;Get the top of the item
 911                 ADD     R3,R5,R14               ;And get the bottom too
 912                 MOV     R2,#0                   ;Redraw from left hand side
 913                 LDR     R4,[R10,#lb__width]     ;Load the window width
 914                 LDR     R14,[R10,#lb__maxWidth] ;And the widest item width
 915                 CMP     R14,R4                  ;Which one is bigger?
 916                 MOVGT   R4,R14                  ;Use the biggest one
 917                 STMIA   R13,{R0,R2-R5}          ;Save them in the block
 918
 919                 ; --- Update the item ---
 920
 921                 MOV     R1,R13                  ;Point to the window block
 922                 SWI     Wimp_UpdateWindow       ;Start doing the update
 923                 CMP     R0,#0                   ;Is there anything to do?
 924                 BEQ     %90lb_updateItem        ;No -- skip it all then
 925
 926 10lb_updateItem MOV     R0,#lbEvent_redraw      ;Send out a redraw event
 927                 LDR     R1,[R13,#48]            ;Get the item handle
 928                 BL      lb__dispatch            ;Give the user an event
 929                 MOV     R1,R13                  ;Point to the update block
 930                 SWI     Wimp_GetRectangle       ;Get another rectangle
 931                 CMP     R0,#0                   ;Was that the last one?
 932                 BNE     %10lb_updateItem        ;No -- do another one then
 933
 934                 ; --- Tidy up and go home again ---
 935
 936 90lb_updateItem ADD     R13,R13,#44             ;Restore the stack pointer
 937                 LDMFD   R13!,{R0-R5,R10,PC}^    ;And return to the caller
 938
 939                 LTORG
 940
 941 ; --- lb_select ---
 942 ;
 943 ; On entry:     R0 == listbox handle
 944 ;               R1 == item handle
 945 ;               R2 == 0 to unselect, 1 to select, or 2 to toggle
 946 ;
 947 ; On exit:      --
 948 ;
 949 ; Use:          Selects or deselects a listbox item, nicely and without
 950 ;               flickering it.
 951
 952                 EXPORT  lb_select
 953 lb_select       ROUT
 954
 955                 CMP     R1,#0                   ;Is there actually an item?
 956                 MOVEQS  PC,R14                  ;No -- then do nothing here
 957
 958                 STMFD   R13!,{R0-R5,R10,R14}    ;Save some registers away
 959                 MOV     R10,R0                  ;Get the listbox handle
 960
 961                 ; --- Read the current flags ---
 962
 963                 LDR     R4,[R10,#lb__descriptor] ;Find the list definition
 964                 MOV     R5,R2                   ;And look after argument
 965                 MOV     R3,#0                   ;Want to read the flags
 966                 MOV     R2,#0                   ;Oh, yes I do
 967                 LDR     R0,[R10,#lb__list]      ;Load the list block
 968                 MOV     R14,PC                  ;Set up the return address
 969                 ADD     PC,R4,#lb_setFlags      ;And read the current flags
 970
 971                 ; --- Work out new flags ---
 972
 973                 AND     R2,R2,#1                ;Only leave selected flag
 974                 CMP     R5,#1                   ;What is the operation?
 975                 MOVLT   R3,#0                   ;Clear -- clear the flag
 976                 MOVEQ   R3,#1                   ;Set -- set the flag
 977                 EORGT   R3,R2,#1                ;Toggle -- toggle the flag
 978                 CMP     R3,R2                   ;Have we made a difference?
 979                 LDMEQFD R13!,{R0-R5,R10,PC}^    ;No -- return now then
 980
 981                 ; --- Set the new flags ---
 982
 983                 MOV     R2,#1                   ;Clear the selected bit
 984                 MOV     R14,PC                  ;Set up return address
 985                 ADD     PC,R4,#lb_setFlags      ;Set the new flags nicely
 986                 MOV     R0,R10                  ;Get handle in R0
 987                 BL      lb_updateItem           ;And redraw the list item
 988                 LDMFD   R13!,{R0-R5,R10,PC}^    ;And return to caller
 989
 990                 LTORG
 991
 992 ; --- lb_isSelected ---
 993 ;
 994 ; On entry:     R0 == listbox handle
 995 ;               R1 == item handle
 996 ;
 997 ; On exit:      CS if item is selected, else CC
 998 ;
 999 ; Use:          Informs you whether an item is selected.
1000
1001                 EXPORT  lb_isSelected
1002 lb_isSelected   ROUT
1003
1004                 CMP     R1,#0                   ;Is there an icon?
1005                 BICEQS  PC,R14,#C_flag          ;No -- not selected then
1006                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
1007                 MOV     R2,#0                   ;Don't clear any flags
1008                 MOV     R3,#0                   ;Don't toggle any either
1009                 LDR     R4,[R0,#lb__descriptor] ;Find the list block
1010                 LDR     R0,[R0,#lb__list]       ;Find the list base
1011                 MOV     R14,PC                  ;Set up return address
1012                 ADD     PC,R4,#lb_setFlags      ;Read the current flags
1013                 TST     R2,#1                   ;Is it selected then?
1014                 LDMFD   R13!,{R0-R4,R14}        ;Restore caller's registers
1015                 ORRNES  PC,R14,#C_flag          ;If selected, return C set
1016                 BICEQS  PC,R14,#C_flag          ;Otherwise clear C on exit
1017
1018                 LTORG
1019
1020 ; --- lb__click ---
1021 ;
1022 ; On entry:     R1 == pointer to event block
1023 ;
1024 ; On exit:      CS
1025 ;
1026 ; Use:          Dispatches click events on the list box
1027
1028 lb__click       ROUT
1029
1030                 ORR     R14,R14,#C_flag         ;Set the carry flag
1031                 STMFD   R13!,{R0-R4,R9,R14}     ;Stack some registers
1032                 MOV     R9,R1                   ;Keep a pointer to the block
1033
1034                 BL      lb__getItem             ;Get item pointer is over
1035
1036                 LDR     R3,[R9,#8]              ;Get the mouse button status
1037                 TST     R3,#&5                  ;Double select or ajdust
1038                 TSTEQ   R3,#&500                ;No -- just select or adjust?
1039                 BNE     %10lb__click            ;Yes -- handle it then
1040                 TST     R3,#&50                 ;Drag with select or adjust?
1041                 BNE     %20lb__click            ;Yes -- deal with that
1042                 TST     R3,#&2                  ;Is it menu click?
1043                 LDMEQFD R13!,{R0-R3,R9,PC}^     ;no -- return then
1044
1045                 ; --- Deal with menu clicks ---
1046
1047                 MOV     R0,#lbEvent_menu        ;The event type
1048                 BL      lb__dispatch            ;Dispatch the event
1049                 B       %99lb__click            ;And return to caller
1050
1051                 ; --- Click or double click on an item ---
1052
1053 10              MOV     R0,#lbEvent_click       ;The event type
1054                 BL      lb__dispatch            ;Dispatch the event
1055                 B       %99lb__click            ;And return to caller
1056
1057                 ; --- There was a drag event ---
1058
1059 20              MOV     R0,#lbEvent_drag        ;The event type
1060                 BL      lb__dispatch            ;Dispatch the event
1061                 B       %99lb__click            ;And return to caller
1062
1063 99              LDMFD   R13!,{R0-R4,R9,PC}^     ;Return to caller
1064
1065                 LTORG
1066
1067 ; --- lb_clearSelection ---
1068 ;
1069 ; On entry:     R0 == listbox handle
1070 ;               R1 == item handle of item to ignore (or 0 for none)
1071 ;
1072 ; On exit:      --
1073 ;
1074 ; Use:          Deselects all items in the listbox.
1075
1076                 EXPORT  lb_clearSelection
1077 lb_clearSelection ROUT
1078
1079                 STMFD   R13!,{R0-R6,R10,R14}    ;Stack some registers
1080                 MOV     R10,R0                  ;Get the listbox handle
1081                 LDR     R6,[R10,#lb__list]      ;And load the list pointer
1082                 MOV     R5,R1                   ;Remember this item
1083                 LDR     R4,[R10,#lb__descriptor] ;Point to the descriptor blk
1084
1085                 MOV     R1,#0                   ;Start with the first item
1086 00              MOV     R0,R6                   ;Get the list handle
1087                 MOV     R2,#1                   ;Only read selected items
1088                 MOV     R3,#1                   ;Don't want the others
1089                 MOV     R14,PC                  ;Set up return address
1090                 ADD     PC,R4,#lb_enumerate     ;Read the item and flags
1091                 BCC     %90                     ;No more items -- skip
1092
1093                 CMP     R1,R5                   ;Is this the special item?
1094                 BEQ     %b00                    ;Yes -- ignore it then
1095                 MOV     R0,R10                  ;No -- get the list handle
1096                 MOV     R2,#0                   ;Deselect it please
1097                 BL      lb_select               ;And unselect the item
1098                 B       %b00                    ;And loop back again
1099
1100 90              LDMFD   R13!,{R0-R6,R10,PC}^    ;Return to caller
1101
1102                 LTORG
1103
1104 ; --- lb_clickS ---
1105 ;
1106 ; On entry:     R0 == listbox handle
1107 ;               R1 == pointer to list item
1108 ;               R3 == mouse button status
1109 ;
1110 ; On exit:      --
1111 ;
1112 ; Use:          Provides a default action for clicking on an item in a
1113 ;               list box.
1114 ;
1115 ;               Only one selection is possible at any one time.
1116
1117                 EXPORT  lb_clickS
1118 lb_clickS       ROUT
1119
1120                 STMFD   R13!,{R0,R2,R14}        ;Stack some registers
1121                 BL      lb_clearSelection       ;Clear all the other items
1122                 TST     R3,#&100                ;Is it an adjust click?
1123                 TSTEQ   R3,#&001                ;Better check the double too
1124                 MOVNE   R2,#2                   ;Yes -- then toggle the item
1125                 MOVEQ   R2,#1                   ;Otherwise just select
1126                 BL      lb_select               ;Go and select the item
1127                 LDMFD   R13!,{R0,R2,PC}^        ;Return to caller
1128
1129                 LTORG
1130
1131 ; --- lb_clickM ---
1132 ;
1133 ; On entry:     R0 == listbox handle
1134 ;               R1 == pointer to list item
1135 ;               R3 == mouse button status
1136 ;
1137 ; On exit:      --
1138 ;
1139 ; Use:          Provides a default action for clicking on an item in a
1140 ;               list box.
1141 ;
1142 ;               The multiple selection model is used.
1143
1144                 EXPORT  lb_clickM
1145 lb_clickM       ROUT
1146
1147                 STMFD   R13!,{R0,R2,R14}        ;Stack some registers
1148                 TST     R3,#&100                ;Is it an adjust click?
1149                 TSTEQ   R3,#&001                ;Better check the double too
1150                 BEQ     %50lb_clickM            ;No -- then deal elsewhere
1151                 MOV     R2,#2                   ;Just toggle the item
1152                 BL      lb_select               ;Do the selecting bit
1153                 B       %90lb_clickM            ;And skip onwards
1154 50lb_clickM     BL      lb_isSelected           ;Is the item selected?
1155                 BLCC    lb_clearSelection       ;No -- then clear the others
1156                 MOVCC   R2,#1                   ;Select this item
1157                 BLCC    lb_select               ;Go and do that
1158 90lb_clickM     LDMFD   R13!,{R0,R2,PC}^        ;Return to caller
1159
1160                 LTORG
1161
1162 ; --- lb__idleHandler ---
1163 ;
1164 ; On entry:     R10 == listbox handle
1165 ;               R12 == workspace pointer                                        ;
1166 ; On exit:      --
1167 ;
1168 ; Use:          Called on NULL events during a drag
1169
1170 lb__idleHandler ROUT
1171
1172                 STMFD   R13!,{R0-R9,R14}        ;Stack some registers
1173
1174                 SUB     R13,R13,#56             ;Get a block
1175                 MOV     R1,R13                  ;Point to it
1176                 SWI     Wimp_GetPointerInfo     ;Get pointer position
1177                 LDR     R0,[R10,#lb__wHandle]   ;Get the window handle
1178                 STR     R0,[R13,#20]            ;Store in the block
1179                 ADD     R1,R13,#20              ;Point to the block
1180                 SWI     Wimp_GetWindowState     ;Get the window state
1181                 LDR     R9,[R13,#36]            ;Get the y1 coordinate
1182                 LDR     R14,[R13,#44]           ;The scroll coordinate
1183                 SUB     R9,R9,R14               ;Window origin
1184                 LDR     R14,[R13,#4]            ;Mouse y position
1185                 SUB     R9,R14,R9               ;Make it window relative
1186
1187                 BL      screen_getInfo          ;Get screen information
1188                 LDR     R14,[R0,#screen_dy]     ;Get y pixel size
1189                 ADD     R0,R9,R14               ;Prepare for division
1190                 LDR     R1,[R10,#lb__iHeight]   ;By the item height
1191                 RSB     R1,R1,#0                ;Negate it
1192                 BL      divide                  ;Perform the division
1193                 CMP     R0,#0                   ;Is index negative?
1194                 MOVLT   R0,#0                   ;Yes -- make it 0
1195
1196                 LDR     R6,ws__dragItem         ;Get start drag index
1197                 LDR     R3,ws__dragLast         ;And last drag position
1198                 MOV     R8,R0                   ;Copy index into R1
1199                 MOV     R7,R0                   ;And R7
1200                 MOV     R5,R0                   ;And R5
1201
1202                 ; --- Find minimum and maximum values ---
1203
1204                 CMP     R7,R6                   ;R0>R2?
1205                 MOVGT   R7,R6                   ;Yes == R0:=R2
1206                 CMP     R7,R3                   ;R0>R3?
1207                 MOVGT   R7,R3                   ;Yes == R0:=R3
1208
1209                 CMP     R8,R6                   ;R0<R2?
1210                 MOVLT   R8,R6                   ;Yes == R0:=R2
1211                 CMP     R8,R3                   ;R0<R3?
1212                 MOVLT   R8,R3                   ;Yes == R0:=R3
1213
1214                 ; --- Summary ---
1215                 ;
1216                 ; R5 == the current index
1217                 ; R6 == the initial index
1218                 ; R7 == minimum of current,last and initial drag indicies
1219                 ; R8 == maximum of current,last and initial drag indicies
1220                 ; R9 == window relative position of the mouse position
1221
1222                 STMFD   R13!,{R12}              ;We need this -- blurgg!!
1223                 LDR     R12,[R10,#lb__descriptor] ;Point to descriptor block
1224                 MOV     R4,#-1                  ;Current item index (i)
1225                 MOV     R3,#-1                  ;The selection type
1226                 LDR     R0,[R10,#lb__list]      ;Get the list head
1227                 MOV     R1,#0                   ;Start from the first item
1228
1229 00              STMFD   R13!,{R3}               ;Preserve R3 over call
1230                 MOV     R2,#0                   ;Interested in all items
1231                 MOV     R3,#0                   ;Interested in all items
1232                 MOV     R14,PC                  ;Set up return address
1233                 ADD     PC,R12,#lb_enumerate    ;Call enumeration function
1234                 LDMFD   R13!,{R3}               ;Get R3 back again
1235                 BCC     %50lb__idleHandler      ;No more -- exit the loop
1236                 ADD     R4,R4,#1                ;Increment index count
1237
1238                 CMP     R4,R7                   ;i == start index?
1239                 MOVEQ   R3,#0                   ;Yes -- sel=0
1240                 CMP     R6,R5                   ;Initial index<index
1241                 BGT     %20lb__idleHandler      ;No -- jump ahead then
1242
1243                 CMP     R4,R6                   ;i=initial index?
1244                 MOVEQ   R3,#1                   ;Yes -- sel=1
1245                 CMP     R4,R5                   ;i>current index?
1246                 MOVGT   R3,#0                   ;Yes -- sel=0
1247                 B       %30lb__idleHandler      ;Jump ahead a bit
1248
1249 20              CMP     R4,R5                   ;i=current index?
1250                 MOVEQ   R3,#1                   ;Yes -- sel=1
1251                 CMP     R4,R6                   ;i>initial index?
1252                 MOVGT   R3,#0                   ;Yes -- sel=0
1253                 B       %30lb__idleHandler      ;Jump ahead a bit
1254
1255 30              CMP     R4,R8                   ;Are we at the end?
1256                 BGT     %50lb__idleHandler      ;Yes -- jump out of loop
1257
1258                 ; --- Redraw the item if we need to ---
1259
1260                 CMP     R3,#-1                  ;Do we need to do anything?
1261                 BEQ     %00lb__idleHandler      ;No -- keep going round
1262                 STMFD   R13!,{R0-R4}            ;Stack some registers
1263                 LDR     R0,[R10,#lb__list]      ;Get the list head
1264                 MOV     R4,R3                   ;Look after thing in R3
1265                 MOV     R2,#0                   ;Read the flags
1266                 MOV     R3,#0                   ;No writing here
1267                 MOV     R14,PC                  ;Set up return address
1268                 ADD     PC,R12,#lb_setFlags     ;Read the flags
1269                 ORR     R3,R2,R2,LSR#1          ;Is bit 0 or 1 set?
1270                 AND     R3,R3,#1                ;Just interested in this bit
1271                 CMP     R3,R4                   ;Is there a change to be made
1272                 BEQ     %40lb__idleHandler      ;No -- keep on looping then
1273                 ANDS    R2,R2,#1                ;Just get selected bit
1274                 BEQ     %35lb__idleHandler      ;If its clear -- jump ahead
1275                 CMP     R2,R4                   ;Is this the same?
1276                 BNE     %40lb__idleHandler      ;No -- return
1277 35              MOV     R2,#2                   ;Just alter this bit
1278                 MOV     R3,R4,LSL#1             ;Set or clear appropriately
1279                 LDR     R0,[R10,#lb__list]      ;Get the list head
1280                 MOV     R14,PC                  ;Set up return address
1281                 ADD     PC,R12,#lb_setFlags     ;Set the flags
1282                 MOV     R0,R10                  ;Put listbox handle in R0
1283                 BL      lb_updateItem           ;Update the item
1284
1285 40              LDMFD   R13!,{R0-R4}            ;Restore registers
1286                 B       %00lb__idleHandler      ;Keep going round
1287
1288 50              LDMFD   R13!,{R12}              ;Get R12 back again
1289                 STR     R5,ws__dragLast         ;Store last item visited
1290
1291                 ; --- Scroll the window nicely ---
1292
1293                 LDR     R0,[R13,#44]            ;Get the y scroll position
1294                 CMP     R9,R0                   ;Is mouse y>y scroll?
1295                 MOVGT   R0,R9                   ;Yes -- y scroll=mouse y
1296                 BGT     %55lb__idleHandler      ;...and jump ahead
1297                 LDR     R2,[R13,#36]            ;Get y1 coordinate
1298                 LDR     R3,[R13,#28]            ;Get y0 coordinate
1299                 SUB     R3,R2,R3                ;Get window height
1300                 ADD     R9,R9,R3                ;Add on mouse position
1301                 CMP     R9,R0                   ;Is it less than y scroll pos
1302                 MOVLT   R0,R9                   ;Yes -- use y scroll pos
1303 55              STR     R0,[R13,#44]            ;Store new scroll position
1304                 ADD     R1,R13,#20              ;Point to the block
1305                 SWI     Wimp_OpenWindow         ;Open the window
1306
1307 99              ADD     R13,R13,#56             ;Reclaim the stack
1308 99              LDMFD   R13!,{R0-R9,PC}^        ;Return to caller
1309
1310                 LTORG
1311
1312 ; --- lb__unknownHandler ---
1313 ;
1314 ; On entry:     R0 == event type
1315 ;               R1 == event block
1316 ;               R10 == listbox handle
1317 ;               R12 == workspace pointer
1318 ;
1319 ; On exit:      --
1320 ;
1321 ; Use:          Called when the drag is ended
1322
1323
1324 lb__unknownHandler ROUT
1325
1326                 CMP     R0,#7                   ;Are we interested?
1327                 MOVNES  PC,R14                  ;No -- return PDQ
1328
1329                 STMFD   R13!,{R0-R4,R14}        ;Stack some registers
1330
1331                 ; --- First get rid of the idle claimer ---
1332
1333                 MOV     R0,#0                   ;Call very frequently
1334                 ADR     R1,lb__idleHandler      ;Call this routine
1335                 MOV     R2,R10                  ;Call with this R10 handle
1336                 MOV     R3,R12                  ;And this R12 value
1337                 BL      idle_removeHandler      ;Add in the handler
1338
1339                 ; --- Now this  unknown handler ---
1340
1341                 ADR     R0,lb__unknownHandler   ;Call this routine
1342                 MOV     R1,#0                   ;R4 value
1343                 MOV     R2,R10                  ;Call with this R10 handle
1344                 MOV     R3,R12                  ;And this R12 value
1345                 BL      win_removeUnknownHandler ;Add in the handler
1346
1347                 ; --- Make temporary selections permanant ---
1348
1349                 LDR     R4,[R10,#lb__descriptor] ;Point to descriptor block
1350                 LDR     R0,[R10,#lb__list]      ;Get the list head
1351                 MOV     R1,#0                   ;Start from the top
1352 00              MOV     R2,#2                   ;Just interested in this bit
1353                 MOV     R3,#2                   ;And it must be set
1354                 MOV     R14,PC                  ;Set up the return address
1355                 ADD     PC,R4,#lb_enumerate     ;Enumerate the list
1356                 BCC     %99lb__unknownHandler   ;No more -- return
1357
1358                 LDR     R0,[R10,#lb__list]      ;Get the list head
1359                 MOV     R2,#3                   ;Clear these bits
1360                 MOV     R3,#1                   ;And set this one
1361                 MOV     R14,PC                  ;Set up the return address
1362                 ADD     PC,R4,#lb_setFlags      ;And set the flags
1363                 B       %00lb__unknownHandler   ;Keep going round for more
1364
1365 99              LDMFD   R13!,{R0-R4,PC}^        ;Return to caller
1366
1367                 LTORG
1368
1369 ; --- lb_drag ---
1370 ;
1371 ; On entry:     R0 == listbox handle
1372 ;               R1 == pointer to list item
1373 ;               R3 == mouse button status
1374 ;
1375 ; On exit:      --
1376 ;
1377 ; Use:          Starts a drag operation to allow for easy multiple
1378 ;               selection.
1379
1380                 EXPORT  lb_drag
1381 lb_drag         ROUT
1382
1383                 STMFD   R13!,{R0-R3,R10,R12,R14} ;Stack some registers
1384                 WSPACE  lb__wSpace              ;Locate my workspace
1385                 MOV     R10,R0                  ;Move listbox handle into R10
1386
1387                 LDR     R0,[R10,#lb__list]      ;Point to the list head
1388                 LDR     R2,[R10,#lb__descriptor] ;Point to descriptor block
1389                 CMP     R1,#0                   ;Is there an item
1390                 MOVEQ   R3,#lb_items            ;No -- use the item count
1391                 MOVNE   R3,#lb_itemToIndex      ;Yes -- find its index
1392                 MOV     R14,PC                  ;Set up return address
1393                 ADD     PC,R2,R3                ;Convert item to an index
1394                 STR     R1,ws__dragItem         ;The start drag item
1395                 STR     R1,ws__dragLast         ;Last item visited
1396
1397                 ; --- First we must start the drag box ---
1398
1399                 SUB     R13,R13,#40             ;Get me a block
1400                 MOV     R1,R13                  ;Point to the block
1401                 SWI     Wimp_GetPointerInfo     ;Get mouse position
1402                 LDR     R0,[R1,#0]              ;Get mouse x position
1403                 LDR     R1,=&9001               ;Parent y0
1404                 MOV     R2,R0                   ;Parent x1
1405                 LDR     R3,=&6FFE               ;Parent Parent y1
1406                 ADD     R14,R13,#24             ;Point to right place
1407                 STMIA   R14,{R0-R3}             ;Store parent coords
1408                 MOV     R0,#7                   ;The drag type
1409                 STR     R0,[R13,#4]             ;Store nicely in block
1410                 MOV     R1,R13                  ;Point to the block
1411                 SWI     Wimp_DragBox            ;Start the drag
1412
1413                 ; --- Set up the idle event handler ---
1414
1415                 MOV     R0,#0                   ;Call very frequently
1416                 ADR     R1,lb__idleHandler      ;Call this routine
1417                 MOV     R2,R10                  ;Call with this R10 handle
1418                 MOV     R3,R12                  ;And this R12 value
1419                 BL      idle_handler            ;Add in the handler
1420
1421                 ; --- Set up the unknown handler ---
1422
1423                 ADR     R0,lb__unknownHandler   ;Call this routine
1424                 MOV     R1,#0                   ;R4 value
1425                 MOV     R2,R10                  ;Call with this R10 handle
1426                 MOV     R3,R12                  ;And this R12 value
1427                 BL      win_unknownHandler      ;Add in the handler
1428
1429                 ; --- Now return to the caller ---
1430
1431                 ADD     R13,R13,#40             ;Reclaim the stack
1432                 LDMFD   R13!,{R0-R3,R10,R12,PC}^ ;Return to caller
1433
1434                 LTORG
1435
1436 ; --- lb_inserted ---
1437 ;
1438 ; On entry:     R0 == pointer to the listbox
1439 ;               R1 == pointer to the new item
1440 ;
1441 ; On exit:      --
1442 ;
1443 ; Use:          Informs the listbox that an item has been inserted,
1444 ;               and causes a flicker free insert to occur if possible.
1445
1446                 EXPORT  lb_inserted
1447 lb_inserted     ROUT
1448
1449                 STMFD   R13!,{R0-R8,R10,R14}    ;Stack some registers
1450
1451                 MOV     R10,R0                  ;Put listbox handle in R10
1452                 MOV     R7,R1                   ;Look after item
1453                 BL      lb__getMaxWidth         ;Get the maximum width
1454                 LDR     R2,[R10,#lb__wHandle]   ;Get the old window handle
1455                 BL      lb__rescanSize          ;Ensure windows right size
1456                 CMP     R2,R0                   ;Has the window changed?
1457                 BNE     %99lb_inserted          ;Yes -- return
1458
1459                 ; --- Now do the block copy ---
1460
1461                 LDR     R0,[R10,#lb__list]      ;Get the list head
1462                 LDR     R2,[R10,#lb__descriptor] ;Get the descriptor
1463                 MOV     R14,PC                  ;Set up the return address
1464                 ADD     PC,R2,#lb_itemToIndex   ;Convert item to index
1465
1466                 LDR     R8,[R10,#lb__iHeight]   ;Get the item height
1467                 RSB     R8,R8,#0                ;Negate it
1468                 MUL     R4,R8,R1                ;Get top of item
1469                 MOV     R14,PC                  ;Set up return address
1470                 ADD     PC,R2,#lb_items         ;Get the item count
1471                 MUL     R2,R1,R8                ;The overall height
1472                 LDR     R0,[R10,#lb__wHandle]   ;Get the window handle
1473                 MOV     R1,#0                   ;The minimum x coord
1474                 LDR     R3,[R10,#lb__width]     ;Load the window width
1475                 LDR     R6,[R10,#lb__maxWidth]  ;And the widest item width
1476                 CMP     R6,R3                   ;Which one is bigger?
1477                 MOVGT   R3,R6                   ;Use the biggest one
1478                 MOV     R5,#0                   ;x coord to move to
1479                 ADD     R6,R2,R8                ;y coord to move to
1480                 SWI     Wimp_BlockCopy          ;Do a block copy
1481
1482                 ; --- Finally, update the new item ---
1483
1484                 MOV     R0,R10                  ;Point to the listbox
1485                 MOV     R1,R7                   ;Put item pointer in R1
1486                 BL      lb_updateItem           ;Update the item
1487
1488 99lb_inserted   LDMFD   R13!,{R0-R8,R10,PC}^    ;Return to caller
1489
1490                 LTORG
1491
1492 ; --- lb_removed ---
1493 ;
1494 ; On entry:     R0 == pointer to the listbox
1495 ;               R1 == index of item removed
1496 ;
1497 ; On exit:      --
1498 ;
1499 ; Use:          Informs the listbox that an item has been removed, and
1500 ;               causes a flicker free remove to occur, if possible.
1501
1502                 EXPORT  lb_removed
1503 lb_removed      ROUT
1504
1505                 STMFD   R13!,{R0-R8,R10,R14}    ;Stack some registers
1506
1507                 MOV     R10,R0                  ;Put listbox handle in R10
1508                 MOV     R7,R1                   ;Look after item
1509                 BL      lb__getMaxWidth         ;Get the maximum width
1510                 LDR     R2,[R10,#lb__wHandle]   ;Get the old window handle
1511                 BL      lb__rescanSize          ;Ensure windows right size
1512                 CMP     R2,R0                   ;Has the window changed?
1513                 BNE     %99lb_removed           ;Yes -- return
1514
1515                 ; --- Now do the block copy ---
1516
1517                 LDR     R2,[R10,#lb__descriptor] ;Get the descriptor block
1518                 LDR     R8,[R10,#lb__iHeight]   ;Get the item height
1519                 RSB     R8,R8,#0                ;Negate it
1520                 MUL     R4,R8,R1                ;Get top of item
1521                 ADD     R4,R4,R8                ;Now get the bottom of it
1522                 LDR     R0,[R10,#lb__list]      ;Get the list head
1523                 MOV     R14,PC                  ;Set up return address
1524                 ADD     PC,R2,#lb_items         ;Get the item count
1525                 MUL     R2,R1,R8                ;The overall height
1526                 LDR     R3,[R10,#lb__height]    ;Get overall window height
1527                 SUB     R2,R2,R3                ;Subtract that for luck
1528                 LDR     R0,[R10,#lb__wHandle]   ;Get the window handle
1529                 MOV     R1,#0                   ;The minimum x coord
1530                 LDR     R3,[R10,#lb__width]     ;Load the window width
1531                 LDR     R6,[R10,#lb__maxWidth]  ;And the widest item width
1532                 CMP     R6,R3                   ;Which one is bigger?
1533                 MOVGT   R3,R6                   ;Use the biggest one
1534                 MOV     R5,#0                   ;x coord to move to
1535                 SUB     R6,R2,R8                ;y coord to move to
1536                 SWI     Wimp_BlockCopy          ;Do a block copy
1537
1538 99lb_removed    LDMFD   R13!,{R0-R8,R10,PC}^    ;Return to caller
1539
1540                 LTORG
1541
1542 ; --- lb_window ---
1543 ;
1544 ; On entry:     R0 == listbox handle
1545 ;
1546 ; On exit:      R0 == window handle
1547 ;
1548 ; Use:          Returns the window handle of the listbox
1549
1550                 EXPORT  lb_window
1551 lb_window       ROUT
1552
1553                 LDR     R0,[R0,#lb__wHandle]    ;Load the window handle
1554                 MOVS    PC,R14                  ;Return to caller
1555
1556                 LTORG
1557
1558 ; --- lb_init ---
1559 ;
1560 ; On entry:     --
1561 ;
1562 ; On exit:      --
1563 ;
1564 ; Use:          Initialises the listbox unit.
1565
1566                 EXPORT  lb_init
1567 lb_init         ROUT
1568
1569                 STMFD   R13!,{R12,R14}          ;Stack some registers
1570                 WSPACE  lb__wSpace              ;Locate my workspace
1571
1572                 ; --- Ensure that we are not already initialised ---
1573
1574                 LDR     R14,ws__flags           ;Get the flags word
1575                 TST     R14,#wsFlag__inited     ;Are we initialised?
1576                 BNE     %99lb_init              ;Yes -- return
1577                 ORR     R14,R14,#wsFlag__inited ;We are initialised now
1578                 STR     R14,ws__flags           ;Store back modified flags
1579
1580                 ; --- Return to caller ---
1581
1582 99lb_init       LDMFD   R13!,{R12,PC}^          ;Return to caller
1583
1584                 LTORG
1585
1586 lb__wSpace      DCD     0
1587
1588 ;----- List events ----------------------------------------------------------
1589
1590                 ^       0
1591 lbEvent_close   #       1                       ;Listbox has been closed
1592
1593 lbEvent_redraw  #       1                       ;Redraw a list item
1594                                                 ;R1 == pointer to list item
1595                                                 ;R2-R5 == window coords
1596 lbEvent_click   #       1                       ;Click/Double on listbox
1597                                                 ;R1 == pointer to list item
1598                                                 ;R2 == window relative y pos
1599                                                 ;R3 == button type (10)
1600 lbEvent_menu    #       1                       ;Menu click
1601                                                 ;R1 == pointer to list item
1602                                                 ;R2 == window relative y pos
1603                                                 ;R3 == button type (10)
1604 lbEvent_drag    #       1                       ;Drag on listbox
1605                                                 ;R1 == pointer to list item
1606                                                 ;R2 == window relative y pos
1607                                                 ;R3 == button type (10)
1608 lbEvent_help    #       1                       ;R1 == pointer to list item
1609 lbEvent_drop    #       1                       ;R1 == pointer to list item
1610                                                 ;R2 == filetype
1611                                                 ;R3 == pointer to filename
1612                                                 ;R4 == estimated file size
1613                                                 ;R5 == subreason cde
1614
1615                 ^       0
1616 lbDrop_load     #       1
1617 lbDrop_save     #       1
1618
1619 ;----- Workspace layout -----------------------------------------------------
1620
1621 ; --- listbox block descriptor ---
1622
1623                 ^       0
1624
1625 lb_itemToIndex  #       4                       ;Item to index routine
1626 lb_indexToItem  #       4                       ;Index to item routine
1627 lb_enumerate    #       4                       ;Enumeration function
1628 lb_items        #       4                       ;Function to return items
1629 lb_setFlags     #       4                       ;Function to set/read flags
1630
1631 ; --- listbox individual layout ---
1632
1633                 ^       0
1634
1635 lb__descriptor  #       4                       ;Pointer to descriptor above
1636 lb__list        #       4                       ;The list itself
1637 lb__widthFun    #       4                       ;Function to return width
1638 lb__iHeight     #       4                       ;Height of each item
1639 lb__pWHandle    #       4                       ;Parent window handle
1640 lb__pIHandle    #       4                       ;Parent icon handle
1641 lb__handler     #       4                       ;The handler function
1642 lb__R10         #       4                       ;The R10 value to pass
1643 lb__R12         #       4                       ;The R12 value to pass
1644 lb__width       #       4                       ;Overall box width
1645 lb__height      #       4                       ;Overall box height
1646 lb__flags       #       4                       ;Listbox flags
1647 lb__wHandle     #       4                       ;The listbox window handle
1648 lb__maxWidth    #       4                       ;The maximum item width
1649 lb__size        #       4                       ;Size of this structure
1650
1651 ; --- Main workspace ---
1652
1653                 ^       0,R12
1654
1655 ws__flags       #       4                       ;The flags word
1656 ws__dragItem    #       4                       ;Item from which drag starts
1657 ws__dragLast    #       4                       ;Last drag item visited
1658
1659 ws__size        EQU     {VAR}-ws__flags         ;The size of the workspace
1660
1661 wsFlag__inited  EQU     (1<<0)                  ;We are initialised
1662
1663                 AREA    |Sapphire$$LibData|,CODE,READONLY
1664
1665                 DCD     ws__size
1666                 DCD     lb__wSpace
1667                 DCD     0
1668                 DCD     lb_init
1669
1670 ;----- That's all, folks ----------------------------------------------------
1671
1672                 END