//
// (C) Copyright 2003-2014 by Autodesk, Inc.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. AUTODESK, INC.
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
//
// Use, duplication, or disclosure by the U.S. Government is subject to
// restrictions set forth in FAR 52.227-19 (Commercial Computer
// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii)
// (Rights in Technical Data and Computer Software), as applicable.
//
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk.Revit;
using System.Diagnostics;
using System.IO;
using System.Windows.Media;
using System.Windows.Forms;
using System.Windows.Media.Imaging;
using Autodesk.Revit.UI;
using Autodesk.Revit.DB;
using Autodesk.Revit.ApplicationServices;
using Autodesk.Revit.UI.Events;
using System.Windows;
using System.ComponentModel;
using KMBIM.Revit.Tools.Properties;
using System.Threading;
using System.Globalization;
using Autodesk.Revit.DB.Events;
using KMBIM.Revit.Tools.AvoidObstruction;
using KMBIM.Revit.Tools.Utils;
using KMBIM.Revit.Tools;
using Microsoft.Win32;
using KMBIM.Revit.Tools.License;
using KMBIM.Revit.Tools.Cmd.Hanger;
using System.Drawing;
using KDCS.Utils;
using System.Windows.Interop;
using System.Runtime.InteropServices;
using System.Runtime.ExceptionServices;
using KMBIM.Revit.Tools.Cmd.Piping;

namespace KMBIM.Revit.Tools
{

    [Autodesk.Revit.Attributes.Transaction(Autodesk.Revit.Attributes.TransactionMode.Manual)]
    [Autodesk.Revit.Attributes.Regeneration(Autodesk.Revit.Attributes.RegenerationOption.Manual)]
    [Autodesk.Revit.Attributes.Journaling(Autodesk.Revit.Attributes.JournalingMode.NoCommandData)]
    public class App : IExternalApplication
    {
        internal static App thisApp = null;
        internal static DisplayUnit CurrentDisplayUnit { get; set; }
        internal static List<string> hanger_families = new List<string>();


        // ExternalCommands assembly path
        static string AddInPath = typeof(App).Assembly.Location;

        // Button icons directory
        static string ButtonIconsFolder = Path.GetDirectoryName(AddInPath);
        // uiApplication
        public static UIApplication uiApplication = null;
        static Utils.WindowWrapper _hWndRevit = null;

        public Form_SetPipeTypeCode m_wfSetPipeTypeCode { get; set; } // 3.0
        public FormAvoidObstruction m_wfAvoidObstruction { get; set; }
        public FormPipeConnector m_wfPipeConnector { get; set; }


        private bool bUseNewFeature2 = false;  // Version 2ÀÇ »õ ±â´É »ç¿ë


        /*        
        // ºä È°¼ºÈ­ ½Ã ó¸®
        /*
        void onViewActivated(object sender, ViewActivatedEventArgs e)
        {
           

            Autodesk.Revit.DB.View vCurrent = e.CurrentActiveView;
            Document doc = e.Document;

            //  È­¸é Ç¥½Ã ´ÜÀ§°¡ ¹Ù²ï °æ¿ì ó¸®
            if (doc.DisplayUnitSystem != App.CurrentDisplayUnit)
            {
                App.CurrentDisplayUnit = doc.DisplayUnitSystem;
               // AddPushButtonImageManualPlacement();
             
            }

            return;


            string pathname = doc.PathName;
            TaskDialog.Show("asd", pathname);
            string id = Convert.ToString(vCurrent.Id);
            string name = vCurrent.Name;
            string userName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
            string now = Convert.ToString(DateTime.Now);
            string content = now + ", " + id + ", " + name + ", " + userName + "\n";

  
        }
         */

#if _v3
        public void OpenFormSetPipeTypeCode(ExternalCommandData commandData, UIApplication uiapp)
        {
            if (m_wfSetPipeTypeCode == null || m_wfSetPipeTypeCode.IsDisposed)
            {
                // A new handler to handle request posting by the dialog
                PTC_RequestHandler handler = new PTC_RequestHandler();
            
                // External Event for the dialog to use (to post requests)
                ExternalEvent exEvent = ExternalEvent.Create(handler);
            
                // We give the objects to the new dialog;
                // The dialog becomes the owner responsible fore disposing them, eventually.
                m_wfSetPipeTypeCode = new Form_SetPipeTypeCode(commandData, uiapp, exEvent, handler);
                //´ëÈ­»óÀÚ À§Ä¡ Á¶Á¤
                Autodesk.Revit.DB.Rectangle rect = uiapp.MainWindowExtents;
                m_wfSetPipeTypeCode.Location = new System.Drawing.Point(rect.Right - 300, rect.Top + 200);
            }
        }

        public void ShowFormSetPipeTypeCode(ExternalCommandData commandData, UIApplication uiapp)
        {
             //If we do not have a dialog yet, create and show it
            if (m_wfSetPipeTypeCode == null || m_wfSetPipeTypeCode.IsDisposed)
            {
                // A new handler to handle request posting by the dialog
                PTC_RequestHandler handler = new PTC_RequestHandler();
            
                // External Event for the dialog to use (to post requests)
                ExternalEvent exEvent = ExternalEvent.Create(handler);
            
                // We give the objects to the new dialog;
                // The dialog becomes the owner responsible fore disposing them, eventually.
                m_wfSetPipeTypeCode = new Form_SetPipeTypeCode(commandData, uiapp, exEvent, handler);
                           
            }
            
            if (null == _hWndRevit)
            {
                Process process = Process.GetCurrentProcess();
                IntPtr h = process.MainWindowHandle;
                _hWndRevit = new WindowWrapper(h);
            }


            m_wfSetPipeTypeCode.Show(_hWndRevit);
        }
        public void WakeFormSetPipeTypeCode()
        {
            if (m_wfSetPipeTypeCode != null)
            {
                m_wfSetPipeTypeCode.WakeUp();
            }
        }
#endif

        public void OpenFormAvoidObstruction(UIApplication uiapp)
        {
            // If we do not have a dialog yet, create and show it
            if (m_wfAvoidObstruction == null || m_wfAvoidObstruction.IsDisposed)
            {
                // A new handler to handle request posting by the dialog
                KDCSRequestHandler handler = new KDCSRequestHandler();

                // External Event for the dialog to use (to post requests)
                ExternalEvent exEvent = ExternalEvent.Create(handler);

                // We give the objects to the new dialog;
                // The dialog becomes the owner responsible fore disposing them, eventually.
                m_wfAvoidObstruction = new FormAvoidObstruction(uiapp, exEvent, handler);

            }
        }

        public void ShowFormAvoidObstruction(UIApplication uiapp)
        {
            // If we do not have a dialog yet, create and show it
            if (m_wfAvoidObstruction == null || m_wfAvoidObstruction.IsDisposed)
            {
                // A new handler to handle request posting by the dialog
                KDCSRequestHandler handler = new KDCSRequestHandler();

                // External Event for the dialog to use (to post requests)
                ExternalEvent exEvent = ExternalEvent.Create(handler);

                // We give the objects to the new dialog;
                // The dialog becomes the owner responsible fore disposing them, eventually.
                m_wfAvoidObstruction = new FormAvoidObstruction(uiapp, exEvent, handler);
            }

            if (null == _hWndRevit)
            {
                Process process = Process.GetCurrentProcess();                
                IntPtr h = process.MainWindowHandle;
                _hWndRevit = new WindowWrapper(h);
            }


            m_wfAvoidObstruction.Show(_hWndRevit);
        }


        public void WakeFormAvoidObstruction()
        {
            if (m_wfAvoidObstruction != null)
            {
                m_wfAvoidObstruction.WakeUp();
            }
        }
#region ¹è°ü¿¬°á
        public void OpenFormPipeConnector(UIApplication uiapp)
        {

            // If we do not have a dialog yet, create and show it
            if (m_wfPipeConnector == null || m_wfPipeConnector.IsDisposed)
            {
                // A new handler to handle request posting by the dialog
                RequestHandlerPipeConnect handler = new RequestHandlerPipeConnect();

                // External Event for the dialog to use (to post requests)
                ExternalEvent exEvent = ExternalEvent.Create(handler);

                // We give the objects to the new dialog;
                // The dialog becomes the owner responsible fore disposing them, eventually.
                m_wfPipeConnector = new FormPipeConnector(uiapp, exEvent, handler);

            }
        }

        public void ShowFormPipeConnector(UIApplication uiapp, Element base_element, XYZ p1, Element target_element, XYZ p2)
        {

            // If we do not have a dialog yet, create and show it
            if (m_wfPipeConnector == null || m_wfPipeConnector.IsDisposed)
            {
                // A new handler to handle request posting by the dialog
                RequestHandlerPipeConnect handler = new RequestHandlerPipeConnect();

                // External Event for the dialog to use (to post requests)
                ExternalEvent exEvent = ExternalEvent.Create(handler);

                // We give the objects to the new dialog;
                // The dialog becomes the owner responsible fore disposing them, eventually.
                m_wfPipeConnector = new FormPipeConnector(uiapp, exEvent, handler);
            }

            if (null == _hWndRevit)
            {
                Process process = Process.GetCurrentProcess();

                IntPtr h = process.MainWindowHandle;
                _hWndRevit = new WindowWrapper(h);
            }

            m_wfPipeConnector.Init(base_element, p1, target_element, p2);
            m_wfPipeConnector.Show(_hWndRevit);
        }


        public void WakeFormPipeConnector()
        {
            if (m_wfPipeConnector != null)
            {
                m_wfPipeConnector.WakeUp();
            }
        }
#endregion


#region IExternalApplication Members
        /// <summary>
        /// Implement this method to implement the external application which should be called when 
        /// Revit starts before a file or default template is actually loaded.
        /// </summary>
        /// <param name="application">An object that is passed to the external application 
        /// which contains the controlled application.</param>
        /// <returns>Return the status of the external application. 
        /// A result of Succeeded means that the external application successfully started. 
        /// Cancelled can be used to signify that the user cancelled the external operation at 
        /// some point.
        /// If Failed is returned then Revit should inform the user that the external application 
        /// failed to load and the release the internal reference.</returns>
        public Autodesk.Revit.UI.Result OnStartup(UIControlledApplication application)
        {
            try
            {

                FormAuth auth = new FormAuth();
                auth.Init(false);


                //¹öÀü¾÷ ¶§ auth.GetUseNewFeature()->True º¯°æÇÏ¸é µÊ.
                bUseNewFeature2 = auth.GetUseNewFeature();  // ¹öÀü-2:  »õ ±â´ÉÀ» »ç¿ëÇÒ ¼ö ÀÖ´Â ±ÇÇÑ ºÎ¿©
                bUseNewFeature2 = true;


                AuthKey authKey = new AuthKey();
                string strSerialNumber = string.Empty, strAuthCodeReg = string.Empty;
                string strAC = string.Empty;
                authKey.GetSerialNumber(ref strSerialNumber);

                // ÀÎÁõ¿¹¿Ü
                if (strSerialNumber.CompareTo("GKDK110SBQR4HHTQMH6RV87") == 0)
                {
                    var wm = WorkMain.GetInstance();
                    wm.IsValid = true;                    
                }

                //=======================================================================================
                m_wfAvoidObstruction = null; // Ãæµ¹(Àå¾Ö¹°) ȸÇÇ ´ëÈ­»óÀÚ°¡ ¾ÆÁ÷ Áغñ ¾ÈµÊ.
#if _v3
                m_wfSetPipeTypeCode = null;
#endif
                thisApp = this;  // static access to this application instance
                App.CurrentDisplayUnit = DisplayUnit.METRIC;
                application.ControlledApplication.DocumentOpened += new EventHandler<DocumentOpenedEventArgs>(DocumentOpened);
                application.ControlledApplication.DocumentCreated += new EventHandler<DocumentCreatedEventArgs>(DocumentCreated);
                //ºä ¹Ù²Ù´Â À̺¥Æ® °¨Áö
                application.ViewActivated += new EventHandler<Autodesk.Revit.UI.Events.ViewActivatedEventArgs>(OnViewActivated);
                application.ViewActivating += new EventHandler<Autodesk.Revit.UI.Events.ViewActivatingEventArgs>(OnViewActivating);
                // create customer Ribbon Items
                CreateRibbonPanel(application);

                //application.ViewActivated += new EventHandler<Autodesk.Revit.UI.Events.ViewActivatedEventArgs>(onViewActivated);
                // Çà°Å
                //HangerSchema.SetAddInId(application.ActiveAddInId);
                //HangerSchema.Init();

                return Autodesk.Revit.UI.Result.Succeeded;
            }
            catch (Exception ex)
            {
                TaskDialog.Show("KMBIM.Revit.Tools", ex.ToString());

                return Autodesk.Revit.UI.Result.Failed;
            }
        }




        [HandleProcessCorruptedStateExceptions]


        /// <summary>
        /// Implement this method to implement the external application which should be called when 
        /// Revit is about to exit, Any documents must have been closed before this method is called.
        /// </summary>
        /// <param name="application">An object that is passed to the external application 
        /// which contains the controlled application.</param>
        /// <returns>Return the status of the external application. 
        /// A result of Succeeded means that the external application successfully shutdown. 
        /// Cancelled can be used to signify that the user cancelled the external operation at 
        /// some point.
        /// If Failed is returned then the Revit user should be warned of the failure of the external 
        /// application to shut down correctly.</returns>
        public Autodesk.Revit.UI.Result OnShutdown(UIControlledApplication application)
        {
            //remove events
            //List<RibbonPanel> myPanels = application.GetRibbonPanels();
            //Autodesk.Revit.UI.ComboBox comboboxLevel = (Autodesk.Revit.UI.ComboBox)(myPanels[0].GetItems()[2]);
            //application.ControlledApplication.DocumentCreated -= new EventHandler<
            //   Autodesk.Revit.DB.Events.DocumentCreatedEventArgs>(DocumentCreated);


            return Autodesk.Revit.UI.Result.Succeeded;
        }
        #endregion

        /// <summary>
        /// This method is used to create RibbonSample panel, and add wall related command buttons to it:
        /// 1. contains a SplitButton for user to create Non-Structural or Structural Wall;
        /// 2. contains a StackedBotton which is consisted with one PushButton and two Comboboxes, 
        /// PushButon is used to reset all the RibbonItem, Comboboxes are use to select Level and WallShape
        /// 3. contains a RadioButtonGroup for user to select WallType.
        /// 4. Adds a Slide-Out Panel to existing panel with following functionalities:
        /// 5. a text box is added to set mark for new wall, mark is a instance parameter for wall, 
        /// Eg: if user set text as "wall", then Mark for each new wall will be "wall1", "wall2", "wall3"....
        /// 6. a StackedButton which consisted of a PushButton (delete all the walls) and a PulldownButton (move all the walls in X or Y direction)
        /// </summary>
        /// <param name="application">An object that is passed to the external application 
        /// which contains the controlled application.</param>
        private void CreateRibbonPanel(UIControlledApplication application)
        {
            // KMBIM Revit X-Tools  
            string TabName = "KMBIM"; // ÅÇ À̸§
            application.CreateRibbonTab(TabName);

            var wm = WorkMain.GetInstance();


            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //********ȯ°æ¼³Á¤ ÆгΠÃß°¡********
            Autodesk.Revit.UI.RibbonPanel rpOptions = application.CreateRibbonPanel(TabName, "¼³Á¤");
            PushButtonData pbdOpts = new PushButtonData("ȯ°æ", "ȯ°æ", AddInPath, "KMBIM.settings");
            pbdOpts.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Option);
            PushButton pbOpts = rpOptions.AddItem(pbdOpts) as PushButton;
            pbOpts.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //********À¯Æ¿¸®Æ¼ ÆгΠÃß°¡********
            Autodesk.Revit.UI.RibbonPanel rpUtility = application.CreateRibbonPanel(TabName, "À¯Æ¿¸®Æ¼");
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //»çÀÌÁî °è»ê
            PushButtonData pbdCalPad = new PushButtonData("°è»ê", "°è»ê", AddInPath, "KMBIM.CalpadLoad");
            pbdCalPad.ToolTip = Resources.Ext2Lvl_Desc;
            pbdCalPad.LongDescription = Resources.Ext2Lvl_Desc;
            pbdCalPad.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Calc);
            PushButton pbCalPad = rpUtility.AddItem(pbdCalPad) as PushButton;


            //¹«·á Å×½ºÆ® ±â´É
            pbCalPad.Enabled = true;
            //pbCalPad.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            //ÆdzÚ, Åä±Û ¹öÆ° ¸¸µé±â(ÁÜ µ¿±âÈ­)
            if (bUseNewFeature2)
            {
                PushButtonData data = new PushButtonData("Toggle", "Off", AddInPath, "KMBIM.Copy_Zoom_State");
                data.AvailabilityClassName = "ToggleButton.Availability";
                //±×¸² ¹× µµ¿ò¸» ³Ö±â
                data.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Zoom_Syn);
                data.ToolTip = "ºä À§Ä¡¸¦ °íÁ¤ÇÕ´Ï´Ù.";
                //PushButton pbtoggle = panel.AddItem(data) as PushButton;
                //pbtoggle.Enabled = wm.IsValid;
                _button = rpUtility.AddItem(data);
                _button.Enabled = wm.IsValid;
            }
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------

            //*½Å±â´É*
            //ÇÊÅÍ 23.08.22
            if (bUseNewFeature2)
            {
                PushButtonData VisibleFilter = new PushButtonData("ÇÊÅÍ", "ÇÊÅÍ", AddInPath, "KMBIM.VisibleFilter");
                VisibleFilter.ToolTip = Resources.Ext2Lvl_Desc;
                VisibleFilter.LongDescription = Resources.Ext2Lvl_Desc;
                VisibleFilter.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Lvl_Cor);
                PushButton pbFilter = rpUtility.AddItem(VisibleFilter) as PushButton;
                pbFilter.Enabled = wm.IsValid;
            }



            //*½Å±â´É*
            //»ö»ó Á¤ÀÇ
            if (bUseNewFeature2)
            {
                PushButtonData ColorSort = new PushButtonData("»ö»ó", "»ö»ó", AddInPath, "KMBIM.ColorSort");
                ColorSort.ToolTip = Resources.Ext2Lvl_Desc;
                ColorSort.LongDescription = Resources.Ext2Lvl_Desc;
                ColorSort.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Lvl_Cor);
                PushButton pbColorSort = rpUtility.AddItem(ColorSort) as PushButton;
                pbColorSort.Enabled = wm.IsValid;
            }
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //°£¼· ȸÇÇ
            PushButtonData pbdAvoidObstruction = new PushButtonData("ȸÇÇ", "ȸÇÇ", AddInPath, "KMBIM.AvoidObstructionCommand");
            pbdAvoidObstruction.ToolTip = Resources.Table1Desc;
            pbdAvoidObstruction.LongDescription = Resources.Table1Desc;
            pbdAvoidObstruction.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Avoid01);
            PushButton pbAvoidObstruction = rpUtility.AddItem(pbdAvoidObstruction) as PushButton;
            pbAvoidObstruction.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            //ÆÄÀÌÇÁ ´öÆ® µî ½ÅÃà
            if (bUseNewFeature2)
            {
                PushButtonData pbdStretch = new PushButtonData("½ÅÃà", "½ÅÃà", AddInPath, "KMBIM.Stretch");
                pbdStretch.ToolTip = Resources.Ext2Lvl_Desc;
                pbdStretch.LongDescription = Resources.Ext2Lvl_Desc;
                pbdStretch.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Stretch);
                PushButton pbStretch = rpUtility.AddItem(pbdStretch) as PushButton;
                //¹«·á Å×½ºÆ® ±â´É
                pbStretch.Enabled = true;
                //pbStretch.Enabled = wm.IsValid;
            }

            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //´öÆ®,ÆÄÀÌÇÁ ¼±Åà ÀÚ¸£±â
            PushButtonData pbdTrimSpacing = new PushButtonData("ÀÚ¸£±â", "ÀÚ¸£±â", AddInPath, "KMBIM.ElementTrim");
            pbdTrimSpacing.ToolTip = Resources.ElementTrim_Desc;
            pbdTrimSpacing.LongDescription = Resources.ElementTrim_Desc;
            pbdTrimSpacing.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Cut);
            PushButton pbTrimSpacing = rpUtility.AddItem(pbdTrimSpacing) as PushButton;
            pbTrimSpacing.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //¿¢¼¿ ³»º¸³»±â
            PushButtonData pbdExcel = new PushButtonData("³»º¸³»±â", "³»º¸³»±â", AddInPath, "KMBIM.DCSTableCmd1");
            pbdExcel.ToolTip = Resources.Table1Desc;
            pbdExcel.LongDescription = Resources.Table1Desc;
            pbdExcel.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Excel01);
            PushButton pbExcel = rpUtility.AddItem(pbdExcel) as PushButton;
            pbExcel.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //¸Å°³º¯¼ö º¹»ç
            PushButtonData MatchProp = new PushButtonData("º¯¼öº¹»ç", "º¯¼öº¹»ç", AddInPath, "KMBIM.MatchProp");
            MatchProp.ToolTip = "Æйи® ¿ä¼ÒÀÇ ÆĶó¹ÌÅ͸¦ ¼±Åà º¹»çÇÕ´Ï´Ù.";
            MatchProp.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Prop_CP);
            MatchProp.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Prop_CP); ;
            PushButton pbMatchProp = rpUtility.AddItem(MatchProp) as PushButton;
            pbMatchProp.Enabled = wm.IsValid;     
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------

            //******** ¹è°ü ÆгΠÃß°¡********
            //------------------------------------------------------------------------------------------------------------------------------------------
            Autodesk.Revit.UI.RibbonPanel rpPipe = application.CreateRibbonPanel(TabName, "¹è°ü");
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------            
            //*½Å±â´É*
            // ¹è°üÀÚµ¿¿¬°á
            if (bUseNewFeature2)
            {
                PushButtonData pbdPipeAutoConnect = new PushButtonData("¹è°ü¿¬°á", "¹è°ü¿¬°á", AddInPath, "KMBIM.PipeConnectionCmd");
                pbdPipeAutoConnect.ToolTip = Resources.CrossConnectT_Desc;
                pbdPipeAutoConnect.LongDescription = Resources.CrossConnectT_Desc;
                pbdPipeAutoConnect.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Con);
                PushButton pbPAC = rpPipe.AddItem(pbdPipeAutoConnect) as PushButton;
                pbPAC.Enabled = wm.IsValid;
            }
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //³­¹æÄÚÀÏ
            PushButtonData pbdCoil = new PushButtonData("ÄÚÀÏ", "ÄÚÀÏ", AddInPath, "KMBIM.CoilMain");
            pbdCoil.ToolTip = Resources.HCoil_Desc;
            pbdCoil.LongDescription = Resources.HCoil_Desc;
            pbdCoil.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Coil);
            PushButton pbCoil = rpPipe.AddItem(pbdCoil) as PushButton;
            pbCoil.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            //³ôÀÌÀÏÄ¡ °£°ÝÁ¶Á¤ ½ºÇø´ ¹öÆ°
            PipeSortSplitButton(rpPipe);

            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            //º¼Æ®¼³Ä¡
            if (bUseNewFeature2)
            {
                PushButtonData pbdInstallBolt = new PushButtonData("º¼Æ®", "º¼Æ®", AddInPath, "KMBIM.FixingBolt");
                pbdInstallBolt.ToolTip = Resources.Ext2Lvl_Desc;
                pbdInstallBolt.LongDescription = Resources.Ext2Lvl_Desc;
                pbdInstallBolt.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Bolt);
                PushButton pbInstallBolt = rpPipe.AddItem(pbdInstallBolt) as PushButton;
                pbInstallBolt.Enabled = wm.IsValid;
            }
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //¹è°ü ÀÏÁ¤ °£°Ý ÀÚ¸£±â
            PushButtonData pbdPipeTrimSpacing = new PushButtonData("ÇѺ»", "ÇѺ»", AddInPath, "KMBIM.PipeTrimSpacing");
            pbdPipeTrimSpacing.ToolTip = Resources.PipeTrimSpacing_Desc;
            pbdPipeTrimSpacing.LongDescription = Resources.PipeTrimSpacing_Desc;
            pbdPipeTrimSpacing.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_One);
            PushButton pbPipeTrimSpacing = rpPipe.AddItem(pbdPipeTrimSpacing) as PushButton;
            pbPipeTrimSpacing.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------



            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            // ********¼³Ä¡ ÆгΠÃß°¡********
            Autodesk.Revit.UI.RibbonPanel rpInstall = application.CreateRibbonPanel(TabName, "¼³Ä¡");
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //Çì´õ
            HeaderAddSplitButton(rpInstall);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            //¾î¼Àºí¸®
            if (bUseNewFeature2)
            {
                PushButtonData pbdAssem = new PushButtonData("¸ÅÅ©·Î", "¸ÅÅ©·Î", AddInPath, "KMBIM.AssemblyMain");
                pbdAssem.ToolTip = Resources.Assembly_Desc;
                pbdAssem.LongDescription = Resources.Assembly_Desc;
                pbdAssem.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Asm);
                PushButton pbAssem = rpPipe.AddItem(pbdAssem) as PushButton;
                pbAssem.Enabled = wm.IsValid;
            }
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //»ó´Üä³Î,ÇÏ´Ü°¡´ë 
            InstallChannelSplitButton(rpInstall);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //Çà°Å ¹èÄ¡
            //Autodesk.Revit.UI.RibbonPanel rpPlaceHanger = application.CreateRibbonPanel(TabName, "Çà°Å");
            PlaceHangerAddSplitButton(rpInstall);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------

            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //********ÆíÁý ÆгΠÃß°¡********
            Autodesk.Revit.UI.RibbonPanel rpEdit = application.CreateRibbonPanel(TabName, "ÆíÁý");
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------

            //T ¿¬°á
            PushButtonData pbdPipeT = new PushButtonData("Tee¿¬°á", "Tee¿¬°á", AddInPath, "KMBIM.PipeConnectT");
            pbdPipeT.ToolTip = Resources.CrossConnectT_Desc;
            pbdPipeT.LongDescription = Resources.CrossConnectT_Desc;
            pbdPipeT.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Tee);
            PushButton pbPipeT = rpEdit.AddItem(pbdPipeT) as PushButton;
            pbPipeT.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //·¹º§¿¬Àå,ºÎÇ°°£°Ý ½ºÇø´¹öÆ°
            EditSplitButton(rpEdit);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------



            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            // ********¼Ò¹æ ÆгΠÃß°¡********
            Autodesk.Revit.UI.RibbonPanel rpFire = application.CreateRibbonPanel(TabName, "¼Ò¹æ");
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //½ºÇÁ¸µ Ŭ·¯ Çìµå ¹èÄ¡
            SprinKlerAddSplitButton(rpFire);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            // ½ºÇÁ¸µÅ¬·¯ »óÇâ½Ä ÀÚµ¿ ÆгΠÃß°¡
            // Autodesk.Revit.UI.RibbonPanel rpSpklrUpAuto = application.CreateRibbonPanel(TabName, "»óÇâ½Ä");
            SpklrAddUpAutoSplitButton(rpFire);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            // ½ºÇÁ¸µÅ¬·¯ ÇÏÇâ½Ä ÀÚµ¿ ÆгΠÃß°¡
            //Autodesk.Revit.UI.RibbonPanel rpSpklrDownAuto = application.CreateRibbonPanel(TabName, "ÇÏÇâ½Ä");
            SpklrAddDownAutoSplitButton(rpFire);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------


            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //´Ü¿­Àç ÀÏ°ýÁ¤ÀÇ
            // ****************½½¸®ºê ´Ü¿­Àç ÆгΠÃß°¡****************
            Autodesk.Revit.UI.RibbonPanel rpSleeveInsulation = application.CreateRibbonPanel(TabName, "´Ü¿­ ¹× ½½¸®ºê");
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //½½¸®ºê ´Ü¿­Àç ¼³Á¤
            PushButtonData pbdSleeveInsulationSettings = new PushButtonData("´Ü¿­Àç", "´Ü¿­Àç", AddInPath, "KMBIM.Revit.Tools.Cmd.Insulation.InsulationSettingsCommand");
            pbdSleeveInsulationSettings.ToolTip = "´Ü¿­Àç ¼³Á¤";
            pbdSleeveInsulationSettings.LongDescription = "º® ¶Ç´Â ¹Ù´ÚÀ» °üÅëÇÏ´Â ¹è°ü ¶Ç´Â ´öÆ®ÀÇ ½½¸®ºêÀÇ ´Ü¿­À縦 ¼³Á¤ÇÕ´Ï´Ù.";
            pbdSleeveInsulationSettings.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Insul);
            PushButton pbSleeveInsulationSettings = rpSleeveInsulation.AddItem(pbdSleeveInsulationSettings) as PushButton;
            pbSleeveInsulationSettings.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------            
            // ½½¸®ºê
            PushButtonData pbdSleeve = new PushButtonData("½½¸®ºê", "½½¸®ºê", AddInPath, "KMBIM.Revit.Tools.Cmd.Sleeve.SleeveCommand");
            pbdSleeve.ToolTip = "½½¸®ºê ¹èÄ¡";
            pbdSleeve.LongDescription = "º® ¶Ç´Â ¹Ù´ÚÀ» °üÅëÇÏ´Â ¹è°ü ¶Ç´Â ´öÆ® À§Ä¡¿¡ ½½¸®ºê¸¦ ¹èÄ¡ÇÕ´Ï´Ù.";
            pbdSleeve.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.sleeve);
            PushButton pbSleeve = rpSleeveInsulation.AddItem(pbdSleeve) as PushButton;
            pbSleeve.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            // ½½¸®ºê À϶÷Ç¥
            PushButtonData pbdSleeveTable = new PushButtonData("SlvÀ϶÷", "SlvÀ϶÷", AddInPath, "KMBIM.SleeveTableCommand");
            pbdSleeveTable.ToolTip = "½½¸®ºê À϶÷Ç¥";
            pbdSleeveTable.LongDescription = "½½¸®ºêÀÇ À϶÷Ç¥¸¦ »ý¼ºÇÕ´Ï´Ù.";
            pbdSleeveTable.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Slv_Sch);
            PushButton pbSleeveTable = rpSleeveInsulation.AddItem(pbdSleeveTable) as PushButton;
            pbSleeveTable.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------



            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            // Ä¡¼ö ÆгΠÃß°¡
            Autodesk.Revit.UI.RibbonPanel rpDimension = application.CreateRibbonPanel(TabName, "¹®¼­È­");
            //Ä¡¼ö±âÀÔ
            DimAddSplitButton(rpDimension);
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //»óÇÏÇâ½Ä ű×
            PushButtonData pbdUpDownTag = new PushButtonData("ÀÔ»óÀÔÇÏ", "ÀÔ»óÀÔÇÏ", AddInPath, "KMBIM.MultiPipeTag");
            pbdUpDownTag.ToolTip = "»ó¤ýÇÏÇâ½Ä ű×";
            pbdUpDownTag.LongDescription = "¼±ÅÃÇÑ ÆÄÀÌÇÁÀÇ »ó¤ýÇÏÇâ½ÄÀÇ Å±׸¦ ±âÀÔÇÕ´Ï´Ù.";
            pbdUpDownTag.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Riser_UPDN);    // 32x32
            pbdUpDownTag.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Riser_UPDN);       // 16x16
            PushButton pbUpDownTag = rpDimension.AddItem(pbdUpDownTag) as PushButton;
            pbUpDownTag.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            //ÀÏ°ýÄ¡¼ö
            // if (bUseNewFeature2)
            {
                //PushButtonData pbdMtag = new PushButtonData("ÀÏ°ýÄ¡¼ö", "ÀÏ°ýÄ¡¼ö", AddInPath, "KMBIM.MultiTag");
                PushButtonData pbdMtag = new PushButtonData("¹­À½", "¹­À½", AddInPath, "KMBIM.NewMultiTag");
                pbdMtag.ToolTip = Resources.Ext2Lvl_Desc;
                pbdMtag.LongDescription = Resources.Ext2Lvl_Desc;
                pbdMtag.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Siz);
                PushButton pbMtag = rpDimension.AddItem(pbdMtag) as PushButton;
                //¹«·á Å×½ºÆ® ±â´É
                pbMtag.Enabled = true;
                //pbMtag.Enabled = wm.IsValid;

            }

            // ´öÆ® ÆгΠÃß°¡
            //------------------------------------------------------------------------------------------------------------------------------------------
           
            Autodesk.Revit.UI.RibbonPanel rpDuct = application.CreateRibbonPanel(TabName, "´öÆ®");
#if _v3       
           //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
           //// dz·® ÀÔ·Â
           PushButtonData pbdDuctVi = new PushButtonData("dz·® ÀÔ·Â", "dz·® ÀÔ·Â", AddInPath, "KMBIM.Revit.Tools.Cmd.DuctSize.DuctViCmd");
           pbdDuctVi.ToolTip = Resources.CrossConnectT_Desc;
           pbdDuctVi.LongDescription = Resources.CrossConnectT_Desc;
           pbdDuctVi.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Vol_Edit);
           PushButton pbDuctVi = rpDuct.AddItem(pbdDuctVi) as PushButton;
           pbDuctVi.Enabled = wm.IsValid;
           ////------------------------------------------------------------------------------------------------------------------------------------------------------------------------
           //// ´öÆ® »çÀÌÁî °è»ê
           PushButtonData pbdDcal = new PushButtonData("´öÆ® »çÀÌÁî", "´öÆ® »çÀÌÁî", AddInPath, "KMBIM.Revit.Tools.Cmd.DuctSize.DuctSizeCmd");
           pbdDcal.ToolTip = Resources.CrossConnectT_Desc;
           pbdDcal.LongDescription = Resources.CrossConnectT_Desc;
           pbdDcal.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.dcalsize32x32);
           PushButton pbDcal = rpDuct.AddItem(pbdDcal) as PushButton;
           pbDcal.Enabled = wm.IsValid;
           // ´ëÇàÀÚ¸¦ ´öÆ®·Î º¯È¯(´öÆ®ÀÚµ¿ÀÛµµ)
           PushButtonData pbdAtd = new PushButtonData("´ëÇàÀÚ º¯È¯", "´ëÇàÀÚ º¯È¯", AddInPath, "KMBIM.Revit.Tools.Cmd.DuctDraw.DuctDrawCmd");
           pbdAtd.ToolTip = Resources.CrossConnectT_Desc;
           pbdAtd.LongDescription = Resources.CrossConnectT_Desc;
           pbdAtd.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.B_ATD);
           PushButton pbAtd = rpDuct.AddItem(pbdAtd) as PushButton;
           pbAtd.Enabled = wm.IsValid;
     

            
#endif

            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            // FD : Ç÷º½Ãºí ´öÆ® ¿¬°á
            if (bUseNewFeature2)
            {
                PushButtonData pbdDfb = new PushButtonData("Flex", "Flex", AddInPath, "KMBIM.Revit.Tools.CmdDuct.FlexibleDuctDiffuserCmd");
                pbdDfb.ToolTip = Resources.CrossConnectT_Desc;
                pbdDfb.LongDescription = Resources.CrossConnectT_Desc;
                pbdDfb.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.fd);
                PushButton pbDfb = rpDuct.AddItem(pbdDfb) as PushButton;
                pbDfb.Enabled = wm.IsValid;
            }
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //´öÆ® ÀÏÁ¤ °£°Ý ÀÚ¸£±â
            PushButtonData pbdDuctTrimSpacing = new PushButtonData("Ç÷£Áö", "Ç÷£Áö", AddInPath, "KMBIM.DuctTrimSpacing");
            pbdDuctTrimSpacing.ToolTip = Resources.DuctTrimSpacing_Desc;
            pbdDuctTrimSpacing.LongDescription = Resources.DuctTrimSpacing_Desc;
            pbdDuctTrimSpacing.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Duct_Fl);
            PushButton pbDuctTrimSpacing = rpDuct.AddItem(pbdDuctTrimSpacing) as PushButton;
            pbDuctTrimSpacing.Enabled = wm.IsValid;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //*½Å±â´É*
            ////S´öÆ®
            //if (bUseNewFeature2)
            //{
            //    PushButtonData DuctOffsetConnect = new PushButtonData("S ´öÆ®", "S ´öÆ®", AddInPath, "KMBIM.DuctOffsetConnect");
            //    DuctOffsetConnect.ToolTip = Resources.DuctOffsetConnect_Desc;
            //    DuctOffsetConnect.LongDescription = Resources.DuctOffsetConnect_Desc;
            //    DuctOffsetConnect.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.wgdp);
            //    PushButton pbDuctOffsetConnect = rpDuct.AddItem(DuctOffsetConnect) as PushButton;
            //    pbDuctOffsetConnect.Enabled = wm.IsValid;
            //}

            //********ÄÚµå ÆгΠÃß°¡********
            //Autodesk.Revit.UI.RibbonPanel test = application.CreateRibbonPanel(TabName, "TEST");
            //PushButtonData pbdTypeCode = new PushButtonData("½ÃÆ®¸µÅ©", "½ÃÆ®¸µÅ©", AddInPath, "KMBIM.SheetLink");
            //pbdTypeCode.ToolTip = Resources.CrossConnectT_Desc;
            //pbdTypeCode.LongDescription = Resources.CrossConnectT_Desc;
            //pbdTypeCode.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.pipe_DrawCode);
            //PushButton pbTypeCode = test.AddItem(pbdTypeCode) as PushButton;
            //test.Enabled = wm.IsValid;

            Autodesk.Revit.UI.RibbonPanel test = application.CreateRibbonPanel(TabName, "ÄÚµå");
            PushButtonData pbdTypeCode = new PushButtonData("ÄÚµå±âÀÔ", "ÄÚµå±âÀÔ", AddInPath, "KMBIM.SetPipeTypeCode");
            pbdTypeCode.ToolTip = Resources.CodeWriteDesc;
            pbdTypeCode.LongDescription = Resources.CodeWriteDesc;
            pbdTypeCode.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.pipe_DrawCode);
            PushButton pbTypeCode = test.AddItem(pbdTypeCode) as PushButton;
            pbTypeCode.Enabled = wm.IsValid;


            //
            PushButtonData pbdTypeCodeOpt = new PushButtonData("Äڵ弳Á¤", "Äڵ弳Á¤", AddInPath, "KMBIM.PipeTypeCode");
            pbdTypeCodeOpt.ToolTip = Resources.CodeWriteDesc;
            pbdTypeCodeOpt.LongDescription = Resources.CodeSettingDesc;
            pbdTypeCodeOpt.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.pipe_SetCode);
            PushButton pbTypeCodeOpt = test.AddItem(pbdTypeCodeOpt) as PushButton;
            pbTypeCodeOpt.Enabled = wm.IsValid;
            test.Enabled = wm.IsValid;

            //PushButtonData pbdBracing = new PushButtonData("¹öÆÀ´ë", "¹öÆÀ´ë", AddInPath, "KMBIM.bracingTest");
            //pbdBracing.ToolTip = Resources.CrossConnectT_Desc;
            //pbdBracing.LongDescription = Resources.CrossConnectT_Desc;
            //pbdBracing.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Plb);
            //PushButton pbBracing = test.AddItem(pbdBracing) as PushButton;
            //test.Enabled = wm.IsValid;
            //
            //
            //PushButtonData pbdDrain = new PushButtonData("¿À¹è¼ö¿¬°á", "¿À¹è¼ö¿¬°á", AddInPath, "KMBIM.DrainConnect");
            //pbdDrain.ToolTip = Resources.CrossConnectT_Desc;
            //pbdDrain.LongDescription = Resources.CrossConnectT_Desc;
            //pbdDrain.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Plb);
            //PushButton pbDrain = test.AddItem(pbdDrain) as PushButton;
            //test.Enabled = wm.IsValid;

            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //************ÀÎÁõ ÆгΠÃß°¡************
            Autodesk.Revit.UI.RibbonPanel rpLogin = application.CreateRibbonPanel(TabName, "ÀÎÁõ");
            // ÀÎÁõ
            PushButtonData pbdKMBConfig = new PushButtonData("ÀÎÁõ", "ÀÎÁõ", AddInPath, "KMBIM.Revit.Tools.Cmd.KMBIMConfigCommand");
            pbdKMBConfig.ToolTip = Resources.Ext2Lvl_Desc;
            pbdKMBConfig.LongDescription = "ÀÎÁõÅ°¿äû/ÀÎÁõÅ° µî·Ï/Á¦°Å";
            pbdKMBConfig.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Auth);
            PushButton pbKMBConfig = rpLogin.AddItem(pbdKMBConfig) as PushButton;
            pbKMBConfig.Enabled = true;



        }

        //¹è°ü-³ôÀÌÀÏÄ¡,°£°ÝÁ¶Á¤ ½ºÇø´ ¹öÆ°
        private void PipeSortSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            //SplitButtonData PipeSortSplitData = new SplitButtonData("¹è°üÁ¤·Ä", "¹è°üÁ¤·Ä");
            SplitButtonData PipeSortSplitData = new SplitButtonData("³ôÀÌ", "³ôÀÌ");
            SplitButton group1 = panel.AddItem(PipeSortSplitData) as SplitButton;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //¹è°ü³ôÀÌÀÏÄ¡
            PushButtonData SyncPipeData = new PushButtonData("³ôÀÌ", "³ôÀÌ", AddInPath, "KMBIM.SyncPipe");
            PushButton SyncPipe = group1.AddPushButton(SyncPipeData) as PushButton;
            SyncPipe.ToolTip = Resources.Ext2Lvl_Desc;
            SyncPipe.LongDescription = Resources.Ext2Lvl_Desc;
            SyncPipe.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Align);
            //¹«·á Å×½ºÆ® ±â´É
            SyncPipe.Enabled = true;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //¹è°ü °£°Ý Á¶Àý
            PushButtonData PipeMatchIntervalData = new PushButtonData("°£°Ý", "°£°Ý", AddInPath, "KMBIM.PipeMatchInterval");
            PushButton PipeMatchInterval = group1.AddPushButton(PipeMatchIntervalData) as PushButton;
            PipeMatchInterval.ToolTip = Resources.Ext2Lvl_Desc;
            PipeMatchInterval.LongDescription = Resources.Ext2Lvl_Desc;
            PipeMatchInterval.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Dst);
            PipeMatchInterval.Enabled = wm.IsValid;
        }

        //¼³Ä¡-ÇÏ´Ü°¡´ë,»ó´Üä³Î ½ºÇø´ ¹öÆ°
        private void InstallChannelSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData InstallChannelSplitData = new SplitButtonData("°¡´ë", "°¡´ë");
            SplitButton InstallChannelSplitBtn = panel.AddItem(InstallChannelSplitData) as SplitButton;
            //¹è°üÇÏ´Ü°¡´ë            
            PushButtonData pbdDownRack = new PushButtonData("°¡´ë", "°¡´ë", AddInPath, "KMBIM.DrawPipeRack");
            PushButton pbDownRack = InstallChannelSplitBtn.AddPushButton(pbdDownRack) as PushButton;
            pbDownRack.ToolTip = Resources.Ext2Lvl_Desc;
            pbDownRack.LongDescription = Resources.Ext2Lvl_Desc;
            pbDownRack.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Holder2);
            //¹«·á Å×½ºÆ® ±â´É
            pbDownRack.Enabled = true;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //¹è°ü»ó´Üä³Î
            PushButtonData pbdUpRack = new PushButtonData("ä³Î", "ä³Î", AddInPath, "KMBIM.DrawUpperPipeRack");
            PushButton pbUpRack = InstallChannelSplitBtn.AddPushButton(pbdUpRack) as PushButton;
            pbUpRack.ToolTip = Resources.Ext2Lvl_Desc;
            pbUpRack.LongDescription = Resources.Ext2Lvl_Desc;
            pbUpRack.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Gad);
            
            pbUpRack.Enabled = wm.IsValid;
        }

        //¼³Ä¡-Çà°Å ½ºÇø´ ¹öÆ°
        private void PlaceHangerAddSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData group6Data = new SplitButtonData("´Üµ¶", "´Üµ¶");
            SplitButton group6 = panel.AddItem(group6Data) as SplitButton;
            //ÆÄÀÏ °æ·Î
            string Dlldir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            PushButtonData itemData1 = new PushButtonData("´Üµ¶", "´Üµ¶", AddInPath, "KMBIM.Revit.Tools.Cmd.Hanger.PlaceHangerCommandManual");
            PushButton item1 = group6.AddPushButton(itemData1) as PushButton;
            item1.ToolTip = "ÁöÁ¤ÇÑ MEP °î¼± À§Ä¡¿¡ Çà°Å¸¦ ¹èÄ¡ÇÕ´Ï´Ù.";
            item1.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Hng);
            item1.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Hng);
            item1.Enabled = wm.IsValid;

            PushButtonData itemData2 = new PushButtonData("´ÙÁß", "´ÙÁß", AddInPath, "KMBIM.Revit.Tools.Cmd.Hanger.PlaceHangerCommandMulti");
            PushButton item2 = group6.AddPushButton(itemData2) as PushButton;
            item2.ToolTip = "¼±ÅÃÇÑ MEP °î¼±¿¡ ÁÖ¾îÁø °£°ÝÀ¸·Î Çà°Å¸¦ ´ÙÁß ¹èÄ¡ÇÕ´Ï´Ù.";
            item2.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Mult);
            item2.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Pipe_Mult);
            item2.Enabled = wm.IsValid;
        }

        //ÆíÁý-·¹º§¿¬Àå,ºÎÇ°°£°Ý ½ºÇø´ ¹öÆ°
        private void EditSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData EditSplitData = new SplitButtonData("·¹º§¿¬Àå", "·¹º§¿¬Àå");
            SplitButton EditSplitBtn = panel.AddItem(EditSplitData) as SplitButton;
            //·¹º§¿¬Àå
            PushButtonData pbdExt2Lvl = new PushButtonData("·¹º§¿¬Àå", "·¹º§¿¬Àå", AddInPath, "KMBIM.Extend2Level");
            PushButton pbExt2Lvl = EditSplitBtn.AddPushButton(pbdExt2Lvl) as PushButton;
            pbExt2Lvl.ToolTip = Resources.Ext2Lvl_Desc;
            pbExt2Lvl.LongDescription = Resources.Ext2Lvl_Desc;
            pbExt2Lvl.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.E2L);
            //¹«·á Å×½ºÆ® ±â´É
            pbExt2Lvl.Enabled = true;
            //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            //ºÎÇ° °£°Ý
            PushButtonData pbdPartSpacing = new PushButtonData("ºÎÇ°°£°Ý", "ºÎÇ°°£°Ý", AddInPath, "KMBIM.PartSpacing");
            PushButton pbPartSpacing = EditSplitBtn.AddPushButton(pbdPartSpacing) as PushButton;
            pbPartSpacing.ToolTip = Resources.PartSpacing_Desc;
            pbPartSpacing.LongDescription = Resources.PartSpacing_Desc;
            pbPartSpacing.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Dis);
            pbPartSpacing.Enabled = wm.IsValid;
        }

        //½ºÇÁ¸µÅ¬·¯ ½ºÇø´ ¹öÆ°
        private void SprinKlerAddSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData group1Data = new SplitButtonData("SP¹èÄ¡", "SP¹èÄ¡");
            SplitButton group1 = panel.AddItem(group1Data) as SplitButton;
            //ÆÄÀÏ °æ·Î
            string Dlldir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            PushButtonData itemData1 = new PushButtonData("SP¹èÄ¡", "SP¹èÄ¡", AddInPath, "KMBIM.CmdSprinKler");
            PushButton item1 = group1.AddPushButton(itemData1) as PushButton;
            item1.ToolTip = Resources.Sprinkler_Desc;
            item1.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Lay);
            item1.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Lay);
            item1.Enabled = wm.IsValid;

            PushButtonData itemData2 = new PushButtonData("OÈ®ÀÎ", "OÈ®ÀÎ", AddInPath, "KMBIM.SprinKlerSpray");
            PushButton item2 = group1.AddPushButton(itemData2) as PushButton;
            item2.ToolTip = Resources.Sprinkler_Rad_Desc;
            item2.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Rad);
            item2.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Rad);
            item2.Enabled = wm.IsValid;

            PushButtonData itemData3 = new PushButtonData("O»èÁ¦", "O»èÁ¦", AddInPath, "KMBIM.SprinklerSprayRemove");
            PushButton item3 = group1.AddPushButton(itemData3) as PushButton;
            item3.ToolTip = Resources.Sprinkler_RadDel_Desc;
            item3.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Del);
            item3.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Del);
            item3.Enabled = wm.IsValid;

            PushButtonData itemData4 = new PushButtonData("Á¤·Ä", "Á¤·Ä", AddInPath, "KMBIM.SprinKlerSort");
            PushButton item4 = group1.AddPushButton(itemData4) as PushButton;
            item4.ToolTip = Resources.Sprinkler_RadDel_Desc;
            item4.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Align);
            item4.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Align);
            item4.Enabled = wm.IsValid;
        }

        //Çì´õ ½ºÇø´ ¹öÆ°
        private void HeaderAddSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData group1Data = new SplitButtonData("³Ã¿Â¼ö S", "³Ã¿Â¼ö S");
            SplitButton group1 = panel.AddItem(group1Data) as SplitButton;
            //ÆÄÀÏ °æ·Î
            string Dlldir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            //PushButtonData itemData1 = new PushButtonData("itemName4", "³Ã¿Â¼ö S", AddInPath, "KMBIM.Header2");
            PushButtonData itemData1 = new PushButtonData("³Ã¿Â¼ö S", "³Ã¿Â¼ö S", AddInPath, "KMBIM.HeaderSupply");
            PushButton item1 = group1.AddPushButton(itemData1) as PushButton;
            item1.ToolTip = Resources.Header2_Desc;
            item1.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Hd_WS);
            item1.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Hd_WS);
            item1.Enabled = wm.IsValid;

            PushButtonData itemData2 = new PushButtonData("³Ã¿Â¼ö R", "³Ã¿Â¼ö R", AddInPath, "KMBIM.HeaderReturn");
            PushButton item2 = group1.AddPushButton(itemData2) as PushButton;
            item2.ToolTip = Resources.Header3_Desc;
            item2.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Hd_WR);
            item2.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Hd_WR);
            item2.Enabled = wm.IsValid;

            PushButtonData itemData3 = new PushButtonData("Çì´õ Áõ±â", "Çì´õ Áõ±â", AddInPath, "KMBIM.HeaderSteam");
            PushButton item3 = group1.AddPushButton(itemData3) as PushButton;
            item3.ToolTip = Resources.Header4_Desc;
            item3.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Hd_S);
            item3.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.Hd_S);
            item3.Enabled = wm.IsValid;
        }

        //Ä¡¼ö±âÀÔ ½ºÇø´ ¹öÆ°
        private void DimAddSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData group1Data = new SplitButtonData("½ÇÄ¡¼ö", "½ÇÄ¡¼ö");
            SplitButton group1 = panel.AddItem(group1Data) as SplitButton;
            //ÆÄÀÏ °æ·Î
            string Dlldir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            PushButtonData itemData1 = new PushButtonData("½ÇÄ¡¼ö", "½ÇÄ¡¼ö", AddInPath, "KMBIM.PipeRealDim");
            PushButton item1 = group1.AddPushButton(itemData1) as PushButton;
            item1.ToolTip = Resources.PipeActualDimension_Desc;
            item1.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.PP_Real);
            item1.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.PP_Real);
            item1.Enabled = wm.IsValid;

            PushButtonData itemData2 = new PushButtonData("½Ì°ú½Ì", "½Ì°ú½Ì", AddInPath, "KMBIM.PipeC2CDim");
            PushButton item2 = group1.AddPushButton(itemData2) as PushButton;
            item2.ToolTip = Resources.PipeC2CDimension_Desc;
            item2.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.PP_C2C);
            item2.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.PP_C2C);
            item2.Enabled = wm.IsValid;
        }



        //»óÇâ½Ä ÀÚµ¿ ½ºÇø´ ¹öÆ°
        private void SpklrAddUpAutoSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData group4Data = new SplitButtonData("»óÇâÀÚµ¿", "»óÇâÀÚµ¿");
            SplitButton group4 = panel.AddItem(group4Data) as SplitButton;
            //ÆÄÀÏ °æ·Î
            string Dlldir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            PushButtonData itemData1 = new PushButtonData("»óÇâÀÚµ¿", "»óÇâÀÚµ¿", AddInPath, "KMBIM.Sprinkler_Upword_Auto");
            PushButton item1 = group4.AddPushButton(itemData1) as PushButton;
            item1.ToolTip = Resources.SprinKler_Upword_Auto_Desc;
            item1.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Up_A_);
            item1.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Up_A_);
            item1.Enabled = wm.IsValid;


            PushButtonData itemData2 = new PushButtonData("»óÇâ¼öµ¿", "»óÇâ¼öµ¿", AddInPath, "KMBIM.Sprinkler_Upword_Manual");
            PushButton item2 = group4.AddPushButton(itemData2) as PushButton;
            item2.ToolTip = Resources.SprinKler_Upword_Manual_Desc;
            item2.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Up_M_);
            item2.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Up_M_);
            item2.Enabled = wm.IsValid;


        }
        //ÇÏÇâ½Ä ÀÚµ¿ ½ºÇø´ ¹öÆ°
        private void SpklrAddDownAutoSplitButton(RibbonPanel panel)
        {
            var wm = WorkMain.GetInstance();

            SplitButtonData group5Data = new SplitButtonData("ÇÏÇâÀÚµ¿", "ÇÏÇâÀÚµ¿");
            SplitButton group5 = panel.AddItem(group5Data) as SplitButton;
            //ÆÄÀÏ °æ·Î
            string Dlldir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            PushButtonData itemData1 = new PushButtonData("ÇÏÇâÀÚµ¿", "ÇÏÇâÀÚµ¿", AddInPath, "KMBIM.Sprinkler_Downward_Auto");
            PushButton item1 = group5.AddPushButton(itemData1) as PushButton;
            item1.ToolTip = Resources.SprinKler_Downward_Auto_Desc;
            item1.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Dn_A_);
            item1.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Dn_A_);
            item1.Enabled = wm.IsValid;

            PushButtonData itemData2 = new PushButtonData("ÇÏÇâ¼öµ¿", "ÇÏÇâ¼öµ¿", AddInPath, "KMBIM.Sprinkler_Downward_Manual");
            PushButton item2 = group5.AddPushButton(itemData2) as PushButton;
            item2.ToolTip = Resources.SprinKler_Downward_Manual_Desc;
            item2.Image = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Dn_M_);
            item2.LargeImage = convertFromBitmap(KMBIM.Revit.Tools.Properties.Resources.SP_Dn_M_);
            item2.Enabled = wm.IsValid;
        }

        BitmapSource convertFromBitmap(System.Drawing.Bitmap bitmap)
        {
            return System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
                bitmap.GetHbitmap(),
                IntPtr.Zero,
                Int32Rect.Empty,
                BitmapSizeOptions.FromEmptyOptions());
        }



        /// <summary>
        /// Insert Level into ComboBox - LevelsSelector
        /// </summary>
        /// <param name="evnetArgs">Autodesk.Revit.DB.Events.DocumentCreatedEventArgs</param>
        public void DocumentCreated(object sender, Autodesk.Revit.DB.Events.DocumentCreatedEventArgs e)
        {
            uiApplication = new UIApplication(e.Document.Application);



            // ¾ð¾î¼³Á¤
            if (uiApplication.Application.Language == LanguageType.Korean)
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("ko-KR");
            }
            else if (uiApplication.Application.Language == LanguageType.Japanese)
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("ja-JP");
            }
            else if (uiApplication.Application.Language == LanguageType.English_USA)
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
            }
            else
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
            }
            Resources.Culture = Thread.CurrentThread.CurrentUICulture;

        }

        private void DocumentOpened(Object sender, RevitAPIPostDocEventArgs args)
        {
            // The document associated with the event. Here means which document has been created or opened.
            Document doc = args.Document;
            uiApplication = new UIApplication(doc.Application);

            // ¾ð¾î¼³Á¤
            if (uiApplication.Application.Language == LanguageType.Korean)
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("ko-KR");

            }
            else if (uiApplication.Application.Language == LanguageType.Japanese)
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("ja-JP");

            }
            else if (uiApplication.Application.Language == LanguageType.English_USA)
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");

            }
            else
            {
                Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");

            }
            Resources.Culture = Thread.CurrentThread.CurrentUICulture;
        }



#region Copy_Zoom

        /// <summary>
        /// Copy_Zoom_State Åä±Û ÀÛ¾÷
        /// </summary>
        RibbonItem _button;
        public string _buttonText { get; set; }
        public static App Instance
        {
            get { return thisApp; }
        }

        //Åä±Û ¹öÆ° On/Off ±³´ë·Î Ç¥½ÃµÇ°Ô Çϱâ
        public void Toggle()
        {
            string s = _button.ItemText;

            _button.ItemText = s.Equals("Off") ? "On" : "Off";
            _buttonText = _button.ItemText;
        }

        static IList<UIView> NewActiveViewList = new List<UIView>();
        public IList<XYZ> newZoomCornerList = new List<XYZ>();
        static Autodesk.Revit.DB.View NewcurrentView = null;


        // ÀüȯµÇ±â ÀüÀÇ ºä¿¡¼­ À§Ä¡ Á¤º¸¸¦ º¹»çÇÑ´Ù.
        public void OnViewActivating(object sender, Autodesk.Revit.UI.Events.ViewActivatingEventArgs args)
        {
            if (KMBIM.Copy_Zoom_State.uidoc == null) return;

            if (_buttonText == "On")
            {
                //ÇöÀç ºä Á¶»ç
                NewActiveViewList = KMBIM.Copy_Zoom_State.uidoc.GetOpenUIViews();// ÇöÀç ¿­·Á ÀÖ´Â ¸ðµç ºä °¡Á®¿À±â
                NewcurrentView = args.CurrentActiveView;

                newZoomCornerList = NewCopyViewState(NewcurrentView, NewActiveViewList);//ÇöÀç ºä À§Ä¡ ±¸Çؼ­ À§Ä¡Á¤º¸ º¹»ç
            }
        }

        // ÀüȯµÈ ÈÄÀÇ ºä¿¡ À§¿¡¼­ º¹»çÇÑ À§Ä¡ Á¤º¸¸¦ ºÙ¿© ³Ö´Â´Ù.
        public void OnViewActivated(Object sender, Autodesk.Revit.UI.Events.ViewActivatedEventArgs args)
        {
            if (KMBIM.Copy_Zoom_State.uidoc == null) return;

            if (_buttonText == "On")
            {
                // Åä±Û ¹öÆ° ½ÇÇà ÇßÀ» ½ÃÀÇ À§Ä¡Á¤º¸¿Í »õ·Ó°Ô ±¸ÇÑ À§Ä¡ Á¤º¸°¡ ´Ù¸£¸é »õ·Ó°Ô ±¸ÇÑ À§Ä¡Á¤º¸¸¦ ºÙ¿© ³Ö´Â´Ù.
                if (newZoomCornerList[0] != KMBIM.Copy_Zoom_State.zoomCornerList[0])
                {
                    NewPasteViewState(args.CurrentActiveView, NewActiveViewList, newZoomCornerList);
                }

                //Åä±Û¹öÆ° ´­·¶À» ¶§ÀÇ À§Ä¡ Á¤º¸¸¦ °¡Á®¿Í¾ß Çϱ⠶§¹®¿¡ Àü¿ªº¯¼ö¸¦ »ç¿ëÇؼ­ Copy_Zoom_State¿¡¼­ Á¤º¸¸¦ °¡Á®¿Í ºÙ¿© ³Ö´Â´Ù.
                else if (newZoomCornerList[0] == KMBIM.Copy_Zoom_State.zoomCornerList[0])
                {
                    KMBIM.Copy_Zoom_State.PasteViewState(KMBIM.Copy_Zoom_State.currentView, KMBIM.Copy_Zoom_State.activeViewList, KMBIM.Copy_Zoom_State.zoomCornerList);
                }
            }
        }

        /// <summary>
        /// Åä±Û ¹öÆ° ´©¸£°í Çѹø ºä ¹Ù²Û µÚºÎÅÍ ½ÇÇàµÇ¾î ºä À§Ä¡ Á¤º¸¸¦ °¡Á®¿À´Â ÇÔ¼ö
        /// </summary>
        /// <param name="currentView">ÇöÀç ºä</param>
        /// <param name="activeViewList">È°¼ºÈ­ µÇ¾î ÀÖ´Â ºä ¸®½ºÆ®</param>
        /// <returns></returns>
        static public IList<XYZ> NewCopyViewState(Autodesk.Revit.DB.View currentView, IList<UIView> activeViewList)
        {
            UIView currentUIView = null;
            IList<XYZ> newFoundZoomCornerList = new List<XYZ>();

            //ÇöÀç ºä ã±â
            foreach (UIView activeUIView in activeViewList)
            {
                if (activeUIView.ViewId == currentView.Id)
                {
                    currentUIView = activeUIView;
                }
                else
                    break;
            }

            if (currentUIView != null)
            {
                //ÁÜ ÄÚ³Ê Ã£±â
                newFoundZoomCornerList = currentUIView.GetZoomCorners();
            }

            return newFoundZoomCornerList;
        }


        /// <summary>
        /// Åä±Û ¹öÆ° ´©¸£°í Çѹø ºä ¹Ù²Û µÚºÎÅÍ ½ÇÇàµÇ¾î ºä À§Ä¡ Á¤º¸¸¦ ºÙ¿© ³Ö´Â ÇÔ¼ö
        /// </summary>
        /// <param name="currentView">ÇöÀç ºä</param>
        /// <param name="activeViewList">È°¼ºÈ­ µÇ¾î ÀÖ´Â ºä ¸®½ºÆ®</param>
        /// <param name="zoomCornerList1">º¹»çÇÑ ÁÜ À§Ä¡ Á¤º¸</param>
        static public void NewPasteViewState(Autodesk.Revit.DB.View currentView, IList<UIView> activeViewList, IList<XYZ> zoomCornerList1)
        {
            UIView currentUIView = null;
            //currentView = uiapp.ActiveUIDocument.ActiveView;

            //ÇöÀç ºä ã±â
            if (currentView != null)
            {
                foreach (UIView activeUIView in activeViewList)
                {
                    if (activeUIView.ViewId == currentView.Id)
                    {
                        currentUIView = activeUIView;
                    }
                }
            }

            if (currentUIView != null)
            {
                using (Transaction tr = new Transaction(KMBIM.Copy_Zoom_State.doc))
                {
                    tr.Start("start");

                    //zoom µ¥ÀÌÅÍ ºÙ¿©³Ö±â
                    currentUIView.ZoomAndCenterRectangle(zoomCornerList1[0], zoomCornerList1[1]);

                    tr.Commit();
                }
            }
        }

        private void A_ViewActivated(object sender, Autodesk.Revit.UI.Events.ViewActivatedEventArgs e)
        {
            throw new NotImplementedException();
        }

#endregion

    }
}