public void UserDefinedCharacterStyle_ExplicitFontName() { // Create a style with an unspecified font name. IStStyle charStyle = new StStyle(); Cache.LangProject.StylesOC.Add(charStyle); charStyle.Context = ContextValues.Text; charStyle.Function = FunctionValues.Prose; charStyle.Structure = StructureValues.Body; charStyle.Type = StyleType.kstCharacter; StyleInfo basedOn = new StyleInfo(charStyle); // Create a user-defined character style inherited from the previously-created character // style, but this style has a font name specified. StyleInfo charStyleInfo = new StyleInfo("New Char Style", basedOn, StyleType.kstCharacter, Cache); FontInfo charFontInfo = charStyleInfo.FontInfoForWs(Cache.DefaultVernWs); m_fontTab.UpdateForStyle(charStyleInfo); // Select a font name for the style (which will call the event handler // m_cboFontNames_SelectedIndexChanged). FwInheritablePropComboBox cboFontNames = ReflectionHelper.GetField(m_fontTab, "m_cboFontNames") as FwInheritablePropComboBox; Assert.IsNotNull(cboFontNames); cboFontNames.AdjustedSelectedIndex = 2; // Make sure we successfully set the font for this user-defined character style. Assert.IsTrue(charStyleInfo.FontInfoForWs(-1).m_fontName.IsExplicit); Assert.AreEqual("<default pub font>", charStyleInfo.FontInfoForWs(-1).m_fontName.Value, "The font should have been set to the default publication font."); cboFontNames.AdjustedSelectedIndex = 3; // Make sure we successfully set the font for this user-defined character style. Assert.IsTrue(charStyleInfo.FontInfoForWs(-1).m_fontName.IsExplicit); Assert.AreEqual("<default sans serif>", charStyleInfo.FontInfoForWs(-1).m_fontName.Value, "The font should have been set to the default heading font (i.e., sans-serif)."); }
public void SaveToDB_NewInfo() { var styleFactory = Cache.ServiceLocator.GetInstance<IStStyleFactory>(); var realStyle = styleFactory.Create(); Cache.LanguageProject.StylesOC.Add(realStyle); realStyle.Context = ContextValues.Intro; realStyle.Function = FunctionValues.Table; realStyle.Structure = StructureValues.Heading; StyleInfo basedOn = new StyleInfo(realStyle); StyleInfo testInfo = new StyleInfo("New Style", basedOn, StyleType.kstParagraph, Cache); // simulate a save to the DB for the test style. var style = styleFactory.Create(); Cache.LanguageProject.StylesOC.Add(style); testInfo.SaveToDB(style, false, false); Assert.AreEqual(ContextValues.Intro, testInfo.Context); Assert.AreEqual(StructureValues.Heading, testInfo.Structure); Assert.AreEqual(FunctionValues.Table, testInfo.Function); Assert.AreEqual(ContextValues.Intro, style.Context); Assert.AreEqual(StructureValues.Heading, style.Structure); Assert.AreEqual(FunctionValues.Table, style.Function); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="StyleInfo"/> class. Creates a new /// style of a given type. /// </summary> /// <param name="name">new style name</param> /// <param name="basedOnStyle">style to be based on</param> /// <param name="styleType"></param> /// <param name="cache">FDO cache</param> /// ------------------------------------------------------------------------------------ public StyleInfo(string name, StyleInfo basedOnStyle, StyleType styleType, FdoCache cache) : base(cache) { Name = name; m_styleType = styleType; m_basedOnStyle = basedOnStyle; if (basedOnStyle != null) m_basedOnStyleName = basedOnStyle.Name; else if (styleType == StyleType.kstParagraph) { throw new ArgumentNullException("basedOnStyle", "New paragraph styles are required to be based on an existing style."); } m_nextStyleName = name; }
public void SaveToDB_CopyOfStyleBasedOnNormal() { StyleInfoTable styleTable = new StyleInfoTable("Normal", Cache.ServiceLocator.WritingSystemManager); var styleFactory = Cache.ServiceLocator.GetInstance<IStStyleFactory>(); var normalStyle = styleFactory.Create(); Cache.LanguageProject.StylesOC.Add(normalStyle); normalStyle.Name = "Normal"; normalStyle.Context = ContextValues.Internal; normalStyle.Function = FunctionValues.Prose; normalStyle.Structure = StructureValues.Undefined; StyleInfo normal = new StyleInfo(normalStyle); styleTable.Add("Normal", normal); var realStyle = styleFactory.Create(); Cache.LanguageProject.StylesOC.Add(realStyle); realStyle.Name = "Paragraph"; realStyle.Context = ContextValues.Text; realStyle.Function = FunctionValues.Prose; realStyle.Structure = StructureValues.Body; realStyle.BasedOnRA = normalStyle; StyleInfo styleToCopyFrom = new StyleInfo(realStyle); styleTable.Add("Paragraph", styleToCopyFrom); StyleInfo testInfo = new StyleInfo(styleToCopyFrom, "Copy of Paragraph"); styleTable.Add("Copy of Paragraph", testInfo); styleTable.ConnectStyles(); // simulate a save to the DB for the test style. var style = styleFactory.Create(); Cache.LanguageProject.StylesOC.Add(style); testInfo.SaveToDB(style, false, false); Assert.AreEqual(ContextValues.Text, testInfo.Context); Assert.AreEqual(StructureValues.Body, testInfo.Structure); Assert.AreEqual(FunctionValues.Prose, testInfo.Function); Assert.AreEqual(ContextValues.Text, style.Context); Assert.AreEqual(StructureValues.Body, style.Structure); Assert.AreEqual(FunctionValues.Prose, style.Function); }
public void SaveToDB_NewInfo() { IStStyle realStyle = new StStyle(); Cache.LangProject.StylesOC.Add(realStyle); realStyle.Context = ContextValues.Intro; realStyle.Function = FunctionValues.Table; realStyle.Structure = StructureValues.Heading; StyleInfo basedOn = new StyleInfo(realStyle); StyleInfo testInfo = new StyleInfo("New Style", basedOn, StyleType.kstParagraph, Cache); // simulate a save to the DB for the test style. IStStyle style = new StStyle(); Cache.LangProject.StylesOC.Add(style); testInfo.SaveToDB(style, false); Assert.AreEqual(ContextValues.Intro, testInfo.Context); Assert.AreEqual(StructureValues.Heading, testInfo.Structure); Assert.AreEqual(FunctionValues.Table, testInfo.Function); Assert.AreEqual(ContextValues.Intro, style.Context); Assert.AreEqual(StructureValues.Heading, style.Structure); Assert.AreEqual(FunctionValues.Table, style.Function); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves the font information to the styleInfo /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void SaveToInfo(StyleInfo styleInfo) { CheckDisposed(); FontInfo fontInfo = styleInfo.FontInfoForWs(m_currentWs); // Font name bool newInherit = IsInherited(m_cboFontNames); string newValue = string.Empty; switch (m_cboFontNames.AdjustedSelectedIndex) { case 1: newValue = StStyle.DefaultFont; break; case 2: newValue = StStyle.DefaultPubFont; break; case 3: newValue = StStyle.DefaultHeadingFont; break; default: newValue = m_cboFontNames.Text; break; } if (fontInfo.m_fontName.Save(newInherit, newValue)) { styleInfo.Dirty = true; } // font size newInherit = IsInherited(m_cboFontSize); int fontSize = (m_cboFontSize.Text == string.Empty || newInherit) ? 0 : Int32.Parse(m_cboFontSize.Text); if (fontInfo.m_fontSize.Save(newInherit, fontSize * 1000)) { styleInfo.Dirty = true; } // color Color color = m_FontAttributes.GetFontColor(out newInherit); if (fontInfo.m_fontColor.Save(newInherit, color)) { styleInfo.Dirty = true; } // background color color = m_FontAttributes.GetBackgroundColor(out newInherit); if (fontInfo.m_backColor.Save(newInherit, color)) { styleInfo.Dirty = true; } // underline style FwUnderlineType underlineType = m_FontAttributes.GetUnderlineType(out newInherit); if (fontInfo.m_underline.Save(newInherit, underlineType)) { styleInfo.Dirty = true; } // underline color color = m_FontAttributes.GetUnderlineColor(out newInherit); if (fontInfo.m_underlineColor.Save(newInherit, color)) { styleInfo.Dirty = true; } // bold, italic, superscript, subscript bool fFlag = m_FontAttributes.GetBold(out newInherit); if (fontInfo.m_bold.Save(newInherit, fFlag)) { styleInfo.Dirty = true; } fFlag = m_FontAttributes.GetItalic(out newInherit); if (fontInfo.m_italic.Save(newInherit, fFlag)) { styleInfo.Dirty = true; } FwSuperscriptVal superSub = m_FontAttributes.GetSubSuperscript(out newInherit); if (fontInfo.m_superSub.Save(newInherit, superSub)) { styleInfo.Dirty = true; } // position int fontPos = m_FontAttributes.GetFontPosition(out newInherit); if (fontInfo.m_offset.Save(newInherit, fontPos)) { styleInfo.Dirty = true; } // features string fontFeatures = m_FontAttributes.GetFontFeatures(out newInherit); if (fontInfo.m_features.Save(newInherit, fontFeatures)) { styleInfo.Dirty = true; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the following styles combo box. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ private void UpdateFollowingStylesCbo(StyleInfo styleInfo) { // Handle the Following Paragraph Style combo box if (styleInfo.IsCharacterStyle) { m_cboFollowingStyle.Items.Clear(); m_cboFollowingStyle.Enabled = false; } else { FillFollowingStyles(styleInfo); if (styleInfo.NextStyle == null) m_cboFollowingStyle.SelectedIndex = -1; else m_cboFollowingStyle.SelectedItem = styleInfo.NextStyle.Name; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the form based on a style being selected. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { CheckDisposed(); #if __MonoCS__ // On Mono, the sequence of events when changing styles can cause this to be // called even when switching to a character style. See FWNX-870. if (!styleInfo.IsParagraphStyle) return; #endif m_dontUpdateInheritance = true; bool fDifferentStyle = m_StyleInfo == null ? true : (styleInfo.Name != m_StyleInfo.Name); // Don't use a 0 size bullet. Fixes FWNX-575. if (styleInfo != null && styleInfo.IBullet != null) if (styleInfo.IBullet.Value.FontInfo.FontSize.Value == 0) styleInfo.IBullet.Value.FontInfo.m_fontSize = new InheritableStyleProp<int>(FontInfo.kDefaultFontSize); m_StyleInfo = styleInfo; m_preview.IsRightToLeft = m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triNotSet ? m_DefaultTextDirectionRtoL : m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triTrue; m_preview.WritingSystemFactory = m_StyleInfo.Cache.WritingSystemFactory; m_preview.WritingSystemCode = m_StyleInfo.Cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.Handle; VwBulNum bulletType; // Note: don't assign m_currentStyleBulletInfo until the end of this method // since setting some of the values change m_currentStyleBulletInfo before we have set // everything. BulletInfo bulletInfo = new BulletInfo(styleInfo.IBullet.Value); bulletType = bulletInfo.m_numberScheme; // If we have a different style, we have to reload the font info. If it is the same // style we were here before so we keep the font info that we already have. if (fDifferentStyle) { if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) { // use font from style for bullets m_BulletsFontInfo = bulletInfo.FontInfo; // create a number font based on the font for bullets m_NumberFontInfo = new FontInfo(m_BulletsFontInfo); m_NumberFontInfo.m_fontName.ResetToInherited(styleInfo.FontInfoForWs(-1).UIFontName()); } else { // use font from style for numbers m_NumberFontInfo = bulletInfo.FontInfo; if (bulletType == VwBulNum.kvbnNone) { m_NumberFontInfo.m_fontName.ResetToInherited(styleInfo.FontInfoForWs(-1).UIFontName()); } // create a bullets font based on the font for numbers m_BulletsFontInfo = new FontInfo(m_NumberFontInfo); // The font for bullets is hard-coded in the views code, so there is no point // in letting the user select any other font for bullets. m_BulletsFontInfo.m_fontName.ResetToInherited("Quivira"); m_BulletsFontInfo.m_fontName.SetDefaultValue("Quivira"); } } m_nudStartAt.Value = bulletInfo.m_start; m_chkStartAt.Checked = (bulletInfo.m_start != 1); m_tbTextBefore.Text = bulletInfo.m_textBefore; m_tbTextAfter.Text = bulletInfo.m_textAfter; m_rbUnspecified.Enabled = styleInfo.Inherits; if (styleInfo.IBullet.IsInherited && styleInfo.Inherits) m_rbUnspecified.Checked = true; else if (bulletType == VwBulNum.kvbnNone) m_rbNone.Checked = true; else if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) m_rbBullet.Checked = true; else // NumberBase m_rbNumber.Checked = true; m_cboBulletScheme.SelectedIndex = GetBulletIndexForType(bulletType); m_cboNumberScheme.SelectedIndex = GetNumberSchemeIndexForType(bulletType); m_currentStyleBulletInfo = bulletInfo; UpdateBulletSchemeComboBox(); m_dontUpdateInheritance = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Changes the name of the style /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ private void ChangeStyleName(StyleInfo styleInfo) { string newName = m_txtStyleName.Text; string oldName = styleInfo.Name; // fix any styles that refer to this one foreach (StyleInfo updateStyle in m_styleTable.Values) { if (updateStyle.BasedOnStyle != null && updateStyle.BasedOnStyle.Name == oldName) updateStyle.SaveBasedOn(newName); if (updateStyle.NextStyle != null && updateStyle.NextStyle.Name == oldName) updateStyle.SaveFollowing(newName); } // save the new name and update the entry in the style table styleInfo.SaveName(newName); m_styleTable.Remove(oldName); m_styleTable.Add(newName, styleInfo); // Change the displayed entry m_styleListHelper.Rename(oldName, newName); // Save an entry to rename the style if it is a real style if (styleInfo.RealStyle != null) SaveRenamedStyle(oldName, newName); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves the paragraph information to the styleInfo /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void SaveToInfo(StyleInfo styleInfo) { CheckDisposed(); if (styleInfo.IsCharacterStyle) { Debug.Assert(false, "Somehow, the Paragraph tab has been asked to write its data to a character-based style [" + styleInfo.Name + "]."); return; } // direction bool newInherit = IsInherited(m_cboDirection); if (styleInfo.IRightToLeftStyle.Save(newInherit, (TriStateBool)m_cboDirection.SelectedIndex)) { styleInfo.Dirty = true; } // alignment newInherit = m_cboAlignment.IsInherited; FwTextAlign newAlignment = FwTextAlign.ktalLeading; switch (m_cboAlignment.AdjustedSelectedIndex) { case 1: newAlignment = FwTextAlign.ktalLeading; break; case 2: newAlignment = FwTextAlign.ktalLeft; break; case 3: newAlignment = FwTextAlign.ktalCenter; break; case 4: newAlignment = FwTextAlign.ktalRight; break; case 5: newAlignment = FwTextAlign.ktalTrailing; break; case 6: newAlignment = FwTextAlign.ktalJustify; break; } if (styleInfo.IAlignment.Save(newInherit, newAlignment)) { styleInfo.Dirty = true; } // background color - only save it if the control is visible if (m_cboBackground.Visible) { newInherit = IsInherited(m_cboBackground); FontInfo fontInfo = styleInfo.FontInfoForWs(-1); // get default FontInfo if (fontInfo.m_backColor.Save(newInherit, m_cboBackground.ColorValue)) { styleInfo.Dirty = true; } } // left indent newInherit = IsInherited(m_nudLeftIndentation); if (styleInfo.ILeadingIndent.Save(newInherit, m_nudLeftIndentation.MeasureValue)) { styleInfo.Dirty = true; } // right indent newInherit = IsInherited(m_nudRightIndentation); if (styleInfo.ITrailingIndent.Save(newInherit, m_nudRightIndentation.MeasureValue)) { styleInfo.Dirty = true; } // special indent newInherit = m_cboSpecialIndentation.IsInherited; int newValue = 0; switch (m_cboSpecialIndentation.AdjustedSelectedIndex) { case 2: newValue = m_nudIndentBy.MeasureValue; break; case 3: newValue = -m_nudIndentBy.MeasureValue; break; } if (styleInfo.IFirstLineIndent.Save(newInherit, newValue)) { styleInfo.Dirty = true; } // spacing before newInherit = IsInherited(m_nudBefore); if (styleInfo.ISpaceBefore.Save(newInherit, m_nudBefore.MeasureValue)) { styleInfo.Dirty = true; } // spacing after newInherit = IsInherited(m_nudAfter); if (styleInfo.ISpaceAfter.Save(newInherit, m_nudAfter.MeasureValue)) { styleInfo.Dirty = true; } // line spacing int index = m_cboLineSpacing.AdjustedSelectedIndex; newInherit = m_cboLineSpacing.IsInherited; LineHeightInfo newLineHeight = new LineHeightInfo(); newLineHeight.m_relative = (index <= 3); switch (index) { case 1: // single spacing newLineHeight.m_lineHeight = 10000; break; case 2: // 1.5 spacing newLineHeight.m_lineHeight = 15000; break; case 3: // double spacing newLineHeight.m_lineHeight = 20000; break; case kAtLeastIndex: // at least newLineHeight.m_lineHeight = m_nudSpacingAt.MeasureValue; break; case kExactlyIndex: // exactly newLineHeight.m_lineHeight = -m_nudSpacingAt.MeasureValue; break; } if (styleInfo.ILineSpacing.Save(newInherit, newLineHeight)) { styleInfo.Dirty = true; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:FwStylesDlg"/> class. /// </summary> /// <param name="rootSite">The root site.</param> /// <param name="cache">The cache.</param> /// <param name="styleSheet">The style sheet.</param> /// <param name="defaultRightToLeft">Indicates whether current context (typically the /// default direction of the view from which this dialog is invoked) is right to left.</param> /// <param name="showBiDiLabels">Indicates whether to show labels that are meaningful /// for both left-to-right and right-to-left. If <c>defaultRightToLeft</c> is set to /// <c>true</c> the passed-in value for this parameter will be ignored and the display /// will automatically be BiDi enabled. If this value is false, then simple "Left" and /// "Right" labels will be used in the display, rather than "Leading" and "Trailing".</param> /// <param name="normalStyleName">Name of the normal style.</param> /// <param name="customUserLevel">The custom user level.</param> /// <param name="userMeasurementType">User's prefered measurement units.</param> /// <param name="paraStyleName">Name of the currently selected paragraph style.</param> /// <param name="charStyleName">Name of the currently selected character style.</param> /// <param name="hvoRootObject">The hvo of the root object in the current view.</param> /// <param name="app">The application.</param> /// <param name="helpTopicProvider">The help topic provider.</param> /// ------------------------------------------------------------------------------------ protected void Init(IVwRootSite rootSite, FdoCache cache, FwStyleSheet styleSheet, bool defaultRightToLeft, bool showBiDiLabels, string normalStyleName, int customUserLevel, MsrSysType userMeasurementType, string paraStyleName, string charStyleName, int hvoRootObject, IApp app, IHelpTopicProvider helpTopicProvider) { CheckDisposed(); m_rootSite = rootSite; m_cache = cache; m_customUserLevel = customUserLevel; m_hvoRootObject = hvoRootObject; m_app = app; showBiDiLabels |= defaultRightToLeft; m_fShowBidiLabels = showBiDiLabels; m_userMeasurementType = userMeasurementType; m_helpTopicProvider = helpTopicProvider; // Cache is null in tests if (cache == null) return; m_cboTypes.SelectedIndex = 1; // All Styles // Load the style information m_styleTable = new StyleInfoTable(normalStyleName, cache.LanguageWritingSystemFactoryAccessor); m_styleSheet = styleSheet; FillStyleTable(m_styleSheet); m_normalStyleInfo = (StyleInfo)m_styleTable[normalStyleName]; Debug.Assert(m_normalStyleInfo != null); m_styleListHelper = new StyleListBoxHelper(m_lstStyles); m_styleListHelper.AddStyles(m_styleTable, null); m_styleListHelper.ShowInternalStyles = true; m_styleListHelper.StyleChosen += new StyleChosenHandler(m_styleListHelper_StyleChosen); m_styleListHelper.Refresh(); // Mark the current styles m_styleListHelper.MarkCurrentStyle(paraStyleName); m_styleListHelper.MarkCurrentStyle(charStyleName); // General tab m_generalTab.StyleListHelper = m_styleListHelper; m_generalTab.StyleTable = m_styleTable; m_generalTab.ShowBiDiLabels = showBiDiLabels; m_generalTab.UserMeasurementType = m_userMeasurementType; m_generalTab.RenamedStyles = m_renamedStyles; // Load the font information m_fontTab.WritingSystemFactory = cache.LanguageWritingSystemFactoryAccessor; m_fontTab.FillFontInfo(cache); // Disable the background color on the paragraph tab. m_paragraphTab.DefaultTextDirectionRtoL = defaultRightToLeft; m_paragraphTab.ShowBiDiLabels = showBiDiLabels; m_paragraphTab.MeasureType = userMeasurementType; m_bulletsTab.DefaultTextDirectionRtoL = defaultRightToLeft; m_bulletsTab.StyleSheet = m_styleSheet; m_borderTab.DefaultTextDirectionRtoL = defaultRightToLeft; m_borderTab.ShowBiDiLabels = showBiDiLabels; // Select the current paragraph style in the list (or fall back to Normal) if (!string.IsNullOrEmpty(paraStyleName)) m_styleListHelper.SelectedStyleName = paraStyleName; else m_styleListHelper.SelectedStyleName = normalStyleName; m_styleListHelper_StyleChosen(null, m_styleListHelper.SelectedStyle); // Default is not to show the style type selection combo. if (!DesignMode) AllowSelectStyleTypes = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Set the properties of a StyleInfo to the factory default settings /// </summary> /// ------------------------------------------------------------------------------------ protected abstract void SetPropsToFactorySettings(StyleInfo styleInfo);
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the information on the font tab using the current writing system. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { CheckDisposed(); UpdateForStyle(styleInfo, m_currentWs); }
protected override void SetPropsToFactorySettings(StyleInfo obj) { throw new NotImplementedException(); }
public void SaveToDB_NewInfoAndBasedOnNewInfo() { IStStyle realStyle = new StStyle(); Cache.LangProject.StylesOC.Add(realStyle); realStyle.Context = ContextValues.Intro; realStyle.Function = FunctionValues.Table; realStyle.Structure = StructureValues.Heading; StyleInfo basedOn = new StyleInfo(realStyle); StyleInfo testInfo1 = new StyleInfo("New Style 1", basedOn, StyleType.kstParagraph, Cache); StyleInfo testInfo2 = new StyleInfo("New Style 2", testInfo1, StyleType.kstParagraph, Cache); // simulate a save to the DB for the test styles. Save the second one first for // a better test. IStStyle style2 = new StStyle(); Cache.LangProject.StylesOC.Add(style2); testInfo2.SaveToDB(style2, false); IStStyle style = new StStyle(); Cache.LangProject.StylesOC.Add(style); testInfo1.SaveToDB(style, false); Assert.AreEqual(ContextValues.Intro, testInfo1.Context); Assert.AreEqual(StructureValues.Heading, testInfo1.Structure); Assert.AreEqual(FunctionValues.Table, testInfo1.Function); Assert.AreEqual(ContextValues.Intro, style.Context); Assert.AreEqual(StructureValues.Heading, style.Structure); Assert.AreEqual(FunctionValues.Table, style.Function); Assert.AreEqual(ContextValues.Intro, testInfo2.Context); Assert.AreEqual(StructureValues.Heading, testInfo2.Structure); Assert.AreEqual(FunctionValues.Table, testInfo2.Function); Assert.AreEqual(ContextValues.Intro, style2.Context); Assert.AreEqual(StructureValues.Heading, style2.Structure); Assert.AreEqual(FunctionValues.Table, style2.Function); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves bullet info into a StyleInfo /// </summary> /// <param name="styleInfo">styleInfo to save into</param> /// ------------------------------------------------------------------------------------ public void SaveToInfo(StyleInfo styleInfo) { CheckDisposed(); // Save the bullet information styleInfo.IBullet.IsInherited = false; BulletInfo bulInfo = new BulletInfo(); UpdateBulletInfo(ref bulInfo); // Replace the value if (styleInfo.IBullet.Save(m_rbUnspecified.Checked, bulInfo)) styleInfo.Dirty = true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the form based on a style being selected. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { CheckDisposed(); m_dontUpdateInheritance = true; bool fDifferentStyle = m_StyleInfo == null ? true : (styleInfo.Name != m_StyleInfo.Name); m_StyleInfo = styleInfo; m_preview.IsRightToLeft = m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triNotSet ? m_DefaultTextDirectionRtoL : m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triTrue; m_preview.WritingSystemFactory = m_StyleInfo.Cache.LanguageWritingSystemFactoryAccessor; m_preview.WritingSystemCode = m_StyleInfo.Cache.DefaultVernWs; VwBulNum bulletType; // Note: don't assign m_currentStyleBulletInfo until the end of this method // since setting some of the values change m_currentStyleBulletInfo before we have set // everything. BulletInfo bulletInfo = new BulletInfo(styleInfo.IBullet.Value); bulletType = bulletInfo.m_numberScheme; // If we have a different style, we have to reload the font info. If it is the same // style we were here before so we keep the font info that we already have. if (fDifferentStyle) { if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) { // use font from style for bullets m_BulletsFontInfo = bulletInfo.FontInfo; // create a number font based on the font for bullets m_NumberFontInfo = new FontInfo(m_BulletsFontInfo); m_NumberFontInfo.m_fontName.ResetToInherited(GetUiFontName( styleInfo.FontInfoForWs(-1).m_fontName.Value)); } else { // use font from style for numbers m_NumberFontInfo = bulletInfo.FontInfo; if (bulletType == VwBulNum.kvbnNone) { m_NumberFontInfo.m_fontName.ResetToInherited(GetUiFontName( styleInfo.FontInfoForWs(-1).m_fontName.Value)); } // create a bullets font based on the font for numbers m_BulletsFontInfo = new FontInfo(m_NumberFontInfo); // The font for bullets is hard-coded in the views code, so there is no point // in letting the user select any other font for bullets. m_BulletsFontInfo.m_fontName.ResetToInherited("Wingdings"); m_BulletsFontInfo.m_fontName.SetDefaultValue("Wingdings"); } } m_nudStartAt.Value = bulletInfo.m_start; m_chkStartAt.Checked = (bulletInfo.m_start != 1); m_tbTextBefore.Text = bulletInfo.m_textBefore; m_tbTextAfter.Text = bulletInfo.m_textAfter; m_rbUnspecified.Enabled = styleInfo.Inherits; if (styleInfo.IBullet.IsInherited && styleInfo.Inherits) m_rbUnspecified.Checked = true; else if (bulletType == VwBulNum.kvbnNone) m_rbNone.Checked = true; else if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) m_rbBullet.Checked = true; else // NumberBase m_rbNumber.Checked = true; m_cboBulletScheme.SelectedIndex = GetBulletIndexForType(bulletType); m_cboNumberScheme.SelectedIndex = GetNumberSchemeIndexForType(bulletType); m_currentStyleBulletInfo = bulletInfo; UpdateBulletSchemeComboBox(); m_dontUpdateInheritance = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves bullet info into a StyleInfo /// </summary> /// <param name="styleInfo">styleInfo to save into</param> /// ------------------------------------------------------------------------------------ public void SaveToInfo(StyleInfo styleInfo) { CheckDisposed(); if (styleInfo.IsCharacterStyle) { Debug.Assert(false, "Somehow, the Bullets tab has been asked to write its data to a character-based style [" + styleInfo.Name + "]."); return; } // Save the bullet information BulletInfo bulInfo = new BulletInfo(); UpdateBulletInfo(ref bulInfo); // Replace the value if (styleInfo.IBullet.Save(m_rbUnspecified.Checked, bulInfo)) styleInfo.Dirty = true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Set the properties of a StyleInfo to the factory default settings /// </summary> /// ------------------------------------------------------------------------------------ public static void SetPropsToFactorySettings(StyleInfo styleInfo) { TeStylesXmlAccessor acc = new TeStylesXmlAccessor(styleInfo.Cache.LanguageProject.TranslatedScriptureOA); acc.ResetProps(styleInfo); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the information on the font tab. /// </summary> /// <param name="styleInfo">The style info.</param> /// <param name="ws">The writing system for the overrides. -1 for the default settings /// </param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo, int ws) { CheckDisposed(); if (styleInfo == null) return; m_dontUpdateInheritance = true; m_currentStyleInfo = styleInfo; m_currentWs = ws; if (ws == -1) { m_fIgnoreWsSelectedIndexChange = true; m_lstWritingSystems.SelectedIndices.Clear(); m_lstWritingSystems.SelectedIndices.Add(0); m_fIgnoreWsSelectedIndexChange = false; } // If the first item is selected, it is the "default", so the font list should // only include the magic font names, not the real ones. FillFontNames(ws > -1); m_FontAttributes.ShowingInheritedProperties = ShowingInheritedProperties; // Initialize controls based on whether or not this style inherits from another style. InitControlBehavior(ShowingInheritedProperties); FontInfo fontInfo = styleInfo.FontInfoForWs(ws); m_FontAttributes.UpdateForStyle(fontInfo); // update the font size combobox if (!m_cboFontSize.SetInheritableProp(fontInfo.m_fontSize)) m_cboFontSize.Text = (fontInfo.m_fontSize.Value / 1000).ToString(); // update the font names if (!m_cboFontNames.SetInheritableProp(fontInfo.m_fontName)) { string fontName = fontInfo.m_fontName.Value; if (string.IsNullOrEmpty(fontName)) { Debug.Fail("How did this happen? Tim & Tom don't think it can."); m_cboFontNames.AdjustedSelectedIndex = 0; } else if (fontName == StyleServices.DefaultFont) m_cboFontNames.AdjustedSelectedIndex = 1; else m_cboFontNames.Text = fontName; } // Update the descriptions for the writing system overrides UpdateWritingSystemDescriptions(); m_dontUpdateInheritance = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Set the properties of a StyleInfo to the factory default settings /// </summary> /// ------------------------------------------------------------------------------------ protected override void SetPropsToFactorySettings(StyleInfo styleInfo) { TeStylesXmlAccessor.SetPropsToFactorySettings(styleInfo); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves the font information to the styleInfo /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void SaveToInfo(StyleInfo styleInfo) { CheckDisposed(); FontInfo fontInfo = styleInfo.FontInfoForWs(m_currentWs); // Font name bool newInherit = IsInherited(m_cboFontNames); string newValue; switch (m_cboFontNames.AdjustedSelectedIndex) { case 1: newValue = StyleServices.DefaultFont; break; default: newValue = m_cboFontNames.Text; break; } if (fontInfo.m_fontName.Save(newInherit, newValue)) styleInfo.Dirty = true; // font size newInherit = IsInherited(m_cboFontSize); int fontSize = (m_cboFontSize.Text == string.Empty || newInherit) ? 0 : Int32.Parse(m_cboFontSize.Text); if (fontInfo.m_fontSize.Save(newInherit, fontSize * 1000)) styleInfo.Dirty = true; // color Color color = m_FontAttributes.GetFontColor(out newInherit); if (fontInfo.m_fontColor.Save(newInherit, color)) styleInfo.Dirty = true; // background color color = m_FontAttributes.GetBackgroundColor(out newInherit); if (fontInfo.m_backColor.Save(newInherit, color)) styleInfo.Dirty = true; // underline style FwUnderlineType underlineType = m_FontAttributes.GetUnderlineType(out newInherit); if (fontInfo.m_underline.Save(newInherit, underlineType)) styleInfo.Dirty = true; // underline color color = m_FontAttributes.GetUnderlineColor(out newInherit); if (fontInfo.m_underlineColor.Save(newInherit, color)) styleInfo.Dirty = true; // bold, italic, superscript, subscript bool fFlag = m_FontAttributes.GetBold(out newInherit); if (fontInfo.m_bold.Save(newInherit, fFlag)) styleInfo.Dirty = true; fFlag = m_FontAttributes.GetItalic(out newInherit); if (fontInfo.m_italic.Save(newInherit, fFlag)) styleInfo.Dirty = true; FwSuperscriptVal superSub = m_FontAttributes.GetSubSuperscript(out newInherit); if (fontInfo.m_superSub.Save(newInherit, superSub)) styleInfo.Dirty = true; // position int fontPos = m_FontAttributes.GetFontPosition(out newInherit); if (fontInfo.m_offset.Save(newInherit, fontPos)) styleInfo.Dirty = true; // features string fontFeatures = m_FontAttributes.GetFontFeatures(out newInherit); if (fontInfo.m_features.Save(newInherit, fontFeatures)) styleInfo.Dirty = true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the form based on a style being selected. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { CheckDisposed(); m_dontUpdateInheritance = true; bool fDifferentStyle = m_StyleInfo == null ? true : (styleInfo.Name != m_StyleInfo.Name); m_StyleInfo = styleInfo; m_preview.IsRightToLeft = m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triNotSet ? m_DefaultTextDirectionRtoL : m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triTrue; m_preview.WritingSystemFactory = m_StyleInfo.Cache.LanguageWritingSystemFactoryAccessor; m_preview.WritingSystemCode = m_StyleInfo.Cache.DefaultVernWs; VwBulNum bulletType; // Note: don't assign m_currentStyleBulletInfo until the end of this method // since setting some of the values change m_currentStyleBulletInfo before we have set // everything. BulletInfo bulletInfo = new BulletInfo(styleInfo.IBullet.Value); bulletType = bulletInfo.m_numberScheme; // If we have a different style, we have to reload the font info. If it is the same // style we were here before so we keep the font info that we already have. if (fDifferentStyle) { if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) { // use font from style for bullets m_BulletsFontInfo = bulletInfo.FontInfo; // create a number font based on the font for bullets m_NumberFontInfo = new FontInfo(m_BulletsFontInfo); m_NumberFontInfo.m_fontName.ResetToInherited(GetUiFontName( styleInfo.FontInfoForWs(-1).m_fontName.Value)); } else { // use font from style for numbers m_NumberFontInfo = bulletInfo.FontInfo; if (bulletType == VwBulNum.kvbnNone) { m_NumberFontInfo.m_fontName.ResetToInherited(GetUiFontName( styleInfo.FontInfoForWs(-1).m_fontName.Value)); } // create a bullets font based on the font for numbers m_BulletsFontInfo = new FontInfo(m_NumberFontInfo); // The font for bullets is hard-coded in the views code, so there is no point // in letting the user select any other font for bullets. m_BulletsFontInfo.m_fontName.ResetToInherited("Wingdings"); m_BulletsFontInfo.m_fontName.SetDefaultValue("Wingdings"); } } m_nudStartAt.Value = bulletInfo.m_start; m_chkStartAt.Checked = (bulletInfo.m_start != 1); m_tbTextBefore.Text = bulletInfo.m_textBefore; m_tbTextAfter.Text = bulletInfo.m_textAfter; m_rbUnspecified.Enabled = styleInfo.Inherits; if (styleInfo.IBullet.IsInherited && styleInfo.Inherits) { m_rbUnspecified.Checked = true; } else if (bulletType == VwBulNum.kvbnNone) { m_rbNone.Checked = true; } else if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) { m_rbBullet.Checked = true; } else // NumberBase { m_rbNumber.Checked = true; } m_cboBulletScheme.SelectedIndex = GetBulletIndexForType(bulletType); m_cboNumberScheme.SelectedIndex = GetNumberSchemeIndexForType(bulletType); m_currentStyleBulletInfo = bulletInfo; UpdateBulletSchemeComboBox(); m_dontUpdateInheritance = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the form based on a style being selected. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { CheckDisposed(); #if __MonoCS__ // On Mono, the sequence of events when changing styles can cause this to be // called even when switching to a character style. See FWNX-870. if (!styleInfo.IsParagraphStyle) { return; } #endif m_dontUpdateInheritance = true; bool fDifferentStyle = m_StyleInfo == null ? true : (styleInfo.Name != m_StyleInfo.Name); // Don't use a 0 size bullet. Fixes FWNX-575. if (styleInfo != null && styleInfo.IBullet != null) { if (styleInfo.IBullet.Value.FontInfo.FontSize.Value == 0) { styleInfo.IBullet.Value.FontInfo.m_fontSize = new InheritableStyleProp <int>(FontInfo.kDefaultFontSize); } } m_StyleInfo = styleInfo; m_preview.IsRightToLeft = m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triNotSet ? m_DefaultTextDirectionRtoL : m_StyleInfo.DirectionIsRightToLeft == TriStateBool.triTrue; m_preview.WritingSystemFactory = m_StyleInfo.Cache.WritingSystemFactory; m_preview.WritingSystemCode = m_StyleInfo.Cache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.Handle; VwBulNum bulletType; // Note: don't assign m_currentStyleBulletInfo until the end of this method // since setting some of the values change m_currentStyleBulletInfo before we have set // everything. BulletInfo bulletInfo = new BulletInfo(styleInfo.IBullet.Value); bulletType = bulletInfo.m_numberScheme; // If we have a different style, we have to reload the font info. If it is the same // style we were here before so we keep the font info that we already have. if (fDifferentStyle) { if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) { // use font from style for bullets m_BulletsFontInfo = bulletInfo.FontInfo; // create a number font based on the font for bullets m_NumberFontInfo = new FontInfo(m_BulletsFontInfo); m_NumberFontInfo.m_fontName.ResetToInherited(styleInfo.FontInfoForWs(-1).UIFontName()); } else { // use font from style for numbers m_NumberFontInfo = bulletInfo.FontInfo; if (bulletType == VwBulNum.kvbnNone) { m_NumberFontInfo.m_fontName.ResetToInherited(styleInfo.FontInfoForWs(-1).UIFontName()); } // create a bullets font based on the font for numbers m_BulletsFontInfo = new FontInfo(m_NumberFontInfo); // The font for bullets is hard-coded in the views code, so there is no point // in letting the user select any other font for bullets. m_BulletsFontInfo.m_fontName.ResetToInherited("Quivira"); m_BulletsFontInfo.m_fontName.SetDefaultValue("Quivira"); } } m_nudStartAt.Value = bulletInfo.m_start; m_chkStartAt.Checked = (bulletInfo.m_start != 1); m_tbTextBefore.Text = bulletInfo.m_textBefore; m_tbTextAfter.Text = bulletInfo.m_textAfter; m_rbUnspecified.Enabled = styleInfo.Inherits; if (styleInfo.IBullet.IsInherited && styleInfo.Inherits) { m_rbUnspecified.Checked = true; } else if (bulletType == VwBulNum.kvbnNone) { m_rbNone.Checked = true; } else if ((int)bulletType >= (int)VwBulNum.kvbnBulletBase) { m_rbBullet.Checked = true; } else // NumberBase { m_rbNumber.Checked = true; } m_cboBulletScheme.SelectedIndex = GetBulletIndexForType(bulletType); m_cboNumberScheme.SelectedIndex = GetNumberSchemeIndexForType(bulletType); m_currentStyleBulletInfo = bulletInfo; UpdateBulletSchemeComboBox(); m_dontUpdateInheritance = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the form based on a style being selected. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { CheckDisposed(); #if __MonoCS__ // On Mono, the sequence of events when changing styles can cause this to be // called even when switching to a character style. See FWNX-870. if (!styleInfo.IsParagraphStyle) { return; } #endif // Don't allow controls to undo their inherited state while filling in m_dontUpdateInheritance = true; m_currentStyleInfo = styleInfo; // Initialize controls based on whether or not this style inherits from another style. InitControlBehavior(styleInfo.Inherits); // LTR or RTL m_cboDirection.SetInheritableProp(styleInfo.IRightToLeftStyle); m_cboDirection.AdjustedSelectedIndex = (int)styleInfo.IRightToLeftStyle.Value; ChangeDirectionLabels(styleInfo.IRightToLeftStyle.Value == TriStateBool.triNotSet || m_fShowBiDiLabels ? m_fShowBiDiLabels : styleInfo.IRightToLeftStyle.Value == TriStateBool.triTrue); // Paragraph Alignment m_cboAlignment.SetInheritableProp(styleInfo.IAlignment); switch (styleInfo.IAlignment.Value) { case FwTextAlign.ktalLeading: m_cboAlignment.AdjustedSelectedIndex = 1; break; case FwTextAlign.ktalLeft: m_cboAlignment.AdjustedSelectedIndex = 2; break; case FwTextAlign.ktalCenter: m_cboAlignment.AdjustedSelectedIndex = 3; break; case FwTextAlign.ktalRight: m_cboAlignment.AdjustedSelectedIndex = 4; break; case FwTextAlign.ktalTrailing: m_cboAlignment.AdjustedSelectedIndex = 5; break; case FwTextAlign.ktalJustify: m_cboAlignment.AdjustedSelectedIndex = 6; break; } // Special indent m_cboSpecialIndentation.SetInheritableProp(styleInfo.IFirstLineIndent); if (styleInfo.IFirstLineIndent.Value == 0) { m_cboSpecialIndentation.AdjustedSelectedIndex = 1; // none } else if (styleInfo.IFirstLineIndent.Value > 0) { m_cboSpecialIndentation.AdjustedSelectedIndex = 2; // first line } else { m_cboSpecialIndentation.AdjustedSelectedIndex = 3; // hanging } m_nudIndentBy.ForeColor = GetCtrlForeColorForProp(styleInfo.IFirstLineIndent); m_nudIndentBy.MeasureValue = Math.Abs(styleInfo.IFirstLineIndent.Value); // update the up/down measure controls m_nudLeftIndentation.ForeColor = GetCtrlForeColorForProp(styleInfo.ILeadingIndent); m_nudLeftIndentation.MeasureValue = styleInfo.ILeadingIndent.Value; m_nudRightIndentation.ForeColor = GetCtrlForeColorForProp(styleInfo.ITrailingIndent); m_nudRightIndentation.MeasureValue = styleInfo.ITrailingIndent.Value; m_nudBefore.ForeColor = GetCtrlForeColorForProp(styleInfo.ISpaceBefore); m_nudBefore.MeasureValue = styleInfo.ISpaceBefore.Value; m_nudAfter.ForeColor = GetCtrlForeColorForProp(styleInfo.ISpaceAfter); m_nudAfter.MeasureValue = styleInfo.ISpaceAfter.Value; LineHeightInfo info = styleInfo.ILineSpacing.Value; m_cboLineSpacing.SetInheritableProp(styleInfo.ILineSpacing); m_nudSpacingAt.ForeColor = GetCtrlForeColorForProp(styleInfo.ILineSpacing); if (!info.m_relative) { if (info.m_lineHeight < 0) { // Exact line spacing m_cboLineSpacing.AdjustedSelectedIndex = kExactlyIndex; m_nudSpacingAt.MeasureMin = 1000; } else { // at least line spacing m_cboLineSpacing.AdjustedSelectedIndex = kAtLeastIndex; m_nudSpacingAt.MeasureMin = 0; } m_nudSpacingAt.MeasureValue = Math.Abs(info.m_lineHeight); } else { switch (info.m_lineHeight) { case 10000: // single spacing m_cboLineSpacing.AdjustedSelectedIndex = 1; break; case 15000: // 1.5 line spacing m_cboLineSpacing.AdjustedSelectedIndex = 2; break; case 20000: // double spacing m_cboLineSpacing.AdjustedSelectedIndex = 3; break; } } FontInfo fontInfo = styleInfo.FontInfoForWs(-1); // get default fontInfo m_cboBackground.ForeColor = GetCtrlForeColorForProp(fontInfo.m_backColor); m_cboBackground.ColorValue = fontInfo.m_backColor.Value; m_dontUpdateInheritance = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves any changes in the dialog for the style /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ private void UpdateChanges(StyleInfo styleInfo) { if (styleInfo == null) return; // save the changes from the other tabs m_generalTab.SaveToInfo(styleInfo); m_fontTab.SaveToInfo(styleInfo); if (styleInfo.IsParagraphStyle) { m_paragraphTab.SaveToInfo(styleInfo); m_bulletsTab.SaveToInfo(styleInfo); m_borderTab.SaveToInfo(styleInfo); } // do this last m_styleTable.ConnectStyles(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Saves the information on the tab to the specified style info. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void SaveToInfo(StyleInfo styleInfo) { // save the changes from the general tab // NOTE: The name has to be set last as ChangeStyleName can update the basedOn // and Following styles for styleInfo to its correct values. styleInfo.SaveBasedOn(m_cboBasedOn.Text); styleInfo.SaveFollowing(m_cboFollowingStyle.Text); if (m_txtStyleName.Text != styleInfo.Name) ChangeStyleName(styleInfo); styleInfo.SaveDescription(m_txtStyleUsage.Text); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the controls on each of the tab pages being displayed to reflect the /// properties of the specified style. /// </summary> /// <param name="styleInfo">The style info (for the currently selected style).</param> /// ------------------------------------------------------------------------------------ private void UpdateTabsForStyle(StyleInfo styleInfo) { m_fontTab.UpdateForStyle(styleInfo, -1); // Only update the rest of the tabs if the style is a paragraph style if (styleInfo.IsParagraphStyle) { m_paragraphTab.UpdateForStyle(styleInfo); m_bulletsTab.UpdateForStyle(styleInfo); m_borderTab.UpdateForStyle(styleInfo); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the form based on a style being selected. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { CheckDisposed(); m_dontUpdateInheritance = true; m_fIgnoreCascadingEvents = true; m_currentStyleInfo = styleInfo; m_cboColor.ForeColor = GetCtrlForeColorForProp(styleInfo.IBorderColor); m_cboColor.IsInherited = styleInfo.Inherits; m_cboColor.ColorValue = styleInfo.BorderColor; bool fWidthInherited = styleInfo.BorderThickness.IsInherited && styleInfo.Inherits; m_chkTop.ThreeState = fWidthInherited; m_chkRight.ThreeState = fWidthInherited; m_chkBottom.ThreeState = fWidthInherited; m_chkLeft.ThreeState = fWidthInherited; if (fWidthInherited) { m_chkBottom.CheckState = CheckState.Indeterminate; m_chkTop.CheckState = CheckState.Indeterminate; m_chkLeft.CheckState = CheckState.Indeterminate; m_chkRight.CheckState = CheckState.Indeterminate; } else { m_chkTop.CheckState = (styleInfo.BorderTop == 0) ? CheckState.Unchecked : CheckState.Checked; m_chkBottom.CheckState = (styleInfo.BorderBottom == 0) ? CheckState.Unchecked : CheckState.Checked; m_chkLeft.CheckState = (styleInfo.BorderLeading == 0) ? CheckState.Unchecked : CheckState.Checked; m_chkRight.CheckState = (styleInfo.BorderTrailing == 0) ? CheckState.Unchecked : CheckState.Checked; } m_cboWidth.SetInheritableProp(styleInfo.BorderThickness); m_cboWidth.ShowingInheritedProperties = styleInfo.Inherits; int maxWidth = styleInfo.BorderWidth; if (maxWidth == 0) { // 1/2 pt is the default value to display, even though 0 is the default value maxWidth = 500; } // select the border width in the combobox m_cboWidth.AdjustedSelectedIndex = Array.IndexOf <int>(s_borderSizes, maxWidth); // Change the left and right check boxes if the check boxes need to change // places (because the paragraph direction is different) if ((m_chkRight.Left < m_chkLeft.Left) != DefaultTextDirectionRtoL) { System.Drawing.ContentAlignment saveChkAlign = m_chkLeft.CheckAlign; m_chkLeft.CheckAlign = m_chkRight.CheckAlign; m_chkRight.CheckAlign = saveChkAlign; AdjustCheckboxPositionsToPreserveGap(); } // Change the labels to show leading/trailing or left/right depending on the // paragraph direction. ChangeDirectionLabels(styleInfo.IRightToLeftStyle.Value == TriStateBool.triNotSet ? m_fShowBiDiLabels : styleInfo.IRightToLeftStyle.Value == TriStateBool.triTrue); m_dontUpdateInheritance = false; m_fIgnoreCascadingEvents = false; m_pnlBorderPreview.Refresh(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Reset the properties of a StyleInfo to the factory default settings /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ protected void ResetProps(StyleInfo styleInfo) { styleInfo.ResetAllPropertiesToFactoryValues(() => { XmlNode styleNode = LoadDoc().SelectSingleNode("markup/tag[@id='" + styleInfo.Name.Replace(" ", "_") + "']"); SetFontProperties(styleInfo.Name, styleNode, (tpt, iVar, iVal) => styleInfo.SetExplicitFontIntProp(tpt, iVal), (tpt, sVal) => { if (tpt == (int)FwTextPropType.ktptWsStyle) styleInfo.ProcessWsSpecificOverrides(sVal); else throw new InvalidEnumArgumentException("tpt", tpt, typeof(FwTextPropType)); }, OverwriteOptions.All); if (styleInfo.IsParagraphStyle) { SetParagraphProperties(styleInfo.Name, styleNode, (tpt, iVar, iVal) => { if (!styleInfo.SetExplicitParaIntProp(tpt, iVar, iVal)) throw new InvalidEnumArgumentException("tpt", tpt, typeof(FwTextPropType)); }, OverwriteOptions.All); } }); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds a new style to our internal table of styles (i.e., not yet to the DB) in /// response to the user clicking one of the style type submenu items. /// </summary> /// ------------------------------------------------------------------------------------ private void StyleTypeMenuItem_Click(object sender, EventArgs e) { bool fParaStyle = (sender == paragraphStyleToolStripMenuItem); // generate a name for the new style string styleName = fParaStyle ? FwCoreDlgs.kstidNewParagraphStyle : FwCoreDlgs.kstidNewCharacterStyle; int styleNum = 2; string styleFormatString = fParaStyle ? FwCoreDlgs.kstidNewParagraphStyleWithNumber : FwCoreDlgs.kstidNewCharacterStyleWithNumber; while (m_styleTable.ContainsKey(styleName)) styleName = string.Format(styleFormatString, styleNum++); // create a new styleinfo StyleInfo style = new StyleInfo(styleName, fParaStyle ? m_normalStyleInfo : null, fParaStyle ? StyleType.kstParagraph : StyleType.kstCharacter, m_cache); // add the styleinfo to the style list and the list control m_styleTable.Add(style.Name, style); m_styleTable.ConnectStyles(); m_styleListHelper.Add(style); // select the name field m_tabControl.SelectedTab = m_tbGeneral; m_tbGeneral.Focus(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="T:FwStylesDlg"/> class. This version /// can be used by C# clients. There is no need for the client to call Init if this /// constructor is used. /// </summary> /// <param name="rootSite">The root site.</param> /// <param name="cache">The cache.</param> /// <param name="styleSheet">The style sheet.</param> /// <param name="defaultRightToLeft">Indicates whether current context (typically the /// default direction of the view from which this dialog is invoked) is right to left.</param> /// <param name="showBiDiLabels">Indicates whether to show labels that are meaningful /// for both left-to-right and right-to-left. If <c>defaultRightToLeft</c> is set to /// <c>true</c> the passed-in value for this parameter will be ignored and the display /// will automatically be BiDi enabled. If this value is false, then simple "Left" and /// "Right" labels will be used in the display, rather than "Leading" and "Trailing".</param> /// <param name="normalStyleName">Name of the normal style.</param> /// <param name="customUserLevel">The custom user level.</param> /// <param name="userMeasurementType">User's prefered measurement units.</param> /// <param name="paraStyleName">Name of the currently selected paragraph style.</param> /// <param name="charStyleName">Name of the currently selected character style.</param> /// <param name="hvoRootObject">The hvo of the root object in the current view.</param> /// <param name="app">The application.</param> /// <param name="helpTopicProvider">The help topic provider.</param> /// ------------------------------------------------------------------------------------ public FwStylesDlg(IVwRootSite rootSite, FdoCache cache, FwStyleSheet styleSheet, bool defaultRightToLeft, bool showBiDiLabels, string normalStyleName, int customUserLevel, MsrSysType userMeasurementType, string paraStyleName, string charStyleName, int hvoRootObject, IApp app, IHelpTopicProvider helpTopicProvider) : this() { m_rootSite = rootSite; m_cache = cache; m_customUserLevel = customUserLevel; m_hvoRootObject = hvoRootObject; m_app = app; showBiDiLabels |= defaultRightToLeft; m_userMeasurementType = userMeasurementType; m_helpTopicProvider = helpTopicProvider; // Cache is null in tests if (cache == null) return; m_cboTypes.SelectedIndex = 1; // All Styles // Load the style information m_styleTable = new StyleInfoTable(normalStyleName, cache.ServiceLocator.WritingSystemManager); m_styleSheet = styleSheet; FillStyleTable(m_styleSheet); m_normalStyleInfo = (StyleInfo)m_styleTable[normalStyleName]; Debug.Assert(m_normalStyleInfo != null); m_styleListHelper = new StyleListBoxHelper(m_lstStyles); m_styleListHelper.AddStyles(m_styleTable, null); m_styleListHelper.ShowInternalStyles = true; m_styleListHelper.StyleChosen += new StyleChosenHandler(m_styleListHelper_StyleChosen); m_styleListHelper.Refresh(); // Mark the current styles m_styleListHelper.MarkCurrentStyle(paraStyleName); m_styleListHelper.MarkCurrentStyle(charStyleName); // General tab m_generalTab.Application = m_app; m_generalTab.StyleListHelper = m_styleListHelper; m_generalTab.StyleTable = m_styleTable; m_generalTab.ShowBiDiLabels = showBiDiLabels; m_generalTab.UserMeasurementType = m_userMeasurementType; m_generalTab.RenamedStyles = m_renamedStyles; // Load the font information m_fontTab.WritingSystemFactory = cache.WritingSystemFactory; m_fontTab.FillFontInfo(cache); // Disable the background color on the paragraph tab. m_paragraphTab.DefaultTextDirectionRtoL = defaultRightToLeft; m_paragraphTab.ShowBiDiLabels = showBiDiLabels; m_paragraphTab.MeasureType = userMeasurementType; m_bulletsTab.DefaultTextDirectionRtoL = defaultRightToLeft; m_bulletsTab.StyleSheet = m_styleSheet; m_borderTab.DefaultTextDirectionRtoL = defaultRightToLeft; m_borderTab.ShowBiDiLabels = showBiDiLabels; // Select the current paragraph style in the list (or fall back to Normal) CurrentStyle = (!string.IsNullOrEmpty(paraStyleName)) ? paraStyleName : normalStyleName; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the information on the font tab. /// </summary> /// <param name="styleInfo">The style info.</param> /// <param name="ws">The writing system for the overrides. -1 for the default settings /// </param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo, int ws) { CheckDisposed(); m_dontUpdateInheritance = true; m_currentStyleInfo = styleInfo; m_currentWs = ws; if (ws == -1) { m_fIgnoreWsSelectedIndexChange = true; m_lstWritingSystems.SelectedIndices.Clear(); m_lstWritingSystems.SelectedIndices.Add(0); m_fIgnoreWsSelectedIndexChange = false; } // If the first item is selected, it is the "default", so the font list should // only include the magic font names, not the real ones. FillFontNames(ws > -1); m_FontAttributes.ShowingInheritedProperties = ShowingInheritedProperties; // Initialize controls based on whether or not this style inherits from another style. InitControlBehavior(ShowingInheritedProperties); FontInfo fontInfo = styleInfo.FontInfoForWs(ws); m_FontAttributes.UpdateForStyle(fontInfo); // update the font size combobox if (!m_cboFontSize.SetInheritableProp(fontInfo.m_fontSize)) { m_cboFontSize.Text = (fontInfo.m_fontSize.Value / 1000).ToString(); } // update the font names if (!m_cboFontNames.SetInheritableProp(fontInfo.m_fontName)) { string fontName = fontInfo.m_fontName.Value; if (fontName == null || fontName == string.Empty) { Debug.Fail("How did this happen? Tim & Tom don't think it can."); m_cboFontNames.AdjustedSelectedIndex = 0; } else if (fontName == StStyle.DefaultFont) { m_cboFontNames.AdjustedSelectedIndex = 1; } else if (fontName == StStyle.DefaultPubFont) { m_cboFontNames.AdjustedSelectedIndex = 2; } else if (fontName == StStyle.DefaultHeadingFont) { m_cboFontNames.AdjustedSelectedIndex = 3; } else { m_cboFontNames.Text = fontName; } } // Update the descriptions for the writing system overrides UpdateWritingSystemDescriptions(); m_dontUpdateInheritance = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handles the Click event of the m_btnCopy control. /// </summary> /// ------------------------------------------------------------------------------------ private void m_btnCopy_Click(object sender, EventArgs e) { // before copying a new style, save any edits to the current style if (m_styleListHelper.SelectedStyle != null) UpdateChanges((StyleInfo)m_styleListHelper.SelectedStyle.StyleInfo); else return; // Get the selected style StyleListItem copiedStyle = m_styleListHelper.SelectedStyle; if (copiedStyle.StyleInfo == null) return; // Generate a name for the copied style. int styleNum = 2; string styleFormatString = FwCoreDlgs.kstidCopyStyleNameFormat; string styleFormatNumberString = FwCoreDlgs.kstidCopyStyleNameFormatNumber; string newStyleName = string.Format(styleFormatString, copiedStyle.Name); while (m_styleTable.ContainsKey(newStyleName)) newStyleName = string.Format(styleFormatNumberString, styleNum++, copiedStyle.Name); // create a new styleinfo StyleInfo newStyle = new StyleInfo(copiedStyle.StyleInfo, newStyleName); // add the styleinfo to the style list and the list control m_styleTable.Add(newStyleName, newStyle); m_styleTable.ConnectStyles(); m_styleListHelper.Add(newStyle); // select the name field m_tabControl.SelectedTab = m_tbGeneral; m_tbGeneral.Focus(); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the information on the tab with the information in the specified style info. /// </summary> /// <param name="styleInfo">The style info.</param> /// ------------------------------------------------------------------------------------ public void UpdateForStyle(StyleInfo styleInfo) { if (styleInfo == null) { FillForDefaultParagraphCharacters(); this.Enabled = false; return; } this.Enabled = true; m_txtStyleName.Enabled = !styleInfo.IsBuiltIn; m_txtStyleUsage.ReadOnly = styleInfo.IsBuiltIn; m_cboBasedOn.Enabled = !styleInfo.IsBuiltIn; m_cboFollowingStyle.Enabled = !styleInfo.IsBuiltIn; m_txtShortcut.Enabled = false; m_txtStyleName.Text = styleInfo.Name; m_lblStyleType.Text = (styleInfo.IsCharacterStyle) ? FwCoreDlgControls.kstidCharacterStyleText : FwCoreDlgControls.kstidParagraphStyleText; m_txtStyleUsage.Text = styleInfo.Usage; m_lblStyleDescription.Text = styleInfo.ToString(m_fShowBiDiLabels, m_userMeasurementType); // Handle the Based On style combo FillBasedOnStyles(styleInfo); if (styleInfo.BasedOnStyle != null) m_cboBasedOn.SelectedItem = styleInfo.BasedOnStyle.Name; else { if (styleInfo.IsCharacterStyle) m_cboBasedOn.SelectedIndex = 0; // "default paragraph characters" else m_cboBasedOn.SelectedIndex = -1; } UpdateFollowingStylesCbo(styleInfo); }