~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Libraries / Sapphire / s / template
1 ;
2 ; template.s
3 ;
4 ; Load window template resources (MDW)
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:except
37 GET sapphire:mem
38 GET sapphire:msgs
39 GET sapphire:res
40 GET sapphire:resources
41 GET sapphire:resspr
42 GET sapphire:sapphire
43 GET sapphire:string
44
45 ;----- Main code ------------------------------------------------------------
46
47 AREA |Sapphire$$Code|,CODE,READONLY
48
49 ; --- tpl__find ---
50 ;
51 ; On entry: R0 == pointer to name to find
52 ;
53 ; On exit: CS if template found in list, and
54 ; R0 == pointer to template block (internal format)
55 ; else CC if in shared resource
56 ; R0 == pointer to embedded template definition
57 ; May return an error
58 ;
59 ; Use: Finds a named template in the list.
60
61 tpl__find ROUT
62
63 ORRS R14,R14,#C_flag ;Set C initially
64 STMFD R13!,{R1,R2,R12,R14} ;Stack some registers
65 WSPACE template_wspace ;Find my workspace
66 LDR R2,template_list ;Find the list head
67
68 ; --- Go through the list trying to find one ---
69
70 00 CMP R2,#0 ;Is this the list end?
71 BEQ %10tpl__find ;Yes -- return the error
72 ADD R1,R2,#tlist_name ;Find this template's name
73 BL str_icmp ;Compare the names
74 LDRNE R2,[R2,#tlist_next] ;If no match, get next one...
75 BNE %b00 ;And go round again
76
77 ; --- We found a match!!! ---
78
79 MOV R0,R2 ;Point to the template
80 LDMFD R13!,{R1,R2,R12,R14} ;Unstack some registers
81 BICS PC,R14,#V_flag ;Return with no error
82
83 ; --- No match -- try shared resource ---
84
85 10tpl__find MOV R1,R0 ;Point to the template name
86 MOV R0,#rsType_template ;Search for template resource
87 BL resources_find ;Try to find the resource
88 LDMCSFD R13!,{R1,R2,R12,R14} ;If it worked, get registers
89 BICCSS PC,R14,#C_flag + V_flag ;And return with no error
90
91 ; --- Couldn't find it then ---
92
93 20tpl__find MOV R2,R1 ;Point to the template name
94 ADR R0,tpl__notfound ;Point to error message
95 BL msgs_error ;Translate the message
96 LDMFD R13!,{R1,R2,R12,R14} ;Unstack some registers
97 ORRS PC,R14,#V_flag ;Return with the error
98
99 tpl__notfound DCD 1
100 DCB "tplTNF",0
101
102 LTORG
103
104 ; --- template_find ---
105 ;
106 ; On entry: R0 == pointer to name to match
107 ;
108 ; On exit: R0 == pointer to window definition if found
109 ; May return an error
110 ;
111 ; Use: Locates a template in the list and gives you a pointer to
112 ; the corresponding window defintion. You may update the
113 ; definition to store an updated window state if you really
114 ; want to.
115 ;
116 ; Note that this call will fail if you attempt to find a
117 ; template which is held in the shared resources DLL.
118
119 EXPORT template_find
120 template_find ROUT
121
122 STMFD R13!,{R1,R2,R14} ;Save return address
123 MOV R2,R0 ;Remember the name
124 BL tpl__find ;Find the definition
125 BVS %10template_find ;If failed, skip onwards
126 BCC %05template_find ;If in resource DLL, skip
127 ADD R0,R0,#tlist_size ;Point to window def
128 LDMFD R13!,{R1,R2,R14} ;Return to caller
129 BICS PC,R14,#V_flag
130
131 ; --- It's in the resources DLL ---
132
133 05template_find ADR R0,tpl__notfound ;Point to error message
134 BL msgs_error ;Translate the message
135
136 ; --- Couldn't find the template ---
137
138 10template_find LDMFD R13!,{R1,R2,R14} ;Restore registers
139 ORRS PC,R14,#V_flag ;And return the error
140
141 LTORG
142
143 ; --- template_copy ---
144 ;
145 ; On entry: R0 == pointer to name to match
146 ;
147 ; On exit: R0 == pointer to copy of a window definition
148 ; May return an error
149 ;
150 ; Use: Returns a copy of a window template (for the use of the
151 ; dialogue box system mainly), including all indirected data
152 ; set up properly and everything. The copy is writable. To
153 ; get rid of the copy, call template_free.
154
155 EXPORT template_copy
156 template_copy ROUT
157
158 ; --- Find the copy first ---
159
160 STMFD R13!,{R1-R5,R14} ;Save some registers
161 BL tpl__find ;Find the definition
162 BVS %99template_copy ;If it failed, tidy up
163 BCC %50template_copy ;In resources -- handle it
164 MOV R5,R0 ;Keep pointer to definition
165
166 ; --- Now allocate the memory we need ---
167
168 LDR R0,[R5,#84+tlist_size] ;Get the number of icons
169 MOV R0,R0,LSL #5 ;Multiply by 32 for size
170 ADD R0,R0,#88+tlist_size ;Bump up by overhead
171 MOV R2,R0 ;Keep the size safe
172 BL alloc ;Allocate the memory
173 BCS %98template_copy ;If that failed, skip ahead
174 MOV R4,R0 ;Keep that pointer safe
175
176 ; --- Copy the window defintion over ---
177
178 MOV R1,R5 ;Point to the definition
179 MOV R0,R4 ;And my new block
180 BL fastMove ;Copy that data across
181
182 ; --- Now see if we need do anything else
183
184 LDR R0,[R5,#tlist_indsize] ;Get indirected data size
185 CMP R0,#0 ;Is there any?
186 BEQ %10template_copy ;If not, skip past this bit
187
188 ; --- Allocate the indirected space ---
189
190 MOV R2,R0 ;Look after the size
191 BL alloc ;Allocate the new block
192 BCS %97template_copy ;And tidy up if it failed
193
194 ; --- Copy indirected data over ---
195
196 LDR R1,[R5,#tlist_indptr] ;Find the old indirect block
197 BL fastMove ;Copy it over very quickly
198 STR R0,[R4,#tlist_indptr] ;Store the new block pointer
199
200 ; --- Now fix up all the references ---
201
202 SUB R5,R0,R1 ;Get the relocation offset
203 LDR R0,[R4,#56+tlist_size] ;Get the title bar flags
204 ADD R1,R4,#72+tlist_size ;Point to the title data
205 BL tpl__fixData ;Fix up that data
206
207 LDR R3,[R4,#84+tlist_size] ;Get the number of icons
208 ADD R2,R4,#88+tlist_size ;Point to the first icon
209 00template_copy SUBS R3,R3,#1 ;Decrement the icon counter
210 LDRGE R0,[R2,#16] ;Get the icon flags word
211 ADDGE R1,R2,#20 ;Point to the icon data
212 BLGE tpl__fixData ;And fix up the icon data
213 ADDGE R2,R2,#32 ;Move onto the next icon
214 BGE %00template_copy ;And move onto the next one
215
216 ; --- All done -- return the pointer ---
217
218 10template_copy ADD R0,R4,#tlist_size ;Point to the actual defn
219 LDMFD R13!,{R1-R5,R14} ;Unstack a load of registers
220 BICS PC,R14,#V_flag ;Return to caller
221
222 ; --- It's in the resources DLL ---
223
224 50template_copy LDMFD R13!,{R1-R5,R14} ;Restore these registers
225 B template_embedded ;Extract embedded definition
226
227 ; --- Error -- free the template block ---
228
229 97template_copy MOV R0,R4 ;Point to the template block
230 BL free ;Free up the block
231
232 ; --- Return the error ---
233
234 98template_copy BL alloc_error ;Find the correct error mesg
235
236 99template_copy LDMFD R13!,{R1-R5,R14} ;Restore the registers
237 ORRS PC,R14,#V_flag ;Return to caller
238
239 LTORG
240
241 ; --- tpl__fixData ---
242 ;
243 ; On entry: R0 == icon flags
244 ; R1 == pointer to icon data to fix
245 ; R5 == offset to bodge data by
246 ;
247 ; On exit: Registers preserved
248 ;
249 ; Use: Relocates indirected data by a given amount
250
251 tpl__fixData ROUT
252
253 TST R0,#&00000100 ;Is it indirected?
254 MOVEQS PC,R14 ;No -- return right now
255
256 ; --- Fix up icon data ---
257
258 STMFD R13!,{R14} ;Save the link register
259 LDR R14,[R1,#0] ;Get the data pointer
260 ADD R14,R14,R5 ;Relocate it
261 STR R14,[R1,#0] ;And store it back again
262
263 ; --- Is there validation data too? ---
264
265 TST R0,#&00000001 ;Does it contain text data?
266 LDRNE R14,[R1,#4] ;Yes -- get validation ptr
267 CMPNE R14,#-1 ;If the pointer sensible?
268 LDMEQFD R13!,{PC}^ ;No -- return
269
270 ; --- Relocate validation string pointer ---
271
272 ADD R14,R14,R5 ;Relocate it
273 STR R14,[R1,#4] ;Store it back in the block
274 LDMFD R13!,{PC}^ ;Return to caller
275
276 LTORG
277
278 ; --- template_embedded ---
279 ;
280 ; On entry: R0 == pointer to embedded template definition
281 ;
282 ; On exit: R0 == pointer to copy (as for template_copy)
283 ;
284 ; Use: Extracts an embedded template into a template block.
285 ; Embedded templates can be generated using the templAOF
286 ; program, and then linked into your application.
287
288 EXPORT template_embedded
289 template_embedded ROUT
290
291 STMFD R13!,{R1-R7,R14} ;Save some registers
292
293 ; --- First load the header out ---
294
295 LDMIA R0,{R3-R5} ;Load the three pointers out
296 ADD R3,R3,R0 ;Relocate the window pointer
297 ADD R4,R4,R0 ;Relocate the ind base ptr
298 ADD R5,R5,R0 ;Relocate the ind limit ptr
299 ADD R6,R0,#12 ;And find the relocation tbl
300
301 ; --- Allocate a block for the window definition ---
302
303 LDR R14,[R3,#84] ;Load the number of icons
304 MOV R0,#88+tlist_size ;Get the base memory req
305 ADD R0,R0,R14,LSL #5 ;Add space for the icons
306 SUB R2,R0,#tlist_size ;Keep size without extras
307 BL alloc ;Try to allocate the space
308 BLCS alloc_error ;If it failed, get error
309 BCS %99template_embedded ;And skip onwards
310 MOV R7,R0 ;Look after this pointer
311
312 ; --- Copy the window data over ---
313
314 ADD R0,R7,#tlist_size ;Point to window def area
315 MOV R1,R3 ;Point to the original def
316 BL fastMove ;Copy that over
317
318 ; --- Now handle the data ---
319
320 SUBS R0,R5,R4 ;Find indirected data size
321 STR R0,[R7,#tlist_indsize] ;Store the size away
322 STREQ R0,[R7,#tlist_indptr] ;If none, store null ptr
323 BEQ %10template_embedded ;And skip on to relocate
324
325 BL alloc ;Allocate the space
326 BLCS alloc_error ;If it failed, get error
327 BCS %98template_embedded ;And skip onwards
328 STR R0,[R7,#tlist_indptr] ;Store the pointer
329
330 ; --- Copy the data over ---
331
332 MOV R1,R4 ;Point to original data
333 SUB R2,R5,R4 ;Find the data size
334 BL fastMove ;Copy it over nicely
335
336 ; --- Finally do the relocation ---
337
338 10 MOV R5,R0 ;Look after indirected addr
339 BL resspr_area ;Find the sprite area
340 MOV R4,R0 ;Look after that too
341 ADD R0,R7,#tlist_size ;Find window definition
342
343 00 CMP R6,R3 ;Finished yet?
344 BCS %90template_embedded ;Yes -- wrap things up
345 LDR R14,[R6],#4 ;Load next directive
346 MOV R2,R14,LSR #28 ;Get the directive type
347 BIC R14,R14,#&F0000000 ;And the offset
348 ADD PC,PC,R2,LSL #2 ;Dispatch to handler
349 DCB "MDW!"
350 B %15template_embedded
351 B %20template_embedded
352 B %b00
353
354 15 LDR R2,[R0,R14] ;Load the word
355 ADD R2,R2,R5 ;Relocate for indirectedness
356 STR R2,[R0,R14] ;Store it back again
357 B %b00 ;Loop
358
359 20 STR R4,[R0,R14] ;Store the sprite area
360 B %b00 ;Loop
361
362 ; --- Finished -- return ---
363
364 90 LDMFD R13!,{R1-R7,R14} ;Load lots of registers
365 BICS PC,R14,#V_flag ;And return errorless
366
367 ; --- Errors -- tidy up ---
368
369 98 MOV R6,R0 ;Look after error pointer
370 MOV R0,R7 ;Get the template block
371 BL free ;Free it
372 MOV R0,R6 ;Restore error pointer
373
374 99 LDMFD R13!,{R1-R7,R14} ;Load lots of registers
375 ORRS PC,R14,#V_flag ;And return the error
376
377 LTORG
378
379 ; --- template_free ---
380 ;
381 ; On entry: R0 == pointer to block allocated with template_copy
382 ;
383 ; On exit: --
384 ;
385 ; Use: Frees a template copy created using template_copy.
386
387 EXPORT template_free
388 template_free ROUT
389
390 STMFD R13!,{R0,R1,R14} ;Save some registers
391 SUB R1,R0,#tlist_size ;Find base of block
392 LDR R0,[R1,#tlist_indptr] ;Get indirect data pointer
393 CMP R0,#0 ;Is there any indirect data?
394 BLNE free ;Yes -- free the memory
395 MOV R0,R1 ;Get the block pointer
396 BL free ;Free that too
397 LDMFD R13!,{R0,R1,PC}^ ;Return to caller
398
399 LTORG
400
401 ; --- template_load ---
402 ;
403 ; On entry: R0 == pointer to name of template file to load
404 ;
405 ; On exit: May return an error
406 ;
407 ; Use: Loads the specified template file, and adds its window
408 ; definitions into the template list so they can be used when
409 ; creating dialogue boxes or windows.
410 ;
411 ; If the templates can't be loaded (e.g. there isn't enough
412 ; memory) an error is generated (and can be caught using the
413 ; standard Sapphire except mechanism).
414
415 EXPORT template_load
416 template_load ROUT
417
418 ; --- We need a lot of registers! ---
419
420 STMFD R13!,{R0-R12,R14} ;Save the registers we want
421 WSPACE template_wspace ;Find my workspace
422
423 ; --- Find out how big the file is ---
424
425 MOV R1,R0 ;Point to the filename
426 MOV R0,#17 ;Info about file please
427 SWI XOS_File ;Try to load the file
428 BVS %99template_load ;If no luck, make the error
429
430 ; --- Allocate a heap block for it ---
431
432 MOV R0,R4 ;Get the template file size
433 BL alloc ;Allocate the block
434 BLCS alloc_error ;If it failed, get error
435 BCS %99template_load ;If no luck, make the error
436 MOV R8,R0 ;Guard pointer with life :-)
437
438 ; --- Load template file into buffer ---
439
440 MOV R0,#16 ;Load a file into memory
441 LDR R1,[R13,#0] ;Get the filename back
442 MOV R2,R8 ;Point to my buffer
443 MOV R3,#0 ;Load into my buffer
444 SWI XOS_File ;Load the file now
445 BVS %98template_load ;Bad news -- free block first
446
447 ; --- Now we can parse the file up ---
448
449 ADD R10,R8,#16 ;Find the first index entry
450 00template_load LDR R0,[R10,#0] ;Is this an empty entry?
451 CMP R0,#0 ;Just check quickly
452 BEQ %05template_load ;Yes -- we've finished
453
454 ADD R9,R8,R0 ;Point to the actual entry
455
456 LDR R1,[R10,#8] ;Get the entry type number
457 SUB R1,R1,#1 ;Convert it to zero-indexed
458 CMP R1,#(%11-%10)/4 ;Make sure it's recognised
459 BCS %02template_load ;No -- don't to it then
460 STMFD R13!,{R8,R12} ;Save workspace and base
461 MOV R12,R13 ;Point to this pair
462 MOV R14,PC ;Set up return address
463 ADD PC,PC,R1,LSL #2 ;Branch table dispatch
464 B %01template_load ;And link in the block
465
466 10template_load B tpl__loadWind ;Load a window definition
467 11template_load
468
469 01template_load LDMFD R13!,{R8,R12} ;Find workspace too
470 BVS %98template_load ;It failed miserably
471
472 ; --- Link the returned block into the list ---
473
474 LDR R1,template_list ;Find the list head
475 STR R1,[R0,#tlist_next] ;Make it this one's next ptr
476 STR R0,template_list ;And make this the list head
477
478 ; --- Move on to the next entry ---
479
480 02template_load ADD R10,R10,#24 ;Move to the next entry
481 B %00template_load ;And go back again
482
483 ; --- We finished loading the file -- free buffer ---
484
485 05template_load MOV R0,R8 ;Point to the file buffer
486 BL free ;Free the memory now
487
488 ; --- Now we can leave ---
489
490 LDMFD R13!,{R0-R12,R14} ;Return to caller
491 BICS PC,R14,#V_flag
492
493 ; --- Error encountered after block allocation ---
494
495 98template_load MOV R9,R0 ;Keep error pointer
496 MOV R0,R8 ;Point to the file buffer
497 BL free ;Free the memory now
498 MOV R0,R9 ;Restore error pointer
499
500 ; --- Error encountered before block allocation ---
501
502 99template_load ADD R2,R0,#4 ;Point to error message
503 ADR R0,tload__error ;Point to error skeleton
504 BL msgs_error ;Create the error message
505 ADD R13,R13,#4 ;Skip past stacked R0
506 LDMFD R13!,{R1-R12,R14} ;Return to caller
507 ORRS PC,R14,#V_flag ;With error indicator set
508
509 tload__error DCD 1
510 DCB "tplTLE",0
511
512 LTORG
513
514 template_wspace DCD 0
515
516 ; --- template_init ---
517 ;
518 ; On entry: R0 == pointer to application name
519 ;
520 ; On exit: --
521 ;
522 ; Use: Initialises the template list and font array, and loads the
523 ; `Templates' resource file.
524
525 EXPORT template_init
526 template_init ROUT
527
528 STMFD R13!,{R0,R1,R12,R14} ;Store some registers
529 WSPACE template_wspace ;Find my workspace
530 LDR R14,template_list ;Get the current list
531 CMP R14,#0 ;Is it silly?
532 LDMNEFD R13!,{R0,R1,R12,PC}^ ;No -- we're already running
533
534 BL alloc_init ;Make sure we can find memory
535 BL resspr_init ;This will initialise res too
536 BL except_init ;For atexit to tidy up later
537
538 ; --- Set up the workspace nicely ---
539
540 MOV R0,#0 ;Store null pointers
541 STR R0,template_list ;No templates yet
542 STR R0,template_fonts ;No fonts found either
543
544 ; --- Build the name in the scratchpad ---
545
546 ADR R0,tpl__templates ;Point to the resource name
547 MOV R1,R11 ;Point to scratchpad buffer
548 ADDS R0,R0,#0 ;Clear C and V flags
549 BL res_find ;Find the resource file
550
551 ; --- Load the file and return ---
552
553 BLCS template_load ;Load the file if it's there
554 SWIVS OS_GenerateError ;If it failed, make an error
555 LDMFD R13!,{R0,R1,R12,PC}^ ;Return to the caller
556
557 tpl__templates DCB "Templates",0
558
559 LTORG
560
561 ; --- tpl__killFont ---
562 ;
563 ; On entry: R12 == pointer to template workspace
564 ;
565 ; On exit: --
566 ;
567 ; Use: Loses loads of fonts when the application quits
568
569 tpl__killFont ROUT
570
571 STMFD R13!,{R0-R2,R14} ;Save some registers
572 LDR R1,template_fonts ;Find the font array
573 MOV R0,#255 ;Start at the top for this
574 00tpl__killFont LDRB R2,[R1,R0] ;Get the reference counter
575 01tpl__killFont SUBS R2,R2,#1 ;Decrement the counter
576 SWIGE Font_LoseFont ;Lose the font
577 BGE %01tpl__killFont ;And go round again
578 SUBS R0,R0,#1 ;Decrement the handle
579 BGE %00tpl__killFont ;And go round again
580 LDMFD R13!,{R0-R2,PC}^ ;And return to caller
581
582 LTORG
583
584 ;----- Template loading routines --------------------------------------------
585 ;
586 ; For all routines:
587 ;
588 ; On entry: R9 == pointer to entry in memory
589 ; R10 == pointer to index entry for this object
590 ; R12 == pointer to template base and workspace block
591 ;
592 ; On exit: If successful:
593 ; R0 == pointer to template entry to add into the list
594 ; V flag clear
595 ; If an error occurred:
596 ; R0 == pointer to standard error block
597 ; V flag set
598 ; R1-R9 may be corrupted
599
600 ; --- tpl__loadWind ---
601 ;
602 ; Use: Loads a window definition and converts it into a template
603 ; list item
604
605 tpl__loadWind ROUT
606
607 STMFD R13!,{R14} ;Just stack the return addr
608
609 ; --- Find out how many icons there are ---
610
611 ADD R0,R9,#84 ;Point to the right place
612 AND R1,R0,#3 ;Get the non-word-alignedness
613 BIC R0,R0,#3 ;And round down to word
614 LDMIA R0,{R2,R3} ;Get the two words we want
615 MOV R1,R1,LSL #3 ;Turn bytes into bits
616 MOV R8,R2,LSR R1 ;Get the bottom few bytes
617 RSB R1,R1,#32 ;Get the shift the other way
618 ORR R8,R8,R3,LSL R1 ;And copy in the top bytes
619
620 ; --- R8 now contains the number of icons ---
621
622 ; --- Allocate a template block ---
623
624 MOV R3,R8,LSL #5 ;Multiply the number by 32
625 ADD R3,R3,#88+tlist_size ;Add on window and list block
626 MOV R0,R3 ;I want to allocate memory
627 BL alloc ;Allocate the space
628 BLCS alloc_error ;If it failed, get error
629 BCS %99tpl__loadWind ;If it failed, return error
630 MOV R7,R0 ;Keep the pointer
631
632 ; --- Copy the window definition into the block ---
633
634 ADD R0,R7,#tlist_size ;Where to store definition
635 SUB R2,R3,#tlist_size ;Size of block to copy
636 MOV R1,R9 ;Point to the window def
637 BL fastMove ;And shunt the bytes over
638
639 ; --- We may as well copy the name over now too ---
640
641 ADD R1,R10,#12 ;Point to the template name
642 ADD R0,R7,#tlist_name ;Point to my block section
643 LDMIA R1,{R2-R4} ;Get the twelve bytes
644 STMIA R0,{R2-R4} ;Store them in my block
645 MOV R1,#0 ;And zero terminate
646 STRB R1,[R0,#12] ;Stop the string off nicely
647
648 ; --- Widge the sprite area ---
649
650 BL resspr_area ;Load the sprite area ptr
651 STR R0,[R7,#64+tlist_size] ;Store sprite area pointer
652
653 ; --- Now count the amount of indirected data ---
654
655 MOV R6,#0 ;Currently no indirected size
656
657 LDR R5,[R7,#56+tlist_size] ;Get the title bar flags
658 ADD R4,R7,#72+tlist_size ;Point to the title bar data
659 BL tpl__dataSize ;Add in the space required
660
661 MOV R0,R8 ;The number of icons I have
662 ADD R1,R7,#88+tlist_size ;Point to the first icon
663 00tpl__loadWind SUBS R0,R0,#1 ;Decrement the counter
664 LDRGE R5,[R1,#16] ;Get the flags word here
665 ADDGE R4,R1,#20 ;Point to the icon data
666 BLGE tpl__dataSize ;Add in the extra data
667 ADDGE R1,R1,#32 ;Point to the next icon defn
668 BGE %00tpl__loadWind ;And go back for the rest
669
670 ; --- We now have the data size in R6 ---
671
672 STR R6,[R7,#tlist_indsize] ;Store the buffer size away
673 CMP R6,#0 ;Is there any indirect space?
674 STREQ R6,[R7,#tlist_indptr] ;No -- store a null pointer
675 BEQ %01tpl__loadWind ;... and skip past allocation
676
677 ; --- Allocate the buffer properly ---
678
679 MOV R0,R6 ;Get the size of the block
680 BL alloc ;Allocate yet more memory
681 BLCS alloc_error ;If failed, get error
682 BCS %98tpl__loadWind ;If it failed, report error
683 MOV R6,R0 ;Point to the new buffer
684 STR R6,[R7,#tlist_indptr] ;Save indirected size away
685
686 ; --- Now copy the indirected data across ---
687 ;
688 ; We also fix up the pointers at the same time, and set up
689 ; any fonts that need loading.
690
691 01tpl__loadWind LDR R5,[R7,#56+tlist_size] ;Get the title bar flags
692 ADD R4,R7,#72+tlist_size ;Point to the title bar data
693 BL tpl__copyData ;Process the indirect data
694 ADD R5,R7,#56+tlist_size ;Point to the flags now
695 BL tpl__findFont ;And handle any fonts
696 BVS %97tpl__loadWind ;Quit if something went wrong
697
698 MOV R0,R8 ;The number of icons I have
699 ADD R1,R7,#88+tlist_size ;Point to the first icon
700 02tpl__loadWind SUBS R0,R0,#1 ;Decrement the counter
701 BLT %03tpl__loadWind ;If no more, skip ahead
702 LDR R5,[R1,#16] ;Get the flags word here
703 ADD R4,R1,#20 ;Point to the icon data
704 BL tpl__copyData ;Copy over the indirect data
705 ADD R5,R1,#16 ;Point to the flags now
706 BL tpl__findFont ;And handle any fonts
707 BVS %97tpl__loadWind ;Quit if something went wrong
708 ADD R1,R1,#32 ;Point to the next icon defn
709 B %02tpl__loadWind ;Now go back for the rest
710
711 ; --- The excitement's over now, so that's it ---
712
713 03tpl__loadWind MOV R0,R7 ;Point at the template block
714 LDMFD R13!,{R14} ;Get the link register out
715 BICS PC,R14,#V_flag ;And return no errors
716
717 ; --- Something screwed up -- deallocate both blocks ---
718
719 97tpl__loadWind MOV R9,R0 ;Save error pointer
720 LDR R0,[R7,#tlist_indptr] ;Find the indirect block addr
721 BL free ;Free indirect data block
722 MOV R0,R9 ;Restore error pointer
723
724 ; --- Error occurred -- free the template block ---
725
726 98tpl__loadWind MOV R9,R0 ;Save error pointer
727 MOV R0,R7 ;Point to template block
728 BL free ;Free the template block
729 MOV R0,R9 ;Restore error pointer
730
731 ; --- Error occurred -- return with V set ---
732
733 99tpl__loadWind LDMFD R13!,{R14} ;Get the link register
734 ORRS PC,R14,#V_flag ;Set the error indicator
735
736 LTORG
737
738 ;----- Support functions ----------------------------------------------------
739
740 ; --- tpl__dataSize ---
741 ;
742 ; On entry: R4 == pointer to icon data
743 ; R5 == icon flags word
744 ; R6 == counter to increment
745 ; R7 == pointer to window block
746 ; R8 == number of icons in the window
747 ; R9 == pointer to the window definition in the template file
748 ; R10 == pointer to index for current window
749 ; R12 == pointer to template base and workspace block
750 ;
751 ; On exit: R6 incremented by an appropriate amount
752 ; Everything else preserved (except R14, obviously!)
753 ;
754 ; Use: Counts the amount of indirected space required for a given
755 ; icon flags/data pair and adds it into a running total
756
757 tpl__dataSize ROUT
758
759 ; --- Make sure there's something to do ---
760
761 TST R5,#&00000100 ;Test indirected bit
762 MOVEQS PC,R14 ;If not indirected, go away
763
764 ; --- Locate and count the indirected data string ---
765
766 STMFD R13!,{R14} ;Save some registers
767 LDR R14,[R4,#8] ;Get the indirect buffer size
768 ADD R6,R6,R14 ;And add this onto the count
769
770 ; --- Check if there's a validation string ---
771
772 TST R5,#&00000001 ;Is the `Is text' bit on?
773 LDRNE R14,[R4,#4] ;Yes -- get validation ptr
774 CMPNE R14,#-1 ;Is it a sensible pointer?
775 LDMEQFD R13!,{PC}^ ;If not, we're done for now
776
777 ; --- Count length of validation string ---
778
779 STMFD R13!,{R0} ;Save another register
780 ADD R0,R14,R9 ;Point to string in memory
781 BL str_len ;Find its length
782 ADD R0,R0,#1 ;Account for the terminator
783 ADD R6,R6,R0 ;Add this to the counter
784 LDMFD R13!,{R0,PC}^ ;And return to the caller
785
786 LTORG
787
788 ; --- tpl__copyData ---
789 ;
790 ; On entry: R4 == pointer to icon data
791 ; R5 == icon flags word
792 ; R6 == pointer to free part of buffer
793 ; R7 == pointer to window block
794 ; R8 == number of icons in the window
795 ; R9 == pointer to the window definition in the template file
796 ; R10 == pointer to index for current window
797 ; R12 == pointer to template base and workspace block
798 ;
799 ; On exit: R6 incremented by an appropriate amount
800 ; Everything else preserved (except R14, obviously!)
801 ;
802 ; Use: Copies indirected data from an icon definition into the
803 ; buffer given and fixes up pointers in the definition
804
805 tpl__copyData ROUT
806
807 ; --- Make sure there's something to do here ---
808
809 TST R5,#&00000100 ;Check the indirected bit
810 MOVEQS PC,R14 ;If unset, return right now
811
812 ; --- Handle basic indirected data ---
813
814 STMFD R13!,{R0,R1,R14} ;Stack some registers
815 LDR R1,[R4,#0] ;Get the indirected pointer
816 STR R6,[R4,#0] ;Store the new pointer in
817 ADD R1,R9,R1 ;Offset by window address
818 MOV R0,R6 ;Point to free bit of bufffer
819 BL str_cpy ;Copy (and null-terminate)
820 LDR R14,[R4,#8] ;Get the indirect buffer size
821 ADD R6,R6,R14 ;Move buffer pointer on by it
822
823 ; --- Check for validation string presence ---
824
825 TST R5,#&00000001 ;Is the `Is text' bit on?
826 LDRNE R14,[R4,#4] ;Yes -- get validation ptr
827 CMPNE R14,#-1 ;Is it a sensible pointer?
828 LDMEQFD R13!,{R0,R1,PC}^ ;If not, we're done
829
830 ; --- Handle the validation string ---
831
832 STR R6,[R4,#4] ;Store the new pointer
833 ADD R1,R9,R14 ;Point to the validation str
834 MOV R0,R6 ;Point to the bit of buffer
835 BL str_cpy ;And copy the string across
836 ADD R6,R0,#1 ;Point R6 past string term
837 LDMFD R13!,{R0,R1,PC}^ ;That's it from us, then
838
839 LTORG
840
841 ; --- tpl__findFont ---
842 ;
843 ; On entry: R5 == pointer to icon flags word
844 ; R6 == pointer to free part of buffer
845 ; R7 == pointer to window block
846 ; R8 == number of icons in the window
847 ; R9 == pointer to the window definition in the template file
848 ; R10 == pointer to index for current window
849 ; R12 == pointer to template base and workspace block
850 ;
851 ; On exit: Everything preserved except R4 (and R14, obviously!)
852 ;
853 ; Use: Fixes up an icon's anti-aliased font data.
854
855 tpl__findFont ROUT
856
857 LDR R4,[R5] ;Get the icon flags word
858 TST R4,#&00000040 ;Is it antialiased?
859 TSTNE R4,#&00000001 ;Make sure it's text too
860 BICEQS PC,R14,#V_flag ;If not, return no error
861
862 ; --- Now to business -- ensure we have a font table ---
863
864 STMFD R13!,{R0-R3,R5,R12,R14} ;Save some registers
865 LDMIA R12,{R5,R12} ;Load base and workspace
866 LDR R0,template_fonts ;Find font array pointer
867 CMP R0,#0 ;Is it null?
868 BEQ %00tpl__findFont ;Yes -- allocate it
869
870 ; --- Now locate the font table in the file ---
871
872 01tpl__findFont LDR R3,[R5,#0] ;Get the font table offset
873 ADD R3,R5,R3 ;Convert it to a pointer
874
875 ; --- Find internal font handle and get table entry ---
876
877 MOV R0,R4,LSR #24 ;Leave only the font handle
878 SUB R0,R0,#1 ;Convert to 0-indexed
879 STMFD R13!,{R4,R5} ;Need some more registers!!
880 ADD R4,R3,R0,LSL #4 ;R4 = R3 + R0 * 16
881 ADD R4,R4,R0,LSL #5 ;Now R4 = R3 + R0 * 48
882
883 ; --- Now we must load the font width and height ---
884 ;
885 ; The problem is that they're not on word boundaries, so
886 ; we must do clever-dick things with the barrel shifter.
887
888 AND R0,R3,#3 ;Get the bottom two bits
889 BIC R1,R3,#3 ;Word align the base address
890 LDMIA R1,{R2,R3,R14} ;Get the width and height
891 MOV R0,R0,LSL #3 ;Convert bits to bytes
892 RSB R1,R0,#32 ;Get the other shift too
893 MOV R2,R2,LSR R0 ;Shift the bits down here
894 ORR R2,R2,R3,LSL R1 ;And add in the top bits
895 MOV R3,R3,LSR R0 ;Shift down bottom bits
896 ORR R3,R3,R14,LSL R1 ;And add in the top bits
897
898 ; --- We are now in a position to find the font ---
899
900 ADD R1,R4,#8 ;Point to the font name
901 MOV R4,#0 ;Default x scaling
902 MOV R5,#0 ;Default y scaling
903 SWI Font_FindFont ;Try very hard to find it
904 LDMFD R13!,{R4,R5} ;Restore these registers
905 ADDVS R13,R13,#4 ;If it failed, skip R0,
906 LDMVSFD R13!,{R1-R3,PC} ;... and restore regs
907
908 ; --- Now bump the item in the font array ---
909
910 LDR R1,template_fonts ;Find the font array
911 LDRB R2,[R1,R0] ;Get counter for the handle
912 ADD R2,R2,#1 ;Bump the counter a bit
913 STRB R2,[R1,R0] ;And store it away again
914
915 ; --- Bodge the icon flags word for the new handle ---
916
917 BIC R4,R4,#&FF000000 ;Clear out the old handle
918 ORR R4,R4,R0,LSL #24 ;Bring in the new...
919 STR R4,[R5] ;Store the new flags word
920 LDMFD R13!,{R0-R3,R5,R12,R14} ;Restore the registers
921 BICS PC,R14,#V_flag ;And return with no error
922
923 ; --- Create the font array if it's not there ---
924
925 00tpl__findFont MOV R0,#256 ;One byte for each font
926 BL alloc ;Allocate the memory
927 BLCS alloc_error ;If failed, get error
928 ADDCS R13,R13,#4 ;If it failed, bump R13
929 LDMCSFD R13!,{R1-R3,R5,R12,PC} ;... and return with error
930 STR R0,template_fonts ;Store the new pointer
931
932 ; --- Clear the font array to 0s ---
933
934 MOV R1,#256 ;The size of the array
935 MOV R2,#0 ;Value to initialise with
936 BL mem_set ;Clear out the array
937
938 ; --- Register our tidy-up routine ---
939
940 ADR R0,tpl__killFont ;Point to tidy up function
941 MOV R1,R12 ;Point to my workspace
942 BL except_atExit ;Register it properly
943 B %01tpl__findFont ;Return to the main proc
944
945 LTORG
946
947 ;----- The list structure ---------------------------------------------------
948
949 ^ 0
950 tlist_start # 0
951
952 tlist_next # 4 ;Pointer to the next one
953 tlist_name # 16 ;Name of this template
954 tlist_indptr # 4 ;Pointer to indirect data
955 tlist_indsize # 4 ;Size of indirect data
956 ; Window definition follows
957
958 tlist_size # 0 ;Size of that structure
959
960 ;----- Workspace ------------------------------------------------------------
961
962 ^ 0,R12
963 template_wstart # 0
964
965 template_list # 4 ;List head for templates
966 template_fonts # 4 ;Font array if we need one
967
968 template_wsize EQU {VAR}-template_wstart
969
970 AREA |Sapphire$$LibData|,CODE,READONLY
971
972 DCD template_wsize
973 DCD template_wspace
974 DCD 256
975 DCD template_init
976
977 ;----- That's all, folks ----------------------------------------------------
978
979 END
The Straylight Source Distribution (obsolete software for RISC OS)