protected void AddGraph(PocGraphInfo graphInfo) { LayoutStates.Clear(); if (graphInfo == null) { return; } HighlightAlgorithm?.ResetHighlight(); RemoveAllGraphElement(); Children.Clear(); Dictionary <int, PocVertex> vertexControlsById = new Dictionary <int, PocVertex>(); foreach (VertexInfo <PocVertex> info in graphInfo.Verteces.OfType <VertexInfo <PocVertex> >()) { AddVertexControl(info); vertexControlsById.Add(info.ID, info.Vertex); } int i = 0; foreach (EdgeInfo <PocEdge> info in graphInfo.Edges.OfType <EdgeInfo <PocEdge> >()) { PocVertex source = vertexControlsById[info.SourceID]; PocVertex target = vertexControlsById[info.TargetID]; CreateEdgeControl(new PocEdge(i.ToString(), source, target)); i++; } }
public void SwitchLayouts(string layout) { foreach (Layout _layout in manuLayouts) { if (_layout.layoutName.ToString() == layout) { currentState = _layout.layoutName; _layout.layoutGameobject.gameObject.SetActive(true); } else { _layout.layoutGameobject.gameObject.SetActive(false); } } }
protected override void OnPaint(PaintEventArgs e) { if (m_layoutState != LayoutStates.klsNormal) { // re-entrant call, in the middle of doing layout! Suppress it. But, we need to paint sometime... // so queue a new paint event. Invalidate(false); return; } try { // Optimize JohnT: Could we do a binary search for the // slice at the top? But the chop point slices may not be real... m_layoutState = LayoutStates.klsChecking; Rectangle requiredReal = ClientRectangle; // all slices in this must be real HandleLayout1(false, requiredReal); bool fNeedResume = (m_layoutState == LayoutStates.klsLayoutSuspended); m_layoutState = LayoutStates.klsNormal; if (fNeedResume) { Point oldPos = AutoScrollPosition; ResumeLayout(); // will cause another paint (and may cause unwanted scroll of parent!) Invalidate(false); // Well, apparently doesn't always do so...we were sometimes not getting the lines. Make sure. PerformLayout(); if (AutoScrollPosition != oldPos) AutoScrollPosition = new Point(-oldPos.X, -oldPos.Y); } else { base.OnPaint(e); HandlePaintLinesBetweenSlices(null, e); } } finally { m_layoutState = LayoutStates.klsNormal; } }
protected override void OnLayout(LayoutEventArgs levent) { if (m_layoutState == LayoutStates.klsChecking) { SuspendLayout(); m_layoutState = LayoutStates.klsLayoutSuspended; return; } // doesn't seem we should ever be called with layout suspended, but it happens, // and we want to ignore it. if (m_layoutState == LayoutStates.klsLayoutSuspended || m_layoutState == LayoutStates.klsClearingAll) return; bool fNeedInternalLayout = true; // call HandleLayout1 at least once Size smallestSize = new Size(); // if we don't converge in three iterations, we probably never will. It is possible to get // in to an infinite loop, when scrollbars appear and disappear changing the width on every // iteration for (int i = 0; i < 3; i++) //for ( ; ; ) { int clientWidth = ClientRectangle.Width; // Somehow this sometimes changes the scroll position. // This might be reasonable if it changed the range, but it does it other times. // I can't figure out why, so just force it back if it does. Grrrr! Point aspOld = AutoScrollPosition; base.OnLayout(levent); if (AutoScrollPosition != aspOld) AutoScrollPosition = new Point(-aspOld.X, -aspOld.Y); if (smallestSize.IsEmpty || ClientSize.Width < smallestSize.Width) smallestSize = ClientSize; // If that changed the width of our client rectangle we definitely need to // call HandleLayout1 again. fNeedInternalLayout |= (clientWidth != ClientRectangle.Width); if (!fNeedInternalLayout) return; fNeedInternalLayout = false; // don't need to do again unless client rect width changes. Rectangle clipRect = ClientRectangle; clipRect.Offset(-AutoScrollPosition.X, -AutoScrollPosition.Y); int yTop = HandleLayout1(true, clipRect); if (yTop != AutoScrollMinSize.Height) { AutoScrollMinSize = new Size(0, yTop); // If we don't do this, the system thinks only the previously hidden part of the // data pane was affected, whereas all of it may have been if control heights // changed. // (I suppose there could be a pathological case where two slices changed heigtht // by opposite amounts and we need this redraw even though the height did not change, // but it seems very unlikely.) Invalidate(); } // Do the BASE.layout AGAIN...this seems to be the only way to get the scroll bars to // apppear and disappear as required by more or less slices... } // if we make it thru all three iterations, resize to the smallest layout size, which usually // means scrollbars will be visible. This ensures that no content will be cut off. if (ClientSize.Width != smallestSize.Width) { ClientSize = smallestSize; } }
/// <summary> /// Intended to be called by Datatree.FieldAt just before it creates a new slice. /// </summary> internal void AboutToCreateField() { CheckDisposed(); if (m_layoutState == LayoutStates.klsChecking) { SuspendLayout(); m_layoutState = LayoutStates.klsLayoutSuspended; } }
/// <summary> /// Private wrapper to remove the slices from the Datatree. /// </summary> private void ClearSlices() { LayoutStates oldState = m_layoutState; m_layoutState = LayoutStates.klsClearingAll; List<Slice> allSlices = new List<Slice>(Controls.Count); foreach (Slice slice in Controls) { slice.SplitCont.SplitterMoved -= new SplitterEventHandler(slice_SplitterMoved); allSlices.Add(slice); slice.AboutToDiscard(); } // It's safer to set m_currentSlice to null here, so that we don't allow using // CurrentSlice during windows message side-effects that occur during Controls.Clear(). m_currentSlice = null; Controls.Clear(); if (m_tooltip != null) m_tooltip.RemoveAll(); // has many tooltips for old slices. foreach (Slice gonner in allSlices) gonner.Dispose(); m_layoutState = oldState; AutoScrollPosition = new Point(0, 0); }
/// <summary> /// For sure make the CurrentSlice if any visible. /// If possible also make the prececing summary slice visible. /// Then make as many as possible of the slices which are children of that summary visible. /// </summary> void ScrollCurrentAndIfPossibleSectionIntoView() { if (CurrentSlice == null) return; // can't do anything. // Make sure all the slices up to one screen above and below are real and valid heights. // This is only called in response to a user action, so m_layoutState should be normal. // We set this state to make quite sure that if we somehow get an OnPaint() or OnLayout call // that is effectively re-entrant, we don't re-enter HandleLayout1, which can really mess things up. Debug.Assert(m_layoutState == LayoutStates.klsNormal); m_layoutState = LayoutStates.klsDoingLayout; try { HandleLayout1(false, new Rectangle(0, Math.Max(0, CurrentSlice.Top - ClientRectangle.Height), ClientRectangle.Width, ClientRectangle.Height * 2)); } finally { m_layoutState = LayoutStates.klsNormal; } ScrollControlIntoView(CurrentSlice); int previousSummaryIndex = CurrentSlice.IndexInContainer; while (!(Slices[previousSummaryIndex] is SummarySlice)) { previousSummaryIndex--; if (previousSummaryIndex < 0) return; } var previousSummary = Slices[previousSummaryIndex]; if (previousSummary.Top < 0 && CurrentSlice.Bottom - previousSummary.Top < ClientRectangle.Height - 20) ScrollControlIntoView(previousSummary); var lastChildIndex = CurrentSlice.IndexInContainer; while (lastChildIndex < Slices.Count && Slice.StartsWith(((Slice)Slices[lastChildIndex]).Key, previousSummary.Key) && Slices[lastChildIndex].Bottom - previousSummary.Top < ClientRectangle.Height - 20) lastChildIndex++; lastChildIndex--; if (lastChildIndex > CurrentSlice.IndexInContainer) ScrollControlIntoView(Slices[lastChildIndex]); }
public Slice FieldAt(int i) { CheckDisposed(); Slice slice = FieldOrDummyAt(i); // Keep trying until we get a real slice. It's possible, for example, that the first object // in a sequence expands into an embedded lazy sequence, which in turn needs to have its // first item made real. while (!slice.IsRealSlice) { var oldState = m_layoutState; // guard against OnPaint() while slice is being constructed. Especially dangerous if it is a view, // which might end up doing a re-entrant call to Construct() the root box. LT-11052. m_layoutState = LayoutStates.klsDoingLayout; try { if (slice.BecomeRealInPlace()) { SetTabIndex(Slices.IndexOf(slice)); return slice; } AboutToCreateField(); slice.BecomeReal(i); RemoveSliceAt(i); if (i >= Slices.Count) { // BecomeReal produced nothing; range has decreased! return null; } // Make sure something changed; otherwise, we have an infinite loop here. Debug.Assert(slice != Slices[i]); slice = Slices[i]; } finally { // If something changed the layout state during this, it probably knows what it's doing. // Otherwise go back to our original state. if (m_layoutState == LayoutStates.klsDoingLayout) m_layoutState = oldState; } } return slice; }