|
14
|
1 ;;; css.el -- Cascading Style Sheet parser
|
|
|
2 ;; Author: wmperry
|
|
26
|
3 ;; Created: 1997/02/20 00:47:21
|
|
|
4 ;; Version: 1.28
|
|
14
|
5 ;; Keywords:
|
|
|
6
|
|
|
7 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
8 ;;; Copyright (c) 1996 by William M. Perry (wmperry@cs.indiana.edu)
|
|
16
|
9 ;;; Copyright (c) 1996, 1997 Free Software Foundation, Inc.
|
|
14
|
10 ;;;
|
|
|
11 ;;; This file is not part of GNU Emacs, but the same permissions apply.
|
|
|
12 ;;;
|
|
|
13 ;;; GNU Emacs 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 ;;; GNU Emacs 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 GNU Emacs; see the file COPYING. If not, write to the
|
|
|
25 ;;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
26 ;;; Boston, MA 02111-1307, USA.
|
|
|
27 ;;;
|
|
|
28 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
29
|
|
|
30 (eval-and-compile
|
|
|
31 (require 'cl)
|
|
|
32 (require 'font)
|
|
|
33 )
|
|
|
34
|
|
|
35 ;; CBI = Cant Be Implemented - due to limitations in emacs/xemacs
|
|
|
36 ;; NYI = Not Yet Implemented - due to limitations of space/time
|
|
|
37 ;; NYPI = Not Yet Partially Implemented - possible partial support, eventually
|
|
|
38
|
|
|
39 (defconst css-properties
|
|
|
40 '(;; Property name Inheritable? Type of data
|
|
16
|
41 ;; Base CSS level 1 properties: http://www.w3.org/pub/WWW/TR/REC-CSS1
|
|
|
42 ;; Font properties, Section 5.2
|
|
|
43 [font-family t string-list]
|
|
|
44 [font-style t symbol]
|
|
|
45 [font-variant t symbol]
|
|
|
46 [font-weight t weight]
|
|
|
47 [font-size t length]
|
|
14
|
48 [font nil font]
|
|
16
|
49
|
|
|
50 ;; Color and background properties, Section 5.3
|
|
|
51 [color t color]
|
|
|
52 [background nil color-shorthand]
|
|
|
53 [background-color nil color]
|
|
|
54 [background-image nil url] ; NYI
|
|
|
55 [background-repeat nil symbol] ; CBI
|
|
|
56 [background-attachment nil symbol] ; CBI
|
|
|
57 [background-position nil symbol] ; CBI
|
|
|
58
|
|
|
59 ;; Text properties, Section 5.4
|
|
|
60 [word-spacing t length] ; CBI
|
|
|
61 [letter-spacing t length] ; CBI
|
|
|
62 [text-decoration t symbol-list]
|
|
|
63 [vertical-align nil symbol]
|
|
|
64 [text-transform t symbol]
|
|
14
|
65 [text-align t symbol]
|
|
|
66 [text-indent t length] ; NYI
|
|
|
67 [line-height t length] ; CBI
|
|
16
|
68
|
|
|
69 ;; Box properties, Section 5.5
|
|
|
70 [margin nil boundary-shorthand]
|
|
|
71 [margin-left nil length]
|
|
|
72 [margin-right nil length]
|
|
|
73 [margin-top nil length]
|
|
|
74 [margin-bottom nil length]
|
|
|
75 [padding nil boundary-shorthand]
|
|
|
76 [padding-left nil length]
|
|
|
77 [padding-right nil length]
|
|
|
78 [padding-top nil length]
|
|
|
79 [padding-bottom nil length]
|
|
|
80 [border nil border-shorthand]
|
|
14
|
81 [border-left nil border]
|
|
|
82 [border-right nil border]
|
|
|
83 [border-top nil border]
|
|
|
84 [border-bottom nil border]
|
|
16
|
85 [border-top-width nil nil]
|
|
|
86 [border-right-width nil nil]
|
|
|
87 [border-bottom-width nil nil]
|
|
|
88 [border-left-width nil nil]
|
|
|
89 [border-width nil boundary-shorthand]
|
|
|
90 [border-color nil color]
|
|
|
91 [border-style nil symbol]
|
|
14
|
92 [width nil length] ; NYPI
|
|
|
93 [height nil length] ; NYPI
|
|
|
94 [float nil symbol]
|
|
|
95 [clear nil symbol]
|
|
16
|
96
|
|
|
97 ;; Classification properties, Section 5.6
|
|
14
|
98 [display nil symbol]
|
|
16
|
99 [list-style-type t symbol]
|
|
|
100 [list-style-image t url]
|
|
|
101 [list-style-position t symbol]
|
|
|
102 [list-style nil list-style]
|
|
14
|
103 [white-space t symbol]
|
|
|
104
|
|
16
|
105 ;; These are for specifying speech properties (ACSS-style)
|
|
|
106 ;; http://www.w3.org/pub/WWW/Style/CSS/Speech/NOTE-ACSS
|
|
|
107
|
|
|
108 ;; General audio properties, Section 3
|
|
|
109 [volume t string] ; Needs its own type?
|
|
|
110 [pause-before nil time]
|
|
|
111 [pause-after nil time]
|
|
|
112 [pause nil pause]
|
|
|
113 [cue-before nil string]
|
|
|
114 [cue-after nil string]
|
|
|
115 [cue-during nil string]
|
|
|
116 [cue nil string] ; Needs its own type?
|
|
|
117
|
|
|
118 ;; Spatial properties, Section 4
|
|
|
119 [azimuth t angle]
|
|
|
120 [elevation t elevation]
|
|
|
121
|
|
|
122 ;; Speech properties, Section 5
|
|
|
123 [speed t string]
|
|
|
124 [voice-family t string-list]
|
|
|
125 [pitch t string]
|
|
|
126 [pitch-range t percentage]
|
|
|
127 [stress t percentage]
|
|
|
128 [richness t percentage]
|
|
|
129 [speak-punctuation t symbol]
|
|
|
130 [speak-date t symbol]
|
|
|
131 [speak-numeral t symbol]
|
|
|
132 [speak-time t symbol]
|
|
|
133
|
|
|
134 ;; Proposed printing extensions
|
|
|
135 ;; http://www.w3.org/pub/WWW/Style/Group/WD-PRINT-961220
|
|
|
136 ;; These apply only to pages (@page directive)
|
|
|
137 [size nil symbol]
|
|
|
138 [orientation nil symbol]
|
|
|
139 [margin-inside nil length]
|
|
|
140 ;; These apply to the document
|
|
|
141 [page-break-before nil symbol]
|
|
|
142 [page-break-after nil symbol]
|
|
|
143
|
|
|
144 ;; These are for specifying speech properties (Raman-style)
|
|
14
|
145 [voice-family t string]
|
|
|
146 [gain t integer]
|
|
|
147 [left-volume t integer]
|
|
|
148 [right-volume t integer]
|
|
|
149 [pitch t integer]
|
|
|
150 [pitch-range t integer]
|
|
|
151 [stress t integer]
|
|
|
152 [richness t integer]
|
|
|
153 )
|
|
|
154 "A description of the various CSS properties and how to interpret them.")
|
|
|
155
|
|
16
|
156 (put 'font 'css-shorthand t)
|
|
|
157 (put 'background 'css-shorthand t)
|
|
|
158 (put 'margin 'css-shorthand t)
|
|
|
159 (put 'padding 'css-shorthand t)
|
|
|
160 (put 'border 'css-shorthand t)
|
|
|
161 (put 'list-style 'css-shorthand t)
|
|
|
162
|
|
14
|
163 (mapcar
|
|
|
164 (lambda (entry)
|
|
|
165 (put (aref entry 0) 'css-inherit (aref entry 1))
|
|
|
166 (put (aref entry 0) 'css-type (aref entry 2)))
|
|
|
167 css-properties)
|
|
|
168
|
|
|
169 (defconst css-weights
|
|
|
170 '(nil ;never used
|
|
|
171 :extra-light
|
|
|
172 :light
|
|
|
173 :demi-light
|
|
|
174 :medium
|
|
|
175 :normal
|
|
|
176 :demi-bold
|
|
|
177 :bold
|
|
|
178 :extra-bold
|
|
|
179 )
|
|
|
180 "List of CSS font weights.")
|
|
|
181
|
|
|
182 (defvar css-syntax-table
|
|
|
183 (copy-syntax-table emacs-lisp-mode-syntax-table)
|
|
|
184 "The syntax table for parsing stylesheets")
|
|
|
185
|
|
|
186 (modify-syntax-entry ?' "\"" css-syntax-table)
|
|
|
187 (modify-syntax-entry ?` "\"" css-syntax-table)
|
|
|
188 (modify-syntax-entry ?{ "(" css-syntax-table)
|
|
|
189 (modify-syntax-entry ?} ")" css-syntax-table)
|
|
|
190
|
|
|
191 (eval-when-compile
|
|
|
192 (defvar css-scratch-val nil)
|
|
|
193 (defvar css-scratch-id nil)
|
|
|
194 (defvar css-scratch-class nil)
|
|
|
195 (defvar css-scratch-possibles nil)
|
|
|
196 (defvar css-scratch-current nil)
|
|
|
197 (defvar css-scratch-classes nil)
|
|
|
198 (defvar css-scratch-class-match nil)
|
|
|
199 (defvar css-scratch-current-rule nil)
|
|
|
200 (defvar css-scratch-current-value nil)
|
|
|
201 )
|
|
|
202
|
|
|
203 (defconst css-running-xemacs
|
|
|
204 (string-match "XEmacs" (emacs-version))
|
|
|
205 "Whether we are running in XEmacs or not.")
|
|
|
206
|
|
|
207 (defsubst css-replace-regexp (regexp to-string)
|
|
|
208 (goto-char (point-min))
|
|
|
209 (while (re-search-forward regexp nil t)
|
|
|
210 (replace-match to-string t nil)))
|
|
|
211
|
|
|
212 (defun css-contextual-match (rule stack)
|
|
|
213 (let ((ancestor)
|
|
|
214 (p-args)
|
|
|
215 (p-class)
|
|
|
216 (matched t))
|
|
|
217 (while rule
|
|
|
218 (setq ancestor (assq (caar rule) stack))
|
|
|
219 (if (not ancestor)
|
|
|
220 (setq rule nil
|
|
|
221 matched nil)
|
|
|
222 (setq p-args (cdr ancestor)
|
|
|
223 p-class (or (cdr-safe (assq 'class p-args)) t))
|
|
|
224 (if (not (equal p-class (cdar rule)))
|
|
|
225 (setq matched nil
|
|
|
226 rule nil)))
|
|
|
227 (setq rule (cdr rule)))
|
|
|
228 matched))
|
|
|
229
|
|
|
230 (defsubst css-get-internal (tag args)
|
|
|
231 (declare (special tag sheet element-stack default))
|
|
|
232 (setq css-scratch-id (or (cdr-safe (assq 'id args))
|
|
|
233 (cdr-safe (assq 'name args)))
|
|
|
234 css-scratch-class (or (cdr-safe (assq 'class args)) t)
|
|
|
235 css-scratch-possibles (cl-gethash tag sheet))
|
|
|
236 (while css-scratch-possibles
|
|
|
237 (setq css-scratch-current (car css-scratch-possibles)
|
|
|
238 css-scratch-current-rule (car css-scratch-current)
|
|
|
239 css-scratch-current-value (cdr css-scratch-current)
|
|
|
240 css-scratch-classes (if (listp (car css-scratch-current-rule))
|
|
|
241 (cdar css-scratch-current-rule)
|
|
|
242 (cdr css-scratch-current-rule))
|
|
|
243 css-scratch-class-match t
|
|
|
244 css-scratch-possibles (cdr css-scratch-possibles))
|
|
|
245 (if (eq t css-scratch-classes)
|
|
|
246 (setq css-scratch-classes nil))
|
|
|
247 (if (eq t css-scratch-class)
|
|
|
248 (setq css-scratch-class nil))
|
|
|
249 (while css-scratch-classes
|
|
|
250 (if (not (member (pop css-scratch-classes) css-scratch-class))
|
|
|
251 (setq css-scratch-class-match nil
|
|
|
252 css-scratch-classes nil)))
|
|
|
253 (cond
|
|
|
254 ((and (listp (car css-scratch-current-rule)) css-scratch-class-match)
|
|
|
255 ;; Contextual!
|
|
|
256 (setq css-scratch-current-rule (cdr css-scratch-current-rule))
|
|
|
257 (if (css-contextual-match css-scratch-current-rule element-stack)
|
|
|
258 (setq css-scratch-val
|
|
|
259 (append css-scratch-val css-scratch-current-value)))
|
|
|
260 )
|
|
|
261 (css-scratch-class-match
|
|
|
262 (setq css-scratch-val (append css-scratch-val css-scratch-current-value))
|
|
|
263 )
|
|
|
264 (t
|
|
|
265 nil))
|
|
|
266 )
|
|
|
267 )
|
|
|
268
|
|
|
269 (defsubst css-get (tag args &optional sheet element-stack)
|
|
|
270 (setq css-scratch-val nil
|
|
|
271 css-scratch-class (or (cdr-safe (assq 'class args)) t))
|
|
|
272
|
|
|
273 ;; check for things without the class
|
|
|
274 (if (listp css-scratch-class)
|
|
|
275 (css-get-internal tag nil))
|
|
|
276
|
|
|
277 ;; check for global class values
|
|
|
278 (css-get-internal '*document args)
|
|
|
279
|
|
|
280 ;; Now check for things with the class - they will be stuck on the front
|
|
|
281 ;; of the list, which will mean we do the right thing
|
|
|
282 (css-get-internal tag args)
|
|
|
283
|
|
|
284 ;; Defaults are up to the calling application to provide
|
|
|
285 css-scratch-val)
|
|
|
286
|
|
|
287 (defun css-ancestor-get (info ancestors sheet)
|
|
|
288 ;; Inheritable property, check ancestors
|
|
|
289 (let (cur)
|
|
|
290 (while ancestors
|
|
|
291 (setq cur (car ancestors)
|
|
|
292 css-scratch-val (css-get info (car cur) (cdr cur) sheet)
|
|
|
293 ancestors (if css-scratch-val nil (cdr ancestors)))))
|
|
|
294 css-scratch-val)
|
|
|
295
|
|
|
296 (defun css-split-selector (tag)
|
|
|
297 ;; Return a list
|
|
|
298 (cond
|
|
|
299 ((string-match " " tag) ; contextual
|
|
|
300 (let ((tags (split-string tag "[ \t]+"))
|
|
|
301 (result nil))
|
|
|
302 (while tags
|
|
|
303 (setq result (cons (css-split-selector (car tags)) result)
|
|
|
304 tags (cdr tags)))
|
|
|
305 result))
|
|
|
306 ((string-match "[:\\.]" tag)
|
|
|
307 (let ((tag (if (= (match-beginning 0) 0)
|
|
|
308 '*document
|
|
|
309 (intern (downcase (substring tag 0 (match-beginning 0))))))
|
|
|
310 (rest (substring tag (match-beginning 0) nil))
|
|
|
311 (classes nil))
|
|
|
312 (while (string-match "^[:\\.][^:\\.]+" rest)
|
|
|
313 (if (= ?. (aref rest 0))
|
|
|
314 (setq classes (cons (substring rest 1 (match-end 0)) classes))
|
|
|
315 (setq classes (cons (substring rest 0 (match-end 0)) classes)))
|
|
|
316 (setq rest (substring rest (match-end 0) nil)))
|
|
|
317 (setq classes (sort classes 'string-lessp))
|
|
|
318 (cons tag classes)))
|
|
|
319 ((string-match "^#" tag) ; id selector
|
|
|
320 (cons '*document tag))
|
|
|
321 (t
|
|
|
322 (cons (intern (downcase tag)) t)
|
|
|
323 )
|
|
|
324 )
|
|
|
325 )
|
|
|
326
|
|
|
327 (defun css-applies-to (st nd)
|
|
|
328 (let ((results nil)
|
|
|
329 (save-pos nil))
|
|
|
330 (narrow-to-region st nd)
|
|
|
331 (goto-char st)
|
|
|
332 (skip-chars-forward " \t\r\n")
|
|
|
333 (while (not (eobp))
|
|
|
334 (setq save-pos (point))
|
|
|
335 (skip-chars-forward "^,")
|
|
|
336 (skip-chars-backward " \r\t\n")
|
|
|
337 (setq results (cons (css-split-selector
|
|
|
338 (buffer-substring save-pos (point))) results))
|
|
|
339 (skip-chars-forward ", \t\r\n"))
|
|
|
340 (widen)
|
|
|
341 results))
|
|
|
342
|
|
|
343 (defun css-split-font-shorthand (font)
|
|
|
344 ;; [<font-weight> || <font-style>]? <font-size> [ / <line-height> ]? <font-family>
|
|
|
345 (let (weight size height family retval)
|
|
|
346 (if (not (string-match " *\\([0-9.]+[^ /]+\\)" font))
|
|
|
347 (error "Malformed font shorthand: %s" font))
|
|
|
348 (setq weight (if (/= 0 (match-beginning 0))
|
|
|
349 (substring font 0 (match-beginning 0)))
|
|
|
350 size (match-string 1 font)
|
|
|
351 font (substring font (match-end 0) nil))
|
|
|
352 (if (string-match " */ *\\([^ ]+\\) *" font)
|
|
|
353 ;; they specified a line-height as well
|
|
|
354 (setq height (match-string 1 font)
|
|
|
355 family (substring font (match-end 0) nil))
|
|
|
356 (if (string-match "^[ \t]+" font)
|
|
|
357 (setq family (substring font (match-end 0) nil))
|
|
|
358 (setq family font)))
|
|
26
|
359 (if weight
|
|
|
360 (push (cons 'font-weight (css-expand-value 'weight weight)) retval))
|
|
|
361 (if size
|
|
|
362 (push (cons 'font-size (css-expand-length size)) retval))
|
|
|
363 (if height
|
|
|
364 (push (cons 'line-height (css-expand-length height)) retval))
|
|
|
365 (if family
|
|
|
366 (push (cons 'font-family (css-expand-value 'string-list family)) retval))
|
|
14
|
367 retval))
|
|
|
368
|
|
|
369 (defun css-expand-length (spec)
|
|
|
370 (cond
|
|
|
371 ((not (stringp spec)) spec)
|
|
|
372 ((string-equal spec "auto") nil)
|
|
20
|
373 ((string-match "\\([+-]?\\([0-9]+\\|[0-9]*\\.[0-9]+\\)\\)%" spec) ; A percentage
|
|
14
|
374 nil)
|
|
20
|
375 ((string-match "\\([+-]?\\([0-9]+\\|[0-9]*\\.[0-9]+\\)\\)e[mx]" spec) ; Character based
|
|
|
376 (max 0 (round (string-to-number (match-string 1 spec)))))
|
|
14
|
377 (t
|
|
|
378 (truncate (font-spatial-to-canonical spec)))
|
|
|
379 )
|
|
|
380 )
|
|
|
381
|
|
|
382 (defsubst css-unhex-char (x)
|
|
|
383 (if (> x ?9)
|
|
|
384 (if (>= x ?a)
|
|
|
385 (+ 10 (- x ?a))
|
|
|
386 (+ 10 (- x ?A)))
|
|
|
387 (- x ?0)))
|
|
|
388
|
|
|
389 (defsubst css-pow (x n)
|
|
|
390 (apply '* (make-list n x)))
|
|
|
391
|
|
|
392 (defun css-unhex (x)
|
|
|
393 (let ((ord (length x))
|
|
|
394 (rval 0))
|
|
|
395 (while (> ord 0)
|
|
|
396 (setq rval (+ rval
|
|
|
397 (* (css-pow 16 (- (length x) ord))
|
|
|
398 (css-unhex-char (aref x (1- ord)))))
|
|
|
399 ord (1- ord)))
|
|
|
400 rval))
|
|
|
401
|
|
16
|
402 (defmacro css-symbol-list-as-regexp (&rest keys)
|
|
|
403 (` (eval-when-compile
|
|
|
404 (concat "^\\("
|
|
|
405 (mapconcat 'symbol-name
|
|
|
406 (quote (, keys))
|
|
|
407 "\\|") "\\)$"))))
|
|
|
408
|
|
14
|
409 (defun css-expand-color (color)
|
|
|
410 (cond
|
|
26
|
411 ((string-match "^\\(transparent\\|none\\)$" color)
|
|
|
412 (setq color nil))
|
|
14
|
413 ((string-match "^#" color)
|
|
|
414 (let (r g b)
|
|
|
415 (cond
|
|
|
416 ((string-match "^#...$" color)
|
|
|
417 ;; 3-char rgb spec, expand out to six chars by replicating
|
|
|
418 ;; digits, not adding zeros.
|
|
|
419 (setq r (css-unhex (make-string 2 (aref color 1)))
|
|
|
420 g (css-unhex (make-string 2 (aref color 2)))
|
|
|
421 b (css-unhex (make-string 2 (aref color 3)))))
|
|
|
422 ((string-match "^#\\(..\\)\\(..\\)\\(..\\)$" color)
|
|
|
423 (setq r (css-unhex (match-string 1 color))
|
|
|
424 g (css-unhex (match-string 2 color))
|
|
|
425 b (css-unhex (match-string 3 color))))
|
|
|
426 (t
|
|
|
427 (setq color (substring color 1))
|
|
|
428 (let* ((n (/ (length color) 3))
|
|
|
429 (max (float (css-pow 16 n))))
|
|
|
430 (setq r (css-unhex (substring color 0 n))
|
|
|
431 g (css-unhex (substring color n (* n 2)))
|
|
|
432 b (css-unhex (substring color (* n 2) (* n 3)))
|
|
|
433 r (round (* (/ r max) 255))
|
|
|
434 g (round (* (/ g max) 255))
|
|
|
435 b (round (* (/ b max) 255))))))
|
|
|
436 (setq color (vector 'rgb r g b))))
|
|
|
437 ((string-match "^rgb *( *\\([0-9]+\\)[, ]+\\([0-9]+\\)[, ]+\\([0-9]+\\) *) *$" color)
|
|
|
438 ;; rgb(r,g,b) 0 - 255, cutting off at 255
|
|
|
439 (setq color (vector
|
|
|
440 'rgb
|
|
|
441 (min (string-to-int (match-string 1 color)) 255)
|
|
|
442 (min (string-to-int (match-string 2 color)) 255)
|
|
|
443 (min (string-to-int (match-string 3 color)) 255))))
|
|
|
444 ((string-match "^rgb *( *\\([0-9]+\\) *%[, ]+\\([0-9]+\\) *%[, ]+\\([0-9]+\\) *% *) *$" color)
|
|
|
445 ;; rgb(r%,g%,b%) 0 - 100%, cutting off at 100%
|
|
|
446 (let ((r (min (string-to-number (match-string 1 color)) 100.0))
|
|
|
447 (g (min (string-to-number (match-string 2 color)) 100.0))
|
|
|
448 (b (min (string-to-number (match-string 3 color)) 100.0)))
|
|
|
449 (setq r (round (* r 2.55))
|
|
|
450 g (round (* g 2.55))
|
|
|
451 b (round (* b 2.55))
|
|
|
452 color (vector 'rgb r g b))))
|
|
|
453 (t
|
|
|
454 ;; Hmmm... pass it through unmangled and hope the underlying
|
|
|
455 ;; windowing system can handle it.
|
|
|
456 )
|
|
|
457 )
|
|
|
458 color
|
|
|
459 )
|
|
|
460
|
|
|
461 (defun css-expand-value (type value)
|
|
16
|
462 (if value
|
|
|
463 (case type
|
|
|
464 (length ; CSS, Section 6.1
|
|
|
465 (setq value (css-expand-length value)))
|
|
|
466 (percentage ; CSS, Section 6.2
|
|
|
467 (setq value (/ (string-to-number value)
|
|
|
468 (if (fboundp 'float) (float 100) 1))))
|
|
|
469 (color ; CSS, Section 6.3
|
|
|
470 (setq value (css-expand-color value)))
|
|
|
471 (url ; CSS, Section 6.4
|
|
|
472 (declare (special url purl))
|
|
|
473 (if (string-match "url *(\\([^ )]+\\) *)" value)
|
|
|
474 (setq value (match-string 1 value)))
|
|
|
475 (if (string-match " *\\([^ ]+\\) *" value)
|
|
|
476 (setq value (match-string 1 value)))
|
|
|
477 (setq value (url-expand-file-name value (or url purl))))
|
|
|
478 (angle ; ACSS, Section 2.2.1
|
|
|
479 )
|
|
|
480 (time ; ACSS, Section 2.2.2
|
|
|
481 (let ((val (string-to-number value))
|
|
|
482 (units 'ms))
|
|
|
483 (if (string-match "^[0-9]+ *\\([a-zA-Z.]+\\)" value)
|
|
|
484 (setq units (intern (downcase (match-string 1 value)))))
|
|
|
485 (setq value (case units
|
|
|
486 ((s second seconds)
|
|
|
487 val)
|
|
|
488 ((min minute minutes)
|
|
|
489 (* val 60))
|
|
|
490 ((hr hour hours)
|
|
|
491 (* val 60 60))
|
|
|
492 ((day days)
|
|
|
493 (* val 24 60 60))
|
|
|
494 (otherwise
|
|
|
495 (/ val (float 1000)))))))
|
|
|
496 (elevation ; ACSS, Section 4.2
|
|
|
497 (if (string-match
|
|
|
498 (css-symbol-list-as-regexp below level above higher lower) value)
|
|
|
499 (setq value (intern (downcase (match-string value 1)))
|
|
|
500 value (case value
|
|
|
501 (below -90)
|
|
|
502 (above 90)
|
|
|
503 (level 0)
|
|
|
504 (higher 45)
|
|
|
505 (lower -45)
|
|
|
506 ))
|
|
|
507 (setq value (css-expand-value 'angle value))))
|
|
|
508 (color-shorthand ; CSS, Section 5.3.7
|
|
|
509 ;; color|image|repeat|attach|position
|
|
|
510 (let ((keys (split-string value " +"))
|
|
|
511 cur color image repeat attach position)
|
|
|
512 (while (setq cur (pop keys))
|
|
|
513 (cond
|
|
|
514 ((string-match "url" cur) ; Only image can have a URL
|
|
|
515 (setq image (css-expand-value 'url cur)))
|
|
|
516 ((string-match "%" cur) ; Only position can have a perc.
|
|
|
517 (setq position (css-expand-value 'percentage cur)))
|
|
|
518 ((string-match "repeat" cur) ; Only repeat
|
|
|
519 (setq repeat (intern (downcase cur))))
|
|
|
520 ((string-match "scroll\\|fixed" cur)
|
|
|
521 (setq attach (intern (downcase (substring cur
|
|
|
522 (match-beginning 0)
|
|
|
523 (match-end 0))))))
|
|
|
524 ((string-match (css-symbol-list-as-regexp
|
|
|
525 top center bottom left right) cur)
|
|
|
526 )
|
|
|
527 (t
|
|
26
|
528 (setq color (css-expand-value 'color cur)))))
|
|
16
|
529 (setq value (list (cons 'background-color color)
|
|
|
530 (cons 'background-image image)
|
|
|
531 (cons 'background-repeat repeat)
|
|
|
532 (cons 'background-attachment attach)
|
|
|
533 (cons 'background-position position)))))
|
|
|
534 (font ; CSS, Section 5.2.7
|
|
|
535 ;; [style | variant | weight]? size[/line-height]? family
|
|
|
536 (setq value (css-split-font-shorthand value)))
|
|
|
537 (border ; width | style | color
|
|
26
|
538 ;; FIXME
|
|
16
|
539 )
|
|
|
540 (border-shorthand ; width | style | color
|
|
26
|
541 ;; FIXME
|
|
16
|
542 )
|
|
|
543 (list-style ; CSS, Section 5.6.6
|
|
|
544 ;; keyword | position | url
|
|
|
545 (setq value (split-string value "[ ,]+"))
|
|
|
546 (if (= (length value) 1)
|
|
|
547 (setq value (list (cons 'list-style-type
|
|
|
548 (intern (downcase (car value))))))
|
|
|
549 (setq value (list (cons 'list-style-type
|
|
|
550 (css-expand-value 'symbol (nth 0 value)))
|
|
|
551 (cons 'list-style-position
|
|
|
552 (css-expand-value 'symbol (nth 1 value)))
|
|
|
553 (cons 'list-style-image
|
|
|
554 (css-expand-value 'url (nth 2 value)))))))
|
|
|
555 (boundary-shorthand ; CSS, Section 5.5.x
|
|
|
556 ;; length|percentage|auto {1,4}
|
|
|
557 (setq value (split-string value "[ ,]+"))
|
|
14
|
558 (let* ((top (intern (format "%s-top" type)))
|
|
|
559 (bottom (intern (format "%s-bottom" type)))
|
|
|
560 (left (intern (format "%s-left" type)))
|
|
|
561 (right (intern (format "%s-right" type))))
|
|
16
|
562 (setq top (cons top (css-expand-value (get top 'css-type)
|
|
|
563 (nth 0 value)))
|
|
|
564 right (cons right (css-expand-value (get right 'css-type)
|
|
|
565 (nth 1 value)))
|
|
|
566 bottom (cons bottom (css-expand-value (get bottom 'css-type)
|
|
|
567 (nth 2 value)))
|
|
|
568 left (cons left (css-expand-value (get left 'css-type)
|
|
|
569 (nth 3 value)))
|
|
|
570 value (list top right bottom left))))
|
|
|
571 (weight ; CSS, Section 5.2.5
|
|
|
572 ;; normal|bold|bolder|lighter|[1-9]00
|
|
|
573 (cond
|
|
|
574 ((string-match "^[0-9]+" value)
|
|
|
575 (setq value (/ (string-to-number value) 100)
|
|
|
576 value (or (nth value css-weights) :bold)))
|
|
|
577 ((string-match (css-symbol-list-as-regexp normal bold bolder lighter)
|
|
|
578 value)
|
|
|
579 (setq value (intern (downcase (concat ":" value)))))
|
|
|
580 (t setq value (intern ":bold"))))
|
|
|
581
|
|
|
582 ;; The rest of these deal with how we handle things internally
|
|
|
583 ((symbol integer) ; Read it in
|
|
|
584 (setq value (read (downcase value))))
|
|
|
585 (symbol-list ; A space/comma delimited symlist
|
|
|
586 (setq value (downcase value)
|
|
|
587 value (split-string value "[ ,]+")
|
|
|
588 value (mapcar 'intern value)))
|
|
|
589 (string-list ; A space/comma delimited list
|
|
|
590 (setq value (split-string value " *, *")))
|
|
|
591 (otherwise ; Leave it as is
|
|
|
592 t)
|
|
|
593 )
|
|
14
|
594 )
|
|
|
595 value
|
|
|
596 )
|
|
|
597
|
|
|
598 (defun css-parse-args (st &optional nd)
|
|
|
599 ;; Return an assoc list of attribute/value pairs from a CSS style entry
|
|
|
600 (let (
|
|
|
601 name ; From name=
|
|
|
602 value ; its value
|
|
|
603 results ; Assoc list of results
|
|
|
604 name-pos ; Start of XXXX= position
|
|
|
605 val-pos ; Start of value position
|
|
26
|
606 (case-fold-search t)
|
|
14
|
607 )
|
|
|
608 (save-excursion
|
|
|
609 (if (stringp st)
|
|
|
610 (progn
|
|
|
611 (set-buffer (get-buffer-create " *css-style-temp*"))
|
|
|
612 (set-syntax-table css-syntax-table)
|
|
|
613 (erase-buffer)
|
|
|
614 (insert st)
|
|
|
615 (setq st (point-min)
|
|
|
616 nd (point-max)))
|
|
|
617 (set-syntax-table css-syntax-table))
|
|
|
618 (save-restriction
|
|
|
619 (narrow-to-region st nd)
|
|
|
620 (goto-char (point-min))
|
|
|
621 (while (not (eobp))
|
|
|
622 (skip-chars-forward ";, \n\t")
|
|
|
623 (setq name-pos (point))
|
|
|
624 (skip-chars-forward "^ \n\t:=,;")
|
|
|
625 (downcase-region name-pos (point))
|
|
|
626 (setq name (intern (buffer-substring name-pos (point))))
|
|
|
627 (skip-chars-forward " \t\n")
|
|
|
628 (if (not (eq (char-after (point)) ?:)) ; There is no value
|
|
|
629 (setq value nil)
|
|
|
630 (skip-chars-forward " \t\n:")
|
|
|
631 (setq val-pos (point)
|
|
|
632 value
|
|
|
633 (cond
|
|
|
634 ((or (= (or (char-after val-pos) 0) ?\")
|
|
|
635 (= (or (char-after val-pos) 0) ?'))
|
|
|
636 (buffer-substring (1+ val-pos)
|
|
|
637 (condition-case ()
|
|
|
638 (prog2
|
|
|
639 (forward-sexp 1)
|
|
|
640 (1- (point))
|
|
|
641 (skip-chars-forward "\""))
|
|
|
642 (error
|
|
|
643 (skip-chars-forward "^ \t\n")
|
|
|
644 (point)))))
|
|
|
645 (t
|
|
|
646 (buffer-substring val-pos
|
|
|
647 (progn
|
|
16
|
648 (skip-chars-forward "^;")
|
|
14
|
649 (skip-chars-backward " \t")
|
|
|
650 (point)))))))
|
|
|
651 (setq value (css-expand-value (get name 'css-type) value))
|
|
16
|
652 (if (get name 'css-shorthand)
|
|
14
|
653 (setq results (append value results))
|
|
|
654 (setq results (cons (cons name value) results)))
|
|
|
655 (skip-chars-forward ";, \n\t"))
|
|
|
656 results))))
|
|
|
657
|
|
16
|
658 (defun css-handle-media-directive (data active)
|
|
|
659 (let (type)
|
|
|
660 (if (string-match "\\([^ \t\r\n{]+\\)" data)
|
|
|
661 (setq type (intern (downcase (substring data (match-beginning 1)
|
|
|
662 (match-end 1))))
|
|
|
663 data (substring data (match-end 1)))
|
|
|
664 (setq type 'unknown))
|
|
|
665 (if (string-match "^[ \t\r\n]*{" data)
|
|
|
666 (setq data (substring data (match-end 0))))
|
|
|
667 (if (memq type active)
|
|
|
668 (save-excursion
|
|
|
669 (insert data)))))
|
|
|
670
|
|
|
671 (defun css-handle-import (data)
|
|
|
672 (let (url)
|
|
|
673 (setq url (css-expand-value 'url data))
|
|
|
674 (and url
|
|
|
675 (let ((url-working-buffer (generate-new-buffer-name " *styleimport*"))
|
|
|
676 (url-mime-accept-string
|
|
|
677 "text/css ; level=2")
|
|
|
678 (sheet nil))
|
|
|
679 (save-excursion
|
|
|
680 (set-buffer (get-buffer-create url-working-buffer))
|
|
|
681 (setq url-be-asynchronous nil)
|
|
|
682 (url-retrieve url)
|
|
|
683 (css-clean-buffer)
|
|
|
684 (setq sheet (buffer-string))
|
|
|
685 (set-buffer-modified-p nil)
|
|
|
686 (kill-buffer (current-buffer)))
|
|
|
687 (insert sheet)))))
|
|
14
|
688
|
|
|
689 (defun css-clean-buffer ()
|
|
|
690 ;; Nuke comments, etc.
|
|
|
691 (goto-char (point-min))
|
|
|
692 (let ((save-pos nil))
|
|
|
693 (while (search-forward "/*" nil t)
|
|
|
694 (setq save-pos (- (point) 2))
|
|
|
695 (delete-region save-pos
|
|
|
696 (if (search-forward "*/" nil t)
|
|
|
697 (point)
|
|
|
698 (end-of-line)
|
|
|
699 (point)))))
|
|
|
700 (goto-char (point-min))
|
|
|
701 (delete-matching-lines "^[ \t\r]*$") ; Nuke blank lines
|
|
|
702 (css-replace-regexp "^[ \t\r]+" "") ; Nuke whitespace at beg. of line
|
|
|
703 (css-replace-regexp "[ \t\r]+$" "") ; Nuke whitespace at end of line
|
|
|
704 (goto-char (point-min)))
|
|
|
705
|
|
|
706 (defun css-active-device-types (&optional device)
|
|
16
|
707 (let ((types (list 'all (if css-running-xemacs 'xemacs 'emacs)))
|
|
14
|
708 (type (device-type device)))
|
|
|
709 (cond
|
|
|
710 ((featurep 'emacspeak)
|
|
|
711 (setq types (cons 'speech types)))
|
|
|
712 ((eq type 'tty)
|
|
|
713 (if (and (fboundp 'tty-color-list)
|
|
|
714 (/= 0 (length (tty-color-list))))
|
|
|
715 (setq types (cons 'ansi-tty types))
|
|
|
716 (setq types (cons 'tty types))))
|
|
|
717 ((eq 'color (device-class))
|
|
|
718 (if (not (device-bitplanes))
|
|
|
719 (setq types (cons 'color types))
|
|
|
720 (setq types
|
|
|
721 (append
|
|
|
722 (list (intern (format "%dbit-color"
|
|
|
723 (device-bitplanes)))
|
|
|
724 (intern (format "%dbit"
|
|
|
725 (device-bitplanes)))
|
|
|
726 'color) types))
|
|
|
727 (if (= 24 (device-bitplanes))
|
|
|
728 (setq types (cons 'truecolor types)))))
|
|
|
729 ((eq 'grayscale (device-class))
|
|
|
730 (setq types (append (list (intern (format "%dbit-grayscale"
|
|
|
731 (device-bitplanes)))
|
|
|
732 'grayscale)
|
|
|
733 types)))
|
|
|
734 ((eq 'mono (device-class))
|
|
|
735 (setq types (append (list 'mono 'monochrome) types)))
|
|
|
736 (t
|
|
|
737 (setq types (cons 'unknown types))))
|
|
|
738 types))
|
|
|
739
|
|
|
740 (defmacro css-rule-specificity-internal (rule)
|
|
|
741 (`
|
|
|
742 (progn
|
|
|
743 (setq tmp (cdr (, rule)))
|
|
|
744 (if (listp tmp)
|
|
|
745 (while tmp
|
|
|
746 (if (= ?# (aref (car tmp) 0))
|
|
|
747 (incf a)
|
|
|
748 (incf b))
|
|
|
749 (setq tmp (cdr tmp)))))))
|
|
|
750
|
|
|
751 (defsubst css-specificity (rule)
|
|
|
752 ;; To find specificity, according to the september 1996 CSS draft
|
|
|
753 ;; a = # of ID attributes in the selector
|
|
|
754 ;; b = # of class attributes in the selector
|
|
|
755 ;; c = # of tag names in the selector
|
|
|
756 (let ((a 0) (b 0) (c 0) cur tmp)
|
|
|
757 (if (not (listp (car rule)))
|
|
|
758 (css-rule-specificity-internal rule)
|
|
|
759 (setq c (length rule))
|
|
|
760 (while rule
|
|
|
761 (css-rule-specificity-internal (pop rule))))
|
|
|
762 (+ (* 100 a) (* 10 b) c)
|
|
|
763 )
|
|
|
764 )
|
|
|
765
|
|
|
766 (defun css-copy-stylesheet (sheet)
|
|
|
767 (let ((new (make-hash-table :size (hash-table-count sheet))))
|
|
|
768 (cl-maphash
|
|
|
769 (function
|
|
|
770 (lambda (k v)
|
|
|
771 (cl-puthash k (copy-tree v) new))) sheet)
|
|
|
772 new))
|
|
|
773
|
|
|
774 (defsubst css-store-rule (attrs applies-to)
|
|
|
775 (declare (special sheet))
|
|
|
776 (let (rules cur tag node)
|
|
|
777 (while applies-to
|
|
|
778 (setq cur (pop applies-to)
|
|
|
779 tag (car cur))
|
|
|
780 (if (listp tag)
|
|
|
781 (setq tag (car tag)))
|
|
|
782 (setq rules (cl-gethash tag sheet))
|
|
|
783 (cond
|
|
|
784 ((null rules)
|
|
|
785 ;; First rule for this tag. Create new ruleset
|
|
|
786 (cl-puthash tag (list (cons cur attrs)) sheet))
|
|
|
787 ((setq node (assoc cur rules))
|
|
|
788 ;; Similar rule already exists, splice in our information
|
|
|
789 (setcdr node (append attrs (cdr node))))
|
|
|
790 (t
|
|
|
791 ;; First rule for this particular combination of tag/ancestors/class.
|
|
|
792 ;; Slap it onto the existing set of rules and push back into sheet.
|
|
|
793 (setq rules (cons (cons cur attrs) rules))
|
|
|
794 (cl-puthash tag rules sheet))
|
|
|
795 )
|
|
|
796 )
|
|
|
797 )
|
|
|
798 )
|
|
|
799
|
|
16
|
800 (defun css-parse (url &optional string inherit)
|
|
14
|
801 (let (
|
|
|
802 (url-mime-accept-string
|
|
|
803 "text/css ; level=2")
|
|
|
804 (save-pos nil)
|
|
|
805 (applies-to nil) ; List of tags to apply style to
|
|
|
806 (attrs nil) ; List of name/value pairs
|
|
|
807 (att nil)
|
|
|
808 (cur nil)
|
|
|
809 (val nil)
|
|
|
810 (device-type nil)
|
|
16
|
811 (purl (url-view-url t))
|
|
14
|
812 (active-device-types (css-active-device-types (selected-device)))
|
|
|
813 (sheet inherit))
|
|
|
814 (if (not sheet)
|
|
|
815 (setq sheet (make-hash-table :size 13 :test 'eq)))
|
|
|
816 (save-excursion
|
|
|
817 (set-buffer (get-buffer-create
|
|
|
818 (generate-new-buffer-name " *style*")))
|
|
|
819 (set-syntax-table css-syntax-table)
|
|
|
820 (erase-buffer)
|
|
16
|
821 (if url (url-insert-file-contents url))
|
|
14
|
822 (goto-char (point-max))
|
|
|
823 (if string (insert string))
|
|
|
824 (css-clean-buffer)
|
|
|
825 (goto-char (point-min))
|
|
|
826 (while (not (eobp))
|
|
|
827 (setq save-pos (point))
|
|
|
828 (cond
|
|
|
829 ;; *sigh* SGML comments are being used to 'hide' data inlined
|
|
|
830 ;; with the <style> tag from older browsers.
|
|
|
831 ((or (looking-at "<!--+") ; begin
|
|
|
832 (looking-at "--+>")) ; end
|
|
|
833 (goto-char (match-end 0)))
|
|
|
834 ;; C++ style comments, and we are doing IE compatibility
|
|
16
|
835 ((looking-at "//")
|
|
14
|
836 (end-of-line))
|
|
|
837 ;; Pre-Processor directives
|
|
|
838 ((looking-at "[ \t\r]*@\\([^ \t\r\n]\\)")
|
|
16
|
839 (let (data directive)
|
|
14
|
840 (skip-chars-forward " @\t\r") ; Past any leading whitespace
|
|
|
841 (setq save-pos (point))
|
|
|
842 (skip-chars-forward "^ \t\r\n") ; Past the @ directive
|
|
|
843 (downcase-region save-pos (point))
|
|
16
|
844 (setq directive (intern (buffer-substring save-pos (point))))
|
|
|
845 (skip-chars-forward " \t\r")
|
|
14
|
846 (setq save-pos (point))
|
|
|
847 (cond
|
|
16
|
848 ((looking-at ".*\\({\\)")
|
|
|
849 (goto-char (match-beginning 1))
|
|
|
850 (forward-sexp 1)
|
|
|
851 (setq data (buffer-substring save-pos (1- (point)))))
|
|
|
852 ((looking-at "[\"']+")
|
|
|
853 (setq save-pos (1+ save-pos))
|
|
|
854 (forward-sexp 1)
|
|
|
855 (setq data (buffer-substring save-pos (1- (point)))))
|
|
14
|
856 (t
|
|
16
|
857 (skip-chars-forward "^;")))
|
|
|
858 (if (not data)
|
|
|
859 (setq data (buffer-substring save-pos (point))))
|
|
|
860 (setq save-pos (point))
|
|
|
861 (case directive
|
|
|
862 (import (css-handle-import data))
|
|
|
863 (media (css-handle-media-directive data active-device-types))
|
|
|
864 (t (message "Unknown directive in stylesheet: @%s" directive)))))
|
|
14
|
865 ;; Giving us some output device information
|
|
|
866 ((looking-at "[ \t\r]*:\\([^: \n]+\\):")
|
|
16
|
867 (message "You are using the old way of specifying device-dependent stylesheets! Please upgrade!")
|
|
|
868 (sleep-for 2)
|
|
14
|
869 (downcase-region (match-beginning 1) (match-end 1))
|
|
|
870 (setq device-type (intern (buffer-substring (match-beginning 1)
|
|
|
871 (match-end 1))))
|
|
|
872 (goto-char (match-end 0))
|
|
|
873 (if (not (memq device-type active-device-types))
|
|
|
874 ;; Not applicable to us... skip the info
|
|
|
875 (progn
|
|
|
876 (if (re-search-forward ":[^:{ ]*:" nil t)
|
|
|
877 (goto-char (match-beginning 0))
|
|
|
878 (goto-char (point-max))))))
|
|
|
879 ;; Default is to treat it like a stylesheet declaration
|
|
|
880 (t
|
|
|
881 (skip-chars-forward "^{")
|
|
|
882 ;;(downcase-region save-pos (point))
|
|
|
883 (setq applies-to (css-applies-to save-pos (point)))
|
|
|
884 (skip-chars-forward "^{")
|
|
|
885 (setq save-pos (point))
|
|
|
886 (condition-case ()
|
|
|
887 (forward-sexp 1)
|
|
|
888 (error (goto-char (point-max))))
|
|
|
889 (end-of-line)
|
|
|
890 (skip-chars-backward "\r}")
|
|
|
891 (subst-char-in-region save-pos (point) ?\n ? )
|
|
|
892 (subst-char-in-region save-pos (point) ?\r ? )
|
|
|
893 ;; This is for not choking on garbage at the end of the buffer.
|
|
|
894 ;; I get bit by this every once in a while when going through my
|
|
|
895 ;; socks gateway.
|
|
|
896 (if (eobp)
|
|
|
897 nil
|
|
|
898 (setq attrs (css-parse-args (1+ save-pos) (point)))
|
|
|
899 (skip-chars-forward "}\r\n")
|
|
|
900 (css-store-rule attrs applies-to))
|
|
|
901 )
|
|
|
902 )
|
|
|
903 (skip-chars-forward " \t\r\n"))
|
|
|
904 (set-buffer-modified-p nil)
|
|
|
905 (kill-buffer (current-buffer)))
|
|
|
906 sheet)
|
|
|
907 )
|
|
|
908
|
|
|
909 ;; Tools for pretty-printing an existing stylesheet.
|
|
|
910 (defun css-rule-name (rule)
|
|
|
911 (cond
|
|
|
912 ((listp (car rule)) ; Contextual
|
|
|
913 (mapconcat 'css-rule-name
|
|
|
914 (reverse rule) " "))
|
|
|
915 ((listp (cdr rule)) ; More than one class
|
|
|
916 (let ((classes (cdr rule))
|
|
|
917 (rval (symbol-name (car rule))))
|
|
|
918 (while classes
|
|
|
919 (setq rval (concat rval
|
|
|
920 (if (= (aref (car classes) 0) ?:)
|
|
|
921 (pop classes)
|
|
|
922 (concat "." (pop classes))))))
|
|
|
923 rval))
|
|
|
924 (t
|
|
|
925 (symbol-name (car rule)))))
|
|
|
926
|
|
|
927 (defun css-display (sheet)
|
|
|
928 (with-output-to-temp-buffer "CSS Stylesheet"
|
|
|
929 (set-buffer standard-output)
|
|
|
930 (indented-text-mode)
|
|
|
931 (insert "# Stylesheet auto-regenerated by css.el\n#\n"
|
|
|
932 "# This is a mixture of the default stylesheet and any\n"
|
|
|
933 "# styles specified by the document. The rules are in no\n"
|
|
|
934 "# particular order.\n\n")
|
|
|
935 (let (tmp cur goal-col)
|
|
|
936 (cl-maphash
|
|
|
937 (function
|
|
|
938 (lambda (k v)
|
|
|
939 (while v
|
|
|
940 (setq cur (pop v))
|
|
|
941 (insert (css-rule-name (car cur)))
|
|
|
942 (insert " { ")
|
|
|
943 (setq goal-col (point))
|
|
|
944 (insert "\n")
|
|
|
945 ;; Display the rules
|
|
|
946 (setq tmp (cdr cur))
|
|
|
947 (let (prop val)
|
|
|
948 (while tmp
|
|
|
949 (setq prop (caar tmp)
|
|
|
950 val (cdar tmp)
|
|
|
951 tmp (cdr tmp))
|
|
|
952 (case (get prop 'css-type)
|
|
|
953 (symbol-list
|
|
|
954 (setq val (mapconcat 'symbol-name val ",")))
|
|
|
955 (weight
|
|
|
956 (setq val (substring (symbol-name val) 1 nil)))
|
|
|
957 (otherwise
|
|
|
958 nil)
|
|
|
959 )
|
|
|
960 (insert (format " %s: %s;\n" prop val))))
|
|
|
961 (insert "}\n\n");
|
|
|
962 )))
|
|
|
963 sheet))))
|
|
|
964
|
|
|
965 (provide 'css)
|
