This IDE includes several tools:
- the project manager with an editor,
- a class browser,
- a source-level debugger,
- the GUI generation tool Visual Architect using the Think Class Library (TCL).
Despite the Mac OS beeing a system really based on graphical user interface, the IDE offers the possibility to create a console application using either printf/scanf or IOStream interfaces. No need then to implement any GUI element.
At first you will need to create a project. To do so you select a project model, which will include libraries depending on what will be the target as well as the settings. Those are :
- Empty project : no lib incuded at all,
- ANSI C : to create a console application using printf/scanf interface,
- ANSI C++ : to create a console application using IOStreams interface,
- C Mac Application: to create an application with a GUI,
- C++ Mac Application: to create an application with a GUI,
- VA App Shared Lib : to create the GUI using VA tool (see below). The used library code (TCL) is included as a shared lib. This speeds up compilation.
- VA Application : to create the GUI with Visual Architext (VA see below) but the TCL source code in included in the project.
When debugging it is possible to navigate to other source files by selecting it in the project and select Project->Debug File.
Auxiliary windows may be opened alongside the main debugging window which also provide a data pane.
Any expression known to the used compiler may be entered in the Data window (or the data panes of the additional windows). Values of variables may be modified and their display format changed by type casting if the type in not in the predefined menu types.
A pointer can be visualised as array by setting its type to Address.
For the evaluation of a variable a context (block of code in which the expression is evaluated) can be fixed, or even locked.
A log window is available in which the DebugStr output is written.
Per menu command it is possible to use the low level debugger MacsBug.
Per option it is possible to have the debugger stop on loading before any code is executed instead of the main routine.
For a deeper insight in the tool and TCL see https://vintageapple.org/macprogramming/pdf/Mastering_the_Think_Class_Library_1995.pdf
With this you can literally draw the user interface of your application (windows, menus, dialogues with their items). For the menu items and buttons you can specify which window will be opened or function will be called. In fact you define a command ( or choose a predefined one) and the class that handles it.
You generate the GUI of your application by picking the elements from a tool palette and place them on the screen or in a window. VA will generate the resources as well as the code.
You just need to know which purpose a GUI item suits (for example Panorama for graphical drawings, Subview to handle a part of a window separately). All those classes may be extended. A diagram is given in the uploads.
For every GUI item, Visual Architect will generate 2 classes x_(ClassName) and (ClassName) derived from the first as well as the necessay ressources for the project. On each generation following a modification, the first (parent) will be overwritten, but not the second in which you will fill the empty methods or add new ones.
The generated code can be compiled and run directly.
My experience (with release 8.5) is that sometimes the object code gets corrupted, especially when a debugging session ends with an error (effect: crash of application or atof returning wrong value). In this case, just clean up the project by removing the objects (even all build information), and recompie all.
The debugger is quite nice. It is even possible to type in small expressions or conversions (to have an hexadecimal address displayed in decimal format for example.)
The distribution (at least 8.5) includes the development tool MPW.
Visual Architect (VA) projects include a resource file Visual Architect.rsrc in which all resources used when generating the GUI are stored. All views created with their GUI elements are stored in a CVue type resource. This type can't be viewed or edited with common resource editors as ResEdit or Resourcer. They are specific to VA. Other resources for example icon buttons (VA needs resources of type cicn or ICON) may be added to this file using ResEdit for example.
In VA you create Views that are mainly windows (Document, Dialog, Splash, Floating Windows ...) in which you create the GUI elements. Only the subview is not a window but a set of GUI elements that can be reused in windows or swaped programatically using the CSubviewDisplayer TCL class.
VA lets you also create the menubar with its menus and commands associated to the menu items.
Full explanations to the screeshots
After generation of a new VA project, a default view in generated (Main).
Info dialog of a view.
The Use file checkbox will make VA include code to use object IO, and the Print checkbox code for printing when generating the source code.
View creation dialog with the list of view types.
The Main Window is the window type of main focus of the user, for example to display a document(the one generally created on selection of File->New menu).
The New... Dialog is the dialog to create a new document (or Main Window) in case the application handles more than one document type.
Dialogs have a default command (the one executed on pressing return).
Window serves as auxiliary view to the main window.
The Subview is an arrangement of GUI elements that is reusable in the other view types.
When creating the view, you select elements from the tool palette and position them in the view typing in a title/label if applicable. The palette offers (top left to bottom right): normal selection cursor, static text item, dialog text box, push button, radio button, checkbox, popup-menu, icon, picture, scroll bar, icon button, picture button, list/table, subview, panorama (generic scrollable area), contrained line, 2 rectangles, unconstained line, oval and polygon.
For the popup-menu you have to add the menu items by editing the created menu (Edit->Menus).
For the list/table you must derive a class from CArrayPane and make it an instance of that class (Pane->Class). A command may also be associated to handle double clics.
For the icon and picture you can use resources PICT ICON or cicn that are in the Visual Architect.rsrc file.
Buttons will be associated a command in the info window.
The subview only displays a rectangle with ???. You will have to create it and set it in the pane info. In case you want it to handle commands, you will have to derive a class from CPanorama aand make the subview an instance of that class (Pane->Class).
After creation you may use menu View->Try Out to test the view.
Pane Info Dialog of a CIconButton
Every GUI element (called Pane in VA) has an info window. At the top you give it a name to find the code implementing it. In the lower part, all classes (the full hierarchy) used for its implementation are listed, and you can set the initial/default values for their attributes or options.
For example choose the behaviour or the icon of the button, and associate it a command that will either open a window (in this case VA generates the complet code) or call a routine in a given class (you will have to fill the body of the routine).
For the icons, VA will only offer for selection only the icons availbale in cicn (color) and ICON (b&w).
Grouping of radio buttons. Only necessary if more than one group used in the same view.
The MenuBar handling dialogs: Menu Bar, Menus and Menu Items. The menubar window has been pasted into the picture. Popup menus are edited the same way.
If you need a specific version of a GUI item, for example an edit box in which the user types in a floating point value, you will derive a class from the CEditText (that implements text editing dialog boxes) with menu Edit->Class and make the Pane an instance of this class with menu Pane->Class and selecting the new class.
When using the List/Table pane, You will have to use a class derived from CArrayPane and make the item an instance of it (with menu Edit->Class) or if a subview should handle commands (be active in the GUI) you will have to do the same with class CPanorama.
Try out of a view
Creation of the subview
This is done as the other views. Any GUI element of the tool palette can be used, even a nested subview.
The subview element with the ??? must refer to the new created subview. Thsi is done in its pane info dialogue.
Try out of the final view. Once everything is in order, you are ready to the let VA generated the code.
(256.37 MiB / 268.83 MB)
System 7.0 - 7.6 - Mac OS 9 / Toast image, compressed w/ Stuffit
(548.88 KiB / 562.05 KB)
Think Class Library Diagram
(3.06 MiB / 3.21 MB)
FAQs Symantec C++ 8.x
Useful info /
(273.49 MiB / 286.77 MB)
68K + PPC (FAT)
From Mac OS 7.0
up to Mac OS 9.0
The tools Symantec Project Manager and Visual Architect work under OS 9.1, but not the PowerPC compiler (outputs an internal error).
So for OS 9.1 and above, You will need to include another compiler.
Emulating this? It could probably run under: SheepShaver