private static extern void nvttSetInputOptionsFormat(IntPtr inputOptions, InputFormat format);

 private void textBox_EmpStateOfHealth_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void cmb_StationPacket_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void txtName_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

        private HtmlValidatorResult FixBrokenHeaders(Stream output, OutputFormat outputFormat, string input, InputFormat inputFormat, IHtmlValidatorSettings settings, string validatorAddress)
        {
            Stream checkStream = mStreamFactory.GetMemoryStream();
            if (outputFormat != OutputFormat.Soap12 || output.CanRead == false)
            {
                if (IsDefaultValidatorAddress(validatorAddress))
                {
                    System.Threading.Thread.Sleep(1000);
                }

                // Headers failed, so we will get the report again in Soap 1.2 format in
                // an in memory stream
                string checkData = GetFormData(input, inputFormat, OutputFormat.Soap12, settings);

                // This time, ignore headers.
                if (inputFormat == InputFormat.Fragment)
                {
                    this.mHttpClient.Post(checkStream, validatorAddress, checkData);
                }
                else
                {
                    this.mHttpClient.Get(checkStream, validatorAddress + "?" + checkData);
                }
            }
            else
            {
                output.Position = 0;
                output.CopyTo(checkStream);
            }

            checkStream.Position = 0;
            var response = mSoapResponseParser.ParseResponse(checkStream);

            var errors = response.Errors.Count();
            var warnings = response.Warnings.Count();
            var status = response.Validity ? "Valid" : "Invalid";
            var recursion = 1;

            var result = new HtmlValidatorResult(status, errors, warnings, recursion);
            return result;
        }

 public virtual HtmlValidatorResult Validate(string input, InputFormat inputFormat)
 {
     return Validate((Stream)null, OutputFormat.Soap12, input, inputFormat, new HtmlValidatorSettings(), defaultValidatorAddress);
 }

 private static InputFormat SetDefaultsBasedOnInputFormat(InputFormat inFormat, PublicationInformation projectInfo, string lcName)
 {
     return SetDefaultsBasedOnInputFormat(inFormat, projectInfo, lcName, "Scripture");
 }

 private static void ProcessInputFormat(InputFormat inFormat, List<string> files, PublicationInformation projectInfo)
 {
     if (inFormat == InputFormat.PTBUNDLE)
     {
         var zf = new FastZip();
         zf.ExtractZip(files[0], projectInfo.ProjectPath, ".*");
         var metadata = Common.DeclareXMLDocument(false);
         metadata.Load(Common.PathCombine(projectInfo.ProjectPath, "metadata.xml"));
         var titleNode = metadata.SelectSingleNode("//bookList[@id='default']/name");
         Param.UpdateTitleMetadataValue(Param.Title, titleNode.InnerText, false);
         var descriptionNode = metadata.SelectSingleNode("//bookList[@id='default']//range");
         Param.UpdateMetadataValue(Param.Description, descriptionNode.InnerText);
         var rightsHolderNode = metadata.SelectSingleNode("//rightsHolder");
         Param.UpdateMetadataValue(Param.Publisher, rightsHolderNode.InnerText);
         var copyrightNode = metadata.SelectSingleNode("//statement");
         Param.UpdateMetadataValue(Param.CopyrightHolder, copyrightNode.InnerText);
         var bookNodes = metadata.SelectNodes("//bookList[@id='default']//book");
         var usxFolder = Common.PathCombine(projectInfo.ProjectPath, "USX");
         var xmlText = new StringBuilder(@"<usx version=""2.0"">");
         var oneBook = Common.DeclareXMLDocument(false);
         foreach (XmlElement bookNode in bookNodes)
         {
             oneBook.Load(Common.PathCombine(usxFolder, bookNode.SelectSingleNode("@code").InnerText + ".usx"));
             xmlText.Append(oneBook.DocumentElement.InnerXml);
             oneBook.RemoveAll();
         }
         xmlText.Append(@"</usx>" + "\r\n");
         var fileName = Common.PathCombine(projectInfo.ProjectPath, titleNode.InnerText + ".xhtml");
         var databaseName = metadata.SelectSingleNode("//identification/abbreviation");
         var linkParam = new Dictionary<string, object>();
         linkParam["dateTime"] = DateTime.Now.ToShortDateString();
         linkParam["user"] = "ukn";
         var wsNode = metadata.SelectSingleNode("//language/iso");
         linkParam["ws"] = wsNode.InnerText;
         linkParam["userWs"] = wsNode.InnerText;
         var nameNode = metadata.SelectSingleNode("//identification/description");
         linkParam["projName"] = nameNode.InnerText;
         var langNameNode = metadata.SelectSingleNode("//language/name");
         linkParam["langInfo"] = string.Format("{0}:{1}", wsNode.InnerText, langNameNode.InnerText);
         ConvertUsx2Xhtml(databaseName, linkParam, xmlText, fileName);
         projectInfo.DefaultXhtmlFileWithPath = fileName;
         var ptxStyle2Css = new XslCompiledTransform();
         ptxStyle2Css.Load(XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream(
             "PathwayB.ptx2css.xsl")));
         projectInfo.DefaultCssFileWithPath = Common.PathCombine(projectInfo.ProjectPath, titleNode.InnerText + ".css");
         var writer = new XmlTextWriter(projectInfo.DefaultCssFileWithPath, Encoding.UTF8);
         ptxStyle2Css.Transform(Common.PathCombine(projectInfo.ProjectPath, "styles.xml"), null, writer);
         writer.Close();
         metadata.RemoveAll();
         inFormat = InputFormat.XHTML;
     }
     if (inFormat == InputFormat.USFM)
     {
         // convert from USFM to xhtml
         UsfmToXhtml(projectInfo, files);
     }
     else if (inFormat == InputFormat.USX)
     {
         // convert from USX to xhtml
         UsxToXhtml(projectInfo, files);
     }
     else if (inFormat == InputFormat.XHTML)
     {
         SetFileName(projectInfo, files);
     }
 }

 private static int ProcessExportType(string[] args, int i, PublicationInformation projectInfo, List<string> files,
                                      ref InputFormat inFormat, ref bool bShowDialog, ref string exportType,
                                      ref bool bOutputSpecified)
 {
     switch (args[i++])
     {
         case "--directory":
         case "-d":
             projectInfo.ProjectPath = args[i++];
             break;
         case "--files":
         case "-f":
             i = CaptureFileList(args, i, files);
             break;
         case "--inputformat":
         case "-if":
             var format = args[i++];
             switch (format)
             {
                 case "xhtml":
                     inFormat = InputFormat.XHTML;
                     break;
                 case "usfm":
                     inFormat = InputFormat.USFM;
                     break;
                 case "usx":
                     inFormat = InputFormat.USX;
                     break;
                 case "ptb":
                     inFormat = InputFormat.PTBUNDLE;
                     break;
             }
             break;
         case "--xhtml":
         case "-x":
             // retained for backwards compatibility (not documented)
             inFormat = InputFormat.XHTML;
             projectInfo.DefaultXhtmlFileWithPath = args[i++];
             break;
         case "--showdialog":
         case "-s":
             bShowDialog = true;
             break;
         case "--css":
         case "-c":
             projectInfo.DefaultCssFileWithPath = args[i++];
             break;
         case "--target":
         case "-t":
             //Note: If export type is more than one word, quotes must be used
             exportType = args[i++];
             bOutputSpecified = true;
             break;
         case "--input":
         case "-i":
             projectInfo.ProjectInputType = args[i++];
             break;
         case "--launch":
         case "-l":
             projectInfo.IsOpenOutput = true;
             break;
         case "--name":
         case "-n":
             projectInfo.ProjectName = args[i++];
             break;
         case "-?":
         case "-h":
             Usage();
             Environment.Exit(0);
             break;
         default:
             i = CaptureFileList(args, --i, files);
             if (files.Count > 0)
             {
                 var lcName = files[0].ToLower();
                 if (lcName.EndsWith(".zip"))
                 {
                     inFormat = SetDefaultsBasedOnInputFormat(InputFormat.PTBUNDLE, projectInfo, lcName);
                     break;
                 }
                 if (lcName.EndsWith(".xhtml"))
                 {
                     inFormat = SetDefaultsBasedOnInputFormat(InputFormat.XHTML, projectInfo, lcName, "Dictionary");
                     break;
                 }
                 if (lcName.EndsWith(".usx"))
                 {
                     inFormat = SetDefaultsBasedOnInputFormat(InputFormat.USX, projectInfo, lcName);
                     break;
                 }
                 if (lcName.EndsWith(".usfm") || lcName.EndsWith(".sfm"))
                 {
                     inFormat = SetDefaultsBasedOnInputFormat(InputFormat.USFM, projectInfo, lcName);
                     break;
                 }
             }
             Usage();
             throw new ArgumentException("Invalid Command Line Argument: " + args[i]);
     }
     return i;
//.........这里部分代码省略.........

 private void textBox_EmployeeArchives_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void textBox_EmpWorkPlace_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void textBox_EmployeeCensusRegister_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void txt_EndStationHeadAddress_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void txt_Directional_Add_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

        private string GetFormData(string input, InputFormat inputFormat, OutputFormat outputFormat, IHtmlValidatorSettings settings)
        {
            if (string.IsNullOrEmpty(input))
            {
                throw new ArgumentNullException("input");
            }

            string data = "uri=" + HttpUtility.UrlEncode(input);

            if (inputFormat == InputFormat.Fragment)
            {
                // fix fragment so it is possible to exclude the <html> and other envelope tags and only test specific tags.
                input = FixHtmlFragment(input);
                data = "fragment=" + HttpUtility.UrlEncode(input);
            }

            if (!string.IsNullOrEmpty(settings.CharSet))
                data += "&charset=" + HttpUtility.UrlEncode(settings.CharSet);

            if (!string.IsNullOrEmpty(settings.DocType))
                data += "&doctype=" + HttpUtility.UrlEncode(settings.DocType);

            if (outputFormat == OutputFormat.Soap12)
                data += "&output=soap12";

            if (settings.Verbose)
                data += "&verbose=1";

            if (settings.Debug)
                data += "&debug=1";

            if (settings.ShowSource)
                data += "&ss=1";

            if (settings.Outline)
                data += "&outline=1";

            if (settings.GroupErrors)
                data += "&group=1";

            if (settings.UseHtmlTidy)
                data += "&st=1";

            return data;
        }

 private void txt_FirstStationHeadPlace_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void txt_StaHeadAntennaB_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 private void textBox_DutyRemark_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }

 public void SetFormat(InputFormat format)
 {
     nvttSetInputOptionsFormat(options, format);
 }

 private void txt_Description_Select_KeyPress(object sender, KeyPressEventArgs e)
 {
     InputFormat ifobj = new InputFormat();
     ifobj.HalfWidthFormat(e);
 }