// Called after returning from the update parameters routine. // You can examine the messages created from internal validation and change them if desired. public void UpdateMessages(IArray paramvalues, IGPEnvironmentManager pEnvMgr, IGPMessages Messages) { // Check for error messages IGPMessage msg = (IGPMessage)Messages; if (msg.IsError()) { return; } // Get the first Input Parameter IGPParameter parameter = (IGPParameter)paramvalues.get_Element(0); // UnPackGPValue. This ensures you get the value either form the dataelement or GpVariable (ModelBuilder) IGPValue parameterValue = m_GPUtilities.UnpackGPValue(parameter); // Open the Input Dataset - Use DecodeFeatureLayer as the input might be a layer file or a feature layer from ArcMap. IFeatureClass inputFeatureClass; IQueryFilter qf; m_GPUtilities.DecodeFeatureLayer(parameterValue, out inputFeatureClass, out qf); IGPParameter3 fieldParameter = (IGPParameter3)paramvalues.get_Element(1); string fieldName = fieldParameter.Value.GetAsText(); // Check if the field already exists and provide a warning. int indexA = inputFeatureClass.FindField(fieldName); if (indexA > 0) { Messages.ReplaceWarning(1, "Field already exists. It will be overwritten."); } return; }
/// <summary> /// Gather the error/warning/informative messages from GPMessages /// <summary> /// <param name="gpMessages">GPMessages container</param> /// <returns>string of all GPMessages</returns> public string GetGPMessagesAsString(IGPMessages gpMessages) { // Gather Error/Warning/Informative Messages var messages = new StringBuilder(); if (gpMessages != null) { for (int i = 0; i < gpMessages.Count; i++) { IGPMessage gpMessage = gpMessages.GetMessage(i); string message = gpMessage.Description; switch (gpMessages.GetMessage(i).Type) { case esriGPMessageType.esriGPMessageTypeError: messages.AppendLine("Error " + gpMessage.ErrorCode + ": " + message); break; case esriGPMessageType.esriGPMessageTypeWarning: messages.AppendLine("Warning: " + message); break; default: messages.AppendLine("Information: " + message); break; } } } return(messages.ToString()); }
/// <summary> /// Called immediately after a tool is executed by the GeoProcessor. /// </summary> /// <param name="Tool"></param> /// <param name="Values"></param> /// <param name="result"></param> /// <param name="Messages"></param> void IGeoProcessorEvents.PostToolExecute(IGPTool Tool, IArray Values, int result, IGPMessages Messages) { GPMessageEventArgs[] messages = new GPMessageEventArgs[Messages.Count]; IGPMessage gpMessage = null; for (int i = 0; i < Messages.Count; i++) { gpMessage = Messages.GetMessage(i); GPMessageEventArgs message = new GPMessageEventArgs(gpMessage.Description, gpMessage.Type, gpMessage.ErrorCode); messages[i] = message; } //create a new instance of GPPostToolExecuteEventArgs GPPostToolExecuteEventArgs e = new GPPostToolExecuteEventArgs(); e.DisplayName = Tool.DisplayName; e.Name = Tool.Name; e.PathName = Tool.PathName; e.Toolbox = Tool.Toolbox.Alias; e.ToolCategory = Tool.ToolCategory; e.ToolType = Tool.ToolType; e.Description = Tool.Description; e.Result = result; //fire the Post tool event if (null != GPPostToolExecute) { GPPostToolExecute(this, e); } }
/// <summary> /// Handles the MessagesCreated event. /// </summary> void _gp_MessagesCreated(object sender, MessagesCreatedEventArgs e) { IGPMessages gpMsgs = e.GPMessages; if (gpMsgs.Count > 0) { for (int count = 0; count < gpMsgs.Count; count++) { IGPMessage msg = gpMsgs.GetMessage(count); string imageToShow = "information"; switch (msg.Type) { case esriGPMessageType.esriGPMessageTypeAbort: imageToShow = "warning"; break; case esriGPMessageType.esriGPMessageTypeEmpty: imageToShow = "information"; break; case esriGPMessageType.esriGPMessageTypeError: imageToShow = "error"; break; case esriGPMessageType.esriGPMessageTypeGDBError: imageToShow = "error"; break; case esriGPMessageType.esriGPMessageTypeInformative: imageToShow = "information"; break; case esriGPMessageType.esriGPMessageTypeProcessDefinition: imageToShow = "information"; break; case esriGPMessageType.esriGPMessageTypeProcessStart: imageToShow = "information"; break; case esriGPMessageType.esriGPMessageTypeProcessStop: imageToShow = "information"; break; case esriGPMessageType.esriGPMessageTypeWarning: imageToShow = "warning"; break; default: break; } listView1.Items.Add(new ListViewItem(new string[2] { "MessagesCreated", msg.Description }, imageToShow)); } } }
/// <summary> /// Called when a message has been posted while executing a SchematicGeoProcessing /// </summary> /// <param name="message"></param> void IGeoProcessorEvents.OnMessageAdded(IGPMessage message) { //fire the GPMessage event if (GPMessage != null) { GPMessage(this, new GPMessageEventArgs(message.Description, message.Type, message.ErrorCode)); } }
public void OnMessageAdded(IGPMessage message) { if (this.m_sb.Length > 0) { this.m_sb.Append("\r\n"); } this.m_sb.Append(message.Description); this.txtMessage.Text = this.m_sb.ToString(); }
public void UpdateMessages(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager pEnvMgr, ESRI.ArcGIS.Geodatabase.IGPMessages Messages) { IGPUtilities3 gpUtilities3 = new GPUtilitiesClass(); for (int i = 0; i < Messages.Count; i++) { IGPMessage blah = Messages.GetMessage(i); if (blah.IsError()) { IGPMessage something = new GPMessageClass(); something.Description = String.Empty; something.Type = esriGPMessageType.esriGPMessageTypeInformative; something.ErrorCode = 0; Messages.Replace(i, something); } } IGPParameter inputOSMParameter = paramvalues.get_Element(in_osmFeatureClassNumber) as IGPParameter; IGPValue inputOSMGPValue = gpUtilities3.UnpackGPValue(inputOSMParameter); if (inputOSMGPValue.IsEmpty() == false) { IFeatureClass osmFeatureClass = null; ITable osmInputTable = null; IQueryFilter osmQueryFilter = null; try { gpUtilities3.DecodeFeatureLayer(inputOSMGPValue, out osmFeatureClass, out osmQueryFilter); osmInputTable = osmFeatureClass as ITable; } catch { } try { if (osmInputTable == null) { gpUtilities3.DecodeTableView(inputOSMGPValue, out osmInputTable, out osmQueryFilter); } } catch { } if (osmInputTable == null) { return; } // find the field that holds tag binary/xml field int osmTagCollectionFieldIndex = osmInputTable.FindField("osmTags"); if (osmTagCollectionFieldIndex == -1) { Messages.ReplaceAbort(in_osmFeatureClassNumber, resourceManager.GetString("GPTools_OSMGPCombineAttributes_inputlayer_missingtagfield")); return; } } }
public IGPMessages Validate(IArray paramValues, bool updateValues, IGPEnvironmentManager envMgr) { if (m_util == null) // delay constructor activities.... they segfault arcmap { m_util = new GPUtilitiesClass(); m_outp_schema = new AoTable( AoField.Integer("left_fid"), AoField.Integer("right_fid") ); } IGPMessages ms = m_util.InternalValidate(ParameterInfo, paramValues, updateValues, true, envMgr); bool passed = AoGPParameter.ValidateAll(m_parms, paramValues, ms); IGPMessage m = (IGPMessage)ms; if (!passed || m.IsError()) { ms.AddError(2, "An error here."); return(ms); } // TODO: Set up the output schema. IGPParameter outparam = paramValues.get_Element(3) as IGPParameter; IGPFeatureLayer fl = outparam.Value as IGPFeatureLayer; if (fl == null) { fl = new GPFeatureLayerClass(); } fl.DEFeatureClass = new DEFeatureClassClass(); (fl.DEFeatureClass as IDETable).Fields = m_outp_schema.Fields; // Set up its catalog path / name.. // IDataElement de = (fc as IDataElement; // if ( (old_val == null || old_val.DEFeatureClass == null) && src_path != null && src_path.DEFeatureClass != null) { // //src_path = m_util.UnpackGPValue(src_path) as IGPFeatureLayer; // IDataElement srcde = src_path.DEFeatureClass as IDataElement; // lazy cut-n-paste shortcut // de.CatalogPath = srcde.GetPath() + "\\" + srcde.GetBaseName() + "_bndgen." + srcde.GetExtension();// old_val.CatalogPath; // de.Children = srcde.Children; // de.ChildrenExpanded = srcde.ChildrenExpanded; // de.MetadataRetrieved = srcde.MetadataRetrieved; // //de.Name = old_val.Name + "bndgen"; // de.Type = srcde.Type; // } m_util.PackGPValue(fl as IGPValue, outparam); return(ms); }
/// <summary> /// Creates a geoprocessing value object from the given string. /// </summary> /// <param name="text"></param> /// <returns></returns> public IGPValue CreateValue(string text) { IGPValue value = new GPAutoValue <TValue>(); IGPMessage message = value.SetAsText(text); if (message.IsInformational()) { return(value); } return(null); }
private void btnGO_Click(object sender, System.EventArgs e) { int facilityCount = 0, cutOffVal = 0; if (txtFacilityCount.Text.Length > 0) { facilityCount = Convert.ToInt32(txtFacilityCount.Text); } if (txtCutOff.Text.Length > 0) { cutOffVal = Convert.ToInt32(txtCutOff.Text); } pGISHelper.SetSolverSettings(ref m_pNAContext, cutOffVal, facilityCount, cmbCost.Text, chkOneWay.Checked, chkHierachy.Checked); IGPMessages pGPMessages = new GPMessagesClass(); IGPMessage pGPMessage = null; if (m_pNAContext.Solver.Solve(m_pNAContext, pGPMessages, null) == false) { for (int ii = 0; ii < pGPMessages.Count; ii++) { pGPMessage = pGPMessages.GetMessage(ii); MessageBox.Show(pGPMessage.Description); } pGISHelper.GetCFOutput("CFRoutes", ref m_pNAContext); } //'Zoom to the extent of the route IGeoDataset pGDS; IEnvelope pEnv; pGDS = m_pNAContext.NAClasses.get_ItemByName("CFRoutes") as IGeoDataset; pEnv = pGDS.Extent; if (!pEnv.IsEmpty) { pEnv.Expand(1.1, 1.1, true); pMainFrm.getMapControl().Extent = pEnv; } pMainFrm.getMapControl().Refresh(); }
public IGPValue CreateValue(string text) { IGPValue gpValue = new HttpBasicGPValue(); IGPMessage gpValueMessage = gpValue.SetAsText(text); if (gpValueMessage.IsInformational()) { return(gpValue); } else { return(null); } }
private bool CheckForTableFields(IDETable inputTable, string[] fieldNames, esriFieldType[] fieldTypes, IGPMessage gpMessage) { IFields fields = inputTable.Fields; int fieldIndex; for (int i = 0; i < fieldNames.Length; i++) { fieldIndex = fields.FindField(fieldNames[i]); if (fieldIndex == -1) { gpMessage.Type = esriGPMessageType.esriGPMessageTypeError; gpMessage.Description = "Field named " + fieldNames[i] + " not found."; return false; } if (fields.get_Field(fieldIndex).Type != fieldTypes[i]) { gpMessage.Type = esriGPMessageType.esriGPMessageTypeError; gpMessage.Description = "Field named " + fieldNames[i] + " is not the expected type."; return false; } } return true; }
public void MessageAdded(IGPMessage Message) { }
/// <summary> /// Called when a message has been posted while executing a SchematicGeoProcessing /// </summary> /// <param name="message"></param> void IGeoProcessorEvents.OnMessageAdded(IGPMessage message) { //fire the GPMessage event if (GPMessage != null) GPMessage(this, new GPMessageEventArgs(message.Description, message.Type, message.ErrorCode)); }
public void OnMessageAdded(IGPMessage message) { if ((message != null) && !string.IsNullOrEmpty(message.Description)) { string strType = ""; switch (message.Type) { case esriGPMessageType.esriGPMessageTypeAbort: strType = "Abort:"; bFailureMessages = true; break; case esriGPMessageType.esriGPMessageTypeEmpty: strType = "Empty:"; break; case esriGPMessageType.esriGPMessageTypeError: strType = "Error:"; bFailureMessages = true; break; case esriGPMessageType.esriGPMessageTypeInformative: strType = "Info:"; break; case esriGPMessageType.esriGPMessageTypeProcessDefinition: strType = "ProcessDef:"; break; case esriGPMessageType.esriGPMessageTypeProcessStart: strType = "ProcessStart:"; break; case esriGPMessageType.esriGPMessageTypeProcessStop: strType = "ProcessStop:"; break; case esriGPMessageType.esriGPMessageTypeWarning: strType = "Warning:"; break; } m_strMessages += strType + " " + message.Description + Environment.NewLine; } }