protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
 {
     ITemplateEditingService service = (ITemplateEditingService) this.GetService(typeof(ITemplateEditingService));
     DataGrid viewControl = (DataGrid) base.ViewControl;
     Style[] templateStyles = new Style[] { viewControl.ItemStyle, viewControl.EditItemStyle, viewControl.HeaderStyle, viewControl.FooterStyle };
     return service.CreateFrame(this, verb.Text, ColumnTemplateNames, viewControl.ControlStyle, templateStyles);
 }
 public TemplateEditingFrame(TemplatedControlDesigner owner, string frameName, string[] templateNames, Style controlStyle, Style[] templateStyles)
 {
     this.owner = owner;
     this.frameName = frameName;
     this.controlStyle = controlStyle;
     this.templateStyles = templateStyles;
     this.verb = null;
     this.templateNames = (string[]) templateNames.Clone();
     if (owner.BehaviorInternal != null)
     {
         System.Design.NativeMethods.IHTMLElement designTimeElementView = (System.Design.NativeMethods.IHTMLElement) ((IControlDesignerBehavior) owner.BehaviorInternal).DesignTimeElementView;
         this.htmlElemParent = designTimeElementView;
     }
     this.htmlElemControlName = null;
 }
Beispiel #3
0
		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;
		}
        protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
        {
            ITemplateEditingService service = (ITemplateEditingService) this.GetService(typeof(ITemplateEditingService));
            DataList viewControl = (DataList) base.ViewControl;
            string[] templateNames = null;
            Style[] templateStyles = null;
            switch (verb.Index)
            {
                case 0:
                    templateNames = ItemTemplateNames;
                    templateStyles = new Style[] { viewControl.ItemStyle, viewControl.AlternatingItemStyle, viewControl.SelectedItemStyle, viewControl.EditItemStyle };
                    break;

                case 1:
                    templateNames = HeaderFooterTemplateNames;
                    templateStyles = new Style[] { viewControl.HeaderStyle, viewControl.FooterStyle };
                    break;

                case 2:
                    templateNames = SeparatorTemplateNames;
                    templateStyles = new Style[] { viewControl.SeparatorStyle };
                    break;
            }
            return service.CreateFrame(this, verb.Text, templateNames, viewControl.ControlStyle, templateStyles);
        }
 public void Insert(int index, TemplateEditingVerb verb)
 {
     this.InternalList.Insert(index, verb);
 }
 public bool Contains(TemplateEditingVerb verb)
 {
     return(this.InternalList.Contains(verb));
 }
 public TemplatedControlDesignerTemplateGroup(TemplateEditingVerb verb, ITemplateEditingFrame frame) : base(verb.Text, frame.ControlStyle)
 {
     this._frame = frame;
     this._verb  = verb;
 }
 public void Dispose()
 {
     if ((this.owner != null) && this.owner.InTemplateMode)
     {
         this.owner.ExitTemplateMode(false, false, false);
     }
     this.ReleaseParentElement();
     if (this.verb != null)
     {
         this.verb.Dispose();
         this.verb = null;
     }
 }
 public void Remove(TemplateEditingVerb verb)
 {
     this.InternalList.Remove(verb);
 }
        protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
        {
            var teService = (ITemplateEditingService)this.GetService(typeof(ITemplateEditingService));

            Trace.Assert(teService != null, "How did we get this far without an ITemplateEditingService?");
            Trace.Assert(verb.Index == 0 || verb.Index == SeparatorTemplates);

            string[] templateNames = null;
            Style[] templateStyles = null;
            Style[] outputTemplateStyles;

            switch (verb.Index)
            {
                case PaneTemplates:
                    templateNames = PaneTemplateNames;
                    outputTemplateStyles = new Style[3];
                    outputTemplateStyles[IdxLeftPaneTemplate] = this.desktopPanes.LeftPaneStyle;
                    outputTemplateStyles[IdxContentPaneTemplate] = this.desktopPanes.ControlStyle;
                    outputTemplateStyles[IdxRightPaneTemplate] = this.desktopPanes.RightPaneStyle;
                    templateStyles = outputTemplateStyles;
                    break;
                case SeparatorTemplates:
                    templateNames = SeparatorTemplateNames;
                    outputTemplateStyles = new Style[2];
                    outputTemplateStyles[IdxHorizontalSeparatorTemplate] = this.desktopPanes.HorizontalSeparatorStyle;
                    outputTemplateStyles[IdxVerticalSeparatorTemplate] = this.desktopPanes.VerticalSeparatorStyle;
                    templateStyles = outputTemplateStyles;
                    break;
            }

            if (teService != null)
            {
                var editingFrame = teService.CreateFrame(
                    this, verb.Text, templateNames, this.desktopPanes.ControlStyle, templateStyles);

                // editingFrame = teService.CreateFrame(this, verb.Text, templateNames);
                return editingFrame;
            }

            return null;
        }
        protected override TemplateEditingVerb[] GetCachedTemplateEditingVerbs()
        {
            if (_templateEditingVerbs == null)
            {
                WeavverTabControl tc = (WeavverTabControl) Component;
                _templateEditingVerbs = new TemplateEditingVerb[tc.Tabs.Count];

                for (int i = 0; i < tc.Tabs.Count; i++)
                {
                    _templateEditingVerbs[i] = new TemplateEditingVerb("Tab " + i.ToString(), i, this);
                }
            }
            return _templateEditingVerbs;
        }
        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;
        }
        protected override TemplateEditingVerb[] GetTemplateVerbs()
        {
            TemplateEditingVerb[] templateVerbs = new TemplateEditingVerb[1];

            if (FormDeviceSpecific)
            {
                templateVerbs[0] = new TemplateEditingVerb(
                    SR.GetString(SR.TemplateFrame_HeaderFooterTemplates),
                    _headerFooterTemplates,
                    this);
            }
            else
            {
                templateVerbs[0] = new TemplateEditingVerb(
                    SR.GetString(SR.TemplateFrame_ContentTemplate),
                    _contentTemplate,
                    this);
            }

            return templateVerbs;
        }
 protected override ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb)
 {
     ITemplateEditingService service = (ITemplateEditingService) this.GetService(typeof(ITemplateEditingService));
     string[] templateFrameNames = this.GetTemplateFrameNames(verb.Index);
     ITemplateEditingFrame frame = service.CreateFrame(this, verb.Text, templateFrameNames, this.WebCtrlStyle, null);
     frame.InitialWidth = Constants.TemplateWidth;
     return frame;
 }
Beispiel #15
0
        protected override TemplateEditingVerb[] GetCachedTemplateEditingVerbs()
        {
            if (_templateEditingVerbs == null) {
                _templateEditingVerbs = new TemplateEditingVerb[2];

                _templateEditingVerbs[0] = new TemplateEditingVerb("Header and Footer", HeaderFooterTemplates, this);
                _templateEditingVerbs[1] = new TemplateEditingVerb("Items", ItemTemplates, this);
            }
            return _templateEditingVerbs;
        }
 public void Insert(int index, TemplateEditingVerb verb)
 {
     this.InternalList.Insert(index, verb);
 }
        protected override TemplateEditingVerb[] GetTemplateVerbs()
        {
            TemplateEditingVerb[] templateVerbs = new TemplateEditingVerb[_numberOfTemplateFrames];

            templateVerbs[_headerFooterTemplates] = new TemplateEditingVerb(
                SR.GetString(SR.TemplateFrame_HeaderFooterTemplates),
                _headerFooterTemplates,
                this);
            templateVerbs[_itemTemplates] = new TemplateEditingVerb(
                SR.GetString(SR.TemplateFrame_ItemTemplates),
                _itemTemplates,
                this);
            templateVerbs[_separatorTemplate] = new TemplateEditingVerb(
                SR.GetString(SR.TemplateFrame_SeparatorTemplate),
                _separatorTemplate,
                this);

            return templateVerbs;
        }
        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;
        }
 public TemplateEditingVerb[] GetTemplateEditingVerbs()
 {
     if (((ITemplateEditingService) this.GetService(typeof(ITemplateEditingService))) == null)
     {
         return null;
     }
     TemplateEditingVerbCollection templateEditingVerbsInternal = this.GetTemplateEditingVerbsInternal();
     TemplateEditingVerb[] array = new TemplateEditingVerb[templateEditingVerbsInternal.Count];
     ((ICollection) templateEditingVerbsInternal).CopyTo(array, 0);
     return array;
 }
 protected abstract ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb);
 public TemplatedControlDesignerTemplateGroup(TemplateEditingVerb verb, ITemplateEditingFrame frame) : base(verb.Text, frame.ControlStyle)
 {
     this._frame = frame;
     this._verb = verb;
 }
 protected abstract ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb);
 internal TemplateEditingVerbCollection(TemplateEditingVerb[] verbs)
 {
     for (int i = 0; i < verbs.Length; i++)
     {
         this.Add(verbs[i]);
     }
 }
 public int Add(TemplateEditingVerb verb)
 {
     return(this.InternalList.Add(verb));
 }
 public int Add(TemplateEditingVerb verb)
 {
     return this.InternalList.Add(verb);
 }
 public int IndexOf(TemplateEditingVerb verb)
 {
     return(this.InternalList.IndexOf(verb));
 }
 public bool Contains(TemplateEditingVerb verb)
 {
     return this.InternalList.Contains(verb);
 }
 public void Remove(TemplateEditingVerb verb)
 {
     this.InternalList.Remove(verb);
 }
 public int IndexOf(TemplateEditingVerb verb)
 {
     return this.InternalList.IndexOf(verb);
 }
Beispiel #30
0
 public void Dispose()
 {
     this._verb = null;
     this._changeTable = null;
 }
Beispiel #31
0
        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;
        }