I have this mistery:
public class UIWindow : Control
{
public PythonDictionary Variables;
public PythonTuple Children
{
get
{
if(Variables.has_key("children"))
return (PythonTuple)Variables["children"];
return null;
}
}
public UIWindow(PythonDictionary variables)
{
Variables = variables;
LoadChildren(Children, this);
Tag = "window";
}
private void LoadChildren(PythonTuple children, Control parent)
{
--recursive loading
}
}
Then i want that a class gets information about itself
public class UIText : Control
{
private PythonDictionary Myself
{
get
{
}
}
public string Name
{
get { MySelf["name"]; }
set { Myself["name"]; }
}
public UIText(Control parent)
{
Parent = parent;
Tag = "text";
}
}
I already know that my info is type of pythontuple because the LoadChildren of UIWindow did load all children from pythontuples, but how do i have reference to myself?
private PythonDictionary Myself
{
get
{
}
}
Related
I want to create builder for my purpose, with such call chain:
User user = new CommonBuilder(new UserNode()).Root //generic parameter, currently is User
.Group.Group.Folder.Build();
Here is the code, which I use:
public abstract class AbstractNode
{
public Guid Id { get; } = Guid.NewGuid();
}
public abstract class AbstractNode<T> where T : AbstractNode<T>
{
}
public class CommonBuilder<T> where T : AbstractNode<T>
{
public T Root { get; private set; }
public CommonBuilder(T root)
{
Root = root;
}
}
public class UserNode : AbstractNode<UserNode>
{
private GroupNode _group;
public GroupNode Group
{
get
{
if (_group is null)
{
_group = new GroupNode();
}
return _group;
}
}
}
public class GroupNode : AbstractNode<GroupNode>
{
private GroupNode _group;
public GroupNode Group
{
get
{
if (_group is null)
{
_group = new GroupNode();
}
return _group;
}
}
private FolderNode _folder;
public FolderNode Folder
{
get
{
if (_folder is null)
{
_folder = new FolderNode();
}
return _folder;
}
}
}
public class FolderNode : AbstractNode<FolderNode>
{
}
The problem is in the Build() method, which need to return Root from CommonBuilder, not the File.
Where must I place Build() method, which must be always called at the end of a chain, which returns Root of a builder?
In case when it's required to make a chain the same object should be returned, even as another interface check first and second examples of implementation Builder with Fluent intefaces
I've tried to implement your case to fit the role, check if it will fits your requirements:
public interface IGroup<T>
{
IGroup<T> Group { get; }
IFolder<T> Folder { get; }
}
public interface IFolder<T>
{
T Build();
}
Builder implements all required interfaces. And returns itself in each call. In general you can put Build method in the builder itself and call it separately after the end of chain execution.
public class CommonBuilder<T> : IGroup<T>, IFolder<T> where T: INode, new()
{
private T _root = new T();
public T Build()
{
return _root;
}
public IGroup<T> Group
{
get
{
_root.MoveToGroup();
return this;
}
}
public IFolder<T> Folder
{
get
{
_root.MoveToFolder();
return this;
}
}
}
Because of generics it's required to set some limitations on generic parameter which is done with INode interface
public interface INode
{
void MoveToGroup();
void MoveToFolder();
}
Testing user object
public class User : INode
{
public StringBuilder Path { get; } = new StringBuilder();
public void MoveToFolder()
{
Path.AppendLine("Folder");
}
public void MoveToGroup()
{
Path.AppendLine("Group");
}
public override string ToString()
{
return Path.ToString();
}
}
And the call will looks like
var user = new CommonBuilder<User>().Group.Group.Folder.Build();
EDIT
Maybe as a the first stage it makes sence to get rid of Fluent interfaces and implement logic using just a Builder:
public class FolderNode : INode<Folder>
{
private readonly Folder _folder = new Folder();
public Folder Build()
{
return _folder;
}
public void AppendGroup()
{
_folder.Path.AppendLine("Folder Group");
}
public void AppendFolder()
{
_folder.Path.AppendLine("Folder Folder");
}
}
public class UserNode : INode<User>
{
private readonly User _user = new User();
public User Build()
{
return _user;
}
public void AppendGroup()
{
_user.Path.AppendLine("Group");
}
public void AppendFolder()
{
_user.Path.AppendLine("Folder");
}
}
public class CommonBuilder<T, TNode> where TNode : INode<T>
{
private readonly TNode _root;
public CommonBuilder(TNode root)
{
_root = root;
}
public T Build()
{
return _root.Build();
}
public CommonBuilder<T, TNode> Group {
get
{
_root.AppendGroup();
return this;
}
}
public CommonBuilder<T, TNode> Folder {
get
{
_root.AppendFolder();
return this;
}
}
}
public interface INode<out T>
{
T Build();
void AppendGroup();
void AppendFolder();
}
public class Folder
{
public StringBuilder Path { get; } = new StringBuilder();
public override string ToString()
{
return Path.ToString();
}
}
public class User
{
public StringBuilder Path { get; } = new StringBuilder();
public override string ToString()
{
return Path.ToString();
}
}
Usage:
var user = new CommonBuilder<User, UserNode>(new UserNode()).Group.Group.Folder.Build();
var folder = new CommonBuilder<Folder, FolderNode>(new FolderNode()).Group.Folder.Group.Folder.Build();
I have the class AppForm inherited Form with property AppIconForm (class).
I want at design time "+" sign appears on the edit IconForm property in the properties window and the child properties ( CloseIcon and MaximizedIcon ) appear. Thanks! :)
public partial class AppForm : Form
{
AppIconForm iconform = new AppIconForm();
public AppForm()
{
InitializeComponent();
}
public AppIconForm IconForm
{
get { return iconform; }
set { iconform = value; }
}
}
//the code of AppIconForm class
public class AppIconForm
{
Icon closeicon;
Icon maximizeicon;
public Icon CloseIcon
{
get { return closeicon; }
set { closeicon = value; }
}
public Icon MaximizeIcon
{
get { return maximizeicon; }
set { maximizeicon = value; }
}
}
Use BrowsableAttribute
[Browsable]
public Icon CloseIcon
{
get { return closeicon; }
set { closeicon = value; }
}
I want to serialize objects of class to xaml format. However, all of the properties name of class are directly serialized and I can't change their name.
I've used the
[DataMember(Name = "NameToChange")]`
attribute, but this still not solve the problem.
Please help me on this.
Here is the class:
public partial class XObject
{
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public string AtName
{
get
{
return this.Name;
}
set
{
this.Name = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public string AtType
{
get
{
return this.m_TypeToken;
}
set
{
this.m_TypeToken = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public string AtSerialize
{
get
{
return this.m_SerializeToken;
}
set
{
this.m_SerializeToken = value;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public List<string> AtValue
{
get
{
return m_Values;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public Dictionary<string, XObject> AtAttached
{
get
{
return m_AttachedAttributes;
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public string AtDynamic
{
get
{
return m_DynamicValue;
}
}
public void UpdateToken()
{
AtSerialize = (true == HasAttribute(AttributeNameToken_Serialize)) ? GetAttribute(AttributeNameToken_Serialize) : null;
AtType = (true == HasAttribute(AttributeNameToken_Type)) ? GetAttribute(AttributeNameToken_Type) : null;
foreach (XObject member in this)
{
member.UpdateToken();
}
}
private string m_TypeToken = null;
private string m_SerializeToken = null;
}
I have created a new Custom Control inheriting from Bar control of DevComponents.DotNetBar controls. Next, I have created a new dock tab in it and have added my other controls to it.
After I compile my Custom Control and add my created Custom Control in a new Windows Form, Dock Tab Controls are editable at design time.
I don't want that anybody can edit these controls (Dock Tab Controls) in design time. How can I disable editing the controls at design time from the form (not the same as editing the control itself)?
public partial class barFloorsGrouping : Bar
{
public barFloorsGrouping()
{
InitializeComponent();
}
[ReadOnly(true)]
public new System.Windows.Forms.AccessibleRole AccessibleRole
{
get { return base.AccessibleRole; }
private set { base.AccessibleRole = System.Windows.Forms.AccessibleRole.ToolBar; }
}
[Browsable(false), ReadOnly(true)]
public new bool AlwaysDisplayDockTab
{
get { return base.AlwaysDisplayDockTab; }
private set { base.AlwaysDisplayDockTab = true; }
}
[Browsable(false), ReadOnly(true)]
public new bool AlwaysDisplayKeyAccelerators
{
get { return base.AlwaysDisplayKeyAccelerators; }
private set { base.AlwaysDisplayKeyAccelerators = true; }
}
[ReadOnly(true)]
public new bool AntiAlias
{
get { return base.AntiAlias; }
private set { base.AntiAlias = true; }
}
[Browsable(false), ReadOnly(true)]
public new bool AutoCreateCaptionMenu
{
get { return base.AutoCreateCaptionMenu; }
}
[ReadOnly(true)]
public new bool AutoHide
{
get { return base.AutoHide; }
}
[Browsable(false), ReadOnly(true)]
public new bool AutoHideTabTextAlwaysVisible
{
get { return base.AutoHideTabTextAlwaysVisible; }
}
[Browsable(false), ReadOnly(true)]
public new bool AutoSyncBarCaption
{
get { return base.AutoSyncBarCaption; }
private set { base.AutoSyncBarCaption = true; }
}
[Browsable(false), ReadOnly(true)]
public new eBarType BarType
{
get { return base.BarType; }
private set { base.BarType = eBarType.DockWindow; }
}
[ReadOnly(true)]
public new bool CanAutoHide
{
get { return base.CanAutoHide; }
}
[ReadOnly(true)]
public new bool CanDockTab
{
get { return base.CanDockTab; }
private set { base.CanDockTab = false; }
}
[ReadOnly(true)]
public new bool CanUndock
{
get { return base.CanUndock; }
private set { base.CanUndock = false; }
}
[Browsable(false), ReadOnly(true)]
public new bool CloseSingleTab
{
get { return base.CloseSingleTab; }
}
[Browsable(false), ReadOnly(true)]
public new bool DisplayMoreItemsOnMenu
{
get { return base.DisplayMoreItemsOnMenu; }
private set { base.DisplayMoreItemsOnMenu = true; }
}
[ReadOnly(true)]
public new DockStyle Dock
{
get { return base.Dock; }
}
[Browsable(false), ReadOnly(true)]
public new bool DockTabCloseButtonVisible
{
get { return base.DockTabCloseButtonVisible; }
}
[Browsable(false), ReadOnly(true)]
public new bool FadeEffect
{
get { return base.FadeEffect; }
private set { base.FadeEffect = true; }
}
[Browsable(false), ReadOnly(true)]
public new eGrabHandleStyle GrabHandleStyle
{
get { return base.GrabHandleStyle; }
private set { base.GrabHandleStyle = eGrabHandleStyle.Caption; }
}
[Browsable(false), ReadOnly(true)]
public new eLayoutType LayoutType
{
get { return base.LayoutType; }
private set { base.LayoutType = eLayoutType.DockContainer; }
}
[Browsable(false), ReadOnly(true)]
public new bool MenuBar
{
get { return base.MenuBar; }
}
[Browsable(false), ReadOnly(true)]
public new bool TabNavigation
{
get { return base.TabNavigation; }
private set { base.TabNavigation = true; }
}
[Browsable(false), ReadOnly(true)]
public new bool WrapItemsDock
{
get { return base.WrapItemsDock; }
private set { base.WrapItemsDock = true; }
}
protected override void OnPaint(PaintEventArgs pe)
{
base.OnPaint(pe);
}
}
You must extend the design mode behavior by using ParentControlDesigner Class. ParentControlDesigner Class provides a base class for designers of controls that can contain child controls.
So, for achieve to your Goal, you must implement design-time services for a component by DesignerAttribute as the following (Just add below code before the written class):
[Designer("System.Windows.Forms.Design.ParentControlDesigner, System.Design", typeof(IDesigner))]
public partial class barFloorsGrouping : Bar
{
...
}
EDIT: As always I work in asp.net and webforms... This answer is for WebForms
You would need to override the GetDesignTimeHtml of the WebControl.
see MSDN docs
It sounds to me like you haven't done a lot of server control creation so you are in for a lot of fun...
Here are two simple classes to illustrate my question:
class Widget
{
private int _widgetID;
public int WidgetID
{
get { return _widgetID; }
set { _widgetID = value; }
}
private int _categoryID;
public int CategoryID
{
get { return _categoryID; }
set { _categoryID = value; }
}
private string _widgetName;
public string WidgetName
{
get { return _widgetName; }
set { _widgetName = value; }
}
}
And them the second class:
class WidgetCategory
{
private int _widgetCategoryID;
public int WidgetCategoryID
{
get { return _widgetCategoryID; }
set { _widgetCategoryID = value; }
}
private Widget[] _widgets;
public Widget[] Widgets
{
get { return _widgets; }
set { _widgets = value; }
}
private string _widgetCategoryName;
public string WidgetCategoryName
{
get { return _widgetCategoryName; }
set { _widgetCategoryName = value; }
}
}
How would I handle this situation in the most efficient way?
Also, so you know, I will need to nest other classes the same way below the Widget class.
You should create a read-only property of type System.Collections.ObjectModel.Collection<Widget>.
Collection properties should be read only
Use Collection<T>