public override string GetTemplateContent (
ITemplateEditingFrame editing_frame,
string template_name,
out bool allow_editing)
{
throw new NotImplementedException ();
}
public override string GetTemplateContent(
ITemplateEditingFrame editing_frame,
string template_name,
out bool allow_editing)
{
throw new NotImplementedException();
}
/// <include file='doc\TemplatedControlDesigner.uex' path='docs/doc[@for="TemplatedControlDesigner.GetTemplateEditingVerbs"]/*' />
public TemplateEditingVerb[] GetTemplateEditingVerbs()
{
if (templateVerbHandler == null)
{
ITemplateEditingService teService =
(ITemplateEditingService)GetService(typeof(ITemplateEditingService));
Debug.Assert(teService != null, "Host that does not implement ITemplateEditingService is asking for template verbs");
if (teService == null)
{
return(null);
}
templateVerbHandler = new EventHandler(this.OnTemplateEditingVerbInvoked);
}
TemplateEditingVerb[] templateVerbs = GetCachedTemplateEditingVerbs();
if ((templateVerbs != null) && (templateVerbs.Length > 0))
{
ITemplateEditingFrame activeTemplateFrame = ActiveTemplateEditingFrame;
for (int i = 0; i < templateVerbs.Length; i++)
{
templateVerbs[i].Checked = (activeTemplateFrame != null) &&
(templateVerbs[i].EditingFrame == activeTemplateFrame);
}
}
return(templateVerbs);
}
protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
{
ITemplateEditingFrame frame = null;
if (null != tmplEditingVerbs)
{
ITemplateEditingService tmplEditingService = (ITemplateEditingService)GetService(typeof(ITemplateEditingService));
if (null != tmplEditingService)
{
Style style = ((TemplateMenu)Component).ControlStyle;
if (tmplEditingVerbs[0] == verb)
{
frame = tmplEditingService.CreateFrame(this, verb.Text, new string[] { "Header Template" }, style, null);
}
if (tmplEditingVerbs[1] == verb)
{
frame = tmplEditingService.CreateFrame(this, verb.Text, new string[] { "Separator Template" }, style, null);
}
if (tmplEditingVerbs[2] == verb)
{
frame = tmplEditingService.CreateFrame(this, verb.Text, new string[] { "Footer Template" }, style, null);
}
}
}
return(frame);
}
public override String GetTemplateContent(
ITemplateEditingFrame editingFrame,
String templateName,
out bool allowEditing)
{
Debug.Assert(AllowTemplateEditing);
#if DEBUG
CheckTemplateName(templateName);
#endif
allowEditing = true;
ITemplate template = null;
String templateContent = String.Empty;
// Here we trust the TemplateVerbs to give valid template names
template = (ITemplate)CurrentChoice.Templates[templateName];
if (template != null)
{
templateContent = GetTextFromTemplate(template);
if (!IsCompleteHtml(templateContent))
{
allowEditing = false;
templateContent = String.Format(CultureInfo.CurrentCulture, _illFormedHtml, _illFormedWarning);
}
}
return(templateContent);
}
protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
{
ITemplateEditingFrame frame = null;
if ((_templateEditingVerbs != null) && ((IList)_templateEditingVerbs).Contains(verb))
{
ITemplateEditingService teService = (ITemplateEditingService)GetService(typeof(ITemplateEditingService));
if (teService != null)
{
ListView lv = (ListView)Component;
string[] templateNames = null;
Style[] templateStyles = null;
switch (verb.Index)
{
case HeaderFooterTemplates:
templateNames = HeaderFooterTemplateNames;
templateStyles = new Style[] { lv.HeaderStyle, lv.FooterStyle };
break;
case ItemTemplates:
templateNames = ItemTemplateNames;
templateStyles = new Style[] { lv.ItemStyle, lv.EditItemStyle };
break;
}
frame = teService.CreateFrame(this, verb.Text, templateNames, lv.ControlStyle, templateStyles);
}
}
return(frame);
}
public override void SetTemplateContent(
ITemplateEditingFrame editing_frame,
string template_name,
string template_content)
{
throw new NotImplementedException();
}
protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
{
ITemplateEditingFrame frame = null;
for (int i = 0; i < _templateEditingVerbs.Length; i++)
{
if (_templateEditingVerbs[i] == verb)
{
index = i;
}
}
System.Diagnostics.Debug.WriteLine(index.ToString() + ":CreateTemplateEditingFrame");
if ((_templateEditingVerbs != null) && (index >= 0)) //(_templateEditingVerbs[0] == verb))
{
ITemplateEditingService teService = (ITemplateEditingService)GetService(typeof(ITemplateEditingService));
if (teService != null)
{
Style style = ((WeavverTabControl)Component).ControlStyle;
frame = teService.CreateFrame(this, verb.Text, new string[] { "New Tab Template" }, style, null);
}
}
return(frame);
}
/// <summary>
/// Sets the current string value of a selected template in design mode
/// </summary>
/// <param name="editingFrame">The template editing frame to retrieve the content of.</param>
/// <param name="templateName">Name of the template</param>
/// <param name="templateContent">Content retrieved from frame in designer.</param>
/// <returns></returns>
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
ITemplate template = null;
if ((templateContent != null) && (templateContent.Length != 0))
{
template = GetTemplateFromText(templateContent);
}
if (templateName.Equals("HeaderTemplate") && editingFrame.Verb.Index == 0)
{
((Result)Component).HeaderTemplate = template;
}
else if (templateName.Equals("StatusTemplate") && editingFrame.Verb.Index == 1)
{
((Result)Component).StatusTemplate = template;
}
else if (templateName.Equals("ItemTemplate") && editingFrame.Verb.Index == 2)
{
((Result)Component).ItemTemplate = template;
}
else if (templateName.Equals("AlternatingItemTemplate") && editingFrame.Verb.Index == 3)
{
((Result)Component).AlternatingItemTemplate = template;
}
else if (templateName.Equals("SeparatorTemplate") && editingFrame.Verb.Index == 4)
{
((Result)Component).SeparatorTemplate = template;
}
else if (templateName.Equals("FooterTemplate") && editingFrame.Verb.Index == 5)
{
((Result)Component).FooterTemplate = template;
}
}
public override void SetTemplateContent(
ITemplateEditingFrame editingFrame,
String templateName,
String templateContent)
{
Debug.Assert(AllowTemplateEditing);
// Debug build only checking
CheckTemplateName(templateName);
ITemplate template = null;
if ((templateContent != null) && (templateContent.Length != 0))
{
template = GetTemplateFromText(templateContent);
}
else
{
CurrentChoice.Templates.Remove(templateName);
return;
}
// Here we trust the TemplateVerbs to give valid template names
CurrentChoice.Templates[templateName] = template;
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
DataGrid component = (DataGrid)base.Component;
int index = editingFrame.Verb.Index;
TemplateColumn column = (TemplateColumn)component.Columns[index];
ITemplate headerTemplate = null;
string textFromTemplate = string.Empty;
if (templateName.Equals(ColumnTemplateNames[2]))
{
headerTemplate = column.HeaderTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[0]))
{
headerTemplate = column.ItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[1]))
{
headerTemplate = column.EditItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[3]))
{
headerTemplate = column.FooterTemplate;
}
if (headerTemplate != null)
{
textFromTemplate = base.GetTextFromTemplate(headerTemplate);
}
return(textFromTemplate);
}
protected virtual void Dispose(bool disposing)
{
if (disposing && (this.editingFrame != null))
{
this.editingFrame.Dispose();
this.editingFrame = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing && (this.editingFrame != null))
{
this.editingFrame.Dispose();
this.editingFrame = null;
}
}
public override string GetTemplateContent(
ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
Trace.Assert(editingFrame.Verb.Index >= 0 && editingFrame.Verb.Index <= 2);
allowEditing = true;
ITemplate template = null;
var templateContent = String.Empty;
switch (editingFrame.Verb.Index)
{
case PaneTemplates:
if (templateName == PaneTemplateNames[IdxLeftPaneTemplate])
{
template = this.desktopPanes.LeftPaneTemplate;
break;
}
if (templateName == PaneTemplateNames[IdxContentPaneTemplate])
{
template = this.desktopPanes.ContentPaneTemplate;
break;
}
if (templateName == PaneTemplateNames[IdxRightPaneTemplate])
{
template = this.desktopPanes.RightPaneTemplate;
break;
}
break;
case SeparatorTemplates:
if (templateName == PaneTemplateNames[IdxHorizontalSeparatorTemplate])
{
template = this.desktopPanes.HorizontalSeparatorTemplate;
break;
}
if (templateName == PaneTemplateNames[IdxVerticalSeparatorTemplate])
{
template = this.desktopPanes.VerticalSeparatorTemplate;
break;
}
break;
}
if (template != null)
{
templateContent = this.GetTextFromTemplate(template);
}
return(templateContent);
}
/// <include file='doc\TemplateEditingVerb.uex' path='docs/doc[@for="TemplateEditingVerb.Dispose2"]/*' />
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (editingFrame != null)
{
editingFrame.Dispose();
editingFrame = null;
}
}
}
public override void SetTemplateContent(
ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
Trace.Assert(editingFrame.Verb.Index >= 0 && editingFrame.Verb.Index <= 2);
ITemplate template = null;
if (!string.IsNullOrEmpty(templateContent))
{
template = this.GetTemplateFromText(templateContent);
}
switch (editingFrame.Verb.Index)
{
case PaneTemplates:
if (templateName == PaneTemplateNames[IdxLeftPaneTemplate])
{
this.desktopPanes.LeftPaneTemplate = template;
return;
}
if (templateName == PaneTemplateNames[IdxContentPaneTemplate])
{
this.desktopPanes.ContentPaneTemplate = template;
return;
}
if (templateName == PaneTemplateNames[IdxRightPaneTemplate])
{
this.desktopPanes.RightPaneTemplate = template;
return;
}
break;
case SeparatorTemplates:
if (templateName == PaneTemplateNames[IdxHorizontalSeparatorTemplate])
{
this.desktopPanes.HorizontalSeparatorTemplate = template;
return;
}
if (templateName == PaneTemplateNames[IdxVerticalSeparatorTemplate])
{
this.desktopPanes.VerticalSeparatorTemplate = template;
return;
}
return;
default:
return;
}
}
/// <include file='doc\TemplatedControlDesigner.uex' path='docs/doc[@for="TemplatedControlDesigner.ExitTemplateMode"]/*' />
/// <devdoc>
/// <para>
/// Closes the currently active template editing frame after saving any relevant changes.
/// </para>
/// </devdoc>
public void ExitTemplateMode(bool fSwitchingTemplates, bool fNested, bool fSave)
{
Debug.Assert(ActiveTemplateEditingFrame != null, "Invalid current template frame!");
try {
IWebFormsDocumentService wfServices = (IWebFormsDocumentService)GetService(typeof(IWebFormsDocumentService));
Debug.Assert(wfServices != null, "Did not get IWebFormsDocumentService");
// First let the inner/nested designers handle exiting of their template mode.
// Note: This has to be done inside-out in order to ensure that the changes
// made in a particular template are saved before its immediate outer level
// control designer saves its children.
ExitNestedTemplates(fSave);
// Save the current contents of all the templates within the active frame, and
// close the frame by removing it from the tree.
ActiveTemplateEditingFrame.Close(fSave);
// Reset the pointer to the active template frame.
// NOTE: Do not call activeTemplateFrame.Dispose here - we're in the process of exiting template mode
// and calling Dispose will attempt to exit template mode again. Calling dispose would also
// throw away the cached html tree, which we want to hang on for perf reasons.
activeTemplateFrame = null;
if (!fSwitchingTemplates)
{
// No longer in template editing mode.
// This will fire the OnTemplateModeChanged notification
SetTemplateMode(false, fSwitchingTemplates);
// When not switching from one template frame to another and it is the
// outer most designer being switched out of template editing, then
// update its design-time html:
if (!fNested)
{
UpdateDesignTimeHtml();
// Invalidate the type descriptor so that proper filtering of properties
// is done when exiting template mode.
TypeDescriptor.Refresh(Component);
if (wfServices != null)
{
wfServices.UpdateSelection();
}
}
}
}
catch (Exception) {
}
}
/// <include file='doc\DataGridDesigner.uex' path='docs/doc[@for="DataGridDesigner.CreateTemplateEditingFrame"]/*' />
protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
{
ITemplateEditingService teService = (ITemplateEditingService)GetService(typeof(ITemplateEditingService));
Debug.Assert(teService != null, "How did we get this far without an ITemplateEditingService");
Style[] templateStyles = new Style[] { dataGrid.HeaderStyle, dataGrid.ItemStyle, dataGrid.AlternatingItemStyle, dataGrid.FooterStyle };
ITemplateEditingFrame editingFrame =
teService.CreateFrame(this, verb.Text, ColumnTemplateNames, dataGrid.ControlStyle, templateStyles);
return(editingFrame);
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
DataList component = (DataList)base.Component;
ITemplate itemTemplate = null;
string textFromTemplate = string.Empty;
switch (editingFrame.Verb.Index)
{
case 0:
if (!templateName.Equals(ItemTemplateNames[0]))
{
if (templateName.Equals(ItemTemplateNames[1]))
{
itemTemplate = component.AlternatingItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[2]))
{
itemTemplate = component.SelectedItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[3]))
{
itemTemplate = component.EditItemTemplate;
}
break;
}
itemTemplate = component.ItemTemplate;
break;
case 1:
if (!templateName.Equals(HeaderFooterTemplateNames[0]))
{
if (templateName.Equals(HeaderFooterTemplateNames[1]))
{
itemTemplate = component.FooterTemplate;
}
break;
}
itemTemplate = component.HeaderTemplate;
break;
case 2:
itemTemplate = component.SeparatorTemplate;
break;
}
if (itemTemplate != null)
{
textFromTemplate = base.GetTextFromTemplate(itemTemplate);
}
return(textFromTemplate);
}
/// <summary>
/// Override the SetTemplateContent method that sets
/// the template content.
/// </summary>
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
Trace.Assert(editingFrame.Verb.Index >= 0 && editingFrame.Verb.Index <= 2);
ITemplate template = null;
if (templateContent != null && templateContent.Length != 0)
{
template = GetTemplateFromText(templateContent);
}
switch (editingFrame.Verb.Index)
{
case PaneTemplates:
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_LEFT_PANE_TEMPLATE])
{
desktopPanes.LeftPaneTemplate = template;
return;
}
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_CONTENT_PANE_TEMPLATE])
{
desktopPanes.ContentPaneTemplate = template;
return;
}
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_RIGHT_PANE_TEMPLATE])
{
desktopPanes.RightPaneTemplate = template;
return;
}
break;
case SeparatorTemplates:
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_HORIZONTAL_SEPARATOR_TEMPLATE])
{
desktopPanes.HorizontalSeparatorTemplate = template;
return;
}
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_VERTICAL_SEPARATOR_TEMPLATE])
{
desktopPanes.VerticalSeparatorTemplate = template;
return;
}
return;
default:
return;
}
}
/// <summary>
/// Override the GetTemplateContent method that gets
/// the template content.
/// </summary>
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
Trace.Assert(editingFrame.Verb.Index >= 0 && editingFrame.Verb.Index <= 2);
allowEditing = true;
ITemplate template = null;
string templateContent = String.Empty;
switch (editingFrame.Verb.Index)
{
case PaneTemplates:
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_LEFT_PANE_TEMPLATE])
{
template = desktopPanes.LeftPaneTemplate;
break;
}
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_CONTENT_PANE_TEMPLATE])
{
template = desktopPanes.ContentPaneTemplate;
break;
}
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_RIGHT_PANE_TEMPLATE])
{
template = desktopPanes.RightPaneTemplate;
break;
}
break;
case SeparatorTemplates:
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_HORIZONTAL_SEPARATOR_TEMPLATE])
{
template = desktopPanes.HorizontalSeparatorTemplate;
break;
}
if (templateName == DesktopPanesDesigner.PaneTemplateNames[IDX_VERTICAL_SEPARATOR_TEMPLATE])
{
template = desktopPanes.VerticalSeparatorTemplate;
break;
}
break;
}
if (template != null)
{
templateContent = GetTextFromTemplate(template);
}
return(templateContent);
}
/// <summary>
/// Creates a template editing frame for a specified designer verb.
/// </summary>
/// <param name="verb">The template editing verb to create a template editing frame for. </param>
/// <returns>ITemplateEditingFrame-based frame instance</returns>
protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
{
ITemplateEditingService teService = (ITemplateEditingService)GetService(typeof(ITemplateEditingService));
string [] templateNames = new string[1];
Style[] templateStyles = new Style[1];
switch (verb.Index)
{
case 0:
templateNames[0] = "HeaderTemplate";
templateStyles[0] = ((Result)Component).HeaderStyle;
break;
case 1:
templateNames[0] = "StatusTemplate";
templateStyles[0] = ((Result)Component).StatusStyle;
break;
case 2:
templateNames[0] = "ItemTemplate";
templateStyles[0] = ((Result)Component).ItemStyle;
break;
case 3:
templateNames[0] = "AlternatingItemTemplate";
templateStyles[0] = ((Result)Component).AlternatingItemStyle;
break;
case 4:
templateNames[0] = "SeparatorTemplate";
templateStyles[0] = ((Result)Component).SeparatorStyle;
break;
case 5:
templateNames[0] = "FooterTemplate";
templateStyles[0] = ((Result)Component).FooterStyle;
break;
}
ITemplateEditingFrame editingFrame =
teService.CreateFrame(this, verb.Text, templateNames,
((Result)Component).ControlStyle, templateStyles);
return(editingFrame);
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
if ((_templateEditingVerbs != null) &&
(_templateEditingVerbs[index] == editingFrame.Verb))
{
WeavverTabControl control = (WeavverTabControl)Component;
ITemplate newTemplate = null;
if ((templateContent != null) &&
(templateContent.Length != 0))
{
newTemplate = GetTemplateFromText(templateContent);
//control.Tabs[index] = newTemplate;
}
}
UpdateDesignTimeHtml();
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
int index = editingFrame.Verb.Index;
DataGrid component = (DataGrid)base.Component;
TemplateColumn column = (TemplateColumn)component.Columns[index];
ITemplate templateFromText = null;
if ((templateContent != null) && (templateContent.Length != 0))
{
ITemplate currentTemplate = null;
if (templateName.Equals(ColumnTemplateNames[2]))
{
currentTemplate = column.HeaderTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[0]))
{
currentTemplate = column.ItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[1]))
{
currentTemplate = column.EditItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[3]))
{
currentTemplate = column.FooterTemplate;
}
templateFromText = base.GetTemplateFromText(templateContent, currentTemplate);
}
if (templateName.Equals(ColumnTemplateNames[2]))
{
column.HeaderTemplate = templateFromText;
}
else if (templateName.Equals(ColumnTemplateNames[0]))
{
column.ItemTemplate = templateFromText;
}
else if (templateName.Equals(ColumnTemplateNames[1]))
{
column.EditItemTemplate = templateFromText;
}
else if (templateName.Equals(ColumnTemplateNames[3]))
{
column.FooterTemplate = templateFromText;
}
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
if (this.templateEditingVerbs != null)
{
WebPartZone control = (WebPartZone)Component;
ITemplate newTemplate = null;
if ((templateContent != null) && (templateContent.Length > 0))
{
newTemplate = this.GetTemplateFromText(templateContent);
}
if (templateName == "ZoneTemplate")
{
control.ZoneTemplate = newTemplate;
}
}
}
protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
{
ITemplateEditingFrame frame = null;
if (this.templateEditingVerbs != null)
{
ITemplateEditingService teService = (ITemplateEditingService)this.GetService(typeof(ITemplateEditingService));
if (teService != null)
{
Style style = ((WebPartZone)Component).ControlStyle;
String templateName = verb.Text.Replace(" ", "");
frame = teService.CreateFrame(this, verb.Text, new string[] { templateName }, style, null);
}
}
return(frame);
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
if ((_templateEditingVerbs != null) && ((IList)_templateEditingVerbs).Contains(editingFrame.Verb))
{
ListView lv = (ListView)Component;
ITemplate template = null;
switch (editingFrame.Verb.Index)
{
case HeaderFooterTemplates:
if (templateName.Equals(HeaderFooterTemplateNames[HeaderTemplate]))
{
template = lv.HeaderTemplate;
}
else if (templateName.Equals(HeaderFooterTemplateNames[FooterTemplate]))
{
template = lv.FooterTemplate;
}
break;
case ItemTemplates:
if (templateName.Equals(ItemTemplateNames[ItemTemplate]))
{
template = lv.ItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[EditItemTemplate]))
{
template = lv.EditItemTemplate;
}
break;
}
string templateContent = String.Empty;
if (template != null)
{
templateContent = GetTextFromTemplate(template);
}
return(templateContent);
}
return(String.Empty);
}
protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
{
ITemplateEditingService teService =
(ITemplateEditingService)GetService(typeof(ITemplateEditingService));
Debug.Assert(teService != null,
"How did we get this far without an ITemplateEditingService");
String[] templateNames = GetTemplateFrameNames(verb.Index);
ITemplateEditingFrame editingFrame = teService.CreateFrame(
this,
TemplateDeviceFilter,
templateNames,
WebCtrlStyle,
null /* we don't have template styles */);
editingFrame.InitialWidth = _templateWidth;
return(editingFrame);
}
/// <include file='doc\DataGridDesigner.uex' path='docs/doc[@for="DataGridDesigner.GetTemplateContent"]/*' />
/// <devdoc>
/// <para>
/// Gets the template's content.
/// </para>
/// </devdoc>
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
int columnIndex = editingFrame.Verb.Index;
Debug.Assert((columnIndex >= 0) && (columnIndex < dataGrid.Columns.Count),
"Invalid column index in template editing frame.");
Debug.Assert(dataGrid.Columns[columnIndex] is TemplateColumn,
"Template editing frame points to a non-TemplateColumn column.");
TemplateColumn column = (TemplateColumn)dataGrid.Columns[columnIndex];
ITemplate template = null;
string templateContent = String.Empty;
if (templateName.Equals(ColumnTemplateNames[IDX_HEADER_TEMPLATE]))
{
template = column.HeaderTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[IDX_ITEM_TEMPLATE]))
{
template = column.ItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[IDX_EDITITEM_TEMPLATE]))
{
template = column.EditItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[IDX_FOOTER_TEMPLATE]))
{
template = column.FooterTemplate;
}
else
{
Debug.Fail("Unknown template name passed to GetTemplateContent");
}
if (template != null)
{
templateContent = GetTextFromTemplate(template);
}
return(templateContent);
}
/// <include file='doc\TemplatedControlDesigner.uex' path='docs/doc[@for="TemplatedControlDesigner.OnBehaviorAttached"]/*' />
/// <devdoc>
/// <para>
/// Notification that is called when the behavior is attached to the designer.
/// </para>
/// </devdoc>
protected override void OnBehaviorAttached()
{
if (InTemplateMode)
{
// REVIEW (IbrahimM): Switching to HTML/Source view when in template mode.
Debug.Assert(ActiveTemplateEditingFrame != null, "Valid template frame should be present when in template mode!");
activeTemplateFrame.Close(false);
templateMode = false;
activeTemplateFrame.Dispose();
activeTemplateFrame = null;
// Refresh the type descriptor so the properties are up to date when switching views.
TypeDescriptor.Refresh(Component);
}
// Call the base implementation.
base.OnBehaviorAttached();
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string tmplName, string tmplContent)
{
if (null != tmplEditingVerbs)
{
if (tmplEditingVerbs[0] == editingFrame.Verb)
{
TemplateMenu control = (TemplateMenu)Component;
ITemplate newHeader = null;
if ((null != tmplContent) && (0 != tmplContent.Length))
{
newHeader = GetTemplateFromText(tmplContent);
}
control.HeaderTemplate = newHeader;
}
if (tmplEditingVerbs[1] == editingFrame.Verb)
{
TemplateMenu control = (TemplateMenu)Component;
ITemplate newSeparator = null;
if ((null != tmplContent) && (0 != tmplContent.Length))
{
newSeparator = GetTemplateFromText(tmplContent);
}
control.SeparatorTemplate = newSeparator;
}
if (tmplEditingVerbs[2] == editingFrame.Verb)
{
TemplateMenu control = (TemplateMenu)Component;
ITemplate newHeader = null;
if ((null != tmplContent) && (0 != tmplContent.Length))
{
newHeader = GetTemplateFromText(tmplContent);
}
control.FooterTemplate = newHeader;
}
}
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
// System.Diagnostics.Debug.WriteLine(index.ToString() + ":GetTemplateContent");
string content = String.Empty;
allowEditing = true;
if ( (_templateEditingVerbs != null)
&& (_templateEditingVerbs[index] == editingFrame.Verb))
{
//ITemplate currentTemplate = ((WeavverTabControl)Component).Tabs[index];
editingFrame.InitialWidth = (int) ((WeavverTabControl)Component).Width.Value;
editingFrame.InitialHeight = (int) ((WeavverTabControl)Component).Height.Value;
// if (currentTemplate != null)
// {
// content = GetTextFromTemplate(currentTemplate);
// }
}
return content;
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
if ((_templateEditingVerbs != null) && ((IList)_templateEditingVerbs).Contains(editingFrame.Verb))
{
ListView lv = (ListView)Component;
ITemplate newTemplate = null;
try {
newTemplate = GetTemplateFromText(templateContent);
}
catch {
return;
}
switch (editingFrame.Verb.Index)
{
case HeaderFooterTemplates:
if (templateName.Equals(HeaderFooterTemplateNames[HeaderTemplate]))
{
lv.HeaderTemplate = newTemplate;
}
else if (templateName.Equals(HeaderFooterTemplateNames[FooterTemplate]))
{
lv.FooterTemplate = newTemplate;
}
break;
case ItemTemplates:
if (templateName.Equals(ItemTemplateNames[ItemTemplate]))
{
lv.ItemTemplate = newTemplate;
}
else if (templateName.Equals(ItemTemplateNames[EditItemTemplate]))
{
lv.EditItemTemplate = newTemplate;
}
break;
}
}
}
public void EnterTemplateMode(ITemplateEditingFrame newTemplateEditingFrame)
{
if ((this.ActiveTemplateEditingFrame != newTemplateEditingFrame) && (this.BehaviorInternal != null))
{
IControlDesignerBehavior behaviorInternal = (IControlDesignerBehavior) this.BehaviorInternal;
try
{
bool fSwitchingTemplates = false;
if (this.InTemplateModeInternal)
{
fSwitchingTemplates = true;
this.ExitTemplateModeInternal(fSwitchingTemplates, false, true);
}
else if (behaviorInternal != null)
{
behaviorInternal.DesignTimeHtml = string.Empty;
}
this._currentTemplateGroup = (TemplatedControlDesignerTemplateGroup) this.TemplateGroupTable[newTemplateEditingFrame];
if (this._currentTemplateGroup == null)
{
this._currentTemplateGroup = new TemplatedControlDesignerTemplateGroup(null, newTemplateEditingFrame);
}
if (!fSwitchingTemplates)
{
this.RaiseTemplateModeChanged();
}
this.ActiveTemplateEditingFrame.Open();
base.IsDirtyInternal = true;
TypeDescriptor.Refresh(base.Component);
}
catch
{
}
IWebFormsDocumentService service = (IWebFormsDocumentService) this.GetService(typeof(IWebFormsDocumentService));
if (service != null)
{
service.UpdateSelection();
}
}
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
string content = String.Empty;
allowEditing = true;
if (this.templateEditingVerbs != null)
{
ITemplate currentTemplate = null;
if (templateName == "ZoneTemplate")
{
currentTemplate = ((WebPartZone)Component).ZoneTemplate;
}
if (currentTemplate != null)
{
content = this.GetTextFromTemplate(currentTemplate);
}
}
return content;
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
DataList component = (DataList) base.Component;
ITemplate itemTemplate = null;
string textFromTemplate = string.Empty;
switch (editingFrame.Verb.Index)
{
case 0:
if (!templateName.Equals(ItemTemplateNames[0]))
{
if (templateName.Equals(ItemTemplateNames[1]))
{
itemTemplate = component.AlternatingItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[2]))
{
itemTemplate = component.SelectedItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[3]))
{
itemTemplate = component.EditItemTemplate;
}
break;
}
itemTemplate = component.ItemTemplate;
break;
case 1:
if (!templateName.Equals(HeaderFooterTemplateNames[0]))
{
if (templateName.Equals(HeaderFooterTemplateNames[1]))
{
itemTemplate = component.FooterTemplate;
}
break;
}
itemTemplate = component.HeaderTemplate;
break;
case 2:
itemTemplate = component.SeparatorTemplate;
break;
}
if (itemTemplate != null)
{
textFromTemplate = base.GetTextFromTemplate(itemTemplate);
}
return textFromTemplate;
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
ITemplate templateFromText = null;
if ((templateContent != null) && (templateContent.Length != 0))
{
templateFromText = base.GetTemplateFromText(templateContent);
}
else
{
this.CurrentChoice.get_Templates().Remove(templateName);
if (Utils.IsChoiceEmpty(this.CurrentChoice) && (this._mobileControl.get_DeviceSpecific() != null))
{
this._mobileControl.get_DeviceSpecific().get_Choices().Remove(this.CurrentChoice);
Utils.SetDeviceSpecificChoice(this._mobileControl, null);
}
return;
}
this.CurrentChoice.get_Templates()[templateName] = templateFromText;
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
if (this.templateEditingVerbs != null)
{
WebPartZone control = (WebPartZone)Component;
ITemplate newTemplate = null;
if ((templateContent != null) && (templateContent.Length > 0))
{
newTemplate = this.GetTemplateFromText(templateContent);
}
if (templateName == "ZoneTemplate")
{
control.ZoneTemplate = newTemplate;
}
}
}
public override void SetTemplateContent (
ITemplateEditingFrame editing_frame,
string template_name,
string template_content)
{
throw new NotImplementedException ();
}
public void EnterTemplateMode (ITemplateEditingFrame newTemplateEditingFrame)
{
throw new NotImplementedException ();
}
public override void SetTemplateContent(
ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
Trace.Assert(editingFrame.Verb.Index >= 0 && editingFrame.Verb.Index <= 2);
ITemplate template = null;
if (!string.IsNullOrEmpty(templateContent))
{
template = this.GetTemplateFromText(templateContent);
}
switch (editingFrame.Verb.Index)
{
case PaneTemplates:
if (templateName == PaneTemplateNames[IdxLeftPaneTemplate])
{
this.desktopPanes.LeftPaneTemplate = template;
return;
}
if (templateName == PaneTemplateNames[IdxContentPaneTemplate])
{
this.desktopPanes.ContentPaneTemplate = template;
return;
}
if (templateName == PaneTemplateNames[IdxRightPaneTemplate])
{
this.desktopPanes.RightPaneTemplate = template;
return;
}
break;
case SeparatorTemplates:
if (templateName == PaneTemplateNames[IdxHorizontalSeparatorTemplate])
{
this.desktopPanes.HorizontalSeparatorTemplate = template;
return;
}
if (templateName == PaneTemplateNames[IdxVerticalSeparatorTemplate])
{
this.desktopPanes.VerticalSeparatorTemplate = template;
return;
}
return;
default:
return;
}
}
// Methods
public void EnterTemplateMode(ITemplateEditingFrame newTemplateEditingFrame)
{
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
ITemplate template = null;
string textFromTemplate = string.Empty;
DeviceSpecificChoice choice = this.FindChoiceInDeviceSpecific(this.ActiveDeviceFilter);
if (choice != null)
{
template = (ITemplate) choice.get_Templates()[templateName];
}
if (template != null)
{
textFromTemplate = base.GetTextFromTemplate(template);
}
return textFromTemplate;
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
if ((_templateEditingVerbs != null) && ((IList)_templateEditingVerbs).Contains(editingFrame.Verb)) {
ListView lv = (ListView)Component;
ITemplate newTemplate = null;
try {
newTemplate = GetTemplateFromText(templateContent);
}
catch {
return;
}
switch (editingFrame.Verb.Index) {
case HeaderFooterTemplates:
if (templateName.Equals(HeaderFooterTemplateNames[HeaderTemplate])) {
lv.HeaderTemplate = newTemplate;
}
else if (templateName.Equals(HeaderFooterTemplateNames[FooterTemplate])) {
lv.FooterTemplate = newTemplate;
}
break;
case ItemTemplates:
if (templateName.Equals(ItemTemplateNames[ItemTemplate])) {
lv.ItemTemplate = newTemplate;
}
else if (templateName.Equals(ItemTemplateNames[EditItemTemplate])) {
lv.EditItemTemplate = newTemplate;
}
break;
}
}
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
if ( (_templateEditingVerbs != null)
&& (_templateEditingVerbs[index] == editingFrame.Verb))
{
WeavverTabControl control = (WeavverTabControl) Component;
ITemplate newTemplate = null;
if ( (templateContent != null)
&& (templateContent.Length != 0))
{
newTemplate = GetTemplateFromText(templateContent);
//control.Tabs[index] = newTemplate;
}
}
UpdateDesignTimeHtml();
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
int index = editingFrame.Verb.Index;
DataGrid component = (DataGrid) base.Component;
TemplateColumn column = (TemplateColumn) component.Columns[index];
ITemplate templateFromText = null;
if ((templateContent != null) && (templateContent.Length != 0))
{
ITemplate currentTemplate = null;
if (templateName.Equals(ColumnTemplateNames[2]))
{
currentTemplate = column.HeaderTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[0]))
{
currentTemplate = column.ItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[1]))
{
currentTemplate = column.EditItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[3]))
{
currentTemplate = column.FooterTemplate;
}
templateFromText = base.GetTemplateFromText(templateContent, currentTemplate);
}
if (templateName.Equals(ColumnTemplateNames[2]))
{
column.HeaderTemplate = templateFromText;
}
else if (templateName.Equals(ColumnTemplateNames[0]))
{
column.ItemTemplate = templateFromText;
}
else if (templateName.Equals(ColumnTemplateNames[1]))
{
column.EditItemTemplate = templateFromText;
}
else if (templateName.Equals(ColumnTemplateNames[3]))
{
column.FooterTemplate = templateFromText;
}
}
public TemplatedControlDesignerTemplateDefinition(string name, Style style, TemplatedControlDesigner parent, ITemplateEditingFrame frame) : base(parent, name, parent.Component, name, style)
{
this._parent = parent;
this._frame = frame;
base.Properties[typeof(Control)] = (Control) this._parent.Component;
}
public abstract void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent);
public abstract string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing);
public TemplatedControlDesignerTemplateGroup(TemplateEditingVerb verb, ITemplateEditingFrame frame) : base(verb.Text, frame.ControlStyle)
{
this._frame = frame;
this._verb = verb;
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
base.SetTemplateContent(editingFrame, templateName, templateContent);
}
private void EnterTemplateModeInternal(ITemplateEditingFrame newTemplateEditingFrame)
{
this.EnterTemplateMode(newTemplateEditingFrame);
}
public override String GetTemplateContent(
ITemplateEditingFrame editingFrame,
String templateName,
out bool allowEditing)
{
Debug.Assert(AllowTemplateEditing);
#if DEBUG
CheckTemplateName(templateName);
#endif
allowEditing = true;
ITemplate template = null;
String templateContent = String.Empty;
// Here we trust the TemplateVerbs to give valid template names
template = (ITemplate)CurrentChoice.Templates[templateName];
if (template != null)
{
templateContent = GetTextFromTemplate(template);
if (!IsCompleteHtml(templateContent))
{
allowEditing = false;
templateContent = String.Format(CultureInfo.CurrentCulture, _illFormedHtml, _illFormedWarning);
}
}
return templateContent;
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
DataGrid component = (DataGrid) base.Component;
int index = editingFrame.Verb.Index;
TemplateColumn column = (TemplateColumn) component.Columns[index];
ITemplate headerTemplate = null;
string textFromTemplate = string.Empty;
if (templateName.Equals(ColumnTemplateNames[2]))
{
headerTemplate = column.HeaderTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[0]))
{
headerTemplate = column.ItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[1]))
{
headerTemplate = column.EditItemTemplate;
}
else if (templateName.Equals(ColumnTemplateNames[3]))
{
headerTemplate = column.FooterTemplate;
}
if (headerTemplate != null)
{
textFromTemplate = base.GetTextFromTemplate(headerTemplate);
}
return textFromTemplate;
}
public override void SetTemplateContent(
ITemplateEditingFrame editingFrame,
String templateName,
String templateContent)
{
Debug.Assert(AllowTemplateEditing);
// Debug build only checking
CheckTemplateName(templateName);
ITemplate template = null;
if ((templateContent != null) && (templateContent.Length != 0))
{
template = GetTemplateFromText(templateContent);
}
else
{
CurrentChoice.Templates.Remove(templateName);
return;
}
// Here we trust the TemplateVerbs to give valid template names
CurrentChoice.Templates[templateName] = template;
}
public override void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent)
{
ITemplate templateFromText = null;
DataList component = (DataList) base.Component;
if ((templateContent != null) && (templateContent.Length != 0))
{
ITemplate currentTemplate = null;
switch (editingFrame.Verb.Index)
{
case 0:
if (!templateName.Equals(ItemTemplateNames[0]))
{
if (templateName.Equals(ItemTemplateNames[1]))
{
currentTemplate = component.AlternatingItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[2]))
{
currentTemplate = component.SelectedItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[3]))
{
currentTemplate = component.EditItemTemplate;
}
break;
}
currentTemplate = component.ItemTemplate;
break;
case 1:
if (!templateName.Equals(HeaderFooterTemplateNames[0]))
{
if (templateName.Equals(HeaderFooterTemplateNames[1]))
{
currentTemplate = component.FooterTemplate;
}
break;
}
currentTemplate = component.HeaderTemplate;
break;
case 2:
currentTemplate = component.SeparatorTemplate;
break;
}
templateFromText = base.GetTemplateFromText(templateContent, currentTemplate);
}
switch (editingFrame.Verb.Index)
{
case 0:
if (!templateName.Equals(ItemTemplateNames[0]))
{
if (templateName.Equals(ItemTemplateNames[1]))
{
component.AlternatingItemTemplate = templateFromText;
return;
}
if (templateName.Equals(ItemTemplateNames[2]))
{
component.SelectedItemTemplate = templateFromText;
return;
}
if (!templateName.Equals(ItemTemplateNames[3]))
{
break;
}
component.EditItemTemplate = templateFromText;
return;
}
component.ItemTemplate = templateFromText;
return;
case 1:
if (!templateName.Equals(HeaderFooterTemplateNames[0]))
{
if (!templateName.Equals(HeaderFooterTemplateNames[1]))
{
break;
}
component.FooterTemplate = templateFromText;
return;
}
component.HeaderTemplate = templateFromText;
return;
case 2:
component.SeparatorTemplate = templateFromText;
break;
default:
return;
}
}
public abstract virtual string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateNameout , System.Boolean& allowEditing)
{
}
public override string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
allowEditing = true;
if ((_templateEditingVerbs != null) && ((IList)_templateEditingVerbs).Contains(editingFrame.Verb)) {
ListView lv = (ListView)Component;
ITemplate template = null;
switch (editingFrame.Verb.Index) {
case HeaderFooterTemplates:
if (templateName.Equals(HeaderFooterTemplateNames[HeaderTemplate])) {
template = lv.HeaderTemplate;
}
else if (templateName.Equals(HeaderFooterTemplateNames[FooterTemplate])) {
template = lv.FooterTemplate;
}
break;
case ItemTemplates:
if (templateName.Equals(ItemTemplateNames[ItemTemplate])) {
template = lv.ItemTemplate;
}
else if (templateName.Equals(ItemTemplateNames[EditItemTemplate])) {
template = lv.EditItemTemplate;
}
break;
}
string templateContent = String.Empty;
if (template != null) {
templateContent = GetTextFromTemplate(template);
}
return templateContent;
}
return String.Empty;
}
public override string GetTemplateContent(
ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing)
{
Trace.Assert(editingFrame.Verb.Index >= 0 && editingFrame.Verb.Index <= 2);
allowEditing = true;
ITemplate template = null;
var templateContent = String.Empty;
switch (editingFrame.Verb.Index)
{
case PaneTemplates:
if (templateName == PaneTemplateNames[IdxLeftPaneTemplate])
{
template = this.desktopPanes.LeftPaneTemplate;
break;
}
if (templateName == PaneTemplateNames[IdxContentPaneTemplate])
{
template = this.desktopPanes.ContentPaneTemplate;
break;
}
if (templateName == PaneTemplateNames[IdxRightPaneTemplate])
{
template = this.desktopPanes.RightPaneTemplate;
break;
}
break;
case SeparatorTemplates:
if (templateName == PaneTemplateNames[IdxHorizontalSeparatorTemplate])
{
template = this.desktopPanes.HorizontalSeparatorTemplate;
break;
}
if (templateName == PaneTemplateNames[IdxVerticalSeparatorTemplate])
{
template = this.desktopPanes.VerticalSeparatorTemplate;
break;
}
break;
}
if (template != null)
{
templateContent = this.GetTextFromTemplate(template);
}
return templateContent;
}
