anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-11-25 10:58:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

encoding patch and mousewheelpatch

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@858 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2000-07-04 20:32:37 +00:00
parent 9468952780
commit b51e368b2b
28 changed files with 881 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
ChangeLog
View File

@ -1,3 +1,53 @@
2000-07-04 edscott <edscott@imp.mx>
* src/lyxrc.C, src/lyxrc.h, src/BufferView_pimpl.C,
lib/lyxrc.example: added option \wheel_jump
2000-07-04 R. Lahaye <lahaye@postech.ac.kr>
* src/lyx_gui.C src/lyx_main.C: add support for -geometry, and
remove support for -width,-height,-xpos and -ypos.
2000-07-01 Dekel Tsur <dekel@math.tau.ac.il>
* src/encoding.[Ch]: New files.
* src/painter.C (text(int,int,XChar2b const *,...)): New method.
(text): Call to the underline() method only when needed.
* src/font.C (XTextWidth16,width(XChar2b const *,...)): New methods.
* src/buffer.C (makeLaTeXFile): Compute automatically the input
encoding(s) for the document.
* src/bufferparams.C (BufferParams): Changed default value of
inputenc to "auto".
* src/language.C (newLang): Removed.
(items[]): Added encoding information for all defined languages.
* src/lyx_gui.C (create_forms): Added "auto" option to the input
encoding choice button.
* src/lyxrc.h (font_norm_type): New member variable.
(set_font_norm_type): New method.
* src/paragraph.C (TeXOnePar): Put "\inputencoding{}" between
paragraphs with different encodings.
* src/text.C (is_arabic, is_nikud, TransformChar): Moved to encoding.C
(TransformChar): Changed to work correctly with Arabic points.
(draw): Added support for drawing Arabic points.
(draw): Removed code for drawing underbars (this is done by
the Painter!)
* src/support/textutils.h (IsPrintableNonspace): New function.
* src/BufferView_pimpl.h: Added "using SigC::Object".
* src/LyXView.h: ditto.
* src/insets/insetinclude.h (include_label): Changed to mutable.
2000-07-04 Lars Gullik Bjønnes <larsbj@lyx.org>
* src/mathed/math_iter.h: remove empty destructor

5
lib/lyxrc.example
View File

@ -207,6 +207,11 @@
# is 150%.
#\screen_zoom 100
# The wheel movement factor (for mice with wheels or five button mice)
# Default is 100, about a page down. A value of 10 give me about a line and
# a half
#\wheel_jump 10
# LyX normally doesn't update the cursor position if you move the scrollbar.
# If you scroll the cursor off the screen and then start typing LyX will
# move you back to where the cursor was. If you'd prefer to always have the

4
src/BufferView_pimpl.C
View File

@ -535,10 +535,10 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
if (button == 4 || button == 5) {
switch (button) {
case 4:
scrollUp(100); // This number is only temporary
scrollUp(lyxrc.wheel_jump); // default 100, set in lyxrc
break;
case 5:
scrollDown(100);
scrollDown(lyxrc.wheel_jump);
break;
}
}

6
src/BufferView_pimpl.h
View File

@ -16,7 +16,11 @@ class LyXView;
class WorkArea;
class LyXScreen;
struct BufferView::Pimpl : public SigC::Object {
#ifdef SIGC_CXX_NAMESPACES
using SigC::Object;
#endif
struct BufferView::Pimpl : public Object {
Pimpl(BufferView * i, LyXView * o,
int xpos, int ypos, int width, int height);
///

6
src/LyXView.h
View File

@ -29,13 +29,17 @@ class Menus;
class BufferView;
class Dialogs;
#ifdef SIGC_CXX_NAMESPACES
using SigC::Object;
#endif
/**
This class is the form containing the view of the buffer. The actual buffer
view is supposed (at least IMHO) to be another class, that shows its output
in one or more LyXView's.
*/
class LyXView : public SigC::Object {
class LyXView : public Object {
public:
/// constructor
LyXView(int w, int h);

3
src/Makefile.am
View File

@ -104,7 +104,8 @@ lyx_SOURCES = \
credits_form.h \
debug.C \
debug.h \
direction.h \
encoding.C \
encoding.h \
figure.h \
filedlg.C \
filedlg.h \

58
src/Painter.C
View File

@ -30,6 +30,8 @@
#include "WorkArea.h"
#include "font.h"
#include "ColorHandler.h"
#include "lyxrc.h"
#include "encoding.h"
using std::endl;
using std::max;
@ -270,6 +272,19 @@ PainterBase & Painter::text(int x, int y, char c, LyXFont const & f)
PainterBase & Painter::text(int x, int y, char const * s, int ls,
LyXFont const & f)
{
if (lyxrc.font_norm_type == LyXRC::ISO_10646_1) {
XChar2b * xs = new XChar2b[ls];
Encoding const * enc = f.language()->encoding();
for (int i = 0; i < ls; ++i) {
Uchar c = enc->ucs(s[i]);
xs[i].byte1 = c >> 8;
xs[i].byte2 = c & 0xff;
}
text(x , y, xs, ls, f);
delete[] xs;
return *this;
}
if (lyxerr.debugging()) {
if (!Lgb_bug_find_hack)
lyxerr << "text not called from "
@ -303,6 +318,46 @@ PainterBase & Painter::text(int x, int y, char const * s, int ls,
}
}
}
if (f.underbar() == LyXFont::ON && f.latex() != LyXFont::ON)
underline(f, x, y, lyxfont::width(s, ls, f));
return *this;
}
PainterBase & Painter::text(int x, int y, XChar2b const * s, int ls,
LyXFont const & f)
{
if (lyxerr.debugging()) {
if (!Lgb_bug_find_hack)
lyxerr << "text not called from "
"workarea::workhandler\n";
lyxerr << "Painter drawable: " << owner.getPixmap() << endl;
}
GC gc = lyxColorHandler->getGCForeground(f.realColor());
if (f.realShape() != LyXFont::SMALLCAPS_SHAPE) {
lyxfont::XSetFont(display, gc, f);
XDrawString16(display, owner.getPixmap(), gc, x, y, s, ls);
} else {
LyXFont smallfont(f);
smallfont.decSize().decSize().setShape(LyXFont::UP_SHAPE);
static XChar2b c = {0, 0};
int tmpx = x;
for(int i = 0; i < ls; ++i) {
if (s[i].byte1 == 0 && islower(s[i].byte2)) {
c.byte2 = toupper(s[i].byte2);
lyxfont::XSetFont(display, gc, smallfont);
XDrawString16(display, owner.getPixmap(),
gc, tmpx, y, &c, 1);
tmpx += lyxfont::XTextWidth16(smallfont, &c, 1);
} else {
lyxfont::XSetFont(display, gc, f);
XDrawString16(display, owner.getPixmap(),
gc, tmpx, y, &s[i], 1);
tmpx += lyxfont::XTextWidth16(f, const_cast<XChar2b *>(&s[i]), 1);
}
}
}
if (f.underbar() == LyXFont::ON && f.latex() != LyXFont::ON)
underline(f, x, y, lyxfont::width(s, ls, f));
return *this;
}
@ -310,8 +365,6 @@ PainterBase & Painter::text(int x, int y, char const * s, int ls,
void Painter::underline(LyXFont const & f, int x, int y, int width)
{
// What about underbars?
if (f.underbar() == LyXFont::ON && f.latex() != LyXFont::ON) {
int below = max(lyxfont::maxDescent(f) / 2, 2);
int height = max((lyxfont::maxDescent(f) / 4) - 1, 1);
if (height < 2)
@ -319,5 +372,4 @@ void Painter::underline(LyXFont const & f, int x, int y, int width)
else
fillRectangle(x, y + below, width, below + height,
f.color());
}
}

3
src/Painter.h
View File

@ -97,6 +97,9 @@ public:
/// Draw a char at position x, y (y is the baseline)
PainterBase & text(int x, int y, char c, LyXFont const & f);
/// Draw a wide string at position x, y
PainterBase & text(int x, int y, XChar2b const * str, int l,
LyXFont const & f);
private:
/// Check the font, and if set, draw an underline
void underline(LyXFont const & f, int x, int y, int width);

26
src/buffer.C
View File

@ -88,6 +88,7 @@
#include "language.h"
#include "lyx_gui_misc.h" // WarnReadonly()
#include "frontends/Dialogs.h"
#include "encoding.h"
using std::ostream;
using std::ofstream;
@ -99,6 +100,7 @@ using std::endl;
using std::pair;
using std::vector;
using std::max;
using std::set;
// all these externs should eventually be removed.
extern BufferList bufferlist;
@ -1678,7 +1680,7 @@ void Buffer::makeLaTeXFile(string const & fname,
// language should be a parameter to \documentclass
bool use_babel = false;
if (params.language_info->RightToLeft()) // This seems necessary
if (params.language_info->lang() == "hebrew") // This seems necessary
features.UsedLanguages.insert(default_language);
if (params.language != "default" ||
!features.UsedLanguages.empty() ) {
@ -1717,7 +1719,27 @@ void Buffer::makeLaTeXFile(string const & fname,
<< "]{fontenc}\n";
texrow.newline();
}
if (params.inputenc != "default") {
if (params.inputenc == "auto") {
string doc_encoding =
params.language_info->encoding()->LatexName();
// Create a list with all the input encodings used
// in the document
set<string> encodings;
for (LaTeXFeatures::LanguageList::const_iterator it =
features.UsedLanguages.begin();
it != features.UsedLanguages.end(); ++it)
if ((*it)->encoding()->LatexName() != doc_encoding)
encodings.insert((*it)->encoding()->LatexName());
ofs << "\\usepackage[";
for (set<string>::const_iterator it = encodings.begin();
it != encodings.end(); ++it)
ofs << *it << ",";
ofs << doc_encoding << "]{inputenc}\n";
texrow.newline();
} else if (params.inputenc != "default") {
ofs << "\\usepackage[" << params.inputenc
<< "]{inputenc}\n";
texrow.newline();

2
src/bufferparams.C
View File

@ -53,7 +53,7 @@ BufferParams::BufferParams()
language = "default";
language_info = default_language;
fonts = "default";
inputenc = "latin1";
inputenc = "auto";
graphicsDriver = "default";
sides = LyXTextClass::OneSide;
columns = 1;

12
src/direction.h
View File

@ -1,12 +0,0 @@
#ifndef DIRECTION_H
#define DIRECTION_H
///
enum LyXDirection {
///
LYX_DIR_LEFT_TO_RIGHT = 1,
///
LYX_DIR_RIGHT_TO_LEFT = -1
};
#endif

336
src/encoding.C Normal file
View File

@ -0,0 +1,336 @@
/* This file is part of
* ======================================================
*
* LyX, The Document Processor
*
* Copyright 1995 Matthias Ettrich
* Copyright 1995-2000 The LyX Team.
*
* ====================================================== */
#include <config.h>
#include "encoding.h"
Uchar tab_iso8859_1[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
Uchar tab_iso8859_2[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7,
0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b,
0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7,
0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c,
0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9
};
Uchar tab_iso8859_4[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0x00a0, 0x0104, 0x0138, 0x0156, 0x00a4, 0x0128, 0x013b, 0x00a7,
0x00a8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00ad, 0x017d, 0x00af,
0x00b0, 0x0105, 0x02db, 0x0157, 0x00b4, 0x0129, 0x013c, 0x02c7,
0x00b8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014a, 0x017e, 0x014b,
0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e,
0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x012a,
0x0110, 0x0145, 0x014c, 0x0136, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x0168, 0x016a, 0x00df,
0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f,
0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x012b,
0x0111, 0x0146, 0x014d, 0x0137, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x0169, 0x016b, 0x02d9
};
Uchar tab_iso8859_6_16[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x0660, 0x0661, 0x0662, 0x0663, 0x0664, 0x0665, 0x0666, 0x0667,
0x0668, 0x0669, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x061f,
0x0040, 0xfe80, 0xfe81, 0xfe83, 0xfe85, 0xfe87, 0xfe89, 0xfe8d,
0xfe8f, 0xfe93, 0xfe95, 0xfe99, 0xfe9d, 0xfea1, 0xfea5, 0xfea9,
0xfeab, 0xfead, 0xfeaf, 0xfeb1, 0xfeb5, 0xfeb9, 0xfebd, 0xfec1,
0xfec5, 0xfec9, 0xfecd, 0x005d, 0x005c, 0x005b, 0x005e, 0x005f,
0x0640, 0xfed1, 0xfed5, 0xfed9, 0xfedd, 0xfee1, 0xfee5, 0xfee9,
0xfeed, 0xfeef, 0xfef1, 0x065b, 0x065c, 0x064d, 0x064e, 0x064f,
0x0650, 0x0651, 0x0652, 0x0073, 0x0074, 0x0075, 0xfef5, 0xfef7,
0xfef9, 0xfefb, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0xfe71, 0x0091, 0x0092, 0xfe77, 0xfe79, 0xfe7b, 0xfe7f, 0xfe7d,
0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
0xfe8c, 0xfe82, 0xfe84, 0xfe86, 0xfe88, 0xfe8e, 0xfeaa, 0xfeac,
0xfeae, 0xfeb0, 0xfeee, 0xfef0, 0xfe91, 0xfe92, 0xfe90, 0xfe97,
0xfe98, 0xfe94, 0xfe97, 0xfe98, 0xfe96, 0xfe9b, 0xfe9c, 0xfe9a,
0xfe9f, 0xfea0, 0xfe9e, 0xfea3, 0xfea4, 0xfea2, 0xfea7, 0xfea8,
0xfea6, 0xfeb3, 0xfeb4, 0xfeb2, 0xfeb7, 0xfeb8, 0xfeb6, 0xfebb,
0xfebc, 0xfeba, 0xfebf, 0xfec0, 0xfebe, 0xfec3, 0xfec4, 0xfec2,
0xfec7, 0xfec8, 0xfec6, 0xfecb, 0xfecc, 0xfeca, 0xfecf, 0xfed0,
0xfece, 0xfed3, 0xfed4, 0xfed2, 0xfed7, 0xfed8, 0xfed6, 0xfedb,
0xfedc, 0xfeda, 0xfedf, 0xfee0, 0xfede, 0xfee3, 0xfee4, 0xfee2,
0xfee7, 0xfee8, 0xfee6, 0xfeeb, 0xfeec, 0xfeea, 0xfef3, 0xfef4,
0xfef2, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
0xfe8b, 0xfe8a, 0xfef6, 0xfefa, 0xfef8, 0xfefc, 0x00fe, 0x00ff
};
Uchar tab_iso8859_7[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0x00a0, 0x0371, 0x0372, 0x00a3, 0xffff, 0xffff, 0x00a6, 0x00a7,
0x00a8, 0x00a9, 0xffff, 0x00ab, 0x00ac, 0x00ad, 0xffff, 0x2015,
0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x03f3, 0x03f4, 0x0386, 0x00b7,
0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
0x03a0, 0x03a1, 0xffff, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7,
0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0xffff
};
Uchar tab_cp1255[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0x00a0, 0xffff, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x203e,
0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
0x05b0, 0x05b1, 0x05b2, 0x05b3, 0x05b4, 0x05b5, 0x05b6, 0x05b7,
0x05b8, 0x05b9, 0xffff, 0x05bb, 0x05bc, 0x05bd, 0x05be, 0x05bf,
0x05c0, 0x05c1, 0x05c2, 0x05c3, 0x05f0, 0x05f1, 0x05f2, 0x05f3,
0x05f4, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
0x05e8, 0x05e9, 0x05ea, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
};
Uchar tab_koi8[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x2500, 0x2502, 0x250c, 0x2510, 0x2514, 0x2518, 0x251c, 0x2524,
0x252c, 0x2534, 0x253c, 0x2580, 0x2584, 0x2588, 0x258c, 0x2590,
0x2591, 0x2592, 0x2593, 0x2320, 0x25a0, 0x2219, 0x221a, 0x2248,
0x2264, 0x2265, 0x00a0, 0x2321, 0x00b0, 0x00b2, 0x00b7, 0x00f7,
0x2550, 0x2551, 0x2552, 0x0451, 0x2553, 0x2554, 0x2555, 0x2556,
0x2557, 0x2558, 0x2559, 0x255a, 0x255b, 0x255c, 0x255d, 0x255e,
0x255f, 0x2560, 0x2561, 0x0401, 0x2562, 0x2563, 0x2564, 0x2565,
0x2566, 0x2567, 0x2568, 0x2569, 0x256a, 0x256b, 0x256c, 0x00a9,
0x044e, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
0x0445, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e,
0x043f, 0x044f, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
0x044c, 0x044b, 0x0437, 0x0448, 0x044d, 0x0449, 0x0447, 0x044a,
0x042e, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
0x0425, 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e,
0x041f, 0x042f, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
0x042c, 0x042b, 0x0417, 0x0428, 0x042d, 0x0429, 0x0427, 0x042a
};
unsigned char arabic_table2[63][4] = {
{0x41, 0x41, 0x41, 0x41}, // 0xc1 = hamza
{0x42, 0xa1, 0x42, 0x42}, // 0xc2 = ligature madda on alef
{0x43, 0xa2, 0x43, 0x43}, // 0xc3 = ligature hamza on alef
{0x44, 0xa3, 0x44, 0x44}, // 0xc4 = ligature hamza on waw
{0x45, 0xa4, 0x45, 0x45}, // 0xc5 = ligature hamza under alef
{0xf9, 0xf9, 0xf8, 0xa0}, // 0xc6 = ligature hamza on ya
{0x47, 0xa5, 0xa5, 0xa5}, // 0xc7 = alef
{0x48, 0xae, 0xac, 0xad}, // 0xc8 = baa
{0x49, 0xb1, 0xaf, 0xb0}, // 0xc9 = taa marbuta
{0x4a, 0xb4, 0xb2, 0xb3}, // 0xca = taa
{0x4b, 0xb7, 0xb5, 0xb6}, // 0xcb = thaa
{0x4c, 0xba, 0xb8, 0xb9}, // 0xcc = jeem
{0x4d, 0xbd, 0xbb, 0xbc}, // 0xcd = haa
{0x4e, 0xc0, 0xbe, 0xbf}, // 0xce = khaa
{0x4f, 0xa6, 0xa6, 0xa6}, // 0xcf = dal
{0x50, 0xa7, 0xa7, 0xa7}, // 0xd0 = thal
{0x51, 0xa8, 0xa8, 0xa8}, // 0xd1 = ra
{0x52, 0xa9, 0xa9, 0xa9}, // 0xd2 = zain
{0x53, 0xc3, 0xc1, 0xc2}, // 0xd3 = seen
{0x54, 0xc6, 0xc4, 0xc5}, // 0xd4 = sheen
{0x55, 0xc9, 0xc7, 0xc8}, // 0xd5 = sad
{0x56, 0xcc, 0xca, 0xcb}, // 0xd6 = dad
{0x57, 0xcf, 0xcd, 0xce}, // 0xd7 = tah
{0x58, 0xd2, 0xd0, 0xd1}, // 0xd8 = zah
{0x59, 0xd5, 0xd3, 0xd4}, // 0xd9 = ain
{0x5a, 0xd8, 0xd6, 0xd7}, // 0xda = ghain
{0,0,0,0}, // 0xdb
{0,0,0,0}, // 0xdc
{0,0,0,0}, // 0xdd
{0,0,0,0}, // 0xde
{0,0,0,0}, // 0xdf
{0,0,0,0}, // 0xe0
{0x61, 0xdb, 0xd9, 0xda}, // 0xe1 = fa
{0x62, 0xde, 0xdc, 0xdd}, // 0xe2 = qaf
{0x63, 0xe1, 0xdf, 0xe0}, // 0xe3 = kaf
{0x64, 0xe4, 0xe2, 0xe3}, // 0xe4 = lam
{0x65, 0xe7, 0xe5, 0xe6}, // 0xe5 = meem
{0x66, 0xea, 0xe8, 0xe9}, // 0xe6 = noon
{0x67, 0xed, 0xeb, 0xec}, // 0xe7 = ha
{0x68, 0xaa, 0xaa, 0xaa}, // 0xe8 = waw
{0x69, 0xab, 0xab, 0xab}, // 0xe9 = alef maksura
{0x6a, 0xf0, 0xee, 0xef}, // 0xea = ya
{0x6b, 0x6b, 0x6b, 0x6b}, // 0xeb = fathatan
{0x6c, 0x6c, 0x6c, 0x6c}, // 0xec = dammatan
{0x6d, 0x6d, 0x6d, 0x6d}, // 0xed = kasratan
{0x6e, 0x6e, 0x6e, 0x6e}, // 0xee = fatha
{0x6f, 0x6f, 0x6f, 0x6f}, // 0xef = damma
{0x70, 0x70, 0x70, 0x70}, // 0xf0 = kasra
{0x71, 0x71, 0x71, 0x71}, // 0xf1 = shadda
{0x72, 0x72, 0x72, 0x72}, // 0xf2 = sukun
{0,0,0,0}, // 0xf3
{0,0,0,0}, // 0xf4
{0,0,0,0}, // 0xf5
{0,0,0,0}, // 0xf6
{0,0,0,0}, // 0xf7
{0,0,0,0}, // 0xf8
{0,0,0,0}, // 0xf9
{0,0,0,0}, // 0xfa
{0,0,0,0}, // 0xfb
{0,0,0,0}, // 0xfc
{0,0,0,0}, // 0xfd
{0,0,0,0}, // 0xfe
{0,0,0,0}, // 0xff
};
unsigned char arabic_table[63][2] = {
{0xc1, 0xc1}, // 0xc1 = hamza
{0xc2, 0xc2}, // 0xc2 = ligature madda on alef
{0xc3, 0xc3}, // 0xc3 = ligature hamza on alef
{0xc4, 0xc4}, // 0xc4 = ligature hamza on waw
{0xc5, 0xc5}, // 0xc5 = ligature hamza under alef
{0xc6, 0xc0}, // 0xc6 = ligature hamza on ya
{0xc7, 0xc7}, // 0xc7 = alef
{0xc8, 0xeb}, // 0xc8 = baa
{0xc9, 0xc9}, // 0xc9 = taa marbuta
{0xca, 0xec}, // 0xca = taa
{0xcb, 0xed}, // 0xcb = thaa
{0xcc, 0xee}, // 0xcc = jeem
{0xcd, 0xef}, // 0xcd = haa
{0xce, 0xf0}, // 0xce = khaa
{0xcf, 0xcf}, // 0xcf = dal
{0xd0, 0xd0}, // 0xd0 = thal
{0xd1, 0xd1}, // 0xd1 = ra
{0xd2, 0xd2}, // 0xd2 = zain
{0xd3, 0xf1}, // 0xd3 = seen
{0xd4, 0xf2}, // 0xd4 = sheen
{0xd5, 0xf3}, // 0xd5 = sad
{0xd6, 0xf4}, // 0xd6 = dad
{0xd7, 0xd7}, // 0xd7 = tah
{0xd8, 0xd8}, // 0xd8 = zah
{0xd9, 0xf5}, // 0xd9 = ain
{0xda, 0xf6}, // 0xda = ghain
{0,0}, // 0xdb
{0,0}, // 0xdc
{0,0}, // 0xdd
{0,0}, // 0xde
{0,0}, // 0xdf
{0,0}, // 0xe0
{0xe1, 0xf7}, // 0xe1 = fa
{0xe2, 0xf8}, // 0xe2 = qaf
{0xe3, 0xf9}, // 0xe3 = kaf
{0xe4, 0xfa}, // 0xe4 = lam
{0xe5, 0xfb}, // 0xe5 = meem
{0xe6, 0xfc}, // 0xe6 = noon
{0xe7, 0xfd}, // 0xe7 = ha
{0xe8, 0xe8}, // 0xe8 = waw
{0xe9, 0xe9}, // 0xe9 = alef maksura
{0xea, 0xfe}, // 0xea = ya
{0xeb, 0xa8}, // 0xeb = fathatan
{0xa9, 0xa9}, // 0xec = dammatan
{0xaa, 0xaa}, // 0xed = kasratan
{0xab, 0xab}, // 0xee = fatha
{0xac, 0xac}, // 0xef = damma
{0xad, 0xad}, // 0xf0 = kasra
{0xae, 0xae}, // 0xf1 = shadda
{0xaf, 0xaf}, // 0xf2 = sukun
{0,0}, // 0xf3
{0,0}, // 0xf4
{0,0}, // 0xf5
{0,0}, // 0xf6
{0,0}, // 0xf7
{0,0}, // 0xf8
{0,0}, // 0xf9
{0,0}, // 0xfa
{0,0}, // 0xfb
{0,0}, // 0xfc
{0,0}, // 0xfd
{0,0}, // 0xfe
{0,0} // 0xff
};
Encoding iso8859_1("latin1",tab_iso8859_1);
Encoding iso8859_2("latin2",tab_iso8859_2);
Encoding iso8859_4("latin4",tab_iso8859_4);
Encoding iso8859_6("latin6",tab_iso8859_6_16);
Encoding iso8859_7("latin7",tab_iso8859_7);
Encoding cp1255("cp1255",tab_cp1255);
Encoding koi8("koi8-r",tab_koi8);

109
src/encoding.h Normal file
View File

@ -0,0 +1,109 @@
// -*- C++ -*-
/* This file is part of
* ======================================================
*
* LyX, The Document Processor
*
* Copyright 1995 Matthias Ettrich
* Copyright 1995-2000 The LyX Team.
*
* ====================================================== */
#ifndef ENCODING_H
#define ENCODING_H
#include "LString.h"
#include "lyxrc.h"
typedef unsigned short int Uchar;
class Encoding {
public:
///
enum Letter_Form {
FORM_ISOLATED,
FORM_FINAL,
FORM_INITIAL,
FORM_MEDIAL
};
///
Encoding(string const & l, Uchar const * e)
: LatexName_(l) , encoding_table(e) {}
///
string const & LatexName() const {
return LatexName_;
}
///
Uchar ucs(unsigned char c) const {
return encoding_table[c];
}
///
static
bool IsComposeChar_hebrew(unsigned char c);
///
static
bool IsComposeChar_arabic(unsigned char c);
///
static
bool is_arabic(unsigned char c);
///
static
unsigned char TransformChar(unsigned char c, Letter_Form form);
private:
///
string LatexName_;
///
Uchar const * encoding_table;
};
extern Encoding iso8859_1;
extern Encoding iso8859_2;
extern Encoding iso8859_4;
extern Encoding iso8859_6;
extern Encoding iso8859_7;
extern Encoding cp1255;
extern Encoding koi8;
inline
bool Encoding::IsComposeChar_hebrew(unsigned char c)
{
return c <= 0xd2 && c >= 0xc0 &&
c != 0xce && c != 0xd0;
}
inline
bool Encoding::IsComposeChar_arabic(unsigned char c)
{
return c >= 0xeb && c <= 0xf2;
}
extern unsigned char arabic_table[][2];
extern unsigned char arabic_table2[][4];
unsigned char const arabic_start = 0xc1;
inline
bool Encoding::is_arabic(unsigned char c)
{
return c >= arabic_start && arabic_table[c-arabic_start][0];
}
inline
unsigned char Encoding::TransformChar(unsigned char c, Encoding::Letter_Form form)
{
if (!is_arabic(c))
return c;
if (lyxrc.font_norm == "iso10646-1")
return arabic_table2[c-arabic_start][form];
else
return arabic_table[c-arabic_start][form >> 1];
}
#endif

65
src/font.C
View File

@ -5,8 +5,7 @@
#include "font.h"
#include "FontLoader.h"
#include "lyxrc.h"
extern LyXRC lyxrc;
#include "encoding.h"
// namespace {
static inline
@ -88,29 +87,24 @@ int lyxfont::rbearing(char c, LyXFont const & f)
}
int lyxfont::width(char c, LyXFont const & f)
{
if (f.realShape() != LyXFont::SMALLCAPS_SHAPE) {
return lyxrc.use_gui ? ::XTextWidth(getXFontstruct(f), &c, 1)
: 1;
} else {
LyXFont smallfont(f);
smallfont.decSize().decSize().setShape(LyXFont::UP_SHAPE);
if (islower(static_cast<unsigned char>(c))) {
c = toupper(c);
return ::XTextWidth(getXFontstruct(smallfont), &c, 1);
} else {
return ::XTextWidth(getXFontstruct(f), &c, 1);
}
}
}
int lyxfont::width(char const * s, int n, LyXFont const & f)
{
if (!lyxrc.use_gui)
return n;
if (lyxrc.font_norm_type == LyXRC::ISO_10646_1) {
XChar2b * xs = new XChar2b[n];
Encoding const * enc = f.language()->encoding();
for (int i = 0; i < n; ++i) {
Uchar c = enc->ucs(s[i]);
xs[i].byte1 = c >> 8;
xs[i].byte2 = c & 0xff;
}
int result = width(xs, n, f);
delete[] xs;
return result;
}
if (f.realShape() != LyXFont::SMALLCAPS_SHAPE) {
return ::XTextWidth(getXFontstruct(f), s, n);
} else {
@ -144,12 +138,43 @@ int lyxfont::signedWidth(string const & s, LyXFont const & f)
}
int lyxfont::width(XChar2b const * s, int n, LyXFont const & f)
{
if (!lyxrc.use_gui)
return n;
if (f.realShape() != LyXFont::SMALLCAPS_SHAPE) {
return ::XTextWidth16(getXFontstruct(f), s, n);
} else {
// emulate smallcaps since X doesn't support this
unsigned int result = 0;
static XChar2b c = {0, 0};
LyXFont smallfont(f);
smallfont.decSize().decSize().setShape(LyXFont::UP_SHAPE);
for (int i = 0; i < n; ++i) {
if (s[i].byte1 == 0 && islower(s[i].byte2)) {
c.byte2 = toupper(s[i].byte2);
result += ::XTextWidth16(getXFontstruct(smallfont), &c, 1);
} else {
result += ::XTextWidth16(getXFontstruct(f), &s[i], 1);
}
}
return result;
}
}
int lyxfont::XTextWidth(LyXFont const & f, char * str, int count)
{
return ::XTextWidth(getXFontstruct(f), str, count);
}
int lyxfont::XTextWidth16(LyXFont const & f, XChar2b * str, int count)
{
return ::XTextWidth16(getXFontstruct(f), str, count);
}
void lyxfont::XSetFont(Display * display, GC gc, LyXFont const & f)
{
::XSetFont(display, gc, getFontID(f));

10
src/font.h
View File

@ -32,7 +32,9 @@ struct lyxfont {
int rbearing(char c, LyXFont const & f);
static
int width(char c, LyXFont const & f);
int width(char c, LyXFont const & f) {
return width(&c, 1, f);
}
static
int width(char const * s, int n, LyXFont const & f);
@ -54,6 +56,12 @@ struct lyxfont {
static
int XTextWidth(LyXFont const & f, char * str, int count);
static
int width(XChar2b const * s, int n, LyXFont const & f);
static
int XTextWidth16(LyXFont const & f, XChar2b * str, int count);
static
void XSetFont(Display * display, GC gc, LyXFont const & f);
};

2
src/insets/insetinclude.h
View File

@ -125,7 +125,7 @@ private:
///
string filename;
///
string include_label;
mutable string include_label;
};

100
src/language.C
View File

@ -3,10 +3,11 @@
#include "language.h"
#include "gettext.h"
#include "encoding.h"
Languages languages;
Language const * default_language;
Language ignore_lang("ignore", "Ignore", false);
Language ignore_lang("ignore", "Ignore", false, 0);
Language const * ignore_language = &ignore_lang;
///
@ -18,14 +19,6 @@ public:
init = true;
}
private:
///
void newLang(char const * l, char const * d, bool rtl) {
Language lang(l, d, rtl);
//lang.lang = l;
//lang.display = d;
//lang.RightToLeft = rtl;
languages[l] = lang;
}
///
void initL();
///
@ -37,6 +30,7 @@ struct lang_item {
char const * lang;
char const * display;
bool rtl;
Encoding const * encoding;
};
@ -46,57 +40,59 @@ void LangInit::initL()
// Same method is used in LyXAction.C (Lgb)
lang_item items[] = {
{ "afrikaans", N_("Afrikaans"), false },
{ "american", N_("American"), false },
{ "arabic", N_("Arabic"), true },
{ "austrian", N_("Austrian"), false },
{ "bahasa", N_("Bahasa"), false },
{ "brazil", N_("Brazil"), false },
{ "breton", N_("Breton"), false },
{ "catalan", N_("Catalan"), false },
{ "croatian", N_("Croatian"), false },
{ "czech", N_("Czech"), false },
{ "danish", N_("Danish"), false },
{ "dutch", N_("Dutch"), false },
{ "english", N_("English"), false },
{ "esperanto", N_("Esperanto"), false },
{ "estonian", N_("Estonian"), false },
{ "finnish", N_("Finnish"), false },
{ "francais", N_("Francais"), false },
{ "french", N_("French"), false },
{ "frenchb", N_("Frenchb"), false },
{ "galician", N_("Galician"), false },
{ "german", N_("German"), false },
{ "greek", N_("Greek"), false },
{ "hebrew", N_("Hebrew"), true },
{ "afrikaans", N_("Afrikaans"), false, &iso8859_1 },
{ "american", N_("American"), false, &iso8859_1 },
{ "arabic", N_("Arabic"), true, &iso8859_6 },
{ "austrian", N_("Austrian"), false, &iso8859_1 },
{ "bahasa", N_("Bahasa"), false, &iso8859_1 },
{ "brazil", N_("Brazil"), false, &iso8859_1 },
{ "breton", N_("Breton"), false, &iso8859_1 },
{ "catalan", N_("Catalan"), false, &iso8859_1 },
{ "croatian", N_("Croatian"), false, &iso8859_2 },
{ "czech", N_("Czech"), false, &iso8859_2 },
{ "danish", N_("Danish"), false, &iso8859_1 },
{ "dutch", N_("Dutch"), false, &iso8859_1 },
{ "english", N_("English"), false, &iso8859_1 },
{ "esperanto", N_("Esperanto"), false, &iso8859_1 },
{ "estonian", N_("Estonian"), false, &iso8859_4 },
{ "finnish", N_("Finnish"), false, &iso8859_1 },
{ "francais", N_("Francais"), false, &iso8859_1 },
{ "french", N_("French"), false, &iso8859_1 },
{ "frenchb", N_("Frenchb"), false, &iso8859_1 },
{ "galician", N_("Galician"), false, &iso8859_1 },
{ "german", N_("German"), false, &iso8859_1 },
{ "greek", N_("Greek"), false, &iso8859_7 },
{ "hebrew", N_("Hebrew"), true, &cp1255 },
/* According to Zrubecz Laszlo <zrubi@k2.jozsef.kando.hu>,
"magyar" is better. I kept it here in case we want
to provide aliasing of languages. (JMarc)
*/
//{ "hungarian", N_("Hungarian"), false },
{ "irish", N_("Irish"), false },
{ "italian", N_("Italian"), false },
{ "lsorbian", N_("Lsorbian"), false },
{ "magyar", N_("Magyar"), false },
{ "norsk", N_("Norsk"), false },
{ "polish", N_("Polish"), false },
{ "portuges", N_("Portuges"), false },
{ "romanian", N_("Romanian"), false },
{ "russian", N_("Russian"), false },
{ "scottish", N_("Scottish"), false },
{ "spanish", N_("Spanish"), false },
{ "slovak", N_("Slovak"), false },
{ "slovene", N_("Slovene"), false },
{ "swedish", N_("Swedish"), false },
{ "turkish", N_("Turkish"), false },
{ "usorbian", N_("Usorbian"), false },
{ "welsh", N_("Welsh"), false },
{ 0, 0, false }
//{ "hungarian", N_("Hungarian"), false, &iso8859_2 },
{ "irish", N_("Irish"), false, &iso8859_1 },
{ "italian", N_("Italian"), false, &iso8859_1 },
{ "lsorbian", N_("Lsorbian"), false, &iso8859_1 },
{ "magyar", N_("Magyar"), false, &iso8859_1 },
{ "norsk", N_("Norsk"), false, &iso8859_1 },
{ "polish", N_("Polish"), false, &iso8859_2 },
{ "portuges", N_("Portuges"), false, &iso8859_1 },
{ "romanian", N_("Romanian"), false, &iso8859_2 },
{ "russian", N_("Russian"), false, &koi8 },
{ "scottish", N_("Scottish"), false, &iso8859_1 },
{ "spanish", N_("Spanish"), false, &iso8859_1 },
{ "slovak", N_("Slovak"), false, &iso8859_2 },
{ "slovene", N_("Slovene"), false, &iso8859_2 },
{ "swedish", N_("Swedish"), false, &iso8859_1 },
{ "turkish", N_("Turkish"), false, &iso8859_1 },
{ "usorbian", N_("Usorbian"), false, &iso8859_1 },
{ "welsh", N_("Welsh"), false, &iso8859_1 },
{ 0, 0, false, 0 }
};
int i = 0;
while (items[i].lang) {
newLang(items[i].lang, items[i].display, items[i].rtl);
languages[items[i].lang] =
Language(items[i].lang, items[i].display,
items[i].rtl, items[i].encoding);
++i;
}

17
src/language.h
View File

@ -5,14 +5,16 @@
#include <map>
#include "LString.h"
class Encoding;
///
class Language {
public:
///
Language() : RightToLeft_(false) {}
///
Language(string const & l, string const & d, bool rtl)
: lang_(l), display_(d), RightToLeft_(rtl) {}
Language(string const & l, string const & d, bool rtl, Encoding const * e)
: lang_(l), display_(d), RightToLeft_(rtl) , encoding_(e) {}
///
string const & lang() const {
return lang_;
@ -25,6 +27,10 @@ public:
bool RightToLeft() const {
return RightToLeft_;
}
///
Encoding const * encoding() const {
return encoding_;
}
private:
///
string lang_;
@ -32,14 +38,17 @@ private:
string display_;
///
bool RightToLeft_;
///
Encoding const * encoding_;
};
#if 0
bool operator==(Language const & l1, Language const & l2)
{
return l1.lang == l2.lang
&& l1.display == l2.display
&& l1.RightToLeft == l2.RightToLeft;
&& l1.display_ == l2.display_
&& l1.RightToLeft_ == l2.RightToLeft_
&& l1.encoding_ == l2.encoding_;
}

1
src/lyx_cb.C
View File

@ -2785,6 +2785,7 @@ extern "C" void ScreenApplyCB(FL_OBJECT *, long)
lyxrc.sans_font_name = fl_get_input(fd_form_screen->input_sans);
lyxrc.typewriter_font_name = fl_get_input(fd_form_screen->input_typewriter);
lyxrc.font_norm = fl_get_input(fd_form_screen->input_font_norm);
lyxrc.set_font_norm_type();
lyxrc.zoom = atoi(fl_get_input(fd_form_screen->intinput_size));
fontloader.update();

23
src/lyx_gui.C
View File

@ -78,25 +78,20 @@ extern BufferList bufferlist;
FL_CMD_OPT cmdopt[] =
{
{"-width", "*.width", XrmoptionSepArg, "690"},
{"-height", "*.height", XrmoptionSepArg, "510"},
{"-xpos", "*.xpos", XrmoptionSepArg, "-1"},
{"-ypos", "*.ypos", XrmoptionSepArg, "-1"}
{"-geometry", "*.geometry", XrmoptionSepArg, "690x510"}
};
static int width;
static int height;
static int xpos;
static int ypos;
static int width = 690;
static int height = 510;
static int xpos = -1;
static int ypos = -1;
static char geometry[40];
bool cursor_follows_scrollbar;
FL_resource res[] =
{
{"width", "widthClass", FL_INT, &width, "690", 0},
{"height", "heightClass", FL_INT, &height, "510", 0},
{"xpos", "xposClass", FL_INT, &xpos, "-1", 0},
{"ypos", "yposClass", FL_INT, &ypos, "-1", 0}
{"geometry", "geometryClass", FL_STRING, geometry, "690x510", 40}
};
@ -130,6 +125,8 @@ LyXGUI::LyXGUI(LyX * owner, int * argc, char * argv[], bool GUI)
fl_initialize(argc, argv, "LyX", cmdopt, num_res);
fl_get_app_resources(res, num_res);
XParseGeometry(geometry, &xpos, &ypos, (unsigned int *) &width, (unsigned int *) &height);
Display * display = fl_get_display();
if (!display) {
lyxerr << "LyX: unable to access X display, exiting" << endl;
@ -416,7 +413,7 @@ void LyXGUI::create_forms()
}
fl_addto_choice(fd_form_document->choice_inputenc,
"default|latin1|latin2|latin5"
"default|auto|latin1|latin2|latin5"
"|koi8-r|koi8-u|cp866|cp1251|iso88595");
for (n = 0; tex_graphics[n][0]; ++n) {

5
src/lyx_main.C
View File

@ -594,10 +594,7 @@ void commandLineHelp()
"\t-help summarize LyX usage\n"
"\t-userdir dir try to set user directory to dir\n"
"\t-sysdir dir try to set system directory to dir\n"
"\t-width x set the width of the main window\n"
"\t-height y set the height of the main window\n"
"\t-xpos x set the x position of the main window\n"
"\t-ypos y set the y position of the main window\n"
"\t-geometry WxH+X+Y set the width of the main window\n"
"\t-dbg feature[,feature]...\n"
" select the features to debug.\n"
" Type `lyx -dbg' to see the list of features\n"

26
src/lyxrc.C
View File

@ -154,6 +154,7 @@ enum LyXRCTags {
RC_DOCBOOK_TO_DVI_COMMAND,
RC_DOCBOOK_TO_HTML_COMMAND,
RC_DOCBOOK_TO_PDF_COMMAND,
RC_WHEEL_JUMP,
RC_LAST
};
@ -266,7 +267,8 @@ keyword_item lyxrcTags[] = {
{ "\\view_dvi_paper_option", RC_VIEWDVI_PAPEROPTION },
{ "\\view_pdf_command", RC_VIEWPDF_COMMAND },
{ "\\view_ps_command", RC_VIEWPS_COMMAND },
{ "\\view_pspic_command", RC_VIEWPSPIC_COMMAND }
{ "\\view_pspic_command", RC_VIEWPSPIC_COMMAND },
{ "\\wheel_jump", RC_WHEEL_JUMP }
};
/* Let the range depend of the size of lyxrcTags. Alejandro 240596 */
@ -325,6 +327,7 @@ void LyXRC::setDefaults() {
dpi = 75;
// Because a screen typically is wider than a piece of paper:
zoom = 150;
wheel_jump = 100;
// Default LaTeX font size:
font_sizes[LyXFont::SIZE_TINY] = 5.0;
font_sizes[LyXFont::SIZE_SCRIPT] = 7.0;
@ -343,6 +346,7 @@ void LyXRC::setDefaults() {
menu_font_name = "-*-helvetica-bold-r";
popup_font_name = "-*-helvetica-medium-r";
font_norm = "iso8859-1";
font_norm_type = OTHER_ENCODING;
font_norm_menu = "";
override_x_deadkeys = true;
autosave = 300;
@ -733,6 +737,11 @@ int LyXRC::read(string const & filename)
zoom = lexrc.GetInteger();
break;
case RC_WHEEL_JUMP:
if (lexrc.next())
wheel_jump = lexrc.GetInteger();
break;
case RC_SCREEN_FONT_SIZES:
if (lexrc.next())
font_sizes[LyXFont::SIZE_TINY] =
@ -838,8 +847,10 @@ int LyXRC::read(string const & filename)
break;
case RC_SCREEN_FONT_ENCODING:
if (lexrc.next())
if (lexrc.next()) {
font_norm = lexrc.GetString();
set_font_norm_type();
}
break;
case RC_SCREEN_FONT_ENCODING_MENU:
@ -1222,6 +1233,8 @@ void LyXRC::output(ostream & os) const
os << "\\screen_dpi " << dpi << "\n";
case RC_SCREEN_ZOOM:
os << "\\screen_zoom " << zoom << "\n";
case RC_WHEEL_JUMP:
os << "\\wheel_jump " << wheel_jump << "\n";
case RC_SCREEN_FONT_SIZES:
os.setf(ios::fixed);
os.precision(2);
@ -1421,6 +1434,15 @@ void LyXRC::output(ostream & os) const
os.flush();
}
void LyXRC::set_font_norm_type()
{
if (font_norm == "iso10646-1")
font_norm_type = ISO_10646_1;
else if (font_norm == "iso8859-6.8x")
font_norm_type = ISO_8859_6_8;
else
font_norm_type = OTHER_ENCODING;
}
// The global instance
LyXRC lyxrc;

10
src/lyxrc.h
View File

@ -140,6 +140,8 @@ public:
string backupdir_path;
/// Zoom factor for screen fonts
unsigned int zoom;
/// parameter for button_4 and button_5 (scrollwheel)
unsigned int wheel_jump;
/// Screen font sizes in points for each font size
float font_sizes[10];
/// Allow the use of scalable fonts? Default is yes.
@ -162,6 +164,14 @@ public:
string popup_font_name;
///
string font_norm;
enum FontEncoding {
ISO_10646_1,
ISO_8859_6_8,
OTHER_ENCODING
};
FontEncoding font_norm_type;
///
void set_font_norm_type();
///
string font_norm_menu;
///

10
src/lyxtext.h
View File

@ -44,13 +44,6 @@ public:
NEED_VERY_LITTLE_REFRESH
};
enum Letter_Form {
FORM_ISOLATED,
FORM_INITIAL,
FORM_MEDIAL,
FORM_FINAL
};
/// Constructor
LyXText(BufferView *);
LyXText(InsetText *);
@ -676,9 +669,6 @@ private:
///
mutable bool bidi_same_direction;
///
unsigned char TransformChar(unsigned char c, Letter_Form form) const;
///
unsigned char TransformChar(unsigned char c, LyXParagraph * par,
LyXParagraph::size_type pos) const;

19
src/paragraph.C
View File

@ -36,6 +36,7 @@
#include "texrow.h"
#include "support/lyxmanip.h"
#include "BufferView.h"
#include "encoding.h"
using std::ostream;
using std::endl;
@ -2092,14 +2093,23 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
Language const * language = getParLanguage(bparams);
Language const * doc_language = bparams.language_info;
if (language != doc_language &&
(!previous || previous->getParLanguage(bparams) != language)) {
Language const * previous_language = previous
? previous->getParLanguage(bparams) : doc_language;
if (language != doc_language && language != previous_language) {
os << subst(lyxrc.language_command_begin, "$$lang",
language->lang())
<< endl;
texrow.newline();
}
if (bparams.inputenc == "auto" &&
language->encoding() != previous_language->encoding()) {
os << "\\inputencoding{"
<< language->encoding()->LatexName()
<< "}" << endl;
texrow.newline();
}
switch (style.latextype) {
case LATEX_COMMAND:
os << '\\'
@ -3315,7 +3325,10 @@ void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf,
case '°': case '±': case '²': case '³':
case '×': case '÷': case '¹': case 'ª':
case 'º': case '¬': case 'µ':
if (bparams.inputenc == "latin1") {
if (bparams.inputenc == "latin1" ||
(bparams.inputenc == "auto" &&
font.language()->encoding()->LatexName()
== "latin1")) {
os << "\\ensuremath{"
<< c
<< '}';

11
src/spellchecker.C
View File

@ -50,6 +50,7 @@
#include "lyx_gui_misc.h"
#include "debug.h"
#include "support/lstrings.h"
#include "encoding.h"
using std::reverse;
using std::endl;
@ -328,12 +329,16 @@ void create_ispell_pipe(BufferParams const & params, string const & lang)
}
if (lyxrc.isp_use_input_encoding &&
params.inputenc != "default") {
string enc = (params.inputenc == "auto")
? params.language_info->encoding()->LatexName()
: params.inputenc;
string::size_type n = enc.length();
tmp = new char[3];
string("-T").copy(tmp, 2); tmp[2] = '\0';
argv[argc++] = tmp; // Input encoding
tmp = new char[params.inputenc.length() + 1];
params.inputenc.copy(tmp, params.inputenc.length());
tmp[params.inputenc.length()] = '\0';
tmp = new char[n + 1];
enc.copy(tmp, n);
tmp[n] = '\0';
argv[argc++] = tmp;
}

7
src/support/textutils.h
View File

@ -109,6 +109,13 @@ bool IsPrintable(unsigned char c) {
}
///
inline
bool IsPrintableNonspace(unsigned char c) {
return (c > ' ');
}
/// Word is not IsSeparator or IsKomma or IsHfill or IsFloat or IsInset.
inline
bool IsWordChar(unsigned char c) {

177
src/text.C
View File

@ -35,6 +35,7 @@
#include "Painter.h"
#include "tracer.h"
#include "font.h"
#include "encoding.h"
using std::max;
using std::min;
@ -44,75 +45,6 @@ using std::pair;
static const int LYX_PAPER_MARGIN = 20;
extern int bibitemMaxWidth(Painter &, LyXFont const &);
static int iso885968x[] = {
0xbc, // 0xa8 = fathatan
0xbd, // 0xa9 = dammatan
0xbe, // 0xaa = kasratan
0xdb, // 0xab = fatha
0xdc, // 0xac = damma
0xdd, // 0xad = kasra
0xde, // 0xae = shadda
0xdf, // 0xaf = sukun
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0xb0-0xbf
0, // 0xc0
0xc1, // 0xc1 = hamza
0xc2, // 0xc2 = ligature madda
0xc3, // 0xc3 = ligature hamza on alef
0xc4, // 0xc4 = ligature hamza on waw
0xc5, // 0xc5 = ligature hamza under alef
0xc0, // 0xc6 = ligature hamza on ya
0xc7, // 0xc7 = alef
0xeb, // 0xc8 = baa
0xc9, // 0xc9 = taa marbuta
0xec, // 0xca = taa
0xed, // 0xcb = thaa
0xee, // 0xcc = jeem
0xef, // 0xcd = haa
0xf0, // 0xce = khaa
0xcf, // 0xcf = dal
0xd0, // 0xd0 = thal
0xd1, // 0xd1 = ra
0xd2, // 0xd2 = zain
0xf1, // 0xd3 = seen
0xf2, // 0xd4 = sheen
0xf3, // 0xd5 = sad
0xf4, // 0xd6 = dad
0xd7, // 0xd7 = tah
0xd8, // 0xd8 = zah
0xf5, // 0xd9 = ain
0xf6, // 0xda = ghain
0,0,0,0,0, // 0xdb- 0xdf
0, // 0xe0
0xf7, // 0xe1 = fa
0xf8, // 0xe2 = qaf
0xf9, // 0xe3 = kaf
0xfa, // 0xe4 = lam
0xfb, // 0xe5 = meem
0xfc, // 0xe6 = noon
0xfd, // 0xe7 = ha
0xe8, // 0xe8 = waw
0xe9, // 0xe9 = alef maksura
0xfe // 0xea = ya
};
inline
bool is_arabic(unsigned char c)
{
return 0xa8 <= c && c <= 0xea && iso885968x[c-0xa8];
}
inline
bool is_nikud(unsigned char c)
{
return 192 <= c && c <= 210;
}
int LyXText::workWidth(BufferView * bview) const
{
@ -122,36 +54,34 @@ int LyXText::workWidth(BufferView * bview) const
return bview->workWidth();
}
unsigned char LyXText::TransformChar(unsigned char c, Letter_Form form) const
{
if (is_arabic(c) &&
(form == FORM_INITIAL || form == FORM_MEDIAL) )
return iso885968x[c-0xa8];
else
return c;
}
unsigned char LyXText::TransformChar(unsigned char c, LyXParagraph * par,
LyXParagraph::size_type pos) const
{
if (!is_arabic(c))
if (isdigit(c))
if (!Encoding::is_arabic(c))
if (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 && isdigit(c))
return c + (0xb0 - '0');
else
return c;
bool not_first = (pos > 0 && is_arabic(par->GetChar(pos-1)));
if (pos < par->Last()-1 && is_arabic(par->GetChar(pos+1)))
if (not_first)
return TransformChar(c,FORM_MEDIAL);
unsigned char prev_char = pos > 0 ? par->GetChar(pos-1) : ' ';
unsigned char next_char = ' ';
for (LyXParagraph::size_type i = pos+1; i < par->Last(); ++i)
if (!Encoding::IsComposeChar_arabic(par->GetChar(i))) {
next_char = par->GetChar(i);
break;
}
if (Encoding::is_arabic(next_char))
if (Encoding::is_arabic(prev_char))
return Encoding::TransformChar(c, Encoding::FORM_MEDIAL);
else
return TransformChar(c,FORM_INITIAL);
return Encoding::TransformChar(c, Encoding::FORM_INITIAL);
else
if (not_first)
return TransformChar(c,FORM_FINAL);
if (Encoding::is_arabic(prev_char))
return Encoding::TransformChar(c, Encoding::FORM_FINAL);
else
return TransformChar(c,FORM_ISOLATED);
return Encoding::TransformChar(c, Encoding::FORM_ISOLATED);
}
// This is the comments that some of the warnings below refers to.
@ -196,10 +126,14 @@ int LyXText::SingleWidth(BufferView * bview, LyXParagraph * par,
if (IsPrintable(c)) {
if (font.language()->RightToLeft()) {
if (font.language()->lang() == "arabic" &&
lyxrc.font_norm == "iso8859-6.8x")
(lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 ||
lyxrc.font_norm_type == LyXRC::ISO_10646_1))
if (Encoding::IsComposeChar_arabic(c))
return 0;
else
c = TransformChar(c, par, pos);
else if (font.language()->lang() == "hebrew" &&
is_nikud(c))
Encoding::IsComposeChar_hebrew(c))
return 0;
}
return lyxfont::width(c, font);
@ -603,29 +537,28 @@ void LyXText::draw(BufferView * bview, Row const * row,
LyXParagraph::size_type last = RowLastPrintable(row);
if (font.language()->lang() == "hebrew") {
if (is_nikud(c)) {
LyXParagraph::size_type vpos2 = vpos;
if (Encoding::IsComposeChar_hebrew(c)) {
int width = lyxfont::width(c, font2);
int dx = 0;
while (vpos2 <= last &&
(pos = vis2log(vpos2)) >= 0
&& static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
&& is_nikud(c))
++vpos2;
if (static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
&& !is_nikud(c)) {
int width2 = SingleWidth(bview, row->par(), pos, c);
dx = (c == 'ø' || c == 'ã')
for (LyXParagraph::size_type i = pos-1; i >= 0; --i) {
c = row->par()->GetChar(i);
if (!Encoding::IsComposeChar_hebrew(c)) {
if (IsPrintableNonspace(c)) {
int width2 = SingleWidth(bview, row->par(), i, c);
dx = (c == 'ø' || c == 'ã') // dalet / resh
? width2 - width : (width2 - width) / 2;
}
break;
}
}
// Draw nikud
pain.text(int(x) + dx, offset + row->baseline(),
textstring, font);
} else {
while (vpos <= last &&
(pos = vis2log(vpos)) >= 0
&& static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
&& !is_nikud(c)
&& IsPrintableNonspace(c = row->par()->GetChar(pos))
&& !Encoding::IsComposeChar_hebrew(c)
&& font2 == GetFont(bview->buffer(), row->par(), pos)) {
textstring += c;
++vpos;
@ -636,23 +569,46 @@ void LyXText::draw(BufferView * bview, Row const * row,
x += lyxfont::width(textstring, font);
}
} else if (font.language()->lang() == "arabic" &&
lyxrc.font_norm == "iso8859-6.8x") {
(lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 ||
lyxrc.font_norm_type == LyXRC::ISO_10646_1)) {
if (Encoding::IsComposeChar_arabic(c)) {
c = TransformChar(c, row->par(), pos);
textstring = c;
int width = lyxfont::width(c, font2);
int dx = 0;
for (LyXParagraph::size_type i = pos-1; i >= 0; --i) {
c = row->par()->GetChar(i);
if (!Encoding::IsComposeChar_arabic(c)) {
if (IsPrintableNonspace(c)) {
int width2 = SingleWidth(bview, row->par(), i, c);
dx = (width2 - width) / 2;
}
break;
}
}
// Draw nikud
pain.text(int(x) + dx, offset + row->baseline(),
textstring, font);
} else {
textstring = TransformChar(c, row->par(), pos);
while (vpos <= last &&
(pos = vis2log(vpos)) >= 0
&& static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
&& IsPrintableNonspace(c = row->par()->GetChar(pos))
&& !Encoding::IsComposeChar_arabic(c)
&& font2 == GetFont(bview->buffer(), row->par(), pos)) {
c = TransformChar(c, row->par(), pos);
textstring += c;
++vpos;
}
// Draw text and set the new x position
pain.text(int(x), offset + row->baseline(), textstring, font);
pain.text(int(x), offset + row->baseline(),
textstring, font);
x += lyxfont::width(textstring, font);
}
} else {
while (vpos <= last &&
(pos = vis2log(vpos)) >= 0
&& static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
&& IsPrintableNonspace(c = row->par()->GetChar(pos))
&& font2 == GetFont(bview->buffer(), row->par(), pos)) {
textstring += c;
++vpos;
@ -662,12 +618,7 @@ void LyXText::draw(BufferView * bview, Row const * row,
x += lyxfont::width(textstring, font);
}
// what about underbars?
if (font.underbar() == LyXFont::ON && font.latex() != LyXFont::ON) {
pain.line(int(tmpx), offset + row->baseline() + 2,
int(x), offset + row->baseline() + 2);
} else if (lyxrc.mark_foreign_language &&
if (lyxrc.mark_foreign_language &&
font.language() != bview->buffer()->params.language_info) {
int y = offset + row->height() - 1;
pain.line(int(tmpx), y, int(x), y,