Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/branches/SMLNJ/src/eXene/widgets/util/attrs.sml
ViewVC logotype

Annotation of /sml/branches/SMLNJ/src/eXene/widgets/util/attrs.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 8 - (view) (download)

1 : monnier 2 (* attrs.sml
2 :     *
3 :     * COPYRIGHT (c) 1994 AT&T Bell Laboratories.
4 :     *
5 :     * Types to add: FontList, Atom
6 :     *)
7 :    
8 :     structure Attrs : ATTRS =
9 :     struct
10 :    
11 :     structure F = Format
12 :     structure SS = Substring
13 :    
14 :     type attr_name = Quark.quark
15 :    
16 :     val attr_active = Quark.quark "active"
17 :     val attr_aspect = Quark.quark "aspect"
18 :     val attr_arrowDir = Quark.quark "arrowDir"
19 :     val attr_background = Quark.quark "background"
20 :     val attr_borderColor = Quark.quark "borderColor"
21 :     val attr_borderWidth = Quark.quark "borderWidth"
22 :     val attr_color = Quark.quark "color"
23 :     val attr_current = Quark.quark "current"
24 :     val attr_cursor = Quark.quark "cursor"
25 :     val attr_font = Quark.quark "font"
26 :     val attr_fontList = Quark.quark "fontList"
27 :     val attr_fontSize = Quark.quark "fontSize"
28 :     val attr_foreground = Quark.quark "foreground"
29 :     val attr_fromValue = Quark.quark "fromValue"
30 :     val attr_gravity = Quark.quark "gravity"
31 :     val attr_halign = Quark.quark "halign"
32 :     val attr_height = Quark.quark "height"
33 :     val attr_iconName = Quark.quark "iconName"
34 :     val attr_isActive = Quark.quark "isActive"
35 :     val attr_isSet = Quark.quark "isSet"
36 :     val attr_isVertical = Quark.quark "isVertical"
37 :     val attr_label = Quark.quark "label"
38 :     val attr_length = Quark.quark "length"
39 :     val attr_padx = Quark.quark "padx"
40 :     val attr_pady = Quark.quark "pady"
41 :     val attr_readyColor = Quark.quark "readyColor"
42 :     val attr_relief = Quark.quark "relief"
43 :     val attr_repeatDelay = Quark.quark "repeatDelay"
44 :     val attr_repeatInterval = Quark.quark "repeatInterval"
45 :     val attr_rounded = Quark.quark "rounded"
46 :     val attr_scale = Quark.quark "scale"
47 :     val attr_selectColor = Quark.quark "selectColor"
48 :     val attr_selectBackground = Quark.quark "selectBackground"
49 :     val attr_selectBorderWidth = Quark.quark "selectBorderWidth"
50 :     val attr_selectForeground = Quark.quark "selectForeground"
51 :     val attr_showValue = Quark.quark "showValue"
52 :     val attr_state = Quark.quark "state"
53 :     val attr_text = Quark.quark "text"
54 :     val attr_thumbLength = Quark.quark "thumbLength"
55 :     val attr_tickInterval = Quark.quark "tickInterval"
56 :     val attr_tile = Quark.quark "tile"
57 :     val attr_title = Quark.quark "title"
58 :     val attr_toValue = Quark.quark "toValue"
59 :     val attr_type = Quark.quark "type"
60 :     val attr_valign = Quark.quark "valign"
61 :     val attr_width = Quark.quark "width"
62 :    
63 :     datatype attr_type
64 :     = AT_Str
65 :     | AT_Int
66 :     | AT_Real
67 :     | AT_Bool
68 :     | AT_Font
69 :     | AT_Color
70 :     | AT_ColorSpec
71 :     | AT_Tile
72 :     | AT_Cursor
73 :     | AT_HAlign
74 :     | AT_VAlign
75 :     | AT_Relief
76 :     | AT_ArrowDir
77 :     | AT_Gravity
78 :    
79 :     datatype attr_value
80 :     = AV_Str of string
81 :     | AV_Int of int
82 :     | AV_Real of real
83 :     | AV_Bool of bool
84 :     | AV_Font of EXeneBase.font
85 :     | AV_Color of EXeneBase.color
86 :     | AV_ColorSpec of EXeneBase.color_spec
87 :     | AV_Tile of EXeneBase.tile
88 :     | AV_Cursor of EXeneBase.cursor
89 :     | AV_HAlign of WidgetBase.halign
90 :     | AV_VAlign of WidgetBase.valign
91 :     | AV_Relief of ThreeD.relief
92 :     | AV_ArrowDir of WidgetBase.arrow_dir
93 :     | AV_Gravity of WidgetBase.gravity
94 :     | AV_NoValue
95 :    
96 :     type attr_ctxt = {
97 :     scr : EXeneBase.screen,
98 :     tilef : string -> EXeneBase.tile
99 :     }
100 :    
101 :     exception BadAttrValue
102 :     exception NoConversion
103 :    
104 :     fun sameType (AV_Str _, AT_Str) = true
105 :     | sameType (AV_Int _, AT_Int) = true
106 :     | sameType (AV_Real _, AT_Real) = true
107 :     | sameType (AV_Bool _, AT_Bool) = true
108 :     | sameType (AV_Font _, AT_Font) = true
109 :     | sameType (AV_Color _, AT_Color) = true
110 :     | sameType (AV_Tile _, AT_Tile) = true
111 :     | sameType (AV_Cursor _, AT_Cursor) = true
112 :     | sameType (AV_HAlign _, AT_HAlign) = true
113 :     | sameType (AV_VAlign _, AT_VAlign) = true
114 :     | sameType (AV_Relief _, AT_Relief) = true
115 :     | sameType _ = false
116 :    
117 :     fun sameValue (AV_Str a, AV_Str b) = a = b
118 :     | sameValue (AV_Int a, AV_Int b) = a = b
119 :     | sameValue (AV_Real a, AV_Real b) = Real.==(a, b)
120 :     | sameValue (AV_Bool a, AV_Bool b) = a = b
121 :     | sameValue (AV_Font a, AV_Font b) = EXeneBase.sameFont(a,b)
122 :     | sameValue (AV_Color a, AV_Color b) = EXeneBase.sameColor(a,b)
123 :     | sameValue (AV_Tile a, AV_Tile b) = EXeneBase.sameTile(a,b)
124 :     | sameValue (AV_Cursor a, AV_Cursor b) = EXeneBase.sameCursor(a,b)
125 :     | sameValue (AV_HAlign a, AV_HAlign b) = a = b
126 :     | sameValue (AV_VAlign a, AV_VAlign b) = a = b
127 :     | sameValue (AV_Relief a, AV_Relief b) = a = b
128 :     | sameValue (AV_NoValue,AV_NoValue) = true
129 :     | sameValue _ = false
130 :    
131 :     (* strip leading and trailing whitespace from a string. *)
132 :     fun sstrip s =
133 :     SS.dropr Char.isSpace (SS.dropl Char.isSpace (SS.all s))
134 :     fun strip s = SS.string (sstrip s)
135 :     fun skipWS s = SS.dropl Char.isSpace (SS.all s)
136 :    
137 :     fun cvtBool s = (case (strip s)
138 :     of ("true"|"yes"|"Yes"|"on"|"On") => true
139 :     | ("false"|"no"|"No"|"off"|"Off") => false
140 :     | _ => raise BadAttrValue
141 :     (* end case *))
142 :    
143 :     fun cvtInt s = let
144 :     val s = StringCvt.skipWS SS.getc (SS.all s)
145 :     val start = if Char.isDigit(SS.sub (s, 0)) then 0 else 1
146 :     val rad = if (SS.sub(s, start) = #"0")
147 :     then (case SS.sub(s, start+1)
148 :     of (#"X" | #"x") => StringCvt.HEX
149 :     | _ => StringCvt.OCT
150 :     (* end case *))
151 :     else StringCvt.DEC
152 :     in
153 :     case Int.scan rad SS.getc s of
154 :     NONE => raise BadAttrValue
155 :     | SOME (n, _) => n
156 :     end
157 :     handle _ => raise BadAttrValue
158 :    
159 :     fun cvtReal s = (#1 (valOf (Real.scan SS.getc (skipWS s))))
160 :     handle _ => raise BadAttrValue
161 :    
162 :     (* convert a string to a color_spec *)
163 :     fun cvtColorSpec s = let
164 :     val s = sstrip s
165 :     fun split n = let
166 :     fun extract i =
167 : monnier 8 #1(valOf(Word.scan StringCvt.HEX SS.getc (SS.slice(s, i, SOME n))))
168 : monnier 2 in
169 :     EXeneBase.CMS_RGB{
170 :     red = extract 1,
171 :     green = extract(1+n),
172 :     blue = extract(1+n+n)
173 :     }
174 :     end
175 :     in
176 :     if (SS.sub(s, 0) = #"#")
177 :     then (case (SS.size s)
178 :     of 4 => split 1 (* "#RGB" *)
179 :     | 7 => split 2 (* "#RRGGBB" *)
180 :     | 10 => split 3 (* "#RRRGGGBBB" *)
181 :     | 13 => split 4 (* "#RRRRGGGGBBBB" *)
182 :     | _ => raise BadAttrValue
183 :     (* end case *))
184 :     else EXeneBase.CMS_Name (SS.string s)
185 :     end
186 :     handle _ => raise BadAttrValue
187 :    
188 :     (* convert between strings and horizontal alignments *)
189 :     fun cvtHAlign "left" = WidgetBase.HLeft
190 :     | cvtHAlign "right" = WidgetBase.HRight
191 :     | cvtHAlign "center" = WidgetBase.HCenter
192 :     | cvtHAlign _ = WidgetBase.HCenter (* ??? *)
193 :    
194 :     fun halignToStr WidgetBase.HLeft = "left"
195 :     | halignToStr WidgetBase.HRight = "right"
196 :     | halignToStr WidgetBase.HCenter = "center"
197 :    
198 :     (* convert between strings and vertical alignments *)
199 :     fun cvtVAlign "top" = WidgetBase.VTop
200 :     | cvtVAlign "bottom" = WidgetBase.VBottom
201 :     | cvtVAlign "center" = WidgetBase.VCenter
202 :     | cvtVAlign _ = WidgetBase.VCenter (* ??? *)
203 :    
204 :     fun valignToStr WidgetBase.VTop = "top"
205 :     | valignToStr WidgetBase.VBottom = "bottom"
206 :     | valignToStr WidgetBase.VCenter = "center"
207 :    
208 :     (* convert strings and reliefs *)
209 :     fun cvtRelief "raised" = ThreeD.Raised
210 :     | cvtRelief "ridge" = ThreeD.Ridge
211 :     | cvtRelief "groove" = ThreeD.Groove
212 :     | cvtRelief "flat" = ThreeD.Flat
213 :     | cvtRelief "sunken" = ThreeD.Sunken
214 :     | cvtRelief _ = ThreeD.Sunken (* ??? *)
215 :    
216 :     fun reliefToStr (ThreeD.Flat) = "flat"
217 :     | reliefToStr (ThreeD.Raised) = "raised"
218 :     | reliefToStr (ThreeD.Ridge) = "ridge"
219 :     | reliefToStr (ThreeD.Groove) = "groove"
220 :     | reliefToStr (ThreeD.Sunken) = "sunken"
221 :    
222 :     (* convert strings and arrow directions *)
223 :     fun cvtArrowDir "down" = WidgetBase.AD_Down
224 :     | cvtArrowDir "left" = WidgetBase.AD_Left
225 :     | cvtArrowDir "right" = WidgetBase.AD_Right
226 :     | cvtArrowDir _ = WidgetBase.AD_Up (* ??? *)
227 :    
228 :     fun arrowDirToStr WidgetBase.AD_Down = "down"
229 :     | arrowDirToStr WidgetBase.AD_Left = "left"
230 :     | arrowDirToStr WidgetBase.AD_Right = "right"
231 :     | arrowDirToStr WidgetBase.AD_Up = "up"
232 :    
233 :     (* convert strings and gravity *)
234 :     fun cvtGravity "north" = WidgetBase.North
235 :     | cvtGravity "south" = WidgetBase.South
236 :     | cvtGravity "east" = WidgetBase.East
237 :     | cvtGravity "west" = WidgetBase.West
238 :     | cvtGravity "northeast" = WidgetBase.NorthEast
239 :     | cvtGravity "northwest" = WidgetBase.NorthWest
240 :     | cvtGravity "southeast" = WidgetBase.SouthEast
241 :     | cvtGravity "southwest" = WidgetBase.SouthWest
242 :     | cvtGravity _ = WidgetBase.Center (* ??? *)
243 :    
244 :     fun gravityToStr WidgetBase.North = "north"
245 :     | gravityToStr WidgetBase.South = "south"
246 :     | gravityToStr WidgetBase.East = "east"
247 :     | gravityToStr WidgetBase.West = "west"
248 :     | gravityToStr WidgetBase.NorthEast = "northeast"
249 :     | gravityToStr WidgetBase.NorthWest = "northwest"
250 :     | gravityToStr WidgetBase.SouthEast = "southeast"
251 :     | gravityToStr WidgetBase.SouthWest = "southwest"
252 :     | gravityToStr WidgetBase.Center = "center"
253 :    
254 :     val colorFmt = F.format "#%04x%04x%04x"
255 :     fun colorToStr c = let
256 :     val EXeneBase.RGB{red,blue,green} = EXeneBase.rgbOfColor c
257 :     in colorFmt [F.WORD red, F.WORD green, F.WORD blue] end
258 :     fun colorSpecToStr (EXeneBase.CMS_RGB{red,green,blue}) =
259 :     colorFmt [F.WORD red, F.WORD green, F.WORD blue]
260 :     | colorSpecToStr _ = raise NoConversion
261 :    
262 :     (* convert a string to a std_cursor - FIX: better encoding *)
263 :     fun cvtStdCursor name =
264 :     case strip name
265 :     of "x_cursor" => StdCursor.x_cursor
266 :     | "arrow" => StdCursor.arrow
267 :     | "based_arrow_down" => StdCursor.based_arrow_down
268 :     | "based_arrow_up" => StdCursor.based_arrow_up
269 :     | "boat" => StdCursor.boat
270 :     | "bogosity" => StdCursor.bogosity
271 :     | "bottom_left_corner" => StdCursor.bottom_left_corner
272 :     | "bottom_right_corner" => StdCursor.bottom_right_corner
273 :     | "bottom_side" => StdCursor.bottom_side
274 :     | "bottom_tee" => StdCursor.bottom_tee
275 :     | "box_spiral" => StdCursor.box_spiral
276 :     | "center_ptr" => StdCursor.center_ptr
277 :     | "circle" => StdCursor.circle
278 :     | "clock" => StdCursor.clock
279 :     | "coffee_mug" => StdCursor.coffee_mug
280 :     | "cross" => StdCursor.cross
281 :     | "cross_reverse" => StdCursor.cross_reverse
282 :     | "crosshair" => StdCursor.crosshair
283 :     | "diamond_cross" => StdCursor.diamond_cross
284 :     | "dot" => StdCursor.dot
285 :     | "dotbox" => StdCursor.dotbox
286 :     | "double_arrow" => StdCursor.double_arrow
287 :     | "draft_large" => StdCursor.draft_large
288 :     | "draft_small" => StdCursor.draft_small
289 :     | "draped_box" => StdCursor.draped_box
290 :     | "exchange" => StdCursor.exchange
291 :     | "fleur" => StdCursor.fleur
292 :     | "gobbler" => StdCursor.gobbler
293 :     | "gumby" => StdCursor.gumby
294 :     | "hand1" => StdCursor.hand1
295 :     | "hand2" => StdCursor.hand2
296 :     | "heart" => StdCursor.heart
297 :     | "icon" => StdCursor.icon
298 :     | "iron_cross" => StdCursor.iron_cross
299 :     | "left_ptr" => StdCursor.left_ptr
300 :     | "left_side" => StdCursor.left_side
301 :     | "left_tee" => StdCursor.left_tee
302 :     | "leftbutton" => StdCursor.leftbutton
303 :     | "ll_angle" => StdCursor.ll_angle
304 :     | "lr_angle" => StdCursor.lr_angle
305 :     | "man" => StdCursor.man
306 :     | "middlebutton" => StdCursor.middlebutton
307 :     | "mouse" => StdCursor.mouse
308 :     | "pencil" => StdCursor.pencil
309 :     | "pirate" => StdCursor.pirate
310 :     | "plus" => StdCursor.plus
311 :     | "question_arrow" => StdCursor.question_arrow
312 :     | "right_ptr" => StdCursor.right_ptr
313 :     | "right_side" => StdCursor.right_side
314 :     | "right_tee" => StdCursor.right_tee
315 :     | "rightbutton" => StdCursor.rightbutton
316 :     | "rtl_logo" => StdCursor.rtl_logo
317 :     | "sailboat" => StdCursor.sailboat
318 :     | "sb_down_arrow" => StdCursor.sb_down_arrow
319 :     | "sb_h_double_arrow" => StdCursor.sb_h_double_arrow
320 :     | "sb_left_arrow" => StdCursor.sb_left_arrow
321 :     | "sb_right_arrow" => StdCursor.sb_right_arrow
322 :     | "sb_up_arrow" => StdCursor.sb_up_arrow
323 :     | "sb_v_double_arrow" => StdCursor.sb_v_double_arrow
324 :     | "shuttle" => StdCursor.shuttle
325 :     | "sizing" => StdCursor.sizing
326 :     | "spider" => StdCursor.spider
327 :     | "spraycan" => StdCursor.spraycan
328 :     | "star" => StdCursor.star
329 :     | "target" => StdCursor.target
330 :     | "tcross" => StdCursor.tcross
331 :     | "top_left_arrow" => StdCursor.top_left_arrow
332 :     | "top_left_corner" => StdCursor.top_left_corner
333 :     | "top_right_corner" => StdCursor.top_right_corner
334 :     | "top_side" => StdCursor.top_side
335 :     | "top_tee" => StdCursor.top_tee
336 :     | "trek" => StdCursor.trek
337 :     | "ul_angle" => StdCursor.ul_angle
338 :     | "umbrella" => StdCursor.umbrella
339 :     | "ur_angle" => StdCursor.ur_angle
340 :     | "watch" => StdCursor.watch
341 :     | "xterm" => StdCursor.xterm
342 :     | _ => raise BadAttrValue
343 :    
344 :     (* convert a string to the specified kind of style attribute value;
345 :     * this raises BadAttrValue if the string has the wrong format.
346 :     *)
347 :     fun cvtString {scr,tilef} = let
348 :     open EXeneBase
349 :     val openFont = Font.openFont (displayOfScr scr)
350 :     fun cvtTile s = (tilef (strip s)) handle _ => raise BadAttrValue
351 :     fun cvtFont s = (openFont(strip s)) handle _ => raise BadAttrValue
352 :     fun cvtCursor s = (stdCursor (displayOfScr scr) (cvtStdCursor s))
353 :     handle _ => raise BadAttrValue
354 :     val colorOfScr = EXeneBase.colorOfScr scr
355 :     fun cvt (value, AT_Str) = AV_Str value
356 :     | cvt (value, AT_Int) = AV_Int(cvtInt value)
357 :     | cvt (value, AT_Real) = AV_Real(cvtReal value)
358 :     | cvt (value, AT_Bool) = AV_Bool(cvtBool value)
359 :     | cvt (value, AT_Font) = AV_Font(cvtFont value)
360 :     | cvt (value, AT_Color) = AV_Color(colorOfScr(cvtColorSpec value))
361 :     | cvt (value, AT_ColorSpec) = AV_ColorSpec(cvtColorSpec value)
362 :     | cvt (value, AT_Tile) = AV_Tile(cvtTile value)
363 :     | cvt (value, AT_Cursor) = AV_Cursor(cvtCursor value)
364 :     | cvt (value, AT_HAlign) = AV_HAlign(cvtHAlign value)
365 :     | cvt (value, AT_VAlign) = AV_VAlign(cvtVAlign value)
366 :     | cvt (value, AT_Relief) = AV_Relief(cvtRelief value)
367 :     | cvt (value, AT_ArrowDir) = AV_ArrowDir(cvtArrowDir value)
368 :     | cvt (value, AT_Gravity) = AV_Gravity(cvtGravity value)
369 :     in
370 :     cvt
371 :     end (* cvtString *)
372 :    
373 :     fun mkString (AV_Str s) = s
374 :     | mkString (AV_Int i) = Int.toString i
375 :     | mkString (AV_Real r) = Real.fmt (StringCvt.SCI (SOME 6)) r
376 :     | mkString (AV_Bool b) = Bool.toString b
377 :     | mkString (AV_Color c) = colorToStr c
378 :     | mkString (AV_ColorSpec c) = colorSpecToStr c
379 :     | mkString (AV_HAlign a) = halignToStr a
380 :     | mkString (AV_VAlign a) = valignToStr a
381 :     | mkString (AV_Relief r) = reliefToStr r
382 :     | mkString (AV_ArrowDir a) = arrowDirToStr a
383 :     | mkString (AV_Gravity a) = gravityToStr a
384 :     | mkString (AV_NoValue) = "NoValue"
385 :     | mkString _ = raise NoConversion
386 :    
387 :     fun cvtAttrValue (ctxt as {scr,...}) = let
388 :     open EXeneBase
389 :     val cvtString = cvtString ctxt
390 :     fun cvtCursor sc = (stdCursor (displayOfScr scr) sc)
391 :     handle _ => raise BadAttrValue
392 :     fun cvt (AV_Str s, ty) = cvtString (s,ty)
393 :     | cvt (v, AT_Str) = AV_Str(mkString v)
394 :     | cvt (v as AV_Int _, AT_Int) = v
395 :     | cvt (AV_Int i, AT_Real) = AV_Real(real i)
396 :     | cvt (v as AV_Real _, AT_Real) = v
397 :     | cvt (AV_Real r, AT_Int) = AV_Int (Real.trunc r) (* ??? *)
398 :     | cvt (v as AV_Bool _, AT_Bool) = v
399 :     | cvt (v as AV_Font _, AT_Font) = v
400 :     | cvt (v as AV_Color _, AT_Color) = v
401 :     | cvt (v as AV_ColorSpec _, AT_ColorSpec) = v
402 :     | cvt (AV_ColorSpec c, AT_Color) =
403 :     AV_Color(EXeneBase.colorOfScr scr c)
404 :     | cvt (v as AV_Tile _, AT_Tile) = v
405 :     | cvt (v as AV_Cursor _, AT_Cursor) = v
406 :     | cvt (v as AV_HAlign _, AT_HAlign) = v
407 :     | cvt (v as AV_VAlign _, AT_VAlign) = v
408 :     | cvt (v as AV_Relief _, AT_Relief) = v
409 :     | cvt (v as AV_ArrowDir _, AT_ArrowDir) = v
410 :     | cvt (v as AV_Gravity _, AT_Gravity) = v
411 :     | cvt _ = raise NoConversion
412 :     in
413 :     cvt
414 :     end (* cvtAttrValue *)
415 :    
416 :     fun getInt (AV_Int i) = i | getInt _ = raise BadAttrValue
417 :     fun getReal (AV_Real r) = r | getReal _ = raise BadAttrValue
418 :     fun getBool (AV_Bool b) = b | getBool _ = raise BadAttrValue
419 :     fun getString (AV_Str s) = s | getString _ = raise BadAttrValue
420 :     fun getColor (AV_Color c) = c | getColor _ = raise BadAttrValue
421 :     fun getColorSpec (AV_ColorSpec c) = c | getColorSpec _ = raise BadAttrValue
422 :     fun getFont (AV_Font f) = f | getFont _ = raise BadAttrValue
423 :     fun getTile (AV_Tile x) = x | getTile _ = raise BadAttrValue
424 :     fun getCursor (AV_Cursor x) = x | getCursor _ = raise BadAttrValue
425 :     fun getHAlign (AV_HAlign x) = x | getHAlign _ = raise BadAttrValue
426 :     fun getVAlign (AV_VAlign x) = x | getVAlign _ = raise BadAttrValue
427 :     fun getRelief (AV_Relief x) = x | getRelief _ = raise BadAttrValue
428 :     fun getArrowDir (AV_ArrowDir x) = x | getArrowDir _ = raise BadAttrValue
429 :     fun getGravity (AV_Gravity x) = x | getGravity _ = raise BadAttrValue
430 :    
431 :     fun wrap f v = (SOME(f v)) handle _ => NONE
432 :     val getIntOpt = wrap getInt
433 :     val getRealOpt = wrap getReal
434 :     val getBoolOpt = wrap getBool
435 :     val getStringOpt = wrap getString
436 :     val getColorOpt = wrap getColor
437 :     val getColorSpecOpt = wrap getColorSpec
438 :     val getFontOpt = wrap getFont
439 :     val getTileOpt = wrap getTile
440 :     val getCursorOpt = wrap getCursor
441 :     val getHAlignOpt = wrap getHAlign
442 :     val getVAlignOpt = wrap getVAlign
443 :     val getReliefOpt = wrap getRelief
444 :     val getArrowDirOpt = wrap getArrowDir
445 :     val getGravityOpt = wrap getGravity
446 :    
447 :     end (* Attrs *)

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0