软件
产品
// 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();
}
}
}
转载于:https://www.cnblogs.com/top5/archive/2009/12/29/1635039.html
免责声明：本文系网络转载或改编，未找到原创作者，版权归原作者所有。如涉及版权，请联系删
技术文档
热门文章
155-2731-8020
