/// <summary>
/// Configure the view in the view panel
/// </summary>
/// <param name="view"></param>
/// <param name="viewPanel"></param>
void ConfigureViewInPanel(
ResultsViewProps view,
XtraPanel viewPanel)
{
Stopwatch sw = Stopwatch.StartNew();
long ms1 = sw.ElapsedMilliseconds;
sw.Restart();
if (viewPanel.Parent != null)
{
viewPanel.Size = viewPanel.Parent.Size;
}
//if (view.RenderingControl == null) // create the rendering control for the view if not done yet
{
view.AllocateRenderingControl(); // allocate rendering control if needed
}
long ms2 = sw.ElapsedMilliseconds;
sw.Restart();
view.InsertRenderingControlIntoDisplayPanel(viewPanel);
if (view.ConfigureCount == 0) // configure if not done yet
{
view.ConfigureRenderingControl();
}
long ms3 = sw.ElapsedMilliseconds;
return;
}
/// <summary>
/// Focus the currently active view
/// </summary>
internal void FocusActiveView()
{
if (ResultsPage == null ||
ResultsPage.Views.Count == 0) // no need to focus if not multiple views
{
return;
}
else if (ResultsPage.Views.Count == 1) // single view
{
ResultsViewProps view = ResultsPage.Views[0];
return; // todo?
}
else // multiple views set focus for active view and associated DockPanel
{
DockPanel dp = DockManager.ActivePanel;
if (dp != null && dp.ControlContainer != null)
{
dp.ControlContainer.Focus();
}
}
return;
}
/// <summary>
/// Close the specified view
/// </summary>
/// <param name="view"></param>
internal void CloseView(ResultsViewProps view)
{
int vi = ResultsPage.Views.IndexOf(view);
if (vi < 0)
{
return;
}
UIMisc.EnteringSetup();
ResultsPage.Views.RemoveAt(vi); // get rid of the view
DockPanel dp = GetContainingDockPanel(view.RenderingControl);
if (dp != null) // if in a dock panel
{
DockManager.RemovePanel(dp); // render the corresponding panel
}
else
{
RenderViews(); // just a single view, render empty page
}
if (ResultsPage.ActiveViewIndex >= ResultsPage.Views.Count)
{
ResultsPage.ActiveViewIndex--; // normally go to next view but keep index within range
}
SaveLayout();
UIMisc.LeavingSetup();
return;
}
/// <summary>
/// Create the view display controls and link them into the QueryResultsControl and the ResultsView object
/// </summary>
/// <returns></returns>
public override Control AllocateRenderingControl()
{
if (RealizeSubQueryView() == null) // be sure the subquery and view still exist
{
MessageBoxMx.ShowError("Failed to realize SubQueryId: " + SubQueryId + ", SubQuerySelectedViewId: " + SubQuerySelectedViewId);
return(null);
}
Query sq = SubQuery;
ResultsViewProps sqView = SubQuerySelectedView;
if (Lex.IsUndefined(CustomViewTypeImageName))
{
CustomViewTypeImageName = sqView.CustomViewTypeImageName;
}
if (Lex.IsUndefined(Title))
{
Title = sqView.Title;
}
if (Sqm == null)
{
Sqm = SetupAndExecuteSecondaryQuery(sq, sqView);
}
RenderingControl = sqView.AllocateRenderingControl(); // allocate proper control for the subquery view we want to use
return(RenderingControl);
}
/// <summary>
/// Don't show default dockmanager menu, substitute our custom menu instead
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DockManager_PopupMenuShowing(object sender, PopupMenuShowingEventArgs e)
{
e.Cancel = true; // cancel default menu
DockPanel dp = e.Control as DockPanel;
if (dp == null)
{
return;
}
DockPanel dp2 = dp;
while (dp2.Count > 0 && dp2.ActiveChild != null) // dp may be a tab container, if so get active child
{
dp2 = dp2.ActiveChild;
}
ResultsViewProps view = dp2.Tag as ResultsViewProps;
if (view == null)
{
return;
}
ContextMenuStrip menu = view.GetContextMenuStrip();
if (menu == null)
{
return;
}
menu.Show(dp, e.Point);
}
/// <summary>
/// Setup subquery with and QueryManger and execute the search step with the proper set of results keys from the parent query
/// </summary>
/// <param name="sq"></param>
/// <param name="view"></param>
/// <returns></returns>
QueryManager SetupAndExecuteSecondaryQuery(
Query sq,
ResultsViewProps view)
{
//sq.ResultKeys = Qm.DataTableManager.ResultsKeys;
//sq.UseResultKeys = true;
QueryEngine qe = new QueryEngine();
Query nq;
List <string> resultKeys = qe.TransformAndExecuteQuery(sq, out nq);
if (nq != null)
{
sq = nq; // if modified then replace original query and QE with the new ones
}
QueryManager sqm = new QueryManager();
OutputDest outputDest = OutputDest.WinForms;
QueryExec.InitializeQueryManager(sqm, sq, outputDest, qe, resultKeys);
DataTableManager dtm = sqm.DataTableManager;
sqm.QueryResultsControl = Qrc; // same query results control as us
//sq.Parent = Qm.Query; // set parent of subQuery;
return(sqm);
}
/// <summary>
/// Remove a subquery from its parent and optionally any associated views
/// </summary>
/// <param name="sq"></param>
/// <param name="removeResultsViews"></param>
/// <param name="removeResultsPagesIfEmpty"></param>
public static void RemoveSubQuery(
Query sq,
bool removeResultsViews,
bool removeResultsPagesIfEmpty)
{
if (sq == null)
{
throw new Exception("Null subquery");
}
Query pq = sq.Parent;
if (pq == null || !pq.Subqueries.Contains(sq))
{
throw new Exception("Subquery not contained in query");
}
sq.Parent = null;
pq.Subqueries.Remove(sq); // remove subquery from query
if (!removeResultsViews)
{
return;
}
ResultsPages rPages = pq.ResultsPages; // overall results pages
sq.ResultsPages = null;
List <ResultsViewProps> rViews = sq.GetResultsViews();
if (rViews != null) // any views for subquery?
{
for (int vi = 0; vi < rViews.Count; vi++)
{ // remove any views from overall query ResultsPages
ResultsViewProps rv = rViews[vi];
if (rv == null || rv.ResultsPage == null)
{
continue;
}
ResultsPage rp = rv.ResultsPage;
if (rp == null || !rp.Views.Contains(rv))
{
continue;
}
rp.Views.Remove(rv);
if (removeResultsPagesIfEmpty && rp.Views.Count == 0 && // remove page if empty & requested
rPages != null && rPages.Pages != null && rPages.Pages.Contains(rp))
{
rPages.Remove(rp);
}
}
}
}
/// <summary>
/// Tentatively add a new view of the specified type to the current page
/// </summary>
/// <param name="chartType"></param>
/// <returns></returns>
ResultsViewProps AddTentativeNewView(ResultsViewType viewType)
{
int intVal, max;
DialogResult = DialogResult.OK; // close the selection menu
Hide();
SessionManager.ActivateShell();
ResultsViewProps view = AddViewHelper.AddTentativeNewView(viewType, Qm.Query, Qrc);
return(view);
}
static void RemoveTentativeView(
ResultsViewProps view,
QueryResultsControl qrc)
{
ResultsPage page = view.ResultsPage;
page.Views.Remove(view);
int qti = qrc.Tabs.SelectedTabPageIndex;
qrc.RemoveTabAndPage(qti);
}
/// <summary>
/// Custom DockPanel button clicked
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ViewDockPanel_CustomButtonClick(object sender, ButtonEventArgs e)
{
DockPanel dp, pp;
dp = sender as DockPanel;
if (dp == null)
{
return;
}
CustomHeaderButton chb = e.Button as CustomHeaderButton;
if (dp == null || chb == null)
{
return;
}
string buttonName = (chb.Tag != null) ? chb.Tag.ToString() : "";
if (buttonName == "Maximize") // convert parent panel to tabbed form
{
if (dp.ParentPanel == null)
{
return;
}
CreateStandardLayoutAndRenderViews(ViewLayout.Tabbed);
}
else if (buttonName == "Close")
{
DockPanel dp2 = dp;
while (dp2.HasChildren && dp2.ActiveChild != null) // dp may be a tab container, if so get active child
{
dp2 = dp2.ActiveChild;
}
ResultsViewProps view = dp2.Tag as ResultsViewProps;
if (view == null)
{
return;
}
CloseView(view);
return;
}
else
{
return; // shouldn't happen
}
}
/// <summary>
/// Show the specified query in a new PopupResults form
/// </summary>
/// <param name="qm"></param>
/// <param name="html"></param>
/// <param name="title"></param>
public static void ShowHtml( // navigate browser to a document
QueryManager qm,
string html,
string title)
{
string uri;
int pi;
Progress.Hide(); // hide any progress so popup gets focus
uri = ClientDirs.TempDir + @"\PopupResults" + "1" + ".htm";
StreamWriter sw = new StreamWriter(uri);
sw.Write(html);
sw.Close();
PopupResults pr = new PopupResults();
UIMisc.PositionPopupForm(pr);
pr.Text = title;
QueryResultsControl qrc = pr.QueryResultsControl;
qm.LinkMember(qrc);
Query q = qm.Query;
qrc.BuildResultsPagesTabs(q);
for (pi = 0; pi < q.ResultsPages.Pages.Count; pi++)
{
ResultsPage page = q.ResultsPages.Pages[pi];
for (int vi = 0; vi < page.Views.Count; vi++)
{
ResultsViewProps view = page.Views[vi];
if (view.ViewType == ResultsViewType.HtmlTable)
{
view.Title = title;
view.ContentUri = uri; // plug in file name for uri
}
}
}
pr.Show();
qrc.ConfigureResultsPage(0); // render the first page
UIMisc.BringFormToFront(pr);
return;
}
/// <summary>
/// Show dialog for initial view setup
/// </summary>
/// <returns></returns>
public override DialogResult ShowInitialViewSetupDialog()
{
DialogResult dr;
QueryColumn qc = null;
if (SubQueryId < 0)
{
QueryViewSelectorDialog qvsd = new QueryViewSelectorDialog();
qvsd.QuerySelectorControl.ShowCurrentQueryMenuItem = false;
dr = qvsd.ShowDialog(this.SubQuery, "");
if (dr == DialogResult.Cancel)
{
return(DialogResult.Cancel);
}
SubQuery = qvsd.SelectedQuery;
if (SubQuery == null)
{
return(DialogResult.Cancel);
}
SubQuerySelectedView = qvsd.SelectedView;
if (SubQuerySelectedView == null)
{
return(DialogResult.Cancel);
}
SubQueryId = SubQuery.UserObject.Id;
SubQuerySelectedViewId = SubQuerySelectedView.Id;
}
if (SubQuerySelectedView == null)
{
RealizeSubQueryView();
}
if (SubQuerySelectedView == null)
{
return(DialogResult.Cancel); // no view realized
}
string defaultViewTitle = ResultsViewProps.GetViewTypeLabel(SubQuerySelectedView.ViewType);
// Setup done here, realization of query results and the view happens in ConfigureRenderingControl
dr = ToolHelper.InvokeToolBasedInitialViewSetupDialog(SubQuery, BaseQuery);
return(dr);
}
/// <summary>
/// SetupDockPanel
/// </summary>
/// <param name="dp"></param>
/// <param name="view"></param>
void SetupDockPanel(
DockPanel dp,
ResultsViewProps view,
XtraPanel viewPanel)
{
dp.Options.AllowFloating = false;
dp.Options.FloatOnDblClick = false;
dp.Options.ShowMaximizeButton = false;
dp.Options.ShowAutoHideButton = false;
dp.Options.ShowCloseButton = false;
ButtonCollection chbs = dp.CustomHeaderButtons;
chbs.Clear();
CustomHeaderButton chb = new CustomHeaderButton // add close button
("", null, 2, HorizontalImageLocation.Default, ButtonStyle.PushButton, "Close", false, -1, true, null, true, false, true, null, null, "Close", -1);
chbs.Add(chb);
chb = new CustomHeaderButton // add maximize button
("", null, 0, HorizontalImageLocation.Default, ButtonStyle.PushButton, "Maximize", false, -1, true, null, true, false, true, null, null, "Maximize", -1);
chbs.Add(chb);
dp.CustomButtonClick += new ButtonEventHandler(ViewDockPanel_CustomButtonClick);
dp.Enter += new EventHandler(ViewDockPanel_Enter); // when dock panel is selected
dp.Leave += new EventHandler(ViewDockPanel_Leave); // when dock panel loses focus
dp.VisibilityChanged += new VisibilityChangedEventHandler(ViewDockPanel_VisibilityChanged);
dp.ClosedPanel += new DockPanelEventHandler(ViewDockPanel_ClosedPanel); // when dock panel is closed
dp.MouseClick += new MouseEventHandler(ViewDockPanel_Click);
dp.Tag = view; // link the dockpanel to the view
dp.Text = view.Title; // set the view title
int vi = view.GetViewIndex();
if (dp.Text == "")
{
dp.Text = "View " + (vi + 1);
}
dp.Name = dp.Text;
dp.ControlContainer.Controls.Add(viewPanel); // put the view panel in the dock panel
return;
}
/// <summary>
/// Changes cancelled, restore state
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CancelButton_Click(object sender, EventArgs e)
{
ResultsViewProps.DeserializeChartProperties(OriginalChartState, View.BaseQuery, View); // restore previous state
if (View.ConfigureCount != OriginalConfigureCount) // reconfigure if config changed
{
View.ConfigureRenderingControl();
}
else if (View.RefreshCount != OriginalRefreshCount) // refresh if other change
{
View.Refresh();
}
DialogResult = DialogResult.Cancel;
return;
}
/// <summary>
/// Use view ids stored in DockPanel hints to restore the associated view
/// </summary>
void RestoreViewsFromHints(
bool setView,
bool clearHint)
{
return; // noop
#if false
int id;
foreach (DockPanel dp0 in DockManager.Panels)
{
if (setView)
{
dp0.Tag = null;
}
string hint = dp0.Hint;
if (clearHint)
{
dp0.Hint = "";
}
if (Lex.IsNullOrEmpty(hint))
{
continue;
}
if (!int.TryParse(hint, out id))
{
continue;
}
if (setView)
{
ResultsViewProps v = ResultsPage.GetViewFromIdForPage(id);
if (v != null)
{
dp0.Tag = v;
}
}
}
return;
#endif
}
/// <summary>
/// Update zoom value
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ZoomSlider_ValueChanged(object sender, EventArgs e)
{
int ctlVal = ZoomSliderCtl.Value; // ranges 0 - 100
int pct = SliderValToPctVal(ctlVal);
ZoomPctBarItem.Caption = pct + "%";
if (Qrc == null)
{
return;
}
ResultsViewProps view = Qrc.CurrentView;
if (view != null)
{
view.ScaleView(pct);
}
return;
}
/// <summary>
/// Copy view ids to hints so they get serialized
/// </summary>
void CopyViewIdsToHints()
{
return; // noop
#if false
foreach (DockPanel dp0 in DockManager.Panels)
{
ResultsViewProps view = dp0.Tag as ResultsViewProps;
if (view != null)
{
dp0.Hint = view.IdForPage.ToString();
}
else
{
dp0.Hint = "";
}
}
return;
#endif
}
/// <summary>
/// Show the dialog and create and display the chart
/// </summary>
/// <param name="chartEx"></param>
/// <param name="tabName"></param>
/// <returns></returns>
public static DialogResult ShowDialog(
ResultsViewProps view,
string tabName)
{
DialogResult dr;
if (Instance == null)
{
Instance = new AssayResultsHeatMapDialog();
}
AssayResultsHeatMapDialog i = Instance;
i.View = view as AssayResultsHeatMapView;
i.Qrc = QueryResultsControl.GetQrcThatContainsControl(view.RenderingControl);
if (!view.IsDefined) // initialize first time
{
i.Initializing = true;
dr = i.InitializeChart();
if (dr == DialogResult.Cancel)
{
return(dr);
}
}
else
{
i.Initializing = false;
}
i.Qm1 = view.BaseQuery.Parent.QueryManager as QueryManager; // root Qm
i.Qm2 = view.BaseQuery.QueryManager as QueryManager; // Qm for summarized data
i.SetupForm();
dr = i.ShowDialog(SessionManager.ActiveForm);
return(dr);
}
public ComboBoxViewItem(ResultsViewProps view)
{
View = view;
}
/// <summary>
/// Create a new view of the specified type
/// </summary>
/// <param name="viewType"></param>
/// <returns></returns>
public ResultsViewProps NewResultsViewManager(
ResultsViewModel rvi)
{
ResultsViewProps view = null;
switch (rvi.ViewType)
{
case ResultsViewType.Table:
view = new MoleculeBandedGridViewManager();
break;
case ResultsViewType.HtmlTable:
view = new HtmlTableView();
break;
case ResultsViewType.PivotGrid:
view = new PivotGridView();
break;
case ResultsViewType.Spotfire:
view = new SpotfireViewManager(rvi);
break;
case ResultsViewType.ScatterPlot:
view = new SpotfireViewManager2(rvi);
break;
case ResultsViewType.BarChart:
view = new SpotfireViewManager2(rvi);
break;
default:
DebugLog.Message("Unrecognized view type: " + rvi.ViewType);
view = new ViewManager();
break;
//throw new Exception("Unrecognized view type: " + viewType);
//case ViewTypeMx.ScatterPlot:
// view = new ChartViewBubble();
// break;
//case ViewTypeMx.Heatmap:
// view = new ChartViewHeatmap();
// break;
//case ViewTypeMx.TargetSummaryUnpivoted:
// view = new TargetSummaryUnpivotedView();
// break;
//case ViewTypeMx.TargetSummaryPivoted:
// view = new TargetSummaryPivotedView();
// break;
//case ViewTypeMx.TargetTargetTable:
// view = new TargetTargetPivotedView();
// break;
//case ViewTypeMx.TargetSummaryImageMap:
// view = new TargetSummaryImageMapView();
// break;
//case ViewTypeMx.TargetSummaryHeatmap:
// view = new TargetSummaryHeatmapView();
// break;
}
// Set some key values if not already set by the specifice view manager constructor
if (view.ViewType == ResultsViewType.Unknown)
{
view.ViewType = rvi.ViewType;
}
if (Lex.IsUndefined(view.ViewSubtype))
{
view.ViewSubtype = rvi.ViewSubtype;
}
if (Lex.IsUndefined(view.CustomViewTypeImageName))
{
view.CustomViewTypeImageName = rvi.CustomViewTypeImageName;
}
if (Lex.IsUndefined(view.Title))
{
view.Title = rvi.Title;
}
if (view.BaseQuery == null)
{
view.BaseQuery = rvi.Query;
}
return(view);
}
/// <summary>
/// Tentatively add a new view of the specified type to the current page
/// </summary>
/// <param name="viewType"></param>
/// <param name="query"></param>
/// <param name="qrc"></param>
/// <returns></returns>
private static ResultsViewProps AddTentativeNewView(
ResultsViewModel rvm)
{
ResultsPage rp;
DialogResult dr;
int intVal, max;
ResultsViewType viewType = rvm.ViewType;
string viewSubtype = rvm.ViewSubtype;
string viewTitle = rvm.Title;
Query query = rvm.Query;
QueryResultsControl qrc = rvm.QueryResultsControl as QueryResultsControl;
LastAddedViewType = viewType;
int pi = qrc.CurrentPageIndex;
if (pi < 0 || // add a page if no pages
query.Root.ResultsPages.Pages[pi].Views.Count > 0) // or (for now) already a view on the current page
{
rp = ResultsPages.AddNewPage(query);
pi = query.Root.ResultsPages.Pages.Count - 1;
qrc.AddResultsPageTabPage(rp);
}
ResultsPage page = query.ResultsPages[pi];
ResultsViewProps view = page.AddNewView(rvm);
if (view == null)
{
throw new Exception("Failed to add new view: " + viewType);
}
//view.CustomViewTypeImageName = rvm.CustomViewTypeImageName; // (should already be set)
if (Lex.IsDefined(viewTitle) && Lex.Ne(viewTitle, viewType.ToString()))
{
view.Title = page.AddSequentialSuffixToTitle(viewTitle, query.ResultsPages); // set custom title (sequentially-numbered) if defined
}
qrc.SetCurrentPageTabTitleAndImage();
dr = view.ShowInitialViewSetupDialog();
if (dr != DialogResult.OK)
{
RemoveTentativeView(view, qrc);
return(null); // not added
}
qrc.ConfigureResultsPage(page); // render the default view in the current page
dr = view.ShowInitialViewPropertiesDialog();
if (dr == DialogResult.OK)
{
//view.ConfigureRenderingControl(); // be sure it's configured (not a good idea, adds overhead)
qrc.SetCurrentPageTabTitleAndImage(); // update tab title & image accordingly
return(view);
}
else // cancelled, remove view
{
RemoveTentativeView(view, qrc);
return(null); // not added
}
}
/// <summary>
/// Render the views in prebuilt DockPanel layout
/// </summary>
internal void RenderViews()
{
ResultsViewProps view = null;
XtraPanel viewPanel; // panel that contains current view control and is contained in a docking panel or directly in the views panel if single view on page
DockPanel activePanel = null;
ResultsPage page = ResultsPage;
if (page == null)
{
return;
}
List <ResultsViewProps> views = page.Views;
if (views.Count == 0) // just have a single blank panel if no views
{
RenderEmptyPage();
return;
}
// See if single view without DockPanels
else if (ResultsPage.Views.Count == 1 && Controls.Count == 1 && Controls[0] is XtraPanel)
{
view = ResultsPage.Views[0];
viewPanel = Controls[0] as XtraPanel;
ConfigureViewInPanel(view, viewPanel);
return;
}
// Scan the set of DockPanels and render the view associated with each panel
else
{
DockManager dm = DockManager;
foreach (DockPanel dp0 in dm.Panels)
{
view = dp0.Tag as ResultsViewProps;
if (view == null)
{
continue;
}
Control.ControlCollection cc = dp0.ControlContainer.Controls;
cc.Clear();
viewPanel = new XtraPanel(); // the panel that will contain the view control
viewPanel.Dock = DockStyle.Fill;
viewPanel.BackColor = Color.White;
cc.Add(viewPanel);
ConfigureViewInPanel(view, viewPanel);
SetupDockPanel(dp0, view, viewPanel);
if (view == page.ActiveView)
{
activePanel = dp0; // save ref to active panel
}
}
if (activePanel != null)
{
DockManager.ActivePanel = activePanel;
}
return;
}
}
/// <summary>
/// Layout views in even rows and columns
/// </summary>
void CreateRowsAndColsLayoutAndRenderViews()
{
DockPanel dp, rowDp, lastRp = null, lastDp = null, activePanel = null;
int vi, ri, ci;
if (ResultsPage.Views.Count < 3) // if less than three views do a simple side by side
{
CreateCommonLayoutAndRenderViews(ViewLayout.SideBySide);
return;
}
DockManager dm = DockManager;
dm.Clear();
Controls.Clear();
int pc = dm.Panels.Count;
int rpc = dm.RootPanels.Count;
List <ResultsViewProps> views = ResultsPage.Views;
if (views.Count == 0)
{
return;
}
double d = Math.Sqrt(views.Count);
if ((int)d != d)
{
d += 1;
}
int cols = (int)d;
if (cols < 1)
{
cols = 1;
}
int rows = (views.Count + (cols - 1)) / cols;
if (rows < 1)
{
rows = 1;
}
int width = (int)(Width / (double)cols + .5);
int height = (int)(Height / (double)rows + .5);
DockPanel masterPanel = null;
List <DockPanel> rowPanels = new List <DockPanel>();
List <DockPanel> viewPanels = new List <DockPanel>();
// Create master panel and one panel per row
for (ri = 0; ri < rows; ri++)
{
if (ri == 0) // first row, create first panel
{
dp = dm.AddPanel(DockingStyle.Left);
}
else if (ri == 1) // 2nd row, add panel to first panel create row splitter
{
dp = rowPanels[0].AddPanel();
masterPanel = dm.RootPanels[0];
masterPanel.Size = Size;
//masterPanel.DockVertical = DefaultBoolean.False; // (not needed)
}
else // subsequent row, add panel to row splitter
{
dp = masterPanel.AddPanel();
}
rowPanels.Add(dp);
}
// Add column/cell panel members to each row panel
for (vi = 0; vi < views.Count; vi++)
{
ri = vi / cols;
ci = vi % cols;
DockPanel rp = rowPanels[ri];
if (ci == 0) // first col, create first panel
{
dp = rp; // get single panel
}
else if (ci == 1) // 2nd col, add panel to first panel create splitter to contain cell panels
{
dp = rp.AddPanel();
rp = rowPanels[ri] = dp.ParentPanel; // store new parent
//rp.DockVertical = DefaultBoolean.True; // (not needed)
}
else // subsequent row, add panel to row splitter
{
dp = rp.AddPanel();
}
viewPanels.Add(dp);
lastDp = dp;
ResultsViewProps view = views[vi];
XtraPanel viewPanel = new XtraPanel(); // the panel that will contain the view control, goes into a DockPanel or directly into the viewsPanel if only one view
viewPanel.Dock = DockStyle.Fill; // it will fill its containing panel
SetupDockPanel(dp, view, viewPanel);
if (ResultsPage.ActiveViewIndex == vi)
{
activePanel = dp;
}
}
if (activePanel != null) // set the active panel
{
dm.ActivePanel = activePanel;
}
ResultsPage.LastLayout = ViewLayout.RowsAndCols;
return;
}
/// <summary>
/// Close the specified view
/// </summary>
/// <param name="view"></param>
internal void CloseView(ResultsViewProps view)
{
ViewsPanel.CloseView(view);
}
