diff options
Diffstat (limited to 'tex/context/base/type-ini.mkvi')
-rw-r--r-- | tex/context/base/type-ini.mkvi | 560 |
1 files changed, 560 insertions, 0 deletions
diff --git a/tex/context/base/type-ini.mkvi b/tex/context/base/type-ini.mkvi new file mode 100644 index 000000000..efe360bdb --- /dev/null +++ b/tex/context/base/type-ini.mkvi @@ -0,0 +1,560 @@ +%D \module +%D [ file=type-ini, +%D version=2001.03.05, +%D title=\CONTEXT\ Typescript Macros, +%D subtitle=Initialization, +%D author=Hans Hagen, +%D date=\currentdate, +%D copyright={PRAGMA ADE \& \CONTEXT\ Development Team}] +%C +%C This module is part of the \CONTEXT\ macro||package and is +%C therefore copyrighted by \PRAGMA. See mreadme.pdf for +%C details. + +\writestatus{loading}{ConTeXt Typescript Macros / Initialization} + +\registerctxluafile{type-ini}{1.001} + +%D The default fontclass is empty. We could demand always using fontclasses, +%D and then make the calling macros simplier (always assume fontclass) but +%D apart from downward compatibility issues, it would make global, class +%D spanning definitions a pain. Some day we will introduce a default class. + +%D The \type {type-ini} and \type {font-ini} modules come as a pair and have +%D mutual dependencies. + +%D Todo: store them at the lua end + +\unprotect + +\newcount \c_font_typescripts_n_of_preloaded +\newconditional\c_font_typescripts_quit +\newtoks \c_font_typescripts_document +\newconditional\c_font_typescripts_preload +\newconditional\c_font_typescripts_first_pass \settrue\c_font_typescripts_first_pass + +\newif \iftypescriptfound % will become a mode +\newif \iftracetypescripts + +\newtoks \everybeforedefinetypeface +\newtoks \everyafterdefinetypeface + +\let\typescriptfiles \empty +\let\currenttypescripts\empty +\let\currenttypefile \empty + +\let\typescriptone \empty % public, used in typescripts +\let\typescripttwo \empty % public, used in typescripts +\let\typescriptthree\empty % public, used in typescripts + +\let\fontclassstyle \empty + +\let\m_font_typescripts_one \empty +\let\m_font_typescripts_two \empty +\let\m_font_typescripts_three\empty +\let\m_font_typescripts_check\empty +\let\m_font_typescripts_match\empty + +\let\t_font_typescripts\relax % uses as synonym + +\installcorenamespace{typescriptcache} +\installcorenamespace{typescriptfiles} +\installcorenamespace{typescriptonce} +\installcorenamespace{typescriptsynonyms} +\installcorenamespace{typescriptprefix} +\installcorenamespace{typescriptinheritances} +\installcorenamespace{typescriptdefaultstyles} +\installcorenamespace{typescriptrelatives} + +\definesystemvariable{ts} % TypeScript + +% tricky ... here we push/pop + +\chardef\typescriptmethod\plusone % 1: empty==all==true 2: empty==false +\chardef\typescriptstate \plustwo % 1: process 2: store + +\unexpanded\def\starttypescriptcollection + {\dosingleempty\font_typescripts_collection_start} + +\def\font_typescripts_collection_start[#tag]% + {} + +\let\stoptypescriptcollection\relax + +\unexpanded\def\usetypescriptfile[#filename]% + {\doifelse{#filename}\v!reset + {\let\typescriptfiles\empty} + {\splitfilename{#filename}% + \addtocommalist\splitoffbase\typescriptfiles}} + +\unexpanded\def\usetypescript {\dotripleempty\font_typescripts_use_one} +\unexpanded\def\usetypescriptexact{\dotripleempty\font_typescripts_use_two} + +\def\font_typescripts_use_one{\let\typescriptmethod\plusone\font_typescripts_use} +\def\font_typescripts_use_two{\let\typescriptmethod\plustwo\font_typescripts_use} + +\unexpanded\def\font_typescripts_use[#one][#two][#three]% + {\pushmacro\m_font_typescripts_one + \pushmacro\m_font_typescripts_two + \pushmacro\m_font_typescripts_three + \edef\m_font_typescripts_one {\truetypescript{#one}}% + \edef\m_font_typescripts_two {\truetypescript{#two}}% + \edef\m_font_typescripts_three{\truetypescript{#three}}% + \pushmacro\typescriptone + \pushmacro\typescripttwo + \pushmacro\typescriptthree + \pushmacro\typescriptmethod + \pushmacro\typescriptstate + \pushmacro\stoptypescript + \typescriptfoundfalse + \let\typescriptstate\plusone + \iftracetypescripts + \writestatus\m!fonts{request: [\m_font_typescripts_one] [\m_font_typescripts_two] [\m_font_typescripts_three]}% + \fi + \processcommacommand[\typescriptfiles]\font_typescripts_load_file + \the\c_font_typescripts_document + \setfalse\c_font_typescripts_first_pass + \popmacro\stoptypescript + \popmacro\typescriptstate + \popmacro\typescriptmethod + \popmacro\typescriptthree + \popmacro\typescripttwo + \popmacro\typescriptone + \popmacro\m_font_typescripts_three + \popmacro\m_font_typescripts_two + \popmacro\m_font_typescripts_one} + +\unexpanded\def\preloadtypescripts + {\ifproductionrun\settrue\c_font_typescripts_preload\fi} + +\prependtoks + \preloadtypescripts +\to \everyjob + +\unexpanded\def\quittypescriptscanning + {\settrue\c_font_typescripts_quit} % public + +\def\font_typescripts_start_store#definitions\stoptypescript + {\global\advance\c_font_typescripts_n_of_preloaded\plusone + \expandafter\normalgdef\csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname + {\starttypescript#definitions\stoptypescript}% + %\normalexpanded{\global\t_font_typescripts{\the\expandafter\t_font_typescripts\noexpand\csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname}}} + \global\t_font_typescripts\expandafter\expandafter\expandafter + {\expandafter\the\expandafter\t_font_typescripts + \csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname}} + +\def\font_typescripts_collection_start_store#definitions\stoptypescriptcollection + {\global\advance\c_font_typescripts_n_of_preloaded\plusone + \expandafter\normalgdef\csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname + {\starttypescriptcollection#definitions\stoptypescriptcollection}% + %\normalexpanded{\global\t_font_typescripts{\the\expandafter\t_font_typescripts\noexpand\csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname}}} + \global\t_font_typescripts\expandafter\expandafter\expandafter + {\expandafter\the\expandafter\t_font_typescripts + \csname\??typescriptcache\the\c_font_typescripts_n_of_preloaded\endcsname}} + +\def\font_typescripts_load_file#filename% + {\setfalse\c_font_typescripts_quit + \pushmacro\currenttypefile + \def\currenttypefile{#filename}% + \ifconditional\c_font_typescripts_preload + \font_typescript_process_typescript_file_and_store + \else + \font_typescript_process_typescript_file + \fi + \popmacro\currenttypefile + \ifconditional\c_font_typescripts_quit + \quitcommalist + \setfalse\c_font_typescripts_quit + \fi} + +\def\font_typescript_process_typescript_file_and_store + {\expandafter\let\expandafter\t_font_typescripts\csname\??typescriptfiles\currenttypefile\endcsname + \ifx\t_font_typescripts\relax + \font_typescript_process_typescript_store_indeed + \fi + \the\t_font_typescripts} + +\def\font_typescript_process_typescript_store_indeed + {\newtoks\t_font_typescripts % is \relaxed elsewhere + \begingroup + \let\starttypescript \font_typescripts_start_store + \let\starttypescriptcollection\font_typescripts_collection_start_store + \font_typescript_process_typescript_file + \endgroup + \expandafter\let\csname\??typescriptfiles\currenttypefile\endcsname\t_font_typescripts} + +\def\font_typescript_process_typescript_file + {\ctxcommand{doprocesstypescriptfile("\currenttypefile")}} + +\unexpanded\def\usetypescriptonce + {\dotripleempty\font_typescripts_use_once} + +\def\font_typescripts_use_once[#one][#two][#three]% + {\ifcsname\??typescriptonce#one:#two:#three\endcsname + \writestatus\m!fonts{once (#one) (#two) (#three)}% + \else + \expandafter\let\csname\??typescriptonce#one:#two:#three\endcsname\relax + \font_typescripts_use[#one][#two][#three]% + \fi} + +% \definetypescriptsynonym[lbr][cmr] + +\unexpanded\def\definetypescriptsynonym + {\dodoubleempty\font_typescripts_synonym_define} + +\def\font_typescripts_synonym_define[#name][#synonym]% + {\ifsecondargument\setevalue{\??typescriptsynonyms#name}{#synonym}\fi} + +\def\truetypescript#name% + {\ifcsname\??typescriptsynonyms#name\endcsname + \expandafter\truetypescript\csname\??typescriptsynonyms#name\endcsname\else#name% + \fi} + +% script [serif] [default] [size] +% script [serif] [computer-modern] [size] +% script [serif] [computer-modern] [ec] +% script [serif] [computer-modern] [name] +% script [serif] [computer-modern] [special] + +\prependtoks + \settrue\c_font_typescripts_first_pass +\to \everyjob + +\unexpanded\def\starttypescript + {\ifcase\typescriptstate + % 0 = skip + \expandafter\font_typescripts_start_gobble + \or + % 1 = process + \expandafter\font_typescripts_start_process + \or + % 2 = store + \expandafter\font_typescripts_start_document + \else + % ? = skip + \expandafter\font_typescripts_start_gobble + \fi} + +\def\font_typescripts_start_gobble#definitions\stoptypescript{} + +\def\font_typescripts_start_document#definitions\stoptypescript + %{\appendtoks\starttypescript#definitions\stoptypescript\to\c_font_typescripts_document} + {\c_font_typescripts_document\expandafter{\the\c_font_typescripts_document\starttypescript#definitions\stoptypescript}} + +\def\font_typescripts_start_process % could be a faster \doifnextoptionalelse if needed + {\let\typescriptone \m_font_typescripts_one + \let\typescripttwo \m_font_typescripts_two + \let\typescriptthree\m_font_typescripts_three + \let\m_font_typescripts_match\empty + \doifnextoptionalelse\font_typescripts_start_process_one\font_typescripts_start_process_all} + +\def\font_typescripts_start_process_all % could be a \let + {\ifconditional\c_font_typescripts_first_pass + \expandafter\font_typescripts_start_process_indeed + \else + % skip this since it may do unwanted resets, like + % setting symbolic font names to unknown, especially + % in run time user type scripts + \expandafter\font_typescripts_start_gobble + \fi} + +\def\font_typescripts_show_match + {\writestatus\m!fonts{match:\ifx\currenttypefile\relax\space *\fi \m_font_typescripts_match}} + +\def\font_typescripts_start_process_yes + {\ifdone + \typescriptfoundtrue + \iftracetypescripts\font_typescripts_show_match\fi + \expandafter\font_typescripts_start_process_indeed + \else + \expandafter\font_typescripts_start_gobble + \fi} + +\def\font_typescripts_start_process_one + {\font_typescripts_check\m_font_typescripts_one\typescriptone\font_typescripts_start_process_again_one} + +\def\font_typescripts_start_process_two + {\font_typescripts_check\m_font_typescripts_two\typescripttwo\font_typescripts_start_process_again_two} + +\def\font_typescripts_start_process_three + {\font_typescripts_check\m_font_typescripts_three\typescriptthree\font_typescripts_start_process_again_three} + +\def\font_typescripts_start_process_again_one + {\doifnextoptionalelse\font_typescripts_start_process_two\font_typescripts_start_process_yes} + +\def\font_typescripts_start_process_again_two + {\doifnextoptionalelse\font_typescripts_start_process_three\font_typescripts_start_process_yes} + +% \def\font_typescripts_start_process_again_three +% {\font_typescripts_start_process_yes} + +\let\font_typescripts_start_process_again_three\font_typescripts_start_process_yes + +\def\font_typescripts_start_process_indeed + {\pushmacro\fontclass} + +\unexpanded\def\stoptypescript + {\popmacro\fontclass} + +\def\font_typescripts_check#asked#target#followup[#value]% script use value next + {\donefalse + \edef\m_font_typescripts_check{#value}% + \ifx\m_font_typescripts_check\empty % no longer needed / met + \ifcase\typescriptmethod\or\donetrue\fi + \else\ifx#asked\s!all + \donetrue + \else\ifx\m_font_typescripts_check\s!all + \donetrue + \else\ifx#asked\m_font_typescripts_check % saves 10% trace so probably faster too + \donetrue + \let#target\m_font_typescripts_check + \else + \doifcommonelse\m_font_typescripts_check#asked\donetrue\donefalse + \ifdone + \let#target\commalistelement + \fi + \fi\fi\fi\fi + \ifdone + \iftracetypescripts\extendtypescriptmatch\fi + \expandafter#followup% + \else + \expandafter\font_typescripts_start_gobble + \fi} + +\def\extendtypescriptmatch + {\edef\m_font_typescripts_match{\m_font_typescripts_match\space[\m_font_typescripts_check]}} + +%D Map files will go away in \LUATEX, but till that happens we +%D use stripped down support for loading them. + +\unexpanded\def\loadmapfile{\dosingleempty\font_map_load_file} +\unexpanded\def\loadmapline{\dodoubleempty\font_map_load_line} + +\def\font_map_load_file[#filename]% + {\ctxlua{fonts.mappings.loadfile("#filename")}} + +\def\font_map_load_line[#kind][#data]% + {\ctxlua{fonts.mappings.loadline("#kind","#data")}} + +\unexpanded\def\forgetmapfiles + {\ctxlua{fonts.mappings.reset()}} + +\prependtoks + \loadmapfile[mkiv-base.map]% can't we preload this one? +\to \everystarttext + +%D A handy shortcut: + +% \definetypescriptprefix[serif][Serif] +% \definetypescriptprefix[sans] [Sans] +% \definetypescriptprefix[mono] [Mono] +% +%\starttypescript [serif,sans,mono] [handling,hanging,hz] [pure,normal,hz,quality] +% \setupfontsynonym [\typescriptprefix\typescriptone] [handling=\typescriptthree] +% \stoptypescript + +\unexpanded\def\definetypescriptprefix + {\dodoubleargument\font_typescripts_define_prefix} + +\def\font_typescripts_define_prefix[#name][#prefix]% + {\setgvalue{\??typescriptprefix#name}{#prefix}} % made global + +% without testing: +% +% \def\typescriptprefix#name% +% {\csname\??typescriptprefix#name\endcsname} +% +% with testing: + +\def\typescriptprefix#name% + {\ifcsname\??typescriptprefix#name\endcsname\csname\??typescriptprefix#name\endcsname\else#name\fi} + +% defining typefaces: +% +% \definetypeface [joke] [rm] +% \definetypeface [joke] [rm] [settings] +% \definetypeface [joke] [rm] [serif] [lucida] +% \definetypeface [joke] [rm] [serif] [lucida] [size] +% \definetypeface [joke] [rm] [serif] [lucida] [size] [settings] +% \definetypeface [joke] [specification] + +\unexpanded\def\definetypeface + {\dosixtupleargument\font_typefaces_define} + +\appendtoks + \font_helpers_reset_fontclass_math_families\fontclass +\to \everybeforedefinetypeface + +\def\font_typefaces_define + {\iffifthargument + \singleexpandafter\font_typefaces_define_a + \else\iffourthargument + \doubleexpandafter\font_typefaces_define_b + \else\ifthirdargument + \tripleexpandafter\font_typefaces_define_c + \else + \tripleexpandafter\font_typefaces_define_d + \fi\fi\fi} + +\def\font_typefaces_define_a[#name][#style][#fontshape][#fontname][#fontsize][#settings]% + {\iftracetypescripts\writestatus\m!fonts{define: [#name] [#style] [#fontshape] [#fontname]}\fi + \font_typefaces_define_indeed[#name][#style]% + \font_typefaces_defining_start{#name}{#style}{#settings}% + \font_typescripts_use_one[#fontshape][#fontname][\s!name,\s!default]% + \font_typescripts_use_one[#fontshape][#fontsize][\s!size]% + \font_typefaces_defining_stop} + +\def\font_typefaces_define_b[#name][#style][#fontshape][#fontname][#dummya][#dummyb]% + {\font_typefaces_define_a[#name][#style][#fontshape][#fontname][\s!default][#dummyb]} + +% \def\font_typefaces_define_c[#name][#style][#settings][#dummya][#dummyb][#dummyc]% misuse for settings +% {\font_typefaces_define_indeed[#name][#style]% +% \getparameters[\??tf#name#style][#settings]} % not used + +\def\font_typefaces_define_c[#name][#style][#dummya][#dummyb][#dummyc][#dummyd]% + {\font_typefaces_define_indeed[#name][#style]} + +\def\font_typefaces_define_d[#name][#specification][#dummya][#dummyb][#dummyc][#dummyd]% use definitions in lfg file + {\ctxlua{fonts.definetypeface("#name",\!!bs#specification\!!es)}} + +\def\font_typefaces_define_indeed[#name][#style]% saveguard against redefinition + {\doifsomething{#name} + {\ifcsname\??typescriptdefaultstyles#name\endcsname \else + \registerfontclass{#name}% + \setxvalue{\??typescriptdefaultstyles#name}{#style}% + \fi + \ifcsname#name\endcsname \else + \setugvalue{#name}{\switchtotypeface[#name][#style]}% + \fi}} + +\def\font_typefaces_defining_start#name#style#settings% + {\let\@@tsrscale \plusone + \let\@@tsfeatures \empty + \let\@@tsfallbacks\empty + \let\@@tsgoodies \empty + \let\@@tsdirection\empty + \geteparameters[\??ts][#settings]% + \pushmacro\fontclass + \pushmacro\fontclassstyle + \setcurrentfontclass{#name}% + \pushmacro\relativefontsize % hm, can be a counter + \let\relativefontsize\@@tsrscale % still needed ? + \savefontclassparameters{#style}\@@tsrscale\@@tsfeatures\@@tsfallbacks\@@tsgoodies\@@tsdirection + \the\everybeforedefinetypeface} + +\def\tsvar#key#default% undocumented and unofficial + {\expandafter\ifx\csname\??ts#key\endcsname\empty + \csname\??ts#key\endcsname + \else + #default% + \fi} + +\def\font_typefaces_defining_stop + {\the\everyafterdefinetypeface + \popmacro\relativefontsize + \popmacro\fontclassstyle + \popmacro\fontclass} + +\def\dofastdefinetypeface#name#style#fontshape#fontsize#settings% called from the lua end (via case d) + {\font_typefaces_define_indeed[#name][#style]% + \font_typefaces_defining_start{#name}{#style}{#settings}% + \font_typescripts_use_one[#fontshape][#fontsize][\s!size]% + \font_typefaces_defining_stop} + +\unexpanded\def\setuptypeface% [class] [settings] + {\dodoubleempty\font_typefaces_setup} + +\unexpanded\def\switchtotypeface% [class] [settings] + {\dodoubleempty\font_typefaces_switch} + +\def\font_typefaces_setup[#class][#settings]% + {\setcurrentfontclass{#class}% + \let\globalfontclass\fontclass + \iffourthargument + \setupbodyfont[#settings]% + \else\ifx\fontclass\empty + \setupbodyfont[\s!rm]% + \else\ifcsname\??typescriptdefaultstyles\fontclass\endcsname + \setupbodyfont[\csname\??typescriptdefaultstyles\fontclass\endcsname]% + \else + \setupbodyfont[\s!rm]% + \fi \fi \fi + \ifmmode\mr\else\tf\fi} % needed ? + +\def\font_typefaces_switch[#class][#settings]% + {\setcurrentfontclass{#class}% + \let\globalfontclass\globalfontclass + \iffourthargument + \switchtobodyfont[#settings]% + \else\ifx\fontclass\empty + \switchtobodyfont[\s!rm]% + \else\ifcsname\??typescriptdefaultstyles\fontclass\endcsname + \switchtobodyfont[\csname\??typescriptdefaultstyles\fontclass\endcsname]% + \else + \switchtobodyfont[\s!rm]% + \fi \fi \fi + \ifmmode\mr\else\tf\fi} % needed ? + +\unexpanded\def\usetypefile[#type]% recurses on path ! % no storage? obsolete? + {\edef\currenttypefile{#type}% + \ctxcommand{doprocesstypescriptfile("\currenttypefile")}} + +%D For Taco: +%D +%D \starttyping +%D \inherittypeface[palatino][rm][postscript] +%D \inherittypeface[palatino][rm][\fontclass] +%D \inherittypeface[palatino][rm] % == \fontclass +%D \inherittypeface[palatino] % == [rm,ss,tt,mm] +%D \stoptyping + +\def\inherittypeface + {\dotripleempty\font_typescripts_inherit_indeed} + +\def\font_typescripts_inherit_indeed[#name][#styles][#parentclass]% + {\doifelsenothing{#styles} + {\font_typescripts_inherit_indeed[#name][\s!rm,\s!ss,\s!tt,\s!mm][\fontclass]} + {\doifnot{#name}{#parentclass} + {\global\let\font_typescripts_inherit_check\font_typescripts_inherit_check_indeed + \def\font_typescripts_inherit_check_step#style{\setevalue{\??typescriptinheritances#name:#style}{#parentclass}}% + \processcommalist[#styles]\font_typescripts_inherit_check_step}}} + +%D This hooks into the font mechanism with: + +\def\font_typescripts_inherit_check_indeed#name% called often + {\ifcsname\??typescriptinheritances\fontclass:#name\endcsname + \expandafter\let\expandafter\fontclass\csname\??typescriptinheritances\fontclass:#name\endcsname + \fi} + +\let\font_typescripts_inherit_check\gobbleoneargument + +% not yet: +% +% \def\font_helpers_check_relative_font_id +% {\ifcsname\??typescriptrelatives\fontclass\endcsname +% \expandafter\let\expandafter\relativefontid\csname\??typescriptrelatives\fontclass\endcsname +% \else +% \expandafter\normalxdef\csname\??typescriptrelatives\fontclass\endcsname{\the\lastfontid}% +% \let\relativefontid\empty +% \fi} + +\def\v_font_string_d % default fontstyle (expands to \s!Serif in font-ini) + {\expandafter\ifx\csname\??typescriptdefaultstyles\fontclass\endcsname\s!rm \s!Serif \else + \expandafter\ifx\csname\??typescriptdefaultstyles\fontclass\endcsname\s!ss \s!Sans \else + \expandafter\ifx\csname\??typescriptdefaultstyles\fontclass\endcsname\s!tt \s!Mono \else + \s!Serif \fi\fi\fi} + +\unexpanded\def\font_helpers_set_fontstyle_of_fontclass + {\ifx\fontclass\empty + \let\fontstyle\s!rm + \else\ifcsname\??typescriptdefaultstyles\fontclass\endcsname + \edef\fontstyle{\csname\??typescriptdefaultstyles\fontclass\endcsname}% + \else + \let\fontstyle\s!rm + \fi\fi} + +%D This might become a module: + +\fetchruntimecommand \typetypescript {\f!typeprefix\s!run} + +\protect \endinput |