Version history

version 0.73 (22nd October 2003)

version 0.72 (14th September 2003)

version 0.71 (31st August 2003)

version 0.70 (25th August 2003)
This is the first version of the new line.

A short guide to porting code from MASkinG v0.65

Warning: this is all just off the top of my head so it may be incomplete, inaccurate or even wrong.

Introduction
If you have used MASkinG prior to the release of version 0.70 you will immediately notice there are quite a lot of differences. The basic concept behind making dialogs with MASkinG has change more or less the same but a number of classes have been renamed, some functions and classed are no longer available and there are quite lot of new ones. But one of the most prominent changes is the fact that all the classes and functions have been moved from the global namespace to MASkinG's own namespace called MAS. This of course means that they are all no longer prefixed with MAS, like MASButton, MASWindow, MASDialog, etc. So the first thing you should do to port your old code from v0.65 or earlier to v0.70 is add the line:

   using namespace MAS;

   #include <MASkinG.h>

   class MyDialog : public MASDialog {
      MASClearScreen desktop;
      MASButton button;
      MASPanelRaised panel;
   };

   #include <MASkinG.h>
   using namespace MAS;

   class MyDialog : public Dialog {
      ClearScreen desktop;
      Button button;
      PanelRaised panel;
   };

Initializing
The next major change is the way you initialize Allegro and MASkinG in your program. Previously you would have to install and initialize Allegro yourself, then install MASkinG by calling a function named MASInstall(). Now you can install everything with a single function call to InstallMASkinG() and everything will be installed for you. So something like this:

   allegro_init();
   install_keyboard();
   install_mouse();
   install_timer();
   install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL);

   int err = MASInstall("allegro.cfg");
   if (err != MASkin::ERR_SKIN_NONE) {
      MASError(err);
   }

   Error err = InstallMASkinG();
   if (err) {
      err.Report();
   }

Widgets
A number of changes have been made in the widgetset and the widget baseclass. Some of the widgets have been renamed for various reasons, some have been merged into one widget and some have simply not been implemented in the new version. The changes are as follows:

There may also be some differences in the way individual widgets are used and there are a number of new ones available. See here for details.

Also note that the widget baseclass is now called Widget when it was previously called MASDialogObject.

The internal workings of a Widget have changed a bit. The most important difference is the way the widgets are drawn to the canvas. Previously you would simply draw to the parent dialog's public member called BITMAP *dscreen. Now you need to get your drawing canvas by calling GetCanvas() and release it when you're done with ReleaseCanvas(). But most widgets should draw themselves in the Draw() function instead of the MsgDraw() function anyway and shouldn't have to care about that at all. Also note that the widget shouldn't care about its position in the parent dialog. All the coordinates, be it the coordinates of the mouse or the coordinates where the widget draws itself, are relative to (0, 0) and not to (x, y) where x and y are the position of the widget. Speaking of mouse coordinates, the widgets should no longer rely on the Allegro mouse_x and mouse_y variables. They should call GetMousePos() instead.

Another big difference is that none of the widgets can be blocking. That means none of the may have loops that wait for some event in them. Previously when a button was clicked it would have a loop like while(mouse_b); to wait for the mouse button to be released. Now this problem has to be solved differently.

Also the way we do animations is completely changed. Previously animations were done with the DRS system through the InvalidateRect() function but now they're done with a special Animator class. If your widgets draw themselves with Draw they shouldn't have to care about that though. Also you shouldn't have to use InvalidateRect() anymore as this will be done for you.

The way widgets access the skin is different too. First of all the widget's skin is now called skin (previously it was theSkin). But there are now also Get functions for retreiving everything that belngs to a widget from the skin (like Widget::GetBitmap(), Widget::GetSample(), etc). So basically a widgets should almost never access its skin directly.

Dialogs
The dialog manager was rewritten completely from scratch. The API has stayed the same or at least similar in most respects but there are some changes. Two of the most prominent changes are that the Add(Widget) function doesn't place and resize widgets anymore and that the HandleEvent() function now takes two optional arguments instead of just one.

Other small changes that come to mind in no particular order:

There are also lots of other minor changes, see here for a detailed description of the dialog class.

Skin
The format of some of the bitmaps has changed and there are some changes in the skin configuration file. Every bitmap in the skin datafile can (and most should) have two properties called TCKX and TCKY that define the size of the part of the bitmap that gets tiled when drawn. Open an existing skin datafile in the grabber to see the what bitmaps have changed and see the template.ini file to see the changes in the configuration file format.

Also the format of the mouse cursor data file is different. All the cursors can now have 4 extra properties called FCSX, FCSY, FRMS and FDUR. The first two define the cursor's focus point and the other two define the cursor's animation properties.

Back to Contents