~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Libraries / Sapphire / s / fontMenu
1 ;
2 ; fontMenu.s
3 ;
4 ; Fontmenu creation
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 GET libs:stream
33
34 ;----- External dependencies ------------------------------------------------
35
36 GET sapphire:alloc
37 GET sapphire:event
38 GET sapphire:flex
39 GET sapphire:menu
40 GET sapphire:menuDefs
41 GET sapphire:msgs
42 GET sapphire:sapphire
43 GET sapphire:string
44
45 ;----- Main code ------------------------------------------------------------
46
47 AREA |Sapphire$$Code|,CODE,READONLY
48
49 ; --- fm_create ---
50 ;
51 ; On entry: R0 == current font name
52 ; R1 == handler to call when selection made
53 ; R2 == R10 value to call with
54 ; R3 == R12 value to call with
55 ; R4 == pointer to routine to call to create submenu
56 ; (ie. menu_create or tms_create)
57 ;
58 ; On exit: CS if any fonts exist and
59 ; R0 == pointer to a menu definition
60 ; R1 == event handler to call
61 ; R2 == R10 value for event handler
62 ; R3 == R12 value for event handler
63 ; else CC and
64 ; R0-R3 corrupted
65 ; May return an error
66 ;
67 ; Use: Creates a user menu definition suitable for passing directly
68 ; to (menu|tms)_create. Note however, that the menu defintion
69 ; does *not* include any title; this must be created first.
70 ; If you require items such as the system font, then
71 ; add these to the menu before creating the menu returned
72 ; from this call.
73
74 EXPORT fm_create
75 fm_create ROUT
76
77 STMFD R13!,{R0,R4-R10,R12,R14} ;Save some registers
78 WSPACE fm__wSpace
79
80 ; --- Save the caller's handler ---
81
82 ADR R14,fm__userHandler ;Point to the handler
83 STMIA R14,{R1-R4} ;Store it away
84
85 ; --- Ensure that we need to create it ---
86
87 MOV R0,R11 ;Build path in scratchpad
88 BL fm__fontPath ;Get the current fontpath
89 BCC %70fm_create ;None found -- no fonts then
90
91 LDR R14,fm__flags ;Load the flags word
92 TST R14,#fmFlag__changed ;Have the fonts changed?
93 BICNE R14,R14,#fmFlag__changed ;Yes -- clear the flag
94 STRNE R14,fm__flags ;...store the flags
95 BNE %00fm_create ;...and recreate the menu
96
97 LDR R1,fm__block ;Load our block address
98 MOVS R2,R1 ;Is it defined yet?
99 ADRNE R1,fm__path ;Point to saved font path
100 BLNE str_cmp ;Compare with current path
101 MOVNE R2,#0 ;If not equal, clear pointer
102 CMP R2,#0 ;So, do we recreate?
103 BNE %40fm_create ;No -- return current menu
104
105 MOV R1,R11 ;Point to font path string
106 ADR R0,fm__path ;Point to font path buffer
107 BL str_cpy ;Take a copy of the path
108
109 00fm_create LDR R0,fm__block ;Load address of menu block
110 CMP R0,#0 ;Is it created currently?
111 BLNE free ;Yes -- free it then
112
113 ; --- Set up a flex block ---
114 ;
115 ; We will read the font names into this block, to make it
116 ; easier to actually build our menu, and reduce heap
117 ; fragmentation.
118 ;
119 ; The format of the data in the block is as follows:
120 ;
121 ; Size Use
122 ; / 4 Number of variants (0 for regular only)
123 ; | ? Name of this family
124 ; \ [ ? Name of this variant
125
126 SUB R13,R13,#12 ;Make a small anchor block
127 MOV R0,R13 ;Point to the block
128 MOV R1,#1024 ;Start it off at 256 bytes
129 BL flex_alloc ;Allocate the block
130 BLCS alloc_error ;If it failed, get error
131 BCS %80fm_create ;And return to caller
132
133 MOV R0,#0 ;Start at the beginning
134 STMIB R13,{R0,R1} ;Save them in the block
135
136 MOV R9,#4 ;No length for main menu
137 MOV R10,#0 ;Or for the submenus
138
139 ; --- Start building font names now ---
140
141 MOV R2,#0 ;Start from the beginning
142 MOV R1,R11 ;Build string in ScratchPad
143 MOV R3,#256 ;Size of scratchpad buffer
144 SWI Font_ListFonts ;Read a font name
145 CMP R2,#-1 ;Is that the very end?
146 BEQ %65fm_create ;Yes -- abort now then
147 MOV R4,#0 ;Found one family so far
148
149 MOV R6,#0 ;Clear a flags word
150 MOV R1,R11 ;Point to the font name
151 BL fm__parse ;Break the name up
152 ORRCC R6,R6,#1 ;If `Regular', set a flag
153 MOV R3,R1 ;Look after variant name
154 MOV R8,R0 ;Look after the family name
155
156 ; --- Set this family name up ---
157
158 10fm_create MOV R5,#0 ;This is the first variant
159
160 MOV R0,R13 ;Point to the anchor block
161 MOV R1,#4 ;Make space for count word
162 BL fm__ensure ;Allocate space for it
163 BVS %79fm_create ;If we couldn't, abort
164 ADD R7,R0,#4 ;Point just past this word
165
166 FSAVE R7 ;Save R7 on relocation stack
167 MOV R1,R8 ;Get family name in R1
168 MOV R0,R13 ;Point to the anchor block
169 BL fm__string ;Write the family name out
170 BVS %79fm_create ;If it failed, abort now
171 ADD R0,R0,#3+8 ;Word align returned length
172 BIC R0,R0,#3 ;Tumtetiddlytumtetum
173 ADD R9,R9,R0 ;Add on to main menu length
174 ADD R9,R9,#4 ;Remember space for radio
175 ADD R10,R10,R0 ;And add on submenu length
176
177 ; --- Write this variant out ---
178
179 15fm_create MOV R0,R13 ;Point to anchor block
180 MOV R1,R3 ;Point to variant name
181 BL fm__string ;Add this on the end
182 BVS %79fm_create ;If it failed, abort now
183 ADD R0,R0,#3+12 ;Word align returned length
184 BIC R0,R0,#3 ;Omtiddlyompepom
185 ADD R10,R10,R0 ;Add this to submenu length
186 ADD R5,R5,#1 ;Increment variant counter
187
188 ; --- Get the next font name ready ---
189
190 MOV R8,R6 ;Remember current flags
191 MOV R1,R11 ;Build string in ScratchPad
192 MOV R3,#256 ;Size of scratchpad buffer
193 SWI Font_ListFonts ;Read a font name
194 CMP R2,#-1 ;Is that the very end?
195 BEQ %20fm_create ;Yes -- we've finished then
196
197 BL fm__parse ;Break up the font name
198 ORRCC R6,R6,#1 ;If `Regular', set a flag
199 BICCS R6,R6,#1 ;Otherwise clear it
200
201 MOV R3,R1 ;Look after the variant name
202 FLOAD R1 ;Restore family name address
203 BL str_cmp ;Do the strings match?
204 FSAVE R1 ;Save the address back
205 BEQ %15fm_create ;And loop round for more
206
207 ; --- Finished a family ---
208
209 20fm_create
210 FLOAD R7 ;Reload family name address
211 CMP R5,R8 ;Is there only `Regular'?
212 MOVEQ R5,#0 ;Yes -- claim no variants
213 STR R5,[R7,#-4] ;Save it in the block
214 MOV R8,R0 ;Look after the family name
215 MOV R0,R13 ;Point to anchor block
216 BL fm__align ;Word align output pointer
217 ADD R4,R4,#1 ;Increment family counter
218 CMP R2,#-1 ;Are there more font names?
219 BNE %10fm_create ;Yes -- put them in the block
220
221 ; --- Allocate a big heap block ---
222
223 ADD R0,R9,R10 ;Add the menu sizes up
224 ADD R0,R0,R4,LSL #2 ;And an indexing block
225 BL alloc ;Allocate this block
226 BLCS alloc_error ;If it failed, get error
227 BCS %79fm_create ;And return to caller
228
229 STR R0,fm__block ;Store this block address
230
231 ; --- A note about register allocation ---
232 ;
233 ; Dear reader,
234 ; I have decided, it being Saturday and all, to allocate
235 ; registers thusly:
236 ;
237 ; R7 == pointer into submenu indexing table
238 ; R8 == pointer into the main menu structure
239 ; R9 == pointer into the submenu area
240 ; R10 == pointer into our juicy big flex table
241 ;
242 ; Yours sincerely
243 ;
244 ; Mark Wooding (Straylight Dev Lab)
245
246 MOV R7,R0 ;Point to indexing table
247 ADD R8,R7,R4,LSL #2 ;Find the main menu area
248 ADD R9,R8,R9 ;And find the submenu area
249 LDR R10,[R13,#0] ;Load base of flex block
250 STR R8,fm__menu ;Store the menu address
251
252 ; --- Now the fun begins ---
253
254 22fm_create MOV R0,#mFlag_radio ;Get the flag ready
255 ORR R0,R0,#mFlag_R12 ;And make data R12-relative
256 LDR R6,[R10],#4 ;Load the number of variants
257 CMP R6,#0 ;Do we want a submenu?
258 ORRNE R0,R0,#mFlag_subWarn ;Yes -- set the flag then
259 STR R0,[R8],#4 ;Save it in the menu block
260
261 MOVEQ R14,#0 ;No submenu -- get null ptr
262 STREQ R14,[R7],#4 ;And clear submenu address
263 STRNE R9,[R7],#4 ;Save this submenu address
264
265 MOV R0,R10 ;Look after this address
266 23fm_create LDRB R14,[R10],#1 ;Load a family name byte
267 CMP R14,#0 ;Is this the end yet?
268 STRB R14,[R8],#1 ;Save it in the menu block
269 BNE %23fm_create ;And go round for the rest
270
271 ADD R8,R8,#3 ;Word align the output addr
272 BIC R8,R8,#3 ;Yingtongiddleipo
273
274 MOV R1,#4 ;Offset 0 in radio block
275 MOV R2,R8 ;Magic radio group tag
276 STMIA R8!,{R1,R2} ;Save these in the block
277
278 ; --- Now build the variants submenu ---
279
280 CMP R6,#0 ;Do we want a submenu
281 BEQ %28fm_create ;No -- *still skip past name*
282
283 MOV R14,#0 ;Title flags
284 STR R14,[R9],#4 ;Save in submenu block
285 24fm_create LDRB R14,[R0],#1 ;Load a family name byte
286 STRB R14,[R9],#1 ;Save it in the menu block
287 CMP R14,#0 ;Is this the end yet?
288 BNE %24fm_create ;And go round for the rest
289
290 ADD R9,R9,#3 ;Word align the output addr
291 BIC R9,R9,#3 ;Obblyjobblywibbledidee
292
293 ; --- Create an item for each variant ---
294
295 25fm_create MOV R0,#mFlag_radio ;Get the flag ready
296 ORR R0,R0,#mFlag_R12 ;And make data R12-relative
297 STR R0,[R9],#4 ;Save in submenu block
298
299 26fm_create LDRB R14,[R10],#1 ;Load a variant name byte
300 CMP R14,#0 ;Is this the end yet?
301 STRB R14,[R9],#1 ;Save it in the menu block
302 BNE %26fm_create ;And go round for the rest
303
304 ADD R9,R9,#3 ;Word align the output addr
305 BIC R9,R9,#3 ;Obblyjobblywibbledidee
306
307 MOV R1,#8 ;Offset 8 in radio block
308 MOV R2,R9 ;Magic radio group tag
309 STMIA R9!,{R1,R2} ;Save these in the block
310
311 SUBS R6,R6,#1 ;Decrement the counter
312 BGT %25fm_create ;And do the rest of them
313
314 MOV R14,#mFlag_end ;Terminate the menu
315 STR R14,[R9],#4 ;Save that at the end
316
317 B %30fm_create ;Skip to end of family stuff
318
319 ; --- No variants -- omit the submenu ---
320 ;
321 ; For odd reasons, we actually leave a `(Regular)' item
322 ; in the flex block. We need to skip over this here.
323
324 28fm_create LDRB R14,[R10],#1 ;Load a variant name byte
325 CMP R14,#0 ;Is this the end yet?
326 BNE %28fm_create ;And go round for the rest
327
328 30fm_create ADD R10,R10,#3 ;Word align flex block ptr
329 BIC R10,R10,#3 ;[Silly comment omitted]
330
331 SUBS R4,R4,#1 ;Done another family
332 BGT %22fm_create ;And go round for the rest
333
334 MOV R14,#mFlag_end ;Terminate the menu
335 STR R14,[R8],#4 ;Save that at the end
336
337 ; --- Destroy the flex block ---
338
339 MOV R0,R13 ;Point to the flex anchor
340 BL flex_free ;Free the block
341 ADD R13,R13,#12 ;Restore stack pointer
342
343 ; --- Now return the menu and things ---
344
345 40fm_create LDR R0,[R13],#4 ;Load the name to tick
346 BL fm_tickFont ;Tick that font
347 LDR R0,fm__menu ;Find the menu address
348 ADR R1,fm__handler1 ;I don't have a handler :-(
349 MOV R2,#0 ;No R10 value either :~-(
350 MOV R3,R12 ;And pass workspace in R12
351 LDMFD R13!,{R4-R10,R12,R14} ;Restore registers
352 ORR R14,R14,#C_flag ;Set C to say we did it
353 BICS PC,R14,#V_flag ;And return errorless
354
355 ; --- Couldn't find any fonts (oops) ---
356
357 65fm_create ADD R13,R13,#12 ;Restore stack pointer
358 70fm_create LDMFD R13!,{R0,R4-R10,R12,R14} ;Restore registers
359 BICS PC,R14,#V_flag+C_flag ;And return CC
360
361 ; --- Tidy up after catastrophes ---
362
363 79fm_create MOV R10,R0 ;Look after the error
364 MOV R0,R13 ;Point to the flex anchor
365 BL flex_free ;Free the flex block
366 MOV R0,R10 ;Restore the error pointer
367
368 80fm_create ADD R13,R13,#12+4 ;Restore the stack nicely
369 LDMFD R13!,{R4-R10,R12,R14} ;Restore registers
370 ORRS PC,R14,#V_flag ;And return the error
371
372 LTORG
373
374 ; --- fm__handler1 ---
375 ;
376 ; On entry: R0 == menu event
377 ; R1 == menu item
378 ; R12 == pointer to private workspace
379 ;
380 ; On exit: --
381 ;
382 ; Use: Handles events on the first level menu.
383
384 fm__handler1 ROUT
385
386 CMP R0,#mEvent_select ;Is it a menu selection
387 CMPNE R0,#mEvent_subMenu ;Or a submenu event?
388 MOVNES PC,R14 ;Nope -- return
389
390 STMFD R13!,{R1-R4,R14} ;Stack registers
391 CMP R0,#mEvent_select ;A selection?
392 BEQ %50fm__handler1 ;Yes -- jump ahead
393
394 ; --- Handle submenu events ---
395
396 LDR R0,fm__block ;Point to useful table
397 LDR R0,[R0,R1,LSL #2] ;Load submenu address
398 MOV R2,R1 ;Pass item number in R10
399 ADR R1,fm__handler2 ;And point to second handler
400 MOV R3,R12 ;And workspace in R12
401 LDR R4,fm__creator ;Load address of creator
402 MOV R14,PC ;Set up return address
403 MOV PC,R4 ;Call the creator
404 B %90fm__handler1 ;Return to caller
405
406 ; --- User selected an item ---
407
408 50fm__handler1 MOV R3,R1 ;Remember index value
409 BL fm__familyName ;Get family name pointer
410 MOV R1,R0 ;Put it in R1
411 ADR R0,fm__name ;Write the name here
412 BL str_cpy ;Copy over family name
413 MOV R2,R0 ;Put terminator ptr in R2
414 LDR R0,fm__block ;Load table pointer
415 LDR R0,[R0,R3,LSL #2] ;Load submenu pointer
416 CMP R0,#0 ;Is there a submenu?
417 BEQ %60fm__handler1 ;No -- jump ahead
418 MOV R1,#0 ;Just choose first index
419 BL fm__variantName ;Find the first variant name
420 CMP R0,#0 ;Is there one?
421 BEQ %60fm__handler1 ;No -- return now then
422 MOV R1,R0 ;Put it in R1
423 MOV R0,R2 ;Copy it to here
424 MOV R14,#'.' ;We want a '.' first
425 STRB R14,[R0],#1 ;Store in the string
426 BL str_cpy ;Copy over the string
427
428 60fm__handler1 MOV R0,#fmEvent_select ;The event type
429 ADR R1,fm__name ;Point to the name
430 BL fm__dispatch ;Dispatch the event
431
432 90fm__handler1 LDMFD R13!,{R1-R4,PC}^ ;Load back registers
433
434 LTORG
435
436 ; --- fm__handler2 ---
437 ;
438 ; On entry: R0 == menu event
439 ; R1 == menu item
440 ; R10 == menu item submenu came from
441 ; R12 == pointer to workspace
442 ;
443 ; On exit: --
444 ;
445 ; Use: Handles events for a second level submenu
446
447 fm__handler2 ROUT
448
449 CMP R0,#mEvent_select ;Is it a menu selection
450 MOVNES PC,R14 ;Nope -- return
451
452 STMFD R13!,{R1-R3,R14} ;Stack registers
453
454 MOV R3,R1 ;Remember index value
455 MOV R1,R10 ;Get previous index
456 BL fm__familyName ;Get family name pointer
457 MOV R1,R0 ;Put it in R1
458 ADR R0,fm__name ;Write the name here
459 BL str_cpy ;Copy over family name
460 MOV R2,R0 ;Put terminator ptr in R2
461 LDR R0,fm__block ;Load table pointer
462 LDR R0,[R0,R10,LSL #2] ;Load submenu pointer
463 MOV R1,R3 ;Put index in R1
464 BL fm__variantName ;Find the variant name
465 CMP R0,#0 ;Is there a name?
466 BEQ %10fm__handler2 ;No -- retur now then
467 MOV R1,R0 ;Put it in R1
468 MOV R0,R2 ;Copy it to here
469 MOV R14,#'.' ;We want a '.' first
470 STRB R14,[R0],#1 ;Store in the string
471 BL str_cpy ;Copy over the string
472
473 10fm__handler2 MOV R0,#fmEvent_select ;The event type
474 ADR R1,fm__name ;Point to the name
475 BL fm__dispatch ;Dispatch the event
476
477 LDMFD R13!,{R1-R3,PC}^ ;Load back registers
478
479 LTORG
480
481 ; --- fm__dispatch ---
482 ;
483 ; On entry: R0-R9 == event data
484 ; R12 == workspace pointer
485 ;
486 ; On exit: --
487 ;
488 ; Use: Sends an event to the users font menu handler.
489
490 fm__dispatch ROUT
491
492 STMFD R13!,{R9,R10,R12,R14} ;Stack registers
493 ADR R14,fm__userHandler ;Point to the handler
494 LDMIA R14,{R9,R10,R12} ;Load registers
495 CMP R9,#0 ;Sanity check
496 MOV R14,PC ;Sey up return address
497 MOVNE PC,R9 ;Call the handler
498 LDMFD R13!,{R9,R10,R12,PC}^ ;Return to caller
499
500 LTORG
501
502 ; --- fm_tickFont ---
503 ;
504 ; On entry: R0 == name to tick
505 ;
506 ; On exit: --
507 ;
508 ; Use: Ticks the font with tht given name in the fontmenu. If
509 ; no font exists then the existing ticks are removed
510
511 EXPORT fm_tickFont
512 fm_tickFont ROUT
513
514 CMP R0,#0 ;Is R0 NULL?
515 MOVEQS PC,R14 ;Yes -- return now
516 STMFD R13!,{R0-R4,R14} ;Stack some registers
517 WSPACE fm__wSpace ;Locate my workspace
518 MOV R1,R0 ;Put the name in R1
519 MOV R0,R11 ;Point to the scratchpad
520 BL str_cpy ;Copy the string over
521 MOV R1,R11 ;Put the pointer in R1
522 BL fm__parse ;Parse up the string
523 MOVCS R4,#1 ;Not regular
524 MOVCC R4,#0 ;Yes it is sir
525 MOV R3,R1 ;Put variant name in R3
526
527 ; --- Clear the existing ticks ---
528
529 MOV R14,#0 ;Get a NULL word
530 STR R14,fm__ticks ;Clear first tick
531 STR R14,fm__ticks+4 ;And second tick
532
533 ; --- Search for the font name ---
534
535 LDR R1,fm__menu ;Point to the menu definition
536 MOV R2,#0 ;Index so far
537 00fm_tickFont LDR R14,[R1],#4 ;Load the flags word
538 TST R14,#mFlag_end ;Have we reached the end?
539 BNE %90fm_tickFont ;Yes -- return
540 BL str_icmp ;Does this name match
541 BEQ %50fm_tickFont ;Yes -- jump ahead
542 10fm_tickFont LDRB R14,[R1],#1 ;Load a character
543 CMP R14,#0 ;Is it a terminator?
544 BNE %10fm_tickFont ;No -- keep on looking
545 ADD R1,R1,#3+8 ;Word align, skip over data
546 BIC R1,R1,#3
547 ADD R2,R2,#1 ;Increment the index
548 B %00fm_tickFont ;Keep on looking
549
550 ; --- We have found a match ---
551 ;
552 ; First we must get the tick word thing
553
554 50fm_tickFont LDRB R14,[R1],#1 ;Load a character
555 CMP R14,#0 ;Is it a terminator?
556 BNE %50fm_tickFont ;No -- keep on looking
557 ADD R1,R1,#3+4 ;Word align, pount to thing
558 BIC R1,R1,#3
559 LDR R14,[R1] ;Load the data word thing
560 STR R14,fm__ticks ;Store as first level tick
561
562 ; --- Now search the submenu ---
563
564 LDR R1,fm__block ;Point to table
565 LDR R1,[R1,R2,LSL #2] ;Load submenu pointer
566 CMP R1,#0 ;Is there one?
567 BEQ %90fm_tickFont ;Nope -- return
568
569 MOV R0,R3 ;Put variant name in R0
570
571 ; --- Skip over title data ---
572
573 ADD R1,R1,#4 ;Skip over flags word
574 52fm_tickFont LDRB R14,[R1],#1 ;Load a byte
575 CMP R14,#0 ;Have we reach the end?
576 BNE %52fm_tickFont ;No -- keep looking
577 ADD R1,R1,#3 ;Word align
578 BIC R1,R1,#3
579
580 ; --- Select 'Regular' if appropriate ---
581
582 CMP R4,#0 ;Did user select 'Regular'?
583 ADDEQ R1,R1,#4 ;Yes -- skip over glags
584 BEQ %58fm_tickFont ;...and tick this one then
585
586 ; --- Now search for the family name ---
587
588 54fm_tickFont LDR R14,[R1],#4 ;Load the flags word
589 TST R14,#mFlag_end ;Have we reached the end?
590 BNE %90fm_tickFont ;Yes -- return
591 BL str_icmp ;Does this name match
592 BEQ %58fm_tickFont ;Yes -- jump ahead
593 56fm_tickFont LDRB R14,[R1],#1 ;Load a character
594 CMP R14,#0 ;Is it a terminator?
595 BNE %56fm_tickFont ;No -- keep on looking
596 ADD R1,R1,#3+8 ;Word align, skip over data
597 BIC R1,R1,#3
598 B %54fm_tickFont ;Keep on looking
599
600 ; --- We have found a match ---
601
602 58fm_tickFont LDRB R14,[R1],#1 ;Load a character
603 CMP R14,#0 ;Is it a terminator?
604 BNE %58fm_tickFont ;No -- keep on looking
605 ADD R1,R1,#3+4 ;Word align, pount to thing
606 BIC R1,R1,#3
607 LDR R14,[R1] ;Load the data word thing
608 STR R14,fm__ticks+4 ;Store as first level tick
609
610 ; --- Return to caller ---
611
612 90fm_tickFont LDMFD R13!,{R0-R4,PC}^ ;Return to caller
613
614 LTORG
615
616 ; --- fm__familyName ---
617 ;
618 ; On entry: R1 == index of name
619 ; R12 == workspace pointer
620 ;
621 ; On exit: R0 == poiner to family name
622 ;
623 ; Use: Points to the family name for the given menu index
624
625 fm__familyName ROUT
626
627 STMFD R13!,{R1,R14} ;Stack registers
628 LDR R0,fm__menu ;Point to the menu block
629
630 ADD R0,R0,#4 ;Skip over flags word
631 CMP R1,#0 ;Is this index 0?
632 BEQ %90fm__familyName ;Yes -- return happy then
633 00 LDRB R14,[R0],#1 ;Load a byte
634 CMP R14,#0 ;Is it the end?
635 BNE %00fm__familyName ;No -- keep looking
636 ADD R0,R0,#3+8+4 ;Word align and point to next
637 BIC R0,R0,#3
638 SUBS R1,R1,#1 ;Decrement the count
639 BNE %00fm__familyName ;And keep on looking
640
641 90 LDMFD R13!,{R1,PC}^ ;Return to caller
642
643 LTORG
644
645 ; --- fm__variantName ---
646 ;
647 ; On entry: R0 == pointer to submenu
648 ; R1 == index of name
649 ; R12 == workspace pointer
650 ;
651 ; On exit: R0 == poiner to family name, or 0 for regular
652 ;
653 ; Use: Points to the family name for the given menu index
654
655 fm__variantName ROUT
656
657 STMFD R13!,{R1,R14} ;Stack registers
658
659 ADD R0,R0,#4 ;Skip over flags word
660
661 00 LDRB R14,[R0],#1 ;Load a byte
662 CMP R14,#0 ;Is it the end?
663 BNE %00fm__variantName ;No -- keep looking
664 ADD R0,R0,#3+4 ;Word align and point to fst
665 BIC R0,R0,#3
666
667 CMP R1,#0 ;Is this index 0?
668 BEQ %90fm__variantName ;Yes -- return happy then
669 10 LDRB R14,[R0],#1 ;Load a byte
670 CMP R14,#0 ;Is it the end?
671 BNE %10fm__variantName ;No -- keep looking
672 ADD R0,R0,#3+8+4 ;Word align and point to next
673 BIC R0,R0,#3
674 SUBS R1,R1,#1 ;Decrement the count
675 BNE %10fm__variantName ;And keep on looking
676
677 90 MOV R1,R0 ;Put string in R1
678 ADR R0,fm__regular ;Point to regular name
679 BL msgs_lookup ;Translate it
680 BL str_cmp ;Is this a match?
681 MOVNE R0,R1 ;No -- return name then
682 MOVEQ R0,#0 ;Yes -- return 0 then
683 LDMFD R13!,{R1,PC}^ ;Return to caller
684
685 LTORG
686
687 ; --- fm__parse ---
688 ;
689 ; On entry: R1 == pointer to font name
690 ;
691 ; On exit: R0 == pointer to font family name (R1 on entry)
692 ; R1 == pointer to font variant name
693 ; CS if variant spcified explicitly, CC if `Regular'
694 ;
695 ; Use: Parses a font name into a family and variant.
696
697 fm__parse ROUT
698
699 STMFD R13!,{R2,R3,R14} ;Save some registers
700 MOV R2,R1 ;Look after start pointer
701
702 00fm__parse LDRB R14,[R1],#1 ;Load next byte from name
703 CMP R14,#'.' ;Is this a dot?
704 BEQ %10fm__parse ;Yes -- found the variant
705 CMP R14,#32 ;Is this the end?
706 BCS %00fm__parse ;No -- keep looking then
707
708 ; --- Reached end of name -- must be (Regular) ---
709
710 MOV R14,#0 ;Zero terminate for luck
711 STRB R14,[R1,#-1] ;Save it over the terminator
712 ADR R0,fm__regular ;Find the regular message
713 BL msgs_lookup ;Translate it nicely
714 MOV R3,R1 ;Point to variant buffer
715 05fm__parse LDRB R14,[R0],#1 ;Load a byte from `Regular'
716 CMP R14,#32 ;Is this a control char?
717 MOVCC R14,#0 ;Yes -- zero terminate then
718 STRB R14,[R3],#1 ;Store in destination
719 BCS %05fm__parse ;And loop round for the rest
720
721 MOV R0,R2 ;Point to family name again
722 LDMFD R13!,{R2,R3,R14} ;Unstack registers
723 BICS PC,R14,#C_flag ;And return to caller
724
725 ; --- Found a variant ---
726
727 10fm__parse MOV R14,#0 ;Zero terminate for luck
728 STRB R14,[R1,#-1] ;Save it over the terminator
729 MOV R0,R2 ;Point to family name again
730 LDMFD R13!,{R2,R3,R14} ;Unstack registers
731 ORRS PC,R14,#C_flag ;And return to caller
732
733 fm__regular DCB "fmREG:(Regular)",0
734
735 LTORG
736
737 ; --- fm__ensure ---
738 ;
739 ; On entry: R0 == address of anchor and size info
740 ; R1 == free space required
741 ;
742 ; On exit: R0 == address of first free byte in area
743 ; May return an error
744 ;
745 ; Use: Ensures that there is the requested quantity of memory free
746 ; in the given block.
747
748 fm__ensure ROUT
749
750 STMFD R13!,{R1,R2,R14} ;Save some registers
751 LDMIB R0,{R2,R14} ;Load used and size words
752 ADD R1,R1,R2 ;Find new total size
753 STR R1,[R0,#4] ;Save this back
754 ADD R1,R1,#255 ;Align up to next 256
755 BIC R1,R1,#255 ;For niceness's sake
756 CMP R1,R14 ;Do we already have enough?
757 BHI %50fm__ensure ;No -- allocate some more
758 10fm__ensure STR R1,[R0,#8] ;Save new total size
759 LDR R0,[R0,#0] ;Load address of block
760 ADD R0,R0,R2 ;Point to first free byte
761 LDMFD R13!,{R1,R2,R14} ;And return to caller
762 BICS PC,R14,#V_flag
763
764 50fm__ensure BL flex_extend ;No -- then extend the block
765 BCC %10fm__ensure ;If OK, rejoin the main thing
766 BL alloc_error ;Find an error message
767 LDMFD R13!,{R1,R2,R14} ;Restore registers
768 ORRS PC,R14,#V_flag ;And return the error
769
770 LTORG
771
772 ; --- fm__string ---
773 ;
774 ; On entry: R0 == pointer to anchor and size info
775 ; R1 == pointer to null terminated string
776 ;
777 ; On exit: R0 == length of the string+1
778 ; May return an error
779 ;
780 ; Use: Writes a string on the end of the given block.
781
782 fm__string ROUT
783
784 STMFD R13!,{R0-R3,R14} ;Save some registers
785 MOV R2,R0 ;Look after the anchor ptr
786 MOV R3,R1 ;Keep the string address
787 MOV R0,R1 ;Point to the string
788 BL str_len ;Find the length of it
789 ADD R1,R0,#1 ;Allow space for terminator
790 STR R1,[R13,#0] ;Save this as return value
791 MOV R0,R2 ;Point to the anchor
792 BL fm__ensure ;Make sure there's enough
793 MOVVC R1,R3 ;Point to string to write
794 BLVC str_cpy ;Copy the string over
795 STRVS R0,[R13,#0] ;If it failed, return error
796 LDMFD R13!,{R0-R3,PC} ;And return to caller
797
798 LTORG
799
800 ; --- fm__align ---
801 ;
802 ; On entry: R0 == pointer to anchor and size info
803 ;
804 ; On exit: --
805 ;
806 ; Use: Word aligns the block output address.
807
808 fm__align ROUT
809
810 STMFD R13!,{R14} ;Save a register
811 LDR R14,[R0,#4] ;Load the current used offset
812 ADD R14,R14,#3 ;Round up to word boundary
813 BIC R14,R14,#3 ;And do the round op
814 STR R14,[R0,#4] ;Save the offset back again
815 LDMFD R13!,{PC}^ ;And return to caller
816
817 LTORG
818
819 ; --- fm__fontPath ---
820 ;
821 ; On entry: R0 == pointer to buffer
822 ;
823 ; On exit: CS if there is a font path
824 ; CC otherwise
825 ;
826 ; Use: Reads the environmental variable font$path and copies
827 ; it into the buffer given. The buffer must be at least 256
828 ; bytes long.
829
830 fm__fontPath ROUT
831
832 STMFD R13!,{R0-R4,R14}
833 MOV R1,R0 ;But buffer ptr in R1
834 ADR R0,fm__varName ;Point to the name
835 MOV R2,#256 ;Length of buffer
836 MOV R3,#0 ;First (and last) call
837 MOV R4,#0 ;Don't expand the string
838 SWI XOS_ReadVarVal ;Read the variable
839 MOV R14,#0 ;We need a NULL byte
840 STRVCB R14,[R1,R2] ;Store the terminator
841 LDMFD R13!,{R0-R4,R14} ;Load registers
842 ORRVCS PC,R14,#C_flag ;Return C set if exists
843 BICVSS PC,R14,#C_flag ;Or clear otherwise
844
845 fm__varName DCB "Font$Path",0
846
847 LTORG
848
849 fm__wSpace DCD 0
850
851 ; --- fm__postFilter ---
852 ;
853 ; On entry: R0 == wimp event
854 ; R1 == wimp poll block pointer
855 ;
856 ; On exit: --
857 ;
858 ; Use: Looks out for font changed events.
859
860 fm__postFilter ROUT
861
862 CMP R0,#17 ;Is it a message?
863 CMPNE R0,#18
864 MOVNES PC,R14 ;Nope -- return
865 STMFD R13!,{R0,R14} ;Stack registers
866 LDR R0,[R1,#16] ;Load the message type
867 LDR R14,=&4A2C0 ;Fonts changed message number
868 CMP R14,R0 ;Is that the message?
869 LDMNEFD R13!,{R0,PC}^ ;No -- return now
870 LDR R14,fm__flags ;Load flags word
871 ORR R14,R14,#fmFlag__changed
872 STR R14,fm__flags ;Store back flags
873 LDMFD R13!,{R0,PC}^ ;Return to caller
874
875 LTORG
876
877 ; --- fm_init ---
878 ;
879 ; On entry: --
880 ;
881 ; On exit: --
882 ;
883 ; Use: Initialises the font menu system.
884
885 EXPORT fm_init
886 fm_init ROUT
887
888 STMFD R13!,{R0,R1,R12,R14} ;Stack some registers
889 WSPACE fm__wSpace
890 MOV R14,#0
891 STR R14,fm__flags ;No flags set yet
892
893 ; --- Set up the post filter ---
894
895 BL event_init ;Ensure event is ready
896 ADR R0,fm__postFilter ;Point to the handler
897 MOV R1,R12 ;R12 value to pass
898 BL event_postFilter ;Add in the post filter
899 SWIVS OS_GenerateError ;Generate the error
900 LDMFD R13!,{R0,R1,R12,PC}^ ;Return to caller
901
902 LTORG
903
904 ;----- Events ---------------------------------------------------------------
905
906 ^ 0
907 fmEvent_select # 1 ;User selected a font
908 ;R1 == pointer to name
909
910 ;----- Workspace ------------------------------------------------------------
911
912 ^ 0,R12
913
914 fm__wStart # 0
915
916 fm__block # 4 ;Address of our heap block
917 fm__ticks # 8 ;Tick blocks
918 fm__menu # 4 ;Pointer to existing menu
919 fm__name # 40 ;Static buffer to return name
920 fm__userHandler # 4 ;User handler function
921 fm__R10 # 4 ;R10 value to call with
922 fm__R12 # 4 ;R12 value to call with
923 fm__creator # 4 ;Menu creation routine
924 fm__flags # 4 ;Useful flags word
925 fm__path # 256 ;Current font path
926
927 fm__wSize EQU {VAR}-fm__wStart
928
929 fmFlag__changed EQU (1<<0) ;The fonts have changed
930
931 AREA |Sapphire$$LibData|,CODE,READONLY
932
933 DCD fm__wSize
934 DCD fm__wSpace
935 DCD 256
936 DCD fm_init
937
938 ;----- That's all, folks ----------------------------------------------------
939
940 END
The Straylight Source Distribution (obsolete software for RISC OS)