;ELC ;;; Compiled by cyd@localhost on Mon Apr 23 22:20:35 2007 ;;; from file /home/cyd/emacs/lisp/composite.el ;;; in Emacs version 22.0.99 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`composite.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #@1423 Alist of symbols vs integer codes of glyph reference points. A glyph reference point symbol is to be used to specify a composition rule in COMPONENTS argument to such functions as `compose-region' and `make-composition'. Meanings of glyph reference point codes are as follows: 0----1----2 <---- ascent 0:tl or top-left | | 1:tc or top-center | | 2:tr or top-right | | 3:Bl or base-left 9:cl or center-left 9 10 11 <---- center 4:Bc or base-center 10:cc or center-center | | 5:Br or base-right 11:cr or center-right --3----4----5-- <-- baseline 6:bl or bottom-left | | 7:bc or bottom-center 6----7----8 <---- descent 8:br or bottom-right Glyph reference point symbols are to be used to specify composition rule of the form (GLOBAL-REF-POINT . NEW-REF-POINT), where GLOBAL-REF-POINT is a reference point in the overall glyphs already composed, and NEW-REF-POINT is a reference point in the new glyph to be added. For instance, if GLOBAL-REF-POINT is `br' (bottom-right) and NEW-REF-POINT is `tc' (top-center), the overall glyph is updated as follows (the point `*' corresponds to both reference points): +-------+--+ <--- new ascent | | | | global| | | glyph | | -- | | |-- <--- baseline (doesn't change) +----+--*--+ | | new | | |glyph| +----+-----+ <--- new descent  (defconst reference-point-alist '((tl . 0) (tc . 1) (tr . 2) (Bl . 3) (Bc . 4) (Br . 5) (bl . 6) (bc . 7) (br . 8) (cl . 9) (cc . 10) (cr . 11) (top-left . 0) (top-center . 1) (top-right . 2) (base-left . 3) (base-center . 4) (base-right . 5) (bottom-left . 6) (bottom-center . 7) (bottom-right . 8) (center-left . 9) (center-center . 10) (center-right . 11) (ml . 3) (mc . 10) (mr . 5) (mid-left . 3) (mid-center . 10) (mid-right . 5)) (#$ . 567)) #@141 Encode composition rule RULE into an integer value. RULE is a cons of global and new reference point symbols (see `reference-point-alist'). (defalias 'encode-composition-rule #[(rule) "\250\203 \304W\203 \207:\204\305\306\"\210@A\211\250\204'\n \236A \250\2041 \236A\n\307Y\203I\n\310W\203I \307Y\203I \310W\204N\305\306\"\210\n\310_ \\*\207" [rule nref gref reference-point-alist 144 error "Invalid composition rule: %S" 0 12] 4 (#$ . 2445)]) (defalias 'decode-composition-rule #[(rule-code) "\304!\203\f\305W\204\306\307\"\210\310\311\245 \"@\310\311\246 \"@\211\2033 9\2033\n\2033\n9\2048\306\312\"\210 \n*B\207" [rule-code reference-point-alist nref gref natnump 144 error "Invalid encoded composition rule: %S" rassq 12 "Invalid composition rule code: %S"] 5]) (defalias 'encode-composition-components #[(components &optional nocopy) "\204\305 !\306 !\203. G\307\n W\203* \n\310 \nH!I\210\n\311\\\211\202*\202E A\211\203D\f\310\f@!\240\210\fAA\211\2045) \207" [nocopy components i len tail copy-sequence vectorp 1 encode-composition-rule 2] 6]) (defalias 'decode-composition-components #[(components &optional nocopy) "\204\304 ! G\305\n W\203$ \n\306 \nH!I\210\n\307\\\211\202* \207" [nocopy components i len copy-sequence 1 decode-composition-rule 2] 6]) #@1238 Compose characters in the current region. Characters are composed relatively, i.e. composed by overstricking or stacking depending on ascent, descent and other properties. When called from a program, expects these four arguments. First two arguments START and END are positions (integers or markers) specifying the region. Optional 3rd argument COMPONENTS, if non-nil, is a character or a sequence (vector, list, or string) of integers. In this case, characters are composed not relatively but according to COMPONENTS. If it is a character, it is an alternate character to display instead of the text in the region. If it is a string, the elements are alternate characters. If it is a vector or list, it is a sequence of alternate characters and composition rules, where (2N)th elements are characters and (2N+1)th elements are composition rules to specify how to compose (2N+2)th elements with previously composed N glyphs. A composition rule is a cons of global and new glyph reference point symbols. See the documentation of `reference-point-alist' for more detail. Optional 4th argument MODIFICATION-FUNC is a function to call to adjust the composition when it gets invalid because of a change of text in the composition. (defalias 'compose-region #[(start end &optional components modification-func) "\306 \307\310\n!\204\n<\203\311\n!\312 \f\n $\210\313 !*\207" [buffer-read-only modified-p components start end modification-func buffer-modified-p nil vectorp encode-composition-components compose-region-internal restore-buffer-modified-p] 5 (#$ . 3779) "r"]) #@146 Decompose text in the current region. When called from a program, expects two arguments, positions (integers or markers) specifying the region. (defalias 'decompose-region #[(start end) "\304 \305\306\n \307#\210\310 !*\207" [buffer-read-only modified-p start end buffer-modified-p nil remove-text-properties (composition nil) set-buffer-modified-p] 4 (#$ . 5371) "r"]) #@613 Compose characters in string STRING. The return value is STRING where `composition' property is put on all the characters in it. Optional 2nd and 3rd arguments START and END specify the range of STRING to be composed. They default to the beginning and the end of STRING respectively. Optional 4th argument COMPONENTS, if non-nil, is a character or a sequence (vector, list, or string) of integers. See the function `compose-region' for more detail. Optional 5th argument MODIFICATION-FUNC is a function to call to adjust the composition when it gets invalid because of a change of text in the composition. (defalias 'compose-string #[(string &optional start end components modification-func) "\305!\204 <\203\306! \204\307\n\204 G\310 \n\f%\210 \207" [components start end string modification-func vectorp encode-composition-components 0 compose-string-internal] 6 (#$ . 5751)]) #@56 Return STRING where `composition' property is removed. (defalias 'decompose-string #[(string) "\301\302G\303$\210\207" [string remove-text-properties 0 (composition nil)] 5 (#$ . 6657)]) #@426 Return a string from arguments in which all characters are composed. For relative composition, arguments are characters. For rule-based composition, Mth (where M is odd) arguments are characters, and Nth (where N is even) arguments are composition rules. A composition rule is a cons of glyph reference points of the form (GLOBAL-REF-POINT . NEW-REF-POINT). See the documentation of `reference-point-alist' for more detail. (defalias 'compose-chars #[(&rest args) "\305\211\nA@:\203/\nG\306\n\307\" \203$ @ B AA\211\204 \237\260\n*\2023\n\260\310 \311 G$*\207" [components str args tail len nil encode-composition-components nocopy compose-string-internal 0] 6 (#$ . 6854)]) #@1221 Return information about a composition at or nearest to buffer position POS. If the character at POS has `composition' property, the value is a list of FROM, TO, and VALID-P. FROM and TO specify the range of text that has the same `composition' property, VALID-P is non-nil if and only if this composition is valid. If there's no composition at POS, and the optional 2nd argument LIMIT is non-nil, search for a composition toward LIMIT. If no composition is found, return nil. Optional 3rd argument STRING, if non-nil, is a string to look for a composition in; nil means the current buffer. If a valid composition is found and the optional 4th argument DETAIL-P is non-nil, the return value is a list of FROM, TO, COMPONENTS, RELATIVE-P, MOD-FUNC, and WIDTH. COMPONENTS is a vector of integers, the meaning depends on RELATIVE-P. RELATIVE-P is t if the composition method is relative, else nil. If RELATIVE-P is t, COMPONENTS is a vector of characters to be composed. If RELATIVE-P is nil, COMPONENTS is a vector of characters and composition rules as described in `compose-region'. MOD-FUNC is a modification function of the composition. WIDTH is a number of columns the composition occupies on the screen. (defalias 'find-composition #[(pos &optional limit string detail-p) "\305 \n $ \203\"\f\203\"\306\f8\203\"\307\f8\204\"\310\306\f8\311\"\210\f)\207" [pos limit string detail-p result find-composition-internal 2 3 decode-composition-components nocopy] 5 (#$ . 7555)]) #@983 Compose characters in current buffer after position POS. It looks up the char-table `composition-function-table' (which see) by a character after POS. If non-nil value is found, the format of the value should be an alist of PATTERNs vs FUNCs, where PATTERNs are regular expressions and FUNCs are functions. If the text after POS matches one of PATTERNs, call the corresponding FUNC with three arguments POS, TO, and PATTERN, where TO is the end position of text matching PATTERN, and return what FUNC returns. Otherwise, return nil. FUNC is responsible for composing the text properly. The return value is: nil -- if no characters were composed. CHARS (integer) -- if CHARS characters were composed. Optional 2nd arg LIMIT, if non-nil, limits the matching of text. Optional 3rd arg OBJECT, if non-nil, is a string that contains the text to compose. In that case, POS and LIMIT index to the string. This function is the default value of `compose-chars-after-function'. (defalias 'compose-chars-after #[(pos &optional limit object) " fH\306\211\211\211\203Y\307  \310\216\212 \203X \204X @@ @A b\210\203>\311\f\312#\203O\313\224 U\202A\314\f!\203O \313\225\f\306$\202\306 A\211\204+\n,\207" [composition-function-table pos result func pattern tail nil match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-forward t 0 looking-at save-match-data-internal limit] 6 (#$ . 9055)]) #@620 Compose last characters. The argument is a parameterized event of the form (compose-last-chars N COMPONENTS), where N is the number of characters before point to compose, COMPONENTS, if non-nil, is the same as the argument to `compose-region' (which see). If it is nil, `compose-chars-after' is called, and that function finds a proper rule to compose the target characters. This function is intended to be used from input methods. The global keymap binds special event `compose-last-chars' to this function. Input method may generate an event (compose-last-chars N COMPONENTS) after a sequence of character events. (defalias 'compose-last-chars #[(args) "A@\211\247\205)`eZ Y\205)\3028\203#\303` Z`\3028#\202)\304` Z`\")\207" [args chars 2 compose-region compose-chars-after] 6 (#$ . 10531) "e"]) #@241 Convert CHAR to string. If optional 2nd arg TYPE is non-nil, it is `string', `list', or `vector'. In this case, CHAR is converted to string, list of CHAR, or vector of CHAR respectively. Optional 3rd arg WITH-COMPOSITION-RULE is ignored. (defalias 'decompose-composite-char #[(char &optional type with-composition-rule) "\203\n\302=\203\303 !\207\304=\203 C\207\305 !\207" [type char string char-to-string list vector] 2 (#$ . 11347)]) (make-obsolete 'decompose-composite-char 'char-to-string "21.1")