// 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;
}
}
