Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Parse klc files

By: a guest on Apr 12th, 2013  |  syntax: C#  |  size: 42.33 KB  |  views: 132  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. using System;
  2. using System.Collections;
  3. using System.Globalization;
  4. using System.IO;
  5. using System.Text;
  6. namespace Microsoft.Globalization.Tools.KeyboardLayoutCreator
  7. {
  8.         internal class KeyboardTextFile
  9.         {
  10.                 private string[] KeyWords = new string[]
  11.                 {
  12.                         "KBD",
  13.                         "VERSION",
  14.                         "COPYRIGHT",
  15.                         "COMPANY",
  16.                         "LOCALEID",
  17.                         "LOCALENAME",
  18.                         "MODIFIERS",
  19.                         "SHIFTSTATE",
  20.                         "ATTRIBUTES",
  21.                         "LAYOUT",
  22.                         "DEADKEY",
  23.                         "LIGATURE",
  24.                         "KEYNAME",
  25.                         "KEYNAME_EXT",
  26.                         "KEYNAME_DEAD",
  27.                         "DESCRIPTIONS",
  28.                         "LANGUAGENAMES",
  29.                         "ENDKBD"
  30.                 };
  31.                 private string m_stFileName;
  32.                 private string m_stFile = "";
  33.                 private string m_stCompany;
  34.                 private string m_stCopyright;
  35.                 private string m_stLocaleId;
  36.                 private string m_stLocaleName;
  37.                 private string m_stVersion;
  38.                 private string m_stName;
  39.                 private string m_stDescription;
  40.                 private ArrayList m_alModifiers = new ArrayList();
  41.                 private ArrayList m_alKeyName = new ArrayList();
  42.                 private ArrayList m_alKeyName_Ext = new ArrayList();
  43.                 private ArrayList m_alKeyName_Dead = new ArrayList();
  44.                 private ArrayList m_alShiftState;
  45.                 private ArrayList m_alLigature;
  46.                 private ArrayList m_alAttributes;
  47.                 private ArrayList m_alDeadKeys;
  48.                 private ArrayList m_alDescriptions;
  49.                 private ArrayList m_alLanguageNames;
  50.                 private SortedList m_slLayout = new SortedList();
  51.                 internal string LOCALEID
  52.                 {
  53.                         get
  54.                         {
  55.                                 if (this.m_stLocaleId == null || this.m_stLocaleId.Length == 0)
  56.                                 {
  57.                                         this.m_stLocaleId = "";
  58.                                         int length = "LOCALEID".Length;
  59.                                         int num = this.m_stFile.IndexOf("LOCALEID");
  60.                                         if (num != -1)
  61.                                         {
  62.                                                 int num2 = this.m_stFile.IndexOf('\r', num + 1);
  63.                                                 if (num2 != -1)
  64.                                                 {
  65.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  66.                                                         this.m_stLocaleId = text.Trim(new char[]
  67.                                                         {
  68.                                                                 ' ',
  69.                                                                 '"'
  70.                                                         });
  71.                                                 }
  72.                                         }
  73.                                         this.m_stLocaleId = "00000000" + this.m_stLocaleId;
  74.                                         this.m_stLocaleId = this.m_stLocaleId.Substring(this.m_stLocaleId.Length - 8);
  75.                                 }
  76.                                 return this.m_stLocaleId;
  77.                         }
  78.                 }
  79.                 internal string LOCALENAME
  80.                 {
  81.                         get
  82.                         {
  83.                                 if (this.m_stLocaleName == null)
  84.                                 {
  85.                                         int length = "LOCALENAME".Length;
  86.                                         int num = this.m_stFile.IndexOf("LOCALENAME");
  87.                                         if (num != -1)
  88.                                         {
  89.                                                 int num2 = this.m_stFile.IndexOf('\r', num + 1);
  90.                                                 if (num2 != -1)
  91.                                                 {
  92.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  93.                                                         this.m_stLocaleName = text.Trim(new char[]
  94.                                                         {
  95.                                                                 ' ',
  96.                                                                 '"'
  97.                                                         });
  98.                                                 }
  99.                                         }
  100.                                         if (this.m_stLocaleName == null)
  101.                                         {
  102.                                                 this.m_stLocaleName = "";
  103.                                         }
  104.                                 }
  105.                                 return this.m_stLocaleName;
  106.                         }
  107.                 }
  108.                 internal string COPYRIGHT
  109.                 {
  110.                         get
  111.                         {
  112.                                 if (this.m_stCopyright == null)
  113.                                 {
  114.                                         int length = "COPYRIGHT".Length;
  115.                                         int num = this.m_stFile.IndexOf("COPYRIGHT");
  116.                                         if (num != -1)
  117.                                         {
  118.                                                 int num2 = this.m_stFile.IndexOf('\r', num + 1);
  119.                                                 if (num2 != -1)
  120.                                                 {
  121.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  122.                                                         this.m_stCopyright = text.Trim(new char[]
  123.                                                         {
  124.                                                                 ' ',
  125.                                                                 '"'
  126.                                                         });
  127.                                                 }
  128.                                         }
  129.                                         if (this.m_stCopyright == null)
  130.                                         {
  131.                                                 this.m_stCopyright = "";
  132.                                         }
  133.                                 }
  134.                                 return this.m_stCopyright;
  135.                         }
  136.                 }
  137.                 internal string COMPANY
  138.                 {
  139.                         get
  140.                         {
  141.                                 if (this.m_stCompany == null)
  142.                                 {
  143.                                         int length = "COMPANY".Length;
  144.                                         int num = this.m_stFile.IndexOf("COMPANY");
  145.                                         if (num != -1)
  146.                                         {
  147.                                                 int num2 = this.m_stFile.IndexOf('\r', num + 1);
  148.                                                 if (num2 != -1)
  149.                                                 {
  150.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  151.                                                         this.m_stCompany = text.Trim(new char[]
  152.                                                         {
  153.                                                                 ' ',
  154.                                                                 '"'
  155.                                                         });
  156.                                                 }
  157.                                         }
  158.                                         if (this.m_stCompany == null)
  159.                                         {
  160.                                                 this.m_stCompany = "";
  161.                                         }
  162.                                 }
  163.                                 return this.m_stCompany;
  164.                         }
  165.                 }
  166.                 internal string VERSION
  167.                 {
  168.                         get
  169.                         {
  170.                                 if (this.m_stVersion == null)
  171.                                 {
  172.                                         int length = "VERSION".Length;
  173.                                         int num = this.m_stFile.IndexOf("VERSION");
  174.                                         if (num != -1)
  175.                                         {
  176.                                                 int num2 = this.m_stFile.IndexOf('\r', num + 1);
  177.                                                 if (num2 != -1)
  178.                                                 {
  179.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  180.                                                         this.m_stVersion = text.Trim(new char[]
  181.                                                         {
  182.                                                                 ' ',
  183.                                                                 '"'
  184.                                                         });
  185.                                                 }
  186.                                         }
  187.                                         if (this.m_stVersion == null)
  188.                                         {
  189.                                                 this.m_stVersion = "";
  190.                                         }
  191.                                 }
  192.                                 return this.m_stVersion;
  193.                         }
  194.                 }
  195.                 internal string NAME
  196.                 {
  197.                         get
  198.                         {
  199.                                 if (this.m_stName == null)
  200.                                 {
  201.                                         this.FillHeaderVariables();
  202.                                 }
  203.                                 return this.m_stName;
  204.                         }
  205.                 }
  206.                 internal string DESCRIPTION
  207.                 {
  208.                         get
  209.                         {
  210.                                 if (this.m_stDescription == null)
  211.                                 {
  212.                                         this.FillHeaderVariables();
  213.                                 }
  214.                                 return this.m_stDescription;
  215.                         }
  216.                 }
  217.                 internal ArrayList MODIFIERS
  218.                 {
  219.                         get
  220.                         {
  221.                                 if (this.m_alModifiers == null || this.m_alModifiers.Count == 0)
  222.                                 {
  223.                                         int length = "MODIFIERS".Length;
  224.                                         int num = this.m_stFile.IndexOf("MODIFIERS");
  225.                                         if (num != -1)
  226.                                         {
  227.                                                 int num2 = this.NextKeyword(num + length);
  228.                                                 if (num2 != -1)
  229.                                                 {
  230.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  231.                                                         do
  232.                                                         {
  233.                                                                 int num3 = text.IndexOf(' ');
  234.                                                                 if (num3 != -1)
  235.                                                                 {
  236.                                                                         this.m_alModifiers.Add(new ValuePair(text.Substring(0, num3 - 1).TrimStart(new char[0]), text.Substring(num3 + 1).Trim(new char[]
  237.                                                                         {
  238.                                                                                 ' ',
  239.                                                                                 '"'
  240.                                                                         })));
  241.                                                                 }
  242.                                                                 text = text.Substring(text.IndexOf('\r') + 2);
  243.                                                         }
  244.                                                         while (text.Length > 0);
  245.                                                 }
  246.                                         }
  247.                                         int arg_E0_0 = this.m_alModifiers.Count;
  248.                                 }
  249.                                 return this.m_alModifiers;
  250.                         }
  251.                 }
  252.                 internal ArrayList SHIFTSTATE
  253.                 {
  254.                         get
  255.                         {
  256.                                 if (this.m_alShiftState == null || this.m_alShiftState.Count == 0)
  257.                                 {
  258.                                         int length = "SHIFTSTATE".Length;
  259.                                         int num = this.m_stFile.IndexOf("SHIFTSTATE");
  260.                                         this.m_alShiftState = new ArrayList();
  261.                                         if (num != -1)
  262.                                         {
  263.                                                 int num2 = this.NextKeyword(num + length);
  264.                                                 if (num2 != -1)
  265.                                                 {
  266.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  267.                                                         string[] array = text.Split(new char[]
  268.                                                         {
  269.                                                                 '\r'
  270.                                                         });
  271.                                                         for (int i = 0; i < array.Length; i++)
  272.                                                         {
  273.                                                                 array[i] = array[i].Trim();
  274.                                                                 if (array[i] != null && array[i].Length > 0)
  275.                                                                 {
  276.                                                                         int num3 = array[i].IndexOf(";");
  277.                                                                         if (num3 != -1 && num3 != 0)
  278.                                                                         {
  279.                                                                                 array[i] = array[i].Substring(0, num3 - 1);
  280.                                                                                 this.m_alShiftState.Add(Convert.ToByte(array[i], Utilities.s_nfi));
  281.                                                                         }
  282.                                                                         else
  283.                                                                         {
  284.                                                                                 this.m_alShiftState.Add(Convert.ToByte(array[i], Utilities.s_nfi));
  285.                                                                         }
  286.                                                                 }
  287.                                                         }
  288.                                                         this.m_alShiftState.TrimToSize();
  289.                                                 }
  290.                                         }
  291.                                         int arg_145_0 = this.m_alShiftState.Count;
  292.                                 }
  293.                                 return this.m_alShiftState;
  294.                         }
  295.                 }
  296.                 internal SortedList LAYOUT
  297.                 {
  298.                         get
  299.                         {
  300.                                 if (this.m_slLayout == null || this.m_slLayout.Count == 0)
  301.                                 {
  302.                                         int length = "LAYOUT".Length;
  303.                                         int num = this.m_stFile.IndexOf("LAYOUT");
  304.                                         if (num != -1)
  305.                                         {
  306.                                                 int num2 = this.NextKeyword(num + length);
  307.                                                 if (num2 != -1)
  308.                                                 {
  309.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  310.                                                         string[] array = text.Split(new char[]
  311.                                                         {
  312.                                                                 '\r'
  313.                                                         });
  314.                                                         for (int i = 0; i < array.Length; i++)
  315.                                                         {
  316.                                                                 array[i] = array[i].Trim();
  317.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  318.                                                                 {
  319.                                                                         string[] array2 = array[i].Split(new char[]
  320.                                                                         {
  321.                                                                                 ' '
  322.                                                                         });
  323.                                                                         if (array2.Length >= 2)
  324.                                                                         {
  325.                                                                                 LayoutRow layoutRow = null;
  326.                                                                                 if (array2.Length > 2)
  327.                                                                                 {
  328.                                                                                         layoutRow = new LayoutRow(array2[1], array2[0]);
  329.                                                                                         if (array2[2].Equals("SGCap"))
  330.                                                                                         {
  331.                                                                                                 layoutRow.CapsInfo = 0;
  332.                                                                                                 layoutRow.SGCap = true;
  333.                                                                                         }
  334.                                                                                         else
  335.                                                                                         {
  336.                                                                                                 layoutRow.CapsInfo = byte.Parse(array2[2], NumberStyles.AllowHexSpecifier, Utilities.s_nfi);
  337.                                                                                         }
  338.                                                                                         for (int j = 3; j < array2.Length; j++)
  339.                                                                                         {
  340.                                                                                                 layoutRow.AddCharValue(array2[j]);
  341.                                                                                         }
  342.                                                                                         if (layoutRow.SGCap)
  343.                                                                                         {
  344.                                                                                                 layoutRow.AddCharValue(65535u);
  345.                                                                                                 i++;
  346.                                                                                                 string[] array3 = array[i].TrimStart(new char[]
  347.                                                                                                 {
  348.                                                                                                         ' '
  349.                                                                                                 }).Split(new char[]
  350.                                                                                                 {
  351.                                                                                                         ' '
  352.                                                                                                 });
  353.                                                                                                 for (int k = 3; k < array3.Length; k++)
  354.                                                                                                 {
  355.                                                                                                         if (array3[k].Length > 0)
  356.                                                                                                         {
  357.                                                                                                                 layoutRow.AddCharValue(array3[k]);
  358.                                                                                                         }
  359.                                                                                                 }
  360.                                                                                         }
  361.                                                                                 }
  362.                                                                                 if (layoutRow != null && !this.m_slLayout.ContainsKey(layoutRow.Vk) && array2.Length > 2)
  363.                                                                                 {
  364.                                                                                         this.m_slLayout.Add(layoutRow.Vk, layoutRow);
  365.                                                                                 }
  366.                                                                         }
  367.                                                                 }
  368.                                                         }
  369.                                                 }
  370.                                         }
  371.                                         if (this.m_slLayout != null)
  372.                                         {
  373.                                                 int arg_227_0 = this.m_slLayout.Count;
  374.                                         }
  375.                                 }
  376.                                 return this.m_slLayout;
  377.                         }
  378.                 }
  379.                 internal ArrayList LIGATURE
  380.                 {
  381.                         get
  382.                         {
  383.                                 if (this.m_alLigature == null || this.m_alLigature.Count == 0)
  384.                                 {
  385.                                         int length = "LIGATURE".Length;
  386.                                         int num = this.m_stFile.IndexOf("LIGATURE");
  387.                                         this.m_alLigature = new ArrayList();
  388.                                         if (num != -1)
  389.                                         {
  390.                                                 int num2 = this.NextKeyword(num + length);
  391.                                                 if (num2 != -1)
  392.                                                 {
  393.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  394.                                                         string[] array = text.Split(new char[]
  395.                                                         {
  396.                                                                 '\r'
  397.                                                         });
  398.                                                         for (int i = 0; i < array.Length; i++)
  399.                                                         {
  400.                                                                 array[i] = array[i].Trim();
  401.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  402.                                                                 {
  403.                                                                         string[] array2 = array[i].Split(new char[]
  404.                                                                         {
  405.                                                                                 ' '
  406.                                                                         });
  407.                                                                         if (array2.Length >= 4)
  408.                                                                         {
  409.                                                                                 byte mod = (byte)this.SHIFTSTATE[(int)byte.Parse(array2[1], CultureInfo.InvariantCulture)];
  410.                                                                                 LigatureRow value;
  411.                                                                                 if (array2.Length == 4)
  412.                                                                                 {
  413.                                                                                         value = new LigatureRow(array2[0], mod, new string[]
  414.                                                                                         {
  415.                                                                                                 array2[2],
  416.                                                                                                 array2[3]
  417.                                                                                         });
  418.                                                                                 }
  419.                                                                                 else
  420.                                                                                 {
  421.                                                                                         if (array2.Length == 5)
  422.                                                                                         {
  423.                                                                                                 value = new LigatureRow(array2[0], mod, new string[]
  424.                                                                                                 {
  425.                                                                                                         array2[2],
  426.                                                                                                         array2[3],
  427.                                                                                                         array2[4]
  428.                                                                                                 });
  429.                                                                                         }
  430.                                                                                         else
  431.                                                                                         {
  432.                                                                                                 value = new LigatureRow(array2[0], mod, new string[]
  433.                                                                                                 {
  434.                                                                                                         array2[2],
  435.                                                                                                         array2[3],
  436.                                                                                                         array2[4],
  437.                                                                                                         array2[5]
  438.                                                                                                 });
  439.                                                                                         }
  440.                                                                                 }
  441.                                                                                 this.m_alLigature.Add(value);
  442.                                                                         }
  443.                                                                 }
  444.                                                         }
  445.                                                         this.m_alLigature.TrimToSize();
  446.                                                 }
  447.                                         }
  448.                                         int arg_1D6_0 = this.m_alLigature.Count;
  449.                                 }
  450.                                 return this.m_alLigature;
  451.                         }
  452.                 }
  453.                 internal ArrayList ATTRIBUTES
  454.                 {
  455.                         get
  456.                         {
  457.                                 if (this.m_alAttributes == null || this.m_alAttributes.Count == 0)
  458.                                 {
  459.                                         int length = "ATTRIBUTES".Length;
  460.                                         int num = this.m_stFile.IndexOf("ATTRIBUTES");
  461.                                         this.m_alAttributes = new ArrayList();
  462.                                         if (num != -1)
  463.                                         {
  464.                                                 int num2 = this.NextKeyword(num + length);
  465.                                                 if (num2 != -1)
  466.                                                 {
  467.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  468.                                                         string[] array = text.Split(new char[]
  469.                                                         {
  470.                                                                 '\r'
  471.                                                         });
  472.                                                         for (int i = 0; i < array.Length; i++)
  473.                                                         {
  474.                                                                 array[i] = array[i].Trim();
  475.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  476.                                                                 {
  477.                                                                         this.m_alAttributes.Add(array[i]);
  478.                                                                 }
  479.                                                         }
  480.                                                         this.m_alAttributes.TrimToSize();
  481.                                                 }
  482.                                         }
  483.                                         int arg_E8_0 = this.m_alAttributes.Count;
  484.                                 }
  485.                                 return this.m_alAttributes;
  486.                         }
  487.                 }
  488.                 internal ArrayList KEYNAME
  489.                 {
  490.                         get
  491.                         {
  492.                                 if (this.m_alKeyName == null)
  493.                                 {
  494.                                         this.m_alKeyName = new ArrayList();
  495.                                 }
  496.                                 if (this.m_stFile.Length > 0 && this.m_alKeyName.Count == 0)
  497.                                 {
  498.                                         int length = "KEYNAME".Length;
  499.                                         int num = this.m_stFile.IndexOf("KEYNAME");
  500.                                         if (num != -1)
  501.                                         {
  502.                                                 int num2 = this.NextKeyword(num + length);
  503.                                                 if (num2 != -1)
  504.                                                 {
  505.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  506.                                                         string[] array = text.Split(new char[]
  507.                                                         {
  508.                                                                 '\r'
  509.                                                         });
  510.                                                         for (int i = 0; i < array.Length; i++)
  511.                                                         {
  512.                                                                 array[i] = array[i].Trim();
  513.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  514.                                                                 {
  515.                                                                         int num3 = array[i].IndexOf(' ', 1);
  516.                                                                         if (num3 != -1)
  517.                                                                         {
  518.                                                                                 this.m_alKeyName.Add(new ValuePair(array[i].Substring(0, num3), array[i].Substring(num3 + 1).Trim(new char[]
  519.                                                                                 {
  520.                                                                                         ' '
  521.                                                                                 })));
  522.                                                                         }
  523.                                                                 }
  524.                                                         }
  525.                                                 }
  526.                                         }
  527.                                 }
  528.                                 if (this.m_alKeyName.Count == 0)
  529.                                 {
  530.                                         this.m_alKeyName.Add(new ValuePair("01", "Esc"));
  531.                                         this.m_alKeyName.Add(new ValuePair("0e", "Backspace"));
  532.                                         this.m_alKeyName.Add(new ValuePair("0f", "Tab"));
  533.                                         this.m_alKeyName.Add(new ValuePair("1c", "Enter"));
  534.                                         this.m_alKeyName.Add(new ValuePair("1d", "Ctrl"));
  535.                                         this.m_alKeyName.Add(new ValuePair("2a", "Shift"));
  536.                                         this.m_alKeyName.Add(new ValuePair("36", "\"Right Shift\""));
  537.                                         this.m_alKeyName.Add(new ValuePair("37", "\"Num *\""));
  538.                                         this.m_alKeyName.Add(new ValuePair("38", "Alt"));
  539.                                         this.m_alKeyName.Add(new ValuePair("39", "Space"));
  540.                                         this.m_alKeyName.Add(new ValuePair("3a", "\"Caps Lock\""));
  541.                                         this.m_alKeyName.Add(new ValuePair("3b", "F1"));
  542.                                         this.m_alKeyName.Add(new ValuePair("3c", "F2"));
  543.                                         this.m_alKeyName.Add(new ValuePair("3d", "F3"));
  544.                                         this.m_alKeyName.Add(new ValuePair("3e", "F4"));
  545.                                         this.m_alKeyName.Add(new ValuePair("3f", "F5"));
  546.                                         this.m_alKeyName.Add(new ValuePair("40", "F6"));
  547.                                         this.m_alKeyName.Add(new ValuePair("41", "F7"));
  548.                                         this.m_alKeyName.Add(new ValuePair("42", "F8"));
  549.                                         this.m_alKeyName.Add(new ValuePair("43", "F9"));
  550.                                         this.m_alKeyName.Add(new ValuePair("44", "F10"));
  551.                                         this.m_alKeyName.Add(new ValuePair("45", "Pause"));
  552.                                         this.m_alKeyName.Add(new ValuePair("46", "\"Scroll Lock\""));
  553.                                         this.m_alKeyName.Add(new ValuePair("47", "\"Num 7\""));
  554.                                         this.m_alKeyName.Add(new ValuePair("48", "\"Num 8\""));
  555.                                         this.m_alKeyName.Add(new ValuePair("49", "\"Num 9\""));
  556.                                         this.m_alKeyName.Add(new ValuePair("4a", "\"Num -\""));
  557.                                         this.m_alKeyName.Add(new ValuePair("4b", "\"Num 4\""));
  558.                                         this.m_alKeyName.Add(new ValuePair("4c", "\"Num 5\""));
  559.                                         this.m_alKeyName.Add(new ValuePair("4d", "\"Num 6\""));
  560.                                         this.m_alKeyName.Add(new ValuePair("4e", "\"Num +\""));
  561.                                         this.m_alKeyName.Add(new ValuePair("4f", "\"Num 1\""));
  562.                                         this.m_alKeyName.Add(new ValuePair("50", "\"Num 2\""));
  563.                                         this.m_alKeyName.Add(new ValuePair("51", "\"Num 3\""));
  564.                                         this.m_alKeyName.Add(new ValuePair("52", "\"Num 0\""));
  565.                                         this.m_alKeyName.Add(new ValuePair("53", "\"Num Del\""));
  566.                                         this.m_alKeyName.Add(new ValuePair("54", "\"Sys Req\""));
  567.                                         this.m_alKeyName.Add(new ValuePair("57", "F11"));
  568.                                         this.m_alKeyName.Add(new ValuePair("58", "F12"));
  569.                                         this.m_alKeyName.Add(new ValuePair("7c", "F13"));
  570.                                         this.m_alKeyName.Add(new ValuePair("7d", "F14"));
  571.                                         this.m_alKeyName.Add(new ValuePair("7e", "F15"));
  572.                                         this.m_alKeyName.Add(new ValuePair("7f", "F16"));
  573.                                         this.m_alKeyName.Add(new ValuePair("80", "F17"));
  574.                                         this.m_alKeyName.Add(new ValuePair("81", "F18"));
  575.                                         this.m_alKeyName.Add(new ValuePair("82", "F19"));
  576.                                         this.m_alKeyName.Add(new ValuePair("83", "F20"));
  577.                                         this.m_alKeyName.Add(new ValuePair("84", "F21"));
  578.                                         this.m_alKeyName.Add(new ValuePair("85", "F22"));
  579.                                         this.m_alKeyName.Add(new ValuePair("86", "F23"));
  580.                                         this.m_alKeyName.Add(new ValuePair("87", "F24"));
  581.                                 }
  582.                                 return this.m_alKeyName;
  583.                         }
  584.                 }
  585.                 internal ArrayList KEYNAME_EXT
  586.                 {
  587.                         get
  588.                         {
  589.                                 if (this.m_alKeyName_Ext == null)
  590.                                 {
  591.                                         this.m_alKeyName_Ext = new ArrayList();
  592.                                 }
  593.                                 if (this.m_stFile.Length > 0 && this.m_alKeyName_Ext.Count == 0)
  594.                                 {
  595.                                         int length = "KEYNAME_EXT".Length;
  596.                                         int num = this.m_stFile.IndexOf("KEYNAME_EXT");
  597.                                         if (num != -1)
  598.                                         {
  599.                                                 int num2 = this.NextKeyword(num + length);
  600.                                                 if (num2 != -1)
  601.                                                 {
  602.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  603.                                                         string[] array = text.Split(new char[]
  604.                                                         {
  605.                                                                 '\r'
  606.                                                         });
  607.                                                         for (int i = 0; i < array.Length; i++)
  608.                                                         {
  609.                                                                 array[i] = array[i].Trim();
  610.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  611.                                                                 {
  612.                                                                         int num3 = array[i].IndexOf(' ', 1);
  613.                                                                         if (num3 != -1)
  614.                                                                         {
  615.                                                                                 this.m_alKeyName_Ext.Add(new ValuePair(array[i].Substring(0, num3), array[i].Substring(num3 + 1).Trim(new char[]
  616.                                                                                 {
  617.                                                                                         ' '
  618.                                                                                 })));
  619.                                                                         }
  620.                                                                 }
  621.                                                         }
  622.                                                 }
  623.                                         }
  624.                                 }
  625.                                 if (this.m_alKeyName_Ext.Count == 0)
  626.                                 {
  627.                                         this.m_alKeyName_Ext.Add(new ValuePair("1c", "\"Num Enter\""));
  628.                                         this.m_alKeyName_Ext.Add(new ValuePair("1d", "\"Right Ctrl\""));
  629.                                         this.m_alKeyName_Ext.Add(new ValuePair("35", "\"Num /\""));
  630.                                         this.m_alKeyName_Ext.Add(new ValuePair("37", "\"Prnt Scrn\""));
  631.                                         this.m_alKeyName_Ext.Add(new ValuePair("38", "\"Right Alt\""));
  632.                                         this.m_alKeyName_Ext.Add(new ValuePair("45", "\"Num Lock\""));
  633.                                         this.m_alKeyName_Ext.Add(new ValuePair("46", "Break"));
  634.                                         this.m_alKeyName_Ext.Add(new ValuePair("47", "Home"));
  635.                                         this.m_alKeyName_Ext.Add(new ValuePair("48", "Up"));
  636.                                         this.m_alKeyName_Ext.Add(new ValuePair("49", "\"Page Up\""));
  637.                                         this.m_alKeyName_Ext.Add(new ValuePair("4b", "Left"));
  638.                                         this.m_alKeyName_Ext.Add(new ValuePair("4d", "Right"));
  639.                                         this.m_alKeyName_Ext.Add(new ValuePair("4f", "End"));
  640.                                         this.m_alKeyName_Ext.Add(new ValuePair("50", "Down"));
  641.                                         this.m_alKeyName_Ext.Add(new ValuePair("51", "\"Page Down\""));
  642.                                         this.m_alKeyName_Ext.Add(new ValuePair("52", "Insert"));
  643.                                         this.m_alKeyName_Ext.Add(new ValuePair("53", "Delete"));
  644.                                         this.m_alKeyName_Ext.Add(new ValuePair("54", "<00>"));
  645.                                         this.m_alKeyName_Ext.Add(new ValuePair("56", "Help"));
  646.                                         this.m_alKeyName_Ext.Add(new ValuePair("5b", "\"Left Windows\""));
  647.                                         this.m_alKeyName_Ext.Add(new ValuePair("5c", "\"Right Windows\""));
  648.                                         this.m_alKeyName_Ext.Add(new ValuePair("5d", "Application"));
  649.                                 }
  650.                                 return this.m_alKeyName_Ext;
  651.                         }
  652.                 }
  653.                 internal ArrayList KEYNAME_DEAD
  654.                 {
  655.                         get
  656.                         {
  657.                                 if (this.m_stFile.Length > 0 && this.m_alKeyName_Dead.Count == 0)
  658.                                 {
  659.                                         int length = "KEYNAME_DEAD".Length;
  660.                                         int num = this.m_stFile.IndexOf("KEYNAME_DEAD");
  661.                                         if (num != -1)
  662.                                         {
  663.                                                 int num2 = this.NextKeyword(num + length);
  664.                                                 if (num2 != -1)
  665.                                                 {
  666.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  667.                                                         string[] array = text.Split(new char[]
  668.                                                         {
  669.                                                                 '\r'
  670.                                                         });
  671.                                                         for (int i = 0; i < array.Length; i++)
  672.                                                         {
  673.                                                                 array[i] = array[i].Trim();
  674.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  675.                                                                 {
  676.                                                                         int num3 = array[i].IndexOf(' ');
  677.                                                                         if (num3 > 0)
  678.                                                                         {
  679.                                                                                 this.m_alKeyName_Dead.Add(new ValuePair(array[i].Substring(0, num3).Trim(), array[i].Substring(num3 + 1).Trim(new char[]
  680.                                                                                 {
  681.                                                                                         '"'
  682.                                                                                 })));
  683.                                                                         }
  684.                                                                 }
  685.                                                         }
  686.                                                 }
  687.                                         }
  688.                                         if (this.m_alKeyName_Dead.Count == 0)
  689.                                         {
  690.                                                 int arg_138_0 = this.DEADKEYS.Count;
  691.                                         }
  692.                                 }
  693.                                 return this.m_alKeyName_Dead;
  694.                         }
  695.                 }
  696.                 internal ArrayList DEADKEYS
  697.                 {
  698.                         get
  699.                         {
  700.                                 if (this.m_alDeadKeys == null || this.m_alDeadKeys.Count == 0)
  701.                                 {
  702.                                         int length = "DEADKEY".Length;
  703.                                         int num = this.m_stFile.IndexOf("DEADKEY");
  704.                                         this.m_alDeadKeys = new ArrayList();
  705.                                         while (num != -1)
  706.                                         {
  707.                                                 int num2 = this.NextKeyword(num + 1);
  708.                                                 string value = this.m_stFile.Substring(num + length, num2 - num - length);
  709.                                                 DeadKeyTable value2 = new DeadKeyTable(value);
  710.                                                 this.m_alDeadKeys.Add(value2);
  711.                                                 int startIndex = num2 - 1;
  712.                                                 num = this.m_stFile.IndexOf("DEADKEY", startIndex);
  713.                                         }
  714.                                 }
  715.                                 int arg_99_0 = this.m_alDeadKeys.Count;
  716.                                 return this.m_alDeadKeys;
  717.                         }
  718.                 }
  719.                 internal ArrayList DESCRIPTIONS
  720.                 {
  721.                         get
  722.                         {
  723.                                 if (this.m_alDescriptions == null || this.m_alDescriptions.Count == 0)
  724.                                 {
  725.                                         this.m_alDescriptions = new ArrayList();
  726.                                 }
  727.                                 if (this.m_stFile.Length > 0 && this.m_alDescriptions.Count == 0)
  728.                                 {
  729.                                         int length = "DESCRIPTIONS".Length;
  730.                                         int num = this.m_stFile.IndexOf("DESCRIPTIONS");
  731.                                         if (num != -1)
  732.                                         {
  733.                                                 int num2 = this.NextKeyword(num + length);
  734.                                                 if (num2 != -1)
  735.                                                 {
  736.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  737.                                                         string[] array = text.Split(new char[]
  738.                                                         {
  739.                                                                 '\r'
  740.                                                         });
  741.                                                         for (int i = 0; i < array.Length; i++)
  742.                                                         {
  743.                                                                 array[i] = array[i].Trim();
  744.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  745.                                                                 {
  746.                                                                         int num3 = array[i].IndexOf(' ', 1);
  747.                                                                         if (num3 != -1)
  748.                                                                         {
  749.                                                                                 this.m_alDescriptions.Add(new ValuePair(array[i].Substring(0, num3), array[i].Substring(num3 + 1).Trim(new char[]
  750.                                                                                 {
  751.                                                                                         ' '
  752.                                                                                 })));
  753.                                                                         }
  754.                                                                 }
  755.                                                         }
  756.                                                 }
  757.                                         }
  758.                                 }
  759.                                 int arg_145_0 = this.m_alDescriptions.Count;
  760.                                 return this.m_alDescriptions;
  761.                         }
  762.                 }
  763.                 internal ArrayList LANGUAGENAMES
  764.                 {
  765.                         get
  766.                         {
  767.                                 if (this.m_alLanguageNames == null || this.m_alLanguageNames.Count == 0)
  768.                                 {
  769.                                         this.m_alLanguageNames = new ArrayList();
  770.                                 }
  771.                                 if (this.m_stFile.Length > 0 && this.m_alLanguageNames.Count == 0)
  772.                                 {
  773.                                         int length = "LANGUAGENAMES".Length;
  774.                                         int num = this.m_stFile.IndexOf("LANGUAGENAMES");
  775.                                         if (num != -1)
  776.                                         {
  777.                                                 int num2 = this.NextKeyword(num + length);
  778.                                                 if (num2 != -1)
  779.                                                 {
  780.                                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  781.                                                         string[] array = text.Split(new char[]
  782.                                                         {
  783.                                                                 '\r'
  784.                                                         });
  785.                                                         for (int i = 0; i < array.Length; i++)
  786.                                                         {
  787.                                                                 array[i] = array[i].Trim();
  788.                                                                 if (array[i].Length > 0 && array[i][0] != ';')
  789.                                                                 {
  790.                                                                         int num3 = array[i].IndexOf(' ', 1);
  791.                                                                         if (num3 != -1)
  792.                                                                         {
  793.                                                                                 this.m_alLanguageNames.Add(new ValuePair(array[i].Substring(0, num3), array[i].Substring(num3 + 1).Trim(new char[]
  794.                                                                                 {
  795.                                                                                         ' '
  796.                                                                                 })));
  797.                                                                         }
  798.                                                                 }
  799.                                                         }
  800.                                                 }
  801.                                         }
  802.                                 }
  803.                                 int arg_145_0 = this.m_alLanguageNames.Count;
  804.                                 return this.m_alLanguageNames;
  805.                         }
  806.                 }
  807.                 internal KeyboardTextFile(string fileName, string name, string description, CultureInfo culture, string company, string copyright, UIntPtr localeId, VirtualKey[] vks, ArrayList alNames, ArrayList alExtNames, ArrayList alAttributes, ArrayList alDesciptions, ArrayList alLanguageNames)
  808.                 {
  809.                         int[] array = new int[]
  810.                         {
  811.                                 -1,
  812.                                 -1,
  813.                                 -1,
  814.                                 -1,
  815.                                 -1,
  816.                                 -1
  817.                         };
  818.                         bool[] array2 = new bool[256];
  819.                         bool flag = false;
  820.                         StringBuilder stringBuilder = null;
  821.                         StringBuilder stringBuilder2 = null;
  822.                         StringBuilder stringBuilder3 = null;
  823.                         StringBuilder stringBuilder4 = null;
  824.                         StringBuilder stringBuilder5 = null;
  825.                         StringBuilder stringBuilder6 = null;
  826.                         SortedList sortedList = new SortedList();
  827.                         int num = 0;
  828.                         this.m_alAttributes = alAttributes;
  829.                         this.m_alKeyName = alNames;
  830.                         this.m_alKeyName_Ext = alExtNames;
  831.                         this.m_alDescriptions = alDesciptions;
  832.                         this.m_alLanguageNames = alLanguageNames;
  833.                         if (fileName.Length == 0)
  834.                         {
  835.                                 this.m_stFileName = name + ".txt";
  836.                         }
  837.                         else
  838.                         {
  839.                                 this.m_stFileName = fileName;
  840.                         }
  841.                         if (File.Exists(this.m_stFileName))
  842.                         {
  843.                                 File.Delete(this.m_stFileName);
  844.                         }
  845.                         StreamWriter streamWriter = new StreamWriter(this.m_stFileName, false, Encoding.Unicode);
  846.                         streamWriter.Write("KBD\t");
  847.                         streamWriter.Write(name);
  848.                         streamWriter.Write("\t\"");
  849.                         streamWriter.Write(description);
  850.                         streamWriter.Write("\"\r\n");
  851.                         streamWriter.WriteLine();
  852.                         if (copyright.Length > 0)
  853.                         {
  854.                                 streamWriter.Write("COPYRIGHT\t\"");
  855.                                 streamWriter.Write(copyright);
  856.                                 streamWriter.Write("\"\r\n");
  857.                                 streamWriter.WriteLine();
  858.                         }
  859.                         streamWriter.Write("COMPANY\t\"");
  860.                         streamWriter.Write(company);
  861.                         streamWriter.Write("\"\r\n");
  862.                         streamWriter.WriteLine();
  863.                         streamWriter.Write("LOCALENAME\t\"");
  864.                         streamWriter.Write(culture.Name);
  865.                         streamWriter.Write("\"\r\n");
  866.                         streamWriter.WriteLine();
  867.                         streamWriter.Write("LOCALEID\t\"");
  868.                         streamWriter.Write(localeId.ToUInt32().ToString("x8", Utilities.s_nfi));
  869.                         streamWriter.Write("\"\r\n");
  870.                         streamWriter.WriteLine();
  871.                         streamWriter.WriteLine("VERSION\t1.0\r\n");
  872.                         if (this.m_alAttributes != null && this.m_alAttributes.Count > 0)
  873.                         {
  874.                                 streamWriter.WriteLine("ATTRIBUTES");
  875.                                 for (int i = 0; i < this.m_alAttributes.Count; i++)
  876.                                 {
  877.                                         streamWriter.WriteLine((string)this.m_alAttributes[i]);
  878.                                 }
  879.                                 streamWriter.WriteLine();
  880.                         }
  881.                         for (int j = 0; j < vks.Length; j++)
  882.                         {
  883.                                 array2[j] = false;
  884.                                 for (int k = 0; k < array.Length; k++)
  885.                                 {
  886.                                         ShiftState shiftState = vks[j].State(k);
  887.                                         if (shiftState != null && shiftState.IsDefined)
  888.                                         {
  889.                                                 if (shiftState.Characters.Length > 1 && shiftState.GetLayoutChar(num) == "%%")
  890.                                                 {
  891.                                                         flag = true;
  892.                                                 }
  893.                                                 array[k] = 0;
  894.                                                 array2[j] = true;
  895.                                                 if (num < k)
  896.                                                 {
  897.                                                         num = k;
  898.                                                 }
  899.                                         }
  900.                                 }
  901.                                 string key = vks[j].ScanCode.ToString("x2", Utilities.s_nfi);
  902.                                 if (array2[j] && !sortedList.ContainsKey(key))
  903.                                 {
  904.                                         sortedList.Add(key, vks[j]);
  905.                                 }
  906.                         }
  907.                         streamWriter.WriteLine("SHIFTSTATE\r\n");
  908.                         int num2 = 3;
  909.                         stringBuilder3 = new StringBuilder();
  910.                         stringBuilder4 = new StringBuilder();
  911.                         if (-1 != array[0])
  912.                         {
  913.                                 num2++;
  914.                                 stringBuilder3.Append("\t0");
  915.                                 stringBuilder4.Append("\t----");
  916.                                 streamWriter.Write("0\t//Column ");
  917.                                 streamWriter.Write(num2.ToString(Utilities.s_nfi));
  918.                                 streamWriter.WriteLine();
  919.                         }
  920.                         if (-1 != array[1])
  921.                         {
  922.                                 num2++;
  923.                                 stringBuilder3.Append("\t1");
  924.                                 stringBuilder4.Append("\t----");
  925.                                 streamWriter.Write("1\t//Column ");
  926.                                 streamWriter.Write(num2.ToString(Utilities.s_nfi));
  927.                                 streamWriter.Write(" : Shft");
  928.                                 streamWriter.WriteLine();
  929.                         }
  930.                         array[2] = 0;
  931.                         if (-1 != array[2])
  932.                         {
  933.                                 num2++;
  934.                                 stringBuilder3.Append("\t2");
  935.                                 stringBuilder4.Append("\t----");
  936.                                 streamWriter.Write("2\t//Column ");
  937.                                 streamWriter.Write(num2.ToString(Utilities.s_nfi));
  938.                                 streamWriter.Write(" :       Ctrl");
  939.                                 streamWriter.WriteLine();
  940.                         }
  941.                         if (-1 != array[3])
  942.                         {
  943.                                 num2++;
  944.                                 stringBuilder3.Append("\t3");
  945.                                 stringBuilder4.Append("\t----");
  946.                                 streamWriter.Write("3\t//Column ");
  947.                                 streamWriter.Write(num2.ToString(Utilities.s_nfi));
  948.                                 streamWriter.Write(" : Shft  Ctrl");
  949.                                 streamWriter.WriteLine();
  950.                         }
  951.                         if (-1 != array[4])
  952.                         {
  953.                                 num2++;
  954.                                 stringBuilder3.Append("\t6");
  955.                                 stringBuilder4.Append("\t----");
  956.                                 streamWriter.Write("6\t//Column ");
  957.                                 streamWriter.Write(num2.ToString(Utilities.s_nfi));
  958.                                 streamWriter.Write(" :       Ctrl Alt");
  959.                                 streamWriter.WriteLine();
  960.                         }
  961.                         if (-1 != array[5])
  962.                         {
  963.                                 num2++;
  964.                                 stringBuilder3.Append("\t7");
  965.                                 stringBuilder4.Append("\t----");
  966.                                 streamWriter.Write("7\t//Column ");
  967.                                 streamWriter.Write(num2.ToString(Utilities.s_nfi));
  968.                                 streamWriter.Write(" : Shft  Ctrl Alt");
  969.                                 streamWriter.WriteLine();
  970.                         }
  971.                         streamWriter.WriteLine();
  972.                         int num3 = 0;
  973.                         for (int l = 0; l < array.Length; l++)
  974.                         {
  975.                                 if (-1 != array[l])
  976.                                 {
  977.                                         array[l] = num3;
  978.                                         num3++;
  979.                                 }
  980.                         }
  981.                         streamWriter.WriteLine("LAYOUT\t\t;an extra '@' at the end is a dead key\r\n");
  982.                         streamWriter.Write("//SC\tVK_\t\tCap");
  983.                         streamWriter.Write(stringBuilder3.ToString());
  984.                         streamWriter.WriteLine();
  985.                         streamWriter.Write("//--\t----\t\t----");
  986.                         streamWriter.Write(stringBuilder4.ToString());
  987.                         streamWriter.WriteLine();
  988.                         streamWriter.WriteLine();
  989.                         VirtualKey virtualKey;
  990.                         for (int m = 0; m < sortedList.Count; m++)
  991.                         {
  992.                                 virtualKey = (VirtualKey)sortedList.GetByIndex(m);
  993.                                 if (virtualKey.VK != 110 && array2[(int)virtualKey.VK])
  994.                                 {
  995.                                         stringBuilder3 = new StringBuilder();
  996.                                         stringBuilder3.Append(virtualKey.ScanCode.ToString("x2", Utilities.s_nfi));
  997.                                         stringBuilder3.Append('\t');
  998.                                         string text = Utilities.VkStringOfIvk((int)virtualKey.VK);
  999.                                         stringBuilder3.Append(text);
  1000.                                         stringBuilder3.Append('\t');
  1001.                                         if (text.Length < 6)
  1002.                                         {
  1003.                                                 stringBuilder3.Append('\t');
  1004.                                         }
  1005.                                         if (virtualKey.IsSgCaps || virtualKey.IsShiftSgCaps)
  1006.                                         {
  1007.                                                 stringBuilder3.Append("SGCap");
  1008.                                                 stringBuilder4 = new StringBuilder();
  1009.                                                 stringBuilder4.Append("-1\t-1\t0\t");
  1010.                                         }
  1011.                                         else
  1012.                                         {
  1013.                                                 stringBuilder3.Append(((virtualKey.CapLok ? 1 : 0) + (virtualKey.AltGrCapLock ? 4 : 0)).ToString(Utilities.s_nfi));
  1014.                                         }
  1015.                                         stringBuilder3.Append('\t');
  1016.                                         stringBuilder = new StringBuilder();
  1017.                                         stringBuilder.Append("// ");
  1018.                                         stringBuilder2 = new StringBuilder();
  1019.                                         if (virtualKey.IsSgCaps || virtualKey.IsShiftSgCaps)
  1020.                                         {
  1021.                                                 stringBuilder2.Append("// ");
  1022.                                         }
  1023.                                         for (int n = 0; n < array.Length; n++)
  1024.                                         {
  1025.                                                 if (-1 != array[n])
  1026.                                                 {
  1027.                                                         ShiftState shiftState = virtualKey.State(n);
  1028.                                                         stringBuilder3.Append(shiftState.GetLayoutChar(num));
  1029.                                                         if (shiftState.IsDeadKey)
  1030.                                                         {
  1031.                                                                 stringBuilder3.Append('@');
  1032.                                                                 if (stringBuilder6 == null)
  1033.                                                                 {
  1034.                                                                         stringBuilder6 = new StringBuilder();
  1035.                                                                 }
  1036.                                                                 stringBuilder6.Append(((ushort)shiftState.Characters[0]).ToString("x4", Utilities.s_nfi));
  1037.                                                                 stringBuilder6.Append('\t');
  1038.                                                                 stringBuilder6.Append('"');
  1039.                                                                 stringBuilder6.Append(shiftState.CharacterName);
  1040.                                                                 stringBuilder6.Append('"');
  1041.                                                                 stringBuilder6.Append("\r\n");
  1042.                                                                 if (stringBuilder5 == null)
  1043.                                                                 {
  1044.                                                                         stringBuilder5 = new StringBuilder();
  1045.                                                                 }
  1046.                                                                 stringBuilder5.Append("DEADKEY\t");
  1047.                                                                 stringBuilder5.Append(((ushort)shiftState.Characters[0]).ToString("x4", Utilities.s_nfi));
  1048.                                                                 stringBuilder5.Append("\r\n\r\n");
  1049.                                                                 if (shiftState.DeadKeyPairs != null)
  1050.                                                                 {
  1051.                                                                         foreach (ValuePair valuePair in shiftState.DeadKeyPairs)
  1052.                                                                         {
  1053.                                                                                 ushort value = Convert.ToUInt16(valuePair.Name, Utilities.s_nfi);
  1054.                                                                                 ushort value2 = Convert.ToUInt16(valuePair.Value, Utilities.s_nfi);
  1055.                                                                                 stringBuilder5.Append(value.ToString("x4", Utilities.s_nfi));
  1056.                                                                                 stringBuilder5.Append('\t');
  1057.                                                                                 stringBuilder5.Append(value2.ToString("x4", Utilities.s_nfi));
  1058.                                                                                 stringBuilder5.Append('\t');
  1059.                                                                                 stringBuilder5.Append("// ");
  1060.                                                                                 stringBuilder5.Append((char)value);
  1061.                                                                                 stringBuilder5.Append(" -> ");
  1062.                                                                                 stringBuilder5.Append((char)value2);
  1063.                                                                                 stringBuilder5.Append("\r\n");
  1064.                                                                         }
  1065.                                                                         stringBuilder5.Append("\r\n");
  1066.                                                                 }
  1067.                                                         }
  1068.                                                         stringBuilder3.Append('\t');
  1069.                                                         if (stringBuilder.Length > 3)
  1070.                                                         {
  1071.                                                                 stringBuilder.Append(", ");
  1072.                                                         }
  1073.                                                         if (shiftState.CharacterName != null && shiftState.CharacterName.Length > 0)
  1074.                                                         {
  1075.                                                                 stringBuilder.Append(shiftState.CharacterName);
  1076.                                                         }
  1077.                                                         else
  1078.                                                         {
  1079.                                                                 stringBuilder.Append("<none>");
  1080.                                                         }
  1081.                                                         if ((virtualKey.IsSgCaps && n == 0) || (virtualKey.IsShiftSgCaps && n == 1))
  1082.                                                         {
  1083.                                                                 ShiftState shiftState2 = virtualKey.State((VirtualKey.SSEnum)(n + 8));
  1084.                                                                 if (shiftState2 == null || shiftState2.Characters.Length == 0)
  1085.                                                                 {
  1086.                                                                         stringBuilder4.Append(shiftState.GetLayoutChar(num));
  1087.                                                                 }
  1088.                                                                 else
  1089.                                                                 {
  1090.                                                                         stringBuilder4.Append(shiftState2.GetLayoutChar(num));
  1091.                                                                         if (shiftState2.IsDeadKey)
  1092.                                                                         {
  1093.                                                                                 stringBuilder4.Append('@');
  1094.                                                                                 if (stringBuilder6 == null)
  1095.                                                                                 {
  1096.                                                                                         stringBuilder6 = new StringBuilder();
  1097.                                                                                 }
  1098.                                                                                 stringBuilder6.Append(((ushort)shiftState2.Characters[0]).ToString("x4", Utilities.s_nfi));
  1099.                                                                                 stringBuilder6.Append('\t');
  1100.                                                                                 stringBuilder6.Append('"');
  1101.                                                                                 stringBuilder6.Append(shiftState2.CharacterName);
  1102.                                                                                 stringBuilder6.Append('"');
  1103.                                                                                 stringBuilder6.Append("\r\n");
  1104.                                                                                 if (stringBuilder5 == null)
  1105.                                                                                 {
  1106.                                                                                         stringBuilder5 = new StringBuilder();
  1107.                                                                                 }
  1108.                                                                                 stringBuilder5.Append("DEADKEY\t");
  1109.                                                                                 stringBuilder5.Append(((ushort)shiftState2.Characters[0]).ToString("x4", Utilities.s_nfi));
  1110.                                                                                 stringBuilder5.Append("\r\n\r\n");
  1111.                                                                                 if (shiftState2.DeadKeyPairs != null)
  1112.                                                                                 {
  1113.                                                                                         foreach (ValuePair valuePair2 in shiftState2.DeadKeyPairs)
  1114.                                                                                         {
  1115.                                                                                                 ushort value3 = Convert.ToUInt16(valuePair2.Name, Utilities.s_nfi);
  1116.                                                                                                 ushort value4 = Convert.ToUInt16(valuePair2.Value, Utilities.s_nfi);
  1117.                                                                                                 stringBuilder5.Append(value3.ToString("x4", Utilities.s_nfi));
  1118.                                                                                                 stringBuilder5.Append('\t');
  1119.                                                                                                 stringBuilder5.Append(value4.ToString("x4", Utilities.s_nfi));
  1120.                                                                                                 stringBuilder5.Append('\t');
  1121.                                                                                                 stringBuilder5.Append("// ");
  1122.                                                                                                 stringBuilder5.Append((char)value3);
  1123.                                                                                                 stringBuilder5.Append(" -> ");
  1124.                                                                                                 stringBuilder5.Append((char)value4);
  1125.                                                                                                 stringBuilder5.Append("\r\n");
  1126.                                                                                         }
  1127.                                                                                         stringBuilder5.Append("\r\n");
  1128.                                                                                 }
  1129.                                                                         }
  1130.                                                                         if (virtualKey.IsSgCaps || virtualKey.IsShiftSgCaps)
  1131.                                                                         {
  1132.                                                                                 stringBuilder4.Append('\t');
  1133.                                                                                 if (stringBuilder2.Length > 3)
  1134.                                                                                 {
  1135.                                                                                         stringBuilder2.Append(", ");
  1136.                                                                                 }
  1137.                                                                                 if (shiftState2.CharacterName != null && shiftState2.CharacterName.Length > 0)
  1138.                                                                                 {
  1139.                                                                                         stringBuilder2.Append(shiftState2.CharacterName);
  1140.                                                                                 }
  1141.                                                                                 else
  1142.                                                                                 {
  1143.                                                                                         stringBuilder.Append("<none>");
  1144.                                                                                 }
  1145.                                                                         }
  1146.                                                                 }
  1147.                                                         }
  1148.                                                 }
  1149.                                         }
  1150.                                         streamWriter.Write(stringBuilder3.ToString());
  1151.                                         streamWriter.Write('\t');
  1152.                                         streamWriter.Write(stringBuilder.ToString());
  1153.                                         streamWriter.WriteLine();
  1154.                                         if (virtualKey.IsSgCaps || virtualKey.IsShiftSgCaps)
  1155.                                         {
  1156.                                                 streamWriter.Write(stringBuilder4.ToString());
  1157.                                                 streamWriter.Write('\t');
  1158.                                                 streamWriter.Write(stringBuilder2.ToString());
  1159.                                                 streamWriter.WriteLine();
  1160.                                         }
  1161.                                 }
  1162.                         }
  1163.                         virtualKey = vks[110];
  1164.                         stringBuilder3 = new StringBuilder();
  1165.                         stringBuilder3.Append(virtualKey.ScanCode.ToString("x2", Utilities.s_nfi));
  1166.                         stringBuilder3.Append('\t');
  1167.                         stringBuilder3.Append(Utilities.VkStringOfIvk((int)virtualKey.VK));
  1168.                         stringBuilder3.Append('\t');
  1169.                         stringBuilder3.Append(((virtualKey.CapLok ? 1 : 0) + (virtualKey.AltGrCapLock ? 4 : 0)).ToString(Utilities.s_nfi));
  1170.                         stringBuilder3.Append('\t');
  1171.                         stringBuilder = new StringBuilder();
  1172.                         for (int num4 = 0; num4 < array.Length; num4++)
  1173.                         {
  1174.                                 if (-1 != array[num4])
  1175.                                 {
  1176.                                         ShiftState shiftState = virtualKey.State(num4);
  1177.                                         stringBuilder3.Append(shiftState.GetLayoutChar(num));
  1178.                                         if (shiftState.IsDeadKey)
  1179.                                         {
  1180.                                                 stringBuilder3.Append('@');
  1181.                                         }
  1182.                                         stringBuilder3.Append('\t');
  1183.                                         if (stringBuilder.Length > 3)
  1184.                                         {
  1185.                                                 stringBuilder.Append(", ");
  1186.                                         }
  1187.                                         if (shiftState.CharacterName.Length > 0)
  1188.                                         {
  1189.                                                 stringBuilder.Append(shiftState.CharacterName);
  1190.                                         }
  1191.                                         if (shiftState.IsDeadKey)
  1192.                                         {
  1193.                                                 stringBuilder6.Append(((ushort)shiftState.Characters[0]).ToString("x4", Utilities.s_nfi));
  1194.                                                 stringBuilder6.Append("\t\"");
  1195.                                                 stringBuilder6.Append(shiftState.CharacterName);
  1196.                                                 stringBuilder6.Append("\"\r\n");
  1197.                                         }
  1198.                                 }
  1199.                         }
  1200.                         streamWriter.Write(stringBuilder3.ToString());
  1201.                         streamWriter.Write('\t');
  1202.                         streamWriter.Write("// ");
  1203.                         streamWriter.Write(stringBuilder.ToString());
  1204.                         streamWriter.Write("\r\n");
  1205.                         streamWriter.WriteLine();
  1206.                         if (flag)
  1207.                         {
  1208.                                 NlsConvert nlsConvert = new NlsConvert();
  1209.                                 streamWriter.WriteLine("LIGATURE\r\n");
  1210.                                 streamWriter.WriteLine("//VK_\tMod#\tChar0\tChar1\tChar2\tChar3");
  1211.                                 streamWriter.WriteLine("//----\t\t----\t----\t----\t----\t----\r\n");
  1212.                                 for (int num5 = 0; num5 < vks.Length; num5++)
  1213.                                 {
  1214.                                         if (array2[num5])
  1215.                                         {
  1216.                                                 for (int num6 = 0; num6 < array.Length; num6++)
  1217.                                                 {
  1218.                                                         virtualKey = vks[num5];
  1219.                                                         ShiftState shiftState = virtualKey.State(num6);
  1220.                                                         if (shiftState != null && shiftState.Characters != null && shiftState.Characters.Length > 1)
  1221.                                                         {
  1222.                                                                 string characters = shiftState.Characters;
  1223.                                                                 if (!shiftState.IsSurrogate)
  1224.                                                                 {
  1225.                                                                         stringBuilder3 = new StringBuilder();
  1226.                                                                         stringBuilder3.Append(Utilities.VkStringOfIvk(num5));
  1227.                                                                         stringBuilder3.Append("\t\t");
  1228.                                                                         stringBuilder3.Append(array[num6]);
  1229.                                                                         stringBuilder3.Append('\t');
  1230.                                                                         stringBuilder = new StringBuilder();
  1231.                                                                         stringBuilder.Append("// ");
  1232.                                                                         for (int num7 = 0; num7 < characters.Length; num7++)
  1233.                                                                         {
  1234.                                                                                 stringBuilder3.Append(((ushort)characters[num7]).ToString("x4", Utilities.s_nfi));
  1235.                                                                                 stringBuilder3.Append('\t');
  1236.                                                                                 if (nlsConvert.FromCharacter(shiftState.Characters.Substring(num7, 1)))
  1237.                                                                                 {
  1238.                                                                                         if (stringBuilder.Length > 3)
  1239.                                                                                         {
  1240.                                                                                                 stringBuilder.Append(" + ");
  1241.                                                                                         }
  1242.                                                                                         if (shiftState.CharacterName.Length > 0)
  1243.                                                                                         {
  1244.                                                                                                 stringBuilder.Append(nlsConvert.ToCharacterName());
  1245.                                                                                         }
  1246.                                                                                 }
  1247.                                                                         }
  1248.                                                                         streamWriter.Write(stringBuilder3.ToString());
  1249.                                                                         streamWriter.Write('\t');
  1250.                                                                         streamWriter.Write(stringBuilder.ToString());
  1251.                                                                         streamWriter.WriteLine();
  1252.                                                                 }
  1253.                                                         }
  1254.                                                 }
  1255.                                         }
  1256.                                 }
  1257.                         }
  1258.                         streamWriter.WriteLine();
  1259.                         if (stringBuilder5 != null)
  1260.                         {
  1261.                                 streamWriter.WriteLine(stringBuilder5.ToString());
  1262.                         }
  1263.                         streamWriter.WriteLine("KEYNAME\r\n");
  1264.                         foreach (ValuePair valuePair3 in this.KEYNAME)
  1265.                         {
  1266.                                 streamWriter.Write(valuePair3.Name);
  1267.                                 streamWriter.Write('\t');
  1268.                                 streamWriter.Write(valuePair3.Value);
  1269.                                 streamWriter.WriteLine();
  1270.                         }
  1271.                         streamWriter.WriteLine();
  1272.                         streamWriter.WriteLine("KEYNAME_EXT\r\n");
  1273.                         foreach (ValuePair valuePair4 in this.KEYNAME_EXT)
  1274.                         {
  1275.                                 streamWriter.Write(valuePair4.Name);
  1276.                                 streamWriter.Write('\t');
  1277.                                 streamWriter.Write(valuePair4.Value);
  1278.                                 streamWriter.WriteLine();
  1279.                         }
  1280.                         streamWriter.WriteLine();
  1281.                         if (stringBuilder6 != null)
  1282.                         {
  1283.                                 streamWriter.WriteLine("KEYNAME_DEAD\r\n");
  1284.                                 streamWriter.WriteLine(stringBuilder6.ToString());
  1285.                                 streamWriter.WriteLine();
  1286.                         }
  1287.                         streamWriter.WriteLine("DESCRIPTIONS\r\n");
  1288.                         if (this.DESCRIPTIONS.Count == 0)
  1289.                         {
  1290.                                 streamWriter.Write("0409");
  1291.                                 streamWriter.Write('\t');
  1292.                                 streamWriter.Write(description);
  1293.                                 streamWriter.WriteLine();
  1294.                         }
  1295.                         else
  1296.                         {
  1297.                                 foreach (ValuePair valuePair5 in this.DESCRIPTIONS)
  1298.                                 {
  1299.                                         streamWriter.Write(valuePair5.Name);
  1300.                                         streamWriter.Write('\t');
  1301.                                         streamWriter.Write(valuePair5.Value);
  1302.                                         streamWriter.WriteLine();
  1303.                                 }
  1304.                                 streamWriter.WriteLine();
  1305.                         }
  1306.                         streamWriter.WriteLine("LANGUAGENAMES\r\n");
  1307.                         if (this.LANGUAGENAMES.Count == 0)
  1308.                         {
  1309.                                 streamWriter.Write("0409");
  1310.                                 streamWriter.Write('\t');
  1311.                                 streamWriter.Write(culture.EnglishName);
  1312.                                 streamWriter.WriteLine();
  1313.                         }
  1314.                         else
  1315.                         {
  1316.                                 foreach (ValuePair valuePair6 in this.LANGUAGENAMES)
  1317.                                 {
  1318.                                         streamWriter.Write(valuePair6.Name);
  1319.                                         streamWriter.Write('\t');
  1320.                                         streamWriter.Write(valuePair6.Value);
  1321.                                         streamWriter.WriteLine();
  1322.                                 }
  1323.                                 streamWriter.WriteLine();
  1324.                         }
  1325.                         streamWriter.WriteLine("ENDKBD");
  1326.                         streamWriter.Flush();
  1327.                         streamWriter.Close();
  1328.                 }
  1329.                 internal KeyboardTextFile(string FileName)
  1330.                 {
  1331.                         this.m_stFileName = FileName;
  1332.                         StreamReader streamReader = new StreamReader(File.OpenRead(FileName));
  1333.                         string stIn = streamReader.ReadToEnd();
  1334.                         streamReader.DiscardBufferedData();
  1335.                         streamReader.Close();
  1336.                         string text = this.StripAllComments(stIn).Replace('\n', ' ');
  1337.                         int length = text.IndexOf("ENDKBD") - 1;
  1338.                         this.m_stFile = this.RemoveWhiteSpace(text.Substring(0, length));
  1339.                 }
  1340.                 internal DeadKeyTable DeadKeyTableOfDeadKey(char dk)
  1341.                 {
  1342.                         for (int i = 0; i < this.DEADKEYS.Count; i++)
  1343.                         {
  1344.                                 DeadKeyTable deadKeyTable = (DeadKeyTable)this.DEADKEYS[i];
  1345.                                 if (deadKeyTable.DK.Equals(dk))
  1346.                                 {
  1347.                                         return deadKeyTable;
  1348.                                 }
  1349.                         }
  1350.                         return null;
  1351.                 }
  1352.                 private int NextKeyword(int ichStart)
  1353.                 {
  1354.                         int num = this.m_stFile.Length;
  1355.                         for (int i = 0; i < this.KeyWords.Length; i++)
  1356.                         {
  1357.                                 int num2 = this.m_stFile.IndexOf(this.KeyWords[i], ichStart);
  1358.                                 if (num2 != -1 && num2 < num)
  1359.                                 {
  1360.                                         num = num2;
  1361.                                 }
  1362.                         }
  1363.                         return num;
  1364.                 }
  1365.                 private string StripAllComments(string stIn)
  1366.                 {
  1367.                         string[] array = stIn.Split(new char[]
  1368.                         {
  1369.                                 '\r'
  1370.                         });
  1371.                         for (int i = 0; i < array.Length; i++)
  1372.                         {
  1373.                                 if (array[i].Length > 0)
  1374.                                 {
  1375.                                         if (array[i][0] == ';')
  1376.                                         {
  1377.                                                 array[i] = "";
  1378.                                         }
  1379.                                         else
  1380.                                         {
  1381.                                                 int num = array[i].IndexOf("//");
  1382.                                                 if (num == 0)
  1383.                                                 {
  1384.                                                         array[i] = "";
  1385.                                                 }
  1386.                                                 else
  1387.                                                 {
  1388.                                                         if (num != -1)
  1389.                                                         {
  1390.                                                                 array[i] = array[i].Substring(0, num - 1);
  1391.                                                         }
  1392.                                                 }
  1393.                                         }
  1394.                                 }
  1395.                         }
  1396.                         return string.Join("\r", array);
  1397.                 }
  1398.                 private void FillHeaderVariables()
  1399.                 {
  1400.                         int length = "KBD".Length;
  1401.                         int num = this.m_stFile.IndexOf("KBD");
  1402.                         if (num != -1)
  1403.                         {
  1404.                                 int num2 = this.m_stFile.IndexOf('\r', num + 1);
  1405.                                 if (num2 != -1)
  1406.                                 {
  1407.                                         string text = this.m_stFile.Substring(num + length, num2 - num - length);
  1408.                                         text = text.TrimStart(new char[0]);
  1409.                                         int num3 = text.IndexOf(' ');
  1410.                                         if (num3 != -1)
  1411.                                         {
  1412.                                                 this.m_stName = text.Substring(0, num3).Trim(new char[]
  1413.                                                 {
  1414.                                                         ' ',
  1415.                                                         '"'
  1416.                                                 });
  1417.                                                 this.m_stDescription = text.Substring(num3 + 1).Trim(new char[]
  1418.                                                 {
  1419.                                                         ' ',
  1420.                                                         '"'
  1421.                                                 });
  1422.                                         }
  1423.                                 }
  1424.                         }
  1425.                         if (this.m_stName == null)
  1426.                         {
  1427.                                 this.m_stName = "";
  1428.                         }
  1429.                         if (this.m_stDescription == null)
  1430.                         {
  1431.                                 this.m_stDescription = "";
  1432.                         }
  1433.                 }
  1434.                 private string RemoveWhiteSpace(string stIn)
  1435.                 {
  1436.                         string text = stIn.Replace('\t', ' ');
  1437.                         int num;
  1438.                         do
  1439.                         {
  1440.                                 num = text.IndexOf("  ");
  1441.                                 if (num >= 0)
  1442.                                 {
  1443.                                         text = text.Replace("  ", " ");
  1444.                                 }
  1445.                         }
  1446.                         while (num >= 0);
  1447.                         return text;
  1448.                 }
  1449.         }
  1450. }