private readonly bool targetAllowsDragBox; //indicates if the drop target allows the generic drag box to be drawn
/// <summary>
/// Constructor that caches the designer (which invoked us) and a ptr
/// to the BehaviorService.
/// </summary>
public ToolboxItemSnapLineBehavior(IServiceProvider serviceProvider, BehaviorService behaviorService)
{
this.serviceProvider = serviceProvider;
this.behaviorService = behaviorService;
designer = null;
isPushed = false;
lastRectangle = Rectangle.Empty;
lastOffset = Point.Empty;
statusCommandUI = new StatusCommandUI(serviceProvider);
targetAllowsDragBox = true;
targetAllowsSnapLines = true;
}
private static ControlDesigner GetDesigner(Control control)
{
ControlDesigner designer = null;
ISite site = control.Site;
if (site != null)
{
IDesignerHost service = (IDesignerHost)site.GetService(typeof(IDesignerHost));
designer = service.GetDesigner(control) as ControlDesigner;
}
return(designer);
}
private void AddSnapLines(ControlDesigner controlDesigner, ArrayList horizontalList, ArrayList verticalList, bool isTarget, bool validTarget)
{
IList snapLines = controlDesigner.SnapLines;
Rectangle clientRectangle = controlDesigner.Control.ClientRectangle;
Rectangle bounds = controlDesigner.Control.Bounds;
bounds.Location = clientRectangle.Location = this.behaviorService.ControlToAdornerWindow(controlDesigner.Control);
int left = bounds.Left;
int top = bounds.Top;
Point offsetToClientArea = controlDesigner.GetOffsetToClientArea();
clientRectangle.X += offsetToClientArea.X;
clientRectangle.Y += offsetToClientArea.Y;
foreach (SnapLine line in snapLines)
{
if (isTarget)
{
if ((line.Filter != null) && line.Filter.StartsWith("Padding"))
{
continue;
}
if (validTarget && !this.targetSnapLineTypes.Contains(line.SnapLineType))
{
this.targetSnapLineTypes.Add(line.SnapLineType);
}
}
else
{
if (validTarget && !this.targetSnapLineTypes.Contains(line.SnapLineType))
{
continue;
}
if ((line.Filter != null) && line.Filter.StartsWith("Padding"))
{
this.snapLineToBounds.Add(line, clientRectangle);
}
else
{
this.snapLineToBounds.Add(line, bounds);
}
}
if (line.IsHorizontal)
{
line.AdjustOffset(top);
horizontalList.Add(line);
}
else
{
line.AdjustOffset(left);
verticalList.Add(line);
}
}
}
/// <summary>设置分页模版</summary>
public void SetPagerTemplate()
{
Cursor current = Cursor.Current;
try
{
Cursor.Current = Cursors.WaitCursor;
ControlDesigner.InvokeTransactedChange(base.Component, SetPagerTemplateCallback, null, "设置分页模版");
UpdateDesignTimeHtml();
}
finally
{
Cursor.Current = current;
}
}
protected ControlDesigner GetDesigner(ITypeDescriptorContext context)
{
IDesignerHost designerHost = (IDesignerHost)context.GetService(typeof(IDesignerHost));
Debug.Assert(designerHost != null, "Did not get DesignerHost service.");
Debug.Assert(context.Instance is Control, "Expected Control");
Control control = (Control)context.Instance;
ControlDesigner designer = (ControlDesigner)designerHost.GetDesigner(control);
Debug.Assert(designer != null, "Did not get designer for component");
return(designer);
}
public void CanParentTest()
{
ParentControlDesigner rootPanel = (ParentControlDesigner)_helper.IDesignerHost.GetDesigner(_helper.CreateControl(typeof(TestPanel), null));
ParentControlDesigner childPanel = (ParentControlDesigner)_helper.IDesignerHost.GetDesigner(_helper.CreateControl(typeof(TestPanel), rootPanel.Control));
ControlDesigner childPanelButton = (ControlDesigner)_helper.IDesignerHost.GetDesigner(_helper.CreateControl(typeof(TestButton), childPanel.Control));
ControlDesigner rootPanelButton = (ControlDesigner)_helper.IDesignerHost.GetDesigner(_helper.CreateControl(typeof(TestButton), rootPanel.Control));
Assert.IsFalse(childPanel.CanParent((Control)_helper.IDesignerHost.RootComponent), "#1");
Assert.IsTrue(childPanel.CanParent(childPanel), "#2");
Assert.IsTrue(childPanel.CanParent(childPanelButton), "#3");
Assert.IsTrue(childPanel.CanParent(rootPanelButton), "#4");
Assert.IsFalse(childPanel.CanParent(rootPanel), "#5");
Assert.IsTrue(rootPanel.CanParent(childPanel), "#6");
Assert.IsTrue(rootPanel.CanParent(rootPanelButton), "#7");
}
/// <summary>
/// Connects the specified control and its underlying element to the event sink.
/// </summary>
/// <param name="element">Underlying element of control.</param>
/// <param name="editor">Reference to editor control.</param>
public void Connect(Interop.IHTMLElement element, IHtmlEditor editor)
{
this._editor = editor;
this._designer = (ControlDesigner)this._behavior.Designer;
try
{
this._element = element;
this._elementStyle = this._element.GetStyle();
this._runTimeStyle = ((Interop.IHTMLElement2) this._element).GetRuntimeStyle();
this._eventSinkCookie = new ConnectionPointCookie(this._element, this, typeof(Interop.IHTMLElementEvents));
}
catch (Exception)
{
}
EventsEnabled = true;
}
private void EditRoleGroups()
{
PropertyDescriptor context = TypeDescriptor.GetProperties(base.Component)["RoleGroups"];
ControlDesigner.InvokeTransactedChange(base.Component, new TransactedChangeCallback(this.EditRoleGroupsChangeCallback), context, System.Design.SR.GetString("LoginView_EditRoleGroupsTransactionDescription"), context);
int num = this._loginView.RoleGroups.Count + 2;
if (this.CurrentView >= num)
{
this.CurrentView = num - 1;
}
if (this.CurrentView < 0)
{
this.CurrentView = 0;
}
this._templateGroups = null;
}
public void InitializeTest()
{
Button button = (Button)_helper.CreateControl(typeof(TestButton), null);
Assert.IsFalse((bool)_helper.GetValue(button, "Locked"), "#1");
Assert.IsTrue((bool)_helper.GetValue(button, "Visible"), "#2");
Assert.IsTrue((bool)_helper.GetValue(button, "Enabled"), "#3");
Assert.IsFalse((bool)_helper.GetValue(button, "AllowDrop"), "#4");
Assert.IsTrue(button.Enabled, "#5");
Assert.IsTrue(button.Visible, "#6");
Assert.IsFalse(button.AllowDrop, "#7");
#if NET_2_0
ControlDesigner buttonDesigner = _helper.IDesignerHost.GetDesigner(button) as ControlDesigner;
Assert.AreEqual(null, buttonDesigner.InternalControlDesigner(20));
Assert.AreEqual(0, buttonDesigner.NumberOfInternalControlDesigners());
#endif
}
protected override void OnSchemaRefreshed()
{
if (!base.InTemplateMode)
{
Cursor current = Cursor.Current;
try
{
Cursor.Current = Cursors.WaitCursor;
ControlDesigner.InvokeTransactedChange(base.Component, new TransactedChangeCallback(this.SchemaRefreshedCallback), null, "Refresh Schema");
this.UpdateDesignTimeHtml();
}
finally
{
Cursor.Current = current;
}
}
}
private void StartDragOperation(Point initialMouseLocation)
{
ISelectionService service = (ISelectionService)this.serviceProvider.GetService(typeof(ISelectionService));
IDesignerHost host = (IDesignerHost)this.serviceProvider.GetService(typeof(IDesignerHost));
if ((service != null) && (host != null))
{
Control parent = this.containerControl.Parent;
ArrayList dragComponents = new ArrayList();
foreach (IComponent component in service.GetSelectedComponents())
{
Control control2 = component as Control;
if ((control2 != null) && control2.Parent.Equals(parent))
{
ControlDesigner designer = host.GetDesigner(control2) as ControlDesigner;
if ((designer != null) && ((designer.SelectionRules & SelectionRules.Moveable) != SelectionRules.None))
{
dragComponents.Add(control2);
}
}
}
if (dragComponents.Count > 0)
{
Point point;
if (this.setInitialDragPoint)
{
point = this.behaviorService.ControlToAdornerWindow(this.containerControl);
point = this.behaviorService.AdornerWindowPointToScreen(point);
}
else
{
point = initialMouseLocation;
}
DropSourceBehavior dropSourceBehavior = new DropSourceBehavior(dragComponents, this.containerControl.Parent, point);
try
{
this.behaviorService.DoDragDrop(dropSourceBehavior);
}
finally
{
this.OkToMove = false;
this.InitialDragPoint = Point.Empty;
}
}
}
}
public void SelectionRulesTest()
{
Button button = (Button)_helper.CreateControl(typeof(TestButton), null);
ControlDesigner designer = _helper.IDesignerHost.GetDesigner(button) as ControlDesigner;
SelectionRules selectionRules = SelectionRules.AllSizeable | SelectionRules.Moveable | SelectionRules.Visible;
Assert.AreEqual(selectionRules, designer.SelectionRules, "#1");
button.Dock = DockStyle.Left;
selectionRules = SelectionRules.RightSizeable | SelectionRules.Visible;
Assert.AreEqual(selectionRules, designer.SelectionRules, "#2");
button.Dock = DockStyle.Fill;
selectionRules = SelectionRules.Visible;
Assert.AreEqual(selectionRules, designer.SelectionRules, "#3");
}
public override DesignerActionItemCollection GetSortedActionItems()
{
DesignerActionItemCollection items = new DesignerActionItemCollection();
PropertyDescriptor descriptor = TypeDescriptor.GetProperties(this._controlDesigner.Component)["DataSourceID"];
if ((descriptor != null) && descriptor.IsBrowsable)
{
items.Add(new DesignerActionPropertyItem("DataSourceID", System.Design.SR.GetString("BaseDataBoundControl_ConfigureDataVerb"), System.Design.SR.GetString("BaseDataBoundControl_DataActionGroup"), System.Design.SR.GetString("BaseDataBoundControl_ConfigureDataVerbDesc")));
}
ControlDesigner designer = this._dataSourceDesigner as ControlDesigner;
if (designer != null)
{
((DesignerActionPropertyItem)items[0]).RelatedComponent = designer.Component;
}
return(items);
}
public void Disconnect()
{
if (this._eventSinkCookie != null)
{
try
{
this._eventSinkCookie.Disconnect();
this._eventSinkCookie = null;
}
catch
{
// on shut down the RCW might be detached alredy
}
}
this._element = null;
this._designer = null;
this._behavior = null;
}
internal static void SetRenderOuterTable(bool value, ControlDesigner designer, bool isFormView)
{
TransactedChangeCallback callback = null;
IComponent component = designer.Component;
IRenderOuterTableControl control = (IRenderOuterTableControl)component;
if (value != control.RenderOuterTable)
{
if (!value && IsAnyPropertyOnOuterTableChanged(component, isFormView))
{
if (UIServiceHelper.ShowMessage(component.Site, System.Design.SR.GetString("RenderOuterTable_RemoveOuterTableWarning"), System.Design.SR.GetString("RenderOuterTable_RemoveOuterTableCaption", new object[] { control.GetType().Name, control.ID }), MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
if (callback == null)
{
callback = delegate(object context) {
try
{
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(component);
string[] strArray = isFormView ? formViewStylePropertiesOnOuterTable : loginStylePropertiesOnOuterTable;
if (isFormView)
{
((FormView)control).ControlStyle.Reset();
}
foreach (string str in strArray)
{
properties[str].ResetValue(component);
}
return(true);
}
catch (Exception)
{
return(false);
}
};
}
ControlDesigner.InvokeTransactedChange(component, callback, null, System.Design.SR.GetString("RenderOuterTableHelper_ResetProperties"));
}
control.RenderOuterTable = value;
TypeDescriptor.Refresh(component);
}
}
/// <summary>
/// This method is used to ensure that designer is notified
/// every time there is a change in the sub-ordinate validators
/// </summary>
internal void NotifyDesigner()
{
if (this.DesignMode)
{
IDesignerHost Host = this.Site.Container as IDesignerHost;
ControlDesigner Designer = Host.GetDesigner(this) as ControlDesigner;
PropertyDescriptor Descriptor = null;
try
{
Descriptor = TypeDescriptor.GetProperties(this)["PopupInfoItems"];
}
catch
{
return;
}
ComponentChangedEventArgs ccea = new ComponentChangedEventArgs(this, Descriptor, null, this.PopupInfoItems);
Designer.OnComponentChanged(this, ccea);
}
}
public ViewRendering GetViewRendering(Control control)
{
string str;
DesignerRegionCollection regions;
try
{
this._partViewRendering = ControlDesigner.GetViewRendering(control);
regions = this._partViewRendering.Regions;
WebPart part = control as WebPart;
if (part == null)
{
part = new DesignerGenericWebPart(PartDesigner.GetViewControl(control));
}
StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);
this.RenderWebPart(new DesignTimeHtmlTextWriter(writer), (WebPart)PartDesigner.GetViewControl(part));
str = writer.ToString();
}
catch (Exception exception)
{
str = ControlDesigner.CreateErrorDesignTimeHtml(System.Design.SR.GetString("ControlDesigner_UnhandledException"), exception, control);
regions = new DesignerRegionCollection();
}
StringWriter writer2 = new StringWriter(CultureInfo.InvariantCulture);
DesignTimeHtmlTextWriter writer3 = new DesignTimeHtmlTextWriter(writer2);
bool flag = base.Zone.LayoutOrientation == Orientation.Horizontal;
if (flag)
{
writer3.AddStyleAttribute("display", "inline-block");
writer3.AddStyleAttribute(HtmlTextWriterStyle.Height, "100%");
writer3.RenderBeginTag(HtmlTextWriterTag.Span);
}
writer3.Write(str);
if (flag)
{
writer3.RenderEndTag();
}
return(new ViewRendering(writer2.ToString(), regions));
}
private void AddControlGlyphs(Control c, GlyphSelectionType selType)
{
ControlDesigner designer = (ControlDesigner)this.componentToDesigner[c];
if (designer != null)
{
ControlBodyGlyph controlGlyphInternal = designer.GetControlGlyphInternal(selType);
if (controlGlyphInternal != null)
{
this.bodyAdorner.Glyphs.Add(controlGlyphInternal);
if ((selType == GlyphSelectionType.SelectedPrimary) || (selType == GlyphSelectionType.Selected))
{
if (this.curSelectionBounds[this.curCompIndex] == Rectangle.Empty)
{
this.curSelectionBounds[this.curCompIndex] = controlGlyphInternal.Bounds;
}
else
{
this.curSelectionBounds[this.curCompIndex] = Rectangle.Union(this.curSelectionBounds[this.curCompIndex], controlGlyphInternal.Bounds);
}
}
}
GlyphCollection glyphs = designer.GetGlyphs(selType);
if (glyphs != null)
{
this.selectionAdorner.Glyphs.AddRange(glyphs);
if ((selType == GlyphSelectionType.SelectedPrimary) || (selType == GlyphSelectionType.Selected))
{
foreach (Glyph glyph2 in glyphs)
{
this.curSelectionBounds[this.curCompIndex] = Rectangle.Union(this.curSelectionBounds[this.curCompIndex], glyph2.Bounds);
}
}
}
}
if ((selType == GlyphSelectionType.SelectedPrimary) || (selType == GlyphSelectionType.Selected))
{
this.curCompIndex++;
}
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
DataBoundControl dataBoundControl = context.Instance as DataBoundControl;
if (dataBoundControl != null)
{
IDesignerHost service = (IDesignerHost)provider.GetService(typeof(IDesignerHost));
DataBoundControlDesigner designer = (DataBoundControlDesigner)service.GetDesigner(dataBoundControl);
IComponentChangeService changeService = (IComponentChangeService)provider.GetService(typeof(IComponentChangeService));
ControlDesigner.InvokeTransactedChange(dataBoundControl, delegate(object callbackContext) {
DataControlFieldsEditor form = new DataControlFieldsEditor(designer);
DialogResult result = UIServiceHelper.ShowDialog(provider, form);
if ((result == DialogResult.OK) && (changeService != null))
{
changeService.OnComponentChanged(dataBoundControl, null, null, null);
}
return(result == DialogResult.OK);
}, null, System.Design.SR.GetString("GridView_EditFieldsTransaction"));
return(value);
}
return(null);
}
internal void OnContentReady(Interop.IHTMLElement element)
{
_element = element;
// System.Diagnostics.Debug.WriteLine("OnContentReady: " + _element.GetTagName());
Interop.IHTMLElement parentElement = Element.GetParentElement();
if (_parent == null && parentElement != null)
{
string str = (String)this.GetAttribute("id", true);
if (str != null)
{
IComponent iComponent = _designerHost.Container.Components[str];
if (iComponent != null && iComponent is XmlControl)
{
XmlControl control = (XmlControl)iComponent;
ControlDesigner controlDesigner = (ControlDesigner)_designerHost.GetDesigner(_control);
if (controlDesigner != null)
{
DesignTimeBehavior behavior = (DesignTimeBehavior)controlDesigner.Behavior;
if (behavior != null && IsDragging())
{
this.EndDrag();
//_control.WebControl = control;
Designer = controlDesigner;
CreateControlView();
SetControlParent(parentElement);
ConnectToControlAndDesigner();
}
}
}
}
if (!isDragging)
{
CreateControlAndDesigner();
CreateControlView();
SetControlParent(parentElement);
ConnectToControlAndDesigner();
}
}
}
private bool AddChildCompSnaplines(IComponent comp, ArrayList dragComponents, Rectangle clipBounds, Control targetControl)
{
Control child = comp as Control;
if (((child == null) || (((dragComponents != null) && dragComponents.Contains(comp)) && !this.ctrlDrag)) || ((IsChildOfParent(child, targetControl) || !clipBounds.IntersectsWith(child.Bounds)) || ((child.Parent == null) || !child.Visible)))
{
return(false);
}
Control component = child;
if (!component.Equals(targetControl))
{
IDesignerHost service = this.serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (service != null)
{
ControlDesigner designer = service.GetDesigner(component) as ControlDesigner;
if (designer != null)
{
return(designer.ControlSupportsSnaplines);
}
}
}
return(true);
}
public ControlBodyGlyph(Rectangle bounds, Cursor cursor, IComponent relatedComponent, ControlDesigner designer)
: this(bounds, cursor, relatedComponent, designer.BehaviorService.CurrentBehavior)
{
}
private void EditMenuItems()
{
PropertyDescriptor member = TypeDescriptor.GetProperties(base.Component)["Items"];
ControlDesigner.InvokeTransactedChange(base.Component, new TransactedChangeCallback(this.EditMenuItemsChangeCallback), null, null, member);
}
public ControlBodyGlyph (Rectangle bounds, Cursor cursor, IComponent relatedComponent, ControlDesigner designer)
: this (bounds, cursor, relatedComponent, designer.BehaviorService.CurrentBehavior)
{
}
// Constructors
public ControlDesignerAccessibleObject(ControlDesigner designer, System.Windows.Forms.Control control)
{
}
/// <summary>
/// this method is called when dragging a TabStrip off the toolbox.
/// </summary>
/// <param name="host"></param>
/// <returns></returns>
protected override IComponent[] CreateComponentsCore(IDesignerHost host)
{
IComponent[] components = base.CreateComponentsCore(host);
Control parentControl = null;
ControlDesigner parentControlDesigner = null;
TabStrip tabStrip = null;
IComponentChangeService changeSvc = (IComponentChangeService)host.GetService(typeof(IComponentChangeService));
// fish out the parent we're adding the TabStrip to.
if (components.Length > 0 && components[0] is TabStrip)
{
tabStrip = components[0] as TabStrip;
ITreeDesigner tabStripDesigner = host.GetDesigner(tabStrip) as ITreeDesigner;
parentControlDesigner = tabStripDesigner.Parent as ControlDesigner;
if (parentControlDesigner != null)
{
parentControl = parentControlDesigner.Control;
}
}
// Create a ControlSwitcher on the same parent.
if (host != null)
{
TabPageSwitcher controlSwitcher = null;
DesignerTransaction t = null;
try {
try {
t = host.CreateTransaction("add tabswitcher");
}
catch (CheckoutException ex) {
if (ex == CheckoutException.Canceled)
{
return(components);
}
throw ex;
}
// create a TabPageSwitcher and add it to the same parent as the TabStrip
MemberDescriptor controlsMember = TypeDescriptor.GetProperties(parentControlDesigner)["Controls"];
controlSwitcher = host.CreateComponent(typeof(TabPageSwitcher)) as TabPageSwitcher;
if (changeSvc != null)
{
changeSvc.OnComponentChanging(parentControl, controlsMember);
changeSvc.OnComponentChanged(parentControl, controlsMember, null, null);
}
// specify default values for our TabStrip
Dictionary <string, object> propertyValues = new Dictionary <string, object>();
propertyValues["Location"] = new Point(tabStrip.Left, tabStrip.Bottom + 3);
propertyValues["TabStrip"] = tabStrip;
// set the property values
SetProperties(controlSwitcher, propertyValues, host);
}
finally {
if (t != null)
{
t.Commit();
}
}
// add the TabPageSwitcher to the list of components that we've created
if (controlSwitcher != null)
{
IComponent[] newComponents = new IComponent[components.Length + 1];
Array.Copy(components, newComponents, components.Length);
newComponents[newComponents.Length - 1] = controlSwitcher;
return(newComponents);
}
}
return(components);
}
public bool CanParent (ControlDesigner designer)
{
return CanParent (designer.Control);
}
public DesignerRegion(ControlDesigner designer, string name, bool selectable) {}
private void ConvertToTemplate()
{
ControlDesigner.InvokeTransactedChange(base.Component, new TransactedChangeCallback(this.ConvertToTemplateChangeCallback), null, System.Design.SR.GetString("WebControls_ConvertToTemplate"), this.TemplateDescriptor);
}
protected ControlDesigner GetBaseDesigner()
{
if (this._designer == null)
{
IDesignerHost service = (IDesignerHost) this.DesignerSite.GetService(typeof(IDesignerHost));
this._designer = (ControlDesigner) service.GetDesigner(base.GetSelectedComponent());
}
return this._designer;
}
// Constructors
public EditableDesignerRegion(ControlDesigner owner, string name) {}
public override void Initialize(IComponent component)
{
ControlDesigner.VerifyInitializeArgument(component, typeof(LoginView));
this._loginView = (LoginView)component;
base.Initialize(component);
}
public EditableDesignerRegion(ControlDesigner owner, string name, bool serverControlsOnly) {}
public TemplateDefinition(ControlDesigner designer, string name, object templatedObject, string templatePropertyName, System.Web.UI.WebControls.Style style)
{
}
public override void Initialize(IComponent component)
{
ControlDesigner.VerifyInitializeArgument(component, typeof(ChangePassword));
this._changePassword = (ChangePassword)component;
base.Initialize(component);
}
// Constructors
public DesignerRegion(ControlDesigner designer, string name) {}
private void Reset()
{
this.UpdateDesignTimeHtml();
ControlDesigner.InvokeTransactedChange(base.Component, new TransactedChangeCallback(this.ResetChangeCallback), null, System.Design.SR.GetString("WebControls_Reset"), this.TemplateDescriptor);
}
public static ViewRendering GetViewRendering(ControlDesigner designer) {}
public override void Initialize(IComponent component)
{
ControlDesigner.VerifyInitializeArgument(component, typeof(DataList));
base.Initialize(component);
}
public static DialogResult ShowCreateDataSourceDialog (ControlDesigner controlDesigner, Type dataSourceType,
bool configure, out string dataSourceID)
{
throw new NotImplementedException ();
}
public DesignerRegionCollection(ControlDesigner owner) {}
// Constructors
public ControlDesignerAccessibleObject(ControlDesigner designer, System.Windows.Forms.Control control) {}
// Constructors
public TemplateDefinition(ControlDesigner designer, string name, object templatedObject, string templatePropertyName)
{
}
// Methods
public virtual bool CanParent(ControlDesigner controlDesigner) {}
