_GUIBASE

Quick Data

General Description

The _GUIBASE class contains functions and members that are relevant to most GUI objects, including functions to create, move, resize, and change the properties of a window. If you did not use this class, you would need to copy and paste these functions, which is a little bit of a pain if you learn after creating 25 components that one function doesn't work! Instead, all the common properties are here, but they can be overwritten by a class that inherits these properties if required.

You may wish to use this class to make your own GUI components. There are a few examples at the end on how to make use of this class in your own GUI components. The properties and methods tables are broken up into two categories - those which you'd normally use, and those that are relevant to programmers who are inheriting this class. I would suggest that you use this class as best as you can. It will save you a lot of time and effort in your own GUI classes.

Secondary Options

Properties - Ordinary properties

Properties - To use if you inherit

Methods - Ordinary methods

Methods - To use if you inherit

Events

Please see the chapter on event handling for information on how to use these correctly.

Important Note: along with each event, there is a parameter void* Sender. This is a pointer to the object that sent the event. You can access all the _GUIBASE properties for this object by acessing it with this code: ((_GUIBASE)Sender)->FunctionName(); What you might like to do is retrieve the Tag property. If you know what the component is, you can cast the pointer to that type of component. For example, if you know that the component that sent the event was a button, then you can use the button's properties by casting with the following code: ((fBUTTON*)Sender)->FunctionName();

If you really want, you can return the type of component that was sent. The ((_GUIBASE)Sender)->ComponentID property will be one of the following values, representing certain components.

• CT_BUTTON - fBUTTON
• CT_COMBO - fCOMBOBOX
• CT_EDIT - fEDIT
• CT_HOTKEYSEL - fHOTKEYSELECTOR
• CT_LISTBOX - fLISTBOX
• CT_LISTVIEW - fLISTVIEW
• CT_PROGRESS - fPROGRESS
• CT_SCROLLBAR - fSCROLLBAR
• CT_STATIC - fSTATIC
• CT_TRACKBAR - fTRACKBAR
• CT_UPDOWN - fUPDOWN
• CT_RICHEDIT - fRICHEDIT

Additional values may be available if more GUI components are added to your distribution. They will most likely be listed here when they are available. However, if you want to check the list or add more values to the list (in case you write your own component), it can be found at the top of gui_controller_start.h.

Sample Code

The following snippet gives a basic idea of how to use this component.

//Create your component, whatever it might be - in this example,
//it's just a button.
//You should not create an instance of a _GUIBASE object!
fBUTTON Button;

//All these functions are inherited...
Button.CreateWin(&Window, "Click me!!", BUTTON_ID, bsNormal, bsUsual);
Button.SetAll(10,10,75,25);
... = Button.Width();

Button.SendMsg(WM_NULL, 0, 0); //Just any message...

Button.Morph(bsNormal, bsCheckBox); //Change it...

//Please don't try this unless you know what you are doing
//(this code will not work directly).
Button.Assimilate(HandleToStartButton, ID_START_BUTTON);

Sample Inhertiance code

This sample code shows how to build an object that inherits the _GUIBASE properties and works properly.

In this example is the code for the fPROGRESS component, plus a few new explanatory comments.

class fPROGRESS : public _GUIBASE { //Inherit the _GUIBASE class.
      private:
//No private properties needed in this class.

      public:
             fPROGRESS()
                  {
                  //Initialise all the stuff...
                  //You will need to do this in your class too...
                  //Set the window class.
                  WindowClass     = PROGRESS_CLASS;
                  //Set up other options...
                  RepaintOnResize = TRUE;
                  Handle          = 0;
                  pLeft           = 0;
                  pTop            = 0;
                  pRight          = 0;
                  pBottom         = 0;
                  pWidth          = 0;
                  pHeight         = 0;
                  DontDestroy     = FALSE;
                  #ifdef F_USEFUICONTROLLER
                  //Change this to TRUE if you want to use
                  //the TAB key to change the focus.
                  UseTab          = FALSE;
                  ComponentID     = CT_BUTTON;
                  Internal_GUIInit();
                  #endif
                  };

//Add your extra properties here. If you have a basic component, you can
//just add some extra properties to make it go.
             void SetBarColour(COLORREF Colour)
                  {
                  if (Handle) SendMessage(Handle, WM_USER+9, 0, (LPARAM) Colour);
                  };
 ...
             void Step(void)
                  {
                  if (Handle) SendMessage(Handle, PBM_STEPIT, 0, 0);
                  };
};

Of course, there is more to the inheritance than this. Firstly, there is the CreateWin() function thingy. Mostly you can use the default ones, but sometimes you may like to replace them with functions that take more or less parameters. An example of this is the listbox, which has it's own CreateWin() functions altered to leave out the caption parameter. If you wish to replace these, copy the CreateWin() functions from gui_base.h and then paste them into your class. Then you can change them to suit your needs.

However, if you just want to do some initialisation before you create the window, or initialisation afterwards, then you can replace the functions void Internal_InitBefore(void); and void Internal_InitAfter(void); These might be useful in situations where you need to load a DLL before you can create the window, or if you need to set some properties related to the window you just created - an example of this is the RichEdit control. Please note that the two aforementioned functions are called internally from CreateWin().

...
//So in your class, if need be, use these functions...
void Internal_InitBefore(void)
     {
     //Do some stuff before the window is created.
     };

void Internal_InitAfter(void)
     {
     //Do some stuff after the window is created.
     };

The last item not mentioned yet is the use of the ComponentID member. Go and have a look at the source of gui_controller_start.h - in particular, lines 31 to 48. The lines 31 through 48 specify numbers for each type of component. The numbers from 1 to 49 are reserved for components based on the _GUIBASE object. The other variables are special objects that require the GUI controller, but are not based on _GUIBASE. If you wish to create a new component, you may like to add a new constant to this list. Please note that I may change this if you submit the code to me; the reason for this is to make sure that all the components fit together nicely - but if you use the constants, there should be no problems.

Any more questions? If you are having trouble, go and look at the other components which make use of this - any of the GUI components (except fFORM) makes use of this class. One class that may be worth a look is the fRICHEDIT class (in richeditor.h), as it has to use both the Internal_InitBefore() and the Internal_InitAfter() functions to load the appropriate DLL's and then unload them when the window is destroyed.

If you make a new GUI object, share it with me and I'll share it around! I'll document it as best I can, and you will definitely get the credit. Please see how to contact me on the main page for where to send your class.