getSectionStyleId(string name)
{
SectionStyleCollection styles = BaseObjs._civDoc.Styles.SectionStyles;
try
{
using (Transaction tr = BaseObjs.startTransactionDb())
{
foreach (ObjectId style in styles)
{
SectionStyle sStyle = (SectionStyle)tr.GetObject(style, OpenMode.ForRead);
if (sStyle.Name == name)
{
return(sStyle.ObjectId);
}
}
tr.Commit();
}
}
catch (System.Exception ex)
{
BaseObjs.writeDebug(string.Format("{0} Sect_Style.cs: line: 95", ex.Message));
}
return(ObjectId.Null);
}
/// <summary>
/// Creates the section style.
/// </summary>
/// <param name="styleNode">The style node.</param>
private void CreateSectionStyle(XElement styleNode)
{
SectionStyle sectionStyle = new SectionStyle(_document, new XElement(styleNode));
IPropertyCollection pCollection = new IPropertyCollection();
if (styleNode.HasElements)
{
foreach (XElement node in styleNode.Elements())
{
IProperty property = GetProperty(sectionStyle, new XElement(node));
if (property != null)
{
pCollection.Add(property);
}
}
}
sectionStyle.Node.Value = "";
foreach (IProperty property in pCollection)
{
sectionStyle.PropertyCollection.Add(property);
}
if (!_common)
{
_document.Styles.Add(sectionStyle);
}
else
{
_document.CommonStyles.Add(sectionStyle);
}
}
/// <summary>
/// Creates the section style.
/// </summary>
/// <param name="styleNode">The style node.</param>
private void CreateSectionStyle(XmlNode styleNode)
{
SectionStyle sectionStyle = new SectionStyle(this._document, styleNode.CloneNode(true));
IPropertyCollection pCollection = new IPropertyCollection();
if (styleNode.HasChildNodes)
{
foreach (XmlNode node in styleNode.ChildNodes)
{
IProperty property = this.GetProperty(sectionStyle, node.CloneNode(true));
if (property != null)
{
pCollection.Add(property);
}
}
}
sectionStyle.Node.InnerXml = "";
foreach (IProperty property in pCollection)
{
sectionStyle.PropertyCollection.Add(property);
}
if (!this._common)
{
this._document.Styles.Add(sectionStyle);
}
else
{
this._document.CommonStyles.Add(sectionStyle);
}
}
/// <summary>
/// Default constructor
/// </summary>
public OrderedSectionGroup()
{
TSSettings settings = JsonUtility.FromJson <TSSettings>(File.ReadAllText(TSConstants.SettingsJSONPath));
sectionStyle = (SectionStyle)settings.sectionStyle;
switch (sectionStyle)
{
case SectionStyle.Bubbles:
buttonStyle = "button";
break;
case SectionStyle.Foldout:
buttonStyle = new GUIStyle("button");
break;
case SectionStyle.Box:
buttonStyle = new GUIStyle("box");
buttonStyle.alignment = TextAnchor.MiddleCenter;
buttonStyle.stretchWidth = true;
buttonStyle.normal.textColor = Color.white;
buttonStyle.fontStyle = FontStyle.Bold;
break;
}
sectionBgColor = settings.sectionColor;
sections = new List <OrderedSection>();
}
copySectionStyle()
{
Document acDocTar = BaseObjs._acadDoc; // target - Active Document
Database dbTar = acDocTar.Database; // target database
Document acDocSrc = BaseObjs.openDwg("R:\\TSet\\Template\\CIVIL3D2010\\EW.dwt"); // source - Active Document
Application.DocumentManager.MdiActiveDocument = acDocSrc;
CivilDocument civDocSrc = BaseObjs._civDoc;
SectionStyleCollection objSectionStyles = civDocSrc.Styles.SectionStyles; //source Section Styles
using (Transaction tr = BaseObjs.startTransactionDb()) {
foreach (ObjectId idStyle in objSectionStyles)
{
SectionStyle style = (SectionStyle)tr.GetObject(idStyle, OpenMode.ForRead);
if (style.Name != "Standard")
{
style.ExportTo(dbTar, Autodesk.Civil.StyleConflictResolverType.Override); //export from source to target db
}
}
tr.Commit();
}
Application.DocumentManager.MdiActiveDocument = acDocTar;
acDocSrc.CloseAndDiscard();
}
/// <summary>
/// Initializations needed when first opening the window
/// </summary>
public void Start()
{
firstCycle = false;
// Gets the inspector level from editorPrefs, if for some reason is not present it just defaults to normal and writes it (should never happen if i remembered to do the first time window)
if (EditorPrefs.HasKey(TSConstants.TSEPInspectorLevel))
{
inspectorLevel = (InspectorLevel)EditorPrefs.GetInt(TSConstants.TSEPInspectorLevel);
}
else
{
inspectorLevel = InspectorLevel.Normal;
EditorPrefs.SetInt(TSConstants.TSEPInspectorLevel, (int)InspectorLevel.Normal);
}
// Loads the settings file if exists, creates a default one if not
if (File.Exists(TSConstants.SettingsJSONPath))
{
TSSettings settings = JsonUtility.FromJson <TSSettings>(File.ReadAllText(TSConstants.SettingsJSONPath));
sectionStyle = (SectionStyle)settings.sectionStyle;
sectionColor = settings.sectionColor;
isAutoUpdateDisabled = settings.disableUpdates;
}
else
{
TSSettings settings = new TSSettings();
settings.sectionStyle = (int)SectionStyle.Bubbles;
settings.sectionColor = new Color(1, 1, 1, 1);
settings.disableUpdates = false;
File.WriteAllText(TSConstants.SettingsJSONPath, JsonUtility.ToJson(settings));
}
}
/// <summary>
/// Default section constructor
/// </summary>
/// <param name="sectionTitle">Title of the section</param>
/// <param name="open">If is open or closed upon creation</param>
/// <param name="content">Delegate function for drawing the section content</param>
/// <param name="changesCheck">Delegate fucntion for checks that need to be done knowing if the box is open or enabled at all</param>
public Section(GUIContent sectionTitle, bool open, SectionContent content, ChangesCheck changesCheck)
{
this.sectionTitle = sectionTitle;
this.isOpen = open;
this.content = content;
this.changesCheck = changesCheck;
TSSettings settings = JsonUtility.FromJson <TSSettings>(File.ReadAllText(TSConstants.SettingsJSONPath));
sectionStyle = (SectionStyle)settings.sectionStyle;
this.sectionBgColor = settings.sectionColor;
}
/// <summary>
/// Standard library use only.
/// </summary>
public Section(
SectionStyle style, string heading, IEnumerable<Control> postHeadingControls, IEnumerable<Control> contentControls, bool? expanded,
bool disableStatePersistence)
: base("section")
{
this.style = style;
this.heading = heading;
this.postHeadingControls = postHeadingControls != null ? postHeadingControls.ToArray() : new Control[ 0 ];
this.contentControls = contentControls != null ? contentControls.ToArray() : new Control[ 0 ];
this.expanded = expanded;
this.disableStatePersistence = disableStatePersistence;
}
/// <summary>
/// Standard library use only.
/// </summary>
public Section(
SectionStyle style, string heading, IEnumerable <Control> postHeadingControls, IEnumerable <Control> contentControls, bool?expanded,
bool disableStatePersistence) : base("section")
{
this.style = style;
this.heading = heading;
this.postHeadingControls = postHeadingControls != null?postHeadingControls.ToArray() : new Control[0];
this.contentControls = contentControls != null?contentControls.ToArray() : new Control[0];
this.expanded = expanded;
this.disableStatePersistence = disableStatePersistence;
}
/// <summary>
/// Creates a section error-display style.
/// </summary>
/// <param name="heading">The section's heading. Do not pass null.</param>
/// <param name="style">The section's style.</param>
public SectionErrorDisplayStyle(string heading, SectionStyle style = SectionStyle.Normal)
{
componentGetter = (errorSources, errors, componentsFocusableOnError) => {
if (!errors.Any())
{
return(Enumerable.Empty <FlowComponent>().Materialize());
}
return(new Section(
heading,
((ErrorDisplayStyle <FlowComponent>) new ListErrorDisplayStyle()).GetComponents(errorSources, errors, componentsFocusableOnError),
style: style).ToCollection());
};
}
/// <summary>
/// Main constructor
/// </summary>
/// <param name="sectionTitle">Title of the section</param>
/// <param name="open">Is the section expanded?</param>
/// <param name="enabled">IS the section enabled?</param>
/// <returns></returns>
public OrderedSection(GUIContent sectionTitle, bool open, bool enabled)
{
this.sectionTitle = sectionTitle;
this.isOpen = open;
this.isEnabled = enabled;
pushState = 0;
isUp = false;
isDown = false;
TSSettings settings = JsonUtility.FromJson <TSSettings>(File.ReadAllText(TSConstants.SettingsJSONPath));
sectionStyle = (SectionStyle)settings.sectionStyle;
this.sectionBgColor = settings.sectionColor;
}
makeSectionStyle(string strName)
{
string nameLayer = string.Format("{0}-SURFACE-SEC", strName);
ObjectId idLayer = Layer.manageLayers(nameLayer);
Color c = clr.byl;
switch (strName)
{
case "CPNT":
Layer.modifyLayer(idLayer, 4, LineWeight.ByLayer);
c = clr.cyn;
break;
case "EXIST":
Layer.modifyLayer(idLayer, 8, LineWeight.ByLayer, "DASHED");
c = clr.c8;
break;
case "SG":
Layer.modifyLayer(idLayer, 1, LineWeight.ByLayer);
c = clr.red;
break;
case "OX":
Layer.modifyLayer(idLayer, 3, LineWeight.ByLayer);
c = clr.grn;
break;
case "BOT":
Layer.modifyLayer(idLayer, 5, LineWeight.ByLayer);
c = clr.blu;
break;
}
ObjectId idStyle = Sect_Style.getSectionStyleId(strName);
using (var tr = BaseObjs.startTransactionDb()){
SectionStyle objSectionStyle = (SectionStyle)tr.GetObject(idStyle, OpenMode.ForWrite);
objSectionStyle.CreateBy = "EarthWork";
DisplayStyle ds = objSectionStyle.GetDisplayStyleSection(SectionDisplayStyleSectionType.Segments);
ds.Visible = true;
ds.Layer = nameLayer;
ds.Color = c;
ds.Linetype = "ByLayer";
tr.Commit();
}
}
/// <summary>
/// Draws the settings GUI
/// </summary>
private void DrawSettings()
{
EditorGUI.BeginChangeCheck();
inspectorLevel = (InspectorLevel)EditorGUILayout.EnumPopup(TSConstants.TSWindowLabels.InspectorLevel, inspectorLevel);
if (EditorGUI.EndChangeCheck())
{
EditorPrefs.SetInt(TSConstants.TSEPInspectorLevel, (int)inspectorLevel);
}
EditorGUI.BeginChangeCheck();
updater.updateStream = (UpdateStream)EditorGUILayout.EnumPopup(TSConstants.TSWindowLabels.UpdateStream, updater.updateStream);
if (EditorGUI.EndChangeCheck())
{
LocalVersionJSON local = JsonUtility.FromJson <LocalVersionJSON>(File.ReadAllText(TSConstants.LocalJSONPath));
local.beta = updater.updateStream == UpdateStream.Beta;
File.WriteAllText(TSConstants.LocalJSONPath, JsonUtility.ToJson(local));
updater.Reset();
}
EditorGUI.BeginChangeCheck();
sectionStyle = (SectionStyle)EditorGUILayout.EnumPopup(TSConstants.TSWindowLabels.SectionStyle, sectionStyle);
sectionColor = EditorGUILayout.ColorField(TSConstants.TSWindowLabels.Color, sectionColor);
isAutoUpdateDisabled = EditorGUILayout.Toggle(TSConstants.TSWindowLabels.DisableAutoUpdates, isAutoUpdateDisabled);
if (EditorGUI.EndChangeCheck())
{
TSSettings settings = JsonUtility.FromJson <TSSettings>(File.ReadAllText(TSConstants.SettingsJSONPath));
settings.sectionStyle = (int)sectionStyle;
settings.sectionColor = sectionColor;
settings.disableUpdates = isAutoUpdateDisabled;
File.WriteAllText(TSConstants.SettingsJSONPath, JsonUtility.ToJson(settings));
exampleSection = new Section(new GUIContent("Example Section"), true, delegate(MaterialEditor m){ EditorGUILayout.LabelField("Example content"); }, delegate(bool a, bool b){});
}
GUILayout.Space(20);
if (exampleSection == null)
{
exampleSection = new Section(new GUIContent("Example Section"), true, delegate(MaterialEditor m){ EditorGUILayout.LabelField("Example content"); }, delegate(bool a, bool b){});
}
exampleSection.DrawSection(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="TableOfContents"/> class.
/// </summary>
/// <param name="textDocument">The text document.</param>
/// <param name="styleName">Name of the style.</param>
/// <param name="useHyperlinks">if set to <c>true</c> [use hyperlinks].</param>
/// <param name="protectChanges">if set to <c>true</c> [protect changes].</param>
/// <param name="textName">Title for the Table of content e.g. Table of Content</param>
public TableOfContents(IDocument textDocument, string styleName, bool useHyperlinks, bool protectChanges,
string textName)
{
Document = textDocument;
UseHyperlinks = useHyperlinks;
Node = new XElement(Ns.Text + "table-of-content");
Node.SetAttributeValue(Ns.Text + "style-name", styleName);
Node.SetAttributeValue(Ns.Text + "protected", Convert.ToString(protectChanges).ToLower());
Node.SetAttributeValue(Ns.Text + "use-outline-level", "true");
Node.SetAttributeValue(Ns.Text + "name", textName ?? "Table of Contents1");
Style = new SectionStyle(this, styleName);
Document.Styles.Add(Style);
TableOfContentsSource = new TableOfContentsSource(this);
TableOfContentsSource.InitStandardTableOfContentStyle();
Node.Add(TableOfContentsSource.Node);
CreateIndexBody();
CreateTitlePargraph();
InsertContentStyle();
SetOutlineStyle();
RegisterEvents();
}
/// <summary>
/// Standard library use only.
/// </summary>
public Section(
SectionStyle style, string heading, IEnumerable <Control> postHeadingControls, IEnumerable <Control> contentControls, bool?expanded,
bool disableStatePersistence) : base("section")
{
postHeadingControls = postHeadingControls?.ToArray() ?? new Control[0];
contentControls = contentControls?.ToArray() ?? new Control[0];
CssClass =
CssClass.ConcatenateWithSpace(
allStylesBothStatesClass + " " +
(style == SectionStyle.Normal
? getSectionClass(expanded, normalClosedClass, normalExpandedClass)
: getSectionClass(expanded, boxClosedClass, boxExpandedClass)));
if (heading.Any())
{
var headingControls =
new WebControl(HtmlTextWriterTag.H1)
{
CssClass = headingClass
}.AddControlsReturnThis(heading.ToComponents().GetControls())
.ToCollection()
.Concat(postHeadingControls);
if (expanded.HasValue)
{
var toggleClasses = style == SectionStyle.Normal ? new[] { normalClosedClass, normalExpandedClass } : new[] { boxClosedClass, boxExpandedClass };
var headingContainer =
new Block(
new GenericPhrasingContainer("Click to Expand".ToComponents(), classes: closeClass).ToCollection()
.Concat(new GenericPhrasingContainer("Click to Close".ToComponents(), classes: expandClass))
.GetControls()
.Concat(headingControls)
.ToArray())
{
CssClass = headingClass
};
var actionControlStyle = new CustomActionControlStyle(c => c.AddControlsReturnThis(headingContainer));
this.AddControlsReturnThis(
disableStatePersistence
? new CustomButton(() => "$( '#" + ClientID + "' ).toggleClass( '" + StringTools.ConcatenateWithDelimiter(" ", toggleClasses) + "', 200 )")
{
ActionControlStyle = actionControlStyle
}
: new ToggleButton(this.ToCollection(), actionControlStyle, false, (postBackValue, validator) => { }, toggleClasses: toggleClasses) as Control);
}
else
{
var headingContainer = new Block(headingControls.ToArray())
{
CssClass = headingClass
};
this.AddControlsReturnThis(new Block(headingContainer));
}
}
if (contentControls.Any())
{
this.AddControlsReturnThis(new Block(contentControls.ToArray())
{
CssClass = contentClass
});
}
}
static void Main(string[] args)
{
TextDocument doc = new TextDocument();
SectionColumn column1 = new SectionColumn();
column1.RelativeWidth = 32767;
column1.LeftSpace = new Independentsoft.Office.Odf.Size(0, Unit.Inch);
column1.RightSpace = new Independentsoft.Office.Odf.Size(0, Unit.Inch);
SectionColumn column2 = new SectionColumn();
column2.RelativeWidth = 32767;
column2.LeftSpace = new Independentsoft.Office.Odf.Size(0, Unit.Inch);
column2.RightSpace = new Independentsoft.Office.Odf.Size(0, Unit.Inch);
SectionStyle sectionStyle1 = new SectionStyle("Style1");
sectionStyle1.Columns.Add(column1);
sectionStyle1.Columns.Add(column2);
SectionStyle sectionStyle2 = new SectionStyle("Style2");
sectionStyle2.BackgroundColor = "#FFFF00"; //yellow
doc.AutomaticStyles.Styles.Add(sectionStyle1);
doc.AutomaticStyles.Styles.Add(sectionStyle2);
Paragraph paragraph1 = new Paragraph();
paragraph1.Add("Text in the first section.");
Paragraph paragraph2 = new Paragraph();
paragraph2.Add("Text in the second section.");
Paragraph emptyParagraph = new Paragraph();
Section section1 = new Section();
section1.Name = "Section1";
section1.Style = "Style1";
section1.Add(paragraph1);
section1.Add(paragraph1);
section1.Add(paragraph1);
section1.Add(emptyParagraph);
section1.Add(emptyParagraph);
section1.Add(paragraph1);
Section section2 = new Section();
section2.Name = "Section2";
section2.Style = "Style2";
section2.Add(paragraph2);
section2.Add(paragraph2);
section2.Add(paragraph2);
section2.Add(paragraph2);
section2.Add(paragraph2);
section2.Add(paragraph2);
doc.Body.Add(section1);
doc.Body.Add(section2);
doc.Save("c:\\test\\output.odt", true);
}
/// <summary>
/// Creates a section.
/// </summary>
/// <param name="heading">The section's heading. Do not pass null.</param>
/// <param name="contentControls">The section's content.</param>
/// <param name="style">The section's style.</param>
/// <param name="postHeadingControls">Controls that follow the heading but are still part of the heading container.</param>
/// <param name="expanded">Set to true or false if you want users to be able to expand or close the section by clicking on the heading.</param>
public Section(
string heading, IEnumerable<Control> contentControls, SectionStyle style = SectionStyle.Normal, IEnumerable<Control> postHeadingControls = null,
bool? expanded = null)
: this(style, heading, postHeadingControls, contentControls, expanded, false)
{
}
/// <summary>
/// Creates a section.
/// </summary>
/// <param name="contentControls">The section's content.</param>
/// <param name="style">The section's style.</param>
public Section( IEnumerable<Control> contentControls, SectionStyle style = SectionStyle.Normal )
: this("", contentControls, style: style)
{
}
public Section GetSection(SectionStyle style, bool isDamaged = false, int maxTries = 0)
{
var cardSpaces = 3;
var formationTypes = new List <FormationType>()
{
FormationType.SUIT_RUN,
FormationType.SAME_RANK,
FormationType.SAME_SUIT,
FormationType.RUN,
FormationType.SUM
};
switch (style)
{
case SectionStyle.RightPit:
cardSpaces = 3;
formationTypes = isDamaged ?
new List <FormationType>()
{
FormationType.RUN, FormationType.SUM
} :
new List <FormationType>()
{
FormationType.LOW_SUM
};
break;
case SectionStyle.LeftPit:
formationTypes = isDamaged ?
new List <FormationType>()
{
FormationType.RUN, FormationType.SUM
} :
new List <FormationType>()
{
FormationType.SUM
};
break;
case SectionStyle.LeftTower:
case SectionStyle.RightTower:
if (isDamaged)
{
cardSpaces = 2;
formationTypes = new List <FormationType>()
{
FormationType.SAME_RANK,
FormationType.SUM,
};
}
else
{
cardSpaces = 4;
}
break;
case SectionStyle.LeftWall:
case SectionStyle.RightWall:
if (isDamaged)
{
formationTypes = new List <FormationType>()
{
FormationType.SAME_SUIT,
FormationType.SUM,
};
}
break;
case SectionStyle.Gate:
if (isDamaged)
{
cardSpaces = 4;
formationTypes = new List <FormationType>()
{
FormationType.LOW_SUM
};
}
else
{
cardSpaces = 2;
}
break;
}
var section = new Section()
{
Style = style,
Name = style.ToString("F"),
IsDamaged = isDamaged,
Spaces = cardSpaces,
Types = formationTypes,
MaxTries = maxTries,
};
return(section);
}
/// <summary>
/// Creates a section.
/// </summary>
/// <param name="heading">The section's heading. Do not pass null.</param>
/// <param name="contentControls">The section's content.</param>
/// <param name="style">The section's style.</param>
/// <param name="postHeadingControls">Controls that follow the heading but are still part of the heading container.</param>
/// <param name="expanded">Set to true or false if you want users to be able to expand or close the section by clicking on the heading.</param>
public Section(
string heading, IEnumerable <Control> contentControls, SectionStyle style = SectionStyle.Normal, IEnumerable <Control> postHeadingControls = null,
bool?expanded = null) : this(style, heading, postHeadingControls, contentControls, expanded, false)
{
}
/// <summary>
/// Creates a section.
/// </summary>
/// <param name="heading">The section's heading. Do not pass null.</param>
/// <param name="content">The section's content.</param>
/// <param name="displaySetup"></param>
/// <param name="style">The section's style.</param>
/// <param name="classes">The classes on the section.</param>
/// <param name="postHeadingComponents">Components that follow the heading but are still part of the heading container.</param>
/// <param name="expanded">Set to true or false if you want users to be able to expand or close the section by clicking on the heading.</param>
/// <param name="etherealContent"></param>
public Section(
string heading, IReadOnlyCollection <FlowComponent> content, DisplaySetup displaySetup = null, SectionStyle style = SectionStyle.Normal,
ElementClassSet classes = null, IReadOnlyCollection <FlowComponent> postHeadingComponents = null, bool?expanded = null,
IReadOnlyCollection <EtherealComponent> etherealContent = null) : this(
displaySetup,
style,
classes,
heading,
postHeadingComponents,
content,
expanded,
false,
etherealContent)
{
}
/// <summary>
/// Creates a section error-display style.
/// </summary>
/// <param name="heading">The section's heading. Do not pass null.</param>
/// <param name="style">The section's style.</param>
public SectionErrorDisplayStyle(string heading, SectionStyle style = SectionStyle.Normal)
{
this.style = style;
this.heading = heading;
}
/// <summary>
/// Creates a section error-display style.
/// </summary>
/// <param name="heading">The section's heading. Do not pass null.</param>
/// <param name="style">The section's style.</param>
public SectionErrorDisplayStyle( string heading, SectionStyle style = SectionStyle.Normal )
{
this.style = style;
this.heading = heading;
}
/// <summary>
/// BasicPage.master use only.
/// </summary>
public Section(
DisplaySetup displaySetup, SectionStyle style, ElementClassSet classes, string heading, IReadOnlyCollection <FlowComponent> postHeadingComponents,
IReadOnlyCollection <FlowComponent> content, bool?expanded, bool disableStatePersistence, IReadOnlyCollection <EtherealComponent> etherealContent)
{
children = new DisplayableElement(
context => {
var hiddenFieldId = new HiddenFieldId();
var expandedPmv = heading.Any() && expanded.HasValue && !disableStatePersistence ? new PageModificationValue <string>() : null;
FlowComponent getHeadingButton()
{
var headingComponents =
new DisplayableElement(
headingContext => new DisplayableElementData(
null,
() => new DisplayableElementLocalData("h1"),
classes: headingClass,
children: heading.ToComponents())).Concat(postHeadingComponents ?? Enumerable.Empty <FlowComponent>());
return(expanded.HasValue
?
// We cannot use EwfButton because we have flow content.
ElementActivationBehavior.GetActivatableElement(
"div",
ElementClassSet.Empty,
Enumerable.Empty <Tuple <string, string> >().Materialize(),
ElementActivationBehavior.CreateButton(
buttonBehavior: new CustomButtonBehavior(
() => disableStatePersistence
? "$( '#{0}' ).toggleClass( '{1}', 200 );".FormatWith(
context.Id,
StringTools.ConcatenateWithDelimiter(
" ",
style == SectionStyle.Normal
? new[] { normalClosedClass.ClassName, normalExpandedClass.ClassName }
: new[] { boxClosedClass.ClassName, boxExpandedClass.ClassName }))
: hiddenFieldId.GetJsValueModificationStatements(
"document.getElementById( '{0}' ).value === '{2}' ? '{1}' : '{2}'".FormatWith(
hiddenFieldId.ElementId.Id,
bool.FalseString,
bool.TrueString)))),
new GenericFlowContainer(
new GenericPhrasingContainer("Click to Expand".ToComponents(), classes: closeClass).ToCollection()
.Append(new GenericPhrasingContainer("Click to Close".ToComponents(), classes: expandClass))
.Concat(headingComponents)
.Materialize(),
classes: headingClass).ToCollection(),
Enumerable.Empty <EtherealComponent>().Materialize())
: new GenericFlowContainer(new GenericFlowContainer(headingComponents.Materialize(), classes: headingClass).ToCollection()));
}
content = content ?? Enumerable.Empty <FlowComponent>().Materialize();
return(new DisplayableElementData(
displaySetup,
() => new DisplayableElementLocalData(
"section",
focusDependentData:
new DisplayableElementFocusDependentData(includeIdAttribute: heading.Any() && expanded.HasValue && disableStatePersistence)),
classes: allStylesBothStatesClass
.Add(
style == SectionStyle.Normal
? getSectionClasses(expanded, expandedPmv, normalClosedClass, normalExpandedClass)
: getSectionClasses(expanded, expandedPmv, boxClosedClass, boxExpandedClass))
.Add(classes ?? ElementClassSet.Empty),
children: (heading.Any() ? getHeadingButton().ToCollection() : Enumerable.Empty <FlowComponent>()).Concat(
content.Any() ? new GenericFlowContainer(content, classes: contentClass).ToCollection() : Enumerable.Empty <FlowComponent>())
.Materialize(),
etherealChildren: (expandedPmv != null
? new EwfHiddenField(expanded.Value.ToString(), id: hiddenFieldId, pageModificationValue: expandedPmv).PageComponent
.ToCollection()
: Enumerable.Empty <EtherealComponent>()).Concat(etherealContent ?? Enumerable.Empty <EtherealComponent>())
.Materialize()));
}).ToCollection();
}
/// <summary>
/// Creates a section.
/// </summary>
/// <param name="contentControls">The section's content.</param>
/// <param name="style">The section's style.</param>
public Section(IEnumerable <Control> contentControls, SectionStyle style = SectionStyle.Normal) : this("", contentControls, style : style)
{
}
/// <summary>
/// Creates a section.
/// </summary>
/// <param name="content">The section's content.</param>
/// <param name="displaySetup"></param>
/// <param name="style">The section's style.</param>
/// <param name="classes">The classes on the section.</param>
/// <param name="etherealContent"></param>
public Section(
IReadOnlyCollection <FlowComponent> content, DisplaySetup displaySetup = null, SectionStyle style = SectionStyle.Normal, ElementClassSet classes = null,
IReadOnlyCollection <EtherealComponent> etherealContent = null) : this(
"",
content,
displaySetup : displaySetup,
style : style,
classes : classes,
etherealContent : etherealContent)
{
}