public void Setup() { m_infoTable = new StyleInfoTable("Normal", null); BaseStyleInfo styleInfo = new BaseStyleInfo(); m_infoTable.Add("TestStyle", styleInfo); m_infoTable.ConnectStyles(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the specified new style. /// </summary> /// <param name="newStyle">The new style.</param> /// ------------------------------------------------------------------------------------ public override void Add(BaseStyleInfo newStyle) { base.Add(newStyle); int index = ListBoxControl.FindStringExact(newStyle.Name); ListBoxControl.SelectedIndex = index; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Fills the following styles combo for a specific style /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ private void FillFollowingStyles(BaseStyleInfo styleInfo) { m_cboFollowingStyle.Items.Clear(); // Add all of the styles of the same type List<string> styleList = new List<string>(); foreach (BaseStyleInfo style in m_styleTable.Values) { // If the style types are not the same, then do not allow them. if (style.IsCharacterStyle != styleInfo.IsCharacterStyle) continue; // TE-6346: Add this style to the list if it's already the following style for the // given styleInfo, even if it's an internal style because internal styles can have // themselves as their own following style. if (styleInfo.NextStyle == style || !style.IsInternalStyle) styleList.Add(style.Name); } styleList.Sort(); m_cboFollowingStyle.Items.AddRange(styleList.ToArray()); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Removes the specified style from the list /// </summary> /// <param name="style">The style.</param> /// ------------------------------------------------------------------------------------ public virtual void Remove(BaseStyleInfo style) { m_styleItemList.Remove(style.Name); Refresh(); }
public void CreateCopy() { IStStyle testStyle = AddTestStyle("Title Main", ContextValues.Title, StructureValues.Body, FunctionValues.Prose, false, m_scr.StylesOC); BaseStyleInfo basedOnInfo = new BaseStyleInfo(); DummyStyleInfo origInfo = new DummyStyleInfo(); origInfo.Name = "original"; origInfo.Usage = "This is the original style"; origInfo.BasedOnStyle = basedOnInfo; origInfo.NextStyle = origInfo; origInfo.IsParagraphStyle = true; origInfo.Context = ContextValues.Publication; origInfo.Structure = StructureValues.Heading; origInfo.Function = FunctionValues.List; origInfo.ExplicitRightToLeftStyle = false; origInfo.UserLevel = 2; origInfo.RealStyle = testStyle; origInfo.IsBuiltIn = true; BaseStyleInfo newInfo = new BaseStyleInfo(origInfo, "new"); Assert.AreEqual("new", newInfo.Name); Assert.AreEqual(origInfo.Usage, newInfo.Usage); Assert.AreEqual(origInfo.BasedOnStyle, newInfo.BasedOnStyle); Assert.AreEqual(origInfo.NextStyle, newInfo.NextStyle); Assert.AreEqual(origInfo.IsParagraphStyle, newInfo.IsParagraphStyle); Assert.AreEqual(origInfo.Context, newInfo.Context); Assert.AreEqual(origInfo.Structure, newInfo.Structure); Assert.AreEqual(origInfo.Function, newInfo.Function); Assert.AreEqual(TriStateBool.triFalse, newInfo.DirectionIsRightToLeft); Assert.AreEqual(origInfo.UserLevel, newInfo.UserLevel); Assert.AreEqual(null, newInfo.RealStyle, "a copy of a style should not have a DB style backing it"); Assert.AreEqual(false, newInfo.IsBuiltIn, "Copies of styles should not be considered built in"); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Constructs a StyleListItem (i.e. an StStyle object) based on a real style. /// </summary> /// ------------------------------------------------------------------------------------ public StyleListItem(BaseStyleInfo styleInfo) { m_styleInfo = styleInfo; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="StyleInfo"/> class. This constructor /// is used to make a copy of a style with a new name. /// </summary> /// <param name="copyFrom">The copy from.</param> /// <param name="newName">name for the new copied style</param> /// ------------------------------------------------------------------------------------ public StyleInfo(BaseStyleInfo copyFrom, string newName) : base(copyFrom, newName) { m_dirty = true; }
private void WriteFontAndParagraphRulesXml(ExportStyleInfo style, XmlWriter writer, string basedOnStyle, BaseStyleInfo nextStyle) { if (style.FontInfoForWs(-1) == null) { writer.WriteStartElement("font"); writer.WriteEndElement(); return; } // Generate the font info (the font element is required by the DTD even if it has no attributes) writer.WriteStartElement("font"); IEnumerable <Tuple <string, string> > fontProps = CollectFontProps(style.FontInfoForWs(-1)); if (fontProps.Any()) { foreach (var prop in fontProps) { writer.WriteAttributeString(prop.Item1, prop.Item2); } } foreach (var writingSystem in Cache.LangProject.AllWritingSystems) { var wsOverrideProps = CollectFontProps(style.FontInfoForWs(writingSystem.Handle)); if (wsOverrideProps.Any()) { writer.WriteStartElement("override"); writer.WriteAttributeString("wsId", writingSystem.RFC5646); foreach (var prop in wsOverrideProps) { writer.WriteAttributeString(prop.Item1, prop.Item2); } writer.WriteEndElement(); } } writer.WriteEndElement(); // font IEnumerable <Tuple <string, string> > paragraphProps = CollectParagraphProps(style, basedOnStyle, nextStyle); if (paragraphProps.Any()) { writer.WriteStartElement("paragraph"); foreach (var prop in paragraphProps) { writer.WriteAttributeString(prop.Item1, prop.Item2); } writer.WriteEndElement(); // paragraph } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the specified new style. /// </summary> /// <param name="newStyle">The new style.</param> /// ------------------------------------------------------------------------------------ public virtual void Add(BaseStyleInfo newStyle) { m_styleItemList.Add(newStyle.Name, new StyleListItem(newStyle)); Refresh(); }
public void MergeWritingSystemWithStyleDefnForToWs_DoesNotConvertStyleDefinition() { IWritingSystem fromWs; WritingSystemServices.FindOrCreateWritingSystem(Cache, null, "en-NO", true, false, out fromWs); IWritingSystem toWs; WritingSystemServices.FindOrCreateWritingSystem(Cache, null, "en-SO", true, false, out toWs); EnsureAnalysisWs(new[] { fromWs, toWs }); var style1 = Cache.ServiceLocator.GetInstance<IStStyleFactory>().Create(); Cache.LangProject.StylesOC.Add(style1); var fontOverrides = new Dictionary<int, FontInfo>(); var fontOverride = new FontInfo(); fontOverride.m_italic.ExplicitValue = true; fontOverrides[fromWs.Handle] = fontOverride; fontOverride = new FontInfo(); fontOverride.m_bold.ExplicitValue = true; fontOverrides[toWs.Handle] = fontOverride; var bldr = TsPropsBldrClass.Create(); BaseStyleInfo.SaveFontOverridesToBuilder(fontOverrides, bldr); style1.Rules = bldr.GetTextProps(); m_actionHandler.EndUndoTask(); UndoableUnitOfWorkHelper.Do("doit", "undoit", m_actionHandler, () => WritingSystemServices.MergeWritingSystems(Cache, fromWs, toWs)); var styleInfo = new BaseStyleInfo(style1); var overrideInfo = styleInfo.OverrideCharacterStyleInfo(toWs.Handle); Assert.IsNotNull(overrideInfo); Assert.That(overrideInfo.Bold.Value, Is.True); Assert.That(overrideInfo.Italic.ValueIsSet, Is.False); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determines if style1 derives from style2 or if the styles are the same /// </summary> /// <param name="style1">style 1</param> /// <param name="style2">style 2</param> /// <returns>true if style1 derives from style2</returns> /// ------------------------------------------------------------------------------------ private bool DerivesFromOrSame(BaseStyleInfo style1, BaseStyleInfo style2) { while (style1 != null) { if (style2.Name == style1.Name) return true; style1 = style1.BasedOnStyle; } return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determines whether or not the specified base style can be used as a base for the /// specified style /// </summary> /// <param name="baseStyle">The base style</param> /// <param name="styleInfo">The style</param> /// <returns>True if the base style can be used as a base for the specified style, /// false otherwise</returns> /// ------------------------------------------------------------------------------------ private bool StylesCanBeABaseFor(BaseStyleInfo baseStyle, BaseStyleInfo styleInfo) { // If the style is not in the DB yet, then we want to allow any style to be a base // so the user can select something if (styleInfo.RealStyle == null) return true; // Styles can always be based on general styles if (baseStyle.Context == ContextValues.General) return true; // If the base style is actually the base style of the style, then show it in the // list if (styleInfo.BasedOnStyle == baseStyle) return true; // Otherwise, the context, structure and function of the style must match for a // style to be based on it. return (baseStyle.Context == styleInfo.Context && baseStyle.Structure == styleInfo.Structure && baseStyle.Function == baseStyle.Function); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Removes the specified style from the list /// </summary> /// <param name="style">The style.</param> /// ------------------------------------------------------------------------------------ public override void Remove(BaseStyleInfo style) { // Save the index of the selected item so it can be restored later. int oldSelectedIndex = ListBoxControl.SelectedIndex; base.Remove(style); if (oldSelectedIndex >= ListBoxControl.Items.Count) --oldSelectedIndex; ListBoxControl.SelectedIndex = oldSelectedIndex; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves the style information to the DB. /// </summary> /// <param name="style">The StStyle to save to.</param> /// <param name="existingStyle"><c>true</c> if the style exists; otherwise <c>false</c></param> /// <param name="isModified">if set to <c>true</c> the user has made changes to the /// properties of the style so that they may differ from the factory defaults /// (caller is not required to guarantee absolutely that the properties do in fact /// differ, since the user could set the properties back to the original values).</param> /// ------------------------------------------------------------------------------------ public void SaveToDB(IStStyle style, bool existingStyle, bool isModified) { Debug.Assert(IsValid); m_style = style; style.Name = m_name; style.Usage.UserDefaultWritingSystem = TsStringUtils.MakeString( m_usage, Cache.ServiceLocator.WritingSystemManager.UserWs); style.Type = m_styleType; if (IsBuiltIn) { style.IsModified = isModified; } else { // We need to update the context, structure, and function to be what the base // style is. We only want to do this for user styles so we don't override what // is set in the stylesheet. // Go down the inheritance chain until we find a value to be based on. BaseStyleInfo basedOn = RealBasedOnStyleInfo; if (!existingStyle) // Never change the context, etc. for an existing style { if (basedOn != null) { // If the based-on style cannot be inherited from, then this style must // be a copy of another style, from which it will have inherited its // context, structure, and function. if (basedOn.CanInheritFrom && basedOn.UserLevel > 0) { m_context = basedOn.Context; m_structure = basedOn.Structure; m_function = basedOn.Function; } } else if (IsParagraphStyle) { throw new ArgumentException("A user-defined paragraph style must have a real based-on style"); } } } style.Context = m_context; style.Structure = m_structure; style.Function = m_function; style.UserLevel = m_userLevel; // Build the text props ITsPropsBldr styleProps = TsStringUtils.MakePropsBldr(); if (m_defaultFontInfo.m_fontName.IsExplicit) { styleProps.SetStrPropValue((int)FwTextPropType.ktptFontFamily, m_defaultFontInfo.m_fontName.Value); } if (m_bulletInfo.IsExplicit) { m_bulletInfo.Value.ConvertAsTextProps(styleProps); } if (m_defaultFontInfo.m_bold.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptBold, (int)FwTextPropVar.ktpvEnum, m_defaultFontInfo.m_bold.Value ? (int)FwTextToggleVal.kttvInvert : (int)FwTextToggleVal.kttvOff); } if (m_defaultFontInfo.m_italic.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptItalic, (int)FwTextPropVar.ktpvEnum, m_defaultFontInfo.m_italic.Value ? (int)FwTextToggleVal.kttvInvert : (int)FwTextToggleVal.kttvOff); } if (m_defaultFontInfo.m_superSub.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptSuperscript, 0, (int)m_defaultFontInfo.m_superSub.Value); } if (m_defaultFontInfo.m_fontSize.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptFontSize, 0, m_defaultFontInfo.m_fontSize.Value); } if (m_defaultFontInfo.m_fontColor.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptForeColor, 0, (int)ColorUtil.ConvertColorToBGR(m_defaultFontInfo.m_fontColor.Value)); } if (m_defaultFontInfo.m_backColor.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptBackColor, 0, (int)ColorUtil.ConvertColorToBGR(m_defaultFontInfo.m_backColor.Value)); } if (m_defaultFontInfo.m_offset.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptOffset, (int)FwTextPropVar.ktpvMilliPoint, m_defaultFontInfo.m_offset.Value); } if (m_defaultFontInfo.m_underline.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptUnderline, 0, (int)m_defaultFontInfo.m_underline.Value); } if (m_defaultFontInfo.m_underlineColor.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptUnderColor, 0, (int)ColorUtil.ConvertColorToBGR(m_defaultFontInfo.m_underlineColor.Value)); } if (m_defaultFontInfo.m_features.IsExplicit) { styleProps.SetStrPropValue((int)FwTextPropType.ktptFontVariations, m_defaultFontInfo.m_features.Value); } if (m_rtl.IsExplicit && m_rtl.Value != TriStateBool.triNotSet) { styleProps.SetIntPropValues((int)FwTextPropType.ktptRightToLeft, 0, (m_rtl.Value == TriStateBool.triTrue) ? 1 : 0); } if (m_alignment.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptAlign, (int)FwTextPropVar.ktpvEnum, (int)m_alignment.Value); } if (m_spaceBefore.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptSpaceBefore, 0, m_spaceBefore.Value); } if (m_spaceAfter.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptSpaceAfter, 0, m_spaceAfter.Value); } if (m_firstLineIndent.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptFirstIndent, 0, m_firstLineIndent.Value); } if (m_leadingIndent.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptLeadingIndent, 0, m_leadingIndent.Value); } if (m_trailingIndent.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptTrailingIndent, 0, m_trailingIndent.Value); } if (m_lineSpacing.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptLineHeight, m_lineSpacing.Value.m_relative ? (int)FwTextPropVar.ktpvRelative : (int)FwTextPropVar.ktpvMilliPoint, m_lineSpacing.Value.m_lineHeight); } if (m_border.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptBorderTop, 0, m_border.Value.Top); styleProps.SetIntPropValues((int)FwTextPropType.ktptBorderBottom, 0, m_border.Value.Bottom); styleProps.SetIntPropValues((int)FwTextPropType.ktptBorderLeading, 0, m_border.Value.Leading); styleProps.SetIntPropValues((int)FwTextPropType.ktptBorderTrailing, 0, m_border.Value.Trailing); } if (m_borderColor.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptBorderColor, 0, (int)ColorUtil.ConvertColorToBGR(m_borderColor.Value)); } if (m_keepWithNext.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptKeepWithNext, 0, (m_keepWithNext.Value) ? 1 : 0); } if (m_keepTogether.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptKeepTogether, 0, (m_keepTogether.Value) ? 1 : 0); } if (m_widowOrphanControl.IsExplicit) { styleProps.SetIntPropValues((int)FwTextPropType.ktptWidowOrphanControl, 0, (m_widowOrphanControl.Value) ? 1 : 0); } SaveFontOverridesToBuilder(m_fontInfoOverrides, styleProps); style.Rules = styleProps.GetTextProps(); }
/// <summary> /// Copy constructor, builds an ExportStyleInfo from a BaseStyleInfo /// </summary> /// <param name="style"></param> public ExportStyleInfo(BaseStyleInfo style) : base(style, "export" + style.Name) { }
/// <summary> /// /// </summary> public StyleComboItem(BaseStyleInfo sty) { m_style = sty; }
/// <summary> /// Collects the paragraph info for the style in tuples of attribute name, attribute value /// </summary> private IEnumerable <Tuple <string, string> > CollectParagraphProps(ExportStyleInfo styleRules, string basedOnStyle, BaseStyleInfo nextStyle) { var paragraphProps = new List <Tuple <string, string> >(); GetPointPropAttribute((int)FwTextPropType.ktptSpaceBefore, "spaceBefore", styleRules.RealStyle.Rules, paragraphProps); GetPointPropAttribute((int)FwTextPropType.ktptSpaceAfter, "spaceAfter", styleRules.RealStyle.Rules, paragraphProps); GetPointPropAttribute((int)FwTextPropType.ktptLeadingIndent, "indentLeft", styleRules.RealStyle.Rules, paragraphProps); GetPointPropAttribute((int)FwTextPropType.ktptTrailingIndent, "indentRight", styleRules.RealStyle.Rules, paragraphProps); GetColorValueAttribute((int)FwTextPropType.ktptBackColor, "background", styleRules.RealStyle.Rules, paragraphProps); if (basedOnStyle != null) { paragraphProps.Add(new Tuple <string, string>("basedOn", GetStyleId(basedOnStyle))); } if (nextStyle != null) { paragraphProps.Add(new Tuple <string, string>("next", GetStyleId(nextStyle))); } if (styleRules.HasFirstLineIndent) { // hanging and firstLine are stored in an overloaded property value, negative for hanging, positive for firstline if (styleRules.FirstLineIndent < 0) { paragraphProps.Add(new Tuple <string, string>("hanging", -(styleRules.FirstLineIndent / 1000) + " pt")); } else { paragraphProps.Add(new Tuple <string, string>("firstLine", styleRules.FirstLineIndent / 1000 + " pt")); } } if (styleRules.HasAlignment) { var alignment = styleRules.Alignment; string alignValue = "none"; switch (alignment) { case FwTextAlign.ktalCenter: alignValue = "center"; break; case FwTextAlign.ktalLeft: alignValue = "left"; break; case FwTextAlign.ktalRight: alignValue = "right"; break; case FwTextAlign.ktalJustify: alignValue = "full"; break; } paragraphProps.Add(new Tuple <string, string>("alignment", alignValue)); } if (styleRules.HasLineSpacing) { string lineSpaceType; // relative is used for single, 1.5, double space if (styleRules.LineSpacing.m_relative) { lineSpaceType = "rel"; } else if (styleRules.LineSpacing.m_lineHeight <= 0) { // for historical reasons negative values mean exact, and positive mean at least // (see: Framework\StylesXmlAccessor.cs SetParagraphProperties()) lineSpaceType = "exact"; } else { lineSpaceType = "atleast"; } var lineSpace = Math.Abs(styleRules.LineSpacing.m_lineHeight) / 1000 + " pt"; paragraphProps.Add(new Tuple <string, string>("lineSpacing", lineSpace)); paragraphProps.Add(new Tuple <string, string>("lineSpacingType", lineSpaceType)); } return(paragraphProps); }
public void ConstructBasedOnStyleAndEffects() { IStStyle mainTitleStyle = AddTestStyle("Title Main", ContextValues.Title, StructureValues.Body, FunctionValues.Prose, false, Cache.LangProject.StylesOC); var props = TsPropsFactoryClass.Create().MakeProps("rubbish", Cache.DefaultAnalWs, 0); var sut = new BaseStyleInfo(mainTitleStyle, props); Assert.That(sut.Cache, Is.EqualTo(Cache)); }
private void WriteFontAndParagraphRulesXml(ExportStyleInfo style, XmlWriter writer, string basedOnStyle, BaseStyleInfo nextStyle) { if (style.FontInfoForWs(-1) == null) { writer.WriteStartElement("font"); writer.WriteEndElement(); return; } // Generate the font info (the font element is required by the DTD even if it has no attributes) writer.WriteStartElement("font"); IEnumerable <Tuple <string, string> > fontProps = CollectFontProps(style.FontInfoForWs(-1)); if (fontProps.Any()) { foreach (var prop in fontProps) { writer.WriteAttributeString(prop.Item1, prop.Item2); } } foreach (var writingSystem in Cache.LangProject.AllWritingSystems) { var wsOverrideProps = CollectFontProps(style.FontInfoForWs(writingSystem.Handle)); if (wsOverrideProps.Any()) { writer.WriteStartElement("override"); writer.WriteAttributeString("wsId", writingSystem.LanguageTag); foreach (var prop in wsOverrideProps) { writer.WriteAttributeString(prop.Item1, prop.Item2); } writer.WriteEndElement(); } } writer.WriteEndElement(); // font IEnumerable <Tuple <string, string> > paragraphProps = CollectParagraphProps(style, basedOnStyle, nextStyle); if (paragraphProps.Any()) { writer.WriteStartElement("paragraph"); foreach (var prop in paragraphProps) { writer.WriteAttributeString(prop.Item1, prop.Item2); } //Bullet/Number FontInfo try { IEnumerable <Tuple <string, string> > bulNumParaProperty = CollectBulletProps(style.BulletInfo); foreach (var prop in bulNumParaProperty) { string propName = prop.Item1; if (BulletPropertyMap.ContainsKey(propName.ToLower())) { propName = BulletPropertyMap[propName.ToLower()]; } writer.WriteAttributeString(propName, prop.Item2); } // Generate the font info (the font element is required by the DTD even if it has no attributes) writer.WriteStartElement("BulNumFontInfo"); IEnumerable <Tuple <string, string> > bulletFontInfoProperties = CollectFontProps(style.BulletInfo.FontInfo); if (bulletFontInfoProperties.Any()) { foreach (var prop in bulletFontInfoProperties) { writer.WriteAttributeString(prop.Item1, prop.Item2); } } writer.WriteEndElement(); // bullet } catch {} writer.WriteEndElement(); // paragraph } }
/// <summary> /// Converts the style name into the 'id' attribute expected by the code that reads in stylesheet files /// </summary> private static string GetStyleId(BaseStyleInfo style) { return(GetStyleId(style.Name)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds the given style info entry to the table. /// </summary> /// <param name="key">The key of the element to add (typically a TE Stylename, but may /// be another unique token (if this entry represents a style which is not known to /// exist)</param> /// <param name="value">The value of the element to add (must not be null)</param> /// <exception cref="T:System.ArgumentException">An element with the same key already /// exists in the <see cref="T:System.Collections.Generic.Dictionary`2"></see>.</exception> /// <exception cref="T:System.ArgumentNullException">key or value is null.</exception> /// ------------------------------------------------------------------------------------ public override void Add(string key, BaseStyleInfo value) { base.Add(key, value); // We need to set the P6 Marker based on the key, but only if it's null. If it's // not null, this is probably a case where an entry is being re-keyed based on the // TE style name, so we should leave the P6 marker as is. UsfmStyEntry entry = (UsfmStyEntry)value; if (entry.P6Marker == null) entry.P6Marker = key.Replace(' ', '_'); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="StyleInfo"/> class. This constructor /// is used to make a copy of a style with a new name. /// </summary> /// <param name="copyFrom">The copy from.</param> /// <param name="newName">name for the new copied style</param> /// ------------------------------------------------------------------------------------ public StyleInfo(BaseStyleInfo copyFrom, string newName): base(copyFrom, newName) { m_dirty = true; }
public StyleComboItem(BaseStyleInfo sty) { m_style = sty; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Fills the based on styles combo for a specific style /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ private void FillBasedOnStyles(BaseStyleInfo styleInfo) { m_cboBasedOn.Items.Clear(); // If this is a character style then put in "Default Paragraph Characters" if (styleInfo.IsCharacterStyle) m_cboBasedOn.Items.Add(StyleUtils.DefaultParaCharsStyleName); // Add all of the styles that are not myself or any style that derives from me and // have the same context as me List<string> styleList = new List<string>(); foreach (BaseStyleInfo baseStyle in m_styleTable.Values) { // If the style types are not the same, then do not allow them. if (baseStyle.IsCharacterStyle != styleInfo.IsCharacterStyle) continue; // TE-6344: If styleInfo is already based on baseStyle, then we must include baseStyle // in the list, even if it is not normally a style that can be a based-on // style. This allows a style with a context of internal (such as "Normal" in // TE) to appear in the list when it is the basis for a built-in or copied style. if (styleInfo.BasedOnStyle == baseStyle) { Debug.Assert(!DerivesFromOrSame(baseStyle, styleInfo)); // Sanity check for circular reference styleList.Add(baseStyle.Name); } else if (!DerivesFromOrSame(baseStyle, styleInfo) && baseStyle.CanInheritFrom && StylesCanBeABaseFor(baseStyle, styleInfo)) { styleList.Add(baseStyle.Name); } } styleList.Sort(); m_cboBasedOn.Items.AddRange(styleList.ToArray()); }