root/MGET/Branches/Jason/VisualStudioSolutions/RegisterToolboxWithArcCatalog92sp3/Program.cs @ 136

// RegisterToolboxWithArcCatalog - Adds or removes a specified ArcGIS toolbox
// (.tbx file) to or from the user's list maintained by ArcCatalog.
//
// Copyright (C) 2007 Jason J. Roberts
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License (available in the file LICENSE.TXT)
// for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.


using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Text;
using Microsoft.Win32;
using ESRI.ArcGIS.esriSystem;
using ESRI.ArcGIS.Framework;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geoprocessing;
using ESRI.ArcGIS.GeoprocessingUI;

namespace RegisterToolboxWithArcCatalog
{
    class Program
    {
        static string Operation = "";
        static IGPToolbox Toolbox = null;
        static int ReturnCode = 2;

        static int Main(string[] args)
        {
            // Check the command line arguments.

            if (args.Length != 2)
            {
                Console.Error.WriteLine("ERROR: Invalid command line arguments.");
                Console.WriteLine("");
                Console.WriteLine("USAGE: RegisterToolboxWithArcCatalog {register|unregister} toolbox");
                Console.WriteLine("");
                Console.WriteLine("       toolbox - path to an ArcGIS toolbox (.tbx) file");
                return 1;
            }

            Program.Operation = args[0].ToLower();
            string toolboxPath = args[1];

            if (Program.Operation != "register" && Program.Operation != "unregister")
            {
                Console.Error.WriteLine("ERROR: Invalid command line arguments. The first parameter must be register or unregister.");
                return 1;
            }

            // Get the ArcGIS installation directory from the registry.

            RegistryKey key = null;

            try
            {
                key = Registry.LocalMachine.OpenSubKey(@"Software\ESRI\ArcInfo\Desktop\8.0");
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("ERROR: Failed to open the registry key \"HKEY_LOCAL_MACHINE\\Software\\ESRI\\ArcInfo\\Desktop\\8.0\". ArcGIS may not be installed on this machine. Registry.LocalMachine.OpenSubKey(@\"Software\\ESRI\\ArcInfo\\Desktop\\8.0\") raised an exception: {0}", e.Message);
                return 1;
            }

            string arcGisInstallDir = "";

            try
            {
                arcGisInstallDir = (string)key.GetValue("InstallDir");
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("ERROR: Failed to read the \"InstallDir\" value from the registry key \"HKEY_LOCAL_MACHINE\\Software\\ESRI\\ArcInfo\\Desktop\\8.0\". AArcGIS may not be installed on this machine. RegistryKey.GetValue(\"InstallDir\") raised an exception: {0}", e.Message);
                return 1;
            }

            // Open the toolbox.

            IWorkspaceFactory factory = new ToolboxWorkspaceFactoryClass();
            IToolboxWorkspace workspace = null;

            try
            {
                workspace = (IToolboxWorkspace)factory.OpenFromFile(Path.GetDirectoryName(toolboxPath), 0);
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("ERROR: Failed to open the ArcGIS workspace \"{0}\". ToolboxWorkspaceFactory.OpenFromFile(\"{0}\", 0) raised an exception: {1}", Path.GetDirectoryName(toolboxPath), e.Message);
                return 1;
            }

            string fileName = Path.GetFileName(toolboxPath);
            if (Path.GetExtension(fileName).ToLower() == ".tbx")
                fileName = Path.GetFileNameWithoutExtension(fileName);

            try
            {
                Program.Toolbox = workspace.OpenToolbox(fileName);
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("ERROR: Failed to open the ArcGIS toolbox \"{0}\" in workspace \"{1}\". IToolboxWorkspace.OpenToolbox(\"{0}\") raised an exception: {2}", fileName, Path.GetDirectoryName(toolboxPath), e.Message);
                return 1;
            }

            Console.WriteLine("Opened ArcGIS toolbox \"{0}\".", toolboxPath);

            // Set up a handler for the IAppROTEvents.AppAdded event. This event
            // will be fired when we start ArcCatalog.exe and allows us to
            // obtain an IApplication interface, which we need to add the
            // toolbox to the list maintained by ArcCatalog.

            AppROTClass appROT = new AppROTClass();
            appROT.AppAdded += new IAppROTEvents_AppAddedEventHandler(appROT_AppAdded);

            // Start ArcCatalog.exe.
            //
            // I do not know how to prevent it from displaying the splash
            // screen. Setting the Splash value in the registry does not work,
            // like it does for ArcMap. Setting
            //
            //     startInfo.WindowStyle = ProcessWindowStyle.Hidden;
            //
            // does not work either. Adding the toolbox to ArcMap does not work
            // because then it ends up in an ArcMap document, not in the default
            // list of toolboxes.
            //
            // It may be possible to enumerate the top-level windows after the
            // process has popped it up and then make it invisible. But this is
            // a bunch of complex Win32 code I'm not going to get into now.

            ProcessStartInfo startInfo = new ProcessStartInfo(Path.Combine(arcGisInstallDir, "Bin\\ArcCatalog.exe"));
            startInfo.WindowStyle = ProcessWindowStyle.Hidden;
            Process p = null;

            Console.WriteLine("Starting \"{0}\"...", startInfo.FileName);
            try
            {
                p = Process.Start(startInfo);
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("ERROR: Failed start the program \"{0}\". Process.Start(\"{0}\") raised an exception: {1}", Path.Combine(arcGisInstallDir, "Bin\\ArcCatalog.exe"), e.Message);
                return 1;
            }

            // Wait for ArcCatalog.exe to exit.

            p.WaitForExit();
            if (Program.ReturnCode == 2)
                Console.Error.WriteLine("ERROR: ArcCatalog exited before we had the opportunity to {0} the toolbox.", Program.Operation);
            else
                Console.WriteLine("ArcCatalog has exited.");

            // Exit.

            return Program.ReturnCode;
        }

        static void appROT_AppAdded(AppRef pApp)
        {
            // Make the ArcCatalog window invisible. In my testing, this has no
            // effect, because we are invoked here before the window is visible.
            // When we call pApp.Shutdown() below, it causes ArcCatalog to exit
            // without ever showing the window. As far as I can tell, I could
            // leave the Visible property alone and everything would still work
            // fine.
            //
            // Note that this property has no apparent relationship to the
            // ArcCatalog splash screen. That screen comes up before we are
            // invoked here.

            pApp.Visible = false;

            // Obtain the ArcToolboxExtension object, which manages the list of
            // toolboxes present in ArcGIS applications.

            UIDClass uid = new UIDClass();
            uid.Value = "esriGeoprocessingUI.ArcToolboxExtension";
            IArcToolboxExtension ext = (IArcToolboxExtension)pApp.FindExtensionByCLSID(uid);

            // Add or remove the toolbox.

            if (Program.Operation == "register")
            {
                try
                {
                    ext.ArcToolbox.AddToolbox(Program.Toolbox);
                    Console.WriteLine("Registered the toolbox with ArcCatalog.");
                    Program.ReturnCode = 0;
                }
                catch (Exception e)
                {
                    Console.Error.WriteLine("ERROR: Failed to add ArcGIS toolbox \"{0}\" to the IArcToolboxExtension.ArcToolbox object. IArcToolboxExtension.ArcToolbox.AddToolbox(<IGPToolbox object>) raised an exception: {1}", Program.Toolbox.PathName, e.Message);
                    Program.ReturnCode = 1;
                }
            }
            else
            {
                // Unfortunately we can't just call ext.ArcToolbox.RemoveToolbox
                // and pass in Program.Toolbox. It does not seem to work. So we
                // have to get an appropriate IGPToolbox reference through this
                // circuitous logic.

                IGPTool tool1 = null;

                try
                {
                    tool1 = Program.Toolbox.Tools.Next();
                }
                catch
                {
                    Console.Error.WriteLine("ERROR: This toolbox cannot be unregistered from ArcCatalog because it does not have any tools inside it. Because ESRI's IArcToolbox interface does not have an API for enumerating the currently-registered toolboxes, there is no way we can check for a given toolbox unless we know the name of a tool within it. If you want to be able to unregister your toolbox using this program you must add at least one tool to it.");
                    Program.ReturnCode = 1;
                }

                if (tool1 != null)
                {
                    IGPTool tool2 = null;

                    try
                    {
                        if (Program.Toolbox.Alias is string && Program.Toolbox.Alias.Length > 0)
                            tool2 = ext.ArcToolbox.GetToolbyNameString(tool1.Name + "_" + Program.Toolbox.Alias);
                        else
                            tool2 = ext.ArcToolbox.GetToolbyNameString(tool1.Name);
                    }
                    catch
                    {
                        // Do nothing. GetToolbyNameString throws when the tool
                        // does not exist. This happens when the user tries to
                        // unregister a toolbox that is not registered.

                        Console.WriteLine("The toolbox is not currently registered with ArcCatalog, so there is no need to unregister it.");
                        Program.ReturnCode = 0;
                    }

                    if (tool2 != null && tool1.PathName == tool2.PathName)
                        try
                        {
                            ext.ArcToolbox.RemoveToolbox(tool2.Toolbox);
                            Console.WriteLine("Unregistered the toolbox from ArcCatalog.");
                            Program.ReturnCode = 0;
                        }
                        catch (Exception e)
                        {
                            Console.Error.WriteLine("ERROR: Failed to remove ArcGIS toolbox \"{0}\" from the IArcToolboxExtension.ArcToolbox object. IArcToolboxExtension.ArcToolbox.RemoveToolbox(<IGPToolbox object>) raised an exception: {1}", Program.Toolbox.PathName, e.Message);
                            Program.ReturnCode = 1;
                        }
                }
            }

            // Signal the application to exit.

            try
            {
                pApp.Shutdown();
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("ERROR: Failed to shut down ArcCatalog. IApplication.Shutdown() raised an exception: {0}", e.Message);
                Environment.Exit(1);
            }

            Console.WriteLine("Waiting for ArcCatalog to exit...");
        }
    }
}