Adding more file formats

As you can see in my 'screensos' source forge project, I have been very active over the last few months.

I have lately added support for png files in FilePng and xml files in FileXml.
I am adding a lot of formats to make use of them in various sub projects.

I have also done a lot of refactoring and tweaking of existing components.
I know that Screens is lacking a lot of documentation. Because I am still in the development stage, I am focusing on the development since the documentation can be added later. It does keep this project under the radar (which I can see just from the page views) but I am fine with that since its not in a usable form anyway at the moment.

Drawing text works

Drawing text now works very nicely.

I have a utility fontray_mk to take any MacOS font and convert it into a C file containing the font data. Then I can easily use any font by just compiling it and passing its buffer into DataFontrayDraw function.

I have uploaded the changes regularly to source forge (ScreensOS).

Font handling

Just uploaded last night the UtilFontray component that allows me to easily capture any MacOS font and store it as an embedded bitmap font format. I am now working on the code to draw the bitmap font format and then I will be complete for an initial drawing scenario of fills, frames, bitmaps and text.

Casting power

One of the great advantages in dynamic casting is that you can move between capabilities of any object with any one of its handles.

UIWindow * pWindow = UIWindowNew();
UIElement * pElement = UIElementCast(pWindow);
pWindow = UIWindowCast(pElement);

You can see how I can move from the element to the window to the element easily and safe.
This simplifies code a lot since I don't have to pass objects down the pipe.
Its a lot like a C++ dynamic_cast call but in ANSI C!

It makes the components that I have to write small and simple.

Power without a manual

I am waiting for september before I buy an iPad to allow my brother to draw graphics for the game.
In the meanwhile I am fixing code bugs, rewriting components and adding new components into the mix.

It is taking me a while to get used to the power of association relationships. Everyone is more or less used to inheritance and containment relationships. Association relationships is not used very much at all even in high level languages. So its not like I can use the web to find out what oppertunities are available for me. I have to find them out one at a time.

Component C Extensions

Using Extensions in Component C makes it so easy to have separation of concerns.


Here is code how to start a specific application component:

- (void)viewDidLoad {

    [super viewDidLoad];

    

    /* Link application to ios view */

    UIAppComponent->pExtension = IOSViewComponent;

    /* Link ios view to engine */

    IOSViewComponent->pExtension = MyGameComponent;

    /* Start the application and set up the view handle */

    self.view = (id) IOSViewHandle(IOSViewCast(UIAppStart()));

}

The second line links the IOS platform specific implementation to the application engine.

The third line links the game component to the IOS platform.

The fourth line starts the application and links the view to the controller.

Neither the application component or the game  are aware of the platform it is running on.

And the platform does not know what game is running.

This is a separation of concerns and allows me to port code to run on the mac and then run it on the simulator without having to modify the game code itself in any way.

Note that the application component creates the object and does not need to be passed the platform or game to run. It all works behind the scenes and that is the way it should be done.