Managed ObjectArx 定制autocad的界面(包括menu.toolbar等...)

  //   Copyright 2005-2006 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.IO;
  using   Autodesk.AutoCAD.Runtime;
  using   Autodesk.AutoCAD.ApplicationServices;
  using   Autodesk.AutoCAD.EditorInput;
  using   Autodesk.AutoCAD.DatabaseServices;

  using   Autodesk.AutoCAD.Customization;

  //   This application implements several commands that shows how to
  //   manipulate some of the existing CUI User interface and components.
  //   The commands implemented here allow you to:
  //  
  //   1) Create/Remove menu and its items (ADDMENU/REMMENU)
  //   3) Create/Remove a workspace (ADDWS/REMWS)
  //   2) Create/Remove a toolbar and its items (ADDTOOLBAR/REMTOOLBAR)
  //   4) Create a keyboard shortcut (CUISHORTCUT)
  //   5) Create a temporary override (TEMPKEY)
  //   6) Change position and docking of "Info Palette" 
  //      window (DOCKR, DOCKL, DOCKF)
  //   7) Add a double-click action (DBLCLICK)
  //   8) A command that performs the tasks of ADDMENU,ADDTOOLBAR,
  //      DOCKL and CUISHORTCUT (CUIALL)
  //   9) Save a CUI after its modifications and reload it (SAVECUI)

  //   Apart from the above commands, lisp wrappers have also been 
  //   implemented to make the commands callable from windows.

  //   To use CuiSamp.dll:
  //   1) Start AutoCAD and open a new drawing.
  //   2) Type netload and select CuiSamp.dll.
  //   3) Execute the CUIALL command, if you want the UI related 
  //      modifications.

  //   Please add the References acdbmgd.dll,acmgd.dll,
  //   AcCui.dll and AcCustomize.dll before trying to 
  //   build this project. 
 
  namespace   CuiSamp
  {
      /**/  ///     <summary>  
      ///   Summary description for Class1.
      ///     </summary> 
       public     class   CuiSamp
      {
          //   All Cui files (main/partial/enterprise) have to be loaded into an object of class 
          //   CustomizationSection
          //   cs - main AutoCAD CUI file 
         CustomizationSection cs;
        CustomizationSection entCs;
        CustomizationSection[]partials ;
        
          int   numPartialFiles;

        YesNoIgnoreToggle yes   =   YesNoIgnoreToggle.yes;
        YesNoIgnoreToggle no    =   YesNoIgnoreToggle.no;
        
          //   True when enterprise CUI file is loaded successfully 
           bool   entCsLoaded;

          //   ed - access to the AutoCAD Command Line
          //   Allows us to write messages or Issue Commands in the interface 
         Editor ed   =   Application.DocumentManager.MdiActiveDocument.Editor;


          //  Default Constructor 
           public   CuiSamp()
          {
              //   retrieve the location of, and open the ACAD Main CUI File 
               string   mainCuiFile   =   (  string  )Application.GetSystemVariable(  "  MENUNAME  "  );
            mainCuiFile   +=     "  .cui  "  ;
            cs   =     new   CustomizationSection(mainCuiFile);
            
              string   entCuiFile   =   (  string  )Application.GetSystemVariable(  "  ENTERPRISEMENU  "  );
              if  ( entCuiFile.Equals(  "  .  "  ))
                entCsLoaded   =     false  ;
              else  
               {
                entCs   =     new   CustomizationSection(entCuiFile);
                entCsLoaded   =     true  ;
            } 
            
              //   Code for loading all partial CUI's listed in the main CUI file 
             
            partials   =     new   CustomizationSection[cs.PartialCuiFiles.Count];
              int   i  =  0  ;
              foreach  (  string   fileName   in   cs.PartialCuiFiles)
              {    
                  if   (File.Exists(fileName))
                  {
                    partials[i]   =     new   CustomizationSection(fileName);
                    i  ++  ;
                } 
            } 
            numPartialFiles   =   i;    
        } 
 
 
          //   Command: savecui
          //   This Command saves all open CUI Files that have been modified 
         [CommandMethod(  "  savecui  "  )]
          public     void   saveCui()
          {
              //   Save all Changes made to the CUI file in this session. 
              //   If changes were made to the Main CUI file - save it
              //   If changes were made to teh Partial CUI files need to save them too 
     
              if  (cs.IsModified)
                cs.Save();

              for  (  int   i  =  0  ;i   <   numPartialFiles;i  ++  )
              {    
                  if  (partials[i].IsModified)
                    partials[i].Save();
            } 
            
              if  (entCsLoaded   &&   entCs.IsModified)
                entCs.Save();

              //   Here we unload and reload the main CUI file so the changes to the CUI file could take effect immediately. 
               string   flName   =   cs.CUIFileBaseName;
            Application.SetSystemVariable(  "  FILEDIA  "  ,  0  );
            Application.DocumentManager.MdiActiveDocument.SendStringToExecute(  "  cuiunload   "     +   flName   +     "     "  ,  false  ,  false  ,  false  );
            Application.DocumentManager.MdiActiveDocument.SendStringToExecute(  "  cuiload   "     +   flName   +     "   filedia 1   "  ,  false  ,  false  ,  false  );
        } 
 
          //   Lisp callable function: savecui
          //   Lisp wrapper for savecui command 
         [LispFunction(  "  savecui  "  )]
          public     void   saveCui(ResultBuffer args)
          {
            saveCui();
        } 
 
          //   Command: addmenu
          //   This Command adds a new menu to all workspaces called Custom Menu, which contains 2 sub items
          //   The Menu is first added to the Main CUI File and then added to all it's workspaces.  
         [CommandMethod(  "  addmenu  "  )]
          public     void   addMenu()
          {
              if   (cs.MenuGroup.PopMenus.IsNameFree(  "  Custom Menu  "  ))
              {
                
                System.Collections.Specialized.StringCollection pmAliases   =     new   System.Collections.Specialized.StringCollection();
                pmAliases.Add(  "  POP12  "  );
                
                PopMenu pm   =     new   PopMenu(  "  Custom Menu  "  ,pmAliases,  "  Custom Menu  "  ,cs.MenuGroup);
                
                addItemsToPM(pm);
                addMenu2Workspaces(pm);
            } 
              else  
                ed.WriteMessage(  "  Custom Menu already Exists\n  "  );    
        } 
 
          //   Lisp callable function: addmenu
          //   Lisp wrapper for addmenu command 
         [LispFunction(  "  addmenu  "  )]
          public     void   addMenu(ResultBuffer args)
          {
            addMenu();
        } 
 
          //   Add new Items to a PopMenu 
           private     void   addItemsToPM(PopMenu pm)
          {
            PopMenuItem pmi   =     new   PopMenuItem(pm,  -  1  );
            pmi.MacroID   =     "  ID_AUGI  "  ;pmi.Name   =     "  Autodesk User Group International  "  ;
            
            pmi   =     new   PopMenuItem(pm,  -  1  );

            pmi   =     new   PopMenuItem(pm,  -  1  );
            pmi.MacroID   =     "  ID_CustomSafe  "  ;pmi.Name   =     "  Online Developer Center  "  ;
        } 
 
          //   Add the menu to all the workspaces 
           private     void   addMenu2Workspaces(PopMenu pm)
          {
              foreach  (Workspace wk   in   cs.Workspaces)
              {
                WorkspacePopMenu wkpm   =     new   WorkspacePopMenu(wk,pm);
                wkpm.Display   =     1  ;
            } 
        
        } 
    
          //   Command: remmenu
          //   This Command deletes the menu added above from the Main CUI File and any
          //    workspaces that it was added to.  
         [CommandMethod(  "  remmenu  "  )]
          public     void   remMenu()
          {
              //   Find Index of the desired MenuItem
              //   Remove it from all Workspaces that it exists in
              //   Omitting this step leaves nasty left-overs in the Workspace files
              //   Remove it from the Cui files' Menu List 
             
            PopMenu    pm   =   cs.MenuGroup.PopMenus.FindPopWithAlias(  "  POP12  "  );
              if   (pm   !=     null   )
              {
                  foreach  (Workspace wk   in   cs.Workspaces)
                  {
                    WorkspacePopMenu wkPm   =   wk.WorkspacePopMenus.FindWorkspacePopMenu(pm.ElementID,pm.Parent.Name);
            
                      if  (wkPm   !=     null  )
                        wk.WorkspacePopMenus.Remove(wkPm);
                } 
                cs.MenuGroup.PopMenus.Remove(pm);      //   Deletes the Menu from ACAD Menu Group 
             } 
        } 
 
          //   Lisp callable function: remmenu
          //   Lisp wrapper for remmenu command 
         [LispFunction(  "  remmenu  "  )]
          public     void   remMenu(ResultBuffer args)
          {
            remMenu();
        } 
 
          //   Command: addws
          //   This command adds a new workspace. The name of the workspace to create is
          //   obtained from the command line. 
         [CommandMethod(  "  addws  "  )]
          public     void   addws()
          {
            String wsName;
            PromptResult prs   =   ed.GetString(  "  Enter name of workspace to create:   "  );
              if  (PromptStatus.OK   ==   prs.Status )
              {
                wsName   =   prs.StringResult;
                  if  (  -  1     ==   cs.Workspaces.IndexOfWorkspaceName(wsName))   //   If the workspace doesnot exist 
                    {
                    Workspace nwWs   =     new   Workspace (cs, wsName);   //   Create the workspace 
                     saveCui();   //   Save and reload the CUI file 
                 } 
                  else  
                   {
                    ed.WriteMessage(  "  A workspace with this name already exists  "  );
                } 
            } 
 
        } 
 
          //   Lisp callable function: addws
          //   Lisp wrapper for addws command 
         [LispFunction(  "  addws  "  )]
          public     void   addws(ResultBuffer args)
          {
            addws();
        } 
 
          //   Command: remws
          //   This command removes a workspace. The name of the workspace to remove is
          //   obtained from the command line. 
         [CommandMethod(  "  remws  "  )]
          public     void   remws()
          {
            String wsName;
            PromptResult prs   =   ed.GetString(  "  Enter name of workspace to remove:   "  );
              if  (PromptStatus.OK   ==   prs.Status )
              {
                wsName   =   prs.StringResult;
                  if  (  -  1     !=   cs.Workspaces.IndexOfWorkspaceName(wsName))   //   If the workspace exist 
                    {
                    cs.deleteWorkspace(wsName);   //   Remove the workspace 
                     saveCui();   //   Save and reload the CUI file 
                 } 
                  else  
                   {
                    ed.WriteMessage(  "  No workspace exists with this name  "  );
                } 
            } 
            
        } 
          //   Lisp callable function: remws
          //   Lisp wrapper for remws command 
         [LispFunction(  "  remws  "  )]
          public     void   remws(ResultBuffer args)
          {
            remws();
        } 
 
 
          //   Command: cuishortcut
          //   This adds a Shortcut key to the CUI command.
          //   Ctrl+B is used for Toggling SNAP. It gets reassigned 
         [CommandMethod(  "  cuishortcut  "  )]
          public     void   shortCut()
          {
              //   In here we will make a shortcut Key combination to the Customize.. command 
             MacroGroup mg   =   cs.MenuGroup.MacroGroups[  0  ];   //   Search the ACAD Macros 
               foreach   (MenuMacro mcr   in   mg.MenuMacros)
              {
                  if  (mcr.ElementID.Equals(  "  MM_1570  "  ))
                  {
                    MenuAccelerator ma   =     new   MenuAccelerator(mcr,cs.MenuGroup);
                    ma.AcceleratorShortcutKey   =     "  CTRL+B  "  ;
                } 
            } 
        } 
          //   Lisp callable function: cuishortcut
          //   Lisp wrapper for cuishortcut command 
         [LispFunction(  "  cuishortcut  "  )]
          public     void   shortCut(ResultBuffer args)
          {
            shortCut();
        } 
 
          //   Command: dockr
          //   Dock Info Palette to the right 
         [CommandMethod(  "  dockr  "  )]
          public     void   dockInfoPalR()
          {
            dockInfoPalette(DockableWindowOrient.right);
        } 
          //   Lisp callable function: dockr
          //   Lisp wrapper for dockr command 
         [LispFunction(  "  dockr  "  )]
          public     void   dockInfoPalR(ResultBuffer args)
          {
            dockInfoPalR();
        } 
 
          //   Command: dockl
          //   Dock Info Palette to the left 
         [CommandMethod(  "  dockl  "  )]
          public     void   dockInfoPalL()
          {
            dockInfoPalette(DockableWindowOrient.left);
        } 
 
          //   Lisp callable function: dockl
          //   Lisp wrapper for dockl command 
         [LispFunction(  "  dockl  "  )]
          public     void   dockInfoPalL(ResultBuffer args)
          {
            dockInfoPalL();
        } 
 
          //   Command: dockf
          //   Set Info Palette to float 
         [CommandMethod(  "  dockf  "  )]
          public     void   dockInfoPalF()
          {
            dockInfoPalette(DockableWindowOrient.floating);
        } 
          //   Lisp callable function: dockf
          //   Lisp wrapper for dockf command 
         [LispFunction(  "  dockf  "  )]
          public     void   dockInfoPalF(ResultBuffer args)
          {
            dockInfoPalF();
        } 
 
 
          //   Method to implement the positiioning/docking of the "Info Palette" window 
           private     void   dockInfoPalette(DockableWindowOrient orientation)
          {
              int   wkB   =   cs.Workspaces.IndexOfWorkspaceName(  "  AutoCAD Default  "  );
              //   check to see if it exists 
               if   (wkB   ==     -  1  )
              {
                  //   if not, then see if it is called simply AutoCAD 
                 wkB   =   cs.Workspaces.IndexOfWorkspaceName(  "  AutoCAD  "  );
                  if   (wkB   ==     -  1  )
                  {
                      //   if not, then ok - it's something else 
                     Application.DocumentManager.MdiActiveDocument.Editor.WriteMessage(  "  Workspace not found.  "  );
                      return  ;
                } 
            } 
            Workspace wk   =   cs.Workspaces[wkB];
            
              foreach  (WorkspaceDockableWindow dockableWindow   in   wk.DockableWindows)
              {
                  if  (dockableWindow.Name.Equals(  "  Info Palette  "  ))
                  {    
                      if  (orientation.Equals(DockableWindowOrient.floating))
                        dockableWindow.DockFloat   =   DockedFloatingIgnoreToggle.floating;
                      else      
                        dockableWindow.DockFloat   =   DockedFloatingIgnoreToggle.docked;

                    dockableWindow.Display   =   yes;
                    dockableWindow.Orientation   =   orientation;
                    dockableWindow.AutoHide   =   OnOffIgnoreToggle.off;
                    dockableWindow.UseTransparency   =   no;
                      break  ;
                } 
            } 
        } 
 
          //   Command: addtoolbar
          //   Creates a new toolbar called "New Toolbar", and adds it to all workspaces. 
          //   This toolbar contains a Toolbar control for named view, button for drawing 
          //   a pline, and a flyout that uses the "Draw" tool bar. 
         [CommandMethod(  "  addtoolbar  "  )]
          public     void   addToolbar()
          {
            Toolbar newTb   =     new   Toolbar(  "  New Toolbar  "  ,cs.MenuGroup);
            newTb.ToolbarOrient   =   ToolbarOrient.floating;
            newTb.ToolbarVisible   =   ToolbarVisible.show;
            
            ToolbarControl tbCtrl   =     new   ToolbarControl(ControlType.NamedViewControl,newTb,  -  1  );
                        
            ToolbarButton tbBtn   =     new   ToolbarButton(newTb,  -  1  );
            tbBtn.Name   =     "  PolyLine  "  ;
            tbBtn.MacroID   =     "  ID_Pline  "  ;

            ToolbarFlyout tbFlyout   =     new   ToolbarFlyout(newTb,  -  1  );
            tbFlyout.ToolbarReference   =     "  DRAW  "  ;

              foreach  ( Workspace wk   in   cs.Workspaces)
              {
                WorkspaceToolbar wkTb   =     new   WorkspaceToolbar(wk,newTb);
                wk.WorkspaceToolbars.Add(wkTb);
                wkTb.Display   =     1  ;
            } 
        } 
          //   Lisp callable function: addtoolbar
          //   Lisp wrapper for addtoolbar command 
         [LispFunction(  "  addtoolbar  "  )]
          public     void   addToolbar(ResultBuffer args)
          {
            addToolbar();
        } 
 
          //   Command: remtoolbar
          //   This Command removes the toolbar added above from the Main CUI File and any
          //   workspaces that it was added to.  
         [CommandMethod(  "  remtoolbar  "  )]
          public     void   remToolbar()
          {
            Toolbar tbr   =   cs.MenuGroup.Toolbars.FindToolbarWithName(  "  New Toolbar  "  );
              if   (tbr   !=     null   )
              {
                  foreach  (Workspace wk   in   cs.Workspaces)
                  {
                    WorkspaceToolbar wkTb   =   wk.WorkspaceToolbars.FindWorkspaceToolbar(tbr.ElementID,tbr.Parent.Name);
            
                      if  (wkTb   !=     null  )
                        wk.WorkspaceToolbars.Remove(wkTb);
                } 
                cs.MenuGroup.Toolbars.Remove(tbr);      //   Deletes the toolbar from ACAD Menu Group 
             } 
        } 
 
          //   Lisp callable function: remtoolbar
          //   Lisp wrapper for remtoolbar command 
         [LispFunction(  "  remtoolbar  "  )]
          public     void   remToolbar(ResultBuffer args)
          {
            remToolbar();
        } 
 
          //   Command: tempkey
          //   This command will install a temporary override key. Temporary override keys are keys that temporarily 
          //   turn on or turn off one of the drawing aids that are set in the Drafting Settings dialog box 
          //   (for example, Ortho mode, object snaps, or Polar mode). 
         [CommandMethod(  "  tempkey  "  )]
          public     void   tempOverride()
          {
            TemporaryOverride newTempOverride   =     new   TemporaryOverride(cs.MenuGroup);    
            newTempOverride.OverrideShortcutKey   =     "  SHIFT+Y  "  ;   //   Scan code for Y 
             newTempOverride.Name   =     "  Customization Override  "  ;
            newTempOverride.Description   =     "  Customization Override  "  ;
            newTempOverride.ElementID   =  "  EID_CUITEMPOVERRIDE  "  ;
              //   Creating a override for Shift+Y (Key down) that will behave as temporary override for OSnap to endpoint (MM_1629) 
             OverrideItem newOverrideItem   =     new   OverrideItem(  "  MM_1629  "  ,OverrideKeyState.Down,newTempOverride);
            newTempOverride.DownOverride   =   newOverrideItem;            
        } 
          //   Lisp callable function: tempkey
          //   Lisp wrapper for tempkey command 
         [LispFunction(  "  tempkey  "  )]
          public     void   tempOverride(ResultBuffer args)
          {
            tempOverride();
        } 
 
          //   Command: dblclick
          //   This command adds a double click action for polylines (Non-LWpolylines like 2D polylines).
          //   After running this command, When we double click a polyline (i.e., a non-light weight polyline), 
          //   the "Properties" window is launched. This replaces the original behaviour where "pedit" was launched. 
         [CommandMethod(  "  dblclick  "  )]
          public     void   doubleClick()
          {
            DoubleClickAction dblClickAction   =     new   DoubleClickAction(cs.MenuGroup,  "  My Double click  "  ,  -  1  );
            dblClickAction.Description   =     "  Double Click Customization  "  ;
            dblClickAction.ElementID   =     "  EID_mydblclick  "  ;
            dblClickAction.DxfName   =     "  Polyline  "  ;
            DoubleClickCmd dblClickCmd   =     new   DoubleClickCmd(dblClickAction);
            dblClickCmd.MacroID   =     "  ID_Ai_propch  "  ;
            dblClickAction.DoubleClickCmd   =   dblClickCmd;
        } 
          //   Lisp callable function: dblclick
          //   Lisp wrapper for dblclick command 
         [LispFunction(  "  dblclick  "  )]
          public     void   doubleClick(ResultBuffer args)
          {
            doubleClick();
        } 
 
        
          //   Command: cuiall
          //   Issuing this command will run the methods to make all changes to the UI
          //   This will add the custom menu, toolbar, and shortcut, as well as 
          //   dock the info palette on the right side. 
         [CommandMethod(  "  cuiall  "  )]
          public     void   callForAllChanges()
          {
            addMenu();
            shortCut();
            addToolbar();
            dockInfoPalR();
            saveCui();
        } 
          //   Lisp callable function: cuiall
          //   Lisp wrapper for cuiall command 
         [LispFunction(  "  cuiall  "  )]
          public     void   callForAllChanges(ResultBuffer args)
          {
            callForAllChanges();
        } 
 
    } 
}