In order to create a PMP we must first create a class. This class is created based on the template of a PMP called an abstract class; this means that before we can create a page we must create an object (class) that has all the required properties and functions required by a PMP. By “deriving” from this base PMP class, it ensures that our new class has all of these required properties and methods. Think of it as if you want to create a new car, called the SuperFly, you cannot start by creating a new car with 3 square wheels, and no steering wheel.
You have got to follow certain rules such as having 3-4 wheels, containing doors to get in, and having certain safety factors. These rules would be put inside a base abstract class called Car for
example, to ensure that any car created will follow these basic rules.
We would derive our SuperFly car class from the base Car class, so that it inherited, and was forced to follow, these base rules.
In the case of our Property Manager Page, we are going to create a new page, called MyFirstPMP that is derived from the base PMP class, which is actually called PropertyManagerPage2Handler5.
When you derive from a base class, your new class first needs to state that it is deriving from that class, and secondly you must create all of the functions that the base class asks you too. So, we are going to create a new class, derive from the PMP base class, and specify all of the required blank functions.
Start by creating a new project in.Net from the normal template with the button to start the code, and go to the coding view. Add the following using code:
using SWPublished;
This will allow us to access the base PMP class.
Now create a new class outside of the main form class but inside the namespace, and call it MyFirstPMP. Now for the important part;
after the class name, but before the opening curly braces, place a colon (:), followed by the name of the base class to derive from, in this case PropertyManagerPage2Handler5.
Now we must implement all of the required functions of this base class, luckily .Net provides a method to do this for us; right-click on the base class name, and from the menu select Implement Interface -> Implement Interface:
This will automatically generate you all of the required functions of the base class. Trust me this is a life saver in cases like this with over 30 functions!
You will also notice that within each function there is one line of code throwing an error to the system. This is inserted by default and when the function is called it will throw a system error stating that the function is not yet implemented. This is not the functionality we want as we don’t really care if some functions are not implemented.
So remove that line of code to be left with empty functions. The end result looks like this:
C#
public class MyFirstPMP : PropertyManagerPage2Handler5 {
#region IPropertyManagerPage2Handler5 Members
public void AfterActivation(){}
public void AfterClose(){}
public int OnActiveXControlCreated(int Id, bool Status) { return (int)swHandleActiveXCreationFailure_e.swHandleActiveXCreationFailure _Cancel; }
public void OnButtonPress(int Id){}
public void OnCheckboxCheck(int Id, bool Checked){}
public void OnClose(int Reason){}
public void OnComboboxEditChanged(int Id, string Text){}
public void OnComboboxSelectionChanged(int Id, int Item){}
public void OnGroupCheck(int Id, bool Checked){}
public void OnGroupExpand(int Id, bool Expanded){}
public bool OnHelp(){}
public bool OnKeystroke(int Wparam, int Message, int Lparam, int Id){}
public void OnListboxSelectionChanged(int Id, int Item){}
public bool OnNextPage(){}
public void OnNumberboxChanged(int Id, double Value){}
public void OnOptionCheck(int Id) { } public void OnPopupMenuItem(int Id) { }
public void OnPopupMenuItemUpdate(int Id, ref int retval) { } public bool OnPreview() { }
public bool OnPreviousPage() { }
public void OnSelectionboxCalloutCreated(int Id) { } public void OnSelectionboxCalloutDestroyed(int Id) { } public void OnSelectionboxFocusChanged(int Id) { } public void OnSelectionboxListChanged(int Id, int Count) { } public void OnSliderPositionChanged(int Id, double Value) { } public void OnSliderTrackingCompleted(int Id, double Value) { }
public bool OnSubmitSelection(int Id, object Selection, int SelType, ref string ItemText){}
public bool OnTabClicked(int Id){}
public void OnTextboxChanged(int Id, string Text) { } public void OnUndo(){}
public void OnWhatsNew(){}
#endregion }
I have moved the curly braces up to the same line instead of on new lines to save space in the coding; it just makes for easier reading.
Some functions you have to add a return statement for as they require feedback, but since we won’t be using them in this book just type what you see. I will explain some functions later on and explain the return values and what they mean, but for now just accept what is written and write your code the same.
The #region and #endregion are Visual Studio styling tags, they are nothing to do with the program code and do not get compiled when you create your program. Their function is to tidy up your code.
Anything within the #region/#endregion block can be expanded and collapsed using the + and – box to the left of the #region tag.
This is very useful when your code gets long in order to keep it tidy.
Before we move on, let’s create the same coding but in VBA. Start by creating the usual VBA template that connects to SolidWorks, and acquires the active document. Then leave the main function like that for now.
Go to Insert->Class Module to insert a new class coding file. Open up this class in the coding window if not already, by expanding the Class Module folder and double-clicking the Class1 file. This should display a blank file in the coding window.
Before we start writing our code in here let me explain exactly where we are now; if this were C#, we would effectively be within the following code block:
public class MyFirstPMP : PropertyManagerPage2Handler5 { // We are here! }
The slight difference in VBA is that although we are effectively within the class when typing our code in the coding window, we do not specify the base class outside of the braces (because there aren’t any), but inside the class. So, inside our class file code we now want to start by letting it know we are deriving from the
PropertyManagerPage2Handler5 base class. Place this code at the first line of your class file:
VBA
Implements PropertyManagerPage2Handler5
Now, unlike .Net languages VBA does not have the power to automatically create all of the required base functions for us, but don’t panic! It does have a semi-automated method. In the coding window, notice the 2 drop-down boxes right above the first line of code. The one on the left is the Object Box, and the one on the right is the Procedures/Events Box.
Procedures is yet another word for a function or a method or a subroutine; each language uses its own term but they all mean exactly the same, unless you want to get pedantic and state that a subroutine should not return a value whereas all others can, but I wasn’t going to say anything.