public FilteredFieldsForm(Dictionary <string, List <string> > mapFilteredSfms, List <string> astrSfmsToConvert, List <string> astrSfmsToNotConvert, Font font, Font fontConverted, IEncConverter aEC) { InitializeComponent(); m_aEC = aEC; m_mapFilteredSfms = mapFilteredSfms; dataGridViewFilterSfms.Columns[cnColumnExampleData].DefaultCellStyle.Font = font; dataGridViewFilterSfms.Columns[cnColumnExampleResult].DefaultCellStyle.Font = fontConverted; foreach (KeyValuePair <string, List <string> > kvp in mapFilteredSfms) { if (!astrSfmsToConvert.Contains(kvp.Key) && !astrSfmsToNotConvert.Contains(kvp.Key)) { System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(kvp.Value[0])); string strInput = kvp.Value[0]; string strOutput = m_aEC.Convert(strInput); bool bOnByDefault = Properties.Settings.Default.DefaultFieldsToConvert.Contains(kvp.Key); object[] aoRowData = new object[4] { bOnByDefault, kvp.Key, kvp.Value[0], strOutput }; int nIndex = dataGridViewFilterSfms.Rows.Add(aoRowData); DataGridViewRow theRow = dataGridViewFilterSfms.Rows[nIndex]; theRow.Tag = 0; } } }
// initialize an EncConverter which will tell us when we've hit a match. Uses ICU RegEx (though, there's // no reason this couldn't be .Net regex...) protected IEncConverter InitSearchFontConverter(string strFindWhat, string strReplaceWith, Font font, bool bMatchCase) { // we're going to use a temporary ICU RegEx EncConverter to do our 'searching' for us. // get a blank ICU Regex converter that we can program with our FindWhat string // but, it may be null if ICU isn't installed System.Diagnostics.Debug.Assert(m_aECs != null); IEncConverter aIEC = null; try { aIEC = m_aECs.NewEncConverterByImplementationType(EncConverters.strTypeSILicuRegex); } catch (Exception ex) { throw new ApplicationException("ICU doesn't appear to have been installed. This feature won't work without ICU.", ex); } // we search for different things depending on whether it's "Find" (only) vs. "Find & Replace" // delimit the replacement string with something we can detect, which we wouldn't otherwise expect // to find in user text. string strConverterSpec = String.Format("{0}->{2}{1}{2}{3}", strFindWhat, strReplaceWith, m_achDelimiter[0], (bMatchCase) ? " /i" : null); // Give it a friendly name that isn't likely to conflict with anything 'real' the user might name it. string strName = String.Format("{0} FindReplaceConverter", OfficeApp.cstrCaption); ConvType eConvType = ConvType.Unicode_to_Unicode; string strDummy = null; int nProcType = (int)ProcessTypeFlags.ICURegularExpression; // initialize it so it's ready and put it in the current repository object (as a temporary converter) aIEC.Initialize(strName, strConverterSpec, ref strDummy, ref strDummy, ref eConvType, ref nProcType, 0, 0, true); return(aIEC); }
private void setDefaultConverterToolStripMenuItem_Click(object sender, EventArgs e) { m_aEcDefault = null; EncConverters aECs = GetEncConverters; if (aECs != null) { IEncConverter aIEC = aECs.AutoSelectWithTitle(ConvType.Unknown, "Choose Default Converter"); if (aIEC != null) { m_aEcDefault = new DirectableEncConverter(aIEC); foreach (DataGridViewRow aRow in dataGridViewConverterMapping.Rows) { string strXmlPath = (string)aRow.Cells[cnXmlPathsColumn].Value; if (!IsConverterDefined(strXmlPath)) { DataGridViewCell cellConverter = aRow.Cells[cnEncConverterColumn]; cellConverter.Value = m_aEcDefault.Name; cellConverter.ToolTipText = m_aEcDefault.ToString(); string strInput = (string)aRow.Cells[cnExampleDataColumn].Value; aRow.Cells[cnExampleOutputColumn].Value = CallSafeConvert(m_aEcDefault, strInput); DefineConverter(strXmlPath, m_aEcDefault); } } m_aECLast = null; } } }
public FilteredFieldsForm(Dictionary<string, List<string>> mapFilteredSfms, List<string> astrSfmsToConvert, List<string> astrSfmsToNotConvert, Font font, Font fontConverted, IEncConverter aEC) { InitializeComponent(); m_aEC = aEC; m_mapFilteredSfms = mapFilteredSfms; dataGridViewFilterSfms.Columns[cnColumnExampleData].DefaultCellStyle.Font = font; dataGridViewFilterSfms.Columns[cnColumnExampleResult].DefaultCellStyle.Font = fontConverted; foreach (KeyValuePair<string, List<string>> kvp in mapFilteredSfms) { if (!astrSfmsToConvert.Contains(kvp.Key) && !astrSfmsToNotConvert.Contains(kvp.Key)) { System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(kvp.Value[0])); string strInput = kvp.Value[0]; string strOutput = m_aEC.Convert(strInput); bool bOnByDefault = Properties.Settings.Default.DefaultFieldsToConvert.Contains(kvp.Key); object[] aoRowData = new object[4] { bOnByDefault, kvp.Key, kvp.Value[0], strOutput }; int nIndex = dataGridViewFilterSfms.Rows.Add(aoRowData); DataGridViewRow theRow = dataGridViewFilterSfms.Rows[nIndex]; theRow.Tag = 0; } } }
private void buttonTest_Click(object sender, EventArgs e) { Util.DebugWriteLine(this, "BEGIN"); IEncConverter aEC = InitializeEncConverter; if (aEC != null) { try { aEC.DirectionForward = !checkBoxTestReverse.Checked; //ecTextBoxOutput.Text = aEC.Convert(ecTextBoxInput.Text); string result = aEC.Convert(ecTextBoxInput.Text); Util.DebugWriteLine(this, "Putting in text box: '" + result + "'"); ecTextBoxOutput.Text = result; //ecTextBoxOutput.Text = "Hello there!"; } catch (Exception ex) { MessageBox.Show(String.Format("Test failed! Reason: {0}", ex.Message), EncConverters.cstrCaption); } NormConversionType eType = (checkBoxTestReverse.Checked) ? EncConverter.NormalizeLhsConversionType(ConversionType) : EncConverter.NormalizeRhsConversionType(ConversionType); if (eType == NormConversionType.eLegacy) { UpdateLegacyCodes(ecTextBoxOutput.Text, m_aEC.CodePageOutput, richTextBoxHexOutput); } else { UpdateUniCodes(ecTextBoxOutput.Text, richTextBoxHexOutput); } } }
protected DirectableEncConverter GetTempFixedValueConverter(string strFixedValue) { string strName = String.Format("{0}{1}", cstrFixedStringConverterPrefix, strFixedValue); EncConverters aECs = GetEncConverters; if (aECs != null) { IEncConverter aIEC = null; if (!aECs.ContainsKey(strName)) { aIEC = aECs.NewEncConverterByImplementationType(EncConverters.strTypeSILicuRegex); ConvType eConvType = ConvType.Unicode_to_Unicode; string strDummy = null; int nProcType = (int)ProcessTypeFlags.ICURegularExpression; aIEC.Initialize(strName, String.Format(".+->{0}", strFixedValue), ref strDummy, ref strDummy, ref eConvType, ref nProcType, 0, 0, true); aECs.Add(strName, aIEC); } else { aIEC = aECs[strName]; } return(new DirectableEncConverter(aIEC)); } return(null); }
private void setDefaultConverterToolStripMenuItem_Click(object sender, EventArgs e) { EncConverters aECs = OfficeApp.GetEncConverters; if (aECs != null) { IEncConverter aIEC = aECs.AutoSelectWithTitle(ConvType.Unknown, "Select Default Converter"); if (aIEC != null) { DirectableEncConverter aEC = new DirectableEncConverter(aIEC.Name, aIEC.DirectionForward, aIEC.NormalizeOutput); foreach (DataGridViewRow aRow in dataGridViewFontsConverters.Rows) { string strFontName = (string)aRow.Cells[nColumnFontNames].Value; if (!m_mapEncConverters.ContainsKey(strFontName)) { m_mapEncConverters.Add(strFontName, aEC); // add it DataGridViewCell cellConverter = aRow.Cells[nColumnConverterNames]; cellConverter.Value = aEC.Name; cellConverter.ToolTipText = aEC.ToString(); } } // clear the last one selected so that a right-click can be used to cancel the selection m_aECLast = null; } } }
protected void ResetFields() { ConversionType = m_eOrigConvType; ConverterIdentifier = null; ProcessType = 0; m_aEC = null; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Convert one line of text for display /// </summary> /// <param name="ec"></param> /// <param name="input"></param> /// <returns></returns> /// ------------------------------------------------------------------------------------ private string ConvertOneLine(IEncConverter ec, string input) { string marker = string.Empty; string remainder = string.Empty; // if the input string is empty, don't try to convert it if (input == string.Empty) { return(input); } // split the marker and the remainder portions of the text line. if (input[0] != '\\') { remainder = input; } else { int spacePosition = input.IndexOf(" "); if (spacePosition == -1) { return(input); } else { marker = input.Substring(0, spacePosition); remainder = input.Substring(spacePosition); } } return(marker + ec.Convert(remainder)); }
protected void InitFromIEncConverter(IEncConverter aEC, bool bInputOutputAlreadySet) { m_strEncConverterName = aEC.Name; m_bDirectionForward = aEC.DirectionForward; m_eNormalForm = aEC.NormalizeOutput; // in some cases (e.g. the SelectConverter dialog), the input/ouput code page values // are already set from the proper perspective and don't need to be reversed as in the other cases // (see CodePageInput below). So swap them if they need to be (so the later swap will put them // back to what they were at the start -- sorry, I know this is confusing) if (!m_bDirectionForward && bInputOutputAlreadySet) { var aEcInputCodePage = aEC.CodePageOutput; aEC.CodePageOutput = aEC.CodePageInput; aEC.CodePageInput = aEcInputCodePage; } // if the user intends for this to be a temporary converter, it won't be available to // subsequent calls of "GetEncConverter" unless we add it to this particular instance // of the local repository object. if (EncConverters[m_strEncConverterName] == null) { EncConverters.Add(m_strEncConverterName, aEC); } }
void ConvertTableField_Click(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool CancelDefault) { try { if (Application.Selection == null) { throw new ApplicationException("First select the cells that you want to convert using a system converter"); } ExcelDocument doc = new ExcelDocument(Application.Selection); if (m_aSelectionProcessor == null) { string strTitle = "Choose the converter for the selected areas/cells"; EncConverters aECs = GetEncConverters; if (aECs != null) { IEncConverter aIEC = aECs.AutoSelectWithTitle(ConvType.Unknown, strTitle); FontConverter aFC = new FontConverter(new DirectableEncConverter(aIEC)); m_aSelectionProcessor = new OfficeDocumentProcessor(aFC, new SILConverterProcessorForm()); } } if (m_aSelectionProcessor != null) { if (doc.ProcessWordByWord(m_aSelectionProcessor)) { m_aSelectionProcessor = null; } } } catch (Exception ex) { DisplayException(ex); } }
private void buttonTest_Click(object sender, EventArgs e) { IEncConverter aEC = InitializeEncConverter; if (aEC != null) { try { aEC.DirectionForward = !checkBoxTestReverse.Checked; ecTextBoxOutput.Text = aEC.Convert(ecTextBoxInput.Text); } catch (Exception ex) { MessageBox.Show(String.Format("Test failed! Reason: {0}", ex.Message), EncConverters.cstrCaption); } NormConversionType eType = (checkBoxTestReverse.Checked) ? EncConverter.NormalizeLhsConversionType(ConversionType) : EncConverter.NormalizeRhsConversionType(ConversionType); if (eType == NormConversionType.eLegacy) { UpdateLegacyCodes(ecTextBoxOutput.Text, m_aEC.CodePageOutput, richTextBoxHexOutput); } else { UpdateUniCodes(ecTextBoxOutput.Text, richTextBoxHexOutput); } } }
public virtual void Initialize ( IEncConverters aECs, string strFriendlyName, string strConverterIdentifier, ConvType eConversionType, string strTestData ) { FriendlyName = strFriendlyName; ConverterIdentifier = strConverterIdentifier; ConversionType = eConversionType; m_aECs = aECs; m_aEC = InitializeEncConverter; tabControl.Controls.Remove(tabPageAbout); tabControl.Controls.Remove(tabPageSetup); tabControl.Controls.Remove(tabPageAdvanced); // for 'test', it's possible that there may be some font mapping in the repository string strLhsName, strRhsName; if (m_aECs.GetFontMappingFromMapping(strFriendlyName, out strLhsName, out strRhsName)) { ecTextBoxInput.Font = CreateFontSafe(strLhsName, ecTextBoxInput.Font); ecTextBoxOutput.Font = CreateFontSafe(strRhsName, ecTextBoxOutput.Font); } ecTextBoxInput.Text = strTestData; buttonOK.Visible = buttonApply.Visible = false; buttonCancel.Text = "Close"; helpProvider.SetHelpString(buttonCancel, Properties.Resources.CloseButtonHelpString); }
// we override this method from EncConverter so that we can call all of the step's // convert functions in turn (i.e. for this one, it isn't sufficient to just // provide a "DoConvert" method) // and we override this from CmpdEncConverter to we can add our bit of only calling // the 2nd step (i.e. the fallback converter) if the 1st step doesn't change the // string. protected override string InternalConvertEx ( EncodingForm eInEncodingForm, string sInput, int ciInput, EncodingForm eOutEncodingForm, NormalizeFlags eNormalizeOutput, out int rciOutput, bool bForward ) { if (CountConverters != 2) { EncConverters.ThrowError(ErrStatus.FallbackTwoStepsRequired); } IEncConverter rConverter = (IEncConverter)m_aEncConverter[0]; if (rConverter == null) { EncConverters.ThrowError(ErrStatus.MissingConverter); } rConverter.Debug = Debug; bool bDirectionForward = (bForward) ? (bool)m_aDirectionForward[0] : !(bool)m_aDirectionForward[0]; string strOutput = rConverter.ConvertEx( sInput, eInEncodingForm, ciInput, eOutEncodingForm, out rciOutput, eNormalizeOutput, bDirectionForward); // call the fallback if the string wasn't changed if (strOutput == sInput) { IEncConverter rFallbackConverter = (IEncConverter)m_aEncConverter[1]; if (rFallbackConverter == null) { EncConverters.ThrowError(ErrStatus.MissingConverter); } rFallbackConverter.Debug = Debug; bDirectionForward = (bForward) ? (bool)m_aDirectionForward[1] : !(bool)m_aDirectionForward[1]; strOutput = rFallbackConverter.ConvertEx( sInput, eInEncodingForm, ciInput, eOutEncodingForm, out rciOutput, eNormalizeOutput, bDirectionForward); } return(strOutput); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Convert a file and display it in the window /// </summary> /// ----------------------------------------------------------------------------------- public void DoFileConvert(IEncConverter ec, string inputFilename) { CheckDisposed(); // start hour glass Cursor cursorBefore = Cursor.Current; Cursor.Current = Cursors.WaitCursor; // open the input and output files using the given encoding formats // 28591 is a 'magic' code page that stuffs each input byte into // the low byte of the unicode character, leaving the top byte zero. // This is a good code page to use because it is simple and fully reversible // for any input. StreamReader reader = new StreamReader(inputFilename, System.Text.Encoding.GetEncoding(28591), true); // This tells the converter that the input will be 16-bit characters // produced by converting the bytes of the file using CP28591. ec.CodePageInput = 28591; ec.EncodingIn = ECInterfaces.EncodingForm.LegacyString; reader.BaseStream.Seek(0, SeekOrigin.Begin); // read the lines of the input file, (optionally convert,) and write them out. string sOutput = string.Empty; string sInput; m_savedOutput = new StringBuilder(); m_svOutput.Clear(false); m_fHasOutput = false; // Read the lines of the input file, convert them, and display them // in the view. while (reader.Peek() > -1) { sInput = reader.ReadLine(); if (sInput == string.Empty || sInput.StartsWith(@"\_sh ") || sInput.StartsWith(@"\id ")) { sOutput = sInput; } else { sOutput = ConvertOneLine(ec, sInput); } m_svOutput.AddPara(sOutput); m_savedOutput.Append(sOutput); m_savedOutput.Append("\r\n"); m_fHasOutput = true; } reader.Close(); m_svOutput.CompleteSetText(); Cursor.Current = cursorBefore; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Open the next source file to read. Skip over any files that do not contain /// data in the desired range. /// </summary> /// <returns>true if a file was opened, else false and there are no more /// files available</returns> /// ------------------------------------------------------------------------------------ private bool OpenNextSourceFile(BCVRef startRef, BCVRef endRef) { // Clear the indicator that tells that an ID line has been encountered m_seenIdInFile = false; m_lineNumber = 0; // If the first file is being opened, then initialize the reference if (m_currentFile == null) { m_currentStartRef = new BCVRef(); m_currentEndRef = new BCVRef(); } // Find the next book in the project that has books in the import range bool fileHasBooksInRange = false; while (!fileHasBooksInRange) { if (!m_importSourceEnum.MoveNext()) { return(false); } m_currentFile = (ScrImportFileInfo)m_importSourceEnum.Current; if (m_domain != ImportDomain.Main) { m_prevDataEncoding = GetEncodingConverterForLocale(m_currentFile.IcuLocale, ScrImportSet.s_markerBook); } // make sure the file contains books in the desired range foreach (int book in m_currentFile.BooksInFile) { if (book >= startRef.Book && book <= endRef.Book) { fileHasBooksInRange = true; break; } } } try { // ASCII encoding will convert all high-bit characters to a '?'. // The magic code page will map all high-bit characters to the same // value with a high-byte of 0 in unicode. For example, character 0x84 // will end up as 0x0084. Encoding useEncoding = (m_currentFile.FileEncoding == Encoding.ASCII) ? Encoding.GetEncoding(kMagicCodePage) : m_currentFile.FileEncoding; m_sfFileReader = new StreamReader(m_currentFile.FileName, useEncoding); } catch (Exception e) { throw new ScriptureUtilsException(SUE_ErrorCode.FileError, m_currentFile.FileName, e); } return(true); }
private bool ChaChaChaChaChanges(IEncConverter aEC, string strFileName, string strWord) { string strDummy = null; int lProcessType = (int)SpellingFixerEC.SFProcessType; ConvType eConvType = (m_bLegacy) ? ConvType.Legacy_to_Legacy : ConvType.Unicode_to_Unicode; aEC.Initialize("dummyname", strFileName, ref strDummy, ref strDummy, ref eConvType, ref lProcessType, 0, 0, true); return(aEC.Convert(strWord) != strWord); }
public bool SetConverter(EncConverters converters) { if (m_EncCvtrMap == null) { return(true); // if the map is empty, this means the lang is already UTF8 } m_iconverter = converters[m_EncCvtrMap]; return(m_iconverter != null); }
public void DoFileConvert ( string strConverterName, string strOutputFileName, System.Text.Encoding outEnc, string strInputFileName, System.Text.Encoding inEnc, bool bDirectionForward ) { // the user *might* not give us a converter name if they simply want to change // the encoding from, say, UTF8 to UTF16. bool bIsConverter = !(strConverterName == null); IEncConverter aEC = null; if (bIsConverter) { EncConverters aECs = new EncConverters(); aEC = aECs[strConverterName]; } // open the input and output files using the given encoding formats StreamReader srReadLine = new StreamReader(strInputFileName, inEnc, true); srReadLine.BaseStream.Seek(0, SeekOrigin.Begin); StreamWriter swWriteLine = new StreamWriter(strOutputFileName, false, outEnc); // tell the converter to go the other way, if the user selected 'reverse' if (!bDirectionForward && bIsConverter) { aEC.DirectionForward = false; } // read the lines of the input file, (optionally convert,) and write them out. string sOutput, sInput; while (srReadLine.Peek() > -1) { sInput = srReadLine.ReadLine(); if (bIsConverter) { sOutput = aEC.Convert(sInput); } else { sOutput = sInput; } swWriteLine.WriteLine(sOutput); } srReadLine.Close(); swWriteLine.Close(); }
/// <summary> /// FontConvertersPicker: to choose the font you want to process in the Word document /// /// This version of the constructor is for when you want the same (given) EncConverter /// used for all fonts. /// </summary> /// <param name="doc"></param> /// <param name="aEC"></param> public FontConvertersPicker(OfficeDocument doc, IEncConverter aEC) { System.Diagnostics.Debug.Assert(aEC != null); m_aECForAll = new DirectableEncConverter(aEC); m_strApplyEC = String.Format(cstrApplyECFormat, aEC.Name); CommonConstruct(doc); // no mapping in this mode converterMappingToolStripMenuItem.Visible = false; }
private void buttonDebug_Click(object sender, EventArgs e) { IEncConverter aEC = m_aEC.GetEncConverter; bool bOrigValue = aEC.Debug; aEC.Debug = true; RefreshTextBoxes(aEC); aEC.Debug = bOrigValue; }
protected bool IsLhsLegacy(IEncConverter aEC) { if (aEC.DirectionForward) { return(EncConverter.NormalizeLhsConversionType(aEC.ConversionType) == NormConversionType.eLegacy); } else { return(EncConverter.NormalizeRhsConversionType(aEC.ConversionType) == NormConversionType.eLegacy); } }
public static AdaptItEncConverter InitLookupAdapter(ProjectSettings proj, GlossType eGlossType) { EncConverters aECs = new EncConverters(); string strName, strConverterSpec; ProjectSettings.LanguageInfo liSource, liTarget; switch (eGlossType) { case GlossType.eVernacularToNational: strName = AdaptItLookupConverterName(proj.Vernacular.LangName, proj.NationalBT.LangName); strConverterSpec = AdaptItLookupFileSpec(proj.Vernacular.LangName, proj.NationalBT.LangName); liSource = proj.Vernacular; liTarget = proj.NationalBT; break; case GlossType.eVernacularToEnglish: // the glossing KB for the Vern to Natl project strName = AdaptItLookupConverterName(proj.Vernacular.LangName, proj.InternationalBT.LangName); strConverterSpec = AdaptItLookupFileSpec(proj.Vernacular.LangName, proj.InternationalBT.LangName); liSource = proj.Vernacular; liTarget = proj.InternationalBT; // this is still the national lg project (but the glossing KB) break; case GlossType.eNationalToEnglish: strName = AdaptItLookupConverterName(proj.NationalBT.LangName, proj.InternationalBT.LangName); strConverterSpec = AdaptItLookupFileSpec(proj.NationalBT.LangName, proj.InternationalBT.LangName); liSource = proj.NationalBT; // this is a whole nuther national to English project liTarget = proj.InternationalBT; break; default: System.Diagnostics.Debug.Assert(false); throw new ApplicationException("Wrong glossing type specified. Send to [email protected] for help"); } // just in case the project doesn't exist yet... WriteAdaptItProjectFiles(liSource, liTarget, proj.InternationalBT); // move this to AIGuesserEC project when it's mature. // if we don't have the converter already in the repository. if (!aECs.ContainsKey(strName)) { aECs.AddConversionMap(strName, strConverterSpec, ConvType.Unicode_to_from_Unicode, EncConverters.strTypeSILadaptit, "UNICODE", "UNICODE", ProcessTypeFlags.DontKnow); } IEncConverter aEC = aECs[strName]; System.Diagnostics.Debug.Assert((aEC != null) && (aEC is AdaptItEncConverter)); AdaptItEncConverter theLookupAdapter = (AdaptItEncConverter)aEC; // in order to get the converter to load the database, do a dummy Convert theLookupAdapter.Convert("nothing"); return(theLookupAdapter); }
protected void InitFromIEncConverter(IEncConverter aEC) { m_strEncConverterName = aEC.Name; m_bDirectionForward = aEC.DirectionForward; m_eNormalForm = aEC.NormalizeOutput; // if the user intends for this to be a temporary converter, it won't be available to // subsequent calls of "GetEncConverter" unless we add it to this particular instance // of the local repository object. if (EncConverters[m_strEncConverterName] == null) EncConverters.Add(m_strEncConverterName, aEC); }
public string Convert(string sInput) { IEncConverter aEC = GetEncConverter; if (aEC != null) { return(aEC.Convert(sInput)); } else { throw NoConverterException; } }
public override string ToString() { IEncConverter aEC = GetEncConverter; if (aEC != null) { return(aEC.ToString()); } else { return(Name); } }
protected void InitConverterDetails(string strFontName, out string strConverterName, out string strTooltip, out string strFontNameOutput) { strConverterName = (UsingSameEncConverter) ? m_strApplyEC : cstrClickMsg; strTooltip = strConverterName; strFontNameOutput = (UsingSameEncConverter) ? strFontName : cstrFontClickMsg; // if there is no converted selected, then see if the repository has a suggestion if (!m_mapEncConverters.ContainsKey(strFontName) && (strConverterName == cstrClickMsg)) { EncConverters aECs = OfficeApp.GetEncConverters; if (aECs != null) { string strMappingName = aECs.GetMappingNameFromFont(strFontName); if (!String.IsNullOrEmpty(strMappingName)) { strConverterName = strMappingName; IEncConverter aIEC = aECs[strConverterName]; if (aIEC != null) { DirectableEncConverter aEC = new DirectableEncConverter(aIEC); m_mapEncConverters.Add(strFontName, aEC); } } } } if (m_mapEncConverters.ContainsKey(strFontName)) { DirectableEncConverter aEC = (DirectableEncConverter)m_mapEncConverters[strFontName]; strConverterName = aEC.Name; strTooltip = aEC.ToString(); if (aEC.TargetFont != null) { strFontNameOutput = aEC.TargetFont.Name; } else // otherwise, the repository might be able to tell us what font to use { EncConverters aECs = OfficeApp.GetEncConverters; if (aECs != null) { string[] astrFontnames = aECs.GetFontMapping(aEC.Name, strFontName); if (astrFontnames.Length > 0) { strFontNameOutput = astrFontnames[0]; aEC.TargetFont = new Font(strFontNameOutput, 14); } } } } }
protected void InitFromIEncConverter(IEncConverter aEC) { m_strEncConverterName = aEC.Name; m_bDirectionForward = aEC.DirectionForward; m_eNormalForm = aEC.NormalizeOutput; // if the user intends for this to be a temporary converter, it won't be available to // subsequent calls of "GetEncConverter" unless we add it to this particular instance // of the local repository object. if (EncConverters[m_strEncConverterName] == null) { EncConverters.Add(m_strEncConverterName, aEC); } }
protected void UpdateConverterCellValue(DataGridViewRow theRow, IEncConverter aEC) { string strStepName = aEC.Name; if (strStepName.Length > cnMaxConverterName) { strStepName = strStepName.Substring(0, cnMaxConverterName); } DataGridViewCell theCell = theRow.Cells[cnStepNameColumn]; theCell.Value = strStepName; theCell.ToolTipText = aEC.ToString(); }
private void comboBox_SelectedIndexChanged(ComboBox sender, CheckBox chk) { if (!m_bIgnoreSelItemChgWhileLoading) { string strConverter = sender.Text; IEncConverter aEC = m_aECs[strConverter]; if (aEC != null) { chk.Enabled = !EncConverters.IsUnidirectional(aEC.ConversionType); } // to enable the name to be changed IsModified = true; } }
protected override void GetConverterNameEnum(out string [] rSa) { rSa = new string[CountConverters]; for (int i = 0; i < CountConverters; i++) { IEncConverter rConvert = (IEncConverter)m_aEncConverter[i]; if (rConvert == null) { EncConverters.ThrowError(ErrStatus.MissingConverter); } else { rSa[i] = FormatConverterStep(rConvert.Name, (bool)m_aDirectionForward[i], (NormalizeFlags)m_aNormalizeOutput[i]); } } }
// convert in the opposite direction (if it started as "reverse", then this // means forward public string ConvertDirectionOpposite(string sInput) { IEncConverter aEC = EncConverters[m_strEncConverterName]; if (aEC != null) { aEC.DirectionForward = !m_bDirectionForward; string strOutput = aEC.Convert(sInput); aEC.DirectionForward = m_bDirectionForward; return(strOutput); } else { throw NoConverterException; } }
protected void ConvertProjectFile(string strProjectFileSource, string strProjectFileTarget, IEncConverter aEcSource, IEncConverter aEcTarget, string strFontNameSource, string strFontNameTarget) { // convert the punctuation in the legacy project file. Encoding enc = Encoding.Default; if (aEcSource != null) { // the "symbol" code page apparently isn't valid for GetEncoding, so use the cp for ISO-8859-1 if (aEcSource.CodePageInput == EncConverters.cnSymbolFontCodePage) enc = Encoding.GetEncoding(EncConverters.cnIso8859_1CodePage); else enc = Encoding.GetEncoding(aEcSource.CodePageInput); } string strProjectFileContents = File.ReadAllText(strProjectFileSource, enc); int nIndex; int nLength = 0; // the charset value has to be 0 in a Unicode project // first the 'Source language' nIndex = strProjectFileContents.IndexOf(cstrAdaptItCharMapDelimiter); if (nIndex != -1) { nIndex += cstrAdaptItCharMapDelimiter.Length; nLength = strProjectFileContents.IndexOfAny(caSplitChars, nIndex) - nIndex; strProjectFileContents = ReplaceSubstring(strProjectFileContents, nIndex, nLength, "0"); // next the target language... nIndex = strProjectFileContents.IndexOf(cstrAdaptItCharMapDelimiter, nIndex); if (nIndex != -1) { nIndex += cstrAdaptItCharMapDelimiter.Length; nLength = strProjectFileContents.IndexOfAny(caSplitChars, nIndex) - nIndex; strProjectFileContents = ReplaceSubstring(strProjectFileContents, nIndex, nLength, "0"); // finally do the navigation language as well. nIndex = strProjectFileContents.IndexOf(cstrAdaptItCharMapDelimiter, nIndex); if (nIndex != -1) { nIndex += cstrAdaptItCharMapDelimiter.Length; nLength = strProjectFileContents.IndexOfAny(caSplitChars, nIndex) - nIndex; strProjectFileContents = ReplaceSubstring(strProjectFileContents, nIndex, nLength, "0"); } } } // see about replacing the font names if (m_strDefaultUnicodeFontSource != m_strStatusBoxDefaultFont) { nIndex = strProjectFileContents.IndexOf(strFontNameSource); nLength = strFontNameSource.Length; strProjectFileContents = ReplaceSubstring(strProjectFileContents, nIndex, nLength, m_strDefaultUnicodeFontSource); } else { nIndex = strProjectFileContents.IndexOf(cstrAdaptItFontNameDelimiter); nIndex = strProjectFileContents.IndexOf(cstrAdaptItFontNameDelimiter, nIndex); } if (m_strDefaultUnicodeFontTarget != m_strStatusBoxDefaultFont) { nIndex = strProjectFileContents.IndexOf(strFontNameTarget, nIndex + nLength); nLength = strFontNameTarget.Length; strProjectFileContents = ReplaceSubstring(strProjectFileContents, nIndex, nLength, m_strDefaultUnicodeFontTarget); } int nIndexPunctDelimiter = strProjectFileContents.IndexOf(cstrAdaptItPunctuationPairsLegacy, nIndex); nIndex = nIndexPunctDelimiter + cstrAdaptItPunctuationPairsLegacy.Length; nLength = strProjectFileContents.IndexOfAny(caSplitChars, nIndex) - nIndex; string strPunctuation = strProjectFileContents.Substring(nIndex, nLength); char[] aPunctSource, aPunctTarget; UnpackPunctuationLegacy(strPunctuation, out aPunctSource, out aPunctTarget); string strNewPunctuationSource = new string(aPunctSource); AppendStatusOutputNl("found: legacy source punctuation: ", m_strStatusBoxDefaultFont, true); AppendStatusOutput(strNewPunctuationSource, strFontNameSource, true); string strNewPunctuationSourceConverted = strNewPunctuationSource; if (aEcSource != null) strNewPunctuationSourceConverted = aEcSource.Convert(strNewPunctuationSource); if (strNewPunctuationSourceConverted != strNewPunctuationSource) AppendStatusOutputNl("converted to: " + strNewPunctuationSourceConverted, m_strDefaultUnicodeFontSource, true); else AppendStatusOutputNl("result: no changes", m_strStatusBoxDefaultFont, true); string strNewPunctuationTarget = new string(aPunctTarget); AppendStatusOutputNl("found: legacy target punctuation: ", m_strStatusBoxDefaultFont, true); AppendStatusOutput(strNewPunctuationTarget, strFontNameTarget, true); string strNewPunctuationTargetConverted = strNewPunctuationTarget; if (aEcTarget != null) strNewPunctuationTargetConverted = aEcTarget.Convert(strNewPunctuationTarget); if (strNewPunctuationTargetConverted != strNewPunctuationTarget) AppendStatusOutputNl("converted to: " + strNewPunctuationTargetConverted, m_strDefaultUnicodeFontTarget, true); else AppendStatusOutputNl("result: no changes", m_strStatusBoxDefaultFont, true); nIndex = strProjectFileContents.IndexOf(cstrAdaptItPunctuationExtraLegacy, nIndex) + cstrAdaptItPunctuationExtraLegacy.Length; nLength = strProjectFileContents.IndexOfAny(caSplitChars, nIndex) - nIndex; string strProjectFileContentsNew = strProjectFileContents.Substring(0, nIndexPunctDelimiter) + cstrAdaptItPunctuationPairsNRSource + strNewPunctuationSourceConverted + CRLF + cstrAdaptItPunctuationPairsNRTarget + strNewPunctuationTargetConverted + CRLF + cstrAdaptItPunctuationExtraNR + strProjectFileContents.Substring(nIndex); // as a special case, if the 'after-conversion' fonts are both defined and are equal to each other, // then go ahead and update in the project file if ( (strFontNameSource == strFontNameTarget) && (m_strDefaultUnicodeFontSource != m_strStatusBoxDefaultFont) && (m_strDefaultUnicodeFontTarget != m_strStatusBoxDefaultFont) && (m_strDefaultUnicodeFontSource == m_strDefaultUnicodeFontTarget)) strProjectFileContentsNew = strProjectFileContentsNew.Replace(strFontNameSource, m_strDefaultUnicodeFontSource); InsureDirectoryExists(strProjectFileTarget); // don't use WriteAllText (c.f. ReadAllText above), because that inserts the BOM which causes AIU grief byte[] abyContents = Encoding.UTF8.GetBytes(strProjectFileContentsNew); File.WriteAllBytes(strProjectFileTarget, abyContents); }
void buttonSelectGlossConverter_Click(object sender, System.EventArgs e) { ConvType eFilter = (IsLegacyToUnicode) ? ConvType.Legacy_to_from_Unicode : ConvType.Unicode_to_from_Legacy; m_aEcGloss = GetEncConverters.AutoSelectWithTitle(eFilter, "Choose Glossing Language Converter"); if (m_aEcGloss != null) labelGlossLanguageConverter.Text = m_aEcGloss.Name; else labelGlossLanguageConverter.Text = cstrDefaultConvertLabelGloss; }
protected void ConvertKbFile(string strKbFileSource, string strKbFileTarget, IEncConverter aEcSource, IEncConverter aEcTarget, string strFontNameSource, string strFontNameTarget) { // Since AdaptIt will make different records for two words which are canonically // equivalent, if we use the class object to read it in via ReadXml, that will throw // an exception in such a case. So see if using XmlDocument is any less restrictive try { AppendStatusOutputNl("Processing KB file: " + strKbFileSource, m_strStatusBoxDefaultFont, true); string strTempKbFileSource = strKbFileSource; CheckForIncorrectEncodingString(ref strTempKbFileSource); XmlDocument doc; XPathNavigator navigator; XmlNamespaceManager manager; GetXmlDocument(strTempKbFileSource, out doc, out navigator, out manager); XPathNodeIterator xpMapIterator = navigator.Select("/aikb:AdaptItKnowledgeBase/aikb:KB/aikb:MAP", manager); progressBarAdaptationFile.Visible = true; // can't have two source words with the same value List<string> astrSourceWords = new List<string>(); while (xpMapIterator.MoveNext()) { // find the first (next) source word element XPathNodeIterator xpSourceWords = xpMapIterator.Current.Select("aikb:TU", manager); progressBarAdaptationFile.Value = 0; progressBarAdaptationFile.Maximum = xpSourceWords.Count; while (xpSourceWords.MoveNext()) { progressBarAdaptationFile.Value++; // get an iterator for the source word attribute (so we can change it later) XPathNodeIterator xpSourceWord = xpSourceWords.Current.Select("@k", manager); if (xpSourceWord.MoveNext()) { // get and convert the source word value string strSourceWord = xpSourceWord.Current.Value; string strSourceWordConverted = ((aEcSource != null) && !String.IsNullOrEmpty(strSourceWord)) ? aEcSource.Convert(strSourceWord) : strSourceWord; // if this word has already come up before, then we have to do something else (TODO: e.g. merge the two) if (astrSourceWords.Contains(strSourceWordConverted)) { AppendStatusOutputNl("Found two source words that have the same value: ", m_strStatusBoxDefaultFont, true); AppendStatusOutput(strSourceWordConverted, m_strDefaultUnicodeFontSource, true); while (astrSourceWords.Contains(strSourceWordConverted)) strSourceWordConverted = "DuplicateOf:" + strSourceWordConverted; AppendStatusOutput(". Changing it to: ", m_strStatusBoxDefaultFont, true); AppendStatusOutput(strSourceWordConverted, m_strDefaultUnicodeFontSource, true); } AppendStatusOutputNl("source: ", m_strStatusBoxDefaultFont, false); AppendStatusOutput(strSourceWord, strFontNameSource, false); if (strSourceWord != strSourceWordConverted) { // otherwise, just change the value in-situ xpSourceWord.Current.SetValue(strSourceWordConverted); astrSourceWords.Add(strSourceWordConverted); AppendStatusOutput(", becomes: ", m_strStatusBoxDefaultFont, false); AppendStatusOutput(strSourceWordConverted, m_strDefaultUnicodeFontSource, false); } else { AppendStatusOutput(cstrNoChange, m_strStatusBoxDefaultFont, false); } // now get an iterator for all of the target words for the current source word // (here we'll go directly to the attribute value) XPathNodeIterator xpTargetWords = xpSourceWords.Current.Select("aikb:RS", manager); // maintain a list of all target words in case the conversion merges them. List<string> astrTargetWords = new List<string>(); while (xpTargetWords.MoveNext()) { XPathNodeIterator xpTargetWord = xpTargetWords.Current.Select("@a", manager); if (xpTargetWord.MoveNext()) { // get and convert the target word string strTargetWord = xpTargetWord.Current.Value; string strTargetWordConverted = ((aEcTarget != null) && !String.IsNullOrEmpty(strTargetWord)) ? aEcTarget.Convert(strTargetWord) : strTargetWord; // if this word has already come up before, then we have to do something else (TODO: e.g. merge the two) if (astrTargetWords.Contains(strTargetWordConverted)) { AppendStatusOutputNl("Found two target words that have the same value: ", m_strStatusBoxDefaultFont, true); AppendStatusOutput(strTargetWordConverted, m_strDefaultUnicodeFontTarget, true); while (astrTargetWords.Contains(strTargetWordConverted)) strTargetWordConverted = "DuplicateOf:" + strTargetWordConverted; AppendStatusOutput(". Changing it to: ", m_strStatusBoxDefaultFont, true); AppendStatusOutput(strTargetWordConverted, m_strDefaultUnicodeFontTarget, true); } AppendStatusOutputNl("target: ", m_strStatusBoxDefaultFont, false); AppendStatusOutput(strTargetWord, strFontNameTarget, false); if (strTargetWord != strTargetWordConverted) { // otherwise, just change the value in-situ xpTargetWord.Current.SetValue(strTargetWordConverted); astrTargetWords.Add(strTargetWordConverted); AppendStatusOutput(", becomes: ", m_strStatusBoxDefaultFont, false); AppendStatusOutput(strTargetWordConverted, m_strDefaultUnicodeFontTarget, false); } else { AppendStatusOutput(cstrNoChange, m_strStatusBoxDefaultFont, false); } } } } } } // now write it to the target folder XmlTextWriter writer = new XmlTextWriter(strKbFileTarget, Encoding.UTF8); writer.Formatting = Formatting.Indented; doc.Save(writer); progressBarAdaptationFile.Visible = false; } catch (System.Data.DataException ex) { if (ex.Message == "A child row has multiple parents.") { // this happens when the knowledge base has invalid data in it (e.g. when there is two // canonically equivalent words in different records). This is technically a bug in // AdaptIt. throw new ApplicationException(String.Format("The AdaptIt xml file '{0}' has invalid data in it! Contact [email protected]", strKbFileSource), ex); } throw ex; } catch (Exception ex) { throw new ApplicationException(String.Format("Unable to process the AdaptIt xml file '{0}'. Contact [email protected]", strKbFileSource), ex); } }
// this method is called either when the user clicks the "Apply" or "OK" buttons *OR* if she // tries to switch to the Test or Advanced tab. It is usually called by one of the sub-classes // which have overriden the method in order to confirm their own configuration information. So // here is checking code that all possible sub-classes must adhere to (or totally re-write). protected virtual bool OnApply() { // every converter must have a Converter Identifier (I think) if (String.IsNullOrEmpty(ConverterIdentifier)) return false; // if the user has switched to the Advanced tab... else if (m_bAdvancedTabVisited) { // means we're saving that extra information in the repository also (e.g. Encoding Names) // update the values from those the Advanced tab FriendlyName = textBoxFriendlyName.Text; LhsEncodingId = comboBoxEncodingNamesLhs.Text; RhsEncodingId = comboBoxEncodingNamesRhs.Text; ProcessType = ProcessTypesChecked; // finally, add it to the repository // (again, some sub-classes do something different at this point, so call a virtual function) AddConverterMapping(); IsModified = false; } else { m_aEC = InitializeEncConverter; IsModified = false; // finally, if we're in 'edit mode' and the converter is already in the repository // then re-add it to save changes to the repository (i.e. make the default behavior // to save to repository in this case, rather than requiring the user to explicitly // click the Update... button) if ((m_aEC != null) && m_bEditMode && IsInRepository) AddConverterMapping(); } return true; }
private void addToSystemRepositoryToolStripMenuItem_Click(object sender, EventArgs e) { // we have to have a file saved to add it if (m_strMapNameReal == null) saveAsToolStripMenuItem_Click(sender, e); // check again, just in case they cancelled. if (m_strMapNameReal != null) { m_aEC = null; // free it so we can re-create it with the "real" content string strFriendlyName = null, strLhsEncodingID = null, strRhsEncodingID = null; if (CompileRealMap()) { m_aEC = new TecEncConverter(); int nProcType = (int)ProcessTypeFlags.DontKnow; m_aEC.Initialize(cstrMyEncConverterName, m_strTecNameReal, ref strLhsEncodingID, ref strRhsEncodingID, ref m_eConvType, ref nProcType, 0, 0, true); } else return; // compile failed, so just quit if (m_aEC != null) { try { strFriendlyName = String.Format("{0}{2}{1}", strLhsEncodingID, strRhsEncodingID, (EncConverters.IsUnidirectional(m_aEC.ConversionType)) ? ">" : "<>"); } catch { } EncConverters aECs = new EncConverters(); IEncConverterConfig rConfigurator = m_aEC.Configurator; // call its Configure method to do the UI rConfigurator.Configure(aECs, strFriendlyName, m_eConvType, strLhsEncodingID, strRhsEncodingID); } } }
public virtual void Initialize ( IEncConverters aECs, string strHtmlFileName, string strDisplayName, string strFriendlyName, string strConverterIdentifier, ConvType eConversionType, string strLhsEncodingId, string strRhsEncodingId, int lProcessTypeFlags, bool bIsInRepository ) { m_strOriginalFriendlyName = FriendlyName = strFriendlyName; ConverterIdentifier = strConverterIdentifier; LhsEncodingId = strLhsEncodingId; RhsEncodingId = strRhsEncodingId; m_eOrigConvType = ConversionType = eConversionType; ProcessType = lProcessTypeFlags; IsInRepository = bIsInRepository; m_aECs = aECs; // if the identifier is given, then it means we're editing. // (which means our button says *Update* rather than "Save in system repository" // and we should ask during OnOK whether they want to update or not) m_bEditMode = !String.IsNullOrEmpty(ConverterIdentifier); // if we're editing, then it starts out clean IsModified = !m_bEditMode; // if we're editing, then we already have this converter in the collection (even if it's // temporary) if (m_bEditMode) { m_aEC = m_aECs[FriendlyName]; if (FriendlyName.IndexOf(EncConverters.cstrTempConverterPrefix) == 0) FriendlyName = m_strOriginalFriendlyName = null; } // this parameter seems the most confusing and yet is a crucial part of EncConverters // so if this is *given* to us, then just use those values rather than prompting the user // for them (e.g. FW knows that the BulkEdits are Unicode_to_(from_)Unicode, so we don't // have to bother the user with it. // If we're in 'edit' mode, it is often because the user has mis-configured these parameters // so if edit mode, then query for the ConvType value. if ((ConversionType == ConvType.Unknown) || m_bEditMode) { m_bQueryForConvType = true; SetConvTypeControls(); } this.Text = strDisplayName; // get the help for the about tab RegistryKey keyRoot = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\SIL\SilEncConverters31", false); if (keyRoot != null) { string strXmlFilePath = (string)keyRoot.GetValue("RootDir"); if (strXmlFilePath[strXmlFilePath.Length - 1] != '\\') strXmlFilePath += '\\'; strXmlFilePath += @"help\" + strHtmlFileName; System.Diagnostics.Debug.Assert(System.IO.File.Exists(strXmlFilePath), String.Format("Can find '{0}'. If this is a development machine, you need to add the following reg key to see the About help files: HLKM\\SOFTWARE\\SIL\\SilEncConverters31\\[RootDir] = '<parent folder where the 'help' sub-folder exists>' along with a trailing slash (e.g. \"C:\\fw\\lib\\release\\\")", strHtmlFileName)); this.webBrowserHelp.Url = new Uri(strXmlFilePath); } #if DEBUG else throw new ApplicationException(@"Can't read the HLKM\SOFTWARE\SIL\SilEncConverters31\[RootDir] registry key!"); #endif ecTextBoxInput.Text = "Test Data"; }
public void NoConvert() { m_EncCvtrMap = null; // if the map is empty, this means the lang is already UTF8 m_iconverter = null; // also null }
// see if the user has some hidden SFM marker which we'll ask whether they want converted or not // the value could be things like: // "\c 1 \v 1 " // or /* // "\~FILTER \note a note a second line a third line it is okay to type ENTER to begin each new line the end \note* \~FILTER* \~FILTER \free This is a bit of free translation. \free* \~FILTER* " */ protected void CheckForEmbeddedMarkers(XmlAttributeCollection xnAttributes, string strAttributeName, IEncConverter aEC) { XmlAttribute xa = xnAttributes[strAttributeName]; if (xa != null) { string strValue = xa.Value; if (!String.IsNullOrEmpty(strValue)) { // put all text between "\" into an array of strings int nIndexThat, nIndexBOC, nLengthContents, nIndexThis = strValue.IndexOf('\\'); List<string> astrOpenedMarkers = new List<string>(); while (nIndexThis != -1) { string strMarker, strContents; if (FindMarkerAndContents(strValue, nIndexThis, out nIndexThat, out nIndexBOC, out strMarker, out strContents, out nLengthContents, astrOpenedMarkers)) { List<string> astrSfmContents; if (!m_mapFilteredSfms.TryGetValue(strMarker, out astrSfmContents)) { astrSfmContents = new List<string>(); m_mapFilteredSfms.Add(strMarker, astrSfmContents); } // do about 20 occurrences max (just in case there's lots!) if (astrSfmContents.Count < cnMaxExamples) astrSfmContents.Add(strContents); } // check the next chunk nIndexThis = nIndexThat; } } } }
public virtual void AddConverterStep(IEncConverter rConvert, bool bDirectionForward, NormalizeFlags eNormalizeOutput) { m_aEncConverter.Add(rConvert); m_aDirectionForward.Add(bDirectionForward); m_aNormalizeOutput.Add(eNormalizeOutput); }
public FindWordProcessor(string strFindWhat, string strReplaceWith, bool bMatchCase, Font font) { if (m_aECs == null) m_aECs = new EncConverters(true); // for some reason, the text that goes to constructing the 'Find what' part of the CRegexMatcher is // expecting doubly-escaped text (e.g. "\\r" for CR), but the text that goes for the 'Replace with' // (i.e. the CRegex::ReplaceAll) is expecting singly-escaped text. Our text boxes, however, will always // return these as doubly-escaped. So for the 'Replace with' stuff, we need to turn certain doubly- // escaped codes into their single-escaped flavors). int nNumEscapeCodes = astrReplaceDoubleEscapeCodes.Length; for (int i = 0; i < nNumEscapeCodes; i++) strReplaceWith = strReplaceWith.Replace(astrReplaceDoubleEscapeCodes[i], astrReplaceEscapeCodes[i]); m_aECRegex = InitSearchFontConverter(strFindWhat, strReplaceWith, font, bMatchCase); AutoReplaceOnNextFind = false; // we'll take care of this as well // Normally, we search the text one paragraph at a time for the FindWhat string, but if the user // has multiple "\r"s in the search string, it means we're supposed to find stuff beyond paragraph // boundaries. So indicate how many paragraphs we should include in the Search based on the number // of "\r"s in the search string... string[] strTokens = strFindWhat.Split(new string[] { @"\r\n", @"\r" }, StringSplitOptions.None); NumOfParagraphsToSearch = strTokens.Length; IsAnyCRs = (NumOfParagraphsToSearch > 1); // ... however, we don't need to get an extra paragraph if the \r occurs at the end of the FindWhat string if (String.IsNullOrEmpty(strTokens[NumOfParagraphsToSearch - 1])) { NumOfParagraphsToSearch--; } }
private void DoEdit(EncConverters aECs, IEncConverter aEC, string strProjectName, string strFontName, string sFontSize) { this.textBoxNewProjectName.Text = strProjectName; this.textBoxWordBoundaryDelimiter.Text = m_strWordBoundaryDelimiter; // new in 1.2 (so it might not exist) this.textBoxAddlPunctuation.Text = this.DecodePunctuationForCC(m_strNonWordCharacters); this.listBoxFontSize.SelectedItem = sFontSize; this.comboBoxFont.SelectedItem = strFontName; m_bLegacy = (aEC.ConversionType == ConvType.Legacy_to_Legacy); this.checkBoxUnicode.Checked = !m_bLegacy; if( m_bLegacy ) { this.labelCP.Visible = this.textBoxCP.Visible = true; this.textBoxCP.Text = aECs.CodePage(strFontName).ToString(); } // update the "Add New Project" button to say "Update Project" this.groupBoxNewProject.Text = "Edit Project Settings"; this.buttonAddNewProject.Text = "Update &Project"; this.toolTips.SetToolTip(this.buttonAddNewProject, "Click to update the project information"); this.textBoxNewProjectName.ReadOnly = true; EnableAddNewProjectButton(); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Convert a file and display it in the window /// </summary> /// ----------------------------------------------------------------------------------- public void DoFileConvert(IEncConverter ec, string inputFilename) { CheckDisposed(); // start hour glass using (new WaitCursor(this)) { // open the input and output files using the given encoding formats // 28591 is a 'magic' code page that stuffs each input byte into // the low byte of the unicode character, leaving the top byte zero. // This is a good code page to use because it is simple and fully reversible // for any input. using (StreamReader reader = new StreamReader(inputFilename, Encoding.GetEncoding(EncodingConstants.kMagicCodePage), true)) { // This tells the converter that the input will be 16-bit characters // produced by converting the bytes of the file using CP28591. ec.CodePageInput = EncodingConstants.kMagicCodePage; ec.EncodingIn = ECInterfaces.EncodingForm.LegacyString; reader.BaseStream.Seek(0, SeekOrigin.Begin); // read the lines of the input file, (optionally convert,) and write them out. string sOutput = string.Empty; string sInput; m_savedOutput = new StringBuilder(); m_svOutput.Clear(false); m_fHasOutput = false; // Read the lines of the input file, convert them, and display them // in the view. while (reader.Peek() > -1) { sInput = reader.ReadLine(); if (sInput == string.Empty || sInput.StartsWith(@"\_sh ") || sInput.StartsWith(@"\id ")) sOutput = sInput; else sOutput = ConvertOneLine(ec, sInput); m_svOutput.AddPara(sOutput); m_savedOutput.AppendLine(sOutput); m_fHasOutput = true; } reader.Close(); m_svOutput.CompleteSetText(); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Convert one line of text for display /// </summary> /// <param name="ec"></param> /// <param name="input"></param> /// <returns></returns> /// ------------------------------------------------------------------------------------ private string ConvertOneLine(IEncConverter ec, string input) { string marker = string.Empty; string remainder = string.Empty; // if the input string is empty, don't try to convert it if (input == string.Empty) return input; // split the marker and the remainder portions of the text line. if (input[0] != '\\') remainder = input; else { int spacePosition = input.IndexOf(" "); if (spacePosition == -1) return input; else { marker = input.Substring(0, spacePosition); remainder = input.Substring(spacePosition); } } return marker + ec.Convert(remainder); }
private void buttonTargetLanguageConverter_Click(object sender, EventArgs e) { ConvType eFilter = (IsLegacyToUnicode) ? ConvType.Legacy_to_from_Unicode : ConvType.Unicode_to_from_Legacy; m_aEcTarget = GetEncConverters.AutoSelectWithTitle(eFilter, "Choose Target Language Converter"); if (m_aEcTarget != null) labelTargetLanguageConverter.Text = m_aEcTarget.Name; else labelTargetLanguageConverter.Text = cstrDefaultConvertLabelTarget; }
public bool SetConverter(EncConverters converters) { if (m_EncCvtrMap == null) return true; // if the map is empty, this means the lang is already UTF8 m_iconverter = converters[m_EncCvtrMap]; return (m_iconverter != null); }
protected void ConvertAttribute(XmlAttributeCollection xnAttributes, string strAttributeName, IEncConverter aEC) { XmlAttribute xa = xnAttributes[strAttributeName]; if (xa != null) { string strValue = xa.Value; if (!String.IsNullOrEmpty(strValue)) { string strValueConverted = (aEC != null) ? aEC.Convert(strValue) : strValue; xa.Value = strValueConverted; } } }
internal void NewDocument() { // reset the name m_strTecNameReal = m_strMapNameReal = null; InitCharacterMapDialogs(); Program.AddFilenameToTitle(m_strMapNameReal); // query the user for the ConvType (kind of need it) bool bUserCancelled = !QueryConvType(); InitTempVars(); // reset vars in case they were something else m_nCodePageLegacyLhs = 0; m_nCodePageLegacyRhs = 0; if (!bUserCancelled) { // for legacy encodings, prompt for the font. #if !DEBUG MessageBox.Show("Select the font for the left-hand side encoding", cstrCaption); #endif bUserCancelled |= !SetFontLhs(); } if (!bUserCancelled) { // for legacy encodings, prompt for the font. #if !DEBUG MessageBox.Show("Select the font for the right-hand side encoding", cstrCaption); #endif SetFontRhs(); } Point ptLocation = new Point(Location.X + Bounds.Size.Width, Location.Y); m_formDisplayUnicodeNamesLhs.Location = ptLocation; ptLocation = new Point(m_formDisplayUnicodeNamesLhs.Location.X, m_formDisplayUnicodeNamesLhs.Location.Y + m_formDisplayUnicodeNamesLhs.Bounds.Size.Height); m_formDisplayUnicodeNamesRhs.Location = ptLocation; // initialize it with our clues this.richTextBoxMapEditor.Text = String.Format("; This file was created by <author> using TECkitMappingEditorU.exe v{1} on {2}.{0}; {3}{4}{0}; {5}{6};{7}{0}; {8}{9};{10}{0}{11}{0}{12}{0}{13}{0}{0}", Environment.NewLine, Application.ProductVersion, DateTime.Now.ToShortDateString(), cstrConvTypeClue, m_eConvType.ToString(), cstrLhsFontClue, textBoxSample.Font.Name, textBoxSample.Font.Size, cstrRhsFontClue, textBoxSampleForward.Font.Name, textBoxSampleForward.Font.Size, BoundsClueString(cstrMainFormClue, Bounds), BoundsClueString(cstrCodePointFormClueLhs, m_formDisplayUnicodeNamesLhs.Bounds), BoundsClueString(cstrCodePointFormClueRhs, m_formDisplayUnicodeNamesRhs.Bounds)); if (IsLhsLegacy) { if (IsRhsLegacy) { this.richTextBoxMapEditor.Text += String.Format("LHSName \"canonical name of the 'source' encoding or left-hand side of the conversion\"{0}RHSName \"canonical name of the 'target' encoding or right-hand side of the conversion\"{0}LHSDescription \"description for the left-hand side of the mapping\"{0}RHSDescription \"description for the right-hand side of the mapping\"{0}Version \"1\"{0}Contact \"mailto:user@addr\"{0}RegistrationAuthority \"the organization responsible for the encoding\"{0}RegistrationName \"the name and version of the mapping, as recognized by that authority\"{0}Copyright \"© {1} <CompanyName>. All rights reserved.\"{0}LHSFlags (){0}RHSFlags (){0}{0}pass(Byte){0}{0}; type a 'k' in the 'Left-side Sample' box below to see how this works.{0}107 <> 110 ; 'k' <> 'n'{0}", Environment.NewLine, DateTime.Today.Year); } else { this.richTextBoxMapEditor.Text += String.Format("EncodingName \"a canonical name that uniquely identifies this mapping table from all others\"{0}DescriptiveName \"a string that describes the mapping\"{0}Version \"1\"{0}Contact \"mailto:user@addr\"{0}RegistrationAuthority \"the organization responsible for the encoding\"{0}RegistrationName \"the name and version of the mapping, as recognized by that authority\"{0}Copyright \"© {1} <CompanyName>. All rights reserved.\"{0}LHSFlags (){0}RHSFlags (){0}{0}pass(Byte_Unicode){0}{0}; type a 'k' in the 'Left-side Sample' box below to see how this works.{0}107 <> LATIN_SMALL_LETTER_N ; 'k' <> 'n'{0}", Environment.NewLine, DateTime.Today.Year); } } else { if (IsRhsLegacy) { this.richTextBoxMapEditor.Text += String.Format("LHSName \"canonical name of the 'source' encoding or left-hand side of the conversion\"{0}RHSName \"canonical name of the 'target' encoding or right-hand side of the conversion\"{0}LHSDescription \"description for the left-hand side of the mapping\"{0}RHSDescription \"description for the right-hand side of the mapping\"{0}Version \"1\"{0}Contact \"mailto:user@addr\"{0}RegistrationAuthority \"the organization responsible for the encoding\"{0}RegistrationName \"the name and version of the mapping, as recognized by that authority\"{0}Copyright \"© {1} <CompanyName>. All rights reserved.\"{0}LHSFlags (){0}RHSFlags (){0}{0}pass(Unicode_Byte){0}{0}; type a 'k' in the 'Left-side Sample' box below to see how this works.{0}LATIN_SMALL_LETTER_K <> 110 ; 'k' <> 'n'{0}", Environment.NewLine, DateTime.Today.Year); } else { this.richTextBoxMapEditor.Text += String.Format("LHSName \"canonical name of the 'source' encoding or left-hand side of the conversion\"{0}RHSName \"canonical name of the 'target' encoding or right-hand side of the conversion\"{0}LHSDescription \"description for the left-hand side of the mapping\"{0}RHSDescription \"description for the right-hand side of the mapping\"{0}Version \"1\"{0}Contact \"mailto:user@addr\"{0}RegistrationAuthority \"the organization responsible for the encoding\"{0}RegistrationName \"the name and version of the mapping, as recognized by that authority\"{0}Copyright \"© {1} <CompanyName>. All rights reserved.\"{0}LHSFlags (){0}RHSFlags (){0}{0}pass(Unicode){0}{0}; type a 'k' in the 'Left-side Sample' box below to see how this works.{0}LATIN_SMALL_LETTER_K <> LATIN_SMALL_LETTER_N ; 'k' <> 'n'{0}", Environment.NewLine, DateTime.Today.Year); } } this.richTextBoxMapEditor.Select(richTextBoxMapEditor.Text.Length, 0); // so it re-creates for this "new" map m_aEC = null; Program.Modified = false; // until the user does something, this doesn't need to be saved }
protected void ConvertEmbeddedMarkers(XmlAttributeCollection xnAttributes, string strAttributeName, IEncConverter aEC, List<string> astrSfmsToConvert) { XmlAttribute xa = xnAttributes[strAttributeName]; if (xa != null) { string strValue = xa.Value; if (!String.IsNullOrEmpty(strValue)) { // iterate thru the chunks of sfm data and convert them with the source converter if in the // list of SFMs to convert int nIndexThat, nIndexBOC, nLengthContents, nIndexThis = strValue.IndexOf('\\'); List<string> astrOpenedMarkers = new List<string>(); while (nIndexThis != -1) { string strMarker, strContents; if (FindMarkerAndContents(strValue, nIndexThis, out nIndexThat, out nIndexBOC, out strMarker, out strContents, out nLengthContents, astrOpenedMarkers)) { // check if it's in the list of SFMs to convert if (astrSfmsToConvert.Contains(strMarker)) { string strContentsConverted = aEC.Convert(strContents); strValue = ReplaceSubstring(strValue, nIndexThis + nIndexBOC, nLengthContents, strContentsConverted); } } nIndexThis = nIndexThat; } xa.Value = strValue; } } }
private void UpdateTextChanged(TextBox tbSrc, TextBox tbDst, IEncConverter aEC, bool bDirectionForward) { if (tbSrc.Text.Length > 0) { if (aEC != null) { try { tbDst.Text = null; // to force the "TextChanged" aEC.DirectionForward = bDirectionForward; tbDst.Text = aEC.Convert(tbSrc.Text); } catch (ECException e) { if (e.ErrorCode != (int)ErrStatus.InvalidForm) MessageBox.Show(e.Message); } } } else tbDst.Text = null; }
internal bool OpenDocument(string strMapName) { if (Program.Modified) CheckForSaveDirtyFile(); InitCharacterMapDialogs(); bool bModified = false; // if we are dealing with a real file... m_strMapNameReal = strMapName; // check to see if it exists (the alternate exception isn't very helpful) if (!File.Exists(m_strMapNameReal)) { MessageBox.Show(String.Format("The file '{0}' doesn't exist!", m_strMapNameReal, cstrCaption)); return false; } // otherwise, determine the .tec filename m_strTecNameReal = m_strMapNameReal.Remove(m_strMapNameReal.Length - 3, 3) + "tec"; Program.AddFilenameToTitle(m_strMapNameReal); // and put it's contents into the editor. this.richTextBoxMapEditor.Lines = File.ReadAllLines(m_strMapNameReal, m_enc); // see if our 'clues' are in the file ConvType eConvType = ConvType.Unknown; bool bLhsFontFound = false; bool bRhsFontFound = false; bool bCodePointFormSizeHasBeenSetLhs = false; bool bCodePointFormSizeHasBeenSetRhs = false; m_nCodePageLegacyLhs = 0; m_nCodePageLegacyRhs = 0; foreach (string strLine in richTextBoxMapEditor.Lines) { int nIndex = strLine.IndexOf(cstrConvTypeClue); if (nIndex != -1) { string strConvType = strLine.Substring(nIndex + cstrConvTypeClue.Length); foreach (string asName in Enum.GetNames(typeof(ConvType))) { if (asName == strConvType) { eConvType = (ConvType)Enum.Parse(typeof(ConvType), strConvType); break; } } } nIndex = strLine.IndexOf(cstrLhsFontClue); if (nIndex != -1) { int nDelimiter = strLine.LastIndexOf(';'); int nLen = nDelimiter - (nIndex + cstrLhsFontClue.Length); string strFontName = strLine.Substring(nIndex + cstrLhsFontClue.Length, nLen); string strFontSize = strLine.Substring(nDelimiter + 1); float emSize = Convert.ToSingle(strFontSize); Font font = Program.GetSafeFont(strFontName, emSize); textBoxSample.Font = font; textBoxSampleReverse.Font = font; bLhsFontFound = true; } nIndex = strLine.IndexOf(cstrRhsFontClue); if (nIndex != -1) { int nDelimiter = strLine.LastIndexOf(';'); int nLen = nDelimiter - (nIndex + cstrRhsFontClue.Length); string strFontName = strLine.Substring(nIndex + cstrRhsFontClue.Length, nLen); string strFontSize = strLine.Substring(nDelimiter + 1); float emSize = Convert.ToSingle(strFontSize); Font font = Program.GetSafeFont(strFontName, emSize); textBoxSampleForward.Font = font; bRhsFontFound = true; } nIndex = strLine.IndexOf(cstrLhsCodePageClue); if (nIndex != -1) { string strCodePage = strLine.Substring(nIndex + cstrLhsCodePageClue.Length); try { m_nCodePageLegacyLhs = Convert.ToInt32(strCodePage); } catch { } } nIndex = strLine.IndexOf(cstrRhsCodePageClue); if (nIndex != -1) { string strCodePage = strLine.Substring(nIndex + cstrRhsCodePageClue.Length); try { m_nCodePageLegacyRhs = Convert.ToInt32(strCodePage); } catch { } } nIndex = strLine.IndexOf(cstrMainFormClue); if (nIndex != -1) { try { string strXYWH = strLine.Substring(nIndex + cstrMainFormClue.Length); string[] aStrBounds = strXYWH.Split(new char[] { ',' }); Rectangle rectBounds = new Rectangle ( Int32.Parse(aStrBounds[0]), Int32.Parse(aStrBounds[1]), Int32.Parse(aStrBounds[2]), Int32.Parse(aStrBounds[3]) ); if (SetBounds(this, ref rectBounds)) SetBoundsClue(cstrMainFormClue, rectBounds); } catch { } } // search for the character map window location (what used to be the 'code point' window) string strClue = cstrCodePointFormClueLhs; nIndex = strLine.IndexOf(cstrCodePointFormClueLhs); if (nIndex != -1) { try { string strXYWH = strLine.Substring(nIndex + strClue.Length); string[] aStrBounds = strXYWH.Split(new char[] { ',' }); Rectangle rectBounds = new Rectangle ( Int32.Parse(aStrBounds[0]), Int32.Parse(aStrBounds[1]), Int32.Parse(aStrBounds[2]), Int32.Parse(aStrBounds[3]) ); if (SetBounds(m_formDisplayUnicodeNamesLhs, ref rectBounds)) SetBoundsClue(strClue, rectBounds); bCodePointFormSizeHasBeenSetLhs = true; } catch { } } nIndex = strLine.IndexOf(cstrCodePointFormClueRhs); if (nIndex != -1) { try { string strXYWH = strLine.Substring(nIndex + cstrCodePointFormClueRhs.Length); string[] aStrBounds = strXYWH.Split(new char[] { ',' }); Rectangle rectBounds = new Rectangle ( Int32.Parse(aStrBounds[0]), Int32.Parse(aStrBounds[1]), Int32.Parse(aStrBounds[2]), Int32.Parse(aStrBounds[3]) ); if (SetBounds(m_formDisplayUnicodeNamesRhs, ref rectBounds)) SetBoundsClue(cstrCodePointFormClueRhs, rectBounds); bCodePointFormSizeHasBeenSetRhs = true; } catch { } } } // if we didn't find the ConvType, then query for it bool bUserCancelled = false; if (eConvType == ConvType.Unknown) bUserCancelled = !QueryConvType(); else ConversionType = eConvType; InitTempVars(); if (!bUserCancelled && !bLhsFontFound) { // for legacy encodings, prompt for the font. MessageBox.Show("Select the font for the left-hand side encoding", cstrCaption); bUserCancelled |= !SetFontLhs(); } else if (unicodeValuesWindowToolStripMenuItem.Checked) { if (IsLhsLegacy && (m_nCodePageLegacyLhs == 0)) { EncConverters aECs = new EncConverters(true); try { m_nCodePageLegacyLhs = aECs.CodePage(textBoxSample.Font.Name); } catch { } } m_formDisplayUnicodeNamesLhs.Initialize(IsLhsLegacy, textBoxSample.Font, m_nCodePageLegacyLhs); } if (!bUserCancelled && !bRhsFontFound) { // for legacy encodings, prompt for the font. MessageBox.Show("Select the font for the right-hand side encoding", cstrCaption); SetFontRhs(); } else if (unicodeValuesWindowToolStripMenuItem.Checked) { if (IsRhsLegacy && (m_nCodePageLegacyRhs == 0)) { EncConverters aECs = new EncConverters(true); try { m_nCodePageLegacyRhs = aECs.CodePage(textBoxSampleForward.Font.Name); } catch { } } m_formDisplayUnicodeNamesRhs.Initialize(IsRhsLegacy, textBoxSampleForward.Font, m_nCodePageLegacyRhs); } if (!bCodePointFormSizeHasBeenSetLhs) { Point ptLocation = new Point(Location.X + Bounds.Size.Width, Location.Y); m_formDisplayUnicodeNamesLhs.Location = ptLocation; } if (!bCodePointFormSizeHasBeenSetRhs) { Point ptLocation = new Point(m_formDisplayUnicodeNamesLhs.Location.X, m_formDisplayUnicodeNamesLhs.Location.Y + m_formDisplayUnicodeNamesLhs.Bounds.Size.Height); m_formDisplayUnicodeNamesRhs.Location = ptLocation; } if (!bLhsFontFound || !bRhsFontFound || !bCodePointFormSizeHasBeenSetLhs || !bCodePointFormSizeHasBeenSetRhs) { // initialize it with our clues string strPrefixHeader = cstrOpeningHeader + String.Format("v{1} on {2}.{0}; {3}{4}{0}; {5}{6};{7}{0}; {8}{9};{10}{0}{11}{0}{12}{0}{13}{0}", Environment.NewLine, Application.ProductVersion, DateTime.Now.ToShortDateString(), cstrConvTypeClue, m_eConvType.ToString(), cstrLhsFontClue, textBoxSample.Font.Name, textBoxSample.Font.Size, cstrRhsFontClue, textBoxSampleForward.Font.Name, textBoxSampleForward.Font.Size, BoundsClueString(cstrMainFormClue, Bounds), BoundsClueString(cstrCodePointFormClueLhs, m_formDisplayUnicodeNamesLhs.Bounds), BoundsClueString(cstrCodePointFormClueRhs, m_formDisplayUnicodeNamesRhs.Bounds)); strPrefixHeader += AddCodePageClue(cstrLhsCodePageClue, m_nCodePageLegacyLhs); strPrefixHeader += AddCodePageClue(cstrRhsCodePageClue, m_nCodePageLegacyRhs); strPrefixHeader += String.Format("{0}", Environment.NewLine); this.richTextBoxMapEditor.Text = strPrefixHeader + SkipPast0900Header; bModified = true; } // so it re-creates for this "new" map m_aEC = null; Program.Modified = bModified; return true; }
public void SaveTempAndCompile() { File.WriteAllLines(m_strMapNameTemp, this.richTextBoxMapEditor.Lines, m_enc); try { string strTecName = m_strTecNameTemp; TECkitDllWrapper.CompileMap(m_strMapNameTemp, ref strTecName); // if the compiler had to use a different file, then clear the reference to rebuild it // if (m_strTecNameTemp != strTecName) m_aEC = null; this.textBoxCompilerResults.Text = "Compiled successfully!"; // now that we have something we can compile successfully, create a converter of it if (m_aEC == null) { m_strTecNameTemp = strTecName; m_aEC = new TecEncConverter(); string strDummy = null; int nProcType = (int)ProcessTypeFlags.DontKnow; m_aEC.Initialize(cstrMyEncConverterName, m_strTecNameTemp, ref strDummy, ref strDummy, ref m_eConvType, ref nProcType, m_nCodePageLegacyLhs, m_nCodePageLegacyRhs, true); } if (this.textBoxSample.Text.Length > 0) { UpdateTextChanged(this.textBoxSample, this.textBoxSampleForward, m_aEC, true); UpdateUnicodeDetails(this.textBoxSample); } } catch (Exception ex) { this.textBoxCompilerResults.Text = ex.Message; // clear the converter so we don't accidentally call it while we don't have a good map m_aEC = null; } }
protected void SetConverter(string strFontName, ref IEncConverter aEC, Label aLabel, ref string strConvertedFontName) { string strMappingName = GetEncConverters.GetMappingNameFromFont(strFontName); if (!String.IsNullOrEmpty(strMappingName)) { aEC = GetEncConverters[strMappingName]; if (aEC != null) aLabel.Text = aEC.Name; // also see if we have a default font for the converted text string[] astrFontMappings = GetEncConverters.GetFontMapping(aEC.Name, strFontName); if (astrFontMappings.Length > 0) strConvertedFontName = astrFontMappings[0]; } Font font; if (!m_mapFonts.TryGetValue(strConvertedFontName, out font)) { font = new Font(strConvertedFontName, m_nStatusBoxDefaultFontSize); m_mapFonts.Add(strConvertedFontName, font); } }
protected void ConvertAdaptationFile(string strAdaptationFileSource, string strAdaptationFileTarget, IEncConverter aEcSource, IEncConverter aEcTarget, IEncConverter aEcGloss, string strFontNameSource, string strFontNameConvertedSource) { // Since AdaptIt will make different records for two words which are canonically // equivalent, if we use the class object to read it in via ReadXml, that will throw // an exception in such a case. So see if using XmlDocument is any less restrictive try { string strTempAdaptationFileSource = strAdaptationFileSource; CheckForIncorrectEncodingString(ref strTempAdaptationFileSource); AppendStatusOutputNl("Processing Adaptation file: " + strAdaptationFileSource, m_strStatusBoxDefaultFont, true); XmlDocument doc = new XmlDocument(); doc.Load(strTempAdaptationFileSource); XmlNodeList xnlBucketIterator = doc.SelectNodes("/AdaptItDoc//S"); // use "//" since the 'S' element can be embedded // go thru it all looking for extra fields we'll need to convert from within the 'm', 'mm' fields. foreach (XmlNode xnBucket in xnlBucketIterator) { XmlAttributeCollection xacAttributes = xnBucket.Attributes; CheckForEmbeddedMarkers(xacAttributes, "m", aEcSource); CheckForEmbeddedMarkers(xacAttributes, "mm", aEcSource); } // ask the user to decide about these fields FilteredFieldsForm dlg = new FilteredFieldsForm(m_mapFilteredSfms, m_astrSfmsToConvert, m_astrSfmsToNotConvert, m_mapFonts[strFontNameSource], m_mapFonts[strFontNameConvertedSource], aEcSource); if (dlg.ShowDialog() == DialogResult.OK) dlg.DivyUpSfmsToConvert(m_astrSfmsToConvert, m_astrSfmsToNotConvert); progressBarAdaptationFile.Visible = true; progressBarAdaptationFile.Value = 0; progressBarAdaptationFile.Maximum = xnlBucketIterator.Count; foreach (XmlNode xnBucket in xnlBucketIterator) { progressBarAdaptationFile.Value++; // convert: <S s="I" k="I" t="v3.0" a="v3.0" XmlAttributeCollection xacAttributes = xnBucket.Attributes; ConvertAttribute(xacAttributes, "s", aEcSource); ConvertAttribute(xacAttributes, "k", aEcSource); ConvertAttribute(xacAttributes, "pp", aEcSource); ConvertAttribute(xacAttributes, "fp", aEcSource); ConvertAttribute(xacAttributes, "mp", aEcSource); ConvertAttribute(xacAttributes, "t", aEcTarget); ConvertAttribute(xacAttributes, "a", aEcTarget); ConvertAttribute(xacAttributes, "g", aEcGloss); if (m_astrSfmsToConvert.Count > 0) { ConvertEmbeddedMarkers(xacAttributes, "m", aEcSource, m_astrSfmsToConvert); ConvertEmbeddedMarkers(xacAttributes, "mm", aEcSource, m_astrSfmsToConvert); } } // now write it to the target folder InsureDirectoryExists(strAdaptationFileTarget); XmlTextWriter writer = new XmlTextWriter(strAdaptationFileTarget, Encoding.UTF8); writer.Formatting = Formatting.Indented; doc.Save(writer); progressBarAdaptationFile.Visible = false; } catch (System.Data.DataException ex) { if (ex.Message == "A child row has multiple parents.") { // this happens when the knowledge base has invalid data in it (e.g. when there is two // canonically equivalent words in different records). This is technically a bug in // AdaptIt. throw new ApplicationException(String.Format("The AdaptIt xml file '{0}' has invalid data in it! Contact [email protected]", strAdaptationFileSource), ex); } throw ex; } catch (Exception ex) { throw new ApplicationException(String.Format("Unable to process the AdaptIt xml file '{0}'. Contact [email protected]", strAdaptationFileSource), ex); } }
private void listBoxProjects_SelectedIndexChanged(object sender, EventArgs e) { buttonConvert.Enabled = (listBoxProjects.SelectedIndex != -1); if (buttonConvert.Enabled) { string strSelectedProjectName = (string)listBoxProjects.SelectedItem; // get the file spec for the project configuration file (so we can harvest the font names) string strProjectFileSource = String.Format(@"{0}\{1}\{2}", ProjectsFolder(ProjectType), strSelectedProjectName, cstrAdaptItProjectFilename); // reset all the details m_aEcGloss = m_aEcSource = m_aEcTarget = null; m_strFontNameSource = m_strFontNameTarget = null; labelSourceLanguageConverter.Text = cstrDefaultConvertLabelSource; labelTargetLanguageConverter.Text = cstrDefaultConvertLabelTarget; labelGlossLanguageConverter.Text = cstrDefaultConvertLabelGloss; m_strDefaultUnicodeFontSource = m_strStatusBoxDefaultFont; m_strDefaultUnicodeFontTarget = m_strStatusBoxDefaultFont; // get the fonts associated with this project GetProjectFonts(strProjectFileSource, out m_strFontNameSource, out m_strFontNameTarget); // see if there's a converter assigned in the repository for these font names SetConverter(m_strFontNameSource, ref m_aEcSource, labelSourceLanguageConverter, ref m_strDefaultUnicodeFontSource); SetConverter(m_strFontNameTarget, ref m_aEcTarget, labelTargetLanguageConverter, ref m_strDefaultUnicodeFontTarget); InitStatusBox(); } }
protected bool IsLhsLegacy(IEncConverter aEC) { if (aEC.DirectionForward) return (EncConverter.NormalizeLhsConversionType(aEC.ConversionType) == NormConversionType.eLegacy); else return (EncConverter.NormalizeRhsConversionType(aEC.ConversionType) == NormConversionType.eLegacy); }