/// <summary> /// Update depiction style /// </summary> /// <param name="psc"></param> public void UpdateDepictions(ParsedStructureCriteria psc) { SmallWorldPredefinedParameters swp = psc.SmallWorldParameters; // new values if (Qm == null || Qm.ResultsFormatter == null || Qm.ResultsFormatter.StructureHighlightPssc == null || Qm.ResultsFormatter.StructureHighlightPssc.SmallWorldParameters == null) { return; } ResultsFormatter fmtr = Qm.ResultsFormatter; SmallWorldPredefinedParameters swp2 = // current view values fmtr.StructureHighlightPssc.SmallWorldParameters; psc.Highlight = swp2.Highlight = swp.Highlight; psc.Align = swp2.Align = swp.Align; int i = SmallWorldData.GetSvgOptionsIndex(swp2.Highlight, swp2.Align); SmallWorldDepictions d = fmtr.SmallWorldDepictions; if ((swp.Highlight || swp.Align) && d != null && i != 0 && d.SvgDict[i] == null) // need to start retrieval for depiction type we don't alread have? { d.StartDepictionRetrieval(Qm, psc.QueryColumn, swp2.Highlight, swp2.Align); return; // leave display as is for now } else // clear current decpiction so new one shows { Qm.DataTableManager.ResetFormattedValues(psc.QueryColumn); // clear existing bitmaps Qm.MoleculeGrid.RefreshDataSource(); } return; }
/// <summary> /// Setup the QueryManager members for the specified query /// </summary> /// <param name="q"></param> /// <param name="rf"></param> /// <param name="qe"></param> /// <param name="resultsKeys"></param> public void Initialize( Query q, ResultsFormat rf, QueryEngine qe, List <string> resultsKeys) { QueryManager qm = this; qm.Query = q; // query ResultsFormat = null; ResultsFormatter = null; DataTableManager = null; DataTable = null; CompleteInitialization(rf); q.ResultKeys = resultsKeys; // set keys for quick search qm.DataTableManager.ResultsKeys = resultsKeys; qm.QueryEngine = qe; // qe2; // update the QM with the new QE qm.LinkMembers(); return; }
/// <summary> /// Build unpivoted subquery QueryManager including the DataTableManger, /// ResultsFormat and ResultsFormatter. /// Build empty DataTable /// </summary> /// <returns></returns> QueryManager InitializeUnpivotedSubqueryQm() { Query q2 = null; DataTableManager dtm2; DataTableMx dt2; ResultsFormat rf2; ResultsFormatFactory rff; ResultsFormatter rfmtr; QueryTable qt; MetaTable mt; QueryManager qm2 = new QueryManager(); // build output query here // Setup unpivoted output query q2 = new Query(qm2); mt = MetaTableCollection.GetWithException(MultiDbAssayDataNames.CombinedNonSumTableName); qt = new QueryTable(q2, mt); // be sure proper cols are selected dtm2 = new DataTableManager(qm2); dt2 = DataTableManager.BuildDataTable(qm2); rff = new ResultsFormatFactory(qm2, OutputDest.WinForms); rff.Build(); rfmtr = new ResultsFormatter(qm2); return(qm2); }
/// <summary> /// Render the view by configuring the control for the current view settings /// </summary> public override void ConfigureRenderingControl() { if (Qm == null) { return; } MoleculeGridControl grid = GridPanel.SelectBaseGridViewGrid(Qm); Qm.LinkMember(grid); // link grid into qm DataTableMx dt = Qm.DataTable; // save ref to data table grid.DataSource = null; // clear source for header build Qm.DataTable = dt; // restore data table in qm grid.ShowCheckMarkCol = BaseQuery.ShowGridCheckBoxes; grid.FormatGridHeaders(Qm.ResultsFormat); // qm.MoleculeGrid.V.Columns.Count should be set for proper cols grid.Visible = true; // now visible Qrc.MoleculeGridPageControl = GridPageControl; // link query results to this page GridPanel.SetDataSource(Qm, dt); ResultsFormatter fmtr = Qm.ResultsFormatter; if (fmtr != null && fmtr.FormattingStarted && !fmtr.BrowseExistingResults) // if already formatting need to start grid display { grid.StartDisplay(); } ConfigureCount++; return; }
/// <summary> /// Method to get bitmap /// </summary> /// <param name="index"></param> /// <returns></returns> private GetImageBitmapArgs GetImageBitmap(CellInfo ci, DataRowMx dr, int listSourceRowIndex, object fieldValue, ImageMx imageMx, int callId) { DateTime t0 = DateTime.Now; QueryManager qm = Grid.QueryManager; ResultsFormatter fmtr = qm.ResultsFormatter; FormattedFieldInfo ffi = fmtr.FormatField(ci.Rt, ci.TableIndex, ci.Rfld, ci.FieldIndex, dr, listSourceRowIndex, fieldValue, ci.DataRowIndex, false); if (ffi.FormattedBitmap == null) { ffi.FormattedBitmap = new Bitmap(1, 1); } imageMx.FormattedBitmap = ffi.FormattedBitmap; // store ref to bitmap imageMx.Value = imageMx.FormattedBitmap; // value is also the bitmap imageMx.IsRetrievingValue = false; // retrieve is complete StoreFormattingInformationInMdt(ffi, fieldValue, dr, ci, imageMx); //if (Debug) ClientLog.Message("GetImageBitmap complete for callId: " + callId + ", Time(ms) = " + TimeOfDay.Delta(t0)); GetImageBitmapArgs a = new GetImageBitmapArgs(); a.ci = ci; a.dr = dr; a.listSourceRowIndex = listSourceRowIndex; a.fieldValue = fieldValue; a.imageMx = imageMx; a.callId = callId; return(a); }
/// <summary> /// Free resources linked to this instance /// </summary> public void Dispose() { try { DisposeOfControls(); if (Query != null) { Query.FreeControlReferences(); // just free control references } if (MoleculeGrid != null) { MoleculeGrid.Dispose(); } if (QueryEngine != null) { QueryEngine.Dispose(); } if (DataTableManager != null) { DataTableManager.Dispose(); } if (ResultsFormat != null) { ResultsFormat.QueryManager = null; } if (ResultsFormatter != null) { ResultsFormatter.QueryManager = null; } if (StatusBarManager != null) { StatusBarManager.QueryManager = null; } if (QueryExec != null) { QueryExec.QueryManager = null; } QueryResultsControl = null; Query = null; DataTableManager = null; DataTable = null; ResultsFormat = null; ResultsFormatter = null; StatusBarManager = null; MoleculeGrid = null; QueryExec = null; QueryEngine = null; } catch (Exception ex) { DebugLog.Message(DebugLog.FormatExceptionMessage(ex)); } }
/// <summary> /// Create a QueryManager and associated objects from the specified Query and DataTable /// </summary> /// <param name="q"></param> /// <param name="dt"></param> /// <returns></returns> public static QueryManager SetupQueryManager( Query q, DataTableMx dt) { QueryManager qm = new QueryManager(); qm.LinkMember(q); qm.LinkMember(dt); DataTableManager dtm = new DataTableManager(qm); ResultsFormatFactory rff = new ResultsFormatFactory(qm, OutputDest.WinForms); rff.Build(); // builds format ResultsFormatter fmtr = new ResultsFormatter(qm); qm.DataTableManager.InitializeRowAttributes(); qm.DataTableManager.SetRowRetrievalStateComplete(); return(qm); }
/// <summary> /// Get formatted text value for field /// </summary> /// <param name="qc"></param> /// <param name="mdt"></param> /// <returns></returns> internal string GetFormattedText(QueryColumn qc, MobiusDataType mdt) { if (qc == null || mdt == null) { return(""); } else if (mdt.FormattedText != null) { return(mdt.FormattedText); } ResultsFormatter fmtr = Qm.ResultsFormatter; FormattedFieldInfo ffi = fmtr.FormatField(qc, mdt); if (ffi.FormattedText == null) { ffi.FormattedText = ""; } mdt.FormattedText = ffi.FormattedText; // store back in the field return(mdt.FormattedText); }
/// <summary> /// Complete any missing base QueryManager entries with default values /// Note: graphics control entries are not initialized /// </summary> public void CompleteInitialization(ResultsFormat rf) { if (Query == null) { throw new Exception("Query not defined"); } if (rf == null) { throw new Exception("ResultsFormat not defined"); } QueryManager qm = this; ResultsFormat = rf; ResultsFormatFactory fmtFactory = new ResultsFormatFactory(qm, rf); fmtFactory.Build(); // build ResultsFormat ResultsFormatter fmtr = qm.ResultsFormatter; if (fmtr == null) // be sure we have a results formatter { fmtr = new ResultsFormatter(qm); } DataTableManager dtm = DataTableManager; if (dtm == null) // build DataTableManager and DataTableMx { dtm = new DataTableManager(qm); } if (qm.DataTable == null || qm.DataTable.Columns.Count == 0) { qm.DataTable = DataTableManager.BuildDataTable(qm.Query); // build data table to receive data } return; }
/// <summary> /// This method runs in a background process and exports data to the specified destination /// </summary> /// <param name="objectIdString">Id of UserObject containing run parameters in a serialized ResultsFormat</param> /// <param name="templateFileName">Name of template file to use</param> /// <param name="emailResultsHtml">If true then send email otherwise just return html</param> /// <returns></returns> public static string RunBackgroundExport( string objectIdString, string templateFileName, bool emailResultsHtml, out bool copiedToDestinationFile, int alertId = 0) { ResultsFormat rf; Query q; string msg = ""; int objId; //if (ClientState.IsDeveloper) //{ // ServicesLog.Message(SS.I.UserName + ": BackgrounExport Debug"); // //DataTableManager.AllowCaching = false; // DataTableManager.DebugBasics = true; // DataTableManager.DebugCaching = true; //} if (String.IsNullOrEmpty(templateFileName)) { templateFileName = "MobiusBackgroundExportEmailTemplate.htm"; } ServicesLog.Message("RunBackgroundExport started: UserObject id = " + objectIdString); string emailSubject = UmlautMobius.String + " background export results"; copiedToDestinationFile = false; try { if (!int.TryParse(objectIdString, out objId)) { throw new Exception("Invalid UserObjectId"); } UserObject uo = UserObjectDao.Read(objId); if (uo == null) { throw new Exception("UserObject not found"); } QueryManager qm = new QueryManager(); rf = ResultsFormat.Deserialize(uo.Content); if (rf == null) { throw new Exception("Failed to deserialize ResultsFormat"); } string clientFile = rf.OutputFileName; // ultimate file we want to go to rf.OutputFileName = GetServerFileName(rf, objId); // get file name to export to on server & use here temporarily qm.ResultsFormat = rf; rf.QueryManager = qm; q = QbUtil.ReadQuery(rf.QueryId); if (q == null) { throw new Exception("Failed to read query: " + rf.QueryId); } q.IncludeRootTableAsNeeded(); qm.Query = q; q.QueryManager = qm; emailSubject += " for query " + Lex.Dq(q.UserObject.Name); // include query name in subject ResultsFormatFactory rff = new ResultsFormatFactory(rf); rff.Build(); ResultsFormatter fmtr = new ResultsFormatter(qm); DataTableManager dtm = new DataTableManager(qm); dtm.BeginCaching(); // allow caching of DataTable dtm.PurgeDataTableWithoutWritingToCacheFile = true; // skip actual writing of cache since it won't be read back in qm.DataTableManager = dtm; qm.DataTable = DataTableManager.BuildDataTable(rf.Query); // build data table to receive data QueryExec qex = new QueryExec(rf); msg = qex.RunQuery3(rf, false, false); // do the export int compoundCount = 0; int rowCount = 0; QueryEngine qe = qex.QueryEngine; if (qe != null) { compoundCount = qm.DataTableManager.KeyCount; rowCount = qm.DataTableManager.TotalRowsTransferredToDataTable; // use this for accurate row count } dtm.EndCaching(); // close cache file (note: resets key/row counts) if (compoundCount <= 0 || rowCount <= 0) // any results { msg = "Query " + Lex.Dq(q.UserObject.Name) + " returned no results."; Email.Send( null, SS.I.UserInfo.EmailAddress, emailSubject, msg); return(msg); } if (ServerFile.CanWriteFileFromServiceAccount(clientFile)) { // copy to dest file if possible try { FileUtil.CopyFile(rf.OutputFileName, clientFile); copiedToDestinationFile = true; rf.OutputFileName = clientFile; } catch (Exception ex) { ServicesLog.Message("Error copying file from service account: " + clientFile + "\n" + DebugLog.FormatExceptionMessage(ex)); } } string viewCmd = "Retrieve Background Export " + uo.Id; msg = "RunBackgroundExport ended: UserObjectId = " + objectIdString; if (emailResultsHtml) { MailBackgroundExportResults( q, clientFile, rowCount, compoundCount, copiedToDestinationFile, viewCmd, SS.I.UserInfo.EmailAddress, emailSubject, templateFileName); ServicesLog.Message(msg); return(msg); } else // just fill in values & return { string html = ReadTemplateFile(templateFileName); html = SubstituteBackgroundExportParameters( html, "", rf.OutputFileName, rowCount, compoundCount, copiedToDestinationFile, viewCmd); ServicesLog.Message(msg); return(html); } } catch (Exception ex) { if (alertId > 0) { msg += "Alert: " + alertId + " "; } msg += "RunBackgroundExport exception: BackgroundExportId = " + objectIdString + ",\r\n" + DebugLog.FormatExceptionMessage(ex); Email.Send( null, SS.I.UserInfo.EmailAddress, emailSubject, msg); ServicesLog.Message(msg); return(msg); } }
/// <summary> /// Handle conversion of Mobius custom data types between the grid and the underlying DataSet /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void ProcessCustomUnboundColumnDataEvent(object sender, CustomColumnDataEventArgs e) { MobiusDataType mdt = null; FormattedFieldInfo ffi = null; bool formatted = false; NumberMx numberEx; StringMx stringEx; ImageMx imageMx; DateTimeMx dateTimeEx; DataRowMx dr = null; BandedGridView mbgv; int nonNullDri; string debugMsg; if (DebugMx.False) // fillValuesImmediately debug test { e.Value = "XXX"; return; } DateTime t0 = DateTime.Now; int callId = ++UnboundCalls; // get id for this call if (sender is BandedGridView) { mbgv = sender as BandedGridView; } if (Grid.DataSource == null) { return; } CellInfo ci = Grid.GetDataTableCellInfo(e.ListSourceRowIndex, e.Column); //if (e.ListSourceRowIndex == 2 && ci.DataRowIndex == 1) e = e; // debug //if (ci.Mc.DataType == MetaColumnType.CompoundId && ci.DataRowIndex > 0) ci = ci; // debug //DebugLog.Message("CustomUnboundColumnData " + ci.DataRowIndex + ", " + ci.DataColIndex + ", " + ci.DataValue.ToString()); if (ci.Rfld == null) { return; } QueryManager qm = Grid.QueryManager; ResultsFormatter fmtr = qm.ResultsFormatter; ResultsFormat rf = qm.ResultsFormat; if (e.ListSourceRowIndex == GridControl.NewItemRowHandle || e.ListSourceRowIndex >= Qm.DataTable.Rows.Count) // new row being created { if (NewRow == null) { NewRow = Qm.DataTable.NewRow(); } dr = NewRow; } else if (e.ListSourceRowIndex >= 0 && ci.DataRowIndex >= 0) // row exist in DataTable (i.e. not new row) { AdjustDataRowToRender(ci); if (ci.DataRowIndex >= 0) { dr = DataTable.Rows[ci.DataRowIndex]; if (ci.DataRowIndex == 0) { } } } else { if (DebugDetails) { ClientLog.Message("Fail 1"); } return; // something else, ignore } // Store edited data for unbound column in DataTable if (e.IsSetData) { SetGridData(e, ci); return; } else if (!e.IsGetData) { return; // just return if not GetData as expected } // Get data from underlying unbound dataset & return in format for grid //if (ci.Mc.DataType == MetaColumnType.Structure) ci = ci; // debug //if (ci.Mc.DataType == MetaColumnType.String) ci = ci; // debug //if (ci.DataValue is StringEx && ((StringEx)ci.DataValue).Value == " ") ci = ci; // debug UnboundGets++; if (dr == null) { e.Value = null; if (DebugDetails) { ClientLog.Message("Fail 2"); // debug } return; } if (Dtm.IsRetrievingDataMessageRow(dr) && ci.Mc != null && !ci.Mc.IsGraphical) { //if (ci.Mc.IsKey) // show retrieving data message for key field e.Value = "Retrieving data..."; return; } object fieldValue = dr[ci.DataColIndex]; if (DebugDetails && fieldValue is MoleculeMx) // debug { MoleculeMx cs = fieldValue as MoleculeMx; MoleculeFormat csType = cs.PrimaryFormat; string csValue = cs.PrimaryValue; int csLen = cs.PrimaryValue.Length; string molfile = cs.GetMolfileString(); molfile = molfile; } try { // If already formatted use existing formatting info ffi = null; if (fieldValue is MobiusDataType) { mdt = (MobiusDataType)fieldValue; if (mdt.FormattedBitmap != null) { ffi = new FormattedFieldInfo(); ffi.FormattedBitmap = mdt.FormattedBitmap; } else if (mdt.FormattedText != null) { ffi = new FormattedFieldInfo(); ffi.FormattedText = mdt.FormattedText; } if (ffi != null) // if formatted then copy other format attributes as well { ffi.BackColor = mdt.BackColor; ffi.ForeColor = mdt.ForeColor; ffi.Hyperlink = mdt.Hyperlink; } } // If not formatted then format if (ffi == null) // need to format? { // Format non-image field (including structures) if (ci.Mc.DataType != MetaColumnType.Image) // format other than image immediately { //if (ci.Mc.DataType == MetaColumnType.Structure) // debug //{ // DebugLog.Message(fieldValue.ToString()); // UIMisc.Beep(); //} ffi = fmtr.FormatField(ci.Rt, ci.TableIndex, ci.Rfld, ci.FieldIndex, dr, e.ListSourceRowIndex, fieldValue, ci.DataRowIndex, false); FormatFieldCalls++; if (ci.Mc.DataType == MetaColumnType.Structure) { FormatStructureFieldCalls++; } StoreFormattingInformationInMdt(ffi, fieldValue, dr, ci, mdt); formatted = true; } // Image: start asynch call to get image in background as necessary since it is too slow to wait for it here else { if (fieldValue is ImageMx) { imageMx = fieldValue as ImageMx; } else { imageMx = new ImageMx(); if (fieldValue != null) { if (fieldValue is MobiusDataType) { imageMx.DbLink = (fieldValue as MobiusDataType).DbLink; } else { imageMx.DbLink = fieldValue.ToString(); // store field value as dblink } } dr.ItemArrayRef[ci.DataColIndex] = imageMx; // store new image object without firing event } mdt = imageMx; // copy image object to general MobiusDataType ffi = new FormattedFieldInfo(); if (imageMx.FormattedBitmap != null) // already have bitmap? { ffi.FormattedBitmap = imageMx.FormattedBitmap; } else if (imageMx.Value != null) // have the bitmap, just need to scale it { int fieldWidth = ci.Rfld.FieldWidth; // current field width in milliinches int desiredWidth = (int)((fieldWidth / 1000.0) * GraphicsMx.LogicalPixelsX * 1.0); // width in pixels imageMx.FormattedBitmap = BitmapUtil.ScaleBitmap(imageMx.Value, desiredWidth); ffi.FormattedBitmap = imageMx.FormattedBitmap; } else if (imageMx.IsRetrievingValue) // already retrieving? { ffi.FormattedBitmap = (Bitmap)RetrievingImageMsg.Image; // put up the processing image } else if (SS.I.AsyncImageRetrieval) // start async image retrieval { FormatImageFieldCalls++; GetImageBitmapAsync(ci, dr, e.ListSourceRowIndex, fieldValue, imageMx, callId); ffi.FormattedBitmap = (Bitmap)RetrievingImageMsg.Image; // put up the processing image } else // do synchronous image retrieval { GetImageBitmap(ci, dr, e.ListSourceRowIndex, fieldValue, imageMx, callId); ffi.FormattedBitmap = imageMx.FormattedBitmap; formatted = true; } } } //if (ci.Mc.DataType == MetaColumnType.CompoundId && String.IsNullOrEmpty(fmtdFld.Hyperlink)) ci = ci; // debug //if (mdt is CompoundId) mdt = mdt; // debug if (e.Column.ColumnEdit is RepositoryItemPictureEdit) { if (ffi != null && ffi.FormattedBitmap != null) { e.Value = ffi.FormattedBitmap; } else { e.Value = new Bitmap(1, 1); // avoid no-image data message } //ffi.FormattedBitmap.Save(@"c:\download\test.bmp"); // debug } else { e.Value = ffi.FormattedText; // non-picture column } if (ci.DataRowIndex == DataTable.Rows.Count - 1 && // if at end of DataTable && more rows available, request them !Dtm.RowRetrievalComplete) { //Progress.Show("Retrieving data..."); // put up progress dialog if not already up //if (WaitForMoreDataStartTime.Equals(DateTime.MinValue)) // say we've started waiting for data //{ // WaitForMoreDataStartTime = DateTime.Now; // ClientLog.Message("Set WaitForMoreDataStartTime: " + WaitForMoreDataStartTime.ToLongTimeString()); //} if (Dtm.RowRetrievalState == RowRetrievalState.Paused) { Dtm.StartRowRetrieval(); // .ReadNextRowsFromQueryEngine(); // restart retrieval } } else if (Lex.StartsWith(Progress.GetCaption(), "Retrieving data...") || Lex.IsUndefined(Progress.GetCaption())) { // hide any "Retrieving data..." message Progress.Hide(); //SystemUtil.Beep(); } Grid.LastRowRendered = e.ListSourceRowIndex; if (DebugDetails) { debugMsg = "Grid.GetData: " + callId + ", e.Row = " + e.ListSourceRowIndex + ", e.Col = " + e.Column.AbsoluteIndex + ", Formatted = " + (formatted ? "T" : "F") + ", Time(ms) = " + TimeOfDay.Delta(t0) + ", ColLabel = " + ci.Qc.ActiveLabel; debugMsg += ", FieldValue = "; if (fieldValue != null) { debugMsg += fieldValue.ToString(); } debugMsg += ", e.Value = "; if (e.Value != null) { debugMsg += e.Value.ToString(); } else { debugMsg += "null"; } ClientLog.Message(debugMsg); } // TODO: This does a some unnecessary hides which cause flashing of the window frame // This happens when we are not at the end of the DataTable but don't know if any additional requests // for rendering will occur. May be better to move this to DataTableManger when we detect // that we have retrieved a row that is below the level of those displayed in the grid or all rows have been retrieved. // Also maybe in MoleculeGridControl.RetrievalMonitorTimer_Tick } catch (Exception ex) { if (e.Column.ColumnEdit is RepositoryItemPictureEdit) { e.Value = new Bitmap(1, 1); // avoid no-image data message } else { e.Value = ex.Message; } string msg = "ColumnView_CustomUnboundColumnData Exception"; if (ci.Rfld != null) { msg += ", MetaColumn: " + ci.Rfld.MetaColumn.MetaTable.Name + "." + ci.Rfld.MetaColumn.Name; } msg += ", DataColIndex: " + ci.DataColIndex + ", DataRowIndex: " + ci.DataRowIndex; if (fieldValue != null) { msg += ", Value: " + fieldValue.ToString(); } ClientLog.Message(msg); } // t0 = TimeOfDay.Milliseconds() - t0; // ClientLog.Message("CustomUnboundColumnData event time: " + t0); }
/// <summary> /// Run the query /// </summary> /// <param name="browseExistingResults">If true browse existing results</param> /// <returns></returns> public string RunQuery3( ResultsFormat rf, bool saveHitlist, bool browseExistingResults) { Query modifiedQuery; QueryTable qt; QueryColumn qc; ResultsTable rt; ResultsField rfld; MetaTable mt; MetaColumn mc; string txt, msg; DialogResult dr; bool success; CellGraphic cg; Lex lex = new Lex(); string tempfile, tok, command, unrecognizedCommand, response; int ti, gi, rc, i1, i2; // Begin execution if (rf == null) { throw new Exception("QueryExec.Run - Null ResultsFormat"); } if (ResultsFormatter == null) { throw new Exception("QueryExec.Run - Null ResultsFormatter"); } if (rf.Segments == null) { throw new Exception("QueryExec.Run - Null ResultsFormat.Segments"); } if (Query == null) { throw new Exception("QueryExec.Run - Null Rf.Query"); } if (Query.Tables == null || Query.Tables.Count <= 0) { throw new QueryException("QueryExec.Run - No Query Tables"); } QueryManager qm = QueryManager; ReturnMsg = ""; //bool useExistingQueryEngine = Rf.ParentQe != null; //bool useExistingDataTable = Query.BrowseExistingResultsWhenOpened && Query.SerializeResults && // qm.DataTable != null && qm.DataTable.Rows.Count > 0; try { //if (Math.Sqrt(4) == 2) throw new Exception("test"); // debug if (!browseExistingResults) // normal open of search { Progress.Show("Analyzing query..."); // put up a status message to the user as soon as possible to let them know something is happening... dr = ValidateQuery(Query); if (dr == DialogResult.Cancel) { return(""); } WriteCurrentListToServerIfNeeded(Query); if (rf.OutputDestination == OutputDest.WinForms) // update access stats if grid { UpdateTableUsageStatistics(Query); } Query.ResultsDataTable = null; // be sure to get new results qm = BuildQueryManager(Query, rf); Query.ResetViewStates(); // reset state of views for proper operation if (Rf.ParentQe == null) // open search unless using existing query engine { if (!ExecuteSearch(saveHitlist)) // returns false if cancelled by user { Progress.Hide(); return(""); } } if ((ResultsKeys == null || ResultsKeys.Count == 0) && // nothing for search !Query.Preview && !MqlUtil.SingleStepExecution(Query) && qm.DataTable.Rows.Count == 0 && Query.RetrievesDataFromQueryEngine) { // if (!Rf.PopupDisplay) Progress.Hide(); if (qm.StatusBarManager != null) { qm.StatusBarManager.DisplayStatusMessage(""); } // if (QueryEngine.Cancelled) return ""; // cancelled by user msg = "No data have been found that matches your query."; if (ResultsFormat.PopupOutputFormContext && !ResultsFormat.SuppressNoDataMessage) { MessageBoxMx.Show(msg, "Search Result", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return("Command EditQuery"); // return to edit query menu } else { return(msg); } } //if (ResultsFormat.PopupDisplay) // SessionManager.DisplayStatusMessage("Retrieving data..."); //else Progress.Show("Retrieving data...", UmlautMobius.Value, true, "Cancelling Retrieval..."); //Progress.Show("Retrieving data...", UmlautMobius.String, true, "Cancelling Retrieval..."); Progress.Hide(); // hide progress - "Retrieving data..." message now appears as bottom line of grid if (ResultsFormat.Grid) { if (ResultsFormat.SessionOutputFormContext) // if normal main session form grid display, set browse mode & view state { Query.ResetViewStates(); // reset view state for all views QbUtil.SetMode(QueryMode.Browse, Query); if (ResultsFormat.Query.LogicType == QueryLogicType.And) // log grid query by logic type { UsageDao.LogEvent("QueryGridAnd", ""); } else if (ResultsFormat.Query.LogicType == QueryLogicType.Or) { UsageDao.LogEvent("QueryGridOr", ""); } else if (ResultsFormat.Query.LogicType == QueryLogicType.Complex) { UsageDao.LogEvent("QueryGridComplex", ""); } } else if (ResultsFormat.PopupOutputFormContext) // create popup window & configure { PopupResults.Show(qm); //MoleculeGridPanel.ConfigureAndShow(qm, null); } else if (ResultsFormat.ToolOutputFormContext) { ContainerControl cc; QueryResultsControl qrc = ResultsFormat.OutputContainerControl as QueryResultsControl; AssertMx.IsTrue(qrc != null, "ResultsFormat.OutputContainerControl must be a QueryResultsControl"); if (!WindowsHelper.FindContainerControl(qrc, typeof(ToolResultsContainer), out cc)) { throw new Exception("ToolResultsContainer not found"); } ToolResultsContainer trc = cc as ToolResultsContainer; trc.SetupQueryResultsControlForResultsDisplay(qm); } else { throw new Exception("Invalid OutputformContext: " + ResultsFormat.OutputFormContext); } } } else // reentering display switch to browse tab { QbUtil.SetMode(QueryMode.Browse, Query); } response = ResultsFormatter.BeginFormatting(browseExistingResults); // format the data if (ResultsFormat.SessionOutputFormContext) // normal display { if (MqlUtil.SingleStepExecution(Query)) { // be sure hit count display is up to date if (ResultsKeys != null) { if (qm.StatusBarManager != null) { qm.StatusBarManager.DisplayCurrentCount(); } } } if (saveHitlist) { CidList hitList = new CidList(ResultsKeys); rc = CidListCommand.WriteCurrentList(hitList); SessionManager.DisplayCurrentCount(); } } return(response); } // end of surrounding try catch (Exception ex) { Progress.Hide(); if (ex is UserQueryException) // exception that can occur from user error { throw new UserQueryException(ex.Message, ex); } else { msg = DebugLog.FormatExceptionMessage(ex); if (!Lex.Contains(msg, "QueryLogged:")) // exception & query { QueryEngine.LogExceptionAndSerializedQuery(msg, Query); } else { ServicesLog.Message(msg); // just log exception } throw new Exception(ex.Message, ex); // pass it up } } }
/// <summary> /// Run Query & return any error message /// </summary> /// <param name="query"></param> /// <param name="rf"></param> /// <param name="browseExistingResults">If true browse existing results</param> /// <returns>Command command or an error message</command></returns> public static string RunQuery2( Query query, ResultsFormat rf, bool browseExistingResults = false) { QueryManager qm = null; DataTableMx dt; QueryTable qt = null; QueryColumn qc; MetaTable mt; MetaColumn mc; QueryExec qex; ResultsFormatter rfmtr; Query modifiedQuery = null; DialogResult dr; bool success; int ti, ci, count; if (query == null) { throw new Exception("Null Query"); } qm = query.QueryManager as QueryManager; if (qm == null || !qm.ContainsRenderedResults()) { browseExistingResults = false; } if (ToolHelper.IsOldToolQuery(query) && !browseExistingResults) { return(ToolHelper.RunOldToolQuery(query)); } //if (query.FirstView == null) //{ ResultsViewType tableViewType = ResultsViewType.Table; if (rf.OutputDestination == OutputDest.Html) { tableViewType = ResultsViewType.HtmlTable; } //} //CheckForConnectionLeaks(); // do routine check for connection leaks (disabled for now) // Build/update the QueryManager as needed (including the QueryExec) if running the query rather than just browsing existing results if (!browseExistingResults) // initialize QueryManager { query.SetupQueryPagesAndViews(tableViewType); // adjust views as necessary to match query qm = BuildQueryManager(query, rf); } // Attempt to display already retrieved data in memory or in cached results file else { if (qm != null) { if (qm.QueryExec == null) // create QueryExec if not defined { qex = new QueryExec(qm); } if (qm.ResultsFormatter == null) // create ResultsFormatter if not defined { rfmtr = new ResultsFormatter(qm); } } else { qm = BuildQueryManager(query, rf); } if (Lex.IsDefined(query.ResultsDataTableFileName)) // get data from file { DataTableManager.LoadDataTableFromFile(query); } else // should have data in DataTable already { DataTableManager.ValidateExistingDataTable(query); } if (qm.DataTableManager != null && qm.QueryExec != null) { qm.QueryExec.ResultsKeys = qm.DataTableManager.ResultsKeys; // have data in memory already } } if (rf.OutputDestination == OutputDest.WinForms && rf.SessionOutputFormContext) { // save qm and query if this is a runquery from the main window QueriesControl.Instance.CurrentBrowseQuery = query; // save ref to the query being browsed } if (rf.SessionOutputFormContext) // if not a popup then update main status bar { qm.StatusBarManager = SessionManager.Instance.StatusBarManager; } LastQEx = qm.QueryExec; // keep track of last QueryExec SetupRunQuery: bool saveHitList = (rf.SessionOutputFormContext && !browseExistingResults); // if popup or browsing existing results don't change hitlist qex = qm.QueryExec; string response = qex.RunQuery3(rf, saveHitList, browseExistingResults); // run the query if (qex.ResultsKeys != null && qex.ResultsKeys.Count > 0 && // save in history list if normal query that resulted in hits !query.Preview && !MqlUtil.SingleStepExecution(query) && !browseExistingResults && rf.OutputDestination == OutputDest.WinForms) { CidList keyList = new CidList(qex.ResultsKeys); AddToHistoryList(query, keyList); // use original query } if (response != "" && !response.ToLower().StartsWith("command")) { return(response); } else if (Lex.EndsWith(response, "refetch")) // data to be retrieved has changed, redo fetch part of query { if (!query.Preview) // use current keys if not preview { query.ResultKeys = qex.QueryEngine.GetKeys(); } goto SetupRunQuery; } //else if (response == "") response = "Command EditQuery"; //if (rf.OutputDestination == OutputDest.Grid) //{ // QbUtil.SetMode(QueryMode.Build); // back to build mode // QbUtil.RenderQuery(QbUtil.Qt); //} return(response); }
public static DialogResult Show( QueryColumn qc) { ColumnFormatEnum displayFormat; int decimals; MetaColumn mc = qc.MetaColumn; if (Instance == null) { Instance = new NumberFormatDialog(); } NumberFormatDialog nfd = Instance; ResultsFormatter.GetOutputFormatForQueryColumn(qc, out displayFormat, out decimals); if (displayFormat == ColumnFormatEnum.SigDigits) { nfd.SigDigits.Checked = true; } else if (displayFormat == ColumnFormatEnum.Scientific) { nfd.Scientific.Checked = true; } else { nfd.Decimal.Checked = true; } if (qc.Decimals > 0) { decimals = qc.Decimals; } string tok = decimals.ToString(); nfd.DecimalPlaces.Text = tok; new JupyterGuiConverter().ConvertFormOrUserControl(Instance); DialogResult dr = nfd.ShowDialog(SessionManager.ActiveForm); if (dr == DialogResult.OK) { if (nfd.SigDigits.Checked) { qc.DisplayFormat = ColumnFormatEnum.SigDigits; } else if (nfd.Scientific.Checked) { qc.DisplayFormat = ColumnFormatEnum.Scientific; } else { qc.DisplayFormat = ColumnFormatEnum.Decimal; } tok = nfd.DecimalPlaces.Text; qc.Decimals = Int32.Parse(tok); // already checked for validity } return(dr); }
/// <summary> /// Display the tool data /// </summary> /// <param name="qm"></param> /// <param name="serializeContentInQuery"></param> public static void DisplayDataOld( // Old version from 1/4/2017 QueryManager qm, MoleculeGridPanel gridPanel, bool serializeContentInQuery, bool fitDataToGridWidth = false) { MoleculeGridControl grid = null; bool displayAsNormalQueryResults = (gridPanel == null); // if grid panel not defined assume display is in normal results panel bool displayAsPopupGrid = (gridPanel != null && gridPanel.Parent is PopupGrid); // display in popup grid Query q = qm.Query; q.SetupQueryPagesAndViews(); // be sure we have a default view page if (serializeContentInQuery) { // no database behind this table so persist within the query MetaTable mt = q.Tables[0].MetaTable; // assume just one metatable foreach (MetaColumn mc in mt.MetaColumns) // no criteria allowed { mc.IsSearchable = false; } q.SerializeMetaTablesWithQuery = true; // if no broker then save the metatable definition q.SerializeResultsWithQuery = true; // also save results when saving the query q.BrowseSavedResultsUponOpen = true; // open the results when the query is opened q.ResultsDataTable = qm.DataTable; // point the query to this results table } ResultsFormatFactory rff = new ResultsFormatFactory(qm, OutputDest.WinForms); rff.Build(); // build format ResultsFormatter fmtr = new ResultsFormatter(qm); // and formatter if (displayAsNormalQueryResults) { gridPanel = SessionManager.Instance.QueryResultsControl.MoleculeGridPageControl.MoleculeGridPanel; QbUtil.AddQuery(qm.Query); // add to the list of visible queries QueriesControl.Instance.CurrentBrowseQuery = qm.Query; // make it current } grid = gridPanel.SelectBaseGridViewGrid(qm); //if (qm.ResultsFormat.UseBandedGridView) // grid = gridPanel.BandedViewGrid; //else grid = gridPanel.LayoutViewGrid; qm.MoleculeGrid = grid; grid.QueryManager = qm; DataTableMx dt = qm.DataTable; // save ref to data table grid.DataSource = null; // clear source for header build if (fitDataToGridWidth && grid.BGV != null) { grid.BGV.OptionsView.ColumnAutoWidth = true; // set view for auto width to fit within view } grid.FormatGridHeaders(qm.ResultsFormat); qm.DataTable = dt; // restore data table qm.DataTableManager.SetResultsKeysFromDatatable(); // set the results keys if (displayAsNormalQueryResults) { QbUtil.SetMode(QueryMode.Browse); // put into browse mode } else if (displayAsPopupGrid) { PopupGrid pug = gridPanel.Parent as PopupGrid; pug.Initialize(qm); // be sure popup is initialized pug.Show(); } gridPanel.Visible = true; grid.Visible = true; grid.DataSource = qm.DataTable; // set the datasource for the grid to the datatable RefreshDataDisplay(qm); return; }
internal void ExportSDFileMenuItem_Click(object sender, EventArgs e) { //CommandExec.Execute("Export SDFile"); ResultsFormatter.ExecuteExportCommand("SDFile", QueryManager); }
/// <summary> /// Link in QueryManager member /// </summary> /// <param name="m"></param> public void LinkMember(ResultsFormatter m) { ResultsFormatter = m; m.QueryManager = this; }