1145 lines
38 KiB
C#
1145 lines
38 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="MobileTemplatedControlDesigner.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.Design.MobileControls
|
|
{
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Web.UI;
|
|
using System.Web.UI.Design;
|
|
using System.Web.UI.Design.MobileControls.Adapters;
|
|
using System.Web.UI.Design.MobileControls.Converters;
|
|
using System.Web.UI.Design.MobileControls.Util;
|
|
using System.Web.UI.MobileControls;
|
|
using System.Web.UI.MobileControls.Adapters;
|
|
|
|
using WebCtrlStyle = System.Web.UI.WebControls.Style;
|
|
using DialogResult = System.Windows.Forms.DialogResult;
|
|
|
|
[
|
|
System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand,
|
|
Flags=System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)
|
|
]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal abstract class MobileTemplatedControlDesigner : TemplatedControlDesigner, IMobileDesigner, IDeviceSpecificDesigner
|
|
{
|
|
#if TRACE
|
|
internal static BooleanSwitch TemplateableControlDesignerSwitch =
|
|
new BooleanSwitch("MobileTemplatedControlDesigner", "Enable TemplateableControl designer general purpose traces.");
|
|
#endif
|
|
|
|
private System.Windows.Forms.Control _header;
|
|
private MobileControl _mobileControl;
|
|
private System.Web.UI.Control _control;
|
|
private DesignerVerbCollection _designerVerbs = null;
|
|
private DeviceSpecificChoice _currentChoice = null;
|
|
private bool _containmentStatusDirty = true;
|
|
private ContainmentStatus _containmentStatus;
|
|
private IDesignerHost _host;
|
|
private IWebFormsDocumentService _iWebFormsDocumentService;
|
|
private IMobileWebFormServices _iMobileWebFormServices;
|
|
private const String _htmlString = "html";
|
|
private TemplateEditingVerb[] _templateVerbs;
|
|
private bool _templateVerbsDirty = true;
|
|
private const int _templateWidth = 275;
|
|
|
|
private static readonly String _noChoiceText =
|
|
SR.GetString(SR.DeviceFilter_NoChoice);
|
|
|
|
private static readonly String _defaultChoiceText =
|
|
SR.GetString(SR.DeviceFilter_DefaultChoice);
|
|
|
|
private static readonly String _nonHtmlSchemaErrorMessage =
|
|
SR.GetString(SR.MobileControl_NonHtmlSchemaErrorMessage);
|
|
|
|
private static readonly String _illFormedWarning =
|
|
SR.GetString(SR.TemplateFrame_IllFormedWarning);
|
|
|
|
private const String _illFormedHtml =
|
|
"<DIV style=\"font-family:tahoma;font-size:8pt; COLOR: infotext; BACKGROUND-COLOR: infobackground\">{0}</DIV>";
|
|
|
|
internal const String DefaultTemplateDeviceFilter = "__TemplateDeviceFilter__";
|
|
private const String _templateDeviceFilterPropertyName = "TemplateDeviceFilter";
|
|
private const String _appliedDeviceFiltersPropertyName = "AppliedDeviceFilters";
|
|
private const String _propertyOverridesPropertyName = "PropertyOverrides";
|
|
private const String _expressionsPropertyName = "Expressions";
|
|
private const String _defaultDeviceSpecificIdentifier = "unique";
|
|
|
|
// used by DesignerAdapterUtil.GetMaxWidthToFit
|
|
// and needs to be exposed in object model because
|
|
// custom controls may need to access the value just like
|
|
// DesignerAdapterUtil.GetMaxWidthToFit does.
|
|
public virtual int TemplateWidth
|
|
{
|
|
get
|
|
{
|
|
return _templateWidth;
|
|
}
|
|
}
|
|
|
|
public override bool AllowResize
|
|
{
|
|
get
|
|
{
|
|
// Non mobilecontrols (ie. DeviceSpecific) does not render templates, no need to resize.
|
|
// When templates are not defined, we render a read-only fixed
|
|
// size block. Once templates are defined or are being edited
|
|
// the control should allow resizing.
|
|
return InTemplateMode || (_mobileControl != null && _mobileControl.IsTemplated);
|
|
}
|
|
}
|
|
|
|
private bool AllowTemplateEditing
|
|
{
|
|
get
|
|
{
|
|
return (CurrentChoice != null && IsHTMLSchema(CurrentChoice) && !ErrorMode);
|
|
}
|
|
}
|
|
|
|
[
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
Editor(typeof(AppliedDeviceFiltersTypeEditor), typeof(UITypeEditor)),
|
|
MergableProperty(false),
|
|
MobileCategory("Category_DeviceSpecific"),
|
|
MobileSysDescription(SR.MobileControl_AppliedDeviceFiltersDescription),
|
|
ParenthesizePropertyName(true),
|
|
]
|
|
protected String AppliedDeviceFilters
|
|
{
|
|
get
|
|
{
|
|
return String.Empty;
|
|
}
|
|
}
|
|
|
|
protected ContainmentStatus ContainmentStatus
|
|
{
|
|
get
|
|
{
|
|
if (!_containmentStatusDirty)
|
|
{
|
|
return _containmentStatus;
|
|
}
|
|
|
|
_containmentStatus =
|
|
DesignerAdapterUtil.GetContainmentStatus(_control);
|
|
|
|
_containmentStatusDirty = false;
|
|
return _containmentStatus;
|
|
}
|
|
}
|
|
|
|
public DeviceSpecificChoice CurrentChoice
|
|
{
|
|
get
|
|
{
|
|
return _currentChoice;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_currentChoice != value)
|
|
{
|
|
SetTemplateVerbsDirty();
|
|
|
|
_currentChoice = value;
|
|
OnCurrentChoiceChange();
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual DeviceSpecific CurrentDeviceSpecific
|
|
{
|
|
get
|
|
{
|
|
if (null == _mobileControl)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return _mobileControl.DeviceSpecific;
|
|
}
|
|
}
|
|
|
|
internal Object DesignTimeElementInternal
|
|
{
|
|
get
|
|
{
|
|
return typeof(HtmlControlDesigner).InvokeMember("DesignTimeElement",
|
|
BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.NonPublic,
|
|
null, this, null, CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
|
|
public override bool DesignTimeHtmlRequiresLoadComplete
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
|
|
// Return true only when GetErrorMessage returns non-null string and
|
|
// it is not info mode (warning only).
|
|
protected virtual bool ErrorMode
|
|
{
|
|
get
|
|
{
|
|
bool infoMode;
|
|
return (GetErrorMessage(out infoMode) != null && !infoMode);
|
|
}
|
|
}
|
|
|
|
protected IDesignerHost Host
|
|
{
|
|
get
|
|
{
|
|
if (_host != null)
|
|
{
|
|
return _host;
|
|
}
|
|
_host = (IDesignerHost)GetService(typeof(IDesignerHost));
|
|
Debug.Assert(_host != null);
|
|
return _host;
|
|
}
|
|
}
|
|
|
|
protected IMobileWebFormServices IMobileWebFormServices
|
|
{
|
|
get
|
|
{
|
|
if (_iMobileWebFormServices == null)
|
|
{
|
|
_iMobileWebFormServices =
|
|
(IMobileWebFormServices)GetService(typeof(IMobileWebFormServices));
|
|
}
|
|
|
|
return _iMobileWebFormServices;
|
|
}
|
|
}
|
|
|
|
private IWebFormsDocumentService IWebFormsDocumentService
|
|
{
|
|
get
|
|
{
|
|
if (_iWebFormsDocumentService == null)
|
|
{
|
|
_iWebFormsDocumentService =
|
|
(IWebFormsDocumentService)GetService(typeof(IWebFormsDocumentService));
|
|
|
|
Debug.Assert(_iWebFormsDocumentService != null);
|
|
}
|
|
|
|
return _iWebFormsDocumentService;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates whether the initial page load is completed
|
|
/// </summary>
|
|
protected bool LoadComplete
|
|
{
|
|
get
|
|
{
|
|
return !IWebFormsDocumentService.IsLoading;
|
|
}
|
|
}
|
|
|
|
[
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
Editor(typeof(PropertyOverridesTypeEditor), typeof(UITypeEditor)),
|
|
MergableProperty(false),
|
|
MobileCategory("Category_DeviceSpecific"),
|
|
MobileSysDescription(SR.MobileControl_DeviceSpecificPropsDescription),
|
|
ParenthesizePropertyName(true),
|
|
]
|
|
protected String PropertyOverrides
|
|
{
|
|
get
|
|
{
|
|
return String.Empty;
|
|
}
|
|
}
|
|
|
|
[
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
|
|
MobileSysDescription(SR.TemplateableDesigner_TemplateChoiceDescription),
|
|
TypeConverter(typeof(ChoiceConverter)),
|
|
]
|
|
public String TemplateDeviceFilter
|
|
{
|
|
get
|
|
{
|
|
if (null == CurrentChoice)
|
|
{
|
|
return _noChoiceText;
|
|
}
|
|
if (CurrentChoice.Filter.Length == 0)
|
|
{
|
|
return _defaultChoiceText;
|
|
}
|
|
else
|
|
{
|
|
return DesignerUtility.ChoiceToUniqueIdentifier(CurrentChoice);
|
|
}
|
|
}
|
|
set
|
|
{
|
|
if (String.IsNullOrEmpty(value) ||
|
|
value.Equals(SR.GetString(SR.DeviceFilter_NoChoice)))
|
|
{
|
|
CurrentChoice = null;
|
|
return;
|
|
}
|
|
|
|
if (null == CurrentDeviceSpecific)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Debug.Assert(CurrentDeviceSpecific.Choices != null);
|
|
|
|
foreach (DeviceSpecificChoice choice in CurrentDeviceSpecific.Choices)
|
|
{
|
|
if (DesignerUtility.ChoiceToUniqueIdentifier(choice).Equals(value) ||
|
|
(choice.Filter.Length == 0 &&
|
|
value.Equals(SR.GetString(SR.DeviceFilter_DefaultChoice))))
|
|
{
|
|
CurrentChoice = choice;
|
|
return;
|
|
}
|
|
}
|
|
|
|
CurrentChoice = null;
|
|
}
|
|
}
|
|
|
|
private bool ValidContainment
|
|
{
|
|
get
|
|
{
|
|
return (ContainmentStatus == ContainmentStatus.InForm ||
|
|
ContainmentStatus == ContainmentStatus.InPanel ||
|
|
ContainmentStatus == ContainmentStatus.InTemplateFrame);
|
|
}
|
|
}
|
|
|
|
public override DesignerVerbCollection Verbs
|
|
{
|
|
get
|
|
{
|
|
if (_designerVerbs == null)
|
|
{
|
|
_designerVerbs = new DesignerVerbCollection();
|
|
|
|
_designerVerbs.Add(new DesignerVerb(
|
|
SR.GetString(SR.TemplateableDesigner_SetTemplatesFilterVerb),
|
|
new EventHandler(this.OnSetTemplatesFilterVerb)));
|
|
}
|
|
|
|
_designerVerbs[0].Enabled = !this.InTemplateMode;
|
|
return _designerVerbs;
|
|
}
|
|
}
|
|
|
|
protected WebCtrlStyle WebCtrlStyle
|
|
{
|
|
get
|
|
{
|
|
WebCtrlStyle style = new WebCtrlStyle();
|
|
|
|
if (_mobileControl != null)
|
|
{
|
|
_mobileControl.Style.ApplyTo(style);
|
|
}
|
|
else
|
|
{
|
|
Debug.Assert(_control is DeviceSpecific);
|
|
if (_control.Parent is Panel)
|
|
{
|
|
((Panel)_control.Parent).Style.ApplyTo(style);
|
|
}
|
|
}
|
|
|
|
return style;
|
|
}
|
|
}
|
|
|
|
[
|
|
Conditional("DEBUG")
|
|
]
|
|
private void CheckTemplateName(String templateName)
|
|
{
|
|
Debug.Assert (
|
|
templateName == Constants.HeaderTemplateTag ||
|
|
templateName == Constants.FooterTemplateTag ||
|
|
templateName == Constants.ItemTemplateTag ||
|
|
templateName == Constants.AlternatingItemTemplateTag ||
|
|
templateName == Constants.SeparatorTemplateTag ||
|
|
templateName == Constants.ItemDetailsTemplateTag ||
|
|
templateName == Constants.ContentTemplateTag);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
DisposeTemplateVerbs();
|
|
|
|
if (IMobileWebFormServices != null)
|
|
{
|
|
// If the page is in loading mode, it means the remove is trigged by webformdesigner.
|
|
if (IWebFormsDocumentService.IsLoading)
|
|
{
|
|
IMobileWebFormServices.SetCache(_control.ID, (Object) DefaultTemplateDeviceFilter, (Object) this.TemplateDeviceFilter);
|
|
}
|
|
else
|
|
{
|
|
// setting to null will remove the entry.
|
|
IMobileWebFormServices.SetCache(_control.ID, (Object) DefaultTemplateDeviceFilter, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
public override void OnComponentChanged(Object sender, ComponentChangedEventArgs ce)
|
|
{
|
|
base.OnComponentChanged(sender, ce);
|
|
|
|
MemberDescriptor member = ce.Member;
|
|
if (member != null &&
|
|
member.GetType().FullName.Equals(Constants.ReflectPropertyDescriptorTypeFullName))
|
|
{
|
|
PropertyDescriptor propDesc = (PropertyDescriptor)member;
|
|
|
|
switch (propDesc.Name)
|
|
{
|
|
case "ID":
|
|
{
|
|
// Update the dictionary of device filters stored in the page designer
|
|
// setting to null will remove the entry.
|
|
IMobileWebFormServices.SetCache(ce.OldValue.ToString(), (Object) DefaultTemplateDeviceFilter, null);
|
|
break;
|
|
}
|
|
|
|
case "BackColor":
|
|
case "ForeColor":
|
|
case "Font":
|
|
case "StyleReference":
|
|
{
|
|
SetTemplateVerbsDirty();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DisposeTemplateVerbs()
|
|
{
|
|
if (_templateVerbs != null)
|
|
{
|
|
for (int i = 0; i < _templateVerbs.Length; i++)
|
|
{
|
|
_templateVerbs[i].Dispose();
|
|
}
|
|
|
|
_templateVerbs = null;
|
|
_templateVerbsDirty = true;
|
|
}
|
|
}
|
|
|
|
protected override TemplateEditingVerb[] GetCachedTemplateEditingVerbs()
|
|
{
|
|
if (ErrorMode)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// dispose template verbs during template editing would cause exiting from editing mode
|
|
// without saving.
|
|
if (_templateVerbsDirty == true && !InTemplateMode)
|
|
{
|
|
DisposeTemplateVerbs();
|
|
|
|
_templateVerbs = GetTemplateVerbs();
|
|
_templateVerbsDirty = false;
|
|
}
|
|
|
|
foreach(TemplateEditingVerb verb in _templateVerbs)
|
|
{
|
|
verb.Enabled = AllowTemplateEditing;
|
|
}
|
|
|
|
return _templateVerbs;
|
|
}
|
|
|
|
// Gets the HTML to be used for the design time representation of the control runtime.
|
|
public sealed override String GetDesignTimeHtml()
|
|
{
|
|
if (!LoadComplete)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
bool infoMode;
|
|
String errorMessage = GetErrorMessage(out infoMode);
|
|
SetStyleAttributes();
|
|
|
|
if (null != errorMessage)
|
|
{
|
|
return GetDesignTimeErrorHtml(errorMessage, infoMode);
|
|
}
|
|
|
|
String designTimeHTML = null;
|
|
|
|
// This is to avoiding cascading error rendering.
|
|
try
|
|
{
|
|
designTimeHTML = GetDesignTimeNormalHtml();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.Fail(ex.ToString());
|
|
designTimeHTML = GetDesignTimeErrorHtml(ex.Message, false);
|
|
}
|
|
|
|
return designTimeHTML;
|
|
}
|
|
|
|
protected virtual String GetDesignTimeErrorHtml(String errorMessage, bool infoMode)
|
|
{
|
|
return DesignerAdapterUtil.GetDesignTimeErrorHtml(
|
|
errorMessage, infoMode, _control, Behavior, ContainmentStatus);
|
|
}
|
|
|
|
protected virtual String GetDesignTimeNormalHtml()
|
|
{
|
|
return GetEmptyDesignTimeHtml();
|
|
}
|
|
|
|
// We sealed this method because it will never be called
|
|
// by our designers under current structure.
|
|
protected override sealed String GetErrorDesignTimeHtml(Exception e)
|
|
{
|
|
return base.GetErrorDesignTimeHtml(e);
|
|
}
|
|
|
|
protected virtual String GetErrorMessage(out bool infoMode)
|
|
{
|
|
infoMode = false;
|
|
|
|
if (!DesignerAdapterUtil.InMobileUserControl(_control))
|
|
{
|
|
if (DesignerAdapterUtil.InUserControl(_control))
|
|
{
|
|
infoMode = true;
|
|
return MobileControlDesigner._userControlWarningMessage;
|
|
}
|
|
|
|
if (!DesignerAdapterUtil.InMobilePage(_control))
|
|
{
|
|
return MobileControlDesigner._mobilePageErrorMessage;
|
|
}
|
|
|
|
if (!ValidContainment)
|
|
{
|
|
return MobileControlDesigner._formPanelContainmentErrorMessage;
|
|
}
|
|
}
|
|
|
|
if (CurrentChoice != null && !IsHTMLSchema(CurrentChoice))
|
|
{
|
|
infoMode = true;
|
|
return _nonHtmlSchemaErrorMessage;
|
|
}
|
|
|
|
// Containment is valid, return null;
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Gets the HTML to be persisted for the content present within the associated server control runtime.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <returns>
|
|
/// <para>
|
|
/// Persistable Inner HTML.
|
|
/// </para>
|
|
/// </returns>
|
|
public override String GetPersistInnerHtml()
|
|
{
|
|
String persist = null;
|
|
|
|
if (InTemplateMode)
|
|
{
|
|
SaveActiveTemplateEditingFrame();
|
|
}
|
|
|
|
if (IsDirty)
|
|
{
|
|
persist = MobileControlPersister.PersistInnerProperties(Component, Host);
|
|
}
|
|
|
|
if (InTemplateMode)
|
|
{
|
|
IsDirty = true;
|
|
}
|
|
|
|
return persist;
|
|
}
|
|
|
|
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 abstract String[] GetTemplateFrameNames(int index);
|
|
|
|
protected abstract TemplateEditingVerb[] GetTemplateVerbs();
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Initializes the designer.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name='component'>
|
|
/// The control element being designed.
|
|
/// </param>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// This is called by the designer host to establish the component being
|
|
/// designed.
|
|
/// </para>
|
|
/// </remarks>
|
|
/// <seealso cref='System.ComponentModel.Design.IDesigner'/>
|
|
public override void Initialize(IComponent component)
|
|
{
|
|
Debug.Assert(component is System.Web.UI.MobileControls.MobileControl ||
|
|
component is System.Web.UI.MobileControls.DeviceSpecific,
|
|
"MobileTemplatedControlDesigner.Initialize - Invalid (Mobile) Control");
|
|
|
|
base.Initialize(component);
|
|
|
|
if (component is System.Web.UI.MobileControls.MobileControl)
|
|
{
|
|
_mobileControl = (System.Web.UI.MobileControls.MobileControl) component;
|
|
}
|
|
// else the component is a DeviceSpecific control
|
|
_control = (System.Web.UI.Control) component;
|
|
|
|
if (IMobileWebFormServices != null)
|
|
{
|
|
this.TemplateDeviceFilter = (String) IMobileWebFormServices.GetCache(_control.ID, (Object)DefaultTemplateDeviceFilter);
|
|
}
|
|
}
|
|
|
|
private bool IsCompleteHtml(String templateContent)
|
|
{
|
|
if (!String.IsNullOrEmpty(templateContent))
|
|
{
|
|
return SimpleParser.IsWellFormed(templateContent);
|
|
}
|
|
|
|
// if template is empty, it's always editable.
|
|
return true;
|
|
}
|
|
|
|
protected bool IsHTMLSchema(DeviceSpecificChoice choice)
|
|
{
|
|
Debug.Assert(choice != null);
|
|
|
|
return choice.Xmlns != null &&
|
|
choice.Xmlns.ToLower(CultureInfo.InvariantCulture).IndexOf(_htmlString, StringComparison.Ordinal) != -1;
|
|
}
|
|
|
|
// Notification that is called when current choice is changed, it is currently
|
|
// used to notify StyleSheet that template device filter is changed.
|
|
protected virtual void OnCurrentChoiceChange()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Notification that is called when internal changes have been made.
|
|
/// </para>
|
|
/// </summary>
|
|
protected virtual void OnInternalChange()
|
|
{
|
|
ISite site = _control.Site;
|
|
if (site != null)
|
|
{
|
|
IComponentChangeService changeService =
|
|
(IComponentChangeService)site.GetService(typeof(IComponentChangeService));
|
|
if (changeService != null)
|
|
{
|
|
try
|
|
{
|
|
changeService.OnComponentChanging(_control, null);
|
|
}
|
|
catch (CheckoutException ex)
|
|
{
|
|
if (ex == CheckoutException.Canceled)
|
|
{
|
|
return;
|
|
}
|
|
throw;
|
|
}
|
|
changeService.OnComponentChanged(_control, null, null, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Notification that is called when the associated control is parented.
|
|
/// </para>
|
|
/// </summary>
|
|
public override void OnSetParent()
|
|
{
|
|
base.OnSetParent();
|
|
|
|
// Template verbs may need to be refreshed
|
|
SetTemplateVerbsDirty();
|
|
|
|
// this needs to be set before OnLoadComplete;
|
|
_containmentStatusDirty = true;
|
|
|
|
if (LoadComplete)
|
|
{
|
|
UpdateRendering();
|
|
}
|
|
}
|
|
|
|
private void OnSetTemplatesFilterVerb(Object sender, EventArgs e)
|
|
{
|
|
ShowTemplatingOptionsDialog();
|
|
}
|
|
|
|
protected override void OnTemplateModeChanged()
|
|
{
|
|
base.OnTemplateModeChanged();
|
|
|
|
if (InTemplateMode)
|
|
{
|
|
// Set xmlns in view linked document to show HTML intrinsic
|
|
// controls in property grid with same schema used by
|
|
// Intellisense for current choice tag in HTML view.
|
|
|
|
// This code won't work in Venus now since there are no viewlinks and
|
|
// they don't support this kind of schema.
|
|
/*
|
|
NativeMethods.IHTMLElement htmlElement = (NativeMethods.IHTMLElement) ((IHtmlControlDesignerBehavior) Behavior).DesignTimeElementView;
|
|
Debug.Assert(htmlElement != null,
|
|
"Invalid HTML element in MobileTemplateControlDesigner.OnTemplateModeChanged");
|
|
NativeMethods.IHTMLDocument2 htmlDocument2 = (NativeMethods.IHTMLDocument2) htmlElement.GetDocument();
|
|
Debug.Assert(htmlDocument2 != null,
|
|
"Invalid HTML Document2 in MobileTemplateControlDesigner.OnTemplateModeChanged");
|
|
NativeMethods.IHTMLElement htmlBody = (NativeMethods.IHTMLElement) htmlDocument2.GetBody();
|
|
Debug.Assert(htmlBody != null,
|
|
"Invalid HTML Body in MobileTemplateControlDesigner.OnTemplateModeChanged");
|
|
htmlBody.SetAttribute("xmlns", (Object) CurrentChoice.Xmlns, 0);
|
|
*/
|
|
}
|
|
}
|
|
|
|
protected override void PreFilterProperties(IDictionary properties)
|
|
{
|
|
base.PreFilterProperties(properties);
|
|
|
|
// DesignTime Property only, we will use this to select choices.
|
|
properties[_templateDeviceFilterPropertyName] =
|
|
TypeDescriptor.CreateProperty(this.GetType(),
|
|
_templateDeviceFilterPropertyName,
|
|
typeof(String),
|
|
new DefaultValueAttribute(SR.GetString(SR.DeviceFilter_NoChoice)),
|
|
MobileCategoryAttribute.Design,
|
|
InTemplateMode ? BrowsableAttribute.No : BrowsableAttribute.Yes
|
|
);
|
|
|
|
// design time only entry used to display dialog box used to create choices.
|
|
properties[_appliedDeviceFiltersPropertyName] =
|
|
TypeDescriptor.CreateProperty(this.GetType(),
|
|
_appliedDeviceFiltersPropertyName,
|
|
typeof(String),
|
|
InTemplateMode? BrowsableAttribute.No : BrowsableAttribute.Yes
|
|
);
|
|
|
|
// design time only entry used to display dialog box to create choices.
|
|
properties[_propertyOverridesPropertyName] =
|
|
TypeDescriptor.CreateProperty(this.GetType(),
|
|
_propertyOverridesPropertyName,
|
|
typeof(String),
|
|
InTemplateMode? BrowsableAttribute.No : BrowsableAttribute.Yes
|
|
);
|
|
|
|
PropertyDescriptor property = (PropertyDescriptor) properties[_expressionsPropertyName];
|
|
if (property != null) {
|
|
properties[_expressionsPropertyName] = TypeDescriptor.CreateProperty(this.GetType(), property, BrowsableAttribute.No);
|
|
}
|
|
}
|
|
|
|
protected virtual void SetStyleAttributes()
|
|
{
|
|
Debug.Assert(Behavior != null);
|
|
DesignerAdapterUtil.SetStandardStyleAttributes(Behavior, ContainmentStatus);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
protected internal void SetTemplateVerbsDirty()
|
|
{
|
|
_templateVerbsDirty = true;
|
|
}
|
|
|
|
protected virtual void ShowTemplatingOptionsDialog()
|
|
{
|
|
IComponentChangeService changeService =
|
|
(IComponentChangeService)GetService(typeof(IComponentChangeService));
|
|
if (changeService != null)
|
|
{
|
|
try
|
|
{
|
|
changeService.OnComponentChanging(_control, null);
|
|
}
|
|
catch (CheckoutException ex)
|
|
{
|
|
if (ex == CheckoutException.Canceled)
|
|
{
|
|
return;
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
TemplatingOptionsDialog dialog = new TemplatingOptionsDialog(
|
|
this,
|
|
_control.Site,
|
|
MobileControlDesigner.MergingContextTemplates);
|
|
dialog.ShowDialog();
|
|
}
|
|
finally
|
|
{
|
|
if (changeService != null)
|
|
{
|
|
changeService.OnComponentChanged(_control, null, null, null);
|
|
|
|
if (IMobileWebFormServices != null)
|
|
{
|
|
IMobileWebFormServices.ClearUndoStack();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UpdateRendering()
|
|
{
|
|
if (!(null == _mobileControl || _mobileControl is StyleSheet))
|
|
{
|
|
_mobileControl.RefreshStyle();
|
|
}
|
|
|
|
// template editing frame need to be recreated because the style
|
|
// (WebCtrlStyle) to use may have to change
|
|
SetTemplateVerbsDirty();
|
|
|
|
if (!InTemplateMode)
|
|
{
|
|
UpdateDesignTimeHtml();
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Begin IDeviceSpecificDesigner Implementation
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
void IDeviceSpecificDesigner.SetDeviceSpecificEditor
|
|
(IRefreshableDeviceSpecificEditor editor)
|
|
{
|
|
}
|
|
|
|
String IDeviceSpecificDesigner.CurrentDeviceSpecificID
|
|
{
|
|
get
|
|
{
|
|
return _defaultDeviceSpecificIdentifier;
|
|
}
|
|
}
|
|
|
|
System.Windows.Forms.Control IDeviceSpecificDesigner.Header
|
|
{
|
|
get
|
|
{
|
|
return _header;
|
|
}
|
|
}
|
|
|
|
System.Web.UI.Control IDeviceSpecificDesigner.UnderlyingControl
|
|
{
|
|
get
|
|
{
|
|
return _control;
|
|
}
|
|
}
|
|
|
|
Object IDeviceSpecificDesigner.UnderlyingObject
|
|
{
|
|
get
|
|
{
|
|
return _control;
|
|
}
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.InitHeader(int mergingContext)
|
|
{
|
|
HeaderPanel panel = new HeaderPanel();
|
|
HeaderLabel lblDescription = new HeaderLabel();
|
|
|
|
lblDescription.TabIndex = 0;
|
|
lblDescription.Height = 24;
|
|
lblDescription.Width = 204;
|
|
panel.Height = 28;
|
|
panel.Width = 204;
|
|
panel.Controls.Add(lblDescription);
|
|
|
|
switch (mergingContext)
|
|
{
|
|
case MobileControlDesigner.MergingContextTemplates:
|
|
{
|
|
lblDescription.Text = SR.GetString(SR.TemplateableDesigner_SettingTemplatingChoiceDescription);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
lblDescription.Text = SR.GetString(SR.TemplateableDesigner_SettingGenericChoiceDescription);
|
|
break;
|
|
}
|
|
}
|
|
|
|
_header = panel;
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.RefreshHeader(int mergingContext)
|
|
{
|
|
}
|
|
|
|
bool IDeviceSpecificDesigner.GetDeviceSpecific(String deviceSpecificParentID, out DeviceSpecific ds)
|
|
{
|
|
Debug.Assert(_defaultDeviceSpecificIdentifier == deviceSpecificParentID);
|
|
ds = CurrentDeviceSpecific;
|
|
return true;
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.SetDeviceSpecific(String deviceSpecificParentID, DeviceSpecific ds)
|
|
{
|
|
Debug.Assert(_defaultDeviceSpecificIdentifier == deviceSpecificParentID);
|
|
|
|
if (_mobileControl != null)
|
|
{
|
|
if (null != ds)
|
|
{
|
|
ds.SetOwner(_mobileControl);
|
|
}
|
|
_mobileControl.DeviceSpecific = ds;
|
|
}
|
|
else if (_control != null && ds == null)
|
|
{
|
|
Debug.Assert(_control is DeviceSpecific);
|
|
|
|
// Clear the choices if it is a DeviceSpecific control.
|
|
((DeviceSpecific)_control).Choices.Clear();
|
|
}
|
|
|
|
if (null != CurrentChoice)
|
|
{
|
|
if (null == ds)
|
|
{
|
|
CurrentChoice = null;
|
|
}
|
|
else
|
|
{
|
|
// This makes sure that the CurrentChoice value is set to null if
|
|
// it was deleted during the deviceSpecific object editing
|
|
if (CurrentChoice.Filter.Length == 0)
|
|
{
|
|
TemplateDeviceFilter = SR.GetString(SR.DeviceFilter_DefaultChoice);
|
|
}
|
|
else
|
|
{
|
|
TemplateDeviceFilter = DesignerUtility.ChoiceToUniqueIdentifier(CurrentChoice);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void IDeviceSpecificDesigner.UseCurrentDeviceSpecificID()
|
|
{
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// End IDeviceSpecificDesigner Implementation
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
// Hack : Internal class used to provide TemplateContainerAttribute for Templates.
|
|
[
|
|
System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.Demand,
|
|
Flags=System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)
|
|
]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
internal class TemplateContainer
|
|
{
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate HeaderTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate FooterTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate ItemTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate AlternatingItemTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate SeparatorTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate ContentTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate LabelTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
|
|
[
|
|
TemplateContainer(typeof(MobileListItem))
|
|
]
|
|
internal ITemplate ItemDetailsTemplate
|
|
{
|
|
get {return null;}
|
|
}
|
|
}
|
|
}
|
|
}
|