internal FreeformAdder(int hvoType, RootSite site, bool fNeedReconstruct, InterlinVc vc) : base(site.Cache) { m_hvoType = hvoType; m_site = site; m_fNeedReconstruct = fNeedReconstruct; m_choices = vc.LineChoices; m_vc = vc; }
protected override int DesiredHeight(RootSite rs) { int height = base.DesiredHeight(rs); // only include the height of the insertion contorl when it is visible if (RuleFormulaControl.InsertionControl.Visible) { height += RuleFormulaControl.InsertionControl.Height; } return(height); }
/// <summary> /// Somehow a slice (I think one that has never scrolled to become visible?) /// can get an OnLoad message for its view in the course of deleting it from the /// parent controls collection. This can be bad (at best it's a waste of time /// to do the Layout in the OnLoad, but it can be actively harmful if the object /// the view is displaying has been deleted). So suppress it. /// </summary> public override void AboutToDiscard() { CheckDisposed(); base.AboutToDiscard(); RootSite rs = RootSite; if (rs != null) { rs.AboutToDiscard(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates the control in column. /// </summary> /// <param name="cell">The cell that will host the control we create.</param> /// ------------------------------------------------------------------------------------ private void CreateHostedControl(DataGridViewControlCell cell) { if (cell.ControlCreateInfo == null || cell.ControlCreateInfo.ViewProxy == null) { return; } IRootSiteGroup group = cell.ControlCreateInfo.Group; Control c = cell.ControlCreateInfo.ViewProxy.CreateView(this); if (c is RootSite) { RootSite rs = c as RootSite; rs.Cache = m_cache; rs.StyleSheet = m_StyleSheet; } if (group != null && c is IRootSiteSlave) { IRootSiteSlave slave = c as IRootSiteSlave; group.AddToSyncGroup(slave); if (cell.ControlCreateInfo.IsScrollingController) { #if __MonoCS__ // TODO-Linux: HACK Check to see if a ScrollingControl has (in error) already been set. // hack to prevent multiple scrollbars controling a group // This isn't needed in Windows as RootSite.cs check to see if it is the Group ScrollingController // Which should mean that if multiple scrolling Control are set only the last one actually contains a scrollbar // However because on mono Creating events aren't exactly the same (shame!) the group property of the RootSite get set before // the second RootSite with the ScrollingControl set, get created meaning when the group is set it IS the scrolling controler! (and hence AutoScroll isn't set to false) // A alternative way of fixing this (and probably better) would be to change the ViewWrapperContructor to only set a single ScrollingControl // (currently BtWrapper set one) and calls it base which also has set one. if (group.ScrollingController != null) { if (group.ScrollingController is ScrollableControl) { (group.ScrollingController as ScrollableControl).AutoScroll = false; } } #endif group.ScrollingController = slave; } } if (c is ISelectableView) { ((ISelectableView)c).BaseInfoBarCaption = m_baseInfoBarCaption; } cell.ControlCreateInfo.Control = c; OnHostedControlCreated(c); }
/// <summary> /// Some 'unreal' slices can become 'real' (ready to actually display) without /// actually replacing themselves with a different object. Such slices override /// this method to do whatever is needed and then answer true. If a slice /// answers false to IsRealSlice, this is tried, and if it returns false, /// then BecomeReal is called. /// </summary> /// <returns></returns> public override bool BecomeRealInPlace() { CheckDisposed(); RootSite rs = this.RootSite; if (rs.RootBox == null) { IntPtr dummy = rs.Handle; // This typically gets the root box created, so setting AllowLayout can lay it out. } rs.AllowLayout = true; // also does PerformLayout. SetHeightFromRootBox(rs); return(true); }
public override void FinishInit() { base.FinishInit(); string paramType = XmlUtils.GetOptionalAttributeValue(m_configurationNode.ParentNode, "paramType"); if (paramType == "LiteralString") { // Instead of the parameter being a layout name, it is literal text which will be // the whole contents of the slice, with standard properties. string text = XmlUtils.GetManditoryAttributeValue(m_callerNode, "label"); if (m_stringTable != null) { text = m_stringTable.LocalizeAttributeValue(text); } m_view = new LiteralLabelView(text, this); } else { m_layout = XmlUtils.GetOptionalAttributeValue(m_callerNode, "param") ?? XmlUtils.GetManditoryAttributeValue(m_configurationNode, "layout"); m_collapsedLayout = XmlUtils.GetOptionalAttributeValue(m_callerNode, "collapsedLayout") ?? XmlUtils.GetOptionalAttributeValue(m_configurationNode, "collapsedLayout"); m_view = new SummaryXmlView(m_obj.Hvo, m_layout, m_stringTable, this); m_view.Mediator = Mediator; } var panel = new Panel { Dock = DockStyle.Fill }; Control = panel; m_view.Dock = DockStyle.Left; m_view.LayoutSizeChanged += m_view_LayoutSizeChanged; panel.Controls.Add(m_view); m_button = new ExpandCollapseButton { Dock = DockStyle.Left }; m_button.Click += m_button_Click; panel.Controls.Add(m_button); panel.MouseDown += OnMouseDownInPanel; m_commandControl = new SummaryCommandControl(this) { Dock = DockStyle.Fill, Visible = XmlUtils.GetOptionalBooleanAttributeValue(m_callerNode, "commandVisible", false) }; panel.Controls.Add(m_commandControl); }
/// <summary> /// Some 'unreal' slices can become 'real' (ready to actually display) without /// actually replacing themselves with a different object. Such slices override /// this method to do whatever is needed and then answer true. If a slice /// answers false to IsRealSlice, this is tried, and if it returns false, /// then BecomeReal is called. /// </summary> /// <returns></returns> public override bool BecomeRealInPlace() { CheckDisposed(); RootSite rs = this.RootSite; if (rs.RootBox == null) { #pragma warning disable 0219 // error CS0219: The variable ... is assigned but its value is never used IntPtr dummy = rs.Handle; // This typically gets the root box created, so setting AllowLayout can lay it out. #pragma warning restore 0219 } rs.AllowLayout = true; // also does PerformLayout. SetHeightFromRootBox(rs); return(true); }
protected override void SetupDataContext() { Debug.Assert(m_configurationParameters != null); base.SetupDataContext(); m_rootSite = ConstructRoot(); m_rootSite.Init(m_mediator, m_configurationParameters); // Init it as xCoreColleague. //m_rootSite.PersistenceProvder = new XCore.PersistenceProvider(m_mediator.PropertyTable); m_rootSite.Dock = System.Windows.Forms.DockStyle.Fill; m_rootSite.Cache = Cache; Controls.Add(m_rootSite); m_rootSite.BringToFront(); // Review JohnT: is this needed? }
protected override int DesiredHeight(RootSite rs) { if (rs != null && !rs.AllowLayout) { rs.AllowLayout = true; // Fixes LT-13603 where sometimes the slice was constructed by not laid out by now. } int height = base.DesiredHeight(rs); // only include the height of the insertion contorl when it is visible if (RuleFormulaControl.InsertionControl.Visible) { height += RuleFormulaControl.InsertionControl.Height; } return(height); }
protected internal override void SetWidthForDataTreeLayout(int width) { CheckDisposed(); if (Width == width) { return; // Nothing to do. } base.SetWidthForDataTreeLayout(width); if (RootSite.RootBox == null) { RootSite.MakeRoot(); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates the control in column. /// </summary> /// <param name="cell">The cell that will host the control we create.</param> /// ------------------------------------------------------------------------------------ private void CreateHostedControl(DataGridViewControlCell cell) { if (cell.ControlCreateInfo == null || (ControlCreator == null && !(cell.ControlCreateInfo.ClientControlInfo is FixedControlCreateInfo))) { return; } IRootSiteGroup group = cell.ControlCreateInfo.Group; Control c; if (cell.ControlCreateInfo.ClientControlInfo is FixedControlCreateInfo) { // We know how to deal with this! c = ((FixedControlCreateInfo)cell.ControlCreateInfo.ClientControlInfo).Control; } else { c = ControlCreator.Create(this, cell.ControlCreateInfo.ClientControlInfo); } if (c is RootSite) { RootSite rs = c as RootSite; rs.Cache = m_cache; rs.StyleSheet = m_StyleSheet; } if (group != null && c is IRootSiteSlave) { IRootSiteSlave slave = c as IRootSiteSlave; group.AddToSyncGroup(slave); if (cell.ControlCreateInfo.IsScrollingController) { group.ScrollingController = slave; } } if (c is ISelectableView) { ((ISelectableView)c).BaseInfoBarCaption = m_baseInfoBarCaption; } cell.ControlCreateInfo.Control = c; OnHostedControlCreated(c); }
/// <summary> /// /// </summary> /// <param name="parent"></param> public override void Install(DataTree parent) { CheckDisposed(); // Sometimes we get a spurious "out of memory" error while trying to create a handle for the // RootSite if its cache isn't set before we add it to its parent. RootSite rs = RootSite; rs.Cache = Cache; // JT: seems to actually cause a problem if we replace it with itself. RootSite probably needs a fix. if (rs.StyleSheet != parent.StyleSheet) { rs.StyleSheet = parent.StyleSheet; } base.Install(parent); rs.SetAccessibleName(this.Label); }
protected override void OnSizeChanged(EventArgs e) { base.OnSizeChanged(e); if (this.Width == m_dxLastWidth) { return; } m_dxLastWidth = Width; // BEFORE doing anything, actions below may trigger recursive call. ReferenceLauncher rl = (ReferenceLauncher)this.Control; RootSite rs = (RootSite)rl.MainControl; rs.PerformLayout(); if (rs.RootBox != null) { // Allow it to be the height it wants + fluff to get rid of scroll bar. // Adjust our own height to suit. // Note that this may produce a recursive call! this.Height = rs.RootBox.Height + 8; } }
protected internal override void SetWidthForDataTreeLayout(int width) { CheckDisposed(); if (Width == width) { return; // Nothing to do. } base.SetWidthForDataTreeLayout(width); RootSite rs = this.RootSite; if (rs.AllowLayout) { // already laid out at some other width, need to do it again right now so // we can get an accurate height. rs.PerformLayout(); SetHeightFromRootBox(rs); } }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) { return; } if (disposing) { // Dispose managed resources here. } // Dispose unmanaged resources here, whether disposing is true or false. m_view = null; // Gets disposed elsewhere, since it is in the Controls collection of another active widget. m_commandControl = null; // Gets disposed elsewhere, since it is in the Controls collection of another active widget. base.Dispose(disposing); }
private void SetHeightFromRootBox(RootSite rs) { if (rs.RootBox != null) { //Debug.WriteLine(String.Format("ViewSlice.SetHeightFromRootBox(): orig rs.Size = {0}, this.Size = {1}", // rs.Size.ToString(), this.Size.ToString())); int widthOrig = rs.Width; this.Height = Math.Max(LabelHeight, DesiredHeight(rs)); // Allow it to be the height it wants. //Debug.WriteLine(String.Format("ViewSlice.SetHeightFromRootBox(): new rs.Size = {0}, this.Size = {1}", // rs.Size.ToString(), this.Size.ToString())); if (widthOrig != rs.Width) { // If the rootsite width changes, we need to layout again. See LT-6156. (This is too much // like a band-aid, but it's taken me 3 days to figure even this much out!) rs.AllowLayout = true; this.Height = Math.Max(LabelHeight, DesiredHeight(rs)); // Debug.WriteLine(String.Format("ViewSlice.SetHeightFromRootBox(): final rs.Size = {0}, this.Size = {1}", // rs.Size.ToString(), this.Size.ToString())); } } }
/// ----------------------------------------------------------------------------------- /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged /// resources; <c>false</c> to release only unmanaged resources. /// </param> /// ----------------------------------------------------------------------------------- protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) { return; } if (disposing) { if (m_rootSite != null) { m_rootSite.Dispose(); } } m_rootSite = null; // m_mediator = null; // Bad idea, since superclass still needs it. base.Dispose(disposing); }
/// <summary> /// Construct one, using the "part ref" element (caller) that /// invoked the "slice" node that specified this editor. /// </summary> /// <param name="caller"></param> /// <param name="node"></param> public SummarySlice(ICmObject obj, XmlNode caller, XmlNode node, StringTable stringTbl) : base() { string paramType = XmlUtils.GetOptionalAttributeValue(node.ParentNode, "paramType"); if (paramType == "LiteralString") { // Instead of the parameter being a layout name, it is literal text which will be // the whole contents of the slice, with standard properties. string text = XmlUtils.GetManditoryAttributeValue(caller, "label"); if (stringTbl != null) { text = stringTbl.LocalizeAttributeValue(text); } m_view = new LiteralLabelView(text, this); m_fLiteralString = true; } else { string layout = XmlUtils.GetOptionalAttributeValue(caller, "param"); if (layout == null) { layout = XmlUtils.GetManditoryAttributeValue(node, "layout"); } m_view = new SummaryXmlView(obj.Hvo, layout, stringTbl, this); } UserControl mainControl = new UserControl(); m_view.Dock = DockStyle.Left; m_view.LayoutSizeChanged += new EventHandler(m_view_LayoutSizeChanged); mainControl.Height = m_view.Height; Control = mainControl; m_commandControl = new SummaryCommandControl(this); m_commandControl.Dock = DockStyle.Fill; m_commandControl.Visible = XmlUtils.GetOptionalBooleanAttributeValue(caller, "commandVisible", false); mainControl.Controls.Add(m_commandControl); mainControl.Dock = DockStyle.Fill; mainControl.Controls.Add(m_view); }
public ViewPropertySlice(RootSite ctrlT, int hvoObj, int flid) : base(ctrlT) { m_hvoContext = hvoObj; m_flid = flid; }
public bool ShowFindReplaceDialog(bool fReplace, RootSite rootsite) { throw new NotImplementedException(); }
/// <summary> /// Override to give the height that the AnalysisInterlinearRs wants to be. /// </summary> /// <param name="rs"></param> /// <returns></returns> protected override int DesiredHeight(RootSite rs) { return(((AnalysisInterlinearRs)rs).DesiredSize.Height); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Start the undo task /// </summary> /// <param name="actionHandler">The action handler.</param> /// <param name="rootSite">The view</param> /// <param name="stid">String resource id used for Undo/Redo labels</param> /// ------------------------------------------------------------------------------------ public DummyUndoTaskHelper(IActionHandler actionHandler, RootSite rootSite, string stid) : base(actionHandler, rootSite, stid) { }
/// ------------------------------------------------------------------------------------ /// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> /// ------------------------------------------------------------------------------------ private void ViewSlice_Enter(object sender, System.EventArgs e) { RootSite.Focus(); ContainingDataTree.ActiveControl = RootSite; }
protected override int DesiredHeight(RootSite rs) { return(Math.Max(base.DesiredHeight(rs), (Control as MSADlgLauncher).LauncherButton.Height)); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Start the undo task /// </summary> /// <param name="rootSite">The view</param> /// <param name="stid">String resource id used for Undo/Redo labels</param> /// ----------------------------------------------------------------------------------- public DummyUndoTaskHelper(RootSite rootSite, string stid) : base(rootSite, stid) { }
/// <summary></summary> public ViewPropertySlice(RootSite ctrlT, ICmObject obj, int flid) : base(ctrlT) { Reuse(obj, flid); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Start the undo task /// </summary> /// <param name="rootSite">The view</param> /// <param name="stid">String resource id used for Undo/Redo labels</param> /// <param name="fSavePoint"><c>true</c> to set a save point</param> /// ----------------------------------------------------------------------------------- public DummyUndoTaskHelper(RootSite rootSite, string stid, bool fSavePoint) : base(rootSite, stid, fSavePoint) { }
protected override int DesiredHeight(RootSite rs) { return(Math.Max(base.DesiredHeight(rs), (Control as PhonologicalFeatureListDlgLauncher).LauncherButton.Height)); }
/// <summary> /// The height that the slice would ideally be to accommodate the rootsite. /// </summary> /// <param name="rs"></param> /// <returns></returns> protected virtual int DesiredHeight(RootSite rs) { return(rs.RootBox.Height); }