anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-11-23 02:14:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of lyx:lyx

Browse Source
This commit is contained in:
Pavel Sanda 2012-03-31 01:09:21 +02:00
commit 612109bb6e
34 changed files with 1345 additions and 1268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,4 +1,5 @@
*.o *.o
*~
.deps/ .deps/
Makefile Makefile
Makefile.in Makefile.in

2
lib/.gitignore vendored
View File

@ -2,3 +2,5 @@ lyx.desktop
lyx.desktop-temp lyx.desktop-temp
lyx.png lyx.png
lyx.svg lyx.svg
*.pyc

2
lib/configure.py
View File

@ -62,7 +62,7 @@ def cmdOutput(cmd):
''' '''
if os.name == 'nt': if os.name == 'nt':
b = False b = False
cmd = 'cmd /d /c ' + cmd cmd = 'cmd /d /c pushd ' + os.getcwd() + '&' + cmd
else: else:
b = True b = True
pipe = subprocess.Popen(cmd, shell=b, close_fds=b, stdin=subprocess.PIPE, \ pipe = subprocess.Popen(cmd, shell=b, close_fds=b, stdin=subprocess.PIPE, \

44
lib/layouts/beamer.layout
View File

@ -222,6 +222,50 @@ Style Subsection*
OptionalArgs 0 OptionalArgs 0
End End
# Subsubsection style definition
Style Subsubsection
Category Section
Margin First_Dynamic
LatexType Command
LatexName lyxframeend{}\subsubsection
NeedProtect 1
NextNoIndent 1
LabelSep xx
ParSkip 0.4
TopSep 2
BottomSep 0.25
ParSep 0.5
Align Left
LabelType Counter
LabelCounter subsubsection
LabelString "Subsubsection \arabic{section}.\arabic{subsection}.\arabic{subsubsection}"
RefPrefix sub
OptionalArgs 1
# standard font definition
Font
Family Roman
Series Bold
Size large
EndFont
LabelFont
Color latex
EndFont
LabelStringAppendix "\arabic{section}.\arabic{subsection}.\arabic{subsubsection}"
TocLevel 2
End
# Subsubsection* style definition
Style Subsubsection*
CopyStyle Subsubsection
Category Unnumbered
Margin Static
LatexName lyxframeend{}\subsubsection*
LabelType No_Label
OptionalArgs 0
End
# Frame control definition # Frame control definition
Style BeginFrame Style BeginFrame
Category Frames Category Frames

34
lib/scripts/include_bib.py
View File

@ -41,8 +41,6 @@ def InsertBib(fil, out):
elif "\\begin{btSect}" in line: elif "\\begin{btSect}" in line:
raise BibError("Cannot export sectioned bibliographies") raise BibError("Cannot export sectioned bibliographies")
filenew = fil[:-4] + "-bibinc.tex" #The new .tex file
if len(biblist) > 1: if len(biblist) > 1:
raise BibError("Cannot export multiple bibliographies.") raise BibError("Cannot export multiple bibliographies.")
if not biblist: if not biblist:
@ -58,9 +56,35 @@ def InsertBib(fil, out):
outfile = open(out, 'w') outfile = open(out, 'w')
outfile.write("".join(newlist)) outfile.write("".join(newlist))
outfile.close() outfile.close()
return filenew return out
def usage():
print r'''
Usage: python include_bib.py file.tex [outfile.tex]
Includes the contents of file.bbl, which must exist in the
same directory as file.tex, in place of the \bibliography
command, and creates the new file outfile.tex. If no name
for that file is given, we create: file-bbl.tex.
'''
if __name__ == "__main__": if __name__ == "__main__":
newfile = InsertBib(sys.argv[1], sys.argv[2]) args = len(sys.argv)
print "Wrote " + newfile if args <= 1 or args > 3:
usage()
sys.exit(0)
# we might should make sure this is a tex file....
infile = sys.argv[1]
if infile[-4:] != ".tex":
print "Error: " + infile + " is not a TeX file"
usage()
sys.exit(1)
if args == 3:
outfile = sys.argv[2]
else:
outfile = infile[:-4] + "-bbl.tex"
newfile = InsertBib(infile, outfile)
print "Wrote " + outfile

239
lib/unicodesymbols
View File

@ -34,10 +34,15 @@
# - combining This is a combining char that will get combined with a base char # - combining This is a combining char that will get combined with a base char
# - force Always output replacement command # - force Always output replacement command
# - mathalpha This character is considered as a math variable in mathmode # - mathalpha This character is considered as a math variable in mathmode
# - notermination Do not terminate this command (by {} or space). # - notermination=text Do not terminate this textcommand (by {} or space).
# This is set by default if textcommand ends with }.
# - notermination=math Do not terminate this mathcommand (by {} or space).
# This is set by default if mathcommand ends with }.
# - notermination=both Do not terminate this textcommand and mathcommand (by {} or space).
# - notermination=none Always terminate this textcommand and mathcommand (by {} or space).
# - tipashortcut=<shortcut> Shortcut notation for TIPA # - tipashortcut=<shortcut> Shortcut notation for TIPA
0x00a0 "~" "" "notermination" "~" "" # NO-BREAK SPACE 0x00a0 "~" "" "notermination=both" "~" "" # NO-BREAK SPACE
0x00a1 "\\textexclamdown" "" "" # INVERTED EXCLAMATION MARK 0x00a1 "\\textexclamdown" "" "" # INVERTED EXCLAMATION MARK
0x00a2 "\\textcent" "textcomp" "" #"\\mathcent" "txfonts|pxfonts" # CENT SIGN 0x00a2 "\\textcent" "textcomp" "" #"\\mathcent" "txfonts|pxfonts" # CENT SIGN
0x00a3 "\\pounds" "" "" "\\pounds" "" # £ POUND SIGN 0x00a3 "\\pounds" "" "" "\\pounds" "" # £ POUND SIGN
@ -50,7 +55,7 @@
0x00aa "\\textordfeminine" "textcomp" "" # FEMININE ORDINAL INDICATOR 0x00aa "\\textordfeminine" "textcomp" "" # FEMININE ORDINAL INDICATOR
0x00ab "\\guillemotleft" "" "" # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK 0x00ab "\\guillemotleft" "" "" # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
0x00ac "\\textlnot" "textcomp" "force" "\\neg" "" # ¬ NOT SIGN 0x00ac "\\textlnot" "textcomp" "force" "\\neg" "" # ¬ NOT SIGN
0x00ad "\\-" "" "notermination" # SOFT HYPHEN 0x00ad "\\-" "" "notermination=text" "" "" # SOFT HYPHEN
0x00ae "\\textregistered" "textcomp" "force" "\\circledR" "amssymb" # REGISTERED SIGN # the force flag is only needed due to a bug in teTeX 3 / TeXLive 2005 0x00ae "\\textregistered" "textcomp" "force" "\\circledR" "amssymb" # REGISTERED SIGN # the force flag is only needed due to a bug in teTeX 3 / TeXLive 2005
0x00af "\\textasciimacron" "textcomp" "" # MACRON 0x00af "\\textasciimacron" "textcomp" "" # MACRON
0x00b0 "\\textdegree" "textcomp" "force" "{^\\circ}" "" # DEGREE SIGN # the force flag is only needed due to a bug in teTeX 3 / TeXLive 2005 0x00b0 "\\textdegree" "textcomp" "force" "{^\\circ}" "" # DEGREE SIGN # the force flag is only needed due to a bug in teTeX 3 / TeXLive 2005
@ -61,7 +66,7 @@
0x00b5 "\\textmu" "textcomp" "force" "\\mu" "" # µ MICRO SIGN 0x00b5 "\\textmu" "textcomp" "force" "\\mu" "" # µ MICRO SIGN
0x00b6 "\\textparagraph" "textcomp" "" # PILCROW SIGN # not equal to \textpilcrow 0x00b6 "\\textparagraph" "textcomp" "" # PILCROW SIGN # not equal to \textpilcrow
0x00b7 "\\textperiodcentered" "" "" "\cdot" # MIDDLE DOT 0x00b7 "\\textperiodcentered" "" "" "\cdot" # MIDDLE DOT
0x00b8 "\\c\\ " "" "" # CEDILLA (command from latin1.def) 0x00b8 "\\c\\ " "" "notermination=text" "" "" # CEDILLA (command from latin1.def)
0x00b9 "\\textonesuperior" "textcomp" "force" "{{}^1}" "" # ¹ SUPERSCRIPT ONE 0x00b9 "\\textonesuperior" "textcomp" "force" "{{}^1}" "" # ¹ SUPERSCRIPT ONE
0x00ba "\\textordmasculine" "textcomp" "" # MASCULINE ORDINAL INDICATOR 0x00ba "\\textordmasculine" "textcomp" "" # MASCULINE ORDINAL INDICATOR
0x00bb "\\guillemotright" "" "" # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK 0x00bb "\\guillemotright" "" "" # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
@ -85,7 +90,7 @@
0x00cd "\\'{I}" "" "mathalpha" "\\acute{I}" # LATIN CAPITAL LETTER I WITH ACUTE 0x00cd "\\'{I}" "" "mathalpha" "\\acute{I}" # LATIN CAPITAL LETTER I WITH ACUTE
0x00ce "\\^{I}" "" "mathalpha" "\\hat{I}" # LATIN CAPITAL LETTER I WITH CIRCUMFLEX 0x00ce "\\^{I}" "" "mathalpha" "\\hat{I}" # LATIN CAPITAL LETTER I WITH CIRCUMFLEX
0x00cf "\\\"{I}" "" "mathalpha" "\\ddot{I}" # LATIN CAPITAL LETTER I WITH DIAERESIS 0x00cf "\\\"{I}" "" "mathalpha" "\\ddot{I}" # LATIN CAPITAL LETTER I WITH DIAERESIS
0x00d0 "\\DH" "" "mathalpha" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER ETH 0x00d0 "\\DH" "" "mathalpha,notermination=math" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER ETH
0x00d1 "\\~{N}" "" "mathalpha" "\\tilde{N}" # LATIN CAPITAL LETTER N WITH TILDE 0x00d1 "\\~{N}" "" "mathalpha" "\\tilde{N}" # LATIN CAPITAL LETTER N WITH TILDE
0x00d2 "\\`{O}" "" "mathalpha" "\\grave{O}" # LATIN CAPITAL LETTER O WITH GRAVE 0x00d2 "\\`{O}" "" "mathalpha" "\\grave{O}" # LATIN CAPITAL LETTER O WITH GRAVE
0x00d3 "\\'{O}" "" "mathalpha" "\\acute{O}" # LATIN CAPITAL LETTER O WITH ACUTE 0x00d3 "\\'{O}" "" "mathalpha" "\\acute{O}" # LATIN CAPITAL LETTER O WITH ACUTE
@ -149,8 +154,8 @@
0x010d "\\v{c}" "" "mathalpha" "\\check{c}" # LATIN SMALL LETTER C WITH CARON 0x010d "\\v{c}" "" "mathalpha" "\\check{c}" # LATIN SMALL LETTER C WITH CARON
0x010e "\\v{D}" "" "mathalpha" "\\check{D}" # LATIN CAPITAL LETTER D WITH CARON 0x010e "\\v{D}" "" "mathalpha" "\\check{D}" # LATIN CAPITAL LETTER D WITH CARON
0x010f "\\v{d}" "" "mathalpha" "\\check{d}" # LATIN SMALL LETTER D WITH CARON 0x010f "\\v{d}" "" "mathalpha" "\\check{d}" # LATIN SMALL LETTER D WITH CARON
0x0110 "\\DJ" "" "mathalpha" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER D WITH STROKE 0x0110 "\\DJ" "" "mathalpha,notermination=math" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER D WITH STROKE
0x0111 "\\dj" "" "mathalpha" "\\mkern3mu\\mathchar'26\\mkern-12mu d" # LATIN SMALL LETTER D WITH STROKE 0x0111 "\\dj" "" "mathalpha,notermination=math" "\\mkern3mu\\mathchar'26\\mkern-12mu d" # LATIN SMALL LETTER D WITH STROKE
0x0112 "\\={E}" "" "mathalpha" "\\bar{E}" # LATIN CAPITAL LETTER E WITH MACRON 0x0112 "\\={E}" "" "mathalpha" "\\bar{E}" # LATIN CAPITAL LETTER E WITH MACRON
0x0113 "\\={e}" "" "mathalpha" "\\bar{e}" # LATIN SMALL LETTER E WITH MACRON 0x0113 "\\={e}" "" "mathalpha" "\\bar{e}" # LATIN SMALL LETTER E WITH MACRON
0x0114 "\\u{E}" "" "mathalpha" "\\breve{E}" # LATIN CAPITAL LETTER E WITH BREVE 0x0114 "\\u{E}" "" "mathalpha" "\\breve{E}" # LATIN CAPITAL LETTER E WITH BREVE
@ -168,7 +173,7 @@
0x0120 "\\.{G}" "" "mathalpha" "\\dot{G}" # LATIN CAPITAL LETTER G WITH DOT ABOVE 0x0120 "\\.{G}" "" "mathalpha" "\\dot{G}" # LATIN CAPITAL LETTER G WITH DOT ABOVE
0x0121 "\\.{g}" "" "mathalpha" "\\dot{g}" # LATIN SMALL LETTER G WITH DOT ABOVE 0x0121 "\\.{g}" "" "mathalpha" "\\dot{g}" # LATIN SMALL LETTER G WITH DOT ABOVE
0x0122 "\\c{G}" "" "mathalpha" "\\cedilla{G}" "accents,cedilla" # LATIN CAPITAL LETTER G WITH CEDILLA 0x0122 "\\c{G}" "" "mathalpha" "\\cedilla{G}" "accents,cedilla" # LATIN CAPITAL LETTER G WITH CEDILLA
0x0123 "\\accent96 g" "" "mathalpha,notermination" "\\mathaccent96 g" # LATIN SMALL LETTER G WITH CEDILLA 0x0123 "\\accent96 g" "" "mathalpha,notermination=both" "\\mathaccent96 g" "" # LATIN SMALL LETTER G WITH CEDILLA
0x0124 "\\^{H}" "" "mathalpha" "\\hat{H}" # LATIN CAPITAL LETTER H WITH CIRCUMFLEX 0x0124 "\\^{H}" "" "mathalpha" "\\hat{H}" # LATIN CAPITAL LETTER H WITH CIRCUMFLEX
0x0125 "\\^{h}" "" "mathalpha" "\\hat{h}" # LATIN SMALL LETTER H WITH CIRCUMFLEX 0x0125 "\\^{h}" "" "mathalpha" "\\hat{h}" # LATIN SMALL LETTER H WITH CIRCUMFLEX
#0x0126 "" "" "" "" "" # LATIN CAPITAL LETTER H WITH STROKE #0x0126 "" "" "" "" "" # LATIN CAPITAL LETTER H WITH STROKE
@ -183,8 +188,8 @@
0x012f "\\k{i}" "" "mathalpha" "\\ogonek{i}" "accents,tipasymb,ogonek" # LATIN SMALL LETTER I WITH OGONEK 0x012f "\\k{i}" "" "mathalpha" "\\ogonek{i}" "accents,tipasymb,ogonek" # LATIN SMALL LETTER I WITH OGONEK
0x0130 "\\.{I}" "" "mathalpha" "\\dot{I}" # LATIN CAPITAL LETTER I WITH DOT ABOVE 0x0130 "\\.{I}" "" "mathalpha" "\\dot{I}" # LATIN CAPITAL LETTER I WITH DOT ABOVE
0x0131 "\\i" "" "mathalpha" "\\imath" # LATIN SMALL LETTER DOTLESS I 0x0131 "\\i" "" "mathalpha" "\\imath" # LATIN SMALL LETTER DOTLESS I
0x0132 "IJ" "" "mathalpha,notermination" "IJ" # LATIN CAPITAL LIGATURE IJ 0x0132 "IJ" "" "mathalpha,notermination=both" "IJ" "" # LATIN CAPITAL LIGATURE IJ
0x0133 "ij" "" "mathalpha,notermination" "ij" # LATIN SMALL LIGATURE IJ 0x0133 "ij" "" "mathalpha,notermination=both" "ij" "" # LATIN SMALL LIGATURE IJ
0x0134 "\\^{J}" "" "mathalpha" "\\hat{J}" # LATIN CAPITAL LETTER J WITH CIRCUMFLEX 0x0134 "\\^{J}" "" "mathalpha" "\\hat{J}" # LATIN CAPITAL LETTER J WITH CIRCUMFLEX
0x0135 "\\^{\\j}" "" "mathalpha" "\\hat{\\jmath}" # LATIN SMALL LETTER J WITH CIRCUMFLEX 0x0135 "\\^{\\j}" "" "mathalpha" "\\hat{\\jmath}" # LATIN SMALL LETTER J WITH CIRCUMFLEX
0x0136 "\\c{K}" "" "mathalpha" "\\cedilla{K}" "accents,cedilla" # LATIN CAPITAL LETTER K WITH CEDILLA 0x0136 "\\c{K}" "" "mathalpha" "\\cedilla{K}" "accents,cedilla" # LATIN CAPITAL LETTER K WITH CEDILLA
@ -198,8 +203,8 @@
0x013e "\\v{l}" "" "mathalpha" "l\\mkern-5mu\\mathchar19" # LATIN SMALL LETTER L WITH CARON 0x013e "\\v{l}" "" "mathalpha" "l\\mkern-5mu\\mathchar19" # LATIN SMALL LETTER L WITH CARON
#0x013f "" "" "" "" "" # LATIN CAPITAL LETTER L WITH MIDDLE DOT #0x013f "" "" "" "" "" # LATIN CAPITAL LETTER L WITH MIDDLE DOT
#0x0140 "" "" "" "" "" # LATIN SMALL LETTER L WITH MIDDLE DOT #0x0140 "" "" "" "" "" # LATIN SMALL LETTER L WITH MIDDLE DOT
0x0141 "\\L" "" "mathalpha" "\\mkern2mu\\mathchar'40\\mkern-7mu L" # LATIN CAPITAL LETTER L WITH STROKE 0x0141 "\\L" "" "mathalpha,notermination=math" "\\mkern2mu\\mathchar'40\\mkern-7mu L" # LATIN CAPITAL LETTER L WITH STROKE
0x0142 "\\l" "" "mathalpha" "\\mathchar'40\\mkern-5mu l" # LATIN SMALL LETTER L WITH STROKE 0x0142 "\\l" "" "mathalpha,notermination=math" "\\mathchar'40\\mkern-5mu l" # LATIN SMALL LETTER L WITH STROKE
0x0143 "\\'{N}" "" "mathalpha" "\\acute{N}" # LATIN CAPITAL LETTER N WITH ACUTE 0x0143 "\\'{N}" "" "mathalpha" "\\acute{N}" # LATIN CAPITAL LETTER N WITH ACUTE
0x0144 "\\'{n}" "" "mathalpha" "\\acute{n}" # LATIN SMALL LETTER N WITH ACUTE 0x0144 "\\'{n}" "" "mathalpha" "\\acute{n}" # LATIN SMALL LETTER N WITH ACUTE
0x0145 "\\c{N}" "" "mathalpha" "\\cedilla{N}" "accents,cedilla" # LATIN CAPITAL LETTER N WITH CEDILLA 0x0145 "\\c{N}" "" "mathalpha" "\\cedilla{N}" "accents,cedilla" # LATIN CAPITAL LETTER N WITH CEDILLA
@ -331,7 +336,7 @@
0x01c0 "\\textpipe" "tipa" "force,tipashortcut=|" # LATIN LETTER DENTAL CLICK 0x01c0 "\\textpipe" "tipa" "force,tipashortcut=|" # LATIN LETTER DENTAL CLICK
0x01c1 "\\textdoublepipe" "tipa" "force,tipashortcut=||" # LATIN LETTER LATERAL CLICK 0x01c1 "\\textdoublepipe" "tipa" "force,tipashortcut=||" # LATIN LETTER LATERAL CLICK
0x01c2 "\\textdoublebarpipe" "tipa" "force" # LATIN LETTER ALVEOLAR CLICK 0x01c2 "\\textdoublebarpipe" "tipa" "force" # LATIN LETTER ALVEOLAR CLICK
0x01c3 "!" "" "notermination" # LATIN LETTER RETROFLEX CLICK 0x01c3 "!" "" "notermination=text" "" "" # LATIN LETTER RETROFLEX CLICK
#0x01c4 "" "" "" # LATIN CAPITAL LETTER DZ WITH CARON #0x01c4 "" "" "" # LATIN CAPITAL LETTER DZ WITH CARON
#0x01c5 "" "" "" # LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON #0x01c5 "" "" "" # LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
#0x01c6 "" "" "" # LATIN SMALL LETTER DZ WITH CARON #0x01c6 "" "" "" # LATIN SMALL LETTER DZ WITH CARON
@ -611,8 +616,8 @@
#0x02d3 "" "" "" # MODIFIER LETTER CENTRED LEFT HALF RING #0x02d3 "" "" "" # MODIFIER LETTER CENTRED LEFT HALF RING
0x02d4 "\\textraising{ }" "tipa" "force" # MODIFIER LETTER UP TACK 0x02d4 "\\textraising{ }" "tipa" "force" # MODIFIER LETTER UP TACK
0x02d5 "\\textlowering{ }" "tipa" "force" # MODIFIER LETTER DOWN TACK 0x02d5 "\\textlowering{ }" "tipa" "force" # MODIFIER LETTER DOWN TACK
0x02d6 "" "" "" "+" # MODIFIER LETTER PLUS SIGN 0x02d6 "" "" "notermination=math" "+" # MODIFIER LETTER PLUS SIGN
0x02d7 "" "" "" "-" # MODIFIER LETTER MINUS SIGN 0x02d7 "" "" "notermination=math" "-" # MODIFIER LETTER MINUS SIGN
0x02d8 "\\u{ }" "" "" # BREVE 0x02d8 "\\u{ }" "" "" # BREVE
0x02d9 "\\.{ }" "" "" # DOT ABOVE 0x02d9 "\\.{ }" "" "" # DOT ABOVE
0x02da "\\r{ }" "" "" # RING ABOVE 0x02da "\\r{ }" "" "" # RING ABOVE
@ -652,15 +657,15 @@
# #
# Combining diacritical marks # Combining diacritical marks
# #
0x0300 "\\`" "" "combining,force" # COMBINING GRAVE ACCENT 0x0300 "\\`" "" "combining,force,notermination=text" "" "" # COMBINING GRAVE ACCENT
0x0301 "\\'" "" "combining,force" # COMBINING ACUTE ACCENT 0x0301 "\\'" "" "combining,force,notermination=text" "" "" # COMBINING ACUTE ACCENT
0x0302 "\\^" "" "combining,force" # COMBINING CIRCUMFLEX ACCENT 0x0302 "\\^" "" "combining,force,notermination=text" "" "" # COMBINING CIRCUMFLEX ACCENT
0x0303 "\\~" "" "combining,force" # COMBINING TILDE 0x0303 "\\~" "" "combining,force,notermination=text" "" "" # COMBINING TILDE
0x0304 "\\=" "" "combining,force" # COMBINING MACRON 0x0304 "\\=" "" "combining,force,notermination=text" "" "" # COMBINING MACRON
#0x0305 "" "" "combining,force" # COMBINING OVERLINE #0x0305 "" "" "combining,force" # COMBINING OVERLINE
0x0306 "\\u" "" "combining,force" # COMBINING BREVE 0x0306 "\\u" "" "combining,force" # COMBINING BREVE
0x0307 "\\." "" "combining,force" # COMBINING DOT ABOVE 0x0307 "\\." "" "combining,force,notermination=text" "" "" # COMBINING DOT ABOVE
0x0308 "\\\"" "" "combining,force" # COMBINING DIAERESIS 0x0308 "\\\"" "" "combining,force,notermination=text" "" "" # COMBINING DIAERESIS
#0x0309 "" "" "combining,force" # COMBINING HOOK ABOVE #0x0309 "" "" "combining,force" # COMBINING HOOK ABOVE
0x030a "\\r" "" "combining,force" # COMBINING RING ABOVE 0x030a "\\r" "" "combining,force" # COMBINING RING ABOVE
0x030b "\\H" "" "combining,force" # COMBINING DOUBLE ACUTE ACCENT 0x030b "\\H" "" "combining,force" # COMBINING DOUBLE ACUTE ACCENT
@ -718,7 +723,7 @@
#0x033f "" "" "combining,force" # COMBINING DOUBLE OVERLINE #0x033f "" "" "combining,force" # COMBINING DOUBLE OVERLINE
#0x0340 "" "" "combining,force" # COMBINING GRAVE TONE MARK #0x0340 "" "" "combining,force" # COMBINING GRAVE TONE MARK
#0x0341 "" "" "combining,force" # COMBINING ACUTE TONE MARK #0x0341 "" "" "combining,force" # COMBINING ACUTE TONE MARK
0x0342 "\\~" "textgreek" "combining,force" # COMBINING GREEK PERISPOMENI 0x0342 "\\~" "textgreek" "combining,force,notermination=text" "" "" # COMBINING GREEK PERISPOMENI
#0x0343 "" "" "combining,force" # COMBINING GREEK KORONIS #0x0343 "" "" "combining,force" # COMBINING GREEK KORONIS
#0x0344 "" "" "combining,force" # COMBINING GREEK DIALYTIKA TONOS #0x0344 "" "" "combining,force" # COMBINING GREEK DIALYTIKA TONOS
#0x0345 "" "" "combining,force" # COMBINING GREEK YPOGEGRAMMENI #0x0345 "" "" "combining,force" # COMBINING GREEK YPOGEGRAMMENI
@ -845,16 +850,16 @@
#0x03d5 "" "" "" "" "" # GREEK PHI SYMBOL #0x03d5 "" "" "" "" "" # GREEK PHI SYMBOL
#0x03d6 "" "" "" "" "" # GREEK PI SYMBOL #0x03d6 "" "" "" "" "" # GREEK PI SYMBOL
#0x03d7 "" "" "" "" "" # GREEK KAI SYMBOL #0x03d7 "" "" "" "" "" # GREEK KAI SYMBOL
0x03d8 "\\textgreek{\\char21}" "textgreek" "" # GREEK LETTER ARCHAIC KOPPA 0x03d8 "\\textgreek{\\char21}" "textgreek" "" "" "" # GREEK LETTER ARCHAIC KOPPA
0x03d9 "\\textgreek{\\char19}" "textgreek" "" # GREEK SMALL LETTER ARCHAIC KOPPA 0x03d9 "\\textgreek{\\char19}" "textgreek" "" "" "" # GREEK SMALL LETTER ARCHAIC KOPPA
#0x03da "" "" "" "" "" # GREEK LETTER STIGMA #0x03da "" "" "" "" "" # GREEK LETTER STIGMA
0x03db "\\textgreek{\\char6}" "textgreek" "" # GREEK SMALL LETTER STIGMA 0x03db "\\textgreek{\\char6}" "textgreek" "" "" "" # GREEK SMALL LETTER STIGMA
0x03dc "\\textgreek{\\char195}" "textgreek" "" # GREEK LETTER DIGAMMA 0x03dc "\\textgreek{\\char195}" "textgreek" "" "" "" # GREEK LETTER DIGAMMA
0x03dd "\\textgreek{\\char147}" "textgreek" "" "\\digamma" "amssymb" # GREEK SMALL LETTER DIGAMMA 0x03dd "\\textgreek{\\char147}" "textgreek" "" "\\digamma" "amssymb" # GREEK SMALL LETTER DIGAMMA
#0x03de "" "" "" "" "" # GREEK LETTER KOPPA #0x03de "" "" "" "" "" # GREEK LETTER KOPPA
0x03df "\\textgreek{\\char18}" "textgreek" "" # GREEK SMALL LETTER KOPPA 0x03df "\\textgreek{\\char18}" "textgreek" "" "" "" # GREEK SMALL LETTER KOPPA
0x03e0 "\\textgreek{\\char23}" "textgreek" "" # GREEK LETTER SAMPI 0x03e0 "\\textgreek{\\char23}" "textgreek" "" "" "" # GREEK LETTER SAMPI
0x03e1 "\\textgreek{\\char27}" "textgreek" "" # GREEK SMALL LETTER SAMPI 0x03e1 "\\textgreek{\\char27}" "textgreek" "" "" "" # GREEK SMALL LETTER SAMPI
0x03f6 "" "" "" "\\backepsilon" "amssymb" # ϶ GREEK REVERSED LUNATE EPSILON SYMBOL 0x03f6 "" "" "" "\\backepsilon" "amssymb" # ϶ GREEK REVERSED LUNATE EPSILON SYMBOL
# #
# Cyrillic # Cyrillic
@ -1580,9 +1585,9 @@
0x2001 "\\quad" "" "" "\\quad" "" # EM QUAD 0x2001 "\\quad" "" "" "\\quad" "" # EM QUAD
0x2002 "\\enskip" "" "" "\\enskip" "" # EN SPACE 0x2002 "\\enskip" "" "" "\\enskip" "" # EN SPACE
0x2003 "\\quad" "" "" "\\quad" "" # EM SPACE 0x2003 "\\quad" "" "" "\\quad" "" # EM SPACE
0x2004 "\\;" "" "notermination" "\\;" "" # THREE-PER-EM SPACE 0x2004 "\\;" "" "notermination=both" "\\;" "" # THREE-PER-EM SPACE
0x2005 "\\:" "" "notermination" "\\:" "" # FOUR-PER-EM SPACE 0x2005 "\\:" "" "notermination=both" "\\:" "" # FOUR-PER-EM SPACE
0x2006 "\\," "" "notermination" "\\," "" # SIX-PER-EM SPACE 0x2006 "\\," "" "notermination=both" "\\," "" # SIX-PER-EM SPACE
0x2007 "\\LyXFigureSpace" "\\newcommand*\\LyXFigureSpace{\\hphantom{0}}" "" "\\LyXFigureSpace" "\\newcommand*\\LyXFigureSpace{\\hphantom{0}}" # FIGURE SPACE 0x2007 "\\LyXFigureSpace" "\\newcommand*\\LyXFigureSpace{\\hphantom{0}}" "" "\\LyXFigureSpace" "\\newcommand*\\LyXFigureSpace{\\hphantom{0}}" # FIGURE SPACE
0x2008 "\\LyXPunctSpace" "\\newcommand*\\LyXPunctSpace{\\hphantom{,}}" "" "\\LyXPunctSpace" "\\newcommand*\\LyXPunctSpace{\\hphantom{,}}" # PUNCTUATION SPACE 0x2008 "\\LyXPunctSpace" "\\newcommand*\\LyXPunctSpace{\\hphantom{,}}" "" "\\LyXPunctSpace" "\\newcommand*\\LyXPunctSpace{\\hphantom{,}}" # PUNCTUATION SPACE
0x2009 "\\LyXThinSpace" "\\newcommand*\\LyXThinSpace{\\,\\hspace{0pt}}" "" "\\LyXThinSpace" "\\newcommand*\\LyXThinSpace{\\,\\hspace{0pt}}" # THIN SPACE 0x2009 "\\LyXThinSpace" "\\newcommand*\\LyXThinSpace{\\,\\hspace{0pt}}" "" "\\LyXThinSpace" "\\newcommand*\\LyXThinSpace{\\,\\hspace{0pt}}" # THIN SPACE
@ -1592,14 +1597,14 @@
#0x200d "" "" "" "" "" # ZERO WIDTH JOINER #0x200d "" "" "" "" "" # ZERO WIDTH JOINER
#0x200e "" "" "" "" "" # LEFT-TO-RIGHT MARK #0x200e "" "" "" "" "" # LEFT-TO-RIGHT MARK
#0x200f "" "" "" "" "" # RIGHT-TO-LEFT MARK #0x200f "" "" "" "" "" # RIGHT-TO-LEFT MARK
0x2010 "-" "" "notermination" "" "" # HYPHEN # identic in LaTeX to FIGURE DASH 0x2010 "-" "" "notermination=text" "" "" # HYPHEN # identic in LaTeX to FIGURE DASH
0x2011 "\\nobreakdash-" "amsmath" "notermination" "" "" # NON-BREAKING HYPHEN 0x2011 "\\nobreakdash-" "amsmath" "notermination=text" "" "" # NON-BREAKING HYPHEN
0x2012 "-" "" "notermination" # FIGURE DASH 0x2012 "-" "" "notermination=text" "" "" # FIGURE DASH
0x2013 "\\textendash" "" "" # EN DASH 0x2013 "\\textendash" "" "" # EN DASH
0x2014 "\\textemdash" "" "" # EM DASH 0x2014 "\\textemdash" "" "" # EM DASH
# use the following macro for the character HORIZONTAL BAR # use the following macro for the character HORIZONTAL BAR
0x2015 "\\LyXbar" "\\newcommand*\\LyXbar{\\rule[0.585ex]{1.2em}{0.25pt}}" "" 0x2015 "\\LyXbar" "\\newcommand*\\LyXbar{\\rule[0.585ex]{1.2em}{0.25pt}}" ""
0x2016 "\\textbardbl" "textcomp" "" "\\|" "" # DOUBLE VERTICAL LINE 0x2016 "\\textbardbl" "textcomp,notermination=math" "" "\\|" "" # DOUBLE VERTICAL LINE
0x2017 "\\subdoublebar{ }" "tipa" "" "" "" # DOUBLE LOW LINE 0x2017 "\\subdoublebar{ }" "tipa" "" "" "" # DOUBLE LOW LINE
0x2018 "\\textquoteleft" "" "" # LEFT SINGLE QUOTATION MARK 0x2018 "\\textquoteleft" "" "" # LEFT SINGLE QUOTATION MARK
0x2019 "\\textquoteright" "" "" # RIGHT SINGLE QUOTATION MARK 0x2019 "\\textquoteright" "" "" # RIGHT SINGLE QUOTATION MARK
@ -1613,10 +1618,10 @@
0x2021 "\\ddag" "" "" "\\ddagger" "" # DOUBLE DAGGER 0x2021 "\\ddag" "" "" "\\ddagger" "" # DOUBLE DAGGER
0x2022 "\\textbullet" "textcomp" "" # BULLET 0x2022 "\\textbullet" "textcomp" "" # BULLET
0x2023 "\\textifsymbol[ifgeo]{116}" "ifsym" "" # TRIANGULAR BULLET # ≈ 0x25b8 0x2023 "\\textifsymbol[ifgeo]{116}" "ifsym" "" # TRIANGULAR BULLET # ≈ 0x25b8
0x2024 "." "" "notermination" # ONE DOT LEADER # ≈ FULL STOP 0x2024 "." "" "notermination=text" "" "" # ONE DOT LEADER # ≈ FULL STOP
0x2025 ".\\,." "" "notermination" # TWO DOT LEADER 0x2025 ".\\,." "" "notermination=text" "" "" # TWO DOT LEADER
0x2026 "\\ldots" "" "" "\\ldots" "" # HORIZONTAL ELLIPSIS 0x2026 "\\ldots" "" "" "\\ldots" "" # HORIZONTAL ELLIPSIS
0x2027 "\\-" "" "notermination" "" "" # HYPHENATION POINT 0x2027 "\\-" "" "notermination=text" "" "" # HYPHENATION POINT
#0x2028 "" "" "" "" "" # LINE SEPARATOR #0x2028 "" "" "" "" "" # LINE SEPARATOR
#0x2029 "" "" "" "" "" # PARAGRAPH SEPARATOR #0x2029 "" "" "" "" "" # PARAGRAPH SEPARATOR
#0x202a "" "" "" "" "" # LEFT-TO-RIGHT EMBEDDING #0x202a "" "" "" "" "" # LEFT-TO-RIGHT EMBEDDING
@ -1624,7 +1629,7 @@
#0x202c "" "" "" "" "" # POP DIRECTIONAL FORMATTING #0x202c "" "" "" "" "" # POP DIRECTIONAL FORMATTING
#0x202d "" "" "" "" "" # LEFT-TO-RIGHT OVERRIDE #0x202d "" "" "" "" "" # LEFT-TO-RIGHT OVERRIDE
#0x202e "" "" "" "" "" # RIGHT-TO-LEFT OVERRIDE #0x202e "" "" "" "" "" # RIGHT-TO-LEFT OVERRIDE
0x202f "\\," "" "notermination" "\\," "" # NARROW NO-BREAK SPACE 0x202f "\\," "" "notermination=both" "\\," "" # NARROW NO-BREAK SPACE
0x2030 "\\textperthousand" "textcomp" "" # PER MILLE SIGN 0x2030 "\\textperthousand" "textcomp" "" # PER MILLE SIGN
0x2031 "\\textpertenthousand" "textcomp" "" # PER TEN THOUSAND SIGN 0x2031 "\\textpertenthousand" "textcomp" "" # PER TEN THOUSAND SIGN
0x2032 "\\textasciiacute" "textcomp" "" "\\prime" "" # PRIME 0x2032 "\\textasciiacute" "textcomp" "" "\\prime" "" # PRIME
@ -1633,24 +1638,24 @@
0x2035 "\\textasciigrave" "textcomp" "" "\\backprime" "amssymb" # REVERSED PRIME 0x2035 "\\textasciigrave" "textcomp" "" "\\backprime" "amssymb" # REVERSED PRIME
0x2036 "\\textgravedbl" "textcomp" "" # REVERSED DOUBLE PRIME 0x2036 "\\textgravedbl" "textcomp" "" # REVERSED DOUBLE PRIME
#0x2037 "" "" "" # REVERSED TRIPLE PRIME #0x2037 "" "" "" # REVERSED TRIPLE PRIME
0x2038 "\\^{}" "" "notermination" # CARET 0x2038 "\\^{}" "" "" "" "" # CARET
0x2039 "\\guilsinglleft" "" "" # SINGLE LEFT-POINTING ANGLE QUOTATION MARK 0x2039 "\\guilsinglleft" "" "" # SINGLE LEFT-POINTING ANGLE QUOTATION MARK
0x203a "\\guilsinglright" "" "" # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK 0x203a "\\guilsinglright" "" "" # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
0x203b "\\textreferencemark" "textcomp" "" # REFERENCE MARK 0x203b "\\textreferencemark" "textcomp" "" # REFERENCE MARK
0x203c "!!" "" "notermination" # DOUBLE EXCLAMATION MARK # ≈ 2×EXCLAMATION MARK 0x203c "!!" "" "notermination=text" "" "" # DOUBLE EXCLAMATION MARK # ≈ 2×EXCLAMATION MARK
0x203d "\\textinterrobang" "textcomp" "" # INTERROBANG 0x203d "\\textinterrobang" "textcomp" "" # INTERROBANG
# use the following macro for the character OVERLINE # use the following macro for the character OVERLINE
0x203e "\\LyXoverline" "\\newcommand*\\LyXoverline{\\raisebox{2.6ex}{\\_}}" "" 0x203e "\\LyXoverline" "\\newcommand*\\LyXoverline{\\raisebox{2.6ex}{\\_}}" ""
0x2044 "\\textfractionsolidus" "textcomp" "" # FRACTION SLASH 0x2044 "\\textfractionsolidus" "textcomp" "" # FRACTION SLASH
0x2045 "\\textlquill" "textcomp" "" # LEFT SQUARE BRACKET WITH QUILL 0x2045 "\\textlquill" "textcomp" "" # LEFT SQUARE BRACKET WITH QUILL
0x2046 "\\textrquill" "textcomp" "" # RIGHT SQUARE BRACKET WITH QUILL 0x2046 "\\textrquill" "textcomp" "" # RIGHT SQUARE BRACKET WITH QUILL
0x2047 "??" "" "notermination" # DOUBLE QUESTION MARK # ≈ 2×QUESTION MARK 0x2047 "??" "" "notermination=text" "" "" # DOUBLE QUESTION MARK # ≈ 2×QUESTION MARK
0x2048 "?!" "" "notermination" # QUESTION EXCLAMATION MARK 0x2048 "?!" "" "notermination=text" "" "" # QUESTION EXCLAMATION MARK
0x2049 "!?" "" "notermination" # EXCLAMATION QUESTION MARK 0x2049 "!?" "" "notermination=text" "" "" # EXCLAMATION QUESTION MARK
0x2052 "\\textdiscount" "textcomp" "" # COMMERCIAL MINUS SIGN 0x2052 "\\textdiscount" "textcomp" "" # COMMERCIAL MINUS SIGN
0x205d "\\vdots" "" "" # TRICOLON # ≈ VERTICAL ELLIPSIS 0x205d "\\vdots" "" "" # TRICOLON # ≈ VERTICAL ELLIPSIS
#0x205e "" "" "" "" "" # VERTICAL FOUR DOTS #0x205e "" "" "" "" "" # VERTICAL FOUR DOTS
0x205f "" "" "" "\\:" "" # MEDIUM MATHEMATICAL SPACE 0x205f "" "" "notermination=math" "\\:" "" # MEDIUM MATHEMATICAL SPACE
#0x2060 "" "" "" "" "" # WORD JOINER #0x2060 "" "" "" "" "" # WORD JOINER
0x2070 "\\textsuperscript{0}" "" "" "{{}^0}" "" # SUPERSCRIPT ZERO 0x2070 "\\textsuperscript{0}" "" "" "{{}^0}" "" # SUPERSCRIPT ZERO
0x2071 "\\textsuperscript{i}" "" "" "{{}^i}" "" # SUPERSCRIPT LATIN SMALL LETTER I 0x2071 "\\textsuperscript{i}" "" "" "{{}^i}" "" # SUPERSCRIPT LATIN SMALL LETTER I
@ -1716,13 +1721,13 @@
0x2105 "\\LyXcareof" "\\newcommand*\\LyXcareof{\\mbox{\\raisebox{.8ex}{c}\\kern-.175em\\raisebox{.2ex}{/}\\kern-.18em\\raisebox{-.2ex}{o}}}" "" 0x2105 "\\LyXcareof" "\\newcommand*\\LyXcareof{\\mbox{\\raisebox{.8ex}{c}\\kern-.175em\\raisebox{.2ex}{/}\\kern-.18em\\raisebox{-.2ex}{o}}}" ""
# use the following macro for the character CADA UNA # use the following macro for the character CADA UNA
0x2106 "\\LyXcadauna" "\\newcommand*\\LyXcadauna{\\mbox{\\raisebox{.8ex}{c}\\kern-.175em\\raisebox{.2ex}{/}\\kern-.18em\\raisebox{-.2ex}{u}}}" "" 0x2106 "\\LyXcadauna" "\\newcommand*\\LyXcadauna{\\mbox{\\raisebox{.8ex}{c}\\kern-.175em\\raisebox{.2ex}{/}\\kern-.18em\\raisebox{-.2ex}{u}}}" ""
0x2109 "°{}F" "" "notermination" # DEGREE FARENHEIT 0x2109 "°{}F" "" "notermination=text" "" "" # DEGREE FAHRENHEIT
# mathrsfs has no small letters # mathrsfs has no small letters
#0x210a "" "" "" "\\mathscr{g}" "mathrsfs" # SCRIPT SMALL G #0x210a "" "" "" "\\mathscr{g}" "mathrsfs" # SCRIPT SMALL G
0x210b "" "" "" "\\mathscr{H}" "mathrsfs" # SCRIPT CAPITAL H 0x210b "" "" "" "\\mathscr{H}" "mathrsfs" # SCRIPT CAPITAL H
0x210c "" "" "" "\\mathfrak{H}" "amssymb" # BLACK-LETTER CAPITAL H 0x210c "" "" "" "\\mathfrak{H}" "amssymb" # BLACK-LETTER CAPITAL H
0x210d "" "" "" "\\mathbb{H}" "amssymb" # DOUBLE-STUCK CAPITAL H 0x210d "" "" "" "\\mathbb{H}" "amssymb" # DOUBLE-STUCK CAPITAL H
0x210e "" "" "" "h" # PLANCK CONSTANT 0x210e "" "" "notermination=math" "h" # PLANCK CONSTANT
0x210f "" "" "" "\\hbar" "amssymb" # PLANCK CONSTANT OVER TWO PI 0x210f "" "" "" "\\hbar" "amssymb" # PLANCK CONSTANT OVER TWO PI
0x2110 "" "" "" "\\mathscr{I}" "mathrsfs" # SCRIPT CAPITAL I 0x2110 "" "" "" "\\mathscr{I}" "mathrsfs" # SCRIPT CAPITAL I
0x2111 "" "" "" "\\mathfrak{I}" "amssymb" # BLACK-LETTER CAPITAL I 0x2111 "" "" "" "\\mathfrak{I}" "amssymb" # BLACK-LETTER CAPITAL I
@ -1748,7 +1753,7 @@
0x2127 "\\textmho" "textcomp" "" "\\mho" "amssymb" # INVERTED OHM SIGN 0x2127 "\\textmho" "textcomp" "" "\\mho" "amssymb" # INVERTED OHM SIGN
0x2128 "" "" "" "\\mathfrak{Z}" "amssymb" # BLACK-LETTER CAPITAL Z 0x2128 "" "" "" "\\mathfrak{Z}" "amssymb" # BLACK-LETTER CAPITAL Z
#0x2129 "" "" "" "" "" # TURNED GREEK SMALL LETTER IOTA #0x2129 "" "" "" "" "" # TURNED GREEK SMALL LETTER IOTA
0x212a "K" "" "notermination" # KELVIN SIGN 0x212a "K" "" "notermination=text" "" "" # KELVIN SIGN
0x212b "\\AA" "" "" # ANGSTROM SIGN 0x212b "\\AA" "" "" # ANGSTROM SIGN
0x212c "" "" "" "\\mathscr{B}" "mathrsfs" # SCRIPT CAPITAL B 0x212c "" "" "" "\\mathscr{B}" "mathrsfs" # SCRIPT CAPITAL B
0x212d "" "" "" "\\mathfrak{C}" "amssymb" # BLACK-LETTER CAPITAL C 0x212d "" "" "" "\\mathfrak{C}" "amssymb" # BLACK-LETTER CAPITAL C
@ -1843,15 +1848,15 @@
0x2193 "\\textdownarrow" "textcomp" "" "\\downarrow" # DOWNWARDS ARROW 0x2193 "\\textdownarrow" "textcomp" "" "\\downarrow" # DOWNWARDS ARROW
0x2194 "" "" "" "\\leftrightarrow" # LEFT RIGHT ARROW 0x2194 "" "" "" "\\leftrightarrow" # LEFT RIGHT ARROW
0x2195 "" "" "" "\\updownarrow" # UP DOWN ARROW 0x2195 "" "" "" "\\updownarrow" # UP DOWN ARROW
0x2196 "Home" "" "notermination" "\\nwarrow" "amssymb" # Qt::Key_Home, NORTH WEST ARROW 0x2196 "Home" "" "notermination=text" "\\nwarrow" "amssymb" # Qt::Key_Home, NORTH WEST ARROW
0x2198 "End" "" "notermination" "\\searrow" "" # Qt::Key_End, SOUTH EAST ARROW 0x2198 "End" "" "notermination=text" "\\searrow" "" # Qt::Key_End, SOUTH EAST ARROW
0x21a8 "{\\ascii\\ETB}" "ascii" "" # UP DOWN ARROW WITH BASE 0x21a8 "{\\ascii\\ETB}" "ascii" "" # UP DOWN ARROW WITH BASE
0x21b5 "{\\Pisymbol{psy}{191}}" "pifont" "" # DOWNWARDS ARROW WITH CORNER LEFTWARDS, Return key 0x21b5 "{\\Pisymbol{psy}{191}}" "pifont" "" # DOWNWARDS ARROW WITH CORNER LEFTWARDS, Return key
0x21de "Option-Up Arrow" "" "notermination" "" # Qt::Key_PageUp, UPWARDS ARROW WITH DOUBLE STROKE = page up 0x21de "Option-Up Arrow" "" "notermination=text" "" "" # Qt::Key_PageUp, UPWARDS ARROW WITH DOUBLE STROKE = page up
0x21df "Option-Down Arrow" "" "notermination" "" # Qt::Key_PageDown, DOWNWARDS ARROW WITH DOUBLE STROKE = page down 0x21df "Option-Down Arrow" "" "notermination=text" "" "" # Qt::Key_PageDown, DOWNWARDS ARROW WITH DOUBLE STROKE = page down
0x21e4 "Shift-Tab" "" "notermination" "" # Qt::Key_Backtab, LEFTWARDS ARROW TO BAR = leftward tab 0x21e4 "Shift-Tab" "" "notermination=text" "" "" # Qt::Key_Backtab, LEFTWARDS ARROW TO BAR = leftward tab
0x21e5 "Tab" "" "notermination" "" # Qt::Key_Tab, RIGHTWARDS ARROW TO BAR = rightward tab 0x21e5 "Tab" "" "notermination=text" "" "" # Qt::Key_Tab, RIGHTWARDS ARROW TO BAR = rightward tab
0x21ea "Caps Lock" "" "notermination" "" # Qt::Key_CapsLock, UPWARDS WHITE ARROW FROM BAR = caps lock 0x21ea "Caps Lock" "" "notermination=text" "" "" # Qt::Key_CapsLock, UPWARDS WHITE ARROW FROM BAR = caps lock
# #
# mathematical operators # mathematical operators
# #
@ -1873,7 +1878,7 @@
0x220f "" "" "" "\\prod" # N-ARY PRODUCT 0x220f "" "" "" "\\prod" # N-ARY PRODUCT
0x2210 "" "" "" "\\coprod" "" # N-ARY COPRODUCT 0x2210 "" "" "" "\\coprod" "" # N-ARY COPRODUCT
0x2211 "" "" "" "\\sum" # N-ARY SUMMATION 0x2211 "" "" "" "\\sum" # N-ARY SUMMATION
0x2212 "\\textminus" "textcomp" "" "-" "" # MINUS SIGN 0x2212 "\\textminus" "textcomp" "notermination=math" "-" "" # MINUS SIGN
0x2213 "" "" "" "\\mp" "" # MINUS-OR-PLUS SIGN 0x2213 "" "" "" "\\mp" "" # MINUS-OR-PLUS SIGN
0x2214 "" "" "" "\\dotplus" "amssymb" # DOT PLUS 0x2214 "" "" "" "\\dotplus" "amssymb" # DOT PLUS
0x2215 "" "" "" "\\slash" # DIVISION SLASH 0x2215 "" "" "" "\\slash" # DIVISION SLASH
@ -1967,10 +1972,10 @@
0x231a "\\Clocklogo" "marvosym" "" # WATCH 0x231a "\\Clocklogo" "marvosym" "" # WATCH
#0x2320 "" "" "" # TOP HALF INTEGRAL #0x2320 "" "" "" # TOP HALF INTEGRAL
#0x2321 "" "" "" # BOTTOM HALF INTEGRAL #0x2321 "" "" "" # BOTTOM HALF INTEGRAL
0x2326 "Delete" "" "notermination" "" # Qt::Key_Delete, ERASE TO THE RIGHT = delete to the right key 0x2326 "Delete" "" "notermination=text" "" "" # Qt::Key_Delete, ERASE TO THE RIGHT = delete to the right key
0x2328 "\\Keyboard" "marvosym" "" # KEYBOARD 0x2328 "\\Keyboard" "marvosym" "" # KEYBOARD
0x232b "Backspace" "" "notermination" "" # Qt::Key_Backspace, ERASE TO THE LEFT = delete to the left key 0x232b "Backspace" "" "notermination=text" "" "" # Qt::Key_Backspace, ERASE TO THE LEFT = delete to the left key
0x238b "Escape" "" "notermination" "" # Qt::Key_Escape, BROKEN CIRCLE WITH NORTHWEST ARROW = escape 0x238b "Escape" "" "notermination=text" "" "" # Qt::Key_Escape, BROKEN CIRCLE WITH NORTHWEST ARROW = escape
# #
# control pictures # control pictures
# #
@ -2267,11 +2272,11 @@
# #
# ligatures # ligatures
# #
0xfb00 "ff" "" "force,notermination" # LATIN SMALL LIGATURE FF 0xfb00 "ff" "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FF
0xfb01 "fi" "" "force,notermination" # LATIN SMALL LIGATURE FI 0xfb01 "fi" "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FI
0xfb02 "fl" "" "force,notermination" # LATIN SMALL LIGATURE FL 0xfb02 "fl" "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FL
0xfb03 "ffi" "" "force,notermination" # LATIN SMALL LIGATURE FFI 0xfb03 "ffi" "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FFI
0xfb04 "ffl" "" "force,notermination" # LATIN SMALL LIGATURE FFL 0xfb04 "ffl" "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FFL
# #
# mathematical alphanumeric symbols # mathematical alphanumeric symbols
# #
@ -2327,57 +2332,57 @@
0x1d431 "" "" "" "\\mathbf{x}" "" # 𝐱 MATHEMATICAL BOLD SMALL X 0x1d431 "" "" "" "\\mathbf{x}" "" # 𝐱 MATHEMATICAL BOLD SMALL X
0x1d432 "" "" "" "\\mathbf{y}" "" # 𝐲 MATHEMATICAL BOLD SMALL Y 0x1d432 "" "" "" "\\mathbf{y}" "" # 𝐲 MATHEMATICAL BOLD SMALL Y
0x1d433 "" "" "" "\\mathbf{z}" "" # 𝐳 MATHEMATICAL BOLD SMALL Z 0x1d433 "" "" "" "\\mathbf{z}" "" # 𝐳 MATHEMATICAL BOLD SMALL Z
0x1d434 "" "" "" "A" "" # 𝐴 MATHEMATICAL ITALIC CAPITAL A 0x1d434 "" "" "notermination=math" "A" "" # 𝐴 MATHEMATICAL ITALIC CAPITAL A
0x1d435 "" "" "" "B" "" # 𝐵 MATHEMATICAL ITALIC CAPITAL B 0x1d435 "" "" "notermination=math" "B" "" # 𝐵 MATHEMATICAL ITALIC CAPITAL B
0x1d436 "" "" "" "C" "" # 𝐶 MATHEMATICAL ITALIC CAPITAL C 0x1d436 "" "" "notermination=math" "C" "" # 𝐶 MATHEMATICAL ITALIC CAPITAL C
0x1d437 "" "" "" "D" "" # 𝐷 MATHEMATICAL ITALIC CAPITAL D 0x1d437 "" "" "notermination=math" "D" "" # 𝐷 MATHEMATICAL ITALIC CAPITAL D
0x1d438 "" "" "" "E" "" # 𝐸 MATHEMATICAL ITALIC CAPITAL E 0x1d438 "" "" "notermination=math" "E" "" # 𝐸 MATHEMATICAL ITALIC CAPITAL E
0x1d439 "" "" "" "F" "" # 𝐹 MATHEMATICAL ITALIC CAPITAL F 0x1d439 "" "" "notermination=math" "F" "" # 𝐹 MATHEMATICAL ITALIC CAPITAL F
0x1d43a "" "" "" "G" "" # 𝐺 MATHEMATICAL ITALIC CAPITAL G 0x1d43a "" "" "notermination=math" "G" "" # 𝐺 MATHEMATICAL ITALIC CAPITAL G
0x1d43b "" "" "" "H" "" # 𝐻 MATHEMATICAL ITALIC CAPITAL H 0x1d43b "" "" "notermination=math" "H" "" # 𝐻 MATHEMATICAL ITALIC CAPITAL H
0x1d43c "" "" "" "I" "" # 𝐼 MATHEMATICAL ITALIC CAPITAL I 0x1d43c "" "" "notermination=math" "I" "" # 𝐼 MATHEMATICAL ITALIC CAPITAL I
0x1d43d "" "" "" "J" "" # 𝐽 MATHEMATICAL ITALIC CAPITAL J 0x1d43d "" "" "notermination=math" "J" "" # 𝐽 MATHEMATICAL ITALIC CAPITAL J
0x1d43e "" "" "" "K" "" # 𝐾 MATHEMATICAL ITALIC CAPITAL K 0x1d43e "" "" "notermination=math" "K" "" # 𝐾 MATHEMATICAL ITALIC CAPITAL K
0x1d43f "" "" "" "L" "" # 𝐿 MATHEMATICAL ITALIC CAPITAL L 0x1d43f "" "" "notermination=math" "L" "" # 𝐿 MATHEMATICAL ITALIC CAPITAL L
0x1d440 "" "" "" "M" "" # 𝑀 MATHEMATICAL ITALIC CAPITAL M 0x1d440 "" "" "notermination=math" "M" "" # 𝑀 MATHEMATICAL ITALIC CAPITAL M
0x1d441 "" "" "" "N" "" # 𝑁 MATHEMATICAL ITALIC CAPITAL N 0x1d441 "" "" "notermination=math" "N" "" # 𝑁 MATHEMATICAL ITALIC CAPITAL N
0x1d442 "" "" "" "O" "" # 𝑂 MATHEMATICAL ITALIC CAPITAL O 0x1d442 "" "" "notermination=math" "O" "" # 𝑂 MATHEMATICAL ITALIC CAPITAL O
0x1d443 "" "" "" "P" "" # 𝑃 MATHEMATICAL ITALIC CAPITAL P 0x1d443 "" "" "notermination=math" "P" "" # 𝑃 MATHEMATICAL ITALIC CAPITAL P
0x1d444 "" "" "" "Q" "" # 𝑄 MATHEMATICAL ITALIC CAPITAL Q 0x1d444 "" "" "notermination=math" "Q" "" # 𝑄 MATHEMATICAL ITALIC CAPITAL Q
0x1d445 "" "" "" "R" "" # 𝑅 MATHEMATICAL ITALIC CAPITAL R 0x1d445 "" "" "notermination=math" "R" "" # 𝑅 MATHEMATICAL ITALIC CAPITAL R
0x1d446 "" "" "" "S" "" # 𝑆 MATHEMATICAL ITALIC CAPITAL S 0x1d446 "" "" "notermination=math" "S" "" # 𝑆 MATHEMATICAL ITALIC CAPITAL S
0x1d447 "" "" "" "T" "" # 𝑇 MATHEMATICAL ITALIC CAPITAL T 0x1d447 "" "" "notermination=math" "T" "" # 𝑇 MATHEMATICAL ITALIC CAPITAL T
0x1d448 "" "" "" "U" "" # 𝑈 MATHEMATICAL ITALIC CAPITAL U 0x1d448 "" "" "notermination=math" "U" "" # 𝑈 MATHEMATICAL ITALIC CAPITAL U
0x1d449 "" "" "" "V" "" # 𝑉 MATHEMATICAL ITALIC CAPITAL V 0x1d449 "" "" "notermination=math" "V" "" # 𝑉 MATHEMATICAL ITALIC CAPITAL V
0x1d44a "" "" "" "W" "" # 𝑊 MATHEMATICAL ITALIC CAPITAL W 0x1d44a "" "" "notermination=math" "W" "" # 𝑊 MATHEMATICAL ITALIC CAPITAL W
0x1d44b "" "" "" "X" "" # 𝑋 MATHEMATICAL ITALIC CAPITAL X 0x1d44b "" "" "notermination=math" "X" "" # 𝑋 MATHEMATICAL ITALIC CAPITAL X
0x1d44c "" "" "" "Y" "" # 𝑌 MATHEMATICAL ITALIC CAPITAL Y 0x1d44c "" "" "notermination=math" "Y" "" # 𝑌 MATHEMATICAL ITALIC CAPITAL Y
0x1d44d "" "" "" "Z" "" # 𝑍 MATHEMATICAL ITALIC CAPITAL Z 0x1d44d "" "" "notermination=math" "Z" "" # 𝑍 MATHEMATICAL ITALIC CAPITAL Z
0x1d44e "" "" "" "a" "" # 𝑎 MATHEMATICAL ITALIC SMALL A 0x1d44e "" "" "notermination=math" "a" "" # 𝑎 MATHEMATICAL ITALIC SMALL A
0x1d44f "" "" "" "b" "" # 𝑏 MATHEMATICAL ITALIC SMALL B 0x1d44f "" "" "notermination=math" "b" "" # 𝑏 MATHEMATICAL ITALIC SMALL B
0x1d450 "" "" "" "c" "" # 𝑐 MATHEMATICAL ITALIC SMALL C 0x1d450 "" "" "notermination=math" "c" "" # 𝑐 MATHEMATICAL ITALIC SMALL C
0x1d451 "" "" "" "d" "" # 𝑑 MATHEMATICAL ITALIC SMALL D 0x1d451 "" "" "notermination=math" "d" "" # 𝑑 MATHEMATICAL ITALIC SMALL D
0x1d452 "" "" "" "e" "" # 𝑒 MATHEMATICAL ITALIC SMALL E 0x1d452 "" "" "notermination=math" "e" "" # 𝑒 MATHEMATICAL ITALIC SMALL E
0x1d453 "" "" "" "f" "" # 𝑓 MATHEMATICAL ITALIC SMALL F 0x1d453 "" "" "notermination=math" "f" "" # 𝑓 MATHEMATICAL ITALIC SMALL F
0x1d454 "" "" "" "g" "" # 𝑔 MATHEMATICAL ITALIC SMALL G 0x1d454 "" "" "notermination=math" "g" "" # 𝑔 MATHEMATICAL ITALIC SMALL G
0x1d456 "" "" "" "i" "" # 𝑖 MATHEMATICAL ITALIC SMALL I 0x1d456 "" "" "notermination=math" "i" "" # 𝑖 MATHEMATICAL ITALIC SMALL I
0x1d457 "" "" "" "j" "" # 𝑗 MATHEMATICAL ITALIC SMALL J 0x1d457 "" "" "notermination=math" "j" "" # 𝑗 MATHEMATICAL ITALIC SMALL J
0x1d458 "" "" "" "k" "" # 𝑘 MATHEMATICAL ITALIC SMALL K 0x1d458 "" "" "notermination=math" "k" "" # 𝑘 MATHEMATICAL ITALIC SMALL K
0x1d459 "" "" "" "l" "" # 𝑙 MATHEMATICAL ITALIC SMALL L 0x1d459 "" "" "notermination=math" "l" "" # 𝑙 MATHEMATICAL ITALIC SMALL L
0x1d45a "" "" "" "m" "" # 𝑚 MATHEMATICAL ITALIC SMALL M 0x1d45a "" "" "notermination=math" "m" "" # 𝑚 MATHEMATICAL ITALIC SMALL M
0x1d45b "" "" "" "n" "" # 𝑛 MATHEMATICAL ITALIC SMALL N 0x1d45b "" "" "notermination=math" "n" "" # 𝑛 MATHEMATICAL ITALIC SMALL N
0x1d45c "" "" "" "o" "" # 𝑜 MATHEMATICAL ITALIC SMALL O 0x1d45c "" "" "notermination=math" "o" "" # 𝑜 MATHEMATICAL ITALIC SMALL O
0x1d45d "" "" "" "p" "" # 𝑝 MATHEMATICAL ITALIC SMALL P 0x1d45d "" "" "notermination=math" "p" "" # 𝑝 MATHEMATICAL ITALIC SMALL P
0x1d45e "" "" "" "q" "" # 𝑞 MATHEMATICAL ITALIC SMALL Q 0x1d45e "" "" "notermination=math" "q" "" # 𝑞 MATHEMATICAL ITALIC SMALL Q
0x1d45f "" "" "" "r" "" # 𝑟 MATHEMATICAL ITALIC SMALL R 0x1d45f "" "" "notermination=math" "r" "" # 𝑟 MATHEMATICAL ITALIC SMALL R
0x1d460 "" "" "" "s" "" # 𝑠 MATHEMATICAL ITALIC SMALL S 0x1d460 "" "" "notermination=math" "s" "" # 𝑠 MATHEMATICAL ITALIC SMALL S
0x1d461 "" "" "" "t" "" # 𝑡 MATHEMATICAL ITALIC SMALL T 0x1d461 "" "" "notermination=math" "t" "" # 𝑡 MATHEMATICAL ITALIC SMALL T
0x1d462 "" "" "" "u" "" # 𝑢 MATHEMATICAL ITALIC SMALL U 0x1d462 "" "" "notermination=math" "u" "" # 𝑢 MATHEMATICAL ITALIC SMALL U
0x1d463 "" "" "" "v" "" # 𝑣 MATHEMATICAL ITALIC SMALL V 0x1d463 "" "" "notermination=math" "v" "" # 𝑣 MATHEMATICAL ITALIC SMALL V
0x1d464 "" "" "" "w" "" # 𝑤 MATHEMATICAL ITALIC SMALL W 0x1d464 "" "" "notermination=math" "w" "" # 𝑤 MATHEMATICAL ITALIC SMALL W
0x1d465 "" "" "" "x" "" # 𝑥 MATHEMATICAL ITALIC SMALL X 0x1d465 "" "" "notermination=math" "x" "" # 𝑥 MATHEMATICAL ITALIC SMALL X
0x1d466 "" "" "" "y" "" # 𝑦 MATHEMATICAL ITALIC SMALL Y 0x1d466 "" "" "notermination=math" "y" "" # 𝑦 MATHEMATICAL ITALIC SMALL Y
0x1d467 "" "" "" "z" "" # 𝑧 MATHEMATICAL ITALIC SMALL Z 0x1d467 "" "" "notermination=math" "z" "" # 𝑧 MATHEMATICAL ITALIC SMALL Z
0x1d49c "" "" "" "\\mathcal{A}" "" # 𝒜 MATHEMATICAL SCRIPT CAPITAL A 0x1d49c "" "" "" "\\mathcal{A}" "" # 𝒜 MATHEMATICAL SCRIPT CAPITAL A
0x1d49e "" "" "" "\\mathcal{C}" "" # 𝒞 MATHEMATICAL SCRIPT CAPITAL C 0x1d49e "" "" "" "\\mathcal{C}" "" # 𝒞 MATHEMATICAL SCRIPT CAPITAL C
0x1d49f "" "" "" "\\mathcal{D}" "" # 𝒟 MATHEMATICAL SCRIPT CAPITAL D 0x1d49f "" "" "" "\\mathcal{D}" "" # 𝒟 MATHEMATICAL SCRIPT CAPITAL D

2
po/.gitignore vendored
View File

@ -3,3 +3,5 @@ POTFILES.in
lyx.pot lyx.pot
*.gmo *.gmo
stamp-po stamp-po
remove-potcdate.sed

733
po/de.po
View File

File diff suppressed because it is too large Load Diff

1169
po/sk.po
View File

File diff suppressed because it is too large Load Diff

5
src/BiblioInfo.cpp
View File

@ -169,14 +169,17 @@ docstring convertLaTeXCommands(docstring const & str)
// unicodesymbols has things in the form: \"{u}, // unicodesymbols has things in the form: \"{u},
// whereas we may see things like: \"u. So we'll // whereas we may see things like: \"u. So we'll
// look for that and change it, if necessary. // look for that and change it, if necessary.
// FIXME: This is a sort of mini-tex2lyx.
// Use the real tex2lyx instead!
static lyx::regex const reg("^\\\\\\W\\w"); static lyx::regex const reg("^\\\\\\W\\w");
if (lyx::regex_search(to_utf8(val), reg)) { if (lyx::regex_search(to_utf8(val), reg)) {
val.insert(3, from_ascii("}")); val.insert(3, from_ascii("}"));
val.insert(2, from_ascii("{")); val.insert(2, from_ascii("{"));
} }
bool termination;
docstring rem; docstring rem;
docstring const cnvtd = Encodings::fromLaTeXCommand(val, docstring const cnvtd = Encodings::fromLaTeXCommand(val,
Encodings::TEXT_CMD, rem); Encodings::TEXT_CMD, termination, rem);
if (!cnvtd.empty()) { if (!cnvtd.empty()) {
// it did, so we'll take that bit and proceed with what's left // it did, so we'll take that bit and proceed with what's left
ret += cnvtd; ret += cnvtd;

5
src/Buffer.cpp
View File

@ -1508,9 +1508,8 @@ void Buffer::writeLaTeXSource(otexstream & os,
Encoding const * const enc = runparams.encoding; Encoding const * const enc = runparams.encoding;
if (enc) { if (enc) {
for (size_t n = 0; n < inputpath.size(); ++n) { for (size_t n = 0; n < inputpath.size(); ++n) {
docstring const glyph = if (!enc->encodable(inputpath[n])) {
docstring(1, inputpath[n]); docstring const glyph(1, inputpath[n]);
if (enc->latexChar(inputpath[n], true) != glyph) {
LYXERR0("Uncodable character '" LYXERR0("Uncodable character '"
<< glyph << glyph
<< "' in input path!"); << "' in input path!");

2
src/Changes.cpp
View File

@ -357,7 +357,7 @@ docstring getLaTeXMarkup(docstring const & macro, docstring const & author,
docstring author_latexed; docstring author_latexed;
for (size_t n = 0; n < author.size(); ++n) { for (size_t n = 0; n < author.size(); ++n) {
try { try {
author_latexed += runparams.encoding->latexChar(author[n]); author_latexed += runparams.encoding->latexChar(author[n]).first;
} catch (EncodingException & /* e */) { } catch (EncodingException & /* e */) {
if (runparams.dryrun) { if (runparams.dryrun) {
ods << "<" << _("LyX Warning: ") ods << "<" << _("LyX Warning: ")

15
src/CutAndPaste.cpp
View File

@ -256,13 +256,13 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist,
if (ref->getParam("reference") == oldname) if (ref->getParam("reference") == oldname)
ref->setParam("reference", newname); ref->setParam("reference", newname);
} else if (itt->lyxCode() == MATH_REF_CODE) { } else if (itt->lyxCode() == MATH_REF_CODE) {
InsetMathHull * mi = itt->asInsetMath()->asHullInset(); InsetMathRef * mi = itt->asInsetMath()->asRefInset();
// this is necessary to prevent an uninitialized // this is necessary to prevent an uninitialized
// buffer when the RefInset is in a MathBox. // buffer when the RefInset is in a MathBox.
// FIXME audit setBuffer calls // FIXME audit setBuffer calls
mi->setBuffer(const_cast<Buffer &>(buffer)); mi->setBuffer(const_cast<Buffer &>(buffer));
if (mi->asRefInset()->getTarget() == oldname) if (mi->getTarget() == oldname)
mi->asRefInset()->changeTarget(newname); mi->changeTarget(newname);
} }
} }
} }
@ -286,14 +286,13 @@ pasteSelectionHelper(Cursor const & cur, ParagraphList const & parlist,
if (ref.getParam("reference") == oldname) if (ref.getParam("reference") == oldname)
ref.setParam("reference", newname); ref.setParam("reference", newname);
} else if (itt->lyxCode() == MATH_REF_CODE) { } else if (itt->lyxCode() == MATH_REF_CODE) {
InsetMathHull & mi = InsetMathRef * mi = itt->asInsetMath()->asRefInset();
static_cast<InsetMathHull &>(*itt);
// this is necessary to prevent an uninitialized // this is necessary to prevent an uninitialized
// buffer when the RefInset is in a MathBox. // buffer when the RefInset is in a MathBox.
// FIXME audit setBuffer calls // FIXME audit setBuffer calls
mi.setBuffer(const_cast<Buffer &>(buffer)); mi->setBuffer(const_cast<Buffer &>(buffer));
if (mi.asRefInset()->getTarget() == oldname) if (mi->getTarget() == oldname)
mi.asRefInset()->changeTarget(newname); mi->changeTarget(newname);
} }
} }
break; break;

161
src/Encoding.cpp
View File

@ -228,6 +228,21 @@ char_type const arabic_start = 0x0621;
char_type const arabic_end = 0x06cc; char_type const arabic_end = 0x06cc;
enum CharInfoFlags {
///
CharInfoCombining = 1,
///
CharInfoTextFeature = 2,
///
CharInfoMathFeature = 4,
///
CharInfoForce = 8,
///
CharInfoTextNoTermination = 16,
///
CharInfoMathNoTermination = 32,
};
/// Information about a single UCS4 character /// Information about a single UCS4 character
struct CharInfo { struct CharInfo {
/// LaTeX command (text mode) for this character /// LaTeX command (text mode) for this character
@ -239,20 +254,24 @@ struct CharInfo {
/// Needed LaTeX preamble (or feature) for math mode /// Needed LaTeX preamble (or feature) for math mode
string mathpreamble; string mathpreamble;
/// Is this a combining character? /// Is this a combining character?
bool combining; bool combining() const { return flags & CharInfoCombining ? true : false; }
/// Is \c textpreamble a feature known by LaTeXFeatures, or a raw LaTeX /// Is \c textpreamble a feature known by LaTeXFeatures, or a raw LaTeX
/// command? /// command?
bool textfeature; bool textfeature() const { return flags & CharInfoTextFeature ? true : false; }
/// Is \c mathpreamble a feature known by LaTeXFeatures, or a raw LaTeX /// Is \c mathpreamble a feature known by LaTeXFeatures, or a raw LaTeX
/// command? /// command?
bool mathfeature; bool mathfeature() const { return flags & CharInfoMathFeature ? true : false; }
/// Always force the LaTeX command, even if the encoding contains /// Always force the LaTeX command, even if the encoding contains
/// this character? /// this character?
bool force; bool force() const { return flags & CharInfoForce ? true : false; }
/// TIPA shortcut /// TIPA shortcut
string tipashortcut; string tipashortcut;
/// This macro needs no termination (such as {} or space). /// \c textcommand needs no termination (such as {} or space).
bool notermination; bool textnotermination() const { return flags & CharInfoTextNoTermination ? true : false; }
/// \c mathcommand needs no termination (such as {} or space).
bool mathnotermination() const { return flags & CharInfoMathNoTermination ? true : false; }
///
unsigned int flags;
}; };
@ -320,7 +339,7 @@ void Encoding::init() const
continue; continue;
char_type const uc = ucs4[0]; char_type const uc = ucs4[0];
CharInfoMap::const_iterator const it = unicodesymbols.find(uc); CharInfoMap::const_iterator const it = unicodesymbols.find(uc);
if (it == unicodesymbols.end() || !it->second.force) if (it == unicodesymbols.end() || !it->second.force())
encodable_.insert(uc); encodable_.insert(uc);
} }
} else { } else {
@ -332,7 +351,7 @@ void Encoding::init() const
vector<char> const eightbit = ucs4_to_eightbit(&c, 1, iconvName_); vector<char> const eightbit = ucs4_to_eightbit(&c, 1, iconvName_);
if (!eightbit.empty()) { if (!eightbit.empty()) {
CharInfoMap::const_iterator const it = unicodesymbols.find(c); CharInfoMap::const_iterator const it = unicodesymbols.find(c);
if (it == unicodesymbols.end() || !it->second.force) if (it == unicodesymbols.end() || !it->second.force())
encodable_.insert(c); encodable_.insert(c);
} }
} }
@ -348,19 +367,25 @@ void Encoding::init() const
} }
docstring Encoding::latexChar(char_type c, bool no_commands) const bool Encoding::encodable(char_type c) const
{ {
// assure the used encoding is properly initialized // assure the used encoding is properly initialized
init(); init();
if (iconvName_ == "UTF-8" && package_ == none) if (iconvName_ == "UTF-8" && package_ == none)
return docstring(1, c); return true;
if (c < start_encodable_ && !encodings.isForced(c)) if (c < start_encodable_ && !encodings.isForced(c))
return docstring(1, c); return true;
if (encodable_.find(c) != encodable_.end()) if (encodable_.find(c) != encodable_.end())
return docstring(1, c); return true;
if (no_commands) return false;
return docstring(); }
pair<docstring, bool> Encoding::latexChar(char_type c) const
{
if (encodable(c))
return make_pair(docstring(1, c), false);
// c cannot (or should not) be encoded in this encoding // c cannot (or should not) be encoded in this encoding
CharInfoMap::const_iterator const it = unicodesymbols.find(c); CharInfoMap::const_iterator const it = unicodesymbols.find(c);
@ -368,8 +393,9 @@ docstring Encoding::latexChar(char_type c, bool no_commands) const
throw EncodingException(c); throw EncodingException(c);
// at least one of mathcommand and textcommand is nonempty // at least one of mathcommand and textcommand is nonempty
if (it->second.textcommand.empty()) if (it->second.textcommand.empty())
return "\\ensuremath{" + it->second.mathcommand + '}'; return make_pair(
return it->second.textcommand; "\\ensuremath{" + it->second.mathcommand + '}', false);
return make_pair(it->second.textcommand, !it->second.textnotermination());
} }
@ -393,10 +419,14 @@ vector<char_type> Encoding::symbolsList() const
bool Encodings::latexMathChar(char_type c, bool mathmode, bool Encodings::latexMathChar(char_type c, bool mathmode,
Encoding const * encoding, docstring & command) Encoding const * encoding, docstring & command,
bool & needsTermination)
{ {
command = empty_docstring();
if (encoding) if (encoding)
command = encoding->latexChar(c, true); if (encoding->encodable(c))
command = docstring(1, c);
needsTermination = false;
CharInfoMap::const_iterator const it = unicodesymbols.find(c); CharInfoMap::const_iterator const it = unicodesymbols.find(c);
if (it == unicodesymbols.end()) { if (it == unicodesymbols.end()) {
@ -411,10 +441,12 @@ bool Encodings::latexMathChar(char_type c, bool mathmode,
(!mathmode && it->second.textcommand.empty()); (!mathmode && it->second.textcommand.empty());
if (use_math) { if (use_math) {
command = it->second.mathcommand; command = it->second.mathcommand;
needsTermination = !it->second.mathnotermination();
addMathCmd(c); addMathCmd(c);
} else { } else {
if (!encoding || command.empty()) { if (!encoding || command.empty()) {
command = it->second.textcommand; command = it->second.textcommand;
needsTermination = !it->second.textnotermination();
addTextCmd(c); addTextCmd(c);
} }
if (mathmode) if (mathmode)
@ -425,35 +457,40 @@ bool Encodings::latexMathChar(char_type c, bool mathmode,
char_type Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype, char_type Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
bool & combining, set<string> * req) bool & combining, bool & needsTermination, set<string> * req)
{ {
CharInfoMap::const_iterator const end = unicodesymbols.end(); CharInfoMap::const_iterator const end = unicodesymbols.end();
CharInfoMap::const_iterator it = unicodesymbols.begin(); CharInfoMap::const_iterator it = unicodesymbols.begin();
for (combining = false; it != end; ++it) { for (combining = false; it != end; ++it) {
docstring const math = it->second.mathcommand; docstring const math = it->second.mathcommand;
docstring const text = it->second.textcommand; docstring const text = it->second.textcommand;
if ((cmdtype && MATH_CMD) && math == cmd) { if ((cmdtype & MATH_CMD) && math == cmd) {
combining = it->second.combining; combining = it->second.combining();
if (req && it->second.mathfeature && needsTermination = !it->second.mathnotermination();
if (req && it->second.mathfeature() &&
!it->second.mathpreamble.empty()) !it->second.mathpreamble.empty())
req->insert(it->second.mathpreamble); req->insert(it->second.mathpreamble);
return it->first; return it->first;
} }
if ((cmdtype & TEXT_CMD) && text == cmd) { if ((cmdtype & TEXT_CMD) && text == cmd) {
combining = it->second.combining; combining = it->second.combining();
if (req && it->second.textfeature && needsTermination = !it->second.textnotermination();
if (req && it->second.textfeature() &&
!it->second.textpreamble.empty()) !it->second.textpreamble.empty())
req->insert(it->second.textpreamble); req->insert(it->second.textpreamble);
return it->first; return it->first;
} }
} }
needsTermination = false;
return 0; return 0;
} }
docstring Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype, docstring Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
docstring & rem, set<string> * req) bool & needsTermination, docstring & rem, set<string> * req)
{ {
needsTermination = false;
rem = empty_docstring();
bool const mathmode = cmdtype & MATH_CMD; bool const mathmode = cmdtype & MATH_CMD;
bool const textmode = cmdtype & TEXT_CMD; bool const textmode = cmdtype & TEXT_CMD;
docstring symbols; docstring symbols;
@ -536,11 +573,15 @@ docstring Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
j = k - 1; j = k - 1;
i = j + 1; i = j + 1;
unicmd_size = cur_size; unicmd_size = cur_size;
if (math == tmp)
needsTermination = !it->second.mathnotermination();
else
needsTermination = !it->second.textnotermination();
if (req) { if (req) {
if (math == tmp && it->second.mathfeature && if (math == tmp && it->second.mathfeature() &&
!it->second.mathpreamble.empty()) !it->second.mathpreamble.empty())
req->insert(it->second.mathpreamble); req->insert(it->second.mathpreamble);
if (text == tmp && it->second.textfeature && if (text == tmp && it->second.textfeature() &&
!it->second.textpreamble.empty()) !it->second.textpreamble.empty())
req->insert(it->second.textpreamble); req->insert(it->second.textpreamble);
} }
@ -548,9 +589,20 @@ docstring Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
} }
if (unicmd_size) if (unicmd_size)
symbols += c; symbols += c;
else if (j + 1 == cmdend) else if (j + 1 == cmdend) {
// No luck. Return what remains // No luck. Return what remains
rem = cmd.substr(i); rem = cmd.substr(i);
if (needsTermination && !rem.empty()) {
if (rem.substr(0, 2) == "{}") {
rem = rem.substr(2);
needsTermination = false;
} else if (rem[0] == ' ') {
needsTermination = false;
// LaTeX would swallow all spaces
rem = ltrim(rem);
}
}
}
} }
return symbols; return symbols;
} }
@ -609,7 +661,7 @@ void Encodings::validate(char_type c, LaTeXFeatures & features, bool for_mathed)
// with utf8-plain, we only load packages when in mathed (see #7766) // with utf8-plain, we only load packages when in mathed (see #7766)
if (math_mode || (use_math && !plain_utf8)) { if (math_mode || (use_math && !plain_utf8)) {
if (!it->second.mathpreamble.empty()) { if (!it->second.mathpreamble.empty()) {
if (it->second.mathfeature) { if (it->second.mathfeature()) {
string feats = it->second.mathpreamble; string feats = it->second.mathpreamble;
while (!feats.empty()) { while (!feats.empty()) {
string feat; string feat;
@ -623,7 +675,7 @@ void Encodings::validate(char_type c, LaTeXFeatures & features, bool for_mathed)
// with utf8-plain, we do not load packages (see #7766) // with utf8-plain, we do not load packages (see #7766)
if (use_text && !plain_utf8) { if (use_text && !plain_utf8) {
if (!it->second.textpreamble.empty()) { if (!it->second.textpreamble.empty()) {
if (it->second.textfeature) { if (it->second.textfeature()) {
string feats = it->second.textpreamble; string feats = it->second.textpreamble;
while (!feats.empty()) { while (!feats.empty()) {
string feat; string feat;
@ -684,7 +736,7 @@ bool Encodings::isCombiningChar(char_type c)
{ {
CharInfoMap::const_iterator const it = unicodesymbols.find(c); CharInfoMap::const_iterator const it = unicodesymbols.find(c);
if (it != unicodesymbols.end()) if (it != unicodesymbols.end())
return it->second.combining; return it->second.combining();
return false; return false;
} }
@ -728,15 +780,6 @@ bool Encodings::isMathAlpha(char_type c)
} }
bool Encodings::needsTermination(char_type c)
{
CharInfoMap::const_iterator const it = unicodesymbols.find(c);
if (it != unicodesymbols.end())
return !it->second.notermination;
return true;
}
Encoding const * Encodings::fromLyXName(string const & name) const Encoding const * Encodings::fromLyXName(string const & name) const
{ {
EncodingList::const_iterator const it = encodinglist.find(name); EncodingList::const_iterator const it = encodinglist.find(name);
@ -806,22 +849,31 @@ void Encodings::read(FileName const & encfile, FileName const & symbolsfile)
break; break;
flags = symbolslex.getString(); flags = symbolslex.getString();
info.combining = false; info.flags = 0;
info.textfeature = false; if (suffixIs(info.textcommand, '}'))
info.force = false; info.flags |= CharInfoTextNoTermination;
info.notermination = false; if (suffixIs(info.mathcommand, '}'))
info.flags |= CharInfoMathNoTermination;
while (!flags.empty()) { while (!flags.empty()) {
string flag; string flag;
flags = split(flags, flag, ','); flags = split(flags, flag, ',');
if (flag == "combining") { if (flag == "combining") {
info.combining = true; info.flags |= CharInfoCombining;
} else if (flag == "force") { } else if (flag == "force") {
info.force = true; info.flags |= CharInfoForce;
forced.insert(symbol); forced.insert(symbol);
} else if (flag == "mathalpha") { } else if (flag == "mathalpha") {
mathalpha.insert(symbol); mathalpha.insert(symbol);
} else if (flag == "notermination") { } else if (flag == "notermination=text") {
info.notermination = true; info.flags |= CharInfoTextNoTermination;
} else if (flag == "notermination=math") {
info.flags |= CharInfoMathNoTermination;
} else if (flag == "notermination=both") {
info.flags |= CharInfoTextNoTermination;
info.flags |= CharInfoMathNoTermination;
} else if (flag == "notermination=none") {
info.flags &= ~CharInfoTextNoTermination;
info.flags &= ~CharInfoMathNoTermination;
} else if (contains(flag, "tipashortcut=")) { } else if (contains(flag, "tipashortcut=")) {
info.tipashortcut = split(flag, '='); info.tipashortcut = split(flag, '=');
} else { } else {
@ -861,15 +913,18 @@ void Encodings::read(FileName const & encfile, FileName const & symbolsfile)
info.mathpreamble = "esint|amsmath"; info.mathpreamble = "esint|amsmath";
if (!info.textpreamble.empty()) if (!info.textpreamble.empty())
info.textfeature = info.textpreamble[0] != '\\'; if (info.textpreamble[0] != '\\')
info.flags |= CharInfoTextFeature;
if (!info.mathpreamble.empty()) if (!info.mathpreamble.empty())
info.mathfeature = info.mathpreamble[0] != '\\'; if (info.mathpreamble[0] != '\\')
info.flags |= CharInfoMathFeature;
LYXERR(Debug::INFO, "Read unicode symbol " << symbol << " '" LYXERR(Debug::INFO, "Read unicode symbol " << symbol << " '"
<< to_utf8(info.textcommand) << "' '" << info.textpreamble << to_utf8(info.textcommand) << "' '" << info.textpreamble
<< "' " << info.combining << ' ' << info.textfeature << " '" << info.textfeature() << ' ' << info.textnotermination()
<< " '" << to_utf8(info.mathcommand) << "' '" << ' ' << to_utf8(info.mathcommand) << "' '" << info.mathpreamble
<< info.mathpreamble << "' " << info.mathfeature); << "' " << info.mathfeature() << ' ' << info.mathnotermination()
<< ' ' << info.combining() << ' ' << info.force());
// we assume that at least one command is nonempty when using unicodesymbols // we assume that at least one command is nonempty when using unicodesymbols
if (!info.textcommand.empty() || !info.mathcommand.empty()) if (!info.textcommand.empty() || !info.mathcommand.empty())

28
src/Encoding.h
View File

@ -67,6 +67,8 @@ public:
std::string const & iconvName() const { return iconvName_; } std::string const & iconvName() const { return iconvName_; }
/// ///
bool const & hasFixedWidth() const { return fixedwidth_; } bool const & hasFixedWidth() const { return fixedwidth_; }
/// \p c is representable in this encoding without a LaTeX macro
bool encodable(char_type c) const;
/** /**
* Convert \p c to something that LaTeX can understand. * Convert \p c to something that LaTeX can understand.
* This is either the character itself (if it is representable * This is either the character itself (if it is representable
@ -74,8 +76,10 @@ public:
* If the character is not representable in this encoding, but no * If the character is not representable in this encoding, but no
* LaTeX macro is known, a warning is given of lyxerr, and the * LaTeX macro is known, a warning is given of lyxerr, and the
* character is returned. * character is returned.
* \return the converted character and a flag indicating whether
* the command needs to be terminated by {} or a space.
*/ */
docstring latexChar(char_type c, bool no_commands = false) const; std::pair<docstring, bool> latexChar(char_type c) const;
/// Which LaTeX package handles this encoding? /// Which LaTeX package handles this encoding?
Package package() const { return package_; } Package package() const { return package_; }
/// A list of all characters usable in this encoding /// A list of all characters usable in this encoding
@ -195,11 +199,6 @@ public:
* letters and accented characters that are output as math commands. * letters and accented characters that are output as math commands.
*/ */
static bool isMathAlpha(char_type c); static bool isMathAlpha(char_type c);
/**
* Do we need to terminate this command (by {} or space)?
* This is true if the "notermination" flag is not set.
*/
static bool needsTermination(char_type c);
/** /**
* Register \p c as a mathmode command. * Register \p c as a mathmode command.
*/ */
@ -231,16 +230,22 @@ public:
/** /**
* If \p c cannot be encoded in the given \p encoding, convert * If \p c cannot be encoded in the given \p encoding, convert
* it to something that LaTeX can understand in mathmode. * it to something that LaTeX can understand in mathmode.
* \p needsTermination indicates whether the command needs to be
* terminated by {} or a space.
* \return whether \p command is a mathmode command * \return whether \p command is a mathmode command
*/ */
static bool latexMathChar(char_type c, bool mathmode, static bool latexMathChar(char_type c, bool mathmode,
Encoding const * encoding, docstring & command); Encoding const * encoding, docstring & command,
bool & needsTermination);
/** /**
* Convert the LaTeX command in \p cmd to the corresponding unicode * Convert the LaTeX command in \p cmd to the corresponding unicode
* point and set \p combining to true if it is a combining symbol * point and set \p combining to true if it is a combining symbol.
* \p needsTermination indicates whether the command needs to be
* terminated by {} or a space.
*/ */
static char_type fromLaTeXCommand(docstring const & cmd, int cmdtype, static char_type fromLaTeXCommand(docstring const & cmd, int cmdtype,
bool & combining, std::set<std::string> * req = 0); bool & combining, bool & needsTermination,
std::set<std::string> * req = 0);
/// ///
enum LatexCmd { enum LatexCmd {
/// ///
@ -255,9 +260,12 @@ public:
* unconverted commands are returned in \p rem. * unconverted commands are returned in \p rem.
* The \p cmdtype parameter can be used to limit recognized * The \p cmdtype parameter can be used to limit recognized
* commands to math or text mode commands only. * commands to math or text mode commands only.
* \p needsTermination indicates whether the command needs to be
* terminated by {} or a space.
*/ */
static docstring fromLaTeXCommand(docstring const & cmd, int cmdtype, static docstring fromLaTeXCommand(docstring const & cmd, int cmdtype,
docstring & rem, std::set<std::string> * req = 0); bool & needsTermination, docstring & rem,
std::set<std::string> * req = 0);
/** /**
* Add the preamble snippet needed for the output of \p c to * Add the preamble snippet needed for the output of \p c to
* \p features. * \p features.

2
src/LaTeXFeatures.cpp
View File

@ -1159,7 +1159,7 @@ docstring const getFloatI18nPreamble(docstring const & type,
// Check whether name can be encoded in the buffer encoding // Check whether name can be encoded in the buffer encoding
bool encodable = true; bool encodable = true;
for (size_t i = 0; i < name.size(); ++i) { for (size_t i = 0; i < name.size(); ++i) {
if (enc.latexChar(name[i], true)[0] != name[i]) { if (!enc.encodable(name[i])) {
encodable = false; encodable = false;
break; break;
} }

2
src/Layout.cpp
View File

@ -893,7 +893,7 @@ docstring const i18npreamble(Language const * lang, Encoding const & enc,
// Check whether name can be encoded in the buffer encoding // Check whether name can be encoded in the buffer encoding
bool encodable = true; bool encodable = true;
for (size_t i = 0; i < name.size(); ++i) { for (size_t i = 0; i < name.size(); ++i) {
if (enc.latexChar(name[i], true)[0] != name[i]) { if (!enc.encodable(name[i])) {
encodable = false; encodable = false;
break; break;
} }

2
src/PDFOptions.cpp
View File

@ -150,7 +150,7 @@ void PDFOptions::writeLaTeX(OutputParams & runparams, otexstream & os,
bool need_unicode = false; bool need_unicode = false;
if (enc) { if (enc) {
for (size_t n = 0; n < hs.size(); ++n) { for (size_t n = 0; n < hs.size(); ++n) {
if (enc->latexChar(hs[n], true) != docstring(1, hs[n])) if (!enc->encodable(hs[n]))
need_unicode = true; need_unicode = true;
} }
} }

42
src/Paragraph.cpp
View File

@ -858,8 +858,8 @@ int Paragraph::Private::latexSurrogatePair(otexstream & os, char_type c,
// FIXME: change tracking // FIXME: change tracking
// Is this correct WRT change tracking? // Is this correct WRT change tracking?
Encoding const & encoding = *(runparams.encoding); Encoding const & encoding = *(runparams.encoding);
docstring const latex1 = encoding.latexChar(next); docstring const latex1 = encoding.latexChar(next).first;
docstring const latex2 = encoding.latexChar(c); docstring const latex2 = encoding.latexChar(c).first;
if (docstring(1, next) == latex1) { if (docstring(1, next) == latex1) {
// the encoding supports the combination // the encoding supports the combination
os << latex2 << latex1; os << latex2 << latex1;
@ -975,7 +975,7 @@ int Paragraph::Private::writeScriptChars(otexstream & os,
// Stop here if there is a font attribute or encoding change. // Stop here if there is a font attribute or encoding change.
if (found && cit != end && prev_font != cit->font()) if (found && cit != end && prev_font != cit->font())
break; break;
docstring const latex = encoding.latexChar(next); docstring const latex = encoding.latexChar(next).first;
docstring::size_type const b1 = docstring::size_type const b1 =
latex.find_first_of(from_ascii("{")); latex.find_first_of(from_ascii("{"));
docstring::size_type const b2 = docstring::size_type const b2 =
@ -1168,7 +1168,7 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
if (style.pass_thru || runparams.pass_thru) { if (style.pass_thru || runparams.pass_thru) {
if (c != '\0') { if (c != '\0') {
Encoding const * const enc = runparams.encoding; Encoding const * const enc = runparams.encoding;
if (enc && enc->latexChar(c, true).empty()) if (enc && !enc->encodable(c))
throw EncodingException(c); throw EncodingException(c);
os.put(c); os.put(c);
} }
@ -1273,41 +1273,41 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
} }
} }
string script; string script;
docstring latex = encoding.latexChar(c); pair<docstring, bool> latex = encoding.latexChar(c);
docstring nextlatex; docstring nextlatex;
if (next != '\0' && next != META_INSET) if (next != '\0' && next != META_INSET)
nextlatex = encoding.latexChar(next); nextlatex = encoding.latexChar(next).first;
bool tipas = false; bool tipas = false;
if (runparams.inIPA) { if (runparams.inIPA) {
string const tipashortcut = Encodings::TIPAShortcut(c); string const tipashortcut = Encodings::TIPAShortcut(c);
if (!tipashortcut.empty()) { if (!tipashortcut.empty()) {
latex = from_ascii(tipashortcut); latex.first = from_ascii(tipashortcut);
latex.second = false;
tipas = true; tipas = true;
} }
} }
if (Encodings::isKnownScriptChar(c, script) if (Encodings::isKnownScriptChar(c, script)
&& prefixIs(latex, from_ascii("\\" + script))) && prefixIs(latex.first, from_ascii("\\" + script)))
column += writeScriptChars(os, latex, column += writeScriptChars(os, latex.first,
running_change, encoding, i) - 1; running_change, encoding, i) - 1;
else if (Encodings::needsTermination(c) else if (latex.second
&& !prefixIs(nextlatex, from_ascii("\\")) && !prefixIs(nextlatex, '\\')
&& !prefixIs(nextlatex, from_ascii("{")) && !prefixIs(nextlatex, '{')
&& !prefixIs(nextlatex, from_ascii("}")) && !prefixIs(nextlatex, '}')
&& latex.length() > 1 && latex[latex.length() - 1] != '}' && !tipas) {
&& latex[latex.length() - 1] != '-' && !tipas) {
// Prevent eating of a following // Prevent eating of a following
// space or command corruption by // space or command corruption by
// following characters // following characters
if (next == ' ' || next == '\0') { if (next == ' ' || next == '\0') {
column += latex.length() + 1; column += latex.first.length() + 1;
os << latex << "{}"; os << latex.first << "{}";
} else { } else {
column += latex.length(); column += latex.first.length();
os << latex << " "; os << latex.first << " ";
} }
} else { } else {
column += latex.length() - 1; column += latex.first.length() - 1;
os << latex; os << latex.first;
} }
break; break;
} }

3
src/frontends/qt4/GuiBranches.cpp
View File

@ -37,6 +37,9 @@
#include <QColor> #include <QColor>
#include <QColorDialog> #include <QColorDialog>
#ifdef KeyPress
#undef KeyPress
#endif
namespace lyx { namespace lyx {
namespace frontend { namespace frontend {

2
src/insets/InsetBibitem.cpp
View File

@ -294,7 +294,7 @@ docstring bibitemWidest(Buffer const & buffer, OutputParams const & runparams)
docstring latex_lbl; docstring latex_lbl;
for (size_t n = 0; n < lbl.size(); ++n) { for (size_t n = 0; n < lbl.size(); ++n) {
try { try {
latex_lbl += runparams.encoding->latexChar(lbl[n]); latex_lbl += runparams.encoding->latexChar(lbl[n]).first;
} catch (EncodingException & /* e */) { } catch (EncodingException & /* e */) {
if (runparams.dryrun) { if (runparams.dryrun) {
latex_lbl += "<" + _("LyX Warning: ") latex_lbl += "<" + _("LyX Warning: ")

2
src/insets/InsetCommandParams.cpp
View File

@ -376,7 +376,7 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
for (size_t n = 0; n < command.size(); ++n) { for (size_t n = 0; n < command.size(); ++n) {
try { try {
char_type const c = command[n]; char_type const c = command[n];
docstring const latex = runparams.encoding->latexChar(c); docstring const latex = runparams.encoding->latexChar(c).first;
result += latex; result += latex;
if (latex.length() > 1 && latex[latex.length() - 1] != '}') { if (latex.length() > 1 && latex[latex.length() - 1] != '}') {
// Prevent eating of a following // Prevent eating of a following

2
src/insets/InsetIndex.cpp
View File

@ -137,7 +137,7 @@ void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const
docstring spart2; docstring spart2;
for (size_t n = 0; n < spart.size(); ++n) { for (size_t n = 0; n < spart.size(); ++n) {
try { try {
spart2 += runparams.encoding->latexChar(spart[n]); spart2 += runparams.encoding->latexChar(spart[n]).first;
} catch (EncodingException & /* e */) { } catch (EncodingException & /* e */) {
LYXERR0("Uncodable character in index entry. Sorting might be wrong!"); LYXERR0("Uncodable character in index entry. Sorting might be wrong!");
} }

4
src/insets/InsetLabel.cpp
View File

@ -113,8 +113,8 @@ void InsetLabel::updateReferences(docstring const & old_label,
for (; it != end; ++it) { for (; it != end; ++it) {
buffer().undo().recordUndo(it->second); buffer().undo().recordUndo(it->second);
if (it->first->lyxCode() == MATH_REF_CODE) { if (it->first->lyxCode() == MATH_REF_CODE) {
InsetMathHull * mi = it->first->asInsetMath()->asHullInset(); InsetMathRef * mi = it->first->asInsetMath()->asRefInset();
mi->asRefInset()->changeTarget(new_label); mi->changeTarget(new_label);
} else { } else {
InsetCommand * ref = it->first->asInsetCommand(); InsetCommand * ref = it->first->asInsetCommand();
ref->setParam("reference", new_label); ref->setParam("reference", new_label);

2
src/insets/InsetListings.cpp
View File

@ -176,7 +176,7 @@ void InsetListings::latex(otexstream & os, OutputParams const & runparams) const
// we can only output characters covered by the current // we can only output characters covered by the current
// encoding! // encoding!
try { try {
if (runparams.encoding->latexChar(c) == docstring(1, c)) if (runparams.encoding->encodable(c))
code += c; code += c;
else if (runparams.dryrun) { else if (runparams.dryrun) {
code += "<" + _("LyX Warning: ") code += "<" + _("LyX Warning: ")

2
src/insets/InsetNomencl.cpp
View File

@ -279,7 +279,7 @@ docstring nomenclWidest(Buffer const & buffer, OutputParams const & runparams)
docstring latex_symb; docstring latex_symb;
for (size_t n = 0; n < symb.size(); ++n) { for (size_t n = 0; n < symb.size(); ++n) {
try { try {
latex_symb += runparams.encoding->latexChar(symb[n]); latex_symb += runparams.encoding->latexChar(symb[n]).first;
} catch (EncodingException & /* e */) { } catch (EncodingException & /* e */) {
if (runparams.dryrun) { if (runparams.dryrun) {
latex_symb += "<" + _("LyX Warning: ") latex_symb += "<" + _("LyX Warning: ")

51
src/mathed/InsetMathGrid.cpp
View File

@ -13,6 +13,7 @@
#include "InsetMathGrid.h" #include "InsetMathGrid.h"
#include "InsetMathUnknown.h"
#include "MathData.h" #include "MathData.h"
#include "MathParser.h" #include "MathParser.h"
#include "MathStream.h" #include "MathStream.h"
@ -176,6 +177,22 @@ void InsetMathGrid::setDefaults()
} }
bool InsetMathGrid::interpretString(Cursor & cur, docstring const & str)
{
if (str == "\\hline") {
FuncRequest fr = FuncRequest(LFUN_INSET_MODIFY, "tabular add-hline-above");
FuncStatus status;
if (getStatus(cur, fr, status)) {
if (status.enabled()) {
rowinfo_[cur.row()].lines_++;
return true;
}
}
}
return InsetMathNest::interpretString(cur, str);
}
void InsetMathGrid::setHorizontalAlignments(docstring const & hh) void InsetMathGrid::setHorizontalAlignments(docstring const & hh)
{ {
col_type col = 0; col_type col = 0;
@ -1332,11 +1349,25 @@ void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
mathed_parse_normal(grid, topaste, parseflg | Parse::VERBATIM); mathed_parse_normal(grid, topaste, parseflg | Parse::VERBATIM);
} }
bool hline_enabled = false;
FuncRequest fr = FuncRequest(LFUN_INSET_MODIFY, "tabular add-hline-above");
FuncStatus status;
if (getStatus(cur, fr, status))
hline_enabled = status.enabled();
if (grid.nargs() == 1) { if (grid.nargs() == 1) {
// single cell/part of cell // single cell/part of cell
cur.recordUndo(); cur.recordUndo();
cur.cell().insert(cur.pos(), grid.cell(0)); cur.cell().insert(cur.pos(), grid.cell(0));
cur.pos() += grid.cell(0).size(); cur.pos() += grid.cell(0).size();
if (hline_enabled)
rowinfo_[cur.row()].lines_ += grid.rowinfo_[0].lines_;
else {
for (unsigned int l = 0; l < grid.rowinfo_[0].lines_; ++l) {
cur.cell().insert(0,
MathAtom(new InsetMathUnknown(from_ascii("\\hline"))));
cur.pos()++;
}
}
} else { } else {
// multiple cells // multiple cells
cur.recordUndoInset(); cur.recordUndoInset();
@ -1349,6 +1380,15 @@ void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
idx_type i = index(r + cur.row(), c + col(cur.idx())); idx_type i = index(r + cur.row(), c + col(cur.idx()));
cell(i).insert(0, grid.cell(grid.index(r, c))); cell(i).insert(0, grid.cell(grid.index(r, c)));
} }
if (hline_enabled)
rowinfo_[r].lines_ += grid.rowinfo_[r].lines_;
else {
for (unsigned int l = 0; l < grid.rowinfo_[r].lines_; ++l) {
idx_type i = index(r + cur.row(), 0);
cell(i).insert(0,
MathAtom(new InsetMathUnknown(from_ascii("\\hline"))));
}
}
// append the left over horizontal cells to the last column // append the left over horizontal cells to the last column
idx_type i = index(r + cur.row(), ncols() - 1); idx_type i = index(r + cur.row(), ncols() - 1);
for (InsetMath::col_type c = numcols; c < grid.ncols(); ++c) for (InsetMath::col_type c = numcols; c < grid.ncols(); ++c)
@ -1356,9 +1396,18 @@ void InsetMathGrid::doDispatch(Cursor & cur, FuncRequest & cmd)
} }
// append the left over vertical cells to the last _cell_ // append the left over vertical cells to the last _cell_
idx_type i = nargs() - 1; idx_type i = nargs() - 1;
for (row_type r = numrows; r < grid.nrows(); ++r) for (row_type r = numrows; r < grid.nrows(); ++r) {
for (col_type c = 0; c < grid.ncols(); ++c) for (col_type c = 0; c < grid.ncols(); ++c)
cell(i).append(grid.cell(grid.index(r, c))); cell(i).append(grid.cell(grid.index(r, c)));
if (hline_enabled)
rowinfo_[r].lines_ += grid.rowinfo_[r].lines_;
else {
for (unsigned int l = 0; l < grid.rowinfo_[r].lines_; ++l) {
cell(i).insert(0,
MathAtom(new InsetMathUnknown(from_ascii("\\hline"))));
}
}
}
} }
cur.clearSelection(); // bug 393 cur.clearSelection(); // bug 393
// FIXME audit setBuffer calls // FIXME audit setBuffer calls

2
src/mathed/InsetMathGrid.h
View File

@ -194,6 +194,8 @@ public:
virtual char defaultColAlign(col_type) { return 'c'; } virtual char defaultColAlign(col_type) { return 'c'; }
/// ///
void setDefaults(); void setDefaults();
///
virtual bool interpretString(Cursor & cur, docstring const & str);
/// ///
virtual int colsep() const; virtual int colsep() const;

2
src/mathed/InsetMathNest.cpp
View File

@ -872,7 +872,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
// if relevant. Think typing "\frac<space>". // if relevant. Think typing "\frac<space>".
if (cmd.argument()[0] == ' ' if (cmd.argument()[0] == ' '
&& cur.inMacroMode() && cur.macroName() != "\\" && cur.inMacroMode() && cur.macroName() != "\\"
&& cur.macroModeClose()) { && cur.macroModeClose() && cur.pos() > 0) {
MathAtom const atom = cur.prevAtom(); MathAtom const atom = cur.prevAtom();
if (atom->asNestInset() && atom->isActive()) { if (atom->asNestInset() && atom->isActive()) {
cur.posBackward(); cur.posBackward();

2
src/mathed/InsetMathNest.h
View File

@ -172,7 +172,7 @@ public:
/// interpret \p str and insert the result at the current position of /// interpret \p str and insert the result at the current position of
/// \p cur if it is something known. Return whether \p cur was /// \p cur if it is something known. Return whether \p cur was
/// inserted. /// inserted.
bool interpretString(Cursor & cur, docstring const & str); virtual bool interpretString(Cursor & cur, docstring const & str);
private: private:
/// lfun handler /// lfun handler

7
src/mathed/InsetMathString.cpp
View File

@ -119,7 +119,9 @@ void InsetMathString::write(WriteStream & os) const
char_type const c = *cit; char_type const c = *cit;
docstring command(1, c); docstring command(1, c);
try { try {
if (c < 0x80 || Encodings::latexMathChar(c, mathmode, os.encoding(), command)) { bool termination = false;
if (c < 0x80 ||
Encodings::latexMathChar(c, mathmode, os.encoding(), command, termination)) {
if (os.textMode()) { if (os.textMode()) {
if (in_forced_mode) { if (in_forced_mode) {
// we were inside \lyxmathsym // we were inside \lyxmathsym
@ -152,8 +154,7 @@ void InsetMathString::write(WriteStream & os) const
os << command; os << command;
// We may need a space if the command contains a macro // We may need a space if the command contains a macro
// and the last char is ASCII. // and the last char is ASCII.
if (lyx::support::contains(command, '\\') if (termination)
&& isAlphaASCII(command[command.size() - 1]))
os.pendingSpace(true); os.pendingSpace(true);
} catch (EncodingException & e) { } catch (EncodingException & e) {
switch (os.output()) { switch (os.output()) {

26
src/mathed/MathParser.cpp
View File

@ -1828,13 +1828,15 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
error("'}' expected in \\" + t.cs()); error("'}' expected in \\" + t.cs());
return success_; return success_;
} }
bool termination;
docstring rem; docstring rem;
do { do {
cmd = Encodings::fromLaTeXCommand(cmd, cmd = Encodings::fromLaTeXCommand(cmd,
Encodings::MATH_CMD | Encodings::TEXT_CMD, rem); Encodings::MATH_CMD | Encodings::TEXT_CMD,
termination, rem);
for (size_t i = 0; i < cmd.size(); ++i) for (size_t i = 0; i < cmd.size(); ++i)
cell->push_back(MathAtom(new InsetMathChar(cmd[i]))); cell->push_back(MathAtom(new InsetMathChar(cmd[i])));
if (rem.size()) { if (!rem.empty()) {
char_type c = rem[0]; char_type c = rem[0];
cell->push_back(MathAtom(new InsetMathChar(c))); cell->push_back(MathAtom(new InsetMathChar(c)));
cmd = rem.substr(1); cmd = rem.substr(1);
@ -1923,9 +1925,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
} }
} }
bool is_combining; bool is_combining;
bool termination;
char_type c = Encodings::fromLaTeXCommand(cmd, char_type c = Encodings::fromLaTeXCommand(cmd,
Encodings::MATH_CMD | Encodings::TEXT_CMD, Encodings::MATH_CMD | Encodings::TEXT_CMD,
is_combining); is_combining, termination);
if (is_combining) { if (is_combining) {
if (cat == catLetter) if (cat == catLetter)
cmd += '{'; cmd += '{';
@ -1935,9 +1938,24 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
cmd += '}'; cmd += '}';
c = Encodings::fromLaTeXCommand(cmd, c = Encodings::fromLaTeXCommand(cmd,
Encodings::MATH_CMD | Encodings::TEXT_CMD, Encodings::MATH_CMD | Encodings::TEXT_CMD,
is_combining); is_combining, termination);
} }
if (c) { if (c) {
if (termination) {
if (nextToken().cat() == catBegin) {
getToken();
if (nextToken().cat() == catEnd) {
getToken();
num_tokens += 2;
} else
putback();
} else {
while (nextToken().cat() == catSpace) {
getToken();
++num_tokens;
}
}
}
is_unicode_symbol = true; is_unicode_symbol = true;
cell->push_back(MathAtom(new InsetMathChar(c))); cell->push_back(MathAtom(new InsetMathChar(c)));
} else { } else {

3
src/tex2lyx/table.cpp
View File

@ -1269,10 +1269,11 @@ void handle_tabular(Parser & p, ostream & os, string const & name,
//cerr << "// output what we have\n"; //cerr << "// output what we have\n";
// output what we have // output what we have
string const rotate = "0";
os << "\n<lyxtabular version=\"3\" rows=\"" << rowinfo.size() os << "\n<lyxtabular version=\"3\" rows=\"" << rowinfo.size()
<< "\" columns=\"" << colinfo.size() << "\">\n"; << "\" columns=\"" << colinfo.size() << "\">\n";
os << "<features" os << "<features"
<< write_attribute("rotate", "0") << write_attribute("rotate", rotate)
<< write_attribute("booktabs", booktabs) << write_attribute("booktabs", booktabs)
<< write_attribute("islongtable", is_long_tabular); << write_attribute("islongtable", is_long_tabular);
if (is_long_tabular) { if (is_long_tabular) {

13
src/tex2lyx/text.cpp
View File

@ -456,10 +456,11 @@ docstring convert_unicodesymbols(docstring s)
continue; continue;
} }
s = s.substr(i); s = s.substr(i);
bool termination;
docstring rem; docstring rem;
set<string> req; set<string> req;
docstring parsed = encodings.fromLaTeXCommand(s, docstring parsed = encodings.fromLaTeXCommand(s,
Encodings::TEXT_CMD, rem, &req); Encodings::TEXT_CMD, termination, rem, &req);
for (set<string>::const_iterator it = req.begin(); it != req.end(); it++) for (set<string>::const_iterator it = req.begin(); it != req.end(); it++)
preamble.registerAutomaticallyLoadedPackage(*it); preamble.registerAutomaticallyLoadedPackage(*it);
os << parsed; os << parsed;
@ -3500,13 +3501,15 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
&& contains("\"'.=^`bcdHkrtuv~", t.cs())) { && contains("\"'.=^`bcdHkrtuv~", t.cs())) {
context.check_layout(os); context.check_layout(os);
// try to see whether the string is in unicodesymbols // try to see whether the string is in unicodesymbols
bool termination;
docstring rem; docstring rem;
string command = t.asInput() + "{" string command = t.asInput() + "{"
+ trimSpaceAndEol(p.verbatim_item()) + trimSpaceAndEol(p.verbatim_item())
+ "}"; + "}";
set<string> req; set<string> req;
docstring s = encodings.fromLaTeXCommand(from_utf8(command), docstring s = encodings.fromLaTeXCommand(from_utf8(command),
Encodings::TEXT_CMD | Encodings::MATH_CMD, rem, &req); Encodings::TEXT_CMD | Encodings::MATH_CMD,
termination, rem, &req);
if (!s.empty()) { if (!s.empty()) {
if (!rem.empty()) if (!rem.empty())
cerr << "When parsing " << command cerr << "When parsing " << command
@ -4106,10 +4109,11 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
// try to see whether the string is in unicodesymbols // try to see whether the string is in unicodesymbols
// Only use text mode commands, since we are in text mode here, // Only use text mode commands, since we are in text mode here,
// and math commands may be invalid (bug 6797) // and math commands may be invalid (bug 6797)
bool termination;
docstring rem; docstring rem;
set<string> req; set<string> req;
docstring s = encodings.fromLaTeXCommand(from_utf8(t.asInput()), docstring s = encodings.fromLaTeXCommand(from_utf8(t.asInput()),
Encodings::TEXT_CMD, rem, &req); Encodings::TEXT_CMD, termination, rem, &req);
if (!s.empty()) { if (!s.empty()) {
if (!rem.empty()) if (!rem.empty())
cerr << "When parsing " << t.cs() cerr << "When parsing " << t.cs()
@ -4117,7 +4121,8 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
<< "+" << to_utf8(rem) << endl; << "+" << to_utf8(rem) << endl;
context.check_layout(os); context.check_layout(os);
os << to_utf8(s); os << to_utf8(s);
skip_spaces_braces(p); if (termination)
skip_spaces_braces(p);
for (set<string>::const_iterator it = req.begin(); it != req.end(); it++) for (set<string>::const_iterator it = req.begin(); it != req.end(); it++)
preamble.registerAutomaticallyLoadedPackage(*it); preamble.registerAutomaticallyLoadedPackage(*it);
} }