I've done quite a bit of "standards enforcement" programming in (v)lisp, and here are some random ideas that have helped me:
1. Have a plan. Don't try to code everything in one shot and allow yourself to think like a programmer. Think in terms of modules of small functions that work together to solve big tasks. Always break the problem down into smaller units. IOW, one function may set up text styles, one may set up layers, another may set up dimstyles, etc.
I've found it very helpful to write long comments of pseudocode or algorthms in plain text that describe the logic breakdown before writing a single piece of code. I do this even for non-programming tasks. Pretty soon you think like this for everything like making cereal to cutting the grass, e.g.
Open Fridge Door
Take Milk Out
If (= Yes EnoughForCereal), (TestMilk)
otherwise, (MakeToast)
If (= Ok (TestMilk))
(MakeCereal)
((ThrowOutMilk) (MakeToast))
2. Separate code from data. That is, create a text file of your intended Standards settings in an .ini file or some other text file (the extension doesn't matter). Make them delimited by space or character. For example, a layer standards file might look like:
0 red continuous plot
A-WALLS yellow continuous plot
A-NOPLOT 37 continuous noplot
etc. Do the same for dimension styles and text styles (each a separate file). For annotation styles, set all heights and size values to plotted sizes.
Each kind fo file may have a different data format. In my dimstyles standards file I use mostly Dimvar names in association lists (e.g., ("DIMBLK" . "_ARCHTICK") because it makes implementing it very easy. For text styles, I used a simple assoc. list based on DXF codes for text Styles (e.g., '(2 . "STYLENAME"). for layers it's a bit more cumbersome because we use layer prefixes then std layer names. But easily handled by code.
The point is, pick a format for the type of data and write code around it to process the file easily. With vlisp's extended functions for handling strings, it's super easy.
3. Create a development environment for yourself. Put all of your code and Standards data files into an \Admin folder tree that only you have read/write access to. Create a parallel \Company folder for everyone else. Develop, test and compile in \Admin, copy the fas/vlx/lsp files to the \Company tree for implementation. Make subfolders for resources, menus, apps, sourcecode, vlx, etc.
Each normal user has their profile Support Files path point to the \Company tree, yours points to \Admin. You are always in development mode, they are always using solid code. You can screw up without torpedoing the entire company.
4. Create very general code functions that process the files. The functions simple read the files in line by line into a big list, then parse the list for the intended fields. Then apply the settings to the layers/dimensions/styles, either through a simple (command "layer") call or through ActiveX.
By doing this you make sure that someone doesn't have to know how to code AutoLISP or VBA to modify the standards. This is important if you get hit by a bus.
Not only that, but it's portable, so you can migrate the same data files to VBA if you want to do so withou recoding the standards themselves.
5. For annot. styles, wrap everything up into a single general function that sets all scale-dependent settings in one shot. If you do annotations in MS, then you can simply execute a function like this (annotsetup "Standards" 96.0) which
a) sets a global LTSCALE size
b) reads the settings for text styles from standards.txt and sets them accordingly,
c) reads the dimensions text file from "standards.dim" and sets up a dimstyle and all child dimstyles
Since we do all annotaiton in MS and use Xrefs extensively, we can get away with using one - and only one - dimstyle per drawing, so all of our dwgs have a dimestyle called ARCHITECT. Each file has one annotation scale; everything is the same except for the all-important DIMSCALE system variable.
3. Wrap everything up into simple cascading menus. I generally don't use Templates because they are tougher to maintain over time, and it's easier to manage a few simple text files that set all standards.
Instead, I have my users start all of their drawings with the same template (acad.dwt) which is "clean" - no layers/dimstyles/text styles. Then they step through two cascading menus - one to load layers, another to set the scale which also sets text/dim styles and ltscale. Since we do Architectural work, the layers pulldown has different entries for loading separate sets of layers (new, demo, existing, RCP, furniture, etc).
Hope it helps to give you ideas.
