Exemple #1
0
        /// <summary>
        ///     Gets the unopened page templates with the specified type and name.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="pageTemplateType">Type of the page template.</param>
        /// <param name="userName">Name of the page template.</param>
        /// <returns>
        ///     Returns a <see cref="IEnumerable{IMMPageTemplate}" /> representing the page templates.
        /// </returns>
        public static IEnumerable <IMMPageTemplate> GetUnopenedPageTemplates(this IMMPageTemplateManager source, mmPageTemplateType pageTemplateType, string userName)
        {
            var items = source.GetPageTemplateNames(pageTemplateType);

            foreach (var i in items.AsEnumerable())
            {
                yield return(source.GetUnopenedPageTemplate(i));
            }
        }
Exemple #2
0
        /// <summary>
        ///     Gets the user names that are associated with the user page templates.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <returns>
        ///     Returns a <see cref="IEnumerable{String}" /> representing the unique user names.
        /// </returns>
        public static IEnumerable <string> GetUserNames(this IMMPageTemplateManager source)
        {
            var userNames = new List <string>();
            var utils     = new MMTableUtilsClass();

            string[] tables = { UserPageTemplates, SystemPageTemplates };
            foreach (var t in tables)
            {
                var tableName = utils.GetFullSystemTableName(source.Workspace, t);
                var reader    = source.Workspace.ExecuteReader(string.Format("SELECT DISTINCT(USERNAME) FROM {0}", tableName));
                userNames.AddRange(reader.AsEnumerable().Select(o => o.GetValue(0, string.Empty)).ToArray());
            }

            return(userNames);
        }
Exemple #3
0
        /// <summary>
        ///     Gets the type of the page template.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="userName">Name of the user.</param>
        /// <returns>Returns a <see cref="mmPageTemplateType" /> representing the type for the user.</returns>
        public static mmPageTemplateType GetPageTemplateType(this IMMPageTemplateManager source, string userName)
        {
            switch (userName)
            {
            case "__DESIGNER__":
                return(mmPageTemplateType.mmPTTDesigner);

            case "__MAPSHEET__":
                return(mmPageTemplateType.mmPTTMapSheet);

            case "SYSTEM":
                return(mmPageTemplateType.mmPTTSystem);

            default:
                return(mmPageTemplateType.mmPTTUser);
            }
        }
Exemple #4
0
        private bool ShutdownArcMap()
        {
            IApplication pApp;
            IDocument pDoc;
            IMxDocument pMXDoc;
            IDocumentDirty2 pDocDirty;

            Type t = Type.GetTypeFromProgID("esriFramework.AppRef");
            System.Object obj = Activator.CreateInstance(t);
            pApp = obj as IApplication;
            pDoc = pApp.Document;
            pMXDoc = (IMxDocument)pDoc;
            pDocDirty = (IDocumentDirty2)pMXDoc;
            pDocDirty.SetClean();
            Workspace = null;
            ScriptEngine.BroadcastProperty("Workspace", this.Workspace, this);
            ScriptEngine.BroadcastProperty("FeatureClass", null, this);
            _SDMGR = null;
            _PTMGR = null;
            pSelection = null;
            m_pGN = null;
            pSC = null;
            pEditor = null;
            pDoc = null;
            pMXDoc = null;
            pApp.Shutdown();
            //Process iProc = Process.GetCurrentProcess();
            //iProc.Kill();

            Logger.WriteLine("Closing Arcmap");
            return true;
        }
Exemple #5
0
        private bool OpenPageTemplate(string SDName, string SDType)
        {
            try
            {
                this.Logger.WriteLine("OpenPageTemplate:" + SDName);

                IMMPageTemplateName pPTName;
                IMMEnumPageTemplateName pEPT;

                if (SDName == "")
                {
                    this.Logger.WriteLine("PageTemplate Name not provided");
                    return false;
                }
                else
                {
                    if (_PTMGR == null)
                    {
                        _PTMGR = (IMMPageTemplateManager) new MMPageTemplateManager();
                    }
                    _PTMGR.Workspace = this.Workspace;
                    pPTName = new MMPageTemplateNameClass();
                    pPTName.Name = SDName;

                    if (SDType.ToUpper() == "SYSTEM")
                    {
                        pEPT = _PTMGR.GetPageTemplateNames(mmPageTemplateType.mmPTTSystem);
                    }
                    else
                    {
                        pEPT = _PTMGR.GetPageTemplateNames(mmPageTemplateType.mmPTTUser);
                    }
                    // Get list of Stored Displays.  We have to do this because we have not logged in to ArcFM.
                    pPTName = pEPT.Next();
                    while (pPTName != null)
                    {
                        if (pPTName.Name.Trim().ToUpper() == SDName.Trim().ToUpper())
                        {
                            SW1.Reset();
                            SW1.Start();
                            try
                            {
                                _PTMGR.OpenPageTemplate(pPTName);
                                SW1.Stop();
                                RecordActionTime("Open Page Template :", SW1.ElapsedMilliseconds);
                            }
                            catch (Exception EX)
                            {
                                this.Logger.WriteLine("Error Opening Page Tempate :" + EX.Message + ":" + EX.StackTrace);
                                SW1.Stop();
                            }
                            break;
                        }
                        pPTName = pEPT.Next();
                    }
                    if (pPTName == null)
                    {
                        this.Logger.WriteLine("PageTemplate not found:" + SDName);
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
            }
            catch (Exception EX)
            {
                this.Logger.WriteLine("Error in OpenPageTempate:" + EX.Message + ":" + EX.StackTrace);
                return false;
            }
        }
Exemple #6
0
        /// <summary>
        ///     Gets the page template blobs for the specific type and users (optional)
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="pageTemplateType">Type of the page template.</param>
        /// <param name="userName">The page template user names.</param>
        /// <returns>
        ///     Returns a <see cref="IEnumerable{KeyValuePair{TKey, TValue}}" /> representing the page template and blob
        ///     value.
        /// </returns>
        public static IEnumerable <KeyValuePair <IMMPageTemplateName, IMemoryBlobStream> > GetBlobPageTemplates(this IMMPageTemplateManager source, mmPageTemplateType pageTemplateType, params string[] userName)
        {
            var filter = new QueryFilterClass();

            filter.WhereClause = "TEMPLATE IS NOT NULL";

            if (userName != null && userName.Any())
            {
                filter.WhereClause = string.Format("{0} AND USERNAME IN ('{1}')", filter.WhereClause, string.Join("','", userName));
            }

            ((IQueryFilterDefinition2)filter).PostfixClause = "ORDER BY USERNAME";

            var system = pageTemplateType == mmPageTemplateType.mmPTTSystem;

            return(GetPageTemplatesImpl(source, system, filter, row =>
            {
                var name = (string)row.Value[row.Fields.FindField("NAME")];
                var blob = (IMemoryBlobStream)row.Value[row.Fields.FindField("TEMPLATE")];

                var i = new MMPageTemplateNameClass();
                i.Initialize(row.OID, name, pageTemplateType);

                return new KeyValuePair <IMMPageTemplateName, IMemoryBlobStream>(i, blob);
            }));
        }
Exemple #7
0
        /// <summary>
        ///     Gets the page templates based on the filter and function delegate.
        /// </summary>
        /// <typeparam name="TKey">The type of the key.</typeparam>
        /// <typeparam name="TValue">The type of the value.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="system">if set to <c>true</c> if the page template manager references the system tables.</param>
        /// <param name="filter">The filter.</param>
        /// <param name="func">The function delegate that returns the key/value pair of the page template information.</param>
        /// <returns>
        ///     Returns a <see cref="KeyValuePair{TKey, TValue}" /> representing the page templates
        /// </returns>
        private static IEnumerable <KeyValuePair <TKey, TValue> > GetPageTemplatesImpl <TKey, TValue>(IMMPageTemplateManager source, bool system, IQueryFilter filter, Func <IRow, KeyValuePair <TKey, TValue> > func)
        {
            var utils     = new MMTableUtilsClass();
            var tableName = utils.GetFullSystemTableName(source.Workspace, system ? SystemPageTemplates : UserPageTemplates);
            var table     = utils.OpenTable(tableName, (IFeatureWorkspace)source.Workspace);

            var cursor = table.Search(filter, true);

            var cr = new ComReleaser();

            cr.ManageLifetime(cursor);

            return(cursor.AsEnumerable().Select(func));
        }
Exemple #8
0
        /// <summary>
        ///     Gets the unopened page templates with the specified type and name.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="userName">Name of the page template.</param>
        /// <returns>
        ///     Returns a <see cref="IEnumerable{IMMPageTemplate}" /> representing the page templates.
        /// </returns>
        public static IEnumerable <IMMPageTemplate> GetUnopenedPageTemplates(this IMMPageTemplateManager source, string userName)
        {
            var pageTemplateType = source.GetPageTemplateType(userName);

            return(source.GetUnopenedPageTemplates(pageTemplateType, userName));
        }