//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p N u l l //
//--------------------------------------------------------------------//
// //
// Null map array. //
// //
//--------------------------------------------------------------------//
private static void unicodeMapNull()
{
const eSymSetMapId mapId = eSymSetMapId.mapNull;
const Int32 rangeCt = 1;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x00, 0x01
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
null));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p U s e r S e t //
//--------------------------------------------------------------------//
// //
// Default map array for 'user-defined' encoding. //
// //
//--------------------------------------------------------------------//
private static void unicodeMapUserSet()
{
const eSymSetMapId mapId = eSymSetMapId.mapUserSet;
const Int32 rangeCt = 1;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x0000, 0xffff
} // rangeMax + 1 > UInt16 max
};
Int32 [] rangeSizes = new Int32 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (rangeData [i] [1] - rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
for (Int32 i = rangeMin; i <= rangeMax; i++) // i > UInt6Max at end loop
{
mapDataStd [0] [i - rangeMin] = (UInt16)i;
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
null));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 8 H //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 8H //
// Kind1 264 //
// Name Hebrew-8 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_8H()
{
const eSymSetMapId mapId = eSymSetMapId.map_8H;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xdf
},
new UInt16 [2] {
0xe0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize,
offset;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL [0] [0x27 - rangeMin] = 0x2019;
mapDataPCL [0] [0x60 - rangeMin] = 0x2019;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL[1][i - rangeMin] = 0xffff; //<not a character> //
}
mapDataPCL[1][0xa0 - rangeMin] = 0x0020;
mapDataPCL[1][0xa1 - rangeMin] = 0x0021;
mapDataPCL[1][0xa2 - rangeMin] = 0x0022;
mapDataPCL[1][0xa3 - rangeMin] = 0x0023;
mapDataPCL[1][0xa4 - rangeMin] = 0x0024;
mapDataPCL[1][0xa5 - rangeMin] = 0x0025;
mapDataPCL[1][0xa6 - rangeMin] = 0x0026;
mapDataPCL[1][0xa7 - rangeMin] = 0x2019;
mapDataPCL[1][0xa8 - rangeMin] = 0x0029;
mapDataPCL[1][0xa9 - rangeMin] = 0x0028;
mapDataPCL[1][0xaa - rangeMin] = 0x002a;
mapDataPCL[1][0xab - rangeMin] = 0x002b;
mapDataPCL[1][0xac - rangeMin] = 0x002c;
mapDataPCL[1][0xad - rangeMin] = 0x002d;
mapDataPCL[1][0xae - rangeMin] = 0x002e;
mapDataPCL[1][0xaf - rangeMin] = 0x002f;
mapDataPCL[1][0xba - rangeMin] = 0x003a;
mapDataPCL[1][0xbb - rangeMin] = 0x003b;
mapDataPCL[1][0xbc - rangeMin] = 0x003e;
mapDataPCL[1][0xbd - rangeMin] = 0x003d;
mapDataPCL[1][0xbe - rangeMin] = 0x003c;
mapDataPCL[1][0xbf - rangeMin] = 0x003f;
mapDataPCL[1][0xc0 - rangeMin] = 0x0040;
mapDataPCL[1][0xd0 - rangeMin] = 0x2019;
mapDataPCL[1][0xd1 - rangeMin] = 0x20aa;
mapDataPCL[1][0xdb - rangeMin] = 0x005d;
mapDataPCL[1][0xdc - rangeMin] = 0x005c;
mapDataPCL[1][0xdd - rangeMin] = 0x005b;
mapDataPCL[1][0xde - rangeMin] = 0x005e;
mapDataPCL[1][0xdf - rangeMin] = 0x005f;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
offset = 0x05d0 - 0x00e0; // 0x05d0 - 0x00e0 = 0x04f0
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL[2][i - rangeMin] = (UInt16)(offset + i);
}
mapDataPCL [2] [0xfb - rangeMin] = 0x007d;
mapDataPCL [2] [0xfc - rangeMin] = 0x007c;
mapDataPCL [2] [0xfd - rangeMin] = 0x007b;
mapDataPCL [2] [0xfe - rangeMin] = 0x007e;
mapDataPCL [2] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 2 U //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 12U //
// Kind1 405 //
// Name PC-850 Multilingual //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_12U()
{
const eSymSetMapId mapId = eSymSetMapId.map_12U;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x01, 0x1f
},
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x01 - rangeMin] = 0x263a;
mapDataStd [0] [0x02 - rangeMin] = 0x263b;
mapDataStd [0] [0x03 - rangeMin] = 0x2665;
mapDataStd [0] [0x04 - rangeMin] = 0x2666;
mapDataStd [0] [0x05 - rangeMin] = 0x2663;
mapDataStd [0] [0x06 - rangeMin] = 0x2660;
mapDataStd [0] [0x07 - rangeMin] = 0x2022;
mapDataStd [0] [0x08 - rangeMin] = 0x25d8;
mapDataStd [0] [0x09 - rangeMin] = 0x25cb;
mapDataStd [0] [0x0a - rangeMin] = 0x25d9;
mapDataStd [0] [0x0b - rangeMin] = 0x2642;
mapDataStd [0] [0x0c - rangeMin] = 0x2640;
mapDataStd [0] [0x0d - rangeMin] = 0x266a;
mapDataStd [0] [0x0e - rangeMin] = 0x266b;
mapDataStd [0] [0x0f - rangeMin] = 0x263c;
mapDataStd [0] [0x10 - rangeMin] = 0x25ba;
mapDataStd [0] [0x11 - rangeMin] = 0x25c4;
mapDataStd [0] [0x12 - rangeMin] = 0x2195;
mapDataStd [0] [0x13 - rangeMin] = 0x203c;
mapDataStd [0] [0x14 - rangeMin] = 0x00b6;
mapDataStd [0] [0x15 - rangeMin] = 0x00a7;
mapDataStd [0] [0x16 - rangeMin] = 0x25ac;
mapDataStd [0] [0x17 - rangeMin] = 0x21a8;
mapDataStd [0] [0x18 - rangeMin] = 0x2191;
mapDataStd [0] [0x19 - rangeMin] = 0x2193;
mapDataStd [0] [0x1a - rangeMin] = 0x2192;
mapDataStd [0] [0x1b - rangeMin] = 0x2190;
mapDataStd [0] [0x1c - rangeMin] = 0x221f;
mapDataStd [0] [0x1d - rangeMin] = 0x2194;
mapDataStd [0] [0x1e - rangeMin] = 0x25b2;
mapDataStd [0] [0x1f - rangeMin] = 0x25bc;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = i;
}
mapDataStd [1] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
mapDataPCL [1] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [1] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [1] [0x7f - rangeMin] = 0x2302;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataStd [2] [0x80 - rangeMin] = 0x00c7;
mapDataStd [2] [0x81 - rangeMin] = 0x00fc;
mapDataStd [2] [0x82 - rangeMin] = 0x00e9;
mapDataStd [2] [0x83 - rangeMin] = 0x00e2;
mapDataStd [2] [0x84 - rangeMin] = 0x00e4;
mapDataStd [2] [0x85 - rangeMin] = 0x00e0;
mapDataStd [2] [0x86 - rangeMin] = 0x00e5;
mapDataStd [2] [0x87 - rangeMin] = 0x00e7;
mapDataStd [2] [0x88 - rangeMin] = 0x00ea;
mapDataStd [2] [0x89 - rangeMin] = 0x00eb;
mapDataStd [2] [0x8a - rangeMin] = 0x00e8;
mapDataStd [2] [0x8b - rangeMin] = 0x00ef;
mapDataStd [2] [0x8c - rangeMin] = 0x00ee;
mapDataStd [2] [0x8d - rangeMin] = 0x00ec;
mapDataStd [2] [0x8e - rangeMin] = 0x00c4;
mapDataStd [2] [0x8f - rangeMin] = 0x00c5;
mapDataStd [2] [0x90 - rangeMin] = 0x00c9;
mapDataStd [2] [0x91 - rangeMin] = 0x00e6;
mapDataStd [2] [0x92 - rangeMin] = 0x00c6;
mapDataStd [2] [0x93 - rangeMin] = 0x00f4;
mapDataStd [2] [0x94 - rangeMin] = 0x00f6;
mapDataStd [2] [0x95 - rangeMin] = 0x00f2;
mapDataStd [2] [0x96 - rangeMin] = 0x00fb;
mapDataStd [2] [0x97 - rangeMin] = 0x00f9;
mapDataStd [2] [0x98 - rangeMin] = 0x00ff;
mapDataStd [2] [0x99 - rangeMin] = 0x00d6;
mapDataStd [2] [0x9a - rangeMin] = 0x00dc;
mapDataStd [2] [0x9b - rangeMin] = 0x00f8;
mapDataStd [2] [0x9c - rangeMin] = 0x00a3;
mapDataStd [2] [0x9d - rangeMin] = 0x00d8;
mapDataStd [2] [0x9e - rangeMin] = 0x00d7;
mapDataStd [2] [0x9f - rangeMin] = 0x0192;
mapDataStd [2] [0xa0 - rangeMin] = 0x00e1;
mapDataStd [2] [0xa1 - rangeMin] = 0x00ed;
mapDataStd [2] [0xa2 - rangeMin] = 0x00f3;
mapDataStd [2] [0xa3 - rangeMin] = 0x00fa;
mapDataStd [2] [0xa4 - rangeMin] = 0x00f1;
mapDataStd [2] [0xa5 - rangeMin] = 0x00d1;
mapDataStd [2] [0xa6 - rangeMin] = 0x00aa;
mapDataStd [2] [0xa7 - rangeMin] = 0x00ba;
mapDataStd [2] [0xa8 - rangeMin] = 0x00bf;
mapDataStd [2] [0xa9 - rangeMin] = 0x00ae;
mapDataStd [2] [0xaa - rangeMin] = 0x00ac;
mapDataStd [2] [0xab - rangeMin] = 0x00bd;
mapDataStd [2] [0xac - rangeMin] = 0x00bc;
mapDataStd [2] [0xad - rangeMin] = 0x00a1;
mapDataStd [2] [0xae - rangeMin] = 0x00ab;
mapDataStd [2] [0xaf - rangeMin] = 0x00bb;
mapDataStd [2] [0xb0 - rangeMin] = 0x2591;
mapDataStd [2] [0xb1 - rangeMin] = 0x2592;
mapDataStd [2] [0xb2 - rangeMin] = 0x2593;
mapDataStd [2] [0xb3 - rangeMin] = 0x2502;
mapDataStd [2] [0xb4 - rangeMin] = 0x2524;
mapDataStd [2] [0xb5 - rangeMin] = 0x00c1;
mapDataStd [2] [0xb6 - rangeMin] = 0x00c2;
mapDataStd [2] [0xb7 - rangeMin] = 0x00c0;
mapDataStd [2] [0xb8 - rangeMin] = 0x00a9;
mapDataStd [2] [0xb9 - rangeMin] = 0x2563;
mapDataStd [2] [0xba - rangeMin] = 0x2551;
mapDataStd [2] [0xbb - rangeMin] = 0x2557;
mapDataStd [2] [0xbc - rangeMin] = 0x255d;
mapDataStd [2] [0xbd - rangeMin] = 0x00a2;
mapDataStd [2] [0xbe - rangeMin] = 0x00a5;
mapDataStd [2] [0xbf - rangeMin] = 0x2510;
mapDataStd [2] [0xc0 - rangeMin] = 0x2514;
mapDataStd [2] [0xc1 - rangeMin] = 0x2534;
mapDataStd [2] [0xc2 - rangeMin] = 0x252c;
mapDataStd [2] [0xc3 - rangeMin] = 0x251c;
mapDataStd [2] [0xc4 - rangeMin] = 0x2500;
mapDataStd [2] [0xc5 - rangeMin] = 0x253c;
mapDataStd [2] [0xc6 - rangeMin] = 0x00e3;
mapDataStd [2] [0xc7 - rangeMin] = 0x00c3;
mapDataStd [2] [0xc8 - rangeMin] = 0x255a;
mapDataStd [2] [0xc9 - rangeMin] = 0x2554;
mapDataStd [2] [0xca - rangeMin] = 0x2569;
mapDataStd [2] [0xcb - rangeMin] = 0x2566;
mapDataStd [2] [0xcc - rangeMin] = 0x2560;
mapDataStd [2] [0xcd - rangeMin] = 0x2550;
mapDataStd [2] [0xce - rangeMin] = 0x256c;
mapDataStd [2] [0xcf - rangeMin] = 0x00a4;
mapDataStd [2] [0xd0 - rangeMin] = 0x00f0;
mapDataStd [2] [0xd1 - rangeMin] = 0x00d0;
mapDataStd [2] [0xd2 - rangeMin] = 0x00ca;
mapDataStd [2] [0xd3 - rangeMin] = 0x00cb;
mapDataStd [2] [0xd4 - rangeMin] = 0x00c8;
mapDataStd [2] [0xd5 - rangeMin] = 0x0131;
mapDataStd [2] [0xd6 - rangeMin] = 0x00cd;
mapDataStd [2] [0xd7 - rangeMin] = 0x00ce;
mapDataStd [2] [0xd8 - rangeMin] = 0x00cf;
mapDataStd [2] [0xd9 - rangeMin] = 0x2518;
mapDataStd [2] [0xda - rangeMin] = 0x250c;
mapDataStd [2] [0xdb - rangeMin] = 0x2588;
mapDataStd [2] [0xdc - rangeMin] = 0x2584;
mapDataStd [2] [0xdd - rangeMin] = 0x00a6;
mapDataStd [2] [0xde - rangeMin] = 0x00cc;
mapDataStd [2] [0xdf - rangeMin] = 0x2580;
mapDataStd [2] [0xe0 - rangeMin] = 0x00d3;
mapDataStd [2] [0xe1 - rangeMin] = 0x00df;
mapDataStd [2] [0xe2 - rangeMin] = 0x00d4;
mapDataStd [2] [0xe3 - rangeMin] = 0x00d2;
mapDataStd [2] [0xe4 - rangeMin] = 0x00f5;
mapDataStd [2] [0xe5 - rangeMin] = 0x00d5;
mapDataStd [2] [0xe6 - rangeMin] = 0x00b5;
mapDataStd [2] [0xe7 - rangeMin] = 0x00fe;
mapDataStd [2] [0xe8 - rangeMin] = 0x00de;
mapDataStd [2] [0xe9 - rangeMin] = 0x00da;
mapDataStd [2] [0xea - rangeMin] = 0x00db;
mapDataStd [2] [0xeb - rangeMin] = 0x00d9;
mapDataStd [2] [0xec - rangeMin] = 0x00fd;
mapDataStd [2] [0xed - rangeMin] = 0x00dd;
mapDataStd [2] [0xee - rangeMin] = 0x00af;
mapDataStd [2] [0xef - rangeMin] = 0x00b4;
mapDataStd [2] [0xf0 - rangeMin] = 0x00ad;
mapDataStd [2] [0xf1 - rangeMin] = 0x00b1;
mapDataStd [2] [0xf2 - rangeMin] = 0x2017;
mapDataStd [2] [0xf3 - rangeMin] = 0x00be;
mapDataStd [2] [0xf4 - rangeMin] = 0x00b6;
mapDataStd [2] [0xf5 - rangeMin] = 0x00a7;
mapDataStd [2] [0xf6 - rangeMin] = 0x00f7;
mapDataStd [2] [0xf7 - rangeMin] = 0x00b8;
mapDataStd [2] [0xf8 - rangeMin] = 0x00b0;
mapDataStd [2] [0xf9 - rangeMin] = 0x00a8;
mapDataStd [2] [0xfa - rangeMin] = 0x00b7;
mapDataStd [2] [0xfb - rangeMin] = 0x00b9;
mapDataStd [2] [0xfc - rangeMin] = 0x00b3;
mapDataStd [2] [0xfd - rangeMin] = 0x00b2;
mapDataStd [2] [0xfe - rangeMin] = 0x25a0;
mapDataStd [2] [0xff - rangeMin] = 0x00a0;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [2] [i] = mapDataStd [2] [i];
}
mapDataPCL [2] [0xee - rangeMin] = 0x02c9;
mapDataPCL [2] [0xfe - rangeMin] = 0x25aa;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 2 S //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 2S //
// Kind1 83 //
// Name ISO 17: Spanish //
// National Language Variant of (7-bit) US-ASCII set. //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_2S()
{
const eSymSetMapId mapId = eSymSetMapId.map_2S;
const Int32 rangeCt = 1;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd[0][0x23 - rangeMin] = 0x00a3;
mapDataStd[0][0x24 - rangeMin] = 0x0024;
mapDataStd[0][0x40 - rangeMin] = 0x00a7;
mapDataStd[0][0x5b - rangeMin] = 0x00a1;
mapDataStd[0][0x5c - rangeMin] = 0x00d1;
mapDataStd[0][0x5d - rangeMin] = 0x00bf;
mapDataStd[0][0x5e - rangeMin] = 0x005e;
mapDataStd[0][0x60 - rangeMin] = 0x0060;
mapDataStd[0][0x7b - rangeMin] = 0x00b0;
mapDataStd[0][0x7c - rangeMin] = 0x00f1;
mapDataStd[0][0x7d - rangeMin] = 0x00e7;
mapDataStd[0][0x7e - rangeMin] = 0x007e;
mapDataStd[0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL [0] [0x27 - rangeMin] = 0x2019;
mapDataPCL [0] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [0] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ x 1 0 0 1 T //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 1001T //
// Kind1 32052 //
// Name ISO-8859-11 Latin/Thai //
// Note As TIS-620 (symbol set 1T) but also includes //
// no-break-space at code-point 0xA0 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_x1001T()
{
const eSymSetMapId mapId = eSymSetMapId.map_x1001T;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
offset;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
offset = 0x0e00 - 0x00a0; // 0x0e00 - 0x00a0 = 0x0d60
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = (UInt16)(offset + i);
}
mapDataStd [1] [0xa0 - rangeMin] = 0x00a0;
mapDataStd [1] [0xdb - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xdc - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xdd - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xde - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xfc - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xfd - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xfe - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
null));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 2 N //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 12N //
// Kind1 398 //
// Name ISO 8859-7 Latin/Greek //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_12N()
{
const eSymSetMapId mapId = eSymSetMapId.map_12N;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize,
offset;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL [0] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [0] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
offset = 0x0370 - 0xa0; // 0x0370 - 0x00a0 = 0x02d0
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = (UInt16)(offset + i);
}
mapDataStd [1] [0xa0 - rangeMin] = 0x00a0;
mapDataStd [1] [0xa1 - rangeMin] = 0x2018;
mapDataStd [1] [0xa2 - rangeMin] = 0x2019;
mapDataStd [1] [0xa3 - rangeMin] = 0x00a3;
mapDataStd [1] [0xa4 - rangeMin] = 0x20ac;
mapDataStd [1] [0xa5 - rangeMin] = 0x20af;
mapDataStd [1] [0xa6 - rangeMin] = 0x00a6;
mapDataStd [1] [0xa7 - rangeMin] = 0x00a7;
mapDataStd [1] [0xa8 - rangeMin] = 0x00a8;
mapDataStd [1] [0xa9 - rangeMin] = 0x00a9;
mapDataStd [1] [0xaa - rangeMin] = 0x037a;
mapDataStd [1] [0xab - rangeMin] = 0x00ab;
mapDataStd [1] [0xac - rangeMin] = 0x00ac;
mapDataStd [1] [0xad - rangeMin] = 0x00ad;
mapDataStd [1] [0xae - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xaf - rangeMin] = 0x2015;
mapDataStd [1] [0xb0 - rangeMin] = 0x00b0;
mapDataStd [1] [0xb1 - rangeMin] = 0x00b1;
mapDataStd [1] [0xb2 - rangeMin] = 0x00b2;
mapDataStd [1] [0xb3 - rangeMin] = 0x00b3;
mapDataStd [1] [0xb7 - rangeMin] = 0x00b7;
mapDataStd [1] [0xbb - rangeMin] = 0x00bb;
mapDataStd [1] [0xbd - rangeMin] = 0x00bd;
mapDataStd [1] [0xd2 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
mapDataPCL [1] [0xa1 - rangeMin] = 0x1ffe;
mapDataPCL [1] [0xa2 - rangeMin] = 0x1fbf;
mapDataPCL [1] [0xae - rangeMin] = 0x003b;
mapDataPCL [1] [0xaf - rangeMin] = 0x2014;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 1 N //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 11N //
// Kind1 366 //
// Name ISO 8859-6 Latin/Arabic //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_11N()
{
const eSymSetMapId mapId = eSymSetMapId.map_11N;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xbf
},
new UInt16 [2] {
0xc0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize,
offset;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[0][i] = mapDataStd[0][i];
}
mapDataPCL[0][0x2a - rangeMin] = 0x066d;
mapDataPCL[0][0x5e - rangeMin] = 0x02c6;
mapDataPCL[0][0x7e - rangeMin] = 0x02dc;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = 0xffff; //<not a character> //
}
mapDataStd [1] [0xa0 - rangeMin] = 0x00a0;
mapDataStd [1] [0xa4 - rangeMin] = 0x00a4;
mapDataStd [1] [0xac - rangeMin] = 0x060c;
mapDataStd [1] [0xad - rangeMin] = 0x00ad;
mapDataStd [1] [0xbb - rangeMin] = 0x061b;
mapDataStd [1] [0xbf - rangeMin] = 0x061f;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[1][i] = mapDataStd[1][i];
}
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
offset = 0x0620 - 0xc0; // 0x0620 - 0x00c0 = 0x0560
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [2] [i - rangeMin] = (UInt16)(offset + i);
}
mapDataStd [2] [0xdb - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xdc - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xdd - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xde - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xdf - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xf3 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xf4 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xf5 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xf6 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xf7 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xf8 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xf9 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xfa - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xfb - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xfc - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xfd - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xfe - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[2][i] = mapDataStd[2][i];
}
mapDataPCL[2][0xc0 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL[2][0xc1 - rangeMin] = 0xfe80;
mapDataPCL[2][0xc2 - rangeMin] = 0xfe81;
mapDataPCL[2][0xc3 - rangeMin] = 0xfe83;
mapDataPCL[2][0xc4 - rangeMin] = 0xef28;
mapDataPCL[2][0xc5 - rangeMin] = 0xfe87;
mapDataPCL[2][0xc6 - rangeMin] = 0xfe8a;
mapDataPCL[2][0xc7 - rangeMin] = 0xfe8d;
mapDataPCL[2][0xc8 - rangeMin] = 0xef03;
mapDataPCL[2][0xc9 - rangeMin] = 0xef09;
mapDataPCL[2][0xca - rangeMin] = 0xef04;
mapDataPCL[2][0xcb - rangeMin] = 0xef05;
mapDataPCL[2][0xcc - rangeMin] = 0xfe9d;
mapDataPCL[2][0xcd - rangeMin] = 0xfea1;
mapDataPCL[2][0xce - rangeMin] = 0xfea5;
mapDataPCL[2][0xcf - rangeMin] = 0xef29;
mapDataPCL[2][0xd0 - rangeMin] = 0xef2a;
mapDataPCL[2][0xd1 - rangeMin] = 0xef2b;
mapDataPCL[2][0xd2 - rangeMin] = 0xef2c;
mapDataPCL[2][0xd3 - rangeMin] = 0xef0b;
mapDataPCL[2][0xd4 - rangeMin] = 0xef0c;
mapDataPCL[2][0xd5 - rangeMin] = 0xef37;
mapDataPCL[2][0xd6 - rangeMin] = 0xef38;
mapDataPCL[2][0xd7 - rangeMin] = 0xef32;
mapDataPCL[2][0xd8 - rangeMin] = 0xef33;
mapDataPCL[2][0xd9 - rangeMin] = 0xfec9;
mapDataPCL[2][0xda - rangeMin] = 0xfecd;
mapDataPCL[2][0xdb - rangeMin] = 0x0640;
mapDataPCL[2][0xe0 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL[2][0xe1 - rangeMin] = 0xef06;
mapDataPCL[2][0xe2 - rangeMin] = 0xef27;
mapDataPCL[2][0xe3 - rangeMin] = 0xef23;
mapDataPCL[2][0xe4 - rangeMin] = 0xef24;
mapDataPCL[2][0xe5 - rangeMin] = 0xef25;
mapDataPCL[2][0xe6 - rangeMin] = 0xef26;
mapDataPCL[2][0xe7 - rangeMin] = 0xfee9;
mapDataPCL[2][0xe8 - rangeMin] = 0xef2d;
mapDataPCL[2][0xe9 - rangeMin] = 0xfeef;
mapDataPCL[2][0xea - rangeMin] = 0xfef1;
mapDataPCL[2][0xeb - rangeMin] = 0xfe70;
mapDataPCL[2][0xec - rangeMin] = 0xfe72;
mapDataPCL[2][0xed - rangeMin] = 0xfe74;
mapDataPCL[2][0xee - rangeMin] = 0xfe76;
mapDataPCL[2][0xef - rangeMin] = 0xfe78;
mapDataPCL[2][0xf0 - rangeMin] = 0xfe7a;
mapDataPCL[2][0xf1 - rangeMin] = 0xfe7c;
mapDataPCL[2][0xf2 - rangeMin] = 0xfe7e;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 9 G //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 9G //
// Kind1 295 //
// Name Windows Latin/Greek //
// Code Page 1253 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_9G()
{
const eSymSetMapId mapId = eSymSetMapId.map_9G;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0x9f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL [0] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [0] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataStd [1] [0x80 - rangeMin] = 0x20ac;
mapDataStd [1] [0x81 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x82 - rangeMin] = 0x201a;
mapDataStd [1] [0x83 - rangeMin] = 0x0192;
mapDataStd [1] [0x84 - rangeMin] = 0x201e;
mapDataStd [1] [0x85 - rangeMin] = 0x2026;
mapDataStd [1] [0x86 - rangeMin] = 0x2020;
mapDataStd [1] [0x87 - rangeMin] = 0x2021;
mapDataStd [1] [0x88 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x89 - rangeMin] = 0x2030;
mapDataStd [1] [0x8a - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x8b - rangeMin] = 0x2039;
mapDataStd [1] [0x8c - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x8d - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x8e - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x8f - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x90 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x91 - rangeMin] = 0x2018;
mapDataStd [1] [0x92 - rangeMin] = 0x2019;
mapDataStd [1] [0x93 - rangeMin] = 0x201c;
mapDataStd [1] [0x94 - rangeMin] = 0x201d;
mapDataStd [1] [0x95 - rangeMin] = 0x2022;
mapDataStd [1] [0x96 - rangeMin] = 0x2013;
mapDataStd [1] [0x97 - rangeMin] = 0x2014;
mapDataStd [1] [0x98 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x99 - rangeMin] = 0x2122;
mapDataStd [1] [0x9a - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x9b - rangeMin] = 0x203a;
mapDataStd [1] [0x9c - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x9d - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x9e - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x9f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataStd[2][0xa0 - rangeMin] = 0x00a0;
mapDataStd[2][0xa1 - rangeMin] = 0x0385;
mapDataStd[2][0xa2 - rangeMin] = 0x0386;
mapDataStd[2][0xa3 - rangeMin] = 0x00a3;
mapDataStd[2][0xa4 - rangeMin] = 0x00a4;
mapDataStd[2][0xa5 - rangeMin] = 0x00a5;
mapDataStd[2][0xa6 - rangeMin] = 0x00a6;
mapDataStd[2][0xa7 - rangeMin] = 0x00a7;
mapDataStd[2][0xa8 - rangeMin] = 0x00a8;
mapDataStd[2][0xa9 - rangeMin] = 0x00a9;
mapDataStd[2][0xaa - rangeMin] = 0x00aa;
mapDataStd[2][0xab - rangeMin] = 0x00ab;
mapDataStd[2][0xac - rangeMin] = 0x00ac;
mapDataStd[2][0xad - rangeMin] = 0x00ad;
mapDataStd[2][0xae - rangeMin] = 0x00ae;
mapDataStd[2][0xaf - rangeMin] = 0x2015;
mapDataStd[2][0xb0 - rangeMin] = 0x00b0;
mapDataStd[2][0xb1 - rangeMin] = 0x00b1;
mapDataStd[2][0xb2 - rangeMin] = 0x00b2;
mapDataStd[2][0xb3 - rangeMin] = 0x00b3;
mapDataStd[2][0xb4 - rangeMin] = 0x0384;
mapDataStd[2][0xb5 - rangeMin] = 0x00b5;
mapDataStd[2][0xb6 - rangeMin] = 0x00b6;
mapDataStd[2][0xb7 - rangeMin] = 0x00b7;
mapDataStd[2][0xb8 - rangeMin] = 0x0388;
mapDataStd[2][0xb9 - rangeMin] = 0x0389;
mapDataStd[2][0xba - rangeMin] = 0x038a;
mapDataStd[2][0xbb - rangeMin] = 0x00bb;
mapDataStd[2][0xbc - rangeMin] = 0x038c;
mapDataStd[2][0xbd - rangeMin] = 0x00bd;
mapDataStd[2][0xbe - rangeMin] = 0x038e;
mapDataStd[2][0xbf - rangeMin] = 0x038f;
mapDataStd[2][0xc0 - rangeMin] = 0x0390;
mapDataStd[2][0xc1 - rangeMin] = 0x0391;
mapDataStd[2][0xc2 - rangeMin] = 0x0392;
mapDataStd[2][0xc3 - rangeMin] = 0x0393;
mapDataStd[2][0xc4 - rangeMin] = 0x0394;
mapDataStd[2][0xc5 - rangeMin] = 0x0395;
mapDataStd[2][0xc6 - rangeMin] = 0x0396;
mapDataStd[2][0xc7 - rangeMin] = 0x0397;
mapDataStd[2][0xc8 - rangeMin] = 0x0398;
mapDataStd[2][0xc9 - rangeMin] = 0x0399;
mapDataStd[2][0xca - rangeMin] = 0x039a;
mapDataStd[2][0xcb - rangeMin] = 0x039b;
mapDataStd[2][0xcc - rangeMin] = 0x039c;
mapDataStd[2][0xcd - rangeMin] = 0x039d;
mapDataStd[2][0xce - rangeMin] = 0x039e;
mapDataStd[2][0xcf - rangeMin] = 0x039f;
mapDataStd[2][0xd0 - rangeMin] = 0x03a0;
mapDataStd[2][0xd1 - rangeMin] = 0x03a1;
mapDataStd[2][0xd2 - rangeMin] = 0xffff; //<not a character> //
mapDataStd[2][0xd3 - rangeMin] = 0x03a3;
mapDataStd[2][0xd4 - rangeMin] = 0x03a4;
mapDataStd[2][0xd5 - rangeMin] = 0x03a5;
mapDataStd[2][0xd6 - rangeMin] = 0x03a6;
mapDataStd[2][0xd7 - rangeMin] = 0x03a7;
mapDataStd[2][0xd8 - rangeMin] = 0x03a8;
mapDataStd[2][0xd9 - rangeMin] = 0x03a9;
mapDataStd[2][0xda - rangeMin] = 0x03aa;
mapDataStd[2][0xdb - rangeMin] = 0x03ab;
mapDataStd[2][0xdc - rangeMin] = 0x03ac;
mapDataStd[2][0xdd - rangeMin] = 0x03ad;
mapDataStd[2][0xde - rangeMin] = 0x03ae;
mapDataStd[2][0xdf - rangeMin] = 0x03af;
mapDataStd[2][0xe0 - rangeMin] = 0x03b0;
mapDataStd[2][0xe1 - rangeMin] = 0x03b1;
mapDataStd[2][0xe2 - rangeMin] = 0x03b2;
mapDataStd[2][0xe3 - rangeMin] = 0x03b3;
mapDataStd[2][0xe4 - rangeMin] = 0x03b4;
mapDataStd[2][0xe5 - rangeMin] = 0x03b5;
mapDataStd[2][0xe6 - rangeMin] = 0x03b6;
mapDataStd[2][0xe7 - rangeMin] = 0x03b7;
mapDataStd[2][0xe8 - rangeMin] = 0x03b8;
mapDataStd[2][0xe9 - rangeMin] = 0x03b9;
mapDataStd[2][0xea - rangeMin] = 0x03ba;
mapDataStd[2][0xeb - rangeMin] = 0x03bb;
mapDataStd[2][0xec - rangeMin] = 0x03bc;
mapDataStd[2][0xed - rangeMin] = 0x03bd;
mapDataStd[2][0xee - rangeMin] = 0x03be;
mapDataStd[2][0xef - rangeMin] = 0x03bf;
mapDataStd[2][0xf0 - rangeMin] = 0x03c0;
mapDataStd[2][0xf1 - rangeMin] = 0x03c1;
mapDataStd[2][0xf2 - rangeMin] = 0x03c2;
mapDataStd[2][0xf3 - rangeMin] = 0x03c3;
mapDataStd[2][0xf4 - rangeMin] = 0x03c4;
mapDataStd[2][0xf5 - rangeMin] = 0x03c5;
mapDataStd[2][0xf6 - rangeMin] = 0x03c6;
mapDataStd[2][0xf7 - rangeMin] = 0x03c7;
mapDataStd[2][0xf8 - rangeMin] = 0x03c8;
mapDataStd[2][0xf9 - rangeMin] = 0x03c9;
mapDataStd[2][0xfa - rangeMin] = 0x03ca;
mapDataStd[2][0xfb - rangeMin] = 0x03cb;
mapDataStd[2][0xfc - rangeMin] = 0x03cc;
mapDataStd[2][0xfd - rangeMin] = 0x03cd;
mapDataStd[2][0xfe - rangeMin] = 0x03ce;
mapDataStd[2][0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [2] [i] = mapDataStd [2] [i];
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 5 H //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 15H //
// Kind1 488 //
// Name PC-862 Latin/Hebrew //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_15H()
{
const eSymSetMapId mapId = eSymSetMapId.map_15H;
const Int32 rangeCt = 4;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x01, 0x1f
},
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0x9f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize,
offset;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
mapDataStd [0] [0x01 - rangeMin] = 0x263a;
mapDataStd [0] [0x02 - rangeMin] = 0x263b;
mapDataStd [0] [0x03 - rangeMin] = 0x2665;
mapDataStd [0] [0x04 - rangeMin] = 0x2666;
mapDataStd [0] [0x05 - rangeMin] = 0x2663;
mapDataStd [0] [0x06 - rangeMin] = 0x2660;
mapDataStd [0] [0x07 - rangeMin] = 0x2022;
mapDataStd [0] [0x08 - rangeMin] = 0x25d8;
mapDataStd [0] [0x09 - rangeMin] = 0x25cb;
mapDataStd [0] [0x0a - rangeMin] = 0x25d9;
mapDataStd [0] [0x0b - rangeMin] = 0x2642;
mapDataStd [0] [0x0c - rangeMin] = 0x2640;
mapDataStd [0] [0x0d - rangeMin] = 0x266a;
mapDataStd [0] [0x0e - rangeMin] = 0x266b;
mapDataStd [0] [0x0f - rangeMin] = 0x263c;
mapDataStd [0] [0x10 - rangeMin] = 0x25ba;
mapDataStd [0] [0x11 - rangeMin] = 0x25c4;
mapDataStd [0] [0x12 - rangeMin] = 0x2195;
mapDataStd [0] [0x13 - rangeMin] = 0x203c;
mapDataStd [0] [0x14 - rangeMin] = 0x00b6;
mapDataStd [0] [0x15 - rangeMin] = 0x00a7;
mapDataStd [0] [0x16 - rangeMin] = 0x25ac;
mapDataStd [0] [0x17 - rangeMin] = 0x21a8;
mapDataStd [0] [0x18 - rangeMin] = 0x2191;
mapDataStd [0] [0x19 - rangeMin] = 0x2193;
mapDataStd [0] [0x1a - rangeMin] = 0x2192;
mapDataStd [0] [0x1b - rangeMin] = 0x2190;
mapDataStd [0] [0x1c - rangeMin] = 0x221f;
mapDataStd [0] [0x1d - rangeMin] = 0x2194;
mapDataStd [0] [0x1e - rangeMin] = 0x25b2;
mapDataStd [0] [0x1f - rangeMin] = 0x25bc;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[0][i] = mapDataStd[0][i];
}
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = i;
}
mapDataStd [1] [0x7f - rangeMin] = 0x2302;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[1][i] = mapDataStd[1][i];
}
mapDataPCL[1][0x5e - rangeMin] = 0x02c6;
mapDataPCL[1][0x7e - rangeMin] = 0x02dc;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData[2][0];
rangeMax = rangeData[2][1];
rangeSize = rangeSizes[2];
offset = 0x05d0 - 0x0080; // 0x05d0 - 0x0080 = 0x0550
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd[2][i - rangeMin] = (UInt16)(offset + i);
}
mapDataStd[2][0x9b - rangeMin] = 0x00a2;
mapDataStd[2][0x9c - rangeMin] = 0x00a3;
mapDataStd[2][0x9d - rangeMin] = 0x00a5;
mapDataStd[2][0x9e - rangeMin] = 0x20a7;
mapDataStd[2][0x9f - rangeMin] = 0x0192;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[2][i] = mapDataStd[2][i];
}
//----------------------------------------------------------------//
// //
// Range 3 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [3] [0];
rangeMax = rangeData [3] [1];
rangeSize = rangeSizes [3];
mapDataStd [3] [0xa0 - rangeMin] = 0x00e1;
mapDataStd [3] [0xa1 - rangeMin] = 0x00ed;
mapDataStd [3] [0xa2 - rangeMin] = 0x00f3;
mapDataStd [3] [0xa3 - rangeMin] = 0x00fa;
mapDataStd [3] [0xa4 - rangeMin] = 0x00f1;
mapDataStd [3] [0xa5 - rangeMin] = 0x00d1;
mapDataStd [3] [0xa6 - rangeMin] = 0x00aa;
mapDataStd [3] [0xa7 - rangeMin] = 0x00ba;
mapDataStd [3] [0xa8 - rangeMin] = 0x00bf;
mapDataStd [3] [0xa9 - rangeMin] = 0x2310;
mapDataStd [3] [0xaa - rangeMin] = 0x00ac;
mapDataStd [3] [0xab - rangeMin] = 0x00bd;
mapDataStd [3] [0xac - rangeMin] = 0x00bc;
mapDataStd [3] [0xad - rangeMin] = 0x00a1;
mapDataStd [3] [0xae - rangeMin] = 0x00ab;
mapDataStd [3] [0xaf - rangeMin] = 0x00bb;
mapDataStd [3] [0xb0 - rangeMin] = 0x2591;
mapDataStd [3] [0xb1 - rangeMin] = 0x2592;
mapDataStd [3] [0xb2 - rangeMin] = 0x2593;
mapDataStd [3] [0xb3 - rangeMin] = 0x2502;
mapDataStd [3] [0xb4 - rangeMin] = 0x2524;
mapDataStd [3] [0xb5 - rangeMin] = 0x2561;
mapDataStd [3] [0xb6 - rangeMin] = 0x2562;
mapDataStd [3] [0xb7 - rangeMin] = 0x2556;
mapDataStd [3] [0xb8 - rangeMin] = 0x2555;
mapDataStd [3] [0xb9 - rangeMin] = 0x2563;
mapDataStd [3] [0xba - rangeMin] = 0x2551;
mapDataStd [3] [0xbb - rangeMin] = 0x2557;
mapDataStd [3] [0xbc - rangeMin] = 0x255d;
mapDataStd [3] [0xbd - rangeMin] = 0x255c;
mapDataStd [3] [0xbe - rangeMin] = 0x255b;
mapDataStd [3] [0xbf - rangeMin] = 0x2510;
mapDataStd [3] [0xc0 - rangeMin] = 0x2514;
mapDataStd [3] [0xc1 - rangeMin] = 0x2534;
mapDataStd [3] [0xc2 - rangeMin] = 0x252c;
mapDataStd [3] [0xc3 - rangeMin] = 0x251c;
mapDataStd [3] [0xc4 - rangeMin] = 0x2500;
mapDataStd [3] [0xc5 - rangeMin] = 0x253c;
mapDataStd [3] [0xc6 - rangeMin] = 0x255e;
mapDataStd [3] [0xc7 - rangeMin] = 0x255f;
mapDataStd [3] [0xc8 - rangeMin] = 0x255a;
mapDataStd [3] [0xc9 - rangeMin] = 0x2554;
mapDataStd [3] [0xca - rangeMin] = 0x2569;
mapDataStd [3] [0xcb - rangeMin] = 0x2566;
mapDataStd [3] [0xcc - rangeMin] = 0x2560;
mapDataStd [3] [0xcd - rangeMin] = 0x2550;
mapDataStd [3] [0xce - rangeMin] = 0x256c;
mapDataStd [3] [0xcf - rangeMin] = 0x2567;
mapDataStd [3] [0xd0 - rangeMin] = 0x2568;
mapDataStd [3] [0xd1 - rangeMin] = 0x2564;
mapDataStd [3] [0xd2 - rangeMin] = 0x2565;
mapDataStd [3] [0xd3 - rangeMin] = 0x2559;
mapDataStd [3] [0xd4 - rangeMin] = 0x2558;
mapDataStd [3] [0xd5 - rangeMin] = 0x2552;
mapDataStd [3] [0xd6 - rangeMin] = 0x2553;
mapDataStd [3] [0xd7 - rangeMin] = 0x256b;
mapDataStd [3] [0xd8 - rangeMin] = 0x256a;
mapDataStd [3] [0xd9 - rangeMin] = 0x2518;
mapDataStd [3] [0xda - rangeMin] = 0x250c;
mapDataStd [3] [0xdb - rangeMin] = 0x2588;
mapDataStd [3] [0xdc - rangeMin] = 0x2584;
mapDataStd [3] [0xdd - rangeMin] = 0x258c;
mapDataStd [3] [0xde - rangeMin] = 0x2590;
mapDataStd [3] [0xdf - rangeMin] = 0x2580;
mapDataStd [3] [0xe0 - rangeMin] = 0x03b1;
mapDataStd [3] [0xe1 - rangeMin] = 0x00df;
mapDataStd [3] [0xe2 - rangeMin] = 0x0393;
mapDataStd [3] [0xe3 - rangeMin] = 0x03c0;
mapDataStd [3] [0xe4 - rangeMin] = 0x03a3;
mapDataStd [3] [0xe5 - rangeMin] = 0x03c3;
mapDataStd [3] [0xe6 - rangeMin] = 0x00b5;
mapDataStd [3] [0xe7 - rangeMin] = 0x03c4;
mapDataStd [3] [0xe8 - rangeMin] = 0x03a6;
mapDataStd [3] [0xe9 - rangeMin] = 0x0398;
mapDataStd [3] [0xea - rangeMin] = 0x03a9;
mapDataStd [3] [0xeb - rangeMin] = 0x03b4;
mapDataStd [3] [0xec - rangeMin] = 0x221e;
mapDataStd [3] [0xed - rangeMin] = 0x03c6;
mapDataStd [3] [0xee - rangeMin] = 0x03b5;
mapDataStd [3] [0xef - rangeMin] = 0x2229;
mapDataStd [3] [0xf0 - rangeMin] = 0x2261;
mapDataStd [3] [0xf1 - rangeMin] = 0x00b1;
mapDataStd [3] [0xf2 - rangeMin] = 0x2265;
mapDataStd [3] [0xf3 - rangeMin] = 0x2264;
mapDataStd [3] [0xf4 - rangeMin] = 0x2320;
mapDataStd [3] [0xf5 - rangeMin] = 0x2321;
mapDataStd [3] [0xf6 - rangeMin] = 0x00f7;
mapDataStd [3] [0xf7 - rangeMin] = 0x2248;
mapDataStd [3] [0xf8 - rangeMin] = 0x00b0;
mapDataStd [3] [0xf9 - rangeMin] = 0x2219;
mapDataStd [3] [0xfa - rangeMin] = 0x00b7;
mapDataStd [3] [0xfb - rangeMin] = 0x221a;
mapDataStd [3] [0xfc - rangeMin] = 0x207f;
mapDataStd [3] [0xfd - rangeMin] = 0x00b2;
mapDataStd [3] [0xfe - rangeMin] = 0x25aa;
mapDataStd [3] [0xff - rangeMin] = 0x00a0;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[3][i] = mapDataStd[3][i];
}
mapDataPCL [3] [0xfa - rangeMin] = 0x2219;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 0 J //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 10J //
// Kind1 330 //
// Name PS Text //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_10J()
{
const eSymSetMapId mapId = eSymSetMapId.map_10J;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL [0] [0x27 - rangeMin] = 0x2019;
mapDataPCL [0] [0x60 - rangeMin] = 0x2018;
mapDataPCL [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [1] [i - rangeMin] = 0xffff; //<not a character> //
}
mapDataPCL [1] [0xa0 - rangeMin] = 0x00a0;
mapDataPCL [1] [0xa1 - rangeMin] = 0x00a1;
mapDataPCL [1] [0xa2 - rangeMin] = 0x00a2;
mapDataPCL [1] [0xa3 - rangeMin] = 0x00a3;
mapDataPCL [1] [0xa4 - rangeMin] = 0x2215;
mapDataPCL [1] [0xa5 - rangeMin] = 0x00a5;
mapDataPCL [1] [0xa6 - rangeMin] = 0x0192;
mapDataPCL [1] [0xa7 - rangeMin] = 0x00a7;
mapDataPCL [1] [0xa8 - rangeMin] = 0x00a4;
mapDataPCL [1] [0xa9 - rangeMin] = 0x0027;
mapDataPCL [1] [0xaa - rangeMin] = 0x201c;
mapDataPCL [1] [0xab - rangeMin] = 0x00ab;
mapDataPCL [1] [0xac - rangeMin] = 0x2039;
mapDataPCL [1] [0xad - rangeMin] = 0x203a;
mapDataPCL [1] [0xae - rangeMin] = 0xf001;
mapDataPCL [1] [0xaf - rangeMin] = 0xf002;
mapDataPCL [1] [0xb1 - rangeMin] = 0x2013;
mapDataPCL [1] [0xb2 - rangeMin] = 0x2020;
mapDataPCL [1] [0xb3 - rangeMin] = 0x2021;
mapDataPCL [1] [0xb4 - rangeMin] = 0x2219;
mapDataPCL [1] [0xb6 - rangeMin] = 0x00b6;
mapDataPCL [1] [0xb7 - rangeMin] = 0x2022;
mapDataPCL [1] [0xb8 - rangeMin] = 0x201a;
mapDataPCL [1] [0xb9 - rangeMin] = 0x201e;
mapDataPCL [1] [0xba - rangeMin] = 0x201d;
mapDataPCL [1] [0xbb - rangeMin] = 0x00bb;
mapDataPCL [1] [0xbc - rangeMin] = 0x2026;
mapDataPCL [1] [0xbd - rangeMin] = 0x2030;
mapDataPCL [1] [0xbf - rangeMin] = 0x00bf;
mapDataPCL [1] [0xc1 - rangeMin] = 0x0060;
mapDataPCL [1] [0xc2 - rangeMin] = 0x00b4;
mapDataPCL [1] [0xc3 - rangeMin] = 0x02c6;
mapDataPCL [1] [0xc4 - rangeMin] = 0x02dc;
mapDataPCL [1] [0xc5 - rangeMin] = 0x02c9;
mapDataPCL [1] [0xc6 - rangeMin] = 0x02d8;
mapDataPCL [1] [0xc7 - rangeMin] = 0x02d9;
mapDataPCL [1] [0xc8 - rangeMin] = 0x00a8;
mapDataPCL [1] [0xca - rangeMin] = 0x02da;
mapDataPCL [1] [0xcb - rangeMin] = 0x00b8;
mapDataPCL [1] [0xcd - rangeMin] = 0x02dd;
mapDataPCL [1] [0xce - rangeMin] = 0x02db;
mapDataPCL [1] [0xcf - rangeMin] = 0x02c7;
mapDataPCL [1] [0xd0 - rangeMin] = 0x2014;
mapDataPCL [1] [0xe1 - rangeMin] = 0x00c6;
mapDataPCL [1] [0xe3 - rangeMin] = 0x00aa;
mapDataPCL [1] [0xe8 - rangeMin] = 0x0141;
mapDataPCL [1] [0xe9 - rangeMin] = 0x00d8;
mapDataPCL [1] [0xea - rangeMin] = 0x0152;
mapDataPCL [1] [0xeb - rangeMin] = 0x00ba;
mapDataPCL [1] [0xf1 - rangeMin] = 0x00e6;
mapDataPCL [1] [0xf5 - rangeMin] = 0x0131;
mapDataPCL [1] [0xf8 - rangeMin] = 0x0142;
mapDataPCL [1] [0xf9 - rangeMin] = 0x00f8;
mapDataPCL [1] [0xfa - rangeMin] = 0x0153;
mapDataPCL [1] [0xfb - rangeMin] = 0x00df;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 9 V //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 9V //
// Kind1 310 //
// Name Windows Latin/Arabic //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_9V()
{
const eSymSetMapId mapId = eSymSetMapId.map_9V;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x10, 0x1f
},
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL[0][i - rangeMin] = i;
}
//----------------------------------------------------------------//
mapDataPCL [0] [0x10 - rangeMin] = 0xef1a;
mapDataPCL [0] [0x11 - rangeMin] = 0xef1b;
mapDataPCL [0] [0x12 - rangeMin] = 0xef1c;
mapDataPCL [0] [0x13 - rangeMin] = 0xef1d;
mapDataPCL [0] [0x14 - rangeMin] = 0xef1e;
mapDataPCL [0] [0x15 - rangeMin] = 0xef1f;
mapDataPCL [0] [0x16 - rangeMin] = 0xef20;
mapDataPCL [0] [0x17 - rangeMin] = 0xef21;
mapDataPCL [0] [0x18 - rangeMin] = 0xef22;
mapDataPCL [0] [0x19 - rangeMin] = 0xfeca;
mapDataPCL [0] [0x1a - rangeMin] = 0xfedf;
mapDataPCL [0] [0x1b - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [0] [0x1c - rangeMin] = 0xfefc;
mapDataPCL [0] [0x1d - rangeMin] = 0xfeea;
mapDataPCL [0] [0x1e - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [0] [0x1f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [1] [i - rangeMin] = i;
}
mapDataPCL [1] [0x2a - rangeMin] = 0x066d;
mapDataPCL [1] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [1] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [1] [0x7f - rangeMin] = 0xfea7;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataPCL [2] [0x80 - rangeMin] = 0xfef8;
mapDataPCL [2] [0x81 - rangeMin] = 0xef0d;
mapDataPCL [2] [0x82 - rangeMin] = 0xef0e;
mapDataPCL [2] [0x83 - rangeMin] = 0xfd3c;
mapDataPCL [2] [0x84 - rangeMin] = 0xef0f;
mapDataPCL [2] [0x85 - rangeMin] = 0xef10;
mapDataPCL [2] [0x86 - rangeMin] = 0xef11;
mapDataPCL [2] [0x87 - rangeMin] = 0xef12;
mapDataPCL [2] [0x88 - rangeMin] = 0xef13;
mapDataPCL [2] [0x89 - rangeMin] = 0xef14;
mapDataPCL [2] [0x8a - rangeMin] = 0xef15;
mapDataPCL [2] [0x8b - rangeMin] = 0xef16;
mapDataPCL [2] [0x8c - rangeMin] = 0xef17;
mapDataPCL [2] [0x8d - rangeMin] = 0xef18;
mapDataPCL [2] [0x8e - rangeMin] = 0xfd3d;
mapDataPCL [2] [0x8f - rangeMin] = 0xef19;
mapDataPCL [2] [0x90 - rangeMin] = 0xfe9d;
mapDataPCL [2] [0x91 - rangeMin] = 0xfea1;
mapDataPCL [2] [0x92 - rangeMin] = 0xfea5;
mapDataPCL [2] [0x93 - rangeMin] = 0xfe94;
mapDataPCL [2] [0x94 - rangeMin] = 0xfe8e;
mapDataPCL [2] [0x95 - rangeMin] = 0xfef2;
mapDataPCL [2] [0x96 - rangeMin] = 0xfe8a;
mapDataPCL [2] [0x97 - rangeMin] = 0xfef0;
mapDataPCL [2] [0x98 - rangeMin] = 0xfef7;
mapDataPCL [2] [0x99 - rangeMin] = 0xfef5;
mapDataPCL [2] [0x9a - rangeMin] = 0xfef9;
mapDataPCL [2] [0x9b - rangeMin] = 0xfefb;
mapDataPCL [2] [0x9c - rangeMin] = 0xfee0;
mapDataPCL [2] [0x9d - rangeMin] = 0xfe84;
mapDataPCL [2] [0x9e - rangeMin] = 0xfe82;
mapDataPCL [2] [0x9f - rangeMin] = 0xfe88;
mapDataPCL [2] [0xa0 - rangeMin] = 0x00a0;
mapDataPCL [2] [0xa1 - rangeMin] = 0xef42;
mapDataPCL [2] [0xa2 - rangeMin] = 0xef43;
mapDataPCL [2] [0xa3 - rangeMin] = 0xef44;
mapDataPCL [2] [0xa4 - rangeMin] = 0xef45;
mapDataPCL [2] [0xa5 - rangeMin] = 0xef46;
mapDataPCL [2] [0xa6 - rangeMin] = 0xef47;
mapDataPCL [2] [0xa7 - rangeMin] = 0xef48;
mapDataPCL [2] [0xa8 - rangeMin] = 0xef49;
mapDataPCL [2] [0xa9 - rangeMin] = 0xfcf2;
mapDataPCL [2] [0xaa - rangeMin] = 0xfe9f;
mapDataPCL [2] [0xab - rangeMin] = 0xfea3;
mapDataPCL [2] [0xac - rangeMin] = 0x060c;
mapDataPCL [2] [0xad - rangeMin] = 0xfecc;
mapDataPCL [2] [0xae - rangeMin] = 0xfed0;
mapDataPCL [2] [0xaf - rangeMin] = 0xfeec;
mapDataPCL [2] [0xb0 - rangeMin] = 0x0660;
mapDataPCL [2] [0xb1 - rangeMin] = 0x0661;
mapDataPCL [2] [0xb2 - rangeMin] = 0x0662;
mapDataPCL [2] [0xb3 - rangeMin] = 0x0663;
mapDataPCL [2] [0xb4 - rangeMin] = 0x0664;
mapDataPCL [2] [0xb5 - rangeMin] = 0x0665;
mapDataPCL [2] [0xb6 - rangeMin] = 0x0666;
mapDataPCL [2] [0xb7 - rangeMin] = 0x0667;
mapDataPCL [2] [0xb8 - rangeMin] = 0x0668;
mapDataPCL [2] [0xb9 - rangeMin] = 0x0669;
mapDataPCL [2] [0xba - rangeMin] = 0xfece;
mapDataPCL [2] [0xbb - rangeMin] = 0x061b;
mapDataPCL [2] [0xbc - rangeMin] = 0xef40;
mapDataPCL [2] [0xbd - rangeMin] = 0xef41;
mapDataPCL [2] [0xbe - rangeMin] = 0xfefa;
mapDataPCL [2] [0xbf - rangeMin] = 0x061f;
mapDataPCL [2] [0xc0 - rangeMin] = 0xfef6;
mapDataPCL [2] [0xc1 - rangeMin] = 0xfe80;
mapDataPCL [2] [0xc2 - rangeMin] = 0xfe81;
mapDataPCL [2] [0xc3 - rangeMin] = 0xfe83;
mapDataPCL [2] [0xc4 - rangeMin] = 0xef28;
mapDataPCL [2] [0xc5 - rangeMin] = 0xfe87;
mapDataPCL [2] [0xc6 - rangeMin] = 0xef34;
mapDataPCL [2] [0xc7 - rangeMin] = 0xfe8d;
mapDataPCL [2] [0xc8 - rangeMin] = 0xef39;
mapDataPCL [2] [0xc9 - rangeMin] = 0xfe93;
mapDataPCL [2] [0xca - rangeMin] = 0xef3a;
mapDataPCL [2] [0xcb - rangeMin] = 0xef3b;
mapDataPCL [2] [0xcc - rangeMin] = 0xef3d;
mapDataPCL [2] [0xcd - rangeMin] = 0xef3e;
mapDataPCL [2] [0xce - rangeMin] = 0xef3f;
mapDataPCL [2] [0xcf - rangeMin] = 0xef29;
mapDataPCL [2] [0xd0 - rangeMin] = 0xef2a;
mapDataPCL [2] [0xd1 - rangeMin] = 0xef2b;
mapDataPCL [2] [0xd2 - rangeMin] = 0xef2c;
mapDataPCL [2] [0xd3 - rangeMin] = 0xef35;
mapDataPCL [2] [0xd4 - rangeMin] = 0xef36;
mapDataPCL [2] [0xd5 - rangeMin] = 0xef37;
mapDataPCL [2] [0xd6 - rangeMin] = 0xef38;
mapDataPCL [2] [0xd7 - rangeMin] = 0xef32;
mapDataPCL [2] [0xd8 - rangeMin] = 0xef33;
mapDataPCL [2] [0xd9 - rangeMin] = 0xfec9;
mapDataPCL [2] [0xda - rangeMin] = 0xfecd;
mapDataPCL [2] [0xdb - rangeMin] = 0xfe9e;
mapDataPCL [2] [0xdc - rangeMin] = 0xfea2;
mapDataPCL [2] [0xdd - rangeMin] = 0xfea6;
mapDataPCL [2] [0xde - rangeMin] = 0xfe7d;
mapDataPCL [2] [0xdf - rangeMin] = 0xfe89;
mapDataPCL [2] [0xe0 - rangeMin] = 0x0640;
mapDataPCL [2] [0xe1 - rangeMin] = 0xef3c;
mapDataPCL [2] [0xe2 - rangeMin] = 0xef27;
mapDataPCL [2] [0xe3 - rangeMin] = 0xef23;
mapDataPCL [2] [0xe4 - rangeMin] = 0xef24;
mapDataPCL [2] [0xe5 - rangeMin] = 0xef25;
mapDataPCL [2] [0xe6 - rangeMin] = 0xef26;
mapDataPCL [2] [0xe7 - rangeMin] = 0xfee9;
mapDataPCL [2] [0xe8 - rangeMin] = 0xef2d;
mapDataPCL [2] [0xe9 - rangeMin] = 0xfeef;
mapDataPCL [2] [0xea - rangeMin] = 0xfef1;
mapDataPCL [2] [0xeb - rangeMin] = 0xfe70;
mapDataPCL [2] [0xec - rangeMin] = 0xfe72;
mapDataPCL [2] [0xed - rangeMin] = 0xfe74;
mapDataPCL [2] [0xee - rangeMin] = 0xfe76;
mapDataPCL [2] [0xef - rangeMin] = 0xfe78;
mapDataPCL [2] [0xf0 - rangeMin] = 0xfe7a;
mapDataPCL [2] [0xf1 - rangeMin] = 0xfe7c;
mapDataPCL [2] [0xf2 - rangeMin] = 0xfe7e;
mapDataPCL [2] [0xf3 - rangeMin] = 0xfecb;
mapDataPCL [2] [0xf4 - rangeMin] = 0xfecf;
mapDataPCL [2] [0xf5 - rangeMin] = 0xfeeb;
mapDataPCL [2] [0xf6 - rangeMin] = 0xfc60;
mapDataPCL [2] [0xf7 - rangeMin] = 0xfc61;
mapDataPCL [2] [0xf8 - rangeMin] = 0xfc62;
mapDataPCL [2] [0xf9 - rangeMin] = 0xfcf3;
mapDataPCL [2] [0xfa - rangeMin] = 0xfcf4;
mapDataPCL [2] [0xfb - rangeMin] = 0xfe77;
mapDataPCL [2] [0xfc - rangeMin] = 0xfe79;
mapDataPCL [2] [0xfd - rangeMin] = 0xfe7b;
mapDataPCL [2] [0xfe - rangeMin] = 0xfe7f;
mapDataPCL [2] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 8 G //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 8G //
// Kind1 263 //
// Name Greek-8 //
// Note that some web pages show this symbol set as CP869, //
// but the Laserjet output is very different. //
// The output from LJ 1320n and LJ M475dn is a subset of //
// that obtained from the LJ M553x for the few fonts //
// (CG Times, Courier, Letter Gothic, Univers) which support //
// this symbol set. //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_8G()
{
const eSymSetMapId mapId = eSymSetMapId.map_8G;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xbc, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL[0][0x27 - rangeMin] = 0x1fbf;
mapDataPCL[0][0x5f - rangeMin] = 0xffff; //<not a character> //
mapDataPCL[0][0x60 - rangeMin] = 0x1ffe;
mapDataPCL[0][0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataPCL [1] [0xbc - rangeMin] = 0x03ca;
mapDataPCL [1] [0xbd - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xbe - rangeMin] = 0x03cb;
mapDataPCL [1] [0xbf - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xc0 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xc1 - rangeMin] = 0x0391;
mapDataPCL [1] [0xc2 - rangeMin] = 0x0392;
mapDataPCL [1] [0xc3 - rangeMin] = 0x0393;
mapDataPCL [1] [0xc4 - rangeMin] = 0x0394;
mapDataPCL [1] [0xc5 - rangeMin] = 0x0395;
mapDataPCL [1] [0xc6 - rangeMin] = 0x0396;
mapDataPCL [1] [0xc7 - rangeMin] = 0x0397;
mapDataPCL [1] [0xc8 - rangeMin] = 0x0398;
mapDataPCL [1] [0xc9 - rangeMin] = 0x0399;
mapDataPCL [1] [0xca - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xcb - rangeMin] = 0x039a;
mapDataPCL [1] [0xcc - rangeMin] = 0x039b;
mapDataPCL [1] [0xcd - rangeMin] = 0x039c;
mapDataPCL [1] [0xce - rangeMin] = 0x039d;
mapDataPCL [1] [0xcf - rangeMin] = 0x039e;
mapDataPCL [1] [0xd0 - rangeMin] = 0x039f;
mapDataPCL [1] [0xd1 - rangeMin] = 0x03a0;
mapDataPCL [1] [0xd2 - rangeMin] = 0x03a1;
mapDataPCL [1] [0xd3 - rangeMin] = 0x03a3;
mapDataPCL [1] [0xd4 - rangeMin] = 0x03a4;
mapDataPCL [1] [0xd5 - rangeMin] = 0x03a5;
mapDataPCL [1] [0xd6 - rangeMin] = 0x03a6;
mapDataPCL [1] [0xd7 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xd8 - rangeMin] = 0x03a7;
mapDataPCL [1] [0xd9 - rangeMin] = 0x03a8;
mapDataPCL [1] [0xda - rangeMin] = 0x03a9;
mapDataPCL [1] [0xdb - rangeMin] = 0x03ac;
mapDataPCL [1] [0xdc - rangeMin] = 0x03ae;
mapDataPCL [1] [0xdd - rangeMin] = 0x03cc;
mapDataPCL [1] [0xde - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xdf - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xe0 - rangeMin] = 0x03cd;
mapDataPCL [1] [0xe1 - rangeMin] = 0x03b1;
mapDataPCL [1] [0xe2 - rangeMin] = 0x03b2;
mapDataPCL [1] [0xe3 - rangeMin] = 0x03b3;
mapDataPCL [1] [0xe4 - rangeMin] = 0x03b4;
mapDataPCL [1] [0xe5 - rangeMin] = 0x03b5;
mapDataPCL [1] [0xe6 - rangeMin] = 0x03b6;
mapDataPCL [1] [0xe7 - rangeMin] = 0x03b7;
mapDataPCL [1] [0xe8 - rangeMin] = 0x03b8;
mapDataPCL [1] [0xe9 - rangeMin] = 0x03b9;
mapDataPCL [1] [0xea - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xeb - rangeMin] = 0x03ba;
mapDataPCL [1] [0xec - rangeMin] = 0x03bb;
mapDataPCL [1] [0xed - rangeMin] = 0x03bc;
mapDataPCL [1] [0xee - rangeMin] = 0x03bd;
mapDataPCL [1] [0xef - rangeMin] = 0x03be;
mapDataPCL [1] [0xf0 - rangeMin] = 0x03bf;
mapDataPCL [1] [0xf1 - rangeMin] = 0x03c0;
mapDataPCL [1] [0xf2 - rangeMin] = 0x03c1;
mapDataPCL [1] [0xf3 - rangeMin] = 0x03c3;
mapDataPCL [1] [0xf4 - rangeMin] = 0x03c4;
mapDataPCL [1] [0xf5 - rangeMin] = 0x03c5;
mapDataPCL [1] [0xf6 - rangeMin] = 0x03c6;
mapDataPCL [1] [0xf7 - rangeMin] = 0x03c2;
mapDataPCL [1] [0xf8 - rangeMin] = 0x03c7;
mapDataPCL [1] [0xf9 - rangeMin] = 0x03c8;
mapDataPCL [1] [0xfa - rangeMin] = 0x03c9;
mapDataPCL [1] [0xfb - rangeMin] = 0x03ad;
mapDataPCL [1] [0xfc - rangeMin] = 0x03af;
mapDataPCL [1] [0xfd - rangeMin] = 0x03ce;
mapDataPCL [1] [0xfe - rangeMin] = 0x2219;
mapDataPCL [1] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 U //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 1U //
// Kind1 53 //
// Name Legal //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_1U()
{
const eSymSetMapId mapId = eSymSetMapId.map_1U;
const Int32 rangeCt = 1;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL [0] [0x22 - rangeMin] = 0x2033;
mapDataPCL [0] [0x27 - rangeMin] = 0x2032;
mapDataPCL [0] [0x3c - rangeMin] = 0x2017;
mapDataPCL [0] [0x3e - rangeMin] = 0x00a2;
mapDataPCL [0] [0x5c - rangeMin] = 0x00ae;
mapDataPCL [0] [0x5e - rangeMin] = 0x00a9;
mapDataPCL [0] [0x60 - rangeMin] = 0x00b0;
mapDataPCL [0] [0x7b - rangeMin] = 0x00a7;
mapDataPCL [0] [0x7c - rangeMin] = 0x00b6;
mapDataPCL [0] [0x7d - rangeMin] = 0x2020;
mapDataPCL [0] [0x7e - rangeMin] = 0x2122;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 9 R //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 9R //
// Kind1 306 //
// Name Windows Latin/Cyrillic //
// Code Page 1251 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_9R()
{
const eSymSetMapId mapId = eSymSetMapId.map_9R;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0xbf
},
new UInt16 [2] {
0xc0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize,
offset;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL [0] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [0] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataStd [1] [0x80 - rangeMin] = 0x0402;
mapDataStd [1] [0x81 - rangeMin] = 0x0403;
mapDataStd [1] [0x82 - rangeMin] = 0x201a;
mapDataStd [1] [0x83 - rangeMin] = 0x0453;
mapDataStd [1] [0x84 - rangeMin] = 0x201e;
mapDataStd [1] [0x85 - rangeMin] = 0x2026;
mapDataStd [1] [0x86 - rangeMin] = 0x2020;
mapDataStd [1] [0x87 - rangeMin] = 0x2021;
mapDataStd [1] [0x88 - rangeMin] = 0x20ac;
mapDataStd [1] [0x89 - rangeMin] = 0x2030;
mapDataStd [1] [0x8a - rangeMin] = 0x0409;
mapDataStd [1] [0x8b - rangeMin] = 0x2039;
mapDataStd [1] [0x8c - rangeMin] = 0x040a;
mapDataStd [1] [0x8d - rangeMin] = 0x040c;
mapDataStd [1] [0x8e - rangeMin] = 0x040b;
mapDataStd [1] [0x8f - rangeMin] = 0x040f;
mapDataStd [1] [0x90 - rangeMin] = 0x0452;
mapDataStd [1] [0x91 - rangeMin] = 0x2018;
mapDataStd [1] [0x92 - rangeMin] = 0x2019;
mapDataStd [1] [0x93 - rangeMin] = 0x201c;
mapDataStd [1] [0x94 - rangeMin] = 0x201d;
mapDataStd [1] [0x95 - rangeMin] = 0x2022;
mapDataStd [1] [0x96 - rangeMin] = 0x2013;
mapDataStd [1] [0x97 - rangeMin] = 0x2014;
mapDataStd [1] [0x98 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x99 - rangeMin] = 0x2122;
mapDataStd [1] [0x9a - rangeMin] = 0x0459;
mapDataStd [1] [0x9b - rangeMin] = 0x203a;
mapDataStd [1] [0x9c - rangeMin] = 0x045a;
mapDataStd [1] [0x9d - rangeMin] = 0x045c;
mapDataStd [1] [0x9e - rangeMin] = 0x045b;
mapDataStd [1] [0x9f - rangeMin] = 0x045f;
mapDataStd [1] [0xa0 - rangeMin] = 0x00a0;
mapDataStd [1] [0xa1 - rangeMin] = 0x040e;
mapDataStd [1] [0xa2 - rangeMin] = 0x045e;
mapDataStd [1] [0xa3 - rangeMin] = 0x0408;
mapDataStd [1] [0xa4 - rangeMin] = 0x00a4;
mapDataStd [1] [0xa5 - rangeMin] = 0x0490;
mapDataStd [1] [0xa6 - rangeMin] = 0x00a6;
mapDataStd [1] [0xa7 - rangeMin] = 0x00a7;
mapDataStd [1] [0xa8 - rangeMin] = 0x0401;
mapDataStd [1] [0xa9 - rangeMin] = 0x00a9;
mapDataStd [1] [0xaa - rangeMin] = 0x0404;
mapDataStd [1] [0xab - rangeMin] = 0x00ab;
mapDataStd [1] [0xac - rangeMin] = 0x00ac;
mapDataStd [1] [0xad - rangeMin] = 0x00ad;
mapDataStd [1] [0xae - rangeMin] = 0x00ae;
mapDataStd [1] [0xaf - rangeMin] = 0x0407;
mapDataStd [1] [0xb0 - rangeMin] = 0x00b0;
mapDataStd [1] [0xb1 - rangeMin] = 0x00b1;
mapDataStd [1] [0xb2 - rangeMin] = 0x0406;
mapDataStd [1] [0xb3 - rangeMin] = 0x0456;
mapDataStd [1] [0xb4 - rangeMin] = 0x0491;
mapDataStd [1] [0xb5 - rangeMin] = 0x00b5;
mapDataStd [1] [0xb6 - rangeMin] = 0x00b6;
mapDataStd [1] [0xb7 - rangeMin] = 0x00b7;
mapDataStd [1] [0xb8 - rangeMin] = 0x0451;
mapDataStd [1] [0xb9 - rangeMin] = 0x2116;
mapDataStd [1] [0xba - rangeMin] = 0x0454;
mapDataStd [1] [0xbb - rangeMin] = 0x00bb;
mapDataStd [1] [0xbc - rangeMin] = 0x0458;
mapDataStd [1] [0xbd - rangeMin] = 0x0405;
mapDataStd [1] [0xbe - rangeMin] = 0x0455;
mapDataStd [1] [0xbf - rangeMin] = 0x0457;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
offset = 0x0410 - 0x00c0; // 0x0410 - 0x00c0 = 0x0350
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd[2][i - rangeMin] = (UInt16)(offset + i);
}
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [2] [i] = mapDataStd [2] [i];
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 8 U //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 8U //
// Kind1 277 //
// Name Roman-8 //
// HP default symbol set //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_8U()
{
const eSymSetMapId mapId = eSymSetMapId.map_8U;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL [0] [0x27 - rangeMin] = 0x2019;
mapDataPCL [0] [0x60 - rangeMin] = 0x2018;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataPCL [1] [0xa0 - rangeMin] = 0x00a0;
mapDataPCL [1] [0xa1 - rangeMin] = 0x00c0;
mapDataPCL [1] [0xa2 - rangeMin] = 0x00c2;
mapDataPCL [1] [0xa3 - rangeMin] = 0x00c8;
mapDataPCL [1] [0xa4 - rangeMin] = 0x00ca;
mapDataPCL [1] [0xa5 - rangeMin] = 0x00cb;
mapDataPCL [1] [0xa6 - rangeMin] = 0x00ce;
mapDataPCL [1] [0xa7 - rangeMin] = 0x00cf;
mapDataPCL [1] [0xa8 - rangeMin] = 0x00b4;
mapDataPCL [1] [0xa9 - rangeMin] = 0x0060;
mapDataPCL [1] [0xaa - rangeMin] = 0x02c6;
mapDataPCL [1] [0xab - rangeMin] = 0x00a8;
mapDataPCL [1] [0xac - rangeMin] = 0x02dc;
mapDataPCL [1] [0xad - rangeMin] = 0x00d9;
mapDataPCL [1] [0xae - rangeMin] = 0x00db;
mapDataPCL [1] [0xaf - rangeMin] = 0x00a3;
mapDataPCL [1] [0xb0 - rangeMin] = 0x00af;
mapDataPCL [1] [0xb1 - rangeMin] = 0x00dd;
mapDataPCL [1] [0xb2 - rangeMin] = 0x00fd;
mapDataPCL [1] [0xb3 - rangeMin] = 0x00b0;
mapDataPCL [1] [0xb4 - rangeMin] = 0x00c7;
mapDataPCL [1] [0xb5 - rangeMin] = 0x00e7;
mapDataPCL [1] [0xb6 - rangeMin] = 0x00d1;
mapDataPCL [1] [0xb7 - rangeMin] = 0x00f1;
mapDataPCL [1] [0xb8 - rangeMin] = 0x00a1;
mapDataPCL [1] [0xb9 - rangeMin] = 0x00bf;
mapDataPCL [1] [0xba - rangeMin] = 0x00a4;
mapDataPCL [1] [0xbb - rangeMin] = 0x00a3;
mapDataPCL [1] [0xbc - rangeMin] = 0x00a5;
mapDataPCL [1] [0xbd - rangeMin] = 0x00a7;
mapDataPCL [1] [0xbe - rangeMin] = 0x0192;
mapDataPCL [1] [0xbf - rangeMin] = 0x00a2;
mapDataPCL [1] [0xc0 - rangeMin] = 0x00e2;
mapDataPCL [1] [0xc1 - rangeMin] = 0x00ea;
mapDataPCL [1] [0xc2 - rangeMin] = 0x00f4;
mapDataPCL [1] [0xc3 - rangeMin] = 0x00fb;
mapDataPCL [1] [0xc4 - rangeMin] = 0x00e1;
mapDataPCL [1] [0xc5 - rangeMin] = 0x00e9;
mapDataPCL [1] [0xc6 - rangeMin] = 0x00f3;
mapDataPCL [1] [0xc7 - rangeMin] = 0x00fa;
mapDataPCL [1] [0xc8 - rangeMin] = 0x00e0;
mapDataPCL [1] [0xc9 - rangeMin] = 0x00e8;
mapDataPCL [1] [0xca - rangeMin] = 0x00f2;
mapDataPCL [1] [0xcb - rangeMin] = 0x00f9;
mapDataPCL [1] [0xcc - rangeMin] = 0x00e4;
mapDataPCL [1] [0xcd - rangeMin] = 0x00eb;
mapDataPCL [1] [0xce - rangeMin] = 0x00f6;
mapDataPCL [1] [0xcf - rangeMin] = 0x00fc;
mapDataPCL [1] [0xd0 - rangeMin] = 0x00c5;
mapDataPCL [1] [0xd1 - rangeMin] = 0x00ee;
mapDataPCL [1] [0xd2 - rangeMin] = 0x00d8;
mapDataPCL [1] [0xd3 - rangeMin] = 0x00c6;
mapDataPCL [1] [0xd4 - rangeMin] = 0x00e5;
mapDataPCL [1] [0xd5 - rangeMin] = 0x00ed;
mapDataPCL [1] [0xd6 - rangeMin] = 0x00f8;
mapDataPCL [1] [0xd7 - rangeMin] = 0x00e6;
mapDataPCL [1] [0xd8 - rangeMin] = 0x00c4;
mapDataPCL [1] [0xd9 - rangeMin] = 0x00ec;
mapDataPCL [1] [0xda - rangeMin] = 0x00d6;
mapDataPCL [1] [0xdb - rangeMin] = 0x00dc;
mapDataPCL [1] [0xdc - rangeMin] = 0x00c9;
mapDataPCL [1] [0xdd - rangeMin] = 0x00ef;
mapDataPCL [1] [0xde - rangeMin] = 0x00df;
mapDataPCL [1] [0xdf - rangeMin] = 0x00d4;
mapDataPCL [1] [0xe0 - rangeMin] = 0x00c1;
mapDataPCL [1] [0xe1 - rangeMin] = 0x00c3;
mapDataPCL [1] [0xe2 - rangeMin] = 0x00e3;
mapDataPCL [1] [0xe3 - rangeMin] = 0x00d0;
mapDataPCL [1] [0xe4 - rangeMin] = 0x00f0;
mapDataPCL [1] [0xe5 - rangeMin] = 0x00cd;
mapDataPCL [1] [0xe6 - rangeMin] = 0x00cc;
mapDataPCL [1] [0xe7 - rangeMin] = 0x00d3;
mapDataPCL [1] [0xe8 - rangeMin] = 0x00d2;
mapDataPCL [1] [0xe9 - rangeMin] = 0x00d5;
mapDataPCL [1] [0xea - rangeMin] = 0x00f5;
mapDataPCL [1] [0xeb - rangeMin] = 0x0160;
mapDataPCL [1] [0xec - rangeMin] = 0x0161;
mapDataPCL [1] [0xed - rangeMin] = 0x00da;
mapDataPCL [1] [0xee - rangeMin] = 0x0178;
mapDataPCL [1] [0xef - rangeMin] = 0x00ff;
mapDataPCL [1] [0xf0 - rangeMin] = 0x00de;
mapDataPCL [1] [0xf1 - rangeMin] = 0x00fe;
mapDataPCL [1] [0xf2 - rangeMin] = 0x00b7;
mapDataPCL [1] [0xf3 - rangeMin] = 0x03bc;
mapDataPCL [1] [0xf4 - rangeMin] = 0x00b6;
mapDataPCL [1] [0xf5 - rangeMin] = 0x00be;
mapDataPCL [1] [0xf6 - rangeMin] = 0x2212;
mapDataPCL [1] [0xf7 - rangeMin] = 0x00bc;
mapDataPCL [1] [0xf8 - rangeMin] = 0x00bd;
mapDataPCL [1] [0xf9 - rangeMin] = 0x00aa;
mapDataPCL [1] [0xfa - rangeMin] = 0x00ba;
mapDataPCL [1] [0xfb - rangeMin] = 0x00ab;
mapDataPCL [1] [0xfc - rangeMin] = 0x25a0;
mapDataPCL [1] [0xfd - rangeMin] = 0x00bb;
mapDataPCL [1] [0xfe - rangeMin] = 0x00b1;
mapDataPCL [1] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 9 J //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 9J //
// Kind1 298 //
// Name PC-1004 Windows Extended //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_9J()
{
const eSymSetMapId mapId = eSymSetMapId.map_9J;
const Int32 rangeCt = 4;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x00, 0x1f
},
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0x9f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData[0][0];
rangeMax = rangeData[0][1];
rangeSize = rangeSizes[0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL[0] [i - rangeMin] = 0xffff; //<not a character> //
}
mapDataPCL [0] [0x04 - rangeMin] = 0x02c9;
mapDataPCL [0] [0x05 - rangeMin] = 0x02d8;
mapDataPCL [0] [0x06 - rangeMin] = 0x02d9;
mapDataPCL [0] [0x08 - rangeMin] = 0x02da;
mapDataPCL [0] [0x0a - rangeMin] = 0x02dd;
mapDataPCL [0] [0x0b - rangeMin] = 0x02db;
mapDataPCL [0] [0x0c - rangeMin] = 0x02c7;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [1] [i - rangeMin] = i;
}
mapDataPCL [1] [0x7f - rangeMin] = 0x2302;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataPCL [2] [0x80 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x81 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x82 - rangeMin] = 0x201a;
mapDataPCL [2] [0x83 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x84 - rangeMin] = 0x201e;
mapDataPCL [2] [0x85 - rangeMin] = 0x2026;
mapDataPCL [2] [0x86 - rangeMin] = 0x2020;
mapDataPCL [2] [0x87 - rangeMin] = 0x2021;
mapDataPCL [2] [0x88 - rangeMin] = 0x02c6;
mapDataPCL [2] [0x89 - rangeMin] = 0x2030;
mapDataPCL [2] [0x8a - rangeMin] = 0x0160;
mapDataPCL [2] [0x8b - rangeMin] = 0x2039;
mapDataPCL [2] [0x8c - rangeMin] = 0x0152;
mapDataPCL [2] [0x8d - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x8e - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x8f - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x90 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x91 - rangeMin] = 0x2018;
mapDataPCL [2] [0x92 - rangeMin] = 0x2019;
mapDataPCL [2] [0x93 - rangeMin] = 0x201c;
mapDataPCL [2] [0x94 - rangeMin] = 0x201d;
mapDataPCL [2] [0x95 - rangeMin] = 0x2022;
mapDataPCL [2] [0x96 - rangeMin] = 0x2013;
mapDataPCL [2] [0x97 - rangeMin] = 0x2014;
mapDataPCL [2] [0x98 - rangeMin] = 0x02dc;
mapDataPCL [2] [0x99 - rangeMin] = 0x2122;
mapDataPCL [2] [0x9a - rangeMin] = 0x0161;
mapDataPCL [2] [0x9b - rangeMin] = 0x203a;
mapDataPCL [2] [0x9c - rangeMin] = 0x0153;
mapDataPCL [2] [0x9d - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x9e - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0x9f - rangeMin] = 0x0178;
//----------------------------------------------------------------//
// //
// Range 3 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [3] [0];
rangeMax = rangeData [3] [1];
rangeSize = rangeSizes [3];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [3] [i - rangeMin] = i;
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 3 R //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 3R //
// Kind1 114 //
// Name PC866 Cyrillic //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_3R()
{
const eSymSetMapId mapId = eSymSetMapId.map_3R;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x01, 0x1f
},
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
mapDataStd [0] [0x01 - rangeMin] = 0x263a;
mapDataStd [0] [0x02 - rangeMin] = 0x263b;
mapDataStd [0] [0x03 - rangeMin] = 0x2665;
mapDataStd [0] [0x04 - rangeMin] = 0x2666;
mapDataStd [0] [0x05 - rangeMin] = 0x2663;
mapDataStd [0] [0x06 - rangeMin] = 0x2660;
mapDataStd [0] [0x07 - rangeMin] = 0x2022;
mapDataStd [0] [0x08 - rangeMin] = 0x25d8;
mapDataStd [0] [0x09 - rangeMin] = 0x25cb;
mapDataStd [0] [0x0a - rangeMin] = 0x25d9;
mapDataStd [0] [0x0b - rangeMin] = 0x2642;
mapDataStd [0] [0x0c - rangeMin] = 0x2640;
mapDataStd [0] [0x0d - rangeMin] = 0x266a;
mapDataStd [0] [0x0e - rangeMin] = 0x266b;
mapDataStd [0] [0x0f - rangeMin] = 0x263c;
mapDataStd [0] [0x10 - rangeMin] = 0x25ba;
mapDataStd [0] [0x11 - rangeMin] = 0x25c4;
mapDataStd [0] [0x12 - rangeMin] = 0x2195;
mapDataStd [0] [0x13 - rangeMin] = 0x203c;
mapDataStd [0] [0x14 - rangeMin] = 0x00b6;
mapDataStd [0] [0x15 - rangeMin] = 0x00a7;
mapDataStd [0] [0x16 - rangeMin] = 0x25ac;
mapDataStd [0] [0x17 - rangeMin] = 0x21a8;
mapDataStd [0] [0x18 - rangeMin] = 0x2191;
mapDataStd [0] [0x19 - rangeMin] = 0x2193;
mapDataStd [0] [0x1a - rangeMin] = 0x2192;
mapDataStd [0] [0x1b - rangeMin] = 0x2190;
mapDataStd [0] [0x1c - rangeMin] = 0x221f;
mapDataStd [0] [0x1d - rangeMin] = 0x2194;
mapDataStd [0] [0x1e - rangeMin] = 0x25b2;
mapDataStd [0] [0x1f - rangeMin] = 0x25bc;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = i;
}
mapDataStd [1] [0x7f - rangeMin] = 0x2302;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
mapDataPCL [1] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [1] [0x7e - rangeMin] = 0x02dc;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataStd [2] [0x80 - rangeMin] = 0x0410;
mapDataStd [2] [0x81 - rangeMin] = 0x0411;
mapDataStd [2] [0x82 - rangeMin] = 0x0412;
mapDataStd [2] [0x83 - rangeMin] = 0x0413;
mapDataStd [2] [0x84 - rangeMin] = 0x0414;
mapDataStd [2] [0x85 - rangeMin] = 0x0415;
mapDataStd [2] [0x86 - rangeMin] = 0x0416;
mapDataStd [2] [0x87 - rangeMin] = 0x0417;
mapDataStd [2] [0x88 - rangeMin] = 0x0418;
mapDataStd [2] [0x89 - rangeMin] = 0x0419;
mapDataStd [2] [0x8a - rangeMin] = 0x041a;
mapDataStd [2] [0x8b - rangeMin] = 0x041b;
mapDataStd [2] [0x8c - rangeMin] = 0x041c;
mapDataStd [2] [0x8d - rangeMin] = 0x041d;
mapDataStd [2] [0x8e - rangeMin] = 0x041e;
mapDataStd [2] [0x8f - rangeMin] = 0x041f;
mapDataStd [2] [0x90 - rangeMin] = 0x0420;
mapDataStd [2] [0x91 - rangeMin] = 0x0421;
mapDataStd [2] [0x92 - rangeMin] = 0x0422;
mapDataStd [2] [0x93 - rangeMin] = 0x0423;
mapDataStd [2] [0x94 - rangeMin] = 0x0424;
mapDataStd [2] [0x95 - rangeMin] = 0x0425;
mapDataStd [2] [0x96 - rangeMin] = 0x0426;
mapDataStd [2] [0x97 - rangeMin] = 0x0427;
mapDataStd [2] [0x98 - rangeMin] = 0x0428;
mapDataStd [2] [0x99 - rangeMin] = 0x0429;
mapDataStd [2] [0x9a - rangeMin] = 0x042a;
mapDataStd [2] [0x9b - rangeMin] = 0x042b;
mapDataStd [2] [0x9c - rangeMin] = 0x042c;
mapDataStd [2] [0x9d - rangeMin] = 0x042d;
mapDataStd [2] [0x9e - rangeMin] = 0x042e;
mapDataStd [2] [0x9f - rangeMin] = 0x042f;
mapDataStd [2] [0xa0 - rangeMin] = 0x0430;
mapDataStd [2] [0xa1 - rangeMin] = 0x0431;
mapDataStd [2] [0xa2 - rangeMin] = 0x0432;
mapDataStd [2] [0xa3 - rangeMin] = 0x0433;
mapDataStd [2] [0xa4 - rangeMin] = 0x0434;
mapDataStd [2] [0xa5 - rangeMin] = 0x0435;
mapDataStd [2] [0xa6 - rangeMin] = 0x0436;
mapDataStd [2] [0xa7 - rangeMin] = 0x0437;
mapDataStd [2] [0xa8 - rangeMin] = 0x0438;
mapDataStd [2] [0xa9 - rangeMin] = 0x0439;
mapDataStd [2] [0xaa - rangeMin] = 0x043a;
mapDataStd [2] [0xab - rangeMin] = 0x043b;
mapDataStd [2] [0xac - rangeMin] = 0x043c;
mapDataStd [2] [0xad - rangeMin] = 0x043d;
mapDataStd [2] [0xae - rangeMin] = 0x043e;
mapDataStd [2] [0xaf - rangeMin] = 0x043f;
mapDataStd [2] [0xb0 - rangeMin] = 0x2591;
mapDataStd [2] [0xb1 - rangeMin] = 0x2592;
mapDataStd [2] [0xb2 - rangeMin] = 0x2593;
mapDataStd [2] [0xb3 - rangeMin] = 0x2502;
mapDataStd [2] [0xb4 - rangeMin] = 0x2524;
mapDataStd [2] [0xb5 - rangeMin] = 0x2561;
mapDataStd [2] [0xb6 - rangeMin] = 0x2562;
mapDataStd [2] [0xb7 - rangeMin] = 0x2556;
mapDataStd [2] [0xb8 - rangeMin] = 0x2555;
mapDataStd [2] [0xb9 - rangeMin] = 0x2563;
mapDataStd [2] [0xba - rangeMin] = 0x2551;
mapDataStd [2] [0xbb - rangeMin] = 0x2557;
mapDataStd [2] [0xbc - rangeMin] = 0x255d;
mapDataStd [2] [0xbd - rangeMin] = 0x255c;
mapDataStd [2] [0xbe - rangeMin] = 0x255b;
mapDataStd [2] [0xbf - rangeMin] = 0x2510;
mapDataStd [2] [0xc0 - rangeMin] = 0x2514;
mapDataStd [2] [0xc1 - rangeMin] = 0x2534;
mapDataStd [2] [0xc2 - rangeMin] = 0x252c;
mapDataStd [2] [0xc3 - rangeMin] = 0x251c;
mapDataStd [2] [0xc4 - rangeMin] = 0x2500;
mapDataStd [2] [0xc5 - rangeMin] = 0x253c;
mapDataStd [2] [0xc6 - rangeMin] = 0x255e;
mapDataStd [2] [0xc7 - rangeMin] = 0x255f;
mapDataStd [2] [0xc8 - rangeMin] = 0x255a;
mapDataStd [2] [0xc9 - rangeMin] = 0x2554;
mapDataStd [2] [0xca - rangeMin] = 0x2569;
mapDataStd [2] [0xcb - rangeMin] = 0x2566;
mapDataStd [2] [0xcc - rangeMin] = 0x2560;
mapDataStd [2] [0xcd - rangeMin] = 0x2550;
mapDataStd [2] [0xce - rangeMin] = 0x256c;
mapDataStd [2] [0xcf - rangeMin] = 0x2567;
mapDataStd [2] [0xd0 - rangeMin] = 0x2568;
mapDataStd [2] [0xd1 - rangeMin] = 0x2564;
mapDataStd [2] [0xd2 - rangeMin] = 0x2565;
mapDataStd [2] [0xd3 - rangeMin] = 0x2559;
mapDataStd [2] [0xd4 - rangeMin] = 0x2558;
mapDataStd [2] [0xd5 - rangeMin] = 0x2552;
mapDataStd [2] [0xd6 - rangeMin] = 0x2553;
mapDataStd [2] [0xd7 - rangeMin] = 0x256b;
mapDataStd [2] [0xd8 - rangeMin] = 0x256a;
mapDataStd [2] [0xd9 - rangeMin] = 0x2518;
mapDataStd [2] [0xda - rangeMin] = 0x250c;
mapDataStd [2] [0xdb - rangeMin] = 0x2588;
mapDataStd [2] [0xdc - rangeMin] = 0x2584;
mapDataStd [2] [0xdd - rangeMin] = 0x258c;
mapDataStd [2] [0xde - rangeMin] = 0x2590;
mapDataStd [2] [0xdf - rangeMin] = 0x2580;
mapDataStd [2] [0xe0 - rangeMin] = 0x0440;
mapDataStd [2] [0xe1 - rangeMin] = 0x0441;
mapDataStd [2] [0xe2 - rangeMin] = 0x0442;
mapDataStd [2] [0xe3 - rangeMin] = 0x0443;
mapDataStd [2] [0xe4 - rangeMin] = 0x0444;
mapDataStd [2] [0xe5 - rangeMin] = 0x0445;
mapDataStd [2] [0xe6 - rangeMin] = 0x0446;
mapDataStd [2] [0xe7 - rangeMin] = 0x0447;
mapDataStd [2] [0xe8 - rangeMin] = 0x0448;
mapDataStd [2] [0xe9 - rangeMin] = 0x0449;
mapDataStd [2] [0xea - rangeMin] = 0x044a;
mapDataStd [2] [0xeb - rangeMin] = 0x044b;
mapDataStd [2] [0xec - rangeMin] = 0x044c;
mapDataStd [2] [0xed - rangeMin] = 0x044d;
mapDataStd [2] [0xee - rangeMin] = 0x044e;
mapDataStd [2] [0xef - rangeMin] = 0x044f;
mapDataStd [2] [0xf0 - rangeMin] = 0x0401;
mapDataStd [2] [0xf1 - rangeMin] = 0x0451;
mapDataStd [2] [0xf2 - rangeMin] = 0x0404;
mapDataStd [2] [0xf3 - rangeMin] = 0x0454;
mapDataStd [2] [0xf4 - rangeMin] = 0x0407;
mapDataStd [2] [0xf5 - rangeMin] = 0x0457;
mapDataStd [2] [0xf6 - rangeMin] = 0x040e;
mapDataStd [2] [0xf7 - rangeMin] = 0x045e;
mapDataStd [2] [0xf8 - rangeMin] = 0x00b0;
mapDataStd [2] [0xf9 - rangeMin] = 0x2219;
mapDataStd [2] [0xfa - rangeMin] = 0x00b7;
mapDataStd [2] [0xfb - rangeMin] = 0x221a;
mapDataStd [2] [0xfc - rangeMin] = 0x2116;
mapDataStd [2] [0xfd - rangeMin] = 0x00a4;
mapDataStd [2] [0xfe - rangeMin] = 0x25a0;
mapDataStd [2] [0xff - rangeMin] = 0x00a0;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [2] [i] = mapDataStd [2] [i];
}
mapDataPCL [2] [0xfe - rangeMin] = 0x25aa;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 7 H //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 7H //
// Kind1 232 //
// Name ISO 8859-8 Latin/Hebrew //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_7H()
{
const eSymSetMapId mapId = eSymSetMapId.map_7H;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xbe
},
new UInt16 [2] {
0xdf, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize,
offset;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL [0] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [0] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = i;
}
mapDataStd [1] [0xa1 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0xaa - rangeMin] = 0x00d7;
mapDataStd [1] [0xb7 - rangeMin] = 0x2219;
mapDataStd [1] [0xba - rangeMin] = 0x00f7;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
offset = 0x05d0 - 0x00e0; // 0x05d0 - 0x00e0 = 0x04f0
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [2] [i - rangeMin] = (UInt16)(offset + i);
}
mapDataStd [2] [0xdf - rangeMin] = 0x2017;
mapDataStd [2] [0xfb - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xfc - rangeMin] = 0xffff; //<not a character> //
mapDataStd [2] [0xfd - rangeMin] = 0x200e;
mapDataStd [2] [0xfe - rangeMin] = 0x200f;
mapDataStd [2] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [2] [i] = mapDataStd [2] [i];
}
mapDataPCL [2] [0xfd - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [2] [0xfe - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 4 N //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 4N //
// Kind1 142 //
// Name ISO 8859-4 Latin 4 //
// North European //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_4N()
{
const eSymSetMapId mapId = eSymSetMapId.map_4N;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = i;
}
mapDataStd[1][0xa0 - rangeMin] = 0x00a0;
mapDataStd[1][0xa1 - rangeMin] = 0x0104;
mapDataStd[1][0xa2 - rangeMin] = 0x0138;
mapDataStd[1][0xa3 - rangeMin] = 0x0156;
mapDataStd[1][0xa4 - rangeMin] = 0x00a4;
mapDataStd[1][0xa5 - rangeMin] = 0x0128;
mapDataStd[1][0xa6 - rangeMin] = 0x013b;
mapDataStd[1][0xa7 - rangeMin] = 0x00a7;
mapDataStd[1][0xa8 - rangeMin] = 0x00a8;
mapDataStd[1][0xa9 - rangeMin] = 0x0160;
mapDataStd[1][0xaa - rangeMin] = 0x0112;
mapDataStd[1][0xab - rangeMin] = 0x0122;
mapDataStd[1][0xac - rangeMin] = 0x0166;
mapDataStd[1][0xad - rangeMin] = 0x00ad;
mapDataStd[1][0xae - rangeMin] = 0x017d;
mapDataStd[1][0xaf - rangeMin] = 0x00af;
mapDataStd[1][0xb0 - rangeMin] = 0x00b0;
mapDataStd[1][0xb1 - rangeMin] = 0x0105;
mapDataStd[1][0xb2 - rangeMin] = 0x02db;
mapDataStd[1][0xb3 - rangeMin] = 0x0157;
mapDataStd[1][0xb4 - rangeMin] = 0x00b4;
mapDataStd[1][0xb5 - rangeMin] = 0x0129;
mapDataStd[1][0xb6 - rangeMin] = 0x013c;
mapDataStd[1][0xb7 - rangeMin] = 0x02c7;
mapDataStd[1][0xb8 - rangeMin] = 0x00b8;
mapDataStd[1][0xb9 - rangeMin] = 0x0161;
mapDataStd[1][0xba - rangeMin] = 0x0113;
mapDataStd[1][0xbb - rangeMin] = 0x0123;
mapDataStd[1][0xbc - rangeMin] = 0x0167;
mapDataStd[1][0xbd - rangeMin] = 0x014a;
mapDataStd[1][0xbe - rangeMin] = 0x017e;
mapDataStd[1][0xbf - rangeMin] = 0x014b;
mapDataStd[1][0xc0 - rangeMin] = 0x0100;
mapDataStd[1][0xc1 - rangeMin] = 0x00c1;
mapDataStd[1][0xc2 - rangeMin] = 0x00c2;
mapDataStd[1][0xc3 - rangeMin] = 0x00c3;
mapDataStd[1][0xc4 - rangeMin] = 0x00c4;
mapDataStd[1][0xc5 - rangeMin] = 0x00c5;
mapDataStd[1][0xc6 - rangeMin] = 0x00c6;
mapDataStd[1][0xc7 - rangeMin] = 0x012e;
mapDataStd[1][0xc8 - rangeMin] = 0x010c;
mapDataStd[1][0xc9 - rangeMin] = 0x00c9;
mapDataStd[1][0xca - rangeMin] = 0x0118;
mapDataStd[1][0xcb - rangeMin] = 0x00cb;
mapDataStd[1][0xcc - rangeMin] = 0x0116;
mapDataStd[1][0xcd - rangeMin] = 0x00cd;
mapDataStd[1][0xce - rangeMin] = 0x00ce;
mapDataStd[1][0xcf - rangeMin] = 0x012a;
mapDataStd[1][0xd0 - rangeMin] = 0x0110;
mapDataStd[1][0xd1 - rangeMin] = 0x0145;
mapDataStd[1][0xd2 - rangeMin] = 0x014c;
mapDataStd[1][0xd3 - rangeMin] = 0x0136;
mapDataStd[1][0xd4 - rangeMin] = 0x00d4;
mapDataStd[1][0xd5 - rangeMin] = 0x00d5;
mapDataStd[1][0xd6 - rangeMin] = 0x00f6;
mapDataStd[1][0xd7 - rangeMin] = 0x00d7;
mapDataStd[1][0xd8 - rangeMin] = 0x00d8;
mapDataStd[1][0xd9 - rangeMin] = 0x0172;
mapDataStd[1][0xda - rangeMin] = 0x00da;
mapDataStd[1][0xdb - rangeMin] = 0x00db;
mapDataStd[1][0xdc - rangeMin] = 0x00dc;
mapDataStd[1][0xdd - rangeMin] = 0x0168;
mapDataStd[1][0xde - rangeMin] = 0x016a;
mapDataStd[1][0xdf - rangeMin] = 0x00df;
mapDataStd[1][0xe0 - rangeMin] = 0x0101;
mapDataStd[1][0xe1 - rangeMin] = 0x00e1;
mapDataStd[1][0xe2 - rangeMin] = 0x00e2;
mapDataStd[1][0xe3 - rangeMin] = 0x00e3;
mapDataStd[1][0xe4 - rangeMin] = 0x00e4;
mapDataStd[1][0xe5 - rangeMin] = 0x00e5;
mapDataStd[1][0xe6 - rangeMin] = 0x00e6;
mapDataStd[1][0xe7 - rangeMin] = 0x012f;
mapDataStd[1][0xe8 - rangeMin] = 0x010d;
mapDataStd[1][0xe9 - rangeMin] = 0x00e9;
mapDataStd[1][0xea - rangeMin] = 0x0119;
mapDataStd[1][0xeb - rangeMin] = 0x00eb;
mapDataStd[1][0xec - rangeMin] = 0x0117;
mapDataStd[1][0xed - rangeMin] = 0x00ed;
mapDataStd[1][0xee - rangeMin] = 0x00ee;
mapDataStd[1][0xef - rangeMin] = 0x012b;
mapDataStd[1][0xf0 - rangeMin] = 0x0111;
mapDataStd[1][0xf1 - rangeMin] = 0x0146;
mapDataStd[1][0xf2 - rangeMin] = 0x014d;
mapDataStd[1][0xf3 - rangeMin] = 0x0137;
mapDataStd[1][0xf4 - rangeMin] = 0x00f4;
mapDataStd[1][0xf5 - rangeMin] = 0x00f5;
mapDataStd[1][0xf6 - rangeMin] = 0x00f6;
mapDataStd[1][0xf7 - rangeMin] = 0x00f7;
mapDataStd[1][0xf8 - rangeMin] = 0x00f8;
mapDataStd[1][0xf9 - rangeMin] = 0x0173;
mapDataStd[1][0xfa - rangeMin] = 0x00fa;
mapDataStd[1][0xfb - rangeMin] = 0x00fb;
mapDataStd[1][0xfc - rangeMin] = 0x00fc;
mapDataStd[1][0xfd - rangeMin] = 0x0169;
mapDataStd[1][0xfe - rangeMin] = 0x016b;
mapDataStd[1][0xff - rangeMin] = 0x02d9;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
mapDataPCL[1][0xa4 - rangeMin] = 0x20ac;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 8 M //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 8M //
// Kind1 269 //
// Name Math-8 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_8M()
{
const eSymSetMapId mapId = eSymSetMapId.map_8M;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
mapDataPCL[0][0x20 - rangeMin] = 0x0020;
mapDataPCL[0][0x21 - rangeMin] = 0xefbf;
mapDataPCL[0][0x22 - rangeMin] = 0x2033;
mapDataPCL[0][0x23 - rangeMin] = 0x00b0;
mapDataPCL[0][0x24 - rangeMin] = 0x221e;
mapDataPCL[0][0x25 - rangeMin] = 0x00f7;
mapDataPCL[0][0x26 - rangeMin] = 0x221d;
mapDataPCL[0][0x27 - rangeMin] = 0x2032;
mapDataPCL[0][0x28 - rangeMin] = 0x0028;
mapDataPCL[0][0x29 - rangeMin] = 0x0029;
mapDataPCL[0][0x2a - rangeMin] = 0x00d7;
mapDataPCL[0][0x2b - rangeMin] = 0x002b;
mapDataPCL[0][0x2c - rangeMin] = 0x002c;
mapDataPCL[0][0x2d - rangeMin] = 0x2212;
mapDataPCL[0][0x2e - rangeMin] = 0x002e;
mapDataPCL[0][0x2f - rangeMin] = 0x002f;
mapDataPCL[0][0x30 - rangeMin] = 0x0030;
mapDataPCL[0][0x31 - rangeMin] = 0x0031;
mapDataPCL[0][0x32 - rangeMin] = 0x0032;
mapDataPCL[0][0x33 - rangeMin] = 0x0033;
mapDataPCL[0][0x34 - rangeMin] = 0x0034;
mapDataPCL[0][0x35 - rangeMin] = 0x0035;
mapDataPCL[0][0x36 - rangeMin] = 0x0036;
mapDataPCL[0][0x37 - rangeMin] = 0x0037;
mapDataPCL[0][0x38 - rangeMin] = 0x0038;
mapDataPCL[0][0x39 - rangeMin] = 0x0039;
mapDataPCL[0][0x3a - rangeMin] = 0x212f;
mapDataPCL[0][0x3b - rangeMin] = 0xefec;
mapDataPCL[0][0x3c - rangeMin] = 0x003c;
mapDataPCL[0][0x3d - rangeMin] = 0x003d;
mapDataPCL[0][0x3e - rangeMin] = 0x003e;
mapDataPCL[0][0x3f - rangeMin] = 0x2248;
mapDataPCL[0][0x40 - rangeMin] = 0x2234;
mapDataPCL[0][0x41 - rangeMin] = 0x0041;
mapDataPCL[0][0x42 - rangeMin] = 0x0042;
mapDataPCL[0][0x43 - rangeMin] = 0x0393;
mapDataPCL[0][0x44 - rangeMin] = 0x2206;
mapDataPCL[0][0x45 - rangeMin] = 0x0045;
mapDataPCL[0][0x46 - rangeMin] = 0x005a;
mapDataPCL[0][0x47 - rangeMin] = 0x0048;
mapDataPCL[0][0x48 - rangeMin] = 0x0398;
mapDataPCL[0][0x49 - rangeMin] = 0x0049;
mapDataPCL[0][0x4a - rangeMin] = 0x0048;
mapDataPCL[0][0x4b - rangeMin] = 0x039b;
mapDataPCL[0][0x4c - rangeMin] = 0x004d;
mapDataPCL[0][0x4d - rangeMin] = 0x004e;
mapDataPCL[0][0x4e - rangeMin] = 0x039e;
mapDataPCL[0][0x4f - rangeMin] = 0x004f;
mapDataPCL[0][0x50 - rangeMin] = 0x03a0;
mapDataPCL[0][0x51 - rangeMin] = 0x0050;
mapDataPCL[0][0x52 - rangeMin] = 0x03a3;
mapDataPCL[0][0x53 - rangeMin] = 0x0054;
mapDataPCL[0][0x54 - rangeMin] = 0x03a5;
mapDataPCL[0][0x55 - rangeMin] = 0x03a6;
mapDataPCL[0][0x56 - rangeMin] = 0x0058;
mapDataPCL[0][0x57 - rangeMin] = 0x03a8;
mapDataPCL[0][0x58 - rangeMin] = 0x03a9;
mapDataPCL[0][0x59 - rangeMin] = 0x2207;
mapDataPCL[0][0x5a - rangeMin] = 0x2202;
mapDataPCL[0][0x5b - rangeMin] = 0x03c2;
mapDataPCL[0][0x5c - rangeMin] = 0x2264;
mapDataPCL[0][0x5d - rangeMin] = 0x2260;
mapDataPCL[0][0x5e - rangeMin] = 0x2265;
mapDataPCL[0][0x5f - rangeMin] = 0xefeb;
mapDataPCL[0][0x60 - rangeMin] = 0x2235;
mapDataPCL[0][0x61 - rangeMin] = 0x03b1;
mapDataPCL[0][0x62 - rangeMin] = 0x03b2;
mapDataPCL[0][0x63 - rangeMin] = 0x03b3;
mapDataPCL[0][0x64 - rangeMin] = 0x03b4;
mapDataPCL[0][0x65 - rangeMin] = 0x03b5;
mapDataPCL[0][0x66 - rangeMin] = 0x03b6;
mapDataPCL[0][0x67 - rangeMin] = 0x03b7;
mapDataPCL[0][0x68 - rangeMin] = 0x03b8;
mapDataPCL[0][0x69 - rangeMin] = 0x03b9;
mapDataPCL[0][0x6a - rangeMin] = 0x03ba;
mapDataPCL[0][0x6b - rangeMin] = 0x03bb;
mapDataPCL[0][0x6c - rangeMin] = 0x03bc;
mapDataPCL[0][0x6d - rangeMin] = 0x03bd;
mapDataPCL[0][0x6e - rangeMin] = 0x03be;
mapDataPCL[0][0x6f - rangeMin] = 0x03bf;
mapDataPCL[0][0x70 - rangeMin] = 0x03c0;
mapDataPCL[0][0x71 - rangeMin] = 0x03c1;
mapDataPCL[0][0x72 - rangeMin] = 0x03c3;
mapDataPCL[0][0x73 - rangeMin] = 0x03c4;
mapDataPCL[0][0x74 - rangeMin] = 0x03c5;
mapDataPCL[0][0x75 - rangeMin] = 0x03c6;
mapDataPCL[0][0x76 - rangeMin] = 0x03c7;
mapDataPCL[0][0x77 - rangeMin] = 0x03c8;
mapDataPCL[0][0x78 - rangeMin] = 0x03c9;
mapDataPCL[0][0x79 - rangeMin] = 0x03d1;
mapDataPCL[0][0x7a - rangeMin] = 0x03d5;
mapDataPCL[0][0x7b - rangeMin] = 0x03d6;
mapDataPCL[0][0x7c - rangeMin] = 0x2243;
mapDataPCL[0][0x7d - rangeMin] = 0x2261;
mapDataPCL[0][0x7e - rangeMin] = 0x2262;
mapDataPCL[0][0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataPCL[1][0xa0 - rangeMin] = 0x00a0;
mapDataPCL[1][0xa1 - rangeMin] = 0x2191;
mapDataPCL[1][0xa2 - rangeMin] = 0x2192;
mapDataPCL[1][0xa3 - rangeMin] = 0x2193;
mapDataPCL[1][0xa4 - rangeMin] = 0x2190;
mapDataPCL[1][0xa5 - rangeMin] = 0x21d1;
mapDataPCL[1][0xa6 - rangeMin] = 0x21d2;
mapDataPCL[1][0xa7 - rangeMin] = 0x21d3;
mapDataPCL[1][0xa8 - rangeMin] = 0x21d0;
mapDataPCL[1][0xa9 - rangeMin] = 0x2195;
mapDataPCL[1][0xaa - rangeMin] = 0x2194;
mapDataPCL[1][0xab - rangeMin] = 0x21d5;
mapDataPCL[1][0xac - rangeMin] = 0x21d4;
mapDataPCL[1][0xad - rangeMin] = 0x21c4;
mapDataPCL[1][0xae - rangeMin] = 0x21c6;
mapDataPCL[1][0xaf - rangeMin] = 0xefe9;
mapDataPCL[1][0xb0 - rangeMin] = 0xefea;
mapDataPCL[1][0xb1 - rangeMin] = 0x2200;
mapDataPCL[1][0xb2 - rangeMin] = 0x2203;
mapDataPCL[1][0xb3 - rangeMin] = 0x22a4;
mapDataPCL[1][0xb4 - rangeMin] = 0x22a5;
mapDataPCL[1][0xb5 - rangeMin] = 0x222a;
mapDataPCL[1][0xb6 - rangeMin] = 0x2229;
mapDataPCL[1][0xb7 - rangeMin] = 0x2208;
mapDataPCL[1][0xb8 - rangeMin] = 0x220b;
mapDataPCL[1][0xb9 - rangeMin] = 0x2209;
mapDataPCL[1][0xba - rangeMin] = 0x2282;
mapDataPCL[1][0xbb - rangeMin] = 0x2283;
mapDataPCL[1][0xbc - rangeMin] = 0x2284;
mapDataPCL[1][0xbd - rangeMin] = 0x2285;
mapDataPCL[1][0xbe - rangeMin] = 0x2286;
mapDataPCL[1][0xbf - rangeMin] = 0x2287;
mapDataPCL[1][0xc0 - rangeMin] = 0x2295;
mapDataPCL[1][0xc1 - rangeMin] = 0x2299;
mapDataPCL[1][0xc2 - rangeMin] = 0x2297;
mapDataPCL[1][0xc3 - rangeMin] = 0x2296;
mapDataPCL[1][0xc4 - rangeMin] = 0x2298;
mapDataPCL[1][0xc5 - rangeMin] = 0x2227;
mapDataPCL[1][0xc6 - rangeMin] = 0x2228;
mapDataPCL[1][0xc7 - rangeMin] = 0x22bb;
mapDataPCL[1][0xc8 - rangeMin] = 0x00ac;
mapDataPCL[1][0xc9 - rangeMin] = 0x2218;
mapDataPCL[1][0xca - rangeMin] = 0x2219;
mapDataPCL[1][0xcb - rangeMin] = 0x2022;
mapDataPCL[1][0xcc - rangeMin] = 0x25cf;
mapDataPCL[1][0xcd - rangeMin] = 0x20dd;
mapDataPCL[1][0xce - rangeMin] = 0x2020;
mapDataPCL[1][0xcf - rangeMin] = 0x2021;
mapDataPCL[1][0xd0 - rangeMin] = 0x00c5;
mapDataPCL[1][0xd1 - rangeMin] = 0x22a3;
mapDataPCL[1][0xd2 - rangeMin] = 0x22a2;
mapDataPCL[1][0xd3 - rangeMin] = 0x221f;
mapDataPCL[1][0xd4 - rangeMin] = 0x220d;
mapDataPCL[1][0xd5 - rangeMin] = 0x222b;
mapDataPCL[1][0xd6 - rangeMin] = 0x222e;
mapDataPCL[1][0xd7 - rangeMin] = 0x2220;
mapDataPCL[1][0xd8 - rangeMin] = 0x2205;
mapDataPCL[1][0xd9 - rangeMin] = 0x2135;
mapDataPCL[1][0xda - rangeMin] = 0x2136;
mapDataPCL[1][0xdb - rangeMin] = 0x2137;
mapDataPCL[1][0xdc - rangeMin] = 0x212d;
mapDataPCL[1][0xdd - rangeMin] = 0x2111;
mapDataPCL[1][0xde - rangeMin] = 0x211c;
mapDataPCL[1][0xdf - rangeMin] = 0x2128;
mapDataPCL[1][0xe0 - rangeMin] = 0xefe7;
mapDataPCL[1][0xe1 - rangeMin] = 0xefe6;
mapDataPCL[1][0xe2 - rangeMin] = 0xefe3;
mapDataPCL[1][0xe3 - rangeMin] = 0xefe2;
mapDataPCL[1][0xe4 - rangeMin] = 0xefe1;
mapDataPCL[1][0xe5 - rangeMin] = 0xefe3;
mapDataPCL[1][0xe6 - rangeMin] = 0xefd4;
mapDataPCL[1][0xe7 - rangeMin] = 0x2321;
mapDataPCL[1][0xe8 - rangeMin] = 0xefd3;
mapDataPCL[1][0xe9 - rangeMin] = 0xefc9;
mapDataPCL[1][0xea - rangeMin] = 0xefd2;
mapDataPCL[1][0xeb - rangeMin] = 0xefd1;
mapDataPCL[1][0xec - rangeMin] = 0xefe8;
mapDataPCL[1][0xed - rangeMin] = 0xefcb;
mapDataPCL[1][0xee - rangeMin] = 0x2217;
mapDataPCL[1][0xef - rangeMin] = 0x2245;
mapDataPCL[1][0xf0 - rangeMin] = 0xefe5;
mapDataPCL[1][0xf1 - rangeMin] = 0xefe4;
mapDataPCL[1][0xf2 - rangeMin] = 0xefe0;
mapDataPCL[1][0xf3 - rangeMin] = 0xefdf;
mapDataPCL[1][0xf4 - rangeMin] = 0xefde;
mapDataPCL[1][0xf5 - rangeMin] = 0xefdd;
mapDataPCL[1][0xf6 - rangeMin] = 0x2223;
mapDataPCL[1][0xf7 - rangeMin] = 0xefdc;
mapDataPCL[1][0xf8 - rangeMin] = 0xefd0;
mapDataPCL[1][0xf9 - rangeMin] = 0xefcf;
mapDataPCL[1][0xfa - rangeMin] = 0xefce;
mapDataPCL[1][0xfb - rangeMin] = 0xefcd;
mapDataPCL[1][0xfc - rangeMin] = 0xefcc;
mapDataPCL[1][0xfd - rangeMin] = 0x2213;
mapDataPCL[1][0xfe - rangeMin] = 0x00b1;
mapDataPCL[1][0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 0 N //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 0N //
// Kind1 14 //
// Name ISO 8859-1 Latin 1 //
// Western European //
// Equivalent to Row 0 of Unicode Basic MultiLingual Plane //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_0N()
{
const eSymSetMapId mapId = eSymSetMapId.map_0N;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL [0] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [0] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = i;
}
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
mapDataPCL [1] [0xaf - rangeMin] = 0x02c9;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 5 T //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 5T //
// Kind1 180 //
// Name Windows Latin-5 //
// Code Page 1254 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_5T()
{
const eSymSetMapId mapId = eSymSetMapId.map_5T;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0x9f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL[0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataStd [1] [0x80 - rangeMin] = 0x20ac;
mapDataStd [1] [0x81 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x82 - rangeMin] = 0x201a;
mapDataStd [1] [0x83 - rangeMin] = 0x0192;
mapDataStd [1] [0x84 - rangeMin] = 0x201e;
mapDataStd [1] [0x85 - rangeMin] = 0x2026;
mapDataStd [1] [0x86 - rangeMin] = 0x2020;
mapDataStd [1] [0x87 - rangeMin] = 0x2021;
mapDataStd [1] [0x88 - rangeMin] = 0x02c6;
mapDataStd [1] [0x89 - rangeMin] = 0x2030;
mapDataStd [1] [0x8a - rangeMin] = 0x0160;
mapDataStd [1] [0x8b - rangeMin] = 0x2039;
mapDataStd [1] [0x8c - rangeMin] = 0x0152;
mapDataStd [1] [0x8d - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x8e - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x8f - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x90 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x91 - rangeMin] = 0x2018;
mapDataStd [1] [0x92 - rangeMin] = 0x2019;
mapDataStd [1] [0x93 - rangeMin] = 0x201c;
mapDataStd [1] [0x94 - rangeMin] = 0x201d;
mapDataStd [1] [0x95 - rangeMin] = 0x2022;
mapDataStd [1] [0x96 - rangeMin] = 0x2013;
mapDataStd [1] [0x97 - rangeMin] = 0x2014;
mapDataStd [1] [0x98 - rangeMin] = 0x02dc;
mapDataStd [1] [0x99 - rangeMin] = 0x2122;
mapDataStd [1] [0x9a - rangeMin] = 0x0161;
mapDataStd [1] [0x9b - rangeMin] = 0x203a;
mapDataStd [1] [0x9c - rangeMin] = 0x0153;
mapDataStd [1] [0x9d - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x9e - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x9f - rangeMin] = 0x0178;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd[2][i - rangeMin] = i;
}
mapDataStd[2][0xd0 - rangeMin] = 0x011e;
mapDataStd[2][0xdd - rangeMin] = 0x0130;
mapDataStd[2][0xde - rangeMin] = 0x015e;
mapDataStd[2][0xf0 - rangeMin] = 0x011f;
mapDataStd[2][0xfd - rangeMin] = 0x0131;
mapDataStd[2][0xfe - rangeMin] = 0x015f;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL[2][i] = mapDataStd[2][i];
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 8 V //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 8V //
// Kind1 278 //
// Name Arabic-8 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_8V()
{
const eSymSetMapId mapId = eSymSetMapId.map_8V;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
mapDataPCL[0][0x20 - rangeMin] = 0x0020;
mapDataPCL[0][0x21 - rangeMin] = 0xef4a;
mapDataPCL[0][0x22 - rangeMin] = 0xef4b;
mapDataPCL[0][0x23 - rangeMin] = 0xef4c;
mapDataPCL[0][0x24 - rangeMin] = 0xef4d;
mapDataPCL[0][0x25 - rangeMin] = 0x066a;
mapDataPCL[0][0x26 - rangeMin] = 0xef4e;
mapDataPCL[0][0x27 - rangeMin] = 0xef4f;
mapDataPCL[0][0x28 - rangeMin] = 0xef50;
mapDataPCL[0][0x29 - rangeMin] = 0xef51;
mapDataPCL[0][0x2a - rangeMin] = 0x066d;
mapDataPCL[0][0x2b - rangeMin] = 0xef52;
mapDataPCL[0][0x2c - rangeMin] = 0x060c;
mapDataPCL[0][0x2d - rangeMin] = 0xef53;
mapDataPCL[0][0x2e - rangeMin] = 0xef54;
mapDataPCL[0][0x2f - rangeMin] = 0xef55;
mapDataPCL[0][0x30 - rangeMin] = 0x0660;
mapDataPCL[0][0x31 - rangeMin] = 0x0661;
mapDataPCL[0][0x32 - rangeMin] = 0x0662;
mapDataPCL[0][0x33 - rangeMin] = 0x0663;
mapDataPCL[0][0x34 - rangeMin] = 0x0664;
mapDataPCL[0][0x35 - rangeMin] = 0x0665;
mapDataPCL[0][0x36 - rangeMin] = 0x0666;
mapDataPCL[0][0x37 - rangeMin] = 0x0667;
mapDataPCL[0][0x38 - rangeMin] = 0x0668;
mapDataPCL[0][0x39 - rangeMin] = 0x0669;
mapDataPCL[0][0x3a - rangeMin] = 0xef56;
mapDataPCL[0][0x3b - rangeMin] = 0x061b;
mapDataPCL[0][0x3c - rangeMin] = 0xef57;
mapDataPCL[0][0x3d - rangeMin] = 0xef58;
mapDataPCL[0][0x3e - rangeMin] = 0xef59;
mapDataPCL[0][0x3f - rangeMin] = 0x061f;
mapDataPCL[0][0x40 - rangeMin] = 0xef5a;
mapDataPCL[0][0x41 - rangeMin] = 0xfee0;
mapDataPCL[0][0x42 - rangeMin] = 0xfedf;
mapDataPCL[0][0x43 - rangeMin] = 0xef00;
mapDataPCL[0][0x44 - rangeMin] = 0xef01;
mapDataPCL[0][0x45 - rangeMin] = 0xef02;
mapDataPCL[0][0x46 - rangeMin] = 0xfe84;
mapDataPCL[0][0x47 - rangeMin] = 0xfe82;
mapDataPCL[0][0x48 - rangeMin] = 0xfe88;
mapDataPCL[0][0x49 - rangeMin] = 0xfefc;
mapDataPCL[0][0x4a - rangeMin] = 0xfef8;
mapDataPCL[0][0x4b - rangeMin] = 0xfef6;
mapDataPCL[0][0x4c - rangeMin] = 0xfefa;
mapDataPCL[0][0x4d - rangeMin] = 0xfefb;
mapDataPCL[0][0x4e - rangeMin] = 0xfef7;
mapDataPCL[0][0x4f - rangeMin] = 0xfef5;
mapDataPCL[0][0x50 - rangeMin] = 0xfef9;
mapDataPCL[0][0x51 - rangeMin] = 0xef03;
mapDataPCL[0][0x52 - rangeMin] = 0xef04;
mapDataPCL[0][0x53 - rangeMin] = 0xef05;
mapDataPCL[0][0x54 - rangeMin] = 0xef06;
mapDataPCL[0][0x55 - rangeMin] = 0xef07;
mapDataPCL[0][0x56 - rangeMin] = 0xfee4;
mapDataPCL[0][0x57 - rangeMin] = 0xef08;
mapDataPCL[0][0x58 - rangeMin] = 0xef09;
mapDataPCL[0][0x59 - rangeMin] = 0xef5b;
mapDataPCL[0][0x5a - rangeMin] = 0xef5c;
mapDataPCL[0][0x5b - rangeMin] = 0xef5d;
mapDataPCL[0][0x5c - rangeMin] = 0xef5e;
mapDataPCL[0][0x5d - rangeMin] = 0xef5f;
mapDataPCL[0][0x5e - rangeMin] = 0xef60;
mapDataPCL[0][0x5f - rangeMin] = 0x005f;
mapDataPCL[0][0x60 - rangeMin] = 0xfe80;
mapDataPCL[0][0x61 - rangeMin] = 0xfe70;
mapDataPCL[0][0x62 - rangeMin] = 0xfe72;
mapDataPCL[0][0x63 - rangeMin] = 0xfe74;
mapDataPCL[0][0x64 - rangeMin] = 0xfc60;
mapDataPCL[0][0x65 - rangeMin] = 0xfc61;
mapDataPCL[0][0x66 - rangeMin] = 0xfc62;
mapDataPCL[0][0x67 - rangeMin] = 0xfe76;
mapDataPCL[0][0x68 - rangeMin] = 0xfe78;
mapDataPCL[0][0x69 - rangeMin] = 0xfe7a;
mapDataPCL[0][0x6a - rangeMin] = 0xfe7e;
mapDataPCL[0][0x6b - rangeMin] = 0xfe7c;
mapDataPCL[0][0x6c - rangeMin] = 0xfec9;
mapDataPCL[0][0x6d - rangeMin] = 0xfecd;
mapDataPCL[0][0x6e - rangeMin] = 0xfee9;
mapDataPCL[0][0x6f - rangeMin] = 0xfe9d;
mapDataPCL[0][0x70 - rangeMin] = 0xfea1;
mapDataPCL[0][0x71 - rangeMin] = 0xfea5;
mapDataPCL[0][0x72 - rangeMin] = 0xfe93;
mapDataPCL[0][0x73 - rangeMin] = 0xfe94;
mapDataPCL[0][0x74 - rangeMin] = 0xfe8e;
mapDataPCL[0][0x75 - rangeMin] = 0xfef2;
mapDataPCL[0][0x76 - rangeMin] = 0xfe8a;
mapDataPCL[0][0x77 - rangeMin] = 0xfef0;
mapDataPCL[0][0x78 - rangeMin] = 0xef0a;
mapDataPCL[0][0x79 - rangeMin] = 0xef0b;
mapDataPCL[0][0x7a - rangeMin] = 0xef0c;
mapDataPCL[0][0x7b - rangeMin] = 0xef61;
mapDataPCL[0][0x7c - rangeMin] = 0x007c;
mapDataPCL[0][0x7d - rangeMin] = 0xef62;
mapDataPCL[0][0x7e - rangeMin] = 0xef63;
mapDataPCL[0][0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataPCL[1][0xa0 - rangeMin] = 0x00a0;
mapDataPCL[1][0xa1 - rangeMin] = 0xef0d;
mapDataPCL[1][0xa2 - rangeMin] = 0xef0e;
mapDataPCL[1][0xa3 - rangeMin] = 0xfd3c;
mapDataPCL[1][0xa4 - rangeMin] = 0xef0f;
mapDataPCL[1][0xa5 - rangeMin] = 0xef10;
mapDataPCL[1][0xa6 - rangeMin] = 0xef11;
mapDataPCL[1][0xa7 - rangeMin] = 0xef12;
mapDataPCL[1][0xa8 - rangeMin] = 0xef13;
mapDataPCL[1][0xa9 - rangeMin] = 0xef14;
mapDataPCL[1][0xaa - rangeMin] = 0xef15;
mapDataPCL[1][0xab - rangeMin] = 0xef16;
mapDataPCL[1][0xac - rangeMin] = 0xef17;
mapDataPCL[1][0xad - rangeMin] = 0xef18;
mapDataPCL[1][0xae - rangeMin] = 0xfd3d;
mapDataPCL[1][0xaf - rangeMin] = 0xef19;
mapDataPCL[1][0xb0 - rangeMin] = 0xef1a;
mapDataPCL[1][0xb1 - rangeMin] = 0xef1b;
mapDataPCL[1][0xb2 - rangeMin] = 0xef1c;
mapDataPCL[1][0xb3 - rangeMin] = 0xef1d;
mapDataPCL[1][0xb4 - rangeMin] = 0xef1e;
mapDataPCL[1][0xb5 - rangeMin] = 0xef1f;
mapDataPCL[1][0xb6 - rangeMin] = 0xef20;
mapDataPCL[1][0xb7 - rangeMin] = 0xef21;
mapDataPCL[1][0xb8 - rangeMin] = 0xef22;
mapDataPCL[1][0xb9 - rangeMin] = 0xfeca;
mapDataPCL[1][0xba - rangeMin] = 0xfece;
mapDataPCL[1][0xbb - rangeMin] = 0xfeea;
mapDataPCL[1][0xbc - rangeMin] = 0xfe9e;
mapDataPCL[1][0xbd - rangeMin] = 0xfea2;
mapDataPCL[1][0xbe - rangeMin] = 0xfea6;
mapDataPCL[1][0xbf - rangeMin] = 0xef23;
mapDataPCL[1][0xc0 - rangeMin] = 0xef24;
mapDataPCL[1][0xc1 - rangeMin] = 0xef25;
mapDataPCL[1][0xc2 - rangeMin] = 0xef26;
mapDataPCL[1][0xc3 - rangeMin] = 0xef27;
mapDataPCL[1][0xc4 - rangeMin] = 0xfef1;
mapDataPCL[1][0xc5 - rangeMin] = 0xfe89;
mapDataPCL[1][0xc6 - rangeMin] = 0xfeef;
mapDataPCL[1][0xc7 - rangeMin] = 0xef28;
mapDataPCL[1][0xc8 - rangeMin] = 0xef29;
mapDataPCL[1][0xc9 - rangeMin] = 0xef2a;
mapDataPCL[1][0xca - rangeMin] = 0xef2b;
mapDataPCL[1][0xcb - rangeMin] = 0xef2c;
mapDataPCL[1][0xcc - rangeMin] = 0xef2d;
mapDataPCL[1][0xcd - rangeMin] = 0xfe83;
mapDataPCL[1][0xce - rangeMin] = 0xfe81;
mapDataPCL[1][0xcf - rangeMin] = 0xfe87;
mapDataPCL[1][0xd0 - rangeMin] = 0xfe8d;
mapDataPCL[1][0xd1 - rangeMin] = 0xef2e;
mapDataPCL[1][0xd2 - rangeMin] = 0xef2f;
mapDataPCL[1][0xd3 - rangeMin] = 0xef30;
mapDataPCL[1][0xd4 - rangeMin] = 0xef31;
mapDataPCL[1][0xd5 - rangeMin] = 0xef32;
mapDataPCL[1][0xd6 - rangeMin] = 0xef33;
mapDataPCL[1][0xd7 - rangeMin] = 0x0640;
mapDataPCL[1][0xd8 - rangeMin] = 0xef34;
mapDataPCL[1][0xd9 - rangeMin] = 0xef35;
mapDataPCL[1][0xda - rangeMin] = 0xef36;
mapDataPCL[1][0xdb - rangeMin] = 0xef37;
mapDataPCL[1][0xdc - rangeMin] = 0xef38;
mapDataPCL[1][0xdd - rangeMin] = 0xfe7d;
mapDataPCL[1][0xde - rangeMin] = 0xef39;
mapDataPCL[1][0xdf - rangeMin] = 0xef3a;
mapDataPCL[1][0xe0 - rangeMin] = 0xef3b;
mapDataPCL[1][0xe1 - rangeMin] = 0xef3c;
mapDataPCL[1][0xe2 - rangeMin] = 0xfecb;
mapDataPCL[1][0xe3 - rangeMin] = 0xfecf;
mapDataPCL[1][0xe4 - rangeMin] = 0xfeeb;
mapDataPCL[1][0xe5 - rangeMin] = 0xfe9f;
mapDataPCL[1][0xe6 - rangeMin] = 0xfea3;
mapDataPCL[1][0xe7 - rangeMin] = 0xfea7;
mapDataPCL[1][0xe8 - rangeMin] = 0xfecc;
mapDataPCL[1][0xe9 - rangeMin] = 0xfed0;
mapDataPCL[1][0xea - rangeMin] = 0xfeec;
mapDataPCL[1][0xeb - rangeMin] = 0xef3d;
mapDataPCL[1][0xec - rangeMin] = 0xef3e;
mapDataPCL[1][0xed - rangeMin] = 0xef3f;
mapDataPCL[1][0xee - rangeMin] = 0xef40;
mapDataPCL[1][0xef - rangeMin] = 0xef41;
mapDataPCL[1][0xf0 - rangeMin] = 0xef42;
mapDataPCL[1][0xf1 - rangeMin] = 0xef43;
mapDataPCL[1][0xf2 - rangeMin] = 0xef44;
mapDataPCL[1][0xf3 - rangeMin] = 0xef45;
mapDataPCL[1][0xf4 - rangeMin] = 0xef46;
mapDataPCL[1][0xf5 - rangeMin] = 0xef47;
mapDataPCL[1][0xf6 - rangeMin] = 0xef48;
mapDataPCL[1][0xf7 - rangeMin] = 0xef49;
mapDataPCL[1][0xf8 - rangeMin] = 0xfcf2;
mapDataPCL[1][0xf9 - rangeMin] = 0xfcf3;
mapDataPCL[1][0xfa - rangeMin] = 0xfcf4;
mapDataPCL[1][0xfb - rangeMin] = 0xfe77;
mapDataPCL[1][0xfc - rangeMin] = 0xfe79;
mapDataPCL[1][0xfd - rangeMin] = 0xfe7b;
mapDataPCL[1][0xfe - rangeMin] = 0xfe7f;
mapDataPCL[1][0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 7 J //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 7J //
// Kind1 234 //
// Name Desktop //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_7J()
{
const eSymSetMapId mapId = eSymSetMapId.map_7J;
const Int32 rangeCt = 2;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL [0] [0x27 - rangeMin] = 0x2019;
mapDataPCL [0] [0x60 - rangeMin] = 0x2018;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataPCL [1] [0xa0 - rangeMin] = 0x00a0;
mapDataPCL [1] [0xa1 - rangeMin] = 0x00b6;
mapDataPCL [1] [0xa2 - rangeMin] = 0x00a7;
mapDataPCL [1] [0xa3 - rangeMin] = 0x2020;
mapDataPCL [1] [0xa4 - rangeMin] = 0x2021;
mapDataPCL [1] [0xa5 - rangeMin] = 0x00a9;
mapDataPCL [1] [0xa6 - rangeMin] = 0x00ae;
mapDataPCL [1] [0xa7 - rangeMin] = 0x2122;
mapDataPCL [1] [0xa8 - rangeMin] = 0x2105;
mapDataPCL [1] [0xa9 - rangeMin] = 0x00a2;
mapDataPCL [1] [0xaa - rangeMin] = 0x2013;
mapDataPCL [1] [0xab - rangeMin] = 0x2014;
mapDataPCL [1] [0xac - rangeMin] = 0x2026;
mapDataPCL [1] [0xad - rangeMin] = 0xf001;
mapDataPCL [1] [0xae - rangeMin] = 0xf002;
mapDataPCL [1] [0xaf - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xb0 - rangeMin] = 0x201c;
mapDataPCL [1] [0xb1 - rangeMin] = 0x201d;
mapDataPCL [1] [0xb2 - rangeMin] = 0x00b5;
mapDataPCL [1] [0xb3 - rangeMin] = 0x2030;
mapDataPCL [1] [0xb4 - rangeMin] = 0x2022;
mapDataPCL [1] [0xb5 - rangeMin] = 0x25cf;
mapDataPCL [1] [0xb6 - rangeMin] = 0x25e6;
mapDataPCL [1] [0xb7 - rangeMin] = 0x25cb;
mapDataPCL [1] [0xb8 - rangeMin] = 0x25aa;
mapDataPCL [1] [0xb9 - rangeMin] = 0x25a0;
mapDataPCL [1] [0xba - rangeMin] = 0x25ab;
mapDataPCL [1] [0xbb - rangeMin] = 0x25a1;
mapDataPCL [1] [0xbc - rangeMin] = 0x0027;
mapDataPCL [1] [0xbd - rangeMin] = 0x00ac;
mapDataPCL [1] [0xbe - rangeMin] = 0x00a6;
mapDataPCL [1] [0xbf - rangeMin] = 0x2017;
mapDataPCL [1] [0xc0 - rangeMin] = 0x2212;
mapDataPCL [1] [0xc1 - rangeMin] = 0x00b1;
mapDataPCL [1] [0xc2 - rangeMin] = 0x00d7;
mapDataPCL [1] [0xc3 - rangeMin] = 0x00f7;
mapDataPCL [1] [0xc4 - rangeMin] = 0x00b0;
mapDataPCL [1] [0xc5 - rangeMin] = 0x2032;
mapDataPCL [1] [0xc6 - rangeMin] = 0x2033;
mapDataPCL [1] [0xc7 - rangeMin] = 0x00bc;
mapDataPCL [1] [0xc8 - rangeMin] = 0x00bd;
mapDataPCL [1] [0xc9 - rangeMin] = 0x00be;
mapDataPCL [1] [0xca - rangeMin] = 0x00b9;
mapDataPCL [1] [0xcb - rangeMin] = 0x00b2;
mapDataPCL [1] [0xcc - rangeMin] = 0x00b3;
mapDataPCL [1] [0xcd - rangeMin] = 0x2215;
mapDataPCL [1] [0xce - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xcf - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0xd0 - rangeMin] = 0x2039;
mapDataPCL [1] [0xd1 - rangeMin] = 0x203a;
mapDataPCL [1] [0xd2 - rangeMin] = 0x00ab;
mapDataPCL [1] [0xd3 - rangeMin] = 0x00bb;
mapDataPCL [1] [0xd4 - rangeMin] = 0x201a;
mapDataPCL [1] [0xd5 - rangeMin] = 0x201e;
mapDataPCL [1] [0xd6 - rangeMin] = 0x2219;
mapDataPCL [1] [0xd7 - rangeMin] = 0x00a1;
mapDataPCL [1] [0xd8 - rangeMin] = 0x00bf;
mapDataPCL [1] [0xd9 - rangeMin] = 0x20a7;
mapDataPCL [1] [0xda - rangeMin] = 0x2113;
mapDataPCL [1] [0xdb - rangeMin] = 0x00a3;
mapDataPCL [1] [0xdc - rangeMin] = 0x00a5;
mapDataPCL [1] [0xdd - rangeMin] = 0x00a4;
mapDataPCL [1] [0xde - rangeMin] = 0x0192;
mapDataPCL [1] [0xdf - rangeMin] = 0x00df;
mapDataPCL [1] [0xe0 - rangeMin] = 0x00aa;
mapDataPCL [1] [0xe1 - rangeMin] = 0x00ba;
mapDataPCL [1] [0xe2 - rangeMin] = 0x00e6;
mapDataPCL [1] [0xe3 - rangeMin] = 0x00c6;
mapDataPCL [1] [0xe4 - rangeMin] = 0x00f0;
mapDataPCL [1] [0xe5 - rangeMin] = 0x00d0;
mapDataPCL [1] [0xe6 - rangeMin] = 0x0133;
mapDataPCL [1] [0xe7 - rangeMin] = 0x0132;
mapDataPCL [1] [0xe8 - rangeMin] = 0x0142;
mapDataPCL [1] [0xe9 - rangeMin] = 0x0141;
mapDataPCL [1] [0xea - rangeMin] = 0x0153;
mapDataPCL [1] [0xeb - rangeMin] = 0x0152;
mapDataPCL [1] [0xec - rangeMin] = 0x00f8;
mapDataPCL [1] [0xed - rangeMin] = 0x00d8;
mapDataPCL [1] [0xee - rangeMin] = 0x00fe;
mapDataPCL [1] [0xef - rangeMin] = 0x00de;
mapDataPCL [1] [0xf0 - rangeMin] = 0x00b4;
mapDataPCL [1] [0xf1 - rangeMin] = 0x0060;
mapDataPCL [1] [0xf2 - rangeMin] = 0x02c6;
mapDataPCL [1] [0xf3 - rangeMin] = 0x00a8;
mapDataPCL [1] [0xf4 - rangeMin] = 0x02dc;
mapDataPCL [1] [0xf5 - rangeMin] = 0x02c7;
mapDataPCL [1] [0xf6 - rangeMin] = 0x02d8;
mapDataPCL [1] [0xf7 - rangeMin] = 0x02dd;
mapDataPCL [1] [0xf8 - rangeMin] = 0x02da;
mapDataPCL [1] [0xf9 - rangeMin] = 0x02d9;
mapDataPCL [1] [0xfa - rangeMin] = 0x02c9;
mapDataPCL [1] [0xfb - rangeMin] = 0x00b8;
mapDataPCL [1] [0xfc - rangeMin] = 0x02db;
mapDataPCL [1] [0xfd - rangeMin] = 0x00b7;
mapDataPCL [1] [0xfe - rangeMin] = 0x0131;
mapDataPCL [1] [0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataPCL [1] [i];
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 2 J //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 12J //
// Kind1 394 //
// Name MC Text //
// Macintosh //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_12J()
{
const eSymSetMapId mapId = eSymSetMapId.map_12J;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0x9f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataPCL [1] [0x80 - rangeMin] = 0x00c4;
mapDataPCL [1] [0x81 - rangeMin] = 0x00c5;
mapDataPCL [1] [0x82 - rangeMin] = 0x00c7;
mapDataPCL [1] [0x83 - rangeMin] = 0x00c9;
mapDataPCL [1] [0x84 - rangeMin] = 0x00d1;
mapDataPCL [1] [0x85 - rangeMin] = 0x00d6;
mapDataPCL [1] [0x86 - rangeMin] = 0x00dc;
mapDataPCL [1] [0x87 - rangeMin] = 0x00e1;
mapDataPCL [1] [0x88 - rangeMin] = 0x00e0;
mapDataPCL [1] [0x89 - rangeMin] = 0x00e2;
mapDataPCL [1] [0x8a - rangeMin] = 0x00e4;
mapDataPCL [1] [0x8b - rangeMin] = 0x00e3;
mapDataPCL [1] [0x8c - rangeMin] = 0x00e5;
mapDataPCL [1] [0x8d - rangeMin] = 0x00e7;
mapDataPCL [1] [0x8e - rangeMin] = 0x00e9;
mapDataPCL [1] [0x8f - rangeMin] = 0x00e8;
mapDataPCL [1] [0x90 - rangeMin] = 0x00ea;
mapDataPCL [1] [0x91 - rangeMin] = 0x00eb;
mapDataPCL [1] [0x92 - rangeMin] = 0x00ed;
mapDataPCL [1] [0x93 - rangeMin] = 0x00ec;
mapDataPCL [1] [0x94 - rangeMin] = 0x00ee;
mapDataPCL [1] [0x95 - rangeMin] = 0x00ef;
mapDataPCL [1] [0x96 - rangeMin] = 0x00f1;
mapDataPCL [1] [0x97 - rangeMin] = 0x00f3;
mapDataPCL [1] [0x98 - rangeMin] = 0x00f2;
mapDataPCL [1] [0x99 - rangeMin] = 0x00f4;
mapDataPCL [1] [0x9a - rangeMin] = 0x00f6;
mapDataPCL [1] [0x9b - rangeMin] = 0x00f5;
mapDataPCL [1] [0x9c - rangeMin] = 0x00fa;
mapDataPCL [1] [0x9d - rangeMin] = 0x00f9;
mapDataPCL [1] [0x9e - rangeMin] = 0x00fb;
mapDataPCL [1] [0x9f - rangeMin] = 0x00fc;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataPCL[2][0xa0 - rangeMin] = 0x2020;
mapDataPCL[2][0xa1 - rangeMin] = 0x00b0;
mapDataPCL[2][0xa2 - rangeMin] = 0x00a2;
mapDataPCL[2][0xa3 - rangeMin] = 0x00a3;
mapDataPCL[2][0xa4 - rangeMin] = 0x00a7;
mapDataPCL[2][0xa5 - rangeMin] = 0x2022;
mapDataPCL[2][0xa6 - rangeMin] = 0x00b6;
mapDataPCL[2][0xa7 - rangeMin] = 0x00df;
mapDataPCL[2][0xa8 - rangeMin] = 0x00ae;
mapDataPCL[2][0xa9 - rangeMin] = 0x00a9;
mapDataPCL[2][0xaa - rangeMin] = 0x2122;
mapDataPCL[2][0xab - rangeMin] = 0x00b4;
mapDataPCL[2][0xac - rangeMin] = 0x00a8;
mapDataPCL[2][0xad - rangeMin] = 0x2260;
mapDataPCL[2][0xae - rangeMin] = 0x00c6;
mapDataPCL[2][0xaf - rangeMin] = 0x00d8;
mapDataPCL[2][0xb0 - rangeMin] = 0x221e;
mapDataPCL[2][0xb1 - rangeMin] = 0x00b1;
mapDataPCL[2][0xb2 - rangeMin] = 0x2264;
mapDataPCL[2][0xb3 - rangeMin] = 0x2265;
mapDataPCL[2][0xb4 - rangeMin] = 0x00a5;
mapDataPCL[2][0xb5 - rangeMin] = 0x00b5;
mapDataPCL[2][0xb6 - rangeMin] = 0x2202;
mapDataPCL[2][0xb7 - rangeMin] = 0x2211;
mapDataPCL[2][0xb8 - rangeMin] = 0x220f;
mapDataPCL[2][0xb9 - rangeMin] = 0x03c0;
mapDataPCL[2][0xba - rangeMin] = 0x222b;
mapDataPCL[2][0xbb - rangeMin] = 0x00aa;
mapDataPCL[2][0xbc - rangeMin] = 0x00ba;
mapDataPCL[2][0xbd - rangeMin] = 0x2126;
mapDataPCL[2][0xbe - rangeMin] = 0x00e6;
mapDataPCL[2][0xbf - rangeMin] = 0x00f8;
mapDataPCL[2][0xc0 - rangeMin] = 0x00bf;
mapDataPCL[2][0xc1 - rangeMin] = 0x00a1;
mapDataPCL[2][0xc2 - rangeMin] = 0x00ac;
mapDataPCL[2][0xc3 - rangeMin] = 0x221a;
mapDataPCL[2][0xc4 - rangeMin] = 0x0192;
mapDataPCL[2][0xc5 - rangeMin] = 0x2248;
mapDataPCL[2][0xc6 - rangeMin] = 0x2206;
mapDataPCL[2][0xc7 - rangeMin] = 0x00ab;
mapDataPCL[2][0xc8 - rangeMin] = 0x00bb;
mapDataPCL[2][0xc9 - rangeMin] = 0x2026;
mapDataPCL[2][0xca - rangeMin] = 0x00a0;
mapDataPCL[2][0xcb - rangeMin] = 0x00c0;
mapDataPCL[2][0xcc - rangeMin] = 0x00c3;
mapDataPCL[2][0xcd - rangeMin] = 0x00d5;
mapDataPCL[2][0xce - rangeMin] = 0x0152;
mapDataPCL[2][0xcf - rangeMin] = 0x0153;
mapDataPCL[2][0xd0 - rangeMin] = 0x2013;
mapDataPCL[2][0xd1 - rangeMin] = 0x2014;
mapDataPCL[2][0xd2 - rangeMin] = 0x201c;
mapDataPCL[2][0xd3 - rangeMin] = 0x201d;
mapDataPCL[2][0xd4 - rangeMin] = 0x2018;
mapDataPCL[2][0xd5 - rangeMin] = 0x2019;
mapDataPCL[2][0xd6 - rangeMin] = 0x00f7;
mapDataPCL[2][0xd7 - rangeMin] = 0x25ca;
mapDataPCL[2][0xd8 - rangeMin] = 0x00ff;
mapDataPCL[2][0xd9 - rangeMin] = 0x0178;
mapDataPCL[2][0xda - rangeMin] = 0x2215;
mapDataPCL[2][0xdb - rangeMin] = 0x20ac;
mapDataPCL[2][0xdc - rangeMin] = 0x2039;
mapDataPCL[2][0xdd - rangeMin] = 0x203a;
mapDataPCL[2][0xde - rangeMin] = 0xf001;
mapDataPCL[2][0xdf - rangeMin] = 0xf002;
mapDataPCL[2][0xe0 - rangeMin] = 0x2021;
mapDataPCL[2][0xe1 - rangeMin] = 0x2219;
mapDataPCL[2][0xe2 - rangeMin] = 0x201a;
mapDataPCL[2][0xe3 - rangeMin] = 0x201e;
mapDataPCL[2][0xe4 - rangeMin] = 0x2030;
mapDataPCL[2][0xe5 - rangeMin] = 0x00c2;
mapDataPCL[2][0xe6 - rangeMin] = 0x00ca;
mapDataPCL[2][0xe7 - rangeMin] = 0x00c1;
mapDataPCL[2][0xe8 - rangeMin] = 0x00cb;
mapDataPCL[2][0xe9 - rangeMin] = 0x00c8;
mapDataPCL[2][0xea - rangeMin] = 0x00cd;
mapDataPCL[2][0xeb - rangeMin] = 0x00ce;
mapDataPCL[2][0xec - rangeMin] = 0x00cf;
mapDataPCL[2][0xed - rangeMin] = 0x00cc;
mapDataPCL[2][0xee - rangeMin] = 0x00d3;
mapDataPCL[2][0xef - rangeMin] = 0x00d4;
mapDataPCL[2][0xf0 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL[2][0xf1 - rangeMin] = 0x00d2;
mapDataPCL[2][0xf2 - rangeMin] = 0x00da;
mapDataPCL[2][0xf3 - rangeMin] = 0x00db;
mapDataPCL[2][0xf4 - rangeMin] = 0x00d9;
mapDataPCL[2][0xf5 - rangeMin] = 0x0131;
mapDataPCL[2][0xf6 - rangeMin] = 0x02c6;
mapDataPCL[2][0xf7 - rangeMin] = 0x02dc;
mapDataPCL[2][0xf8 - rangeMin] = 0x02c9;
mapDataPCL[2][0xf9 - rangeMin] = 0x02d8;
mapDataPCL[2][0xfa - rangeMin] = 0x02d9;
mapDataPCL[2][0xfb - rangeMin] = 0x02da;
mapDataPCL[2][0xfc - rangeMin] = 0x00b8;
mapDataPCL[2][0xfd - rangeMin] = 0x02dd;
mapDataPCL[2][0xfe - rangeMin] = 0x02db;
mapDataPCL[2][0xff - rangeMin] = 0x02c7;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 0 V //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 10V //
// Kind1 342 //
// Name PC-864 Latin/Arabic //
// //
// Note that the 'Laserjet' table (as per output on LaserJet M553x, //
// M475dn and 1320n0 is quite different from the 'strict' table (as //
// defined by Wikipedia / Unicode. //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_10V()
{
const eSymSetMapId mapId = eSymSetMapId.map_10V;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x01, 0x1f
},
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd[0][i - rangeMin] = i;
}
//----------------------------------------------------------------//
mapDataPCL [0] [0x01 - rangeMin] = 0x263a;
mapDataPCL [0] [0x02 - rangeMin] = 0x266a;
mapDataPCL [0] [0x03 - rangeMin] = 0x266b;
mapDataPCL [0] [0x04 - rangeMin] = 0x263c;
mapDataPCL [0] [0x05 - rangeMin] = 0x2550;
mapDataPCL [0] [0x06 - rangeMin] = 0x2551;
mapDataPCL [0] [0x07 - rangeMin] = 0x256c;
mapDataPCL [0] [0x08 - rangeMin] = 0x2563;
mapDataPCL [0] [0x09 - rangeMin] = 0x2566;
mapDataPCL [0] [0x0a - rangeMin] = 0x2560;
mapDataPCL [0] [0x0b - rangeMin] = 0x2569;
mapDataPCL [0] [0x0c - rangeMin] = 0x2557;
mapDataPCL [0] [0x0d - rangeMin] = 0x2554;
mapDataPCL [0] [0x0e - rangeMin] = 0x255a;
mapDataPCL [0] [0x0f - rangeMin] = 0x255d;
mapDataPCL [0] [0x10 - rangeMin] = 0x25ba;
mapDataPCL [0] [0x11 - rangeMin] = 0x25c4;
mapDataPCL [0] [0x12 - rangeMin] = 0x2195;
mapDataPCL [0] [0x13 - rangeMin] = 0x203c;
mapDataPCL [0] [0x14 - rangeMin] = 0x00b6;
mapDataPCL [0] [0x15 - rangeMin] = 0x00a7;
mapDataPCL [0] [0x16 - rangeMin] = 0x25ac;
mapDataPCL [0] [0x17 - rangeMin] = 0x21a8;
mapDataPCL [0] [0x18 - rangeMin] = 0x2191;
mapDataPCL [0] [0x19 - rangeMin] = 0x2193;
mapDataPCL [0] [0x1a - rangeMin] = 0x2192;
mapDataPCL [0] [0x1b - rangeMin] = 0x2190;
mapDataPCL [0] [0x1c - rangeMin] = 0x221f;
mapDataPCL [0] [0x1d - rangeMin] = 0x2194;
mapDataPCL [0] [0x1e - rangeMin] = 0x25b2;
mapDataPCL [0] [0x1f - rangeMin] = 0x25bc;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [1] [i - rangeMin] = i;
}
mapDataStd [1] [0x25 - rangeMin] = 0x066a;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
mapDataPCL [1] [0x2a - rangeMin] = 0x066d;
mapDataPCL [1] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [1] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [1] [0x7f - rangeMin] = 0x2302;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataStd [2] [0x80 - rangeMin] = 0x00b0;
mapDataStd [2] [0x81 - rangeMin] = 0x00b7;
mapDataStd [2] [0x82 - rangeMin] = 0x2219;
mapDataStd [2] [0x83 - rangeMin] = 0x221a;
mapDataStd [2] [0x84 - rangeMin] = 0x2592;
mapDataStd [2] [0x85 - rangeMin] = 0x2500;
mapDataStd [2] [0x86 - rangeMin] = 0x2502;
mapDataStd [2] [0x87 - rangeMin] = 0x253c;
mapDataStd [2] [0x88 - rangeMin] = 0x2524;
mapDataStd [2] [0x89 - rangeMin] = 0x252c;
mapDataStd [2] [0x8a - rangeMin] = 0x251c;
mapDataStd [2] [0x8b - rangeMin] = 0x2534;
mapDataStd [2] [0x8c - rangeMin] = 0x2510;
mapDataStd [2] [0x8d - rangeMin] = 0x250c;
mapDataStd [2] [0x8e - rangeMin] = 0x2514;
mapDataStd [2] [0x8f - rangeMin] = 0x2518;
mapDataStd [2] [0x90 - rangeMin] = 0x03b2;
mapDataStd [2] [0x91 - rangeMin] = 0x221e;
mapDataStd [2] [0x92 - rangeMin] = 0x03c6;
mapDataStd [2] [0x93 - rangeMin] = 0x00b1;
mapDataStd [2] [0x94 - rangeMin] = 0x00bd;
mapDataStd [2] [0x95 - rangeMin] = 0x00bc;
mapDataStd [2] [0x96 - rangeMin] = 0x2248;
mapDataStd [2] [0x97 - rangeMin] = 0x00ab;
mapDataStd [2] [0x98 - rangeMin] = 0x00bb;
mapDataStd [2] [0x99 - rangeMin] = 0xfef7;
mapDataStd [2] [0x9a - rangeMin] = 0xfef8;
mapDataStd [2] [0x9b - rangeMin] = 0xffff;
mapDataStd [2] [0x9c - rangeMin] = 0xffff;
mapDataStd [2] [0x9d - rangeMin] = 0xfefb;
mapDataStd [2] [0x9e - rangeMin] = 0xfefc;
mapDataStd [2] [0x9f - rangeMin] = 0xffff;
mapDataStd [2] [0xa0 - rangeMin] = 0x00a0;
mapDataStd [2] [0xa1 - rangeMin] = 0x00ad;
mapDataStd [2] [0xa2 - rangeMin] = 0xfe82;
mapDataStd [2] [0xa3 - rangeMin] = 0x00a3;
mapDataStd [2] [0xa4 - rangeMin] = 0x00a4;
mapDataStd [2] [0xa5 - rangeMin] = 0xfe84;
mapDataStd [2] [0xa6 - rangeMin] = 0xffff;
mapDataStd [2] [0xa7 - rangeMin] = 0x20ac;
mapDataStd [2] [0xa8 - rangeMin] = 0xfe8e;
mapDataStd [2] [0xa9 - rangeMin] = 0xfe8f;
mapDataStd [2] [0xaa - rangeMin] = 0xfe95;
mapDataStd [2] [0xab - rangeMin] = 0xfe99;
mapDataStd [2] [0xac - rangeMin] = 0x060c;
mapDataStd [2] [0xad - rangeMin] = 0xfe9d;
mapDataStd [2] [0xae - rangeMin] = 0xfea1;
mapDataStd [2] [0xaf - rangeMin] = 0xfea5;
mapDataStd [2] [0xb0 - rangeMin] = 0x0660;
mapDataStd [2] [0xb1 - rangeMin] = 0x0661;
mapDataStd [2] [0xb2 - rangeMin] = 0x0662;
mapDataStd [2] [0xb3 - rangeMin] = 0x0663;
mapDataStd [2] [0xb4 - rangeMin] = 0x0664;
mapDataStd [2] [0xb5 - rangeMin] = 0x0665;
mapDataStd [2] [0xb6 - rangeMin] = 0x0666;
mapDataStd [2] [0xb7 - rangeMin] = 0x0667;
mapDataStd [2] [0xb8 - rangeMin] = 0x0668;
mapDataStd [2] [0xb9 - rangeMin] = 0x0669;
mapDataStd [2] [0xba - rangeMin] = 0xfed1;
mapDataStd [2] [0xbb - rangeMin] = 0x061b;
mapDataStd [2] [0xbc - rangeMin] = 0xfeb1;
mapDataStd [2] [0xbd - rangeMin] = 0xfeb5;
mapDataStd [2] [0xbe - rangeMin] = 0xfeb9;
mapDataStd [2] [0xbf - rangeMin] = 0x061f;
mapDataStd [2] [0xc0 - rangeMin] = 0x00a2;
mapDataStd [2] [0xc1 - rangeMin] = 0xfe80;
mapDataStd [2] [0xc2 - rangeMin] = 0xfe81;
mapDataStd [2] [0xc3 - rangeMin] = 0xfe83;
mapDataStd [2] [0xc4 - rangeMin] = 0xfe85;
mapDataStd [2] [0xc5 - rangeMin] = 0xfeca;
mapDataStd [2] [0xc6 - rangeMin] = 0xfe8b;
mapDataStd [2] [0xc7 - rangeMin] = 0xfe8d;
mapDataStd [2] [0xc8 - rangeMin] = 0xfe91;
mapDataStd [2] [0xc9 - rangeMin] = 0xfe93;
mapDataStd [2] [0xca - rangeMin] = 0xfe97;
mapDataStd [2] [0xcb - rangeMin] = 0xfe9b;
mapDataStd [2] [0xcc - rangeMin] = 0xfe9f;
mapDataStd [2] [0xcd - rangeMin] = 0xfea3;
mapDataStd [2] [0xce - rangeMin] = 0xfea7;
mapDataStd [2] [0xcf - rangeMin] = 0xfea9;
mapDataStd [2] [0xd0 - rangeMin] = 0xfeab;
mapDataStd [2] [0xd1 - rangeMin] = 0xfead;
mapDataStd [2] [0xd2 - rangeMin] = 0xfeaf;
mapDataStd [2] [0xd3 - rangeMin] = 0xfeb3;
mapDataStd [2] [0xd4 - rangeMin] = 0xfeb7;
mapDataStd [2] [0xd5 - rangeMin] = 0xfebb;
mapDataStd [2] [0xd6 - rangeMin] = 0xfebf;
mapDataStd [2] [0xd7 - rangeMin] = 0xfec1;
mapDataStd [2] [0xd8 - rangeMin] = 0xfec5;
mapDataStd [2] [0xd9 - rangeMin] = 0xfecb;
mapDataStd [2] [0xda - rangeMin] = 0xfecf;
mapDataStd [2] [0xdb - rangeMin] = 0x00a6;
mapDataStd [2] [0xdc - rangeMin] = 0x00ac;
mapDataStd [2] [0xdd - rangeMin] = 0x00f7;
mapDataStd [2] [0xde - rangeMin] = 0x00d7;
mapDataStd [2] [0xdf - rangeMin] = 0xfec9;
mapDataStd [2] [0xe0 - rangeMin] = 0x0640;
mapDataStd [2] [0xe1 - rangeMin] = 0xfed3;
mapDataStd [2] [0xe2 - rangeMin] = 0xfed7;
mapDataStd [2] [0xe3 - rangeMin] = 0xfedb;
mapDataStd [2] [0xe4 - rangeMin] = 0xfedf;
mapDataStd [2] [0xe5 - rangeMin] = 0xfee3;
mapDataStd [2] [0xe6 - rangeMin] = 0xfee7;
mapDataStd [2] [0xe7 - rangeMin] = 0xfeeb;
mapDataStd [2] [0xe8 - rangeMin] = 0xfeed;
mapDataStd [2] [0xe9 - rangeMin] = 0xfeef;
mapDataStd [2] [0xea - rangeMin] = 0xfef3;
mapDataStd [2] [0xeb - rangeMin] = 0xfebd;
mapDataStd [2] [0xec - rangeMin] = 0xfecc;
mapDataStd [2] [0xed - rangeMin] = 0xfece;
mapDataStd [2] [0xee - rangeMin] = 0xfecd;
mapDataStd [2] [0xef - rangeMin] = 0xfee1;
mapDataStd [2] [0xf0 - rangeMin] = 0xfe7d;
mapDataStd [2] [0xf1 - rangeMin] = 0x0651;
mapDataStd [2] [0xf2 - rangeMin] = 0xfee5;
mapDataStd [2] [0xf3 - rangeMin] = 0xfee9;
mapDataStd [2] [0xf4 - rangeMin] = 0xfeec;
mapDataStd [2] [0xf5 - rangeMin] = 0xfef0;
mapDataStd [2] [0xf6 - rangeMin] = 0xfef2;
mapDataStd [2] [0xf7 - rangeMin] = 0xfed0;
mapDataStd [2] [0xf8 - rangeMin] = 0xfed5;
mapDataStd [2] [0xf9 - rangeMin] = 0xfef5;
mapDataStd [2] [0xfa - rangeMin] = 0xfef6;
mapDataStd [2] [0xfb - rangeMin] = 0xfedd;
mapDataStd [2] [0xfc - rangeMin] = 0xfed9;
mapDataStd [2] [0xfd - rangeMin] = 0xfef1;
mapDataStd [2] [0xfe - rangeMin] = 0x25a0;
mapDataStd [2] [0xff - rangeMin] = 0xffff;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [2] [i] = mapDataStd [2] [i];
}
mapDataPCL[2][0x81 - rangeMin] = 0x2219;
mapDataPCL[2][0x9f - rangeMin] = 0xef0e;
mapDataPCL[2][0xa9 - rangeMin] = 0xef03;
mapDataPCL[2][0xaa - rangeMin] = 0xef04;
mapDataPCL[2][0xab - rangeMin] = 0xef05;
mapDataPCL[2][0xad - rangeMin] = 0xef02;
mapDataPCL[2][0xae - rangeMin] = 0xef07;
mapDataPCL[2][0xaf - rangeMin] = 0xef0a;
mapDataPCL[2][0xba - rangeMin] = 0xef06;
mapDataPCL[2][0xbc - rangeMin] = 0xef35;
mapDataPCL[2][0xbd - rangeMin] = 0xef36;
mapDataPCL[2][0xbe - rangeMin] = 0xef37;
mapDataPCL[2][0xc4 - rangeMin] = 0xef28;
mapDataPCL[2][0xc6 - rangeMin] = 0xef34;
mapDataPCL[2][0xc8 - rangeMin] = 0xef39;
mapDataPCL[2][0xc9 - rangeMin] = 0xef09;
mapDataPCL[2][0xca - rangeMin] = 0xef3a;
mapDataPCL[2][0xcb - rangeMin] = 0xef3b;
mapDataPCL[2][0xcc - rangeMin] = 0xef3d;
mapDataPCL[2][0xcd - rangeMin] = 0xef3e;
mapDataPCL[2][0xce - rangeMin] = 0xef3f;
mapDataPCL[2][0xcf - rangeMin] = 0xef29;
mapDataPCL[2][0xd0 - rangeMin] = 0xef2a;
mapDataPCL[2][0xd1 - rangeMin] = 0xef2b;
mapDataPCL[2][0xd2 - rangeMin] = 0xef2c;
mapDataPCL[2][0xd3 - rangeMin] = 0xef46;
mapDataPCL[2][0xd4 - rangeMin] = 0xef47;
mapDataPCL[2][0xd5 - rangeMin] = 0xef48;
mapDataPCL[2][0xd6 - rangeMin] = 0xef49;
mapDataPCL[2][0xd7 - rangeMin] = 0xef32;
mapDataPCL[2][0xd8 - rangeMin] = 0xef33;
mapDataPCL[2][0xe1 - rangeMin] = 0xef3c;
mapDataPCL[2][0xe2 - rangeMin] = 0xef44;
mapDataPCL[2][0xe3 - rangeMin] = 0xef40;
mapDataPCL[2][0xe4 - rangeMin] = 0xef41;
mapDataPCL[2][0xe5 - rangeMin] = 0xef42;
mapDataPCL[2][0xe6 - rangeMin] = 0xef43;
mapDataPCL[2][0xe8 - rangeMin] = 0xef2d;
mapDataPCL[2][0xea - rangeMin] = 0xef45;
mapDataPCL[2][0xeb - rangeMin] = 0xef38;
mapDataPCL[2][0xef - rangeMin] = 0xef25;
mapDataPCL[2][0xf1 - rangeMin] = 0xfe7c;
mapDataPCL[2][0xf2 - rangeMin] = 0xef26;
mapDataPCL[2][0xf3 - rangeMin] = 0xef08;
mapDataPCL[2][0xf8 - rangeMin] = 0xef27;
mapDataPCL[2][0xfb - rangeMin] = 0xef24;
mapDataPCL[2][0xfc - rangeMin] = 0xef23;
mapDataPCL[2][0xfe - rangeMin] = 0x25aa;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 9 U //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 9U //
// Kind1 309 //
// Name Windows 3.0 Latin 1 (obsolete) //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_9U()
{
const eSymSetMapId mapId = eSymSetMapId.map_9U;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0x9f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [0] [i - rangeMin] = i;
}
mapDataPCL [0] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [0] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataPCL [1] [0x80 - rangeMin] = 0x20ac;
mapDataPCL [1] [0x81 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x82 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x83 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x84 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x85 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x86 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x87 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x88 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x89 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x8a - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x8b - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x8c - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x8d - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x8e - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x8f - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x90 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x91 - rangeMin] = 0x2018;
mapDataPCL [1] [0x92 - rangeMin] = 0x2019;
mapDataPCL [1] [0x93 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x94 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x95 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x96 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x97 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x98 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x99 - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x9a - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x9b - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x9c - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x9d - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x9e - rangeMin] = 0xffff; //<not a character> //
mapDataPCL [1] [0x9f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataPCL [1] [i];
}
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [2] [i - rangeMin] = i;
}
mapDataPCL [2] [0xaf - rangeMin] = 0x02c9;
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 9 E //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 9E //
// Kind1 293 //
// Name Windows Latin 2 //
// Code Page 1250 //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_9E()
{
const eSymSetMapId mapId = eSymSetMapId.map_9E;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0x9f
},
new UInt16 [2] {
0xa0, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataStd = new UInt16 [rangeCt] [];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataStd [i] = new UInt16 [rangeSizes [i]];
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataStd [0] [i - rangeMin] = i;
}
mapDataStd [0] [0x7f - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [0] [i] = mapDataStd [0] [i];
}
mapDataPCL [0] [0x7f - rangeMin] = 0x2592;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
mapDataStd [1] [0x80 - rangeMin] = 0x20ac;
mapDataStd [1] [0x81 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x82 - rangeMin] = 0x201a;
mapDataStd [1] [0x83 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x84 - rangeMin] = 0x201e;
mapDataStd [1] [0x85 - rangeMin] = 0x2026;
mapDataStd [1] [0x86 - rangeMin] = 0x2020;
mapDataStd [1] [0x87 - rangeMin] = 0x2021;
mapDataStd [1] [0x88 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x89 - rangeMin] = 0x2030;
mapDataStd [1] [0x8a - rangeMin] = 0x0160;
mapDataStd [1] [0x8b - rangeMin] = 0x2039;
mapDataStd [1] [0x8c - rangeMin] = 0x015a;
mapDataStd [1] [0x8d - rangeMin] = 0x0164;
mapDataStd [1] [0x8e - rangeMin] = 0x017d;
mapDataStd [1] [0x8f - rangeMin] = 0x0179;
mapDataStd [1] [0x90 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x91 - rangeMin] = 0x2018;
mapDataStd [1] [0x92 - rangeMin] = 0x2019;
mapDataStd [1] [0x93 - rangeMin] = 0x201c;
mapDataStd [1] [0x94 - rangeMin] = 0x201d;
mapDataStd [1] [0x95 - rangeMin] = 0x2022;
mapDataStd [1] [0x96 - rangeMin] = 0x2013;
mapDataStd [1] [0x97 - rangeMin] = 0x2014;
mapDataStd [1] [0x98 - rangeMin] = 0xffff; //<not a character> //
mapDataStd [1] [0x99 - rangeMin] = 0x2122;
mapDataStd [1] [0x9a - rangeMin] = 0x0161;
mapDataStd [1] [0x9b - rangeMin] = 0x203a;
mapDataStd [1] [0x9c - rangeMin] = 0x015b;
mapDataStd [1] [0x9d - rangeMin] = 0x0165;
mapDataStd [1] [0x9e - rangeMin] = 0x017e;
mapDataStd [1] [0x9f - rangeMin] = 0x017a;
//----------------------------------------------------------------//
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [1] [i] = mapDataStd [1] [i];
}
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [2] [0];
rangeMax = rangeData [2] [1];
rangeSize = rangeSizes [2];
mapDataStd[2][0xa0 - rangeMin] = 0x00a0;
mapDataStd[2][0xa1 - rangeMin] = 0x02c7;
mapDataStd[2][0xa2 - rangeMin] = 0x02d8;
mapDataStd[2][0xa3 - rangeMin] = 0x0141;
mapDataStd[2][0xa4 - rangeMin] = 0x00a4;
mapDataStd[2][0xa5 - rangeMin] = 0x0104;
mapDataStd[2][0xa6 - rangeMin] = 0x00a6;
mapDataStd[2][0xa7 - rangeMin] = 0x00a7;
mapDataStd[2][0xa8 - rangeMin] = 0x00a8;
mapDataStd[2][0xa9 - rangeMin] = 0x00a9;
mapDataStd[2][0xaa - rangeMin] = 0x015e;
mapDataStd[2][0xab - rangeMin] = 0x00ab;
mapDataStd[2][0xac - rangeMin] = 0x00ac;
mapDataStd[2][0xad - rangeMin] = 0x00ad;
mapDataStd[2][0xae - rangeMin] = 0x00ae;
mapDataStd[2][0xaf - rangeMin] = 0x017b;
mapDataStd[2][0xb0 - rangeMin] = 0x00b0;
mapDataStd[2][0xb1 - rangeMin] = 0x00b1;
mapDataStd[2][0xb2 - rangeMin] = 0x02db;
mapDataStd[2][0xb3 - rangeMin] = 0x0142;
mapDataStd[2][0xb4 - rangeMin] = 0x00b4;
mapDataStd[2][0xb5 - rangeMin] = 0x00b5;
mapDataStd[2][0xb6 - rangeMin] = 0x00b6;
mapDataStd[2][0xb7 - rangeMin] = 0x00b7;
mapDataStd[2][0xb8 - rangeMin] = 0x00b8;
mapDataStd[2][0xb9 - rangeMin] = 0x0105;
mapDataStd[2][0xba - rangeMin] = 0x015f;
mapDataStd[2][0xbb - rangeMin] = 0x00bb;
mapDataStd[2][0xbc - rangeMin] = 0x013d;
mapDataStd[2][0xbd - rangeMin] = 0x02dd;
mapDataStd[2][0xbe - rangeMin] = 0x013e;
mapDataStd[2][0xbf - rangeMin] = 0x017c;
mapDataStd[2][0xc0 - rangeMin] = 0x0154;
mapDataStd[2][0xc1 - rangeMin] = 0x00c1;
mapDataStd[2][0xc2 - rangeMin] = 0x00c2;
mapDataStd[2][0xc3 - rangeMin] = 0x0102;
mapDataStd[2][0xc4 - rangeMin] = 0x00c4;
mapDataStd[2][0xc5 - rangeMin] = 0x0139;
mapDataStd[2][0xc6 - rangeMin] = 0x0106;
mapDataStd[2][0xc7 - rangeMin] = 0x00c7;
mapDataStd[2][0xc8 - rangeMin] = 0x010c;
mapDataStd[2][0xc9 - rangeMin] = 0x00c9;
mapDataStd[2][0xca - rangeMin] = 0x0118;
mapDataStd[2][0xcb - rangeMin] = 0x00cb;
mapDataStd[2][0xcc - rangeMin] = 0x011a;
mapDataStd[2][0xcd - rangeMin] = 0x00cd;
mapDataStd[2][0xce - rangeMin] = 0x00ce;
mapDataStd[2][0xcf - rangeMin] = 0x010e;
mapDataStd[2][0xd0 - rangeMin] = 0x0110;
mapDataStd[2][0xd1 - rangeMin] = 0x0143;
mapDataStd[2][0xd2 - rangeMin] = 0x0147;
mapDataStd[2][0xd3 - rangeMin] = 0x00d3;
mapDataStd[2][0xd4 - rangeMin] = 0x00d4;
mapDataStd[2][0xd5 - rangeMin] = 0x0150;
mapDataStd[2][0xd6 - rangeMin] = 0x00d6;
mapDataStd[2][0xd7 - rangeMin] = 0x00d7;
mapDataStd[2][0xd8 - rangeMin] = 0x0158;
mapDataStd[2][0xd9 - rangeMin] = 0x016e;
mapDataStd[2][0xda - rangeMin] = 0x00da;
mapDataStd[2][0xdb - rangeMin] = 0x0170;
mapDataStd[2][0xdc - rangeMin] = 0x00dc;
mapDataStd[2][0xdd - rangeMin] = 0x00dd;
mapDataStd[2][0xde - rangeMin] = 0x0162;
mapDataStd[2][0xdf - rangeMin] = 0x00df;
mapDataStd[2][0xe0 - rangeMin] = 0x0155;
mapDataStd[2][0xe1 - rangeMin] = 0x00e1;
mapDataStd[2][0xe2 - rangeMin] = 0x00e2;
mapDataStd[2][0xe3 - rangeMin] = 0x0103;
mapDataStd[2][0xe4 - rangeMin] = 0x00e4;
mapDataStd[2][0xe5 - rangeMin] = 0x013a;
mapDataStd[2][0xe6 - rangeMin] = 0x0107;
mapDataStd[2][0xe7 - rangeMin] = 0x00e7;
mapDataStd[2][0xe8 - rangeMin] = 0x010d;
mapDataStd[2][0xe9 - rangeMin] = 0x00e9;
mapDataStd[2][0xea - rangeMin] = 0x0119;
mapDataStd[2][0xeb - rangeMin] = 0x00eb;
mapDataStd[2][0xec - rangeMin] = 0x011b;
mapDataStd[2][0xed - rangeMin] = 0x00ed;
mapDataStd[2][0xee - rangeMin] = 0x00ee;
mapDataStd[2][0xef - rangeMin] = 0x010f;
mapDataStd[2][0xf0 - rangeMin] = 0x0111;
mapDataStd[2][0xf1 - rangeMin] = 0x0144;
mapDataStd[2][0xf2 - rangeMin] = 0x0148;
mapDataStd[2][0xf3 - rangeMin] = 0x00f3;
mapDataStd[2][0xf4 - rangeMin] = 0x00f4;
mapDataStd[2][0xf5 - rangeMin] = 0x0151;
mapDataStd[2][0xf6 - rangeMin] = 0x00f6;
mapDataStd[2][0xf7 - rangeMin] = 0x00f7;
mapDataStd[2][0xf8 - rangeMin] = 0x0159;
mapDataStd[2][0xf9 - rangeMin] = 0x016f;
mapDataStd[2][0xfa - rangeMin] = 0x00fa;
mapDataStd[2][0xfb - rangeMin] = 0x0171;
mapDataStd[2][0xfc - rangeMin] = 0x00fc;
mapDataStd[2][0xfd - rangeMin] = 0x00fd;
mapDataStd[2][0xfe - rangeMin] = 0x0163;
mapDataStd[2][0xff - rangeMin] = 0x02d9;
for (UInt16 i = 0; i < rangeSize; i++)
{
mapDataPCL [2] [i] = mapDataStd [2] [i];
}
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
mapDataStd,
mapDataPCL));
}
//--------------------------------------------------------------------//
// M e t h o d //
// u n i c o d e M a p _ 1 2 G //
//--------------------------------------------------------------------//
// //
// Maps characters in symbol set to Unicode (UCS-2) code-points. //
// //
// ID 10G //
// Kind1 391 //
// Name PC-8 Latin/Greek //
// //
//--------------------------------------------------------------------//
private static void unicodeMap_12G()
{
const eSymSetMapId mapId = eSymSetMapId.map_12G;
const Int32 rangeCt = 3;
UInt16 [] [] rangeData = new UInt16 [rangeCt] []
{
new UInt16 [2] {
0x01, 0x1f
},
new UInt16 [2] {
0x20, 0x7f
},
new UInt16 [2] {
0x80, 0xff
}
};
UInt16 [] rangeSizes = new UInt16 [rangeCt];
UInt16 [] [] mapDataPCL = new UInt16 [rangeCt] [];
UInt16 rangeMin,
rangeMax,
rangeSize;
//----------------------------------------------------------------//
for (Int32 i = 0; i < rangeCt; i++)
{
rangeSizes [i] = (UInt16)(rangeData [i] [1] -
rangeData [i] [0] + 1);
}
for (Int32 i = 0; i < rangeCt; i++)
{
mapDataPCL [i] = new UInt16 [rangeSizes [i]];
}
//----------------------------------------------------------------//
// //
// Range 0 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [0] [0];
rangeMax = rangeData [0] [1];
rangeSize = rangeSizes [0];
mapDataPCL [0] [0x01 - rangeMin] = 0x263a;
mapDataPCL [0] [0x02 - rangeMin] = 0x263b;
mapDataPCL [0] [0x03 - rangeMin] = 0x2665;
mapDataPCL [0] [0x04 - rangeMin] = 0x2666;
mapDataPCL [0] [0x05 - rangeMin] = 0x2663;
mapDataPCL [0] [0x06 - rangeMin] = 0x2660;
mapDataPCL [0] [0x07 - rangeMin] = 0x2022;
mapDataPCL [0] [0x08 - rangeMin] = 0x25d8;
mapDataPCL [0] [0x09 - rangeMin] = 0x25cb;
mapDataPCL [0] [0x0a - rangeMin] = 0x25d9;
mapDataPCL [0] [0x0b - rangeMin] = 0x2642;
mapDataPCL [0] [0x0c - rangeMin] = 0x2640;
mapDataPCL [0] [0x0d - rangeMin] = 0x266a;
mapDataPCL [0] [0x0e - rangeMin] = 0x266b;
mapDataPCL [0] [0x0f - rangeMin] = 0x263c;
mapDataPCL [0] [0x10 - rangeMin] = 0x25ba;
mapDataPCL [0] [0x11 - rangeMin] = 0x25c4;
mapDataPCL [0] [0x12 - rangeMin] = 0x2195;
mapDataPCL [0] [0x13 - rangeMin] = 0x203c;
mapDataPCL [0] [0x14 - rangeMin] = 0x00b6;
mapDataPCL [0] [0x15 - rangeMin] = 0x00a7;
mapDataPCL [0] [0x16 - rangeMin] = 0x25ac;
mapDataPCL [0] [0x17 - rangeMin] = 0x21a8;
mapDataPCL [0] [0x18 - rangeMin] = 0x2191;
mapDataPCL [0] [0x19 - rangeMin] = 0x2193;
mapDataPCL [0] [0x1a - rangeMin] = 0x2192;
mapDataPCL [0] [0x1b - rangeMin] = 0x2190;
mapDataPCL [0] [0x1c - rangeMin] = 0x221f;
mapDataPCL [0] [0x1d - rangeMin] = 0x2194;
mapDataPCL [0] [0x1e - rangeMin] = 0x25b2;
mapDataPCL [0] [0x1f - rangeMin] = 0x25bc;
//----------------------------------------------------------------//
// //
// Range 1 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData [1] [0];
rangeMax = rangeData [1] [1];
rangeSize = rangeSizes [1];
for (UInt16 i = rangeMin; i <= rangeMax; i++)
{
mapDataPCL [1] [i - rangeMin] = i;
}
mapDataPCL [1] [0x5e - rangeMin] = 0x02c6;
mapDataPCL [1] [0x7e - rangeMin] = 0x02dc;
mapDataPCL [1] [0x7f - rangeMin] = 0x2302;
//----------------------------------------------------------------//
// //
// Range 2 //
// //
//----------------------------------------------------------------//
rangeMin = rangeData[2][0];
rangeMax = rangeData[2][1];
rangeSize = rangeSizes[2];
mapDataPCL[2][0x80 - rangeMin] = 0x0391;
mapDataPCL[2][0x81 - rangeMin] = 0x0392;
mapDataPCL[2][0x82 - rangeMin] = 0x0393;
mapDataPCL[2][0x83 - rangeMin] = 0x0394;
mapDataPCL[2][0x84 - rangeMin] = 0x0395;
mapDataPCL[2][0x85 - rangeMin] = 0x0396;
mapDataPCL[2][0x86 - rangeMin] = 0x0397;
mapDataPCL[2][0x87 - rangeMin] = 0x0398;
mapDataPCL[2][0x88 - rangeMin] = 0x0399;
mapDataPCL[2][0x89 - rangeMin] = 0x039a;
mapDataPCL[2][0x8a - rangeMin] = 0x039b;
mapDataPCL[2][0x8b - rangeMin] = 0x039c;
mapDataPCL[2][0x8c - rangeMin] = 0x039d;
mapDataPCL[2][0x8d - rangeMin] = 0x039e;
mapDataPCL[2][0x8e - rangeMin] = 0x039f;
mapDataPCL[2][0x8f - rangeMin] = 0x03a0;
mapDataPCL[2][0x90 - rangeMin] = 0x03a1;
mapDataPCL[2][0x91 - rangeMin] = 0x03a3;
mapDataPCL[2][0x92 - rangeMin] = 0x03a4;
mapDataPCL[2][0x93 - rangeMin] = 0x03a5;
mapDataPCL[2][0x94 - rangeMin] = 0x03a6;
mapDataPCL[2][0x95 - rangeMin] = 0x03a7;
mapDataPCL[2][0x96 - rangeMin] = 0x03a8;
mapDataPCL[2][0x97 - rangeMin] = 0x03a9;
mapDataPCL[2][0x98 - rangeMin] = 0x03b1;
mapDataPCL[2][0x99 - rangeMin] = 0x03b2;
mapDataPCL[2][0x9a - rangeMin] = 0x03b3;
mapDataPCL[2][0x9b - rangeMin] = 0x03b4;
mapDataPCL[2][0x9c - rangeMin] = 0x03b5;
mapDataPCL[2][0x9d - rangeMin] = 0x03b6;
mapDataPCL[2][0x9e - rangeMin] = 0x03b7;
mapDataPCL[2][0x9f - rangeMin] = 0x03b8;
mapDataPCL[2][0xa0 - rangeMin] = 0x03b9;
mapDataPCL[2][0xa1 - rangeMin] = 0x03ba;
mapDataPCL[2][0xa2 - rangeMin] = 0x03bb;
mapDataPCL[2][0xa3 - rangeMin] = 0x03bc;
mapDataPCL[2][0xa4 - rangeMin] = 0x03bd;
mapDataPCL[2][0xa5 - rangeMin] = 0x03be;
mapDataPCL[2][0xa6 - rangeMin] = 0x03bf;
mapDataPCL[2][0xa7 - rangeMin] = 0x03c0;
mapDataPCL[2][0xa8 - rangeMin] = 0x03c1;
mapDataPCL[2][0xa9 - rangeMin] = 0x03c3;
mapDataPCL[2][0xaa - rangeMin] = 0x03c2;
mapDataPCL[2][0xab - rangeMin] = 0x03c4;
mapDataPCL[2][0xac - rangeMin] = 0x03c5;
mapDataPCL[2][0xad - rangeMin] = 0x03c6;
mapDataPCL[2][0xae - rangeMin] = 0x03c7;
mapDataPCL[2][0xaf - rangeMin] = 0x03c8;
mapDataPCL[2][0xb0 - rangeMin] = 0x2591;
mapDataPCL[2][0xb1 - rangeMin] = 0x2592;
mapDataPCL[2][0xb2 - rangeMin] = 0x2593;
mapDataPCL[2][0xb3 - rangeMin] = 0x2502;
mapDataPCL[2][0xb4 - rangeMin] = 0x2524;
mapDataPCL[2][0xb5 - rangeMin] = 0x2561;
mapDataPCL[2][0xb6 - rangeMin] = 0x2562;
mapDataPCL[2][0xb7 - rangeMin] = 0x2556;
mapDataPCL[2][0xb8 - rangeMin] = 0x2555;
mapDataPCL[2][0xb9 - rangeMin] = 0x2563;
mapDataPCL[2][0xba - rangeMin] = 0x2551;
mapDataPCL[2][0xbb - rangeMin] = 0x2557;
mapDataPCL[2][0xbc - rangeMin] = 0x255d;
mapDataPCL[2][0xbd - rangeMin] = 0x255c;
mapDataPCL[2][0xbe - rangeMin] = 0x255b;
mapDataPCL[2][0xbf - rangeMin] = 0x2510;
mapDataPCL[2][0xc0 - rangeMin] = 0x2514;
mapDataPCL[2][0xc1 - rangeMin] = 0x2534;
mapDataPCL[2][0xc2 - rangeMin] = 0x252c;
mapDataPCL[2][0xc3 - rangeMin] = 0x251c;
mapDataPCL[2][0xc4 - rangeMin] = 0x2500;
mapDataPCL[2][0xc5 - rangeMin] = 0x253c;
mapDataPCL[2][0xc6 - rangeMin] = 0x255e;
mapDataPCL[2][0xc7 - rangeMin] = 0x255f;
mapDataPCL[2][0xc8 - rangeMin] = 0x255a;
mapDataPCL[2][0xc9 - rangeMin] = 0x2554;
mapDataPCL[2][0xca - rangeMin] = 0x2569;
mapDataPCL[2][0xcb - rangeMin] = 0x2566;
mapDataPCL[2][0xcc - rangeMin] = 0x2560;
mapDataPCL[2][0xcd - rangeMin] = 0x2550;
mapDataPCL[2][0xce - rangeMin] = 0x256c;
mapDataPCL[2][0xcf - rangeMin] = 0x2567;
mapDataPCL[2][0xd0 - rangeMin] = 0x2568;
mapDataPCL[2][0xd1 - rangeMin] = 0x2564;
mapDataPCL[2][0xd2 - rangeMin] = 0x2565;
mapDataPCL[2][0xd3 - rangeMin] = 0x2559;
mapDataPCL[2][0xd4 - rangeMin] = 0x2558;
mapDataPCL[2][0xd5 - rangeMin] = 0x2552;
mapDataPCL[2][0xd6 - rangeMin] = 0x2553;
mapDataPCL[2][0xd7 - rangeMin] = 0x256b;
mapDataPCL[2][0xd8 - rangeMin] = 0x256a;
mapDataPCL[2][0xd9 - rangeMin] = 0x2518;
mapDataPCL[2][0xda - rangeMin] = 0x250c;
mapDataPCL[2][0xdb - rangeMin] = 0x2588;
mapDataPCL[2][0xdc - rangeMin] = 0x2584;
mapDataPCL[2][0xdd - rangeMin] = 0x258c;
mapDataPCL[2][0xde - rangeMin] = 0x2590;
mapDataPCL[2][0xdf - rangeMin] = 0x2580;
mapDataPCL[2][0xe0 - rangeMin] = 0x03c9;
mapDataPCL[2][0xe1 - rangeMin] = 0x03ac;
mapDataPCL[2][0xe2 - rangeMin] = 0x03ad;
mapDataPCL[2][0xe3 - rangeMin] = 0x03ae;
mapDataPCL[2][0xe4 - rangeMin] = 0x03ca;
mapDataPCL[2][0xe5 - rangeMin] = 0x03af;
mapDataPCL[2][0xe6 - rangeMin] = 0x03cc;
mapDataPCL[2][0xe7 - rangeMin] = 0x03cd;
mapDataPCL[2][0xe8 - rangeMin] = 0x03cb;
mapDataPCL[2][0xe9 - rangeMin] = 0x03ce;
mapDataPCL[2][0xea - rangeMin] = 0x03a9;
mapDataPCL[2][0xeb - rangeMin] = 0x03b4;
mapDataPCL[2][0xec - rangeMin] = 0x221e;
mapDataPCL[2][0xed - rangeMin] = 0x03c6;
mapDataPCL[2][0xee - rangeMin] = 0x03b5;
mapDataPCL[2][0xef - rangeMin] = 0x2229;
mapDataPCL[2][0xf0 - rangeMin] = 0x2261;
mapDataPCL[2][0xf1 - rangeMin] = 0x00b1;
mapDataPCL[2][0xf2 - rangeMin] = 0x2265;
mapDataPCL[2][0xf3 - rangeMin] = 0x2264;
mapDataPCL[2][0xf4 - rangeMin] = 0x2320;
mapDataPCL[2][0xf5 - rangeMin] = 0x2321;
mapDataPCL[2][0xf6 - rangeMin] = 0x00f7;
mapDataPCL[2][0xf7 - rangeMin] = 0x2248;
mapDataPCL[2][0xf8 - rangeMin] = 0x00b0;
mapDataPCL[2][0xf9 - rangeMin] = 0x2219;
mapDataPCL[2][0xfa - rangeMin] = 0x00b7;
mapDataPCL[2][0xfb - rangeMin] = 0x221a;
mapDataPCL[2][0xfc - rangeMin] = 0x207f;
mapDataPCL[2][0xfd - rangeMin] = 0x00b2;
mapDataPCL[2][0xfe - rangeMin] = 0x25aa;
mapDataPCL[2][0xff - rangeMin] = 0xffff; //<not a character> //
//----------------------------------------------------------------//
_sets.Add(new PCLSymSetMap(mapId,
rangeCt,
rangeData,
null,
mapDataPCL));
}