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

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();
        }

    }
}

需要ref dlls:accui.dll(在cad的安装目录) , acmgd.dll  ,acdbmgd.dll

Lisp命令需要的attribute.