C# ITsString.get_WritingSystem方法代码示例

		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Gets a TsString made from the ashes of the input parameter which has:
		/// 1) only one run
		/// 2) uses the ws of the 1st run of the input TsString.
		/// </summary>
		/// <param name="tss">structured text string</param>
		/// ------------------------------------------------------------------------------------
		public static ITsString GetCleanSingleRunTsString(ITsString tss)
		{
			return MakeTss(tss.Text, tss.get_WritingSystem(0));
		}

		/// <summary>
		/// Get the writing system of the specified run of a TsString.
		/// </summary>
		public static int GetWsOfRun(ITsString tss, int irun)
		{
			return tss.get_WritingSystem(irun);
		}

		/// <summary>
		/// Gets the first vernacular ws.
		/// </summary>
		/// <param name="vernWsVecImage">The vern ws vec image, like "seh pt mar-fonipa".</param>
		/// <param name="wsf">The Writing System Factory.</param>
		/// <param name="text">The text.</param>
		/// <returns>
		/// The first vernacular ws used in the text or -1 if none
		/// </returns>
		public static int GetFirstVernacularWs(string vernWsVecImage, ILgWritingSystemFactory wsf, ITsString text)
		{
			int wid = -1; // writing system id
			for (int runSeq = 0; runSeq < text.RunCount; runSeq++)
			{
				wid = text.get_WritingSystem(runSeq);
				var ws = wsf.get_EngineOrNull(wid);
				if (ws != null)
				{   // ws.Id is short like "en"
					if (vernWsVecImage.IndexOf(ws.Id) >= 0)
						break; // wid > -1
				}
				wid = -1;
			}
			return wid;
		}

        public static string TextFromTsString(ITsString tss, ILgWritingSystemFactory wsf)
        {
            // This will replace SafeTsStringText, and will actually deal with <span> elements

            // Spec: the TsString properties ktptWs (an int property) and ktptNamedStyle (a string property)
            // will be replaced with lang="(wsStr)" and class="styleName_PropValue". Other properties, that
            // LF doesn't process, will be preserved in the class attribute as well, as follows:
            //
            // 1) Determine whether the property is an int property or a string property.
            // 2) Call either IntPropertyName() or StringPropertyName() to get its name.
            // 3) Create a class string in format "propC_N_NAME_VALUE" where:
            //      - C is "i" for int props or "s" for string props
            //      - N is the property number
            //      - NAME is, of course, the property name
            //      - VALUE is the property's value, with two special cases:
            //          * in string properties, spaces are first replaced by "_SPACE_"
            //          * in int properties, there's a value and a "variation", and VALUE is both of them separated by _
            //
            // Result: class="propi_1_ktptWs_1_0 props_1_ktptFontFamily_Times_SPACE_New_SPACE_Roman"

            if (tss == null)
                return null;
            int[] intPropsToSkip = new int[] { (int)FwTextPropType.ktptWs };
            int[] strPropsToSkip = new int[] { (int)FwTextPropType.ktptNamedStyle };
            int mainWs = tss.get_WritingSystem(0);
            var resultBuilder = new StringBuilder();
            foreach (TsRunPart run in tss.Runs())
            {
                string runText = run.Text;
                ITsTextProps props = run.Props;
                int ws = props.GetWs();
                string namedStyle = props.Style();
                List<string> classes = ClassesFromTsTextProps(props, intPropsToSkip, strPropsToSkip);

                bool needSpan = false;
                string langAttr = null;
                string classAttr = null;
                if (ws != mainWs)
                {
                    needSpan = true;
                    langAttr = String.Format(" lang=\"{0}\"", wsf.GetStrFromWs(ws));
                }
                if (namedStyle != null)
                {
                    needSpan = true;
                    classes.Insert(0, String.Format("styleName_{0}", namedStyle.Replace(" ", "_SPACE_")));
                }
                if (classes.Count > 0)
                {
                    needSpan = true;
                    classAttr = String.Format(" class=\"{0}\"", String.Join(" ", classes));
                }

                if (needSpan)
                {
                    var spanBuilder = new StringBuilder();
                    spanBuilder.Append("<span");
                    if (langAttr != null)
                        spanBuilder.Append(langAttr);
                    if (classAttr != null)
                        spanBuilder.Append(classAttr);
                    spanBuilder.Append(">");
                    spanBuilder.Append(runText);
                    spanBuilder.Append("</span>");
                    resultBuilder.Append(spanBuilder.ToString());
                }
                else
                    resultBuilder.Append(runText);
            }
            return resultBuilder.ToString();
        }

		/// <summary>
		/// Return true if the specified string has a run in the specified WS
		/// </summary>
		public static bool HasWs(ITsString tss, int ws)
		{
			var crun = tss.RunCount;
			for (int i = 0; i < crun; i++)
			{
				if (tss.get_WritingSystem(i) == ws)
					return true;
			}
			return false;
		}

		private static int GetWsFromString(ITsString tss, int ichMin, int ichLim)
		{
			if (tss == null || tss.Length == 0 || ichMin >= ichLim)
				return 0;
			int runMin = tss.get_RunAt(ichMin);
			int runMax = tss.get_RunAt(ichLim - 1);
			int ws = tss.get_WritingSystem(runMin);
			if (runMin == runMax)
				return ws;
			for (int i = runMin + 1; i <= runMax; ++i)
			{
				int wsT = tss.get_WritingSystem(i);
				if (wsT != ws)
					return 0;
			}
			return ws;
		}