~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Libraries / Sapphire / s / drag
1 ;
2 ; drag.s
3 ;
4 ; Support code for dragging operations (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:idle
38 GET sapphire:intKeys
39 GET sapphire:sapphire
40 GET sapphire:screen
41 GET sapphire:win
42
43 ;----- Main code ------------------------------------------------------------
44
45 AREA |Sapphire$$Code|,CODE,READONLY
46
47 ; --- drag_start ---
48 ;
49 ; On entry: R0 == window containing the drag
50 ; R1 == flags word (see flags below)
51 ; R2 == pointer to drag routine
52 ; R3 == magic number to pass in R9
53 ; R4 == value to pass to routine in R10
54 ; R5 == value to pass to routine in R12
55 ;
56 ; On exit: --
57 ;
58 ; Use: Starts a drag operation. Any outstanding drag operation
59 ; is cancelled on the assumption that someone stole our
60 ; UserDragBox event.
61
62 EXPORT drag_start
63 drag_start ROUT
64
65 STMFD R13!,{R0-R7,R12,R14} ;Save some registers
66 WSPACE drag__wSpace ;Find my workspace address
67
68 ; --- Cancel any current drag operation ---
69
70 LDR R14,drag__window ;Load current window
71 CMP R14,#0 ;Is there one defined?
72 BLNE drag_cancel ;Yes -- cancel it then
73
74 ; --- Ensure that this isn't a silly ---
75 ;
76 ; Rather irritatingly, the WIMP's drag-detection is a little
77 ; suspect; it thinks that moving the pointer outside of
78 ; a window while the button is held down is actually a drag.
79 ; We try to hack around this little problem.
80
81 SWI OS_Mouse ;Read the current mouse pos.
82 CMP R2,#0 ;Are any buttons pressed?
83 LDMEQFD R13!,{R0-R7,R12,PC}^ ;No -- do nothing then
84
85 ; --- Set up handlers for new drag op ---
86
87 MOV R0,#0 ;Call me very often please
88 ADR R1,drag__idles ;Point to the handler
89 MOV R2,#0 ;Nothing to pass in R10
90 MOV R3,R12 ;Pass workspace in R12
91 BL idle_handler ;Install the handler
92 LDMVSFD R13!,{R0-R7,R12,PC}^ ;If it failed, return now
93
94 ; --- Set up all the new information ---
95
96 LDMIA R13,{R0-R3} ;Load information off stack
97 STMIA R12,{R0-R5} ;Save all that lot away
98
99 MOV R0,#&3F ;Reset the dash pattern
100 STRB R0,drag__dash ;This is the current dash
101 STRB R0,drag__oldDash ;And the previous one
102 BL drag_setDash ;Make it the current pattern
103
104 SWI OS_ReadMonotonicTime ;Find the current time
105 STR R0,drag__lastTime ;And store that away too
106
107 ; --- Now read the current position of the drag ---
108
109 SUB R13,R13,#44 ;Make space for window state
110 LDR R14,drag__window ;Load the window handle
111 STR R14,[R13,#0] ;Save it in the block
112 MOV R1,R13 ;Point to this block
113 SWI Wimp_GetWindowState ;Read the window's position
114
115 BL drag__find ;Find the current position
116 ADR R14,drag__startPos ;Point to the current posn
117 STMIA R14!,{R4,R5} ;Load the coordinates out
118 STMIA R14!,{R4,R5} ;Store them in start position
119
120 MOV R0,#drEvent_draw ;Do some drawing please
121 BL drag__draw ;And draw the dash box
122 ADD R13,R13,#44 ;Restore the stack pointer
123 LDMFD R13!,{R0-R7,R12,PC}^ ;Return to caller finally
124
125 LTORG
126
127 ; --- drag_scroll ---
128 ;
129 ; On entry: R1 == pointer to window state block
130 ;
131 ; On exit: R2,R3 == new scroll positions to set
132 ; R14 == R1+20 (pointer to scroll offsets)
133 ;
134 ; Use: Works out the scroll positions which should be set to auto-
135 ; scroll the window. The algorithm is simple: the window is
136 ; scrolled so that the point beneath the mouse pointer is
137 ; within the window's visible work area.
138
139 EXPORT drag_scroll
140 drag_scroll ROUT
141
142 STMFD R13!,{R0,R1,R4-R7,R14} ;Save some registers
143
144 ; --- Find the mouse pointer position ---
145
146 LDMIB R1!,{R4-R7} ;Load the bounding box out
147 LDMIB R1!,{R2,R3} ;And the current scroll pos
148 SUB R13,R13,#20 ;Make a PointerInfo block
149 MOV R1,R13 ;Point at this
150 SWI Wimp_GetPointerInfo ;Read the information
151 LDMIA R13,{R0,R1} ;Load the current position
152
153 ; --- Now fiddle the scroll positions ---
154
155 SUBS R14,R0,R4 ;Compare x to left side
156 ADDLT R2,R2,R14 ;If too far left, then scroll
157 SUBS R14,R1,R5 ;Compare y to bottom
158 ADDLT R3,R3,R14 ;If too low, then scroll
159 SUBS R14,R0,R6 ;Compare x to right side
160 ADDGT R2,R2,R14 ;If too far right, scroll
161 SUBS R14,R1,R7 ;Compare y to top
162 ADDGT R3,R3,R14 ;If too high, then scroll
163
164 ; --- Return everything to caller ---
165
166 ADD R13,R13,#20 ;Restore the stack pointer
167 LDR R14,[R13,#4] ;Load the pointer out
168 ADD R14,R14,#20 ;Point to scroll offsets
169 LDMFD R13!,{R0,R1,R4-R7,PC}^ ;And return to caller
170
171 LTORG
172
173 ; --- drag__dispatch ---
174 ;
175 ; On entry: R0 == event code
176 ; R1-R7 depend on event
177 ;
178 ; On exit: --
179 ;
180 ; Use: Dispatches a drag event to the current handler.
181
182 drag__dispatch ROUT
183
184 STMFD R13!,{R8-R10,R12,R14} ;Save some registers
185 ADR R14,drag__handler ;Point to the handler
186 LDMIA R14,{R8-R10,R12} ;Load the registers out
187 MOV R14,PC ;Set up return address
188 MOV PC,R8 ;Call the routine nicely
189 LDMFD R13!,{R8-R10,R12,PC}^ ;And return to caller
190
191 LTORG
192
193 ; --- drag__draw ---
194 ;
195 ; On entry: R0 == event code to pass
196 ; R1 == pointer to window state block (44 bytes required)
197 ;
198 ; On exit: --
199 ;
200 ; Use: Updates a window using the given event.
201
202 drag__draw ROUT
203
204 STMFD R13!,{R0-R9,R14} ;Save some registers
205 MOV R8,R0 ;Look after the event code
206 LDR R9,[R1,#28] ;Load the `behind' pointer
207
208 ; --- Build the update block ---
209
210 LDMIB R1,{R2-R5,R7,R14} ;Load the values out of it
211
212 SUB R6,R2,R7 ;Find the x origin position
213 SUB R4,R4,R2 ;Find the window width
214 MOV R2,R7 ;Get left side of update box
215 ADD R4,R2,R4 ;Get right side of update box
216
217 SUB R7,R5,R14 ;Find the y origin position
218 SUB R3,R5,R3 ;Find the window height
219 MOV R5,R14 ;Get top of update box
220 SUB R3,R5,R3 ;Get bottom of update box
221
222 STMIB R1,{R2-R5} ;Save the box back
223
224 ; --- Set up other registers for the job ---
225
226 ADR R14,drag__startPos ;Find the start position
227 LDMIA R14,{R2-R5} ;Load the positions out
228
229 ; --- Finally do the actual update ---
230
231 SWI Wimp_UpdateWindow ;Start the update job
232 CMP R0,#0 ;Is there anything to do?
233 BEQ %90drag__draw ;No -- then skip ahead
234
235 00 MOV R0,R8 ;Get caller's event code
236 BL drag__dispatch ;Call the event handler
237 SWI Wimp_GetRectangle ;Get the next rectangle
238 CMP R0,#0 ;Is there anything left?
239 BNE %b00 ;Yes -- loop back to do it
240
241 ; --- Tidy up and return to caller ---
242
243 90drag__draw STR R9,[R1,#28] ;Store `behind' pointer back
244 LDMFD R13!,{R0-R9,PC}^ ;And return to caller
245
246 LTORG
247
248 ; --- drag__find ---
249 ;
250 ; On entry: R1 == pointer to window state block
251 ;
252 ; On exit: R4,R5 == coordinates, suitably transformed
253 ; R6,R7 == window origin coordinates
254 ; CS if mouse button still down, else CC
255 ;
256 ; Use: Locates the mouse pointer within the window.
257
258 drag__find ROUT
259
260 STMFD R13!,{R0-R3,R14} ;Save some registers
261 MOV R2,R1 ;Remember initial pointer
262 SUB R13,R13,#20 ;Make space for pointer info
263 MOV R1,R13 ;Point to this block
264 SWI Wimp_GetPointerInfo ;Find the pointer position
265 MOV R1,R2 ;Point to original block
266
267 ; --- Set up for calling event handler ---
268
269 LDR R2,[R1,#4] ;Load the left hand side
270 ADD R14,R1,#16 ;Find top and scroll position
271 LDMIA R14,{R5-R7} ;Load them out nicely
272 SUB R6,R2,R6 ;Find the x origin position
273 SUB R7,R5,R7 ;And the y origin position
274
275 LDMIA R13,{R4,R5} ;Load the coordinates out
276 SUB R4,R4,R6 ;Translate to window coords
277 SUB R5,R5,R7 ;Do that to y coord too
278 MOV R0,#drEvent_trans ;Get handler to translate
279 BL drag__dispatch ;Go and do that then
280
281 ; --- Tidy up and return ---
282
283 LDR R14,[R13,#8] ;Load the mouse status
284 CMP R14,#0 ;Are all buttons released?
285 ADD R13,R13,#20 ;Restore the stack block
286 LDMFD R13!,{R0-R3,R14} ;Restore registers
287 ORRNES PC,R14,#C_flag ;If button pressed, return CS
288 BICEQS PC,R14,#C_flag ;Else return CC
289
290 LTORG
291
292 ; --- drag__getPosition ---
293 ;
294 ; On entry: R1 == pointer to window state block
295 ; R4,R5 == new position
296 ; R6,R7 == window origin position
297 ;
298 ; On exit: R4,R5 == new position, translated further
299 ;
300 ; Use: Reads the position of the current drag operation. This
301 ; allows the client to do clever things like gridlocking and
302 ; autoscrolling.
303
304 drag__getPosition ROUT
305
306 STMFD R13!,{R0,R2,R3,R14} ;Save some registers
307 ADR R14,drag__startPos ;Find the start position
308 LDMIA R14,{R2,R3} ;Load those coordinates out
309 MOV R0,#drEvent_getPos ;Tell client to translate
310 BL drag__dispatch ;Send the event off
311 LDMFD R13!,{R0,R2,R3,PC}^ ;And return to caller
312
313 LTORG
314
315 ; --- drag_setDash ---
316 ;
317 ; On entry: R0 == dash pattern byte
318 ;
319 ; On exit: --
320 ;
321 ; Use: Sets the dash pattern to be the given value.
322
323 EXPORT drag_setDash
324 drag_setDash ROUT
325
326 STMFD R13!,{R0-R2,R14} ;Save some registers
327
328 ; --- Build VDU block ---
329
330 AND R0,R0,#&FF ;Clear top bits of R0
331 ORR R1,R0,R0,LSL #8 ;Duplicate the byte
332 ORR R1,R1,R1,LSL #16 ;Fill a word with it
333 MOV R0,#23 ;Get the VDU command code
334 ORR R0,R0,#6<<8 ;OR in the command type
335 ORR R0,R0,R1,LSL #16 ;Put in first two patterns
336 MOV R2,R1,LSR #16 ;Put in last two patterns
337 STMIA R11,{R0-R2} ;Save that on the stack
338
339 ; --- Set the dash pattern length ---
340
341 MOV R0,#163 ;Write general graphics info
342 MOV R1,#242 ;Set dash pattern length
343 MOV R2,#8 ;Set the repeat length
344 SWI OS_Byte ;Set the length then
345
346 ; --- Now set the dash pattern itself ---
347
348 MOV R0,R11 ;Point to my VDU block
349 MOV R1,#10 ;Size of block in bytes
350 SWI OS_WriteN ;Write that to the VDU things
351 LDMFD R13!,{R0-R2,PC}^ ;And return to caller
352
353 LTORG
354
355 ; --- drag__idles ---
356 ;
357 ; On entry: --
358 ;
359 ; On exit: --
360 ;
361 ; Use: Handles idle events during a drag operation.
362
363 drag__idles ROUT
364
365 STMFD R13!,{R0-R7,R14} ;Save some registers
366
367 ; --- Check for a cancelled drag ---
368
369 MOV R0,#intk_Esc ;Get the Escape kep code
370 BL akbd_test ;Test the key
371 BCS %70drag__idles ;Cancelled -- abort it then
372
373 ; --- Update the dash pattern ---
374
375 SWI OS_ReadMonotonicTime ;Read the current time
376 LDR R14,drag__lastTime ;Load the old time nicely
377 SUB R0,R0,R14 ;Find the difference
378 MOV R0,R0,LSR #2 ;Divide by 4
379 ADD R14,R14,R0,LSL #2 ;Add on rounded value
380 STR R14,drag__lastTime ;Save that back
381
382 LDRB R14,drag__dash ;Load the dash position
383 STRB R14,drag__oldDash ;This is now the old one
384 MOV R0,R0,LSL #1 ;Multiply difference by 2
385 MOV R0,R14,ROR R0 ;Rotate the dash pattern
386 ORR R0,R0,R0,ROR #24 ;Fake an 8-bit rotate
387 ORR R0,R0,R0,ROR #16 ;Make sure it's done properly
388 STRB R0,drag__dash ;This is the new pattern
389
390 ; --- Read the new position ---
391
392 SUB R13,R13,#44 ;Make a window state block
393 LDR R14,drag__window ;Load the window handle out
394 STR R14,[R13,#0] ;Store handle in there
395 MOV R1,R13 ;Point to the block
396 SWI Wimp_GetWindowState ;Read the window information
397
398 BL drag__find ;Find the new position
399 BL drag__getPosition ;Do any exra processing reqd
400 BCC %50drag__idles ;If done, skip onwards
401
402 ; --- Work out what needs to be done ---
403
404 ADR R14,drag__currPos ;Find the current position
405 LDMIA R14,{R2,R3} ;Load that out
406 CMP R2,R4 ;Has the drag box moved?
407 CMPEQ R3,R5 ;Check both coordinates
408 BEQ %30drag__idles ;No -- handle speciallt
409
410 ; --- Force the update of the drag box ---
411
412 LDRB R0,drag__oldDash ;Get the old dash pattern
413 BL drag_setDash ;Set this as the pattern
414 MOV R0,#drEvent_undraw ;Tell client to undraw
415 BL drag__draw ;Go and do that then
416
417 ; --- Now draw the new one ---
418
419 ADR R14,drag__currPos ;Find the current position
420 STMIA R14,{R4,R5} ;Save new position in there
421 LDRB R0,drag__dash ;Load the new dash pattern
422 BL drag_setDash ;Set this as the pattern
423 MOV R0,#drEvent_draw ;Tell client to draw
424 BL drag__draw ;Go and do that then
425 B %90drag__idles ;Now go and tidy up
426
427 ; --- Update the drag box in place ---
428
429 30drag__idles LDR R14,drag__flags ;Load any interesting flags
430 TST R14,#drFlag_noUpdate ;Do we send update events?
431 BNE %90drag__idles ;No -- then do nothing
432
433 LDR R0,drag__oldDash ;Load the two dash patterns
434 EOR R0,R0,R0,LSR #8 ;Exclusive OR them together
435 BL drag_setDash ;Set this as the pattern
436 MOV R0,#drEvent_update ;Tell client to update drag
437 BL drag__draw ;Go and do that then
438 B %90drag__idles ;Now go and tidy up
439
440 ; --- Tidy up at the end of the drag ---
441
442 50drag__idles LDRB R0,drag__oldDash ;Get the old dash pattern
443 BL drag_setDash ;Set this as the pattern
444 MOV R0,#drEvent_undraw ;Now remove the drag box
445 BL drag__draw ;Go and do that then
446
447 ADR R14,drag__startPos ;Point to start position
448 LDMIA R14,{R2-R5} ;Load all that lot
449 MOV R0,#drEvent_done ;Say it's all over
450 BL drag__dispatch ;Send that to the user
451
452 ; --- Remove this idle handler ---
453
454 MOV R0,#0 ;We're called very often
455 ADR R1,drag__idles ;Point to the handler
456 MOV R2,#0 ;Passed nothing in R10
457 MOV R3,R12 ;Passed workspace in R12
458 BL idle_removeHandler ;Remove the handler
459
460 MOV R14,#0 ;A convenient zero
461 STR R14,drag__window ;Clear the window handle
462
463 B %90drag__idles ;Now go and tidy up
464
465 ; --- Cancel the drag ---
466
467 70drag__idles BL drag_cancel ;Cancel the drag
468 B %95drag__idles ;Now go and tidy up
469
470 ; --- Now tidy up and go home ---
471
472 90drag__idles ADD R13,R13,#44 ;Recover any lost stack space
473 95drag__idles LDMFD R13!,{R0-R7,PC}^ ;And return to caller
474
475 LTORG
476
477 ; --- drag_cancel ---
478 ;
479 ; On entry: --
480 ;
481 ; On exit: --
482 ;
483 ; Use: Cancels the current drag operation.
484
485 EXPORT drag_cancel
486 drag_cancel ROUT
487
488 STMFD R13!,{R0-R3,R12,R14} ;Save some registers
489 WSPACE drag__wSpace ;Find my workspace
490
491 ; --- Make sure this is worth it ---
492
493 LDR R14,drag__window ;Load current drag window
494 CMP R14,#0 ;Is it defined?
495 LDMEQFD R13!,{R0-R3,R12,PC}^ ;No -- then do nothing
496
497 ; --- Undraw the drag box ---
498
499 SUB R13,R13,#44 ;Drop the stack by a bit
500 LDR R14,drag__window ;Load the window handle out
501 STR R14,[R13,#0] ;Store handle in there
502 MOV R1,R13 ;Point to the block
503 SWI Wimp_GetWindowState ;Read the window information
504 LDR R0,drag__dash ;Load the current dash pos
505 BL drag_setDash ;Set the dash pattern
506 MOV R0,#drEvent_undraw ;Undraw the drag box
507 BL drag__draw ;Go and do that then
508 MOV R0,#drEvent_cancel ;Say the drag was cancelled
509 BL drag__dispatch ;Inform the client of this
510
511 ; --- Now tidy up and return ---
512
513 MOV R0,#0 ;We're called very often
514 ADR R1,drag__idles ;Point to the handler
515 MOV R2,#0 ;Passed nothing in R10
516 MOV R3,R12 ;Passed workspace in R12
517 BL idle_removeHandler ;Remove the handler
518
519 MOV R14,#0 ;A convenient zero
520 STR R14,drag__window ;Clear the window handle
521
522 ADD R13,R13,#44 ;Restore the stack pointer
523 LDMFD R13!,{R0-R3,R12,PC}^ ;And return to caller
524
525 LTORG
526
527 ; --- drag_redraw ---
528 ;
529 ; On entry: R1 == pointer to redraw block
530 ;
531 ; On exit: --
532 ;
533 ; Use: Redraws the drag box, if the redraw takes place in the
534 ; currently dragging window.
535
536 EXPORT drag_redraw
537 drag_redraw ROUT
538
539 STMFD R13!,{R0-R7,R12,R14} ;Save some registers
540 WSPACE drag__wSpace ;Find the workspace address
541
542 ; --- Make sure there's something to do ---
543
544 LDR R0,[R1,#0] ;Load the window handle
545 LDR R14,drag__window ;Load current drag window
546 CMP R0,R14 ;Do these match up?
547 LDMNEFD R13!,{R0-R7,R12,PC}^ ;No -- do nothing then
548
549 ; --- Set up registers ---
550
551 LDR R2,[R1,#4] ;Load left hand side
552 ADD R14,R1,#16 ;Find top and scroll
553 LDMIA R14,{R5-R7} ;Load that lot out
554 SUB R6,R2,R6 ;Find the x origin pos
555 SUB R7,R5,R7 ;And the y origin pos
556 ADR R14,drag__startPos ;Find the start position
557 LDMIA R14,{R2-R5} ;Load position out nicely
558
559 ; --- Now do the drawing ---
560
561 LDRB R0,drag__dash ;Load current dash pattern
562 BL drag_setDash ;Set the dash pattern
563 MOV R0,#drEvent_draw ;Now do some drawing
564 BL drag__dispatch ;Send to event handler
565 LDMFD R13!,{R0-R7,R12,PC}^ ;Now return to caller
566
567 LTORG
568
569 ; --- drag_eorColour ---
570 ;
571 ; On entry: R0 == colour A
572 ; R1 == colour B
573 ;
574 ; On exit: --
575 ;
576 ; Use: Sets the foreground colour to be an EOR colour such that
577 ; when painted over Wimp colour A, it appears as Wimp colour B.
578
579 EXPORT drag_eorColour
580 drag_eorColour ROUT
581
582 STMFD R13!,{R0-R3,R14} ;Save some registers
583 MOV R2,R0,LSL #2 ;Keep the background colour
584 MOV R3,R1,LSL #2 ;And the foreground colour
585 MOV R1,R11 ;Point to the block
586 SWI Wimp_ReadPalette ;Read the current palette
587 LDR R0,[R11,R2] ;Load the fore palette entry
588 SWI ColourTrans_ReturnColourNumber
589 MOV R2,R0 ;Save the colour number
590 LDR R0,[R11,R3] ;Load the back palette entry
591 SWI ColourTrans_ReturnColourNumber
592 EOR R1,R0,R2 ;Get the EOR colour number
593 MOV R0,#3 ;Set EOR colour please
594 SWI XOS_SetColour ;Set the colour, please
595 BVC %90drag_eorColour ;If it worked, return
596
597 ; --- We must be running RISC OS 2 ---
598 ;
599 ; This is very tedious -- we have to set the colour by hand.
600
601 BL screen_getInfo ;Read the screen cache
602 LDR R0,[R0,#screen_bpp] ;Load the current BPP
603 CMP R0,#8 ;Are we in a 256 colour mode?
604 BEQ %50drag_eorColour ;Yes -- handle it specially
605
606 ; --- Just set the GCOL from R1 ---
607
608 SWI OS_WriteI+18 ;Set graphics colour
609 SWI OS_WriteI+3 ;Use XOR colour
610 MOV R0,R1 ;Get the colour to set
611 SWI OS_WriteC ;Set the colour
612 B %90drag_eorColour ;Return -- we did it
613
614 ; --- Set the colour in a 256 colour mode ---
615
616 50 MOV R0,R1 ;Get colour in R0
617 SWI ColourTrans_ColourNumberToGCOL
618 MOV R1,R0 ;Keep the GCOL safe
619 SWI OS_WriteI+18 ;Set graphics colour
620 SWI OS_WriteI+3 ;Use XOR colour
621 MOV R0,R1,LSR #2 ;Get the GCOL part of it
622 SWI OS_WriteC ;Set the colour
623
624 ; --- Now set the tint ---
625
626 MOV R0,#23 ;VDU code for tint setting
627 ORR R0,R0,#17<<8 ;Subreason code for tint
628 ORR R0,R0,#2<<16 ;Set the graphics foreground
629 ORR R0,R0,R1,LSL #30 ;Get the tint bits in too
630 MOV R1,#0 ;Other bytes are all 0
631 MOV R2,#0 ;Two words of them
632 STMIA R11,{R0-R2} ;Save them in scratchpad
633 MOV R0,R11 ;Point at them
634 MOV R1,#10 ;VDU 23 is 10 bytes long
635 SWI OS_WriteN ;Write the whole lot out
636
637 90 LDMFD R13!,{R0-R3,PC}^
638
639 LTORG
640
641 drag__wSpace DCD 0
642
643 ;----- Flags ----------------------------------------------------------------
644
645 drFlag_noUpdate EQU (1<<0) ;Don't generate update events
646
647 ;----- Drag handler events --------------------------------------------------
648
649 ; --- Note ---
650 ;
651 ; The events which request that you draw something are called for each
652 ; rectangle of the draw operation -- i.e. do not call Wimp_GetRectangle
653 ; because this is done for you.
654
655 ^ 0
656 drEvent_draw # 1 ;Draw dragged object
657 ;R1 == pointer to redraw blk
658 ;R2,R3 == drag start posn
659 ;R4,R5 == drag current posn
660 ;R6,R7 == window origin
661 ;Dash pattern set up
662
663 drEvent_undraw # 1 ;Undraw dragged object
664 ;Regs as for drEvent_draw
665 ;Normally use the same code
666
667 drEvent_update # 1 ;Redraw dragged object in
668 ;place
669 ;Regs as for drEvent_draw
670 ;Dash pattern set up so that
671 ;single plot will rotate box,
672 ;so may share code with
673 ;drEvent_draw
674
675 drEvent_trans # 1 ;Translate coordinates
676 ;R1 == ptr to window state
677 ;R4,R5 == pointer position
678 ;R6,R7 == window origin
679 ;Translate pointer position
680 ;to internal coordinates if
681 ;this is useful to you.
682 ;Return new coords in R4,R5
683
684 drEvent_getPos # 1 ;Read pointer position
685 ;R1 == ptr to window state
686 ;R2,R3 == start position
687 ;R4,R5 == pointer position
688 ;R6,R7 == window origin
689 ;Used to read pointer posn.
690 ;Do any grid snapping here
691 ;and return with R4,R5 as
692 ;coords to use.
693
694 drEvent_done # 1 ;Drag operation completed
695 ;R1 == ptr to window state
696 ;R2,R3 == drag start posn
697 ;R4,R5 == drag current posn
698
699 drEvent_cancel # 1 ;Drag operation aborted
700 ;No other registers set up
701
702 ;----- Workspace ------------------------------------------------------------
703
704 ^ 0,R12
705 drag__wStart # 0
706
707 drag__window # 4 ;Window handle of drag
708 drag__flags # 4 ;Various interesting flags
709 drag__handler # 16 ;All the handler information
710 drag__oldDash # 1 ;The old dash pattern
711 drag__dash # 1 ;The current dash pattern
712 # 2 ;Align to word boundary
713 drag__lastTime # 4 ;Last time we changed pattern
714 drag__startPos # 8 ;Find the start position
715 drag__currPos # 8 ;Find the end position
716
717 drag__wSize EQU {VAR}-drag__wStart
718
719 AREA |Sapphire$$LibData|,CODE,READONLY
720
721 DCD drag__wSize
722 DCD drag__wSpace
723 DCD 0
724 DCD 0
725
726 ;----- That's all, folks ----------------------------------------------------
727
728 END
The Straylight Source Distribution (obsolete software for RISC OS)