/// <summary>
/// Method to Export the given plot window to PDF
/// </summary>
/// <param name="pw"></param>
private void ExportToPDF(IGTPlotWindow pw)
{
IGTExportService svcExport = null;
IGTPDFPrinterProperties printProps = null;
try
{
// Construct printer properties
PageOrientationType orientation =
(pw.NamedPlot.PaperWidth > pw.NamedPlot.PaperHeight)
? PageOrientationType.Portrait : PageOrientationType.Landscape;
printProps = GTClassFactory.Create <IGTPDFPrinterProperties>();
printProps.PageWidth = pw.NamedPlot.PaperWidth;
printProps.PageHeight = pw.NamedPlot.PaperHeight;
printProps.Orientation = orientation;
printProps.PageSize = PageSizeValue.Auto;
printProps.Resolution = ResolutionValue.DPI600;
// Perform export
svcExport = GTClassFactory.Create <IGTExportService>();
svcExport.PDFLayersEnabled = false;
svcExport.SaveAsPDF(m_strDoumentsPath, printProps, pw, true);
m_oGTTransactionManager.Begin("Attach Street Light Supplemental Agreement Plot");
IGTKeyObject gTTempKeyObject = m_gTDataContext.OpenFeature(m_gTDesignAreaKeyObject.FNO, m_gTDesignAreaKeyObject.FID);
Recordset rs = gTTempKeyObject.Components.GetComponent(8130).Recordset;
rs.AddNew("G3E_FID", gTTempKeyObject.FID);
rs.Fields["HYPERLINK_T"].Value = m_strDoumentsPath;
rs.Fields["DESCRIPTION_T"].Value = "Street Supplemental Plot";
rs.Fields["TYPE_C"].Value = "SUPPLEPLOT";
rs.Fields["G3E_FNO"].Value = 8100;
rs.Update();
if (m_oGTTransactionManager.TransactionInProgress)
{
m_oGTTransactionManager.Commit();
}
}
catch
{
throw;
}
finally
{
svcExport = null;
printProps = null;
pw = null;
}
}
/// <summary>
/// Attach Plot to Current Active WR.
/// </summary>
public void AttachPlot()
{
IGTPlotWindow gTPlotWindow = null;
try
{
gTPlotWindow = m_gTApplication.ActivePlotWindow;
ExportToPDF(gTPlotWindow);
}
catch
{
throw;
}
}
/// <summary>
/// Method to Export the given plot window to PDF
/// </summary>
/// <param name="p_destDir">Directory path of the target PDF filename.</param>
/// <param name="p_destName">PDF filename</param>
/// <param name="p_append">Append the results to destFileName, if destFileName already exists; otherwise create/overwrite FileName</param>
/// <param name="pw">Plot window which needs to be exported to PDF</param>
private void ExportToPDF(string p_destDir, string p_destName, bool p_append, IGTPlotWindow pw)
{
IGTExportService svcExport = null;
IGTPDFPrinterProperties printProps = null;
try
{
// Construct full path
string destPathName = Path.Combine(p_destDir, p_destName);
// Construct printer properties
PageOrientationType orientation =
(pw.NamedPlot.PaperWidth > pw.NamedPlot.PaperHeight)
? PageOrientationType.Portrait : PageOrientationType.Landscape;
printProps = GTClassFactory.Create <IGTPDFPrinterProperties>();
printProps.PageWidth = pw.NamedPlot.PaperWidth;
printProps.PageHeight = pw.NamedPlot.PaperHeight;
printProps.Orientation = orientation;
printProps.PageSize = PageSizeValue.Auto;
printProps.Resolution = ResolutionValue.DPI600;
// Perform export
svcExport = GTClassFactory.Create <IGTExportService>();
svcExport.PDFLayersEnabled = false;
svcExport.SaveAsPDF(destPathName, printProps, pw, p_append);
}
catch
{
throw;
}
finally
{
svcExport = null;
printProps = null;
pw = null;
}
}
public void Activate()
{
IGTPlotWindow igtPlotWindow = null;
IGTExportService igtExportService = null;
IGTPDFPrinterProperties igtPDFPrinterProperties = null;
OncDocManage.OncDocManage tmpOncDocMgr = new OncDocManage.OncDocManage();
try
{
m_igtApplication = GTClassFactory.Create <IGTApplication>();
igtPlotWindow = m_igtApplication.ActivePlotWindow;
igtExportService = GTClassFactory.Create <IGTExportService>();
igtPDFPrinterProperties = GTClassFactory.Create <IGTPDFPrinterProperties>();
m_igtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, "Attach Site Drawing to selected feature started");
if (Validate())
{
m_plotwindowPdfFilename = m_plotwindowPath + igtPlotWindow.Caption + ".pdf";
m_igtApplication.BeginWaitCursor();
setPDFPrinterProps(ref igtPDFPrinterProperties);
igtExportService.SaveAsPDF(m_plotwindowPdfFilename, igtPDFPrinterProperties, igtPlotWindow, false);
igtExportService = null;
igtPDFPrinterProperties = null;
igtPlotWindow = null;
//m_igtApplication.EndWaitCursor();
if (File.Exists(m_plotwindowPdfFilename))
{
if (GetGeneralParams(ref tmpOncDocMgr))
{
m_igtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, "Adding the Site Drawing PDF file to SharePoint.");
tmpOncDocMgr.SrcFilePath = m_plotwindowPdfFilename;
tmpOncDocMgr.SPFileName = m_plotwindowPdfFilename.Substring(m_plotwindowPdfFilename.LastIndexOf("\\") + 1);
tmpOncDocMgr.SPFileType = "Site Drawings";
tmpOncDocMgr.WrkOrd_Job = m_igtApplication.DataContext.ActiveJob;
if (tmpOncDocMgr.AddSPFile(true))
{
//add to hyperlink to selected object
//AddHyperLinktoSelectedFeature(m_selectedFNO, m_selectedFID, m_plotwindowPdfFilename, "Plotwindow " + m_igtApplication.ActivePlotWindow.Caption + " pdf", "SITE");
AddHyperLinktoSelectedFeature(m_selectedFNO, m_selectedFID,
tmpOncDocMgr.RetFileURL, tmpOncDocMgr.RetFileName,
"Plotwindow " + m_igtApplication.ActivePlotWindow.Caption + " pdf", tmpOncDocMgr.SPFileType);
}
else
{
MessageBox.Show("Error during while trying to add the file to SharePoint. Error: " + tmpOncDocMgr.RetErrMessage, "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
else
{
MessageBox.Show(m_igtApplication.ApplicationWindow, "Ad hoc plots may only be attached to a Permit or Easement feature.", "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
m_igtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, "Attach Site Drawing Command has ended.");
m_igtApplication.EndWaitCursor();
}
catch (Exception ex)
{
m_igtApplication.EndWaitCursor();
MessageBox.Show("Error during execution of Attach Site Drawing custom command" + ex.Message, "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Error);
m_igtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, "Attach Site Drawing Command has ended with errors.");
}
}
/// <summary>
/// Generates the construction prints (plots) for the active job. Generates a new string List for the prints parameter.
/// </summary>
/// <param name="prints">string that will contain the path/file name of the generated plots.</param>
/// <returns>true if successful; else, false</returns>
private bool GenerateConstructionPrints(out string prints)
{
bool retVal = false;
prints = string.Empty;
try
{
IGTApplication app = GTClassFactory.Create <IGTApplication>();
CommonMapPrintingHelper mpHelper = new CommonMapPrintingHelper(app);
string tmpFileName = string.Format("{0}-Close-WorkPrint", app.DataContext.ActiveJob);
string tmpFilePath = System.IO.Path.GetTempPath();
#region Code in this region to be removed entirely once Plotting Template(s) are available.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Until we get plot templates, then check whether the "Construction Print" named plot exists.
// If it doesn't, then create one to serve as a temporary solution for a missing plot sheet.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool needNamedPlot = true;
foreach (IGTNamedPlot namedPlot in app.NamedPlots)
{
if (namedPlot.Name == "Construction Print")
{
needNamedPlot = false;
}
}
// If the Construction Print named plot doesn't exist, then create one.
if (needNamedPlot)
{
IGTNamedPlot np = app.NewNamedPlot("Construction Print");
IGTPlotWindow pw = app.NewPlotWindow(np);
IGTPoint frameTopLeft = GTClassFactory.Create <IGTPoint>();
frameTopLeft.X = 0.0;
frameTopLeft.Y = 0.0;
IGTPoint frameBottomRight = GTClassFactory.Create <IGTPoint>();
frameBottomRight.X = 20000.0;
frameBottomRight.Y = 30000.0;
IGTPaperRange paperRange = GTClassFactory.Create <IGTPaperRange>();
paperRange.TopLeft = frameTopLeft;
paperRange.BottomRight = frameBottomRight;
IGTPlotMap map = pw.InsertMap(paperRange);
}
#endregion
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// For now, defaulting the legend name to Distribution Design Legend for these prints; however,
// this may be enhanced to determine which legend to use based on the WR type.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (mpHelper.GenerateConstructionPlots("Distribution Design Legend", tmpFileName, tmpFilePath))
{
prints = string.Format("{0}\\{1}", tmpFilePath, tmpFileName);
retVal = true;
}
}
catch (Exception ex)
{
string exMsg = string.Format("Error occurred in {0} of {1}.{2}{3}", System.Reflection.MethodBase.GetCurrentMethod().Name, this.ToString(), Environment.NewLine, ex.Message);
MessageBox.Show(exMsg, "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
return(retVal);
}
public bool GeneratePlot(string strPlot, string strCity, string strDivision)
{
IGTNamedPlot gTNewNamedPlot = GTClassFactory.Create <IGTNamedPlot>();
IGTPlotFrame gTNewPlotFrame = GTClassFactory.Create <IGTPlotFrame>();
IGTPlotWindow gTPlotWindow = GTClassFactory.Create <IGTPlotWindow>();
IGTPlotMap gtNewPlotMap = GTClassFactory.Create <IGTPlotMap>();
IGTPlotRedlines gTPlotRedlines = null;
//Recordset rs = null;
object objectValue = null;
string strNewPlotName = "";
try
{
if (!IsPlotNameExist(strPlot))
{
strNewPlotName = strPlot;
if (m_gTNamedPlot != null && !string.IsNullOrEmpty(strNewPlotName))
{
gTNewNamedPlot = m_gTNamedPlot.CopyPlot(strNewPlotName);
gTPlotWindow = m_gTApplication.NewPlotWindow(gTNewNamedPlot);
gTPlotWindow.BackColor = System.Drawing.Color.White;
gTPlotWindow.Caption = gTPlotWindow.NamedPlot.Name;
if (!String.IsNullOrEmpty(m_gTNamedPlot.FieldsQuery))
{
gTPlotWindow.NamedPlot.FieldsQuery = m_gTNamedPlot.FieldsQuery;
}
//rs = gTDataContext.OpenRecordset(gTPlotWindow.NamedPlot.FieldsQuery, ADODB.CursorTypeEnum.adOpenStatic, ADODB.LockTypeEnum.adLockReadOnly,
// (int)ADODB.CommandTypeEnum.adCmdText, gTDataContext.ActiveJob);
gTPlotRedlines = gTPlotWindow.NamedPlot.GetRedlines(GTPlotRedlineCollectionConstants.gtprcTextOnly);
foreach (IGTPlotRedline prl in gTPlotRedlines)
{
IGTTextPointGeometry gTTextPointGeometry = (IGTTextPointGeometry)prl.Geometry.Copy();
if (prl.AutomaticTextSource == GTPlotAutomaticTextSourceConstants.gtpatPlotByQuery)
{
string currentVal = String.IsNullOrEmpty(gTTextPointGeometry.Text) ? " " : gTTextPointGeometry.Text;
if (prl.AutomaticTextField.ToString() == "WR")
{
objectValue = m_gTApplication.DataContext.ActiveJob;
}
else if (prl.AutomaticTextField.ToString() == "StreetLightESILocation")
{
string esiLocations = "";
foreach (string esiL in m_SelectedEsiLocations)
{
if (!string.IsNullOrEmpty(esiLocations))
{
esiLocations = esiLocations + ",'" + esiL + "'";
}
else
{
esiLocations = "'" + esiL + "'";
}
}
objectValue = esiLocations;
}
else if (prl.AutomaticTextField.ToString() == "CountofStreetLightsinselectset")
{
objectValue = m_SelectedEsiLocations.Length + " Street Lights";
}
else if (prl.AutomaticTextField.ToString() == "Subdivision")
{
objectValue = strDivision;
}
else if (prl.AutomaticTextField.ToString() == "City")
{
objectValue = strCity;
}
gTTextPointGeometry.Text = (objectValue == null) ? " " : objectValue.ToString();
prl.Geometry = gTTextPointGeometry;
}
}
foreach (IGTPlotFrame plf in gTNewNamedPlot.Frames)
{
if (plf.Type == GTPlotFrameTypeConstants.gtpftMap)
{
gTNewPlotFrame = plf;
}
}
if (gTNewPlotFrame != null)
{
gtNewPlotMap = gTNewPlotFrame.PlotMap;
gTNewPlotFrame.Activate();
gTNewPlotFrame.PlotMap.FitSelectedObjects(1.2);
gTNewPlotFrame.Deactivate();
m_gTApplication.RefreshWindows();
return(true);
}
}
}
else
{
MessageBox.Show("Plot name already exists in workspace. Please enter a different plot name", "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Information,
MessageBoxDefaultButton.Button1);
return(false);
}
}
catch
{
throw;
}
return(false);
}
/// <summary>
/// Method to create a Plot window with given template and exports the plot window to create a PDF.
/// </summary>
/// <param name="p_template">Specified plot template using which need to create a new named plot </param>
/// <param name="p_newTreeTrimmingfeature">Current placed feature</param>
private void CreatePlotWindowAndPlotPDF(IGTNamedPlot p_template, IGTKeyObject p_newTreeTrimmingfeature)
{
Recordset oPlotRS = null;
IGTPlotRedlines oRLs = null;
IGTPlotFrame gTPlotFrame = GTClassFactory.Create <IGTPlotFrame>();
IGTPlotMap gtPlotMap = GTClassFactory.Create <IGTPlotMap>();
IGTNamedPlot namedPlot = GTClassFactory.Create <IGTNamedPlot>();
IGTPlotWindow gTPlotWindow = GTClassFactory.Create <IGTPlotWindow>();
string plotName = null;
object autoVal = null;
try
{
plotName = GetPlotName();
namedPlot = p_template.CopyPlot(plotName);
gTPlotWindow = m_oGTApplication.NewPlotWindow(namedPlot);
gTPlotWindow.BackColor = System.Drawing.Color.White;
gTPlotWindow.Caption = gTPlotWindow.NamedPlot.Name;
foreach (IGTPlotFrame apf in namedPlot.Frames)
{
if (apf.Type == GTPlotFrameTypeConstants.gtpftMap)
{
gTPlotFrame = apf;
}
}
if (gTPlotFrame != null)
{
gtPlotMap = gTPlotFrame.PlotMap;
if (!String.IsNullOrEmpty(p_template.FieldsQuery))
{
gTPlotWindow.NamedPlot.FieldsQuery = p_template.FieldsQuery;
}
else
{
gTPlotWindow.NamedPlot.FieldsQuery = "Select WR_NBR,G3E_IDENTIFIER,DESIGNER_UID,G3E_DATECREATED,WR_CREW_HQ_C from g3e_job where g3e_identifier='" + m_oGTApplication.DataContext.ActiveJob + "'";
}
oPlotRS = m_oGTApplication.DataContext.OpenRecordset(gTPlotWindow.NamedPlot.FieldsQuery, ADODB.CursorTypeEnum.adOpenStatic, ADODB.LockTypeEnum.adLockReadOnly, (int)ADODB.CommandTypeEnum.adCmdText);
oRLs = gTPlotWindow.NamedPlot.GetRedlines(GTPlotRedlineCollectionConstants.gtprcTextOnly);
foreach (IGTPlotRedline oRL in oRLs)
{
IGTTextPointGeometry oTPG = (IGTTextPointGeometry)oRL.Geometry.Copy();
if (oRL.AutomaticTextSource == GTPlotAutomaticTextSourceConstants.gtpatPlotByQuery)
{
if (oRL.AutomaticTextField.ToString() == "WR Number")
{
autoVal = oPlotRS.Fields["WR_NBR"].Value;
}
else if (oRL.AutomaticTextField.ToString() == "WR Name")
{
autoVal = oPlotRS.Fields["G3E_IDENTIFIER"].Value;
}
else if (oRL.AutomaticTextField.ToString() == "Designer Name")
{
autoVal = oPlotRS.Fields["DESIGNER_UID"].Value;
}
else if (oRL.AutomaticTextField.ToString() == "Date")
{
autoVal = oPlotRS.Fields["G3E_DATECREATED"].Value;
}
else if (oRL.AutomaticTextField.ToString() == "Crew HQ")
{
autoVal = oPlotRS.Fields["WR_CREW_HQ_C"].Value;
}
oTPG.Text = (autoVal == null) ? " " : autoVal.ToString();
oRL.Geometry = oTPG;
}
}
gTPlotFrame.Activate();
gTPlotFrame.PlotMap.ZoomArea(p_newTreeTrimmingfeature.Components.GetComponent(19002).Geometry.Range);
ZoomToExtents(gTPlotFrame, p_newTreeTrimmingfeature.Components.GetComponent(19002).Geometry.Range, 1.2);
gTPlotFrame.ClipGeometry = WorldToPaper(gtPlotMap, (IGTPolygonGeometry)p_newTreeTrimmingfeature.Components.GetComponent(19002).Geometry);
gTPlotFrame.IsClipped = true;
gTPlotFrame.Deactivate();
m_oGTApplication.RefreshWindows();
m_oPlotPDFName = plotName.Replace('/', '_').Replace('\\', '_').Replace(' ', '_');
ExportToPDF(Path.GetTempPath(), m_oPlotPDFName, false, gTPlotWindow);
}
}
catch
{
throw;
}
finally
{
oPlotRS = null;
}
}
internal void BuildWorkPrint(List <PlotBoundaryAttributes> p_PlotBoundaryCollection, IGTApplication p_oApp, string p_destDir, string p_outputFileName, string p_legendName)
{
try
{
List <string> PDFNames = new List <string>();
for (int i = 0; i < p_PlotBoundaryCollection.Count; i++)
{
string sErrMsg = string.Empty;
IGTNamedPlot oNamedPlot = null;
IGTKeyObject oClipGeom = p_oApp.DataContext.OpenFeature(p_PlotBoundaryCollection[i].FNO, p_PlotBoundaryCollection[i].FID);
IGTComponent oComp = oClipGeom.Components.GetComponent(18802);
oComp.Recordset.MoveFirst();
IGTPolygonGeometry oGeom = (IGTPolygonGeometry)oComp.Geometry;
foreach (IGTNamedPlot item in p_oApp.NamedPlots)
{
if (item.Name.Equals(p_PlotBoundaryCollection[i].PlotTemplateName))
{
oNamedPlot = item;
break;
}
}
DeleteNamedPlot("OUTPUT - " + p_oApp.DataContext.ActiveJob + "-" + i, p_oApp);
IGTNamedPlot oCopiedPlot = oNamedPlot.CopyPlot("OUTPUT - " + p_oApp.DataContext.ActiveJob + "-" + i);
IGTPlotWindow oPlotWindow = p_oApp.NewPlotWindow(oCopiedPlot);
IGTPlotFrame oFrame = null;
foreach (IGTPlotFrame tmpFrame in oPlotWindow.NamedPlot.Frames)
{
// IGTPlotFrame oFrame = oPlotWindow.NamedPlot.Frames[0];
if (tmpFrame.Type == GTPlotFrameTypeConstants.gtpftMap)
{
oFrame = tmpFrame;
break;
}
}
oFrame.Activate();
oFrame.PlotMap.DisplayService.ReplaceLegend(p_legendName);
AssignClipGeometryToFrame(p_oApp, oFrame, oGeom);
oPlotWindow.Activate();
SetAutomaticFields(oPlotWindow.NamedPlot, p_PlotBoundaryCollection.Count, i + 1, p_oApp);
p_oApp.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, string.Format("Generating Construction Print {0} of {1}", i + 1, p_PlotBoundaryCollection));
ExportToPDF(p_destDir, p_outputFileName + "-" + i + ".pdf", false, oPlotWindow, out sErrMsg);
PDFNames.Add(p_outputFileName + "-" + i + ".pdf");
oPlotWindow.Close();
DeleteNamedPlot("OUTPUT - " + p_oApp.DataContext.ActiveJob + "-" + i + 1, p_oApp);
}
if (PDFNames.Count > 0)
{
MergePDFs(p_destDir, PDFNames, p_outputFileName);
}
}
catch (Exception)
{
throw;
}
}
private string ExportToPDF(string p_destDir, string p_destName, bool p_append, IGTPlotWindow p_outputWindow, out string p_msg)
{
string retVal = string.Empty;
p_msg = "";
try
{
string destPathName = Path.Combine(p_destDir, p_destName);
IGTPDFPrinterProperties pdfProps = GTClassFactory.Create <IGTPDFPrinterProperties>();
pdfProps.EmbedFont = true;
if (p_outputWindow.NamedPlot != null)
{
pdfProps.PageHeight = p_outputWindow.NamedPlot.PaperHeight;
pdfProps.PageWidth = p_outputWindow.NamedPlot.PaperWidth;
}
pdfProps.Orientation = PageOrientationType.Portrait;
pdfProps.PageSize = PageSizeValue.Auto;
pdfProps.Resolution = ResolutionValue.DPI600;
// Perform export
IGTExportService svcExport = GTClassFactory.Create <IGTExportService>();
svcExport.PDFLayersEnabled = false;
svcExport.SaveAsPDF(destPathName, pdfProps, p_outputWindow, p_append);
svcExport = null;
// Close output window
p_outputWindow.Close();
retVal = destPathName;
}
catch (Exception ex)
{
p_msg = ex.Message;
}
return(retVal);
}
