encoding patch and mousewheelpatch

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@858 a592a061-630c-0410-9148-cb99ea01b6c8

ChangeLog

@@ -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

lib/lyxrc.example

@@ -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 

src/BufferView_pimpl.C

@@ -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;
 		}
 	}

src/BufferView_pimpl.h

@@ -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);
 	///

src/LyXView.h

@@ -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);

src/Makefile.am

@@ -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 \

src/Painter.C

@@ -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,21 +318,58 @@ PainterBase & Painter::text(int x, int y, char const * s, int ls,
 			}
 		}
 	}
-	underline(f, x, y, lyxfont::width(s, ls, f));
+	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;
 }
 
 
 void Painter::underline(LyXFont const & f, int x, int y, int width)
 {
-	// What about underbars?
+	int below = max(lyxfont::maxDescent(f) / 2, 2);
-	if (f.underbar() == LyXFont::ON && f.latex() != LyXFont::ON) {
+	int height = max((lyxfont::maxDescent(f) / 4) - 1, 1);
-		int below = max(lyxfont::maxDescent(f) / 2, 2);
+	if (height < 2)
-		int height = max((lyxfont::maxDescent(f) / 4) - 1, 1);
+		line(x, y + below, x + width, y + below, f.color());
-		if (height < 2)
+	else
-			line(x, y + below, x + width, y + below, f.color());
+		fillRectangle(x, y + below, width, below + height,
-		else
+			      f.color());
-			fillRectangle(x, y + below, width, below + height,
-				      f.color());
-	}
 }

src/Painter.h

@@ -96,7 +96,10 @@ 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);

src/buffer.C

@@ -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,12 +1719,32 @@ 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();
 		}
-		
+
 		// At the very beginning the text parameters.
 		if (params.paperpackage != BufferParams::PACKAGE_NONE) {
 			switch (params.paperpackage) {

src/bufferparams.C

@@ -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;

src/direction.h

@@ -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

src/encoding.C

@@ -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);

src/encoding.h

@@ -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

src/font.C

@@ -5,8 +5,7 @@
 #include "font.h"
 #include "FontLoader.h"
 #include "lyxrc.h"
-
+#include "encoding.h"
-extern LyXRC lyxrc;
 
 // 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));

src/font.h

@@ -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);
 };

src/insets/insetinclude.h

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

src/language.C

@@ -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;
 };
 
 
@@ -44,59 +38,61 @@ void LangInit::initL()
 {
 	// Use this style of initialization to lower compilation times.
 	// Same method is used in LyXAction.C (Lgb)
-	
+
 	lang_item items[] = {
-	{ "afrikaans", N_("Afrikaans"), false },
+	{ "afrikaans", N_("Afrikaans"), false, &iso8859_1 },
-	{ "american", N_("American"), false },
+	{ "american", N_("American"), false, &iso8859_1 },
-	{ "arabic", N_("Arabic"), true },
+	{ "arabic", N_("Arabic"), true, &iso8859_6 },
-	{ "austrian", N_("Austrian"), false },
+	{ "austrian", N_("Austrian"), false, &iso8859_1 },
-	{ "bahasa", N_("Bahasa"), false },
+	{ "bahasa", N_("Bahasa"), false, &iso8859_1 },
-	{ "brazil", N_("Brazil"), false },
+	{ "brazil", N_("Brazil"), false, &iso8859_1 },
-	{ "breton", N_("Breton"), false },
+	{ "breton", N_("Breton"), false, &iso8859_1 },
-	{ "catalan", N_("Catalan"), false },
+	{ "catalan", N_("Catalan"), false, &iso8859_1 },
-	{ "croatian", N_("Croatian"), false },
+	{ "croatian", N_("Croatian"), false, &iso8859_2 },
-	{ "czech", N_("Czech"), false },
+	{ "czech", N_("Czech"), false, &iso8859_2 },
-	{ "danish", N_("Danish"), false },
+	{ "danish", N_("Danish"), false, &iso8859_1 },
-	{ "dutch", N_("Dutch"), false },
+	{ "dutch", N_("Dutch"), false, &iso8859_1 },
-	{ "english", N_("English"), false },
+	{ "english", N_("English"), false, &iso8859_1 },
-	{ "esperanto", N_("Esperanto"), false },
+	{ "esperanto", N_("Esperanto"), false, &iso8859_1 },
-	{ "estonian", N_("Estonian"), false },
+	{ "estonian", N_("Estonian"), false, &iso8859_4 },
-	{ "finnish", N_("Finnish"), false },
+	{ "finnish", N_("Finnish"), false, &iso8859_1 },
-	{ "francais", N_("Francais"), false },
+	{ "francais", N_("Francais"), false, &iso8859_1 },
-	{ "french", N_("French"), false },
+	{ "french", N_("French"), false, &iso8859_1 },
-	{ "frenchb", N_("Frenchb"), false },
+	{ "frenchb", N_("Frenchb"), false, &iso8859_1 },
-	{ "galician", N_("Galician"), false },
+	{ "galician", N_("Galician"), false, &iso8859_1 },
-	{ "german", N_("German"), false },
+	{ "german", N_("German"), false, &iso8859_1 },
-	{ "greek", N_("Greek"), false },
+	{ "greek", N_("Greek"), false, &iso8859_7 },
-	{ "hebrew", N_("Hebrew"), true },
+	{ "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 },
+	//{ "hungarian", N_("Hungarian"), false, &iso8859_2 },
-	{ "irish", N_("Irish"), false },
+	{ "irish", N_("Irish"), false, &iso8859_1 },
-	{ "italian", N_("Italian"), false },
+	{ "italian", N_("Italian"), false, &iso8859_1 },
-	{ "lsorbian", N_("Lsorbian"), false },
+	{ "lsorbian", N_("Lsorbian"), false, &iso8859_1 },
-	{ "magyar", N_("Magyar"), false },
+	{ "magyar", N_("Magyar"), false, &iso8859_1 },
-	{ "norsk", N_("Norsk"), false },
+	{ "norsk", N_("Norsk"), false, &iso8859_1 },
-	{ "polish", N_("Polish"), false },
+	{ "polish", N_("Polish"), false, &iso8859_2 },
-	{ "portuges", N_("Portuges"), false },
+	{ "portuges", N_("Portuges"), false, &iso8859_1 },
-	{ "romanian", N_("Romanian"), false },
+	{ "romanian", N_("Romanian"), false, &iso8859_2 },
-	{ "russian", N_("Russian"), false },
+	{ "russian", N_("Russian"), false, &koi8 },
-	{ "scottish", N_("Scottish"), false },
+	{ "scottish", N_("Scottish"), false, &iso8859_1 },
-	{ "spanish", N_("Spanish"), false },
+	{ "spanish", N_("Spanish"), false, &iso8859_1 },
-	{ "slovak", N_("Slovak"), false },
+	{ "slovak", N_("Slovak"), false, &iso8859_2 },
-	{ "slovene", N_("Slovene"), false },
+	{ "slovene", N_("Slovene"), false, &iso8859_2 },
-	{ "swedish", N_("Swedish"), false },
+	{ "swedish", N_("Swedish"), false, &iso8859_1 },
-	{ "turkish", N_("Turkish"), false },
+	{ "turkish", N_("Turkish"), false, &iso8859_1 },
-	{ "usorbian", N_("Usorbian"), false },
+	{ "usorbian", N_("Usorbian"), false, &iso8859_1 },
-	{ "welsh", N_("Welsh"), false },
+	{ "welsh", N_("Welsh"), false, &iso8859_1 },
-	{ 0, 0, false }
+	{ 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;
 	}
 	

src/language.h

@@ -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)
+	Language(string const & l, string const & d, bool rtl, Encoding const * e)
-		: lang_(l), display_(d), RightToLeft_(rtl) {}
+		: 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.display_ == l2.display_
-		&& l1.RightToLeft == l2.RightToLeft;
+		&& l1.RightToLeft_ == l2.RightToLeft_
+		&& l1.encoding_ == l2.encoding_;
 }
 
 

src/lyx_cb.C

@@ -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();
 

src/lyx_gui.C

@@ -78,25 +78,20 @@ extern BufferList bufferlist;
 
 FL_CMD_OPT cmdopt[] =
 {
-	{"-width", "*.width", XrmoptionSepArg, "690"},
+	{"-geometry", "*.geometry", XrmoptionSepArg, "690x510"}
-	{"-height", "*.height", XrmoptionSepArg, "510"},
-	{"-xpos", "*.xpos", XrmoptionSepArg, "-1"},
-	{"-ypos", "*.ypos", XrmoptionSepArg, "-1"}
 };
 
-static int width;
+static int width  = 690;
-static int height;
+static int height = 510;
-static int xpos;
+static int xpos   = -1;
-static int ypos;
+static int ypos   = -1;
+static char geometry[40];
 bool	   cursor_follows_scrollbar;
 
 
 FL_resource res[] =
 {
-	{"width", "widthClass", FL_INT, &width, "690", 0},
+	{"geometry", "geometryClass", FL_STRING, geometry, "690x510", 40}
-	{"height", "heightClass", FL_INT, &height, "510", 0},
-	{"xpos", "xposClass", FL_INT, &xpos, "-1", 0},
-	{"ypos", "yposClass", FL_INT, &ypos, "-1", 0}
 };
 
 
@@ -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) {

src/lyx_main.C

@@ -591,13 +591,10 @@ void commandLineHelp()
 	lyxerr <<
 		_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n"
 		  "Command line switches (case sensitive):\n"
-		  "\t-help           summarize LyX usage\n"
+		  "\t-help              summarize LyX usage\n"
-		  "\t-userdir dir      try to set user directory to dir\n"
+		  "\t-userdir dir       try to set user directory to dir\n"
-		  "\t-sysdir dir       try to set system 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-geometry WxH+X+Y  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-dbg feature[,feature]...\n"
                   "                  select the features to debug.\n"
                   "                  Type `lyx -dbg' to see the list of features\n"

src/lyxrc.C

@@ -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;
@@ -732,6 +736,11 @@ int LyXRC::read(string const & filename)
 			if (lexrc.next())
 				zoom = lexrc.GetInteger();
 			break;
+
+		case RC_WHEEL_JUMP:
+			if (lexrc.next())
+				wheel_jump = lexrc.GetInteger();
+			break;
 			
 		case RC_SCREEN_FONT_SIZES:
 			if (lexrc.next())
@@ -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;

src/lyxrc.h

@@ -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;
 	///

src/lyxtext.h

@@ -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;

src/paragraph.C

@@ -36,6 +36,7 @@
 #include "texrow.h"
 #include "support/lyxmanip.h"
 #include "BufferView.h"
+#include "encoding.h"
 
 using std::ostream;
 using std::endl;
@@ -2092,13 +2093,22 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf,
 
 	Language const * language = getParLanguage(bparams);
 	Language const * doc_language = bparams.language_info;
-	if (language != doc_language &&
+	Language const * previous_language = previous
-	    (!previous || previous->getParLanguage(bparams) != language)) {
+		? 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:
@@ -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
 					   << '}';

src/spellchecker.C

@@ -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;
@@ -327,13 +328,17 @@ void create_ispell_pipe(BufferParams const & params, string const & lang)
 			argv[argc++] = tmp;
 		}
 		if (lyxrc.isp_use_input_encoding &&
-        	    params.inputenc != "default") {
+		    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];
+			tmp = new char[n + 1];
-			params.inputenc.copy(tmp, params.inputenc.length());
+			enc.copy(tmp, n);
-			tmp[params.inputenc.length()] = '\0';
+			tmp[n] = '\0';
 			argv[argc++] = tmp;
 		}
 

src/support/textutils.h

@@ -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) {

src/text.C

@@ -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 (!Encoding::is_arabic(c))
-		if (isdigit(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)));
+	unsigned char prev_char = pos > 0 ? par->GetChar(pos-1) : ' ';
-	if (pos < par->Last()-1 && is_arabic(par->GetChar(pos+1)))
+	unsigned char next_char = ' ';
-		if (not_first)
+	for (LyXParagraph::size_type i = pos+1; i < par->Last(); ++i)
-			return TransformChar(c,FORM_MEDIAL);
+		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)
+		if (Encoding::is_arabic(prev_char))
-			return TransformChar(c,FORM_FINAL);
+			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 ||
-				c = TransformChar(c, par, pos);
+			     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,20 +537,19 @@ void LyXText::draw(BufferView * bview, Row const * row,
 	LyXParagraph::size_type last = RowLastPrintable(row);
 
 	if (font.language()->lang() == "hebrew") {
-		if (is_nikud(c)) {
+		if (Encoding::IsComposeChar_hebrew(c)) {
-			LyXParagraph::size_type vpos2 = vpos;
 			int width = lyxfont::width(c, font2);
 			int dx = 0;
-			while (vpos2 <= last &&
+			for (LyXParagraph::size_type i = pos-1; i >= 0; --i) {
-			       (pos = vis2log(vpos2)) >= 0
+				c = row->par()->GetChar(i);
-			       && static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
+				if (!Encoding::IsComposeChar_hebrew(c)) {
-			       && is_nikud(c))
+					if (IsPrintableNonspace(c)) {
-				++vpos2;
+						int width2 = SingleWidth(bview, row->par(), i, c);
-			if (static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
+						dx = (c == 'ø' || c == 'ã') // dalet / resh
-			    && !is_nikud(c)) {
+							? width2 - width : (width2 - width) / 2;
-				int width2 = SingleWidth(bview, row->par(), pos, c);
+					}
-				dx = (c == 'ø' || c == 'ã') 
+					break;
-					? width2 - width : (width2 - width) / 2;
+				}
 			}
 			// Draw nikud
 			pain.text(int(x) + dx, offset + row->baseline(),
@@ -624,8 +557,8 @@ void LyXText::draw(BufferView * bview, Row const * row,
 		} else {
 			while (vpos <= last &&
 			       (pos = vis2log(vpos)) >= 0
-			       && static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
+			       && IsPrintableNonspace(c = row->par()->GetChar(pos))
-			       && !is_nikud(c)
+			       && !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 ||
-		textstring = TransformChar(c, row->par(), pos);
+		    lyxrc.font_norm_type == LyXRC::ISO_10646_1)) {
-		while (vpos <= last &&
+		if (Encoding::IsComposeChar_arabic(c)) {
-		       (pos = vis2log(vpos)) >= 0
-		       && static_cast<unsigned char>(c = row->par()->GetChar(pos)) > ' '
-		       && font2 == GetFont(bview->buffer(), row->par(), pos)) {
 			c = TransformChar(c, row->par(), pos);
-			textstring += c;
+			textstring = c;
-			++vpos;
+			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
+			       && 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);
+			x += lyxfont::width(textstring, font);
 		}
-		// Draw text and set the new x position
-		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;
@@ -661,13 +617,8 @@ void LyXText::draw(BufferView * bview, Row const * row,
 		pain.text(int(x), offset + row->baseline(), textstring, font);
 		x += lyxfont::width(textstring, font);
 	}
-	
+
-	// what about underbars?
+	if (lyxrc.mark_foreign_language &&
-	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 &&
 	    font.language() != bview->buffer()->params.language_info) {
 		int y = offset + row->height() - 1;
 		pain.line(int(tmpx), y, int(x), y,