tag:blogger.com,1999:blog-77893162011-12-15T09:45:34.128+02:00Screens Environment is a multi-platform component based middleware research project designed to connect technologies together and provide better user experiences for the future of computing http://sourceforge.net/projects/screensos/Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.comBlogger2921100tag:blogger.com,1999:blog-7789316.post-7230104855342335942011-12-15T09:45:00.001+02:002011-12-15T09:45:34.133+02:00

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

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-88460202178824679752011-09-28T15:19:00.001+03:002011-09-28T15:19:37.471+03:00

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).

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-71482037166506316852011-09-18T08:53:00.001+03:002011-09-18T08:53:24.566+03:00

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.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-22666494143526115642011-08-19T10:55:00.000+03:002011-08-19T10:55:14.096+03:00

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

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-37624639807018152262011-08-16T09:19:00.000+03:002011-08-16T09:19:30.067+03:00

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

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-30722840342021205962011-08-05T19:07:00.001+03:002011-08-05T19:09:43.439+03:00

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

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-88860390009499396262011-08-04T22:36:00.000+03:002011-08-04T22:36:18.204+03:00

Hi, As you can see by my source forge status, I have working on the Screens components for quite a while. I am playing around with a simple game for the iPhone to test and write new components. I have finished an initial version of the application but I still lack some good graphics that I need to import before I can publish it to the AppStore. It was written using only Component C components.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-79676316775299067102011-05-22T11:51:00.000+03:002011-05-22T11:51:11.983+03:00

I have been active on my ScreensOS project. I did another refactoring of the components and made it simpler to understand and easier to send notifications. To register for an event: CoreEventRegister(pObject, CoreNodeComponent, CORE_NODE_EVENT_MOVE, MyMoveCallback); To send an event: CoreEventNotify(pObject, CoreNodeComponent, CORE_NODE_EVENT_MOVE); The advantage of this design is that each

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-23227587489255204362011-05-01T02:34:00.000+03:002011-05-01T02:34:47.469+03:00

Great! FileXml parser works combined with FileChunk and FileToken. However there is a bug in detaching objects when inside a destroy handler message. I will work on this bug next. I gave it a simple xhtml file and it parsed it successfully. I will do some more tests on different xml files to know that I can move on to the next set of components. You can find always the latest package of

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-76508609711726165862011-04-29T00:25:00.000+03:002011-04-29T00:25:08.024+03:00

I saw a problem lurking which was the callback design for components. There was no way to know when an object was being destroyed unless the component sent a notification. The component could know that its instance is being destroyed but attached objects could not know. I met this problem in FileToken where it wanted to point to an attached FileChunk instance but would not know if the FileChunk

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-10425172057601824752011-04-27T23:46:00.000+03:002011-04-27T23:46:29.064+03:00

Things are moving along quite nicely. 1. FileChunk that divides files into chunks has been finished. 2. Rewrote CorePool to be a simpler design. 3. Fixed various bugs along the way I work in a sequence where I write code without testing it and test it at a later date. Because each component is small, its easier to debug and decide if to re-factor or not. Next component I am writing is

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-42759827423392100572011-04-13T21:13:00.000+03:002011-04-13T21:13:19.387+03:00

You can find a zipped collection of all the packaged components at:  https://sourceforge.net/projects/screensos/files/screensos/ Currently its labeled packages_001.zip I also uploaded a simple 'author public domain' comment for each file to keep things license consistent. I am currently working still on the FileXml component. It is taking a little longer than I expected but I am sure progress

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-85902114349536243412011-04-08T16:13:00.000+03:002011-04-08T16:13:56.887+03:00

You can find the latest code uploaded via SVN at: http://screensos.svn.sourceforge.net/viewvc/screensos/ I know that it looks like Screens is not moving anywhere, but there is an actual strategy involved even if it is taking a long time. Let's recap: 2002-2008 = Wanted an application middleware, researching which programming model to use 2009-2011 = Figured out a new programming model:

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-37597887737500797302011-04-01T16:57:00.000+03:002011-04-01T16:57:34.519+03:00

I finally found how to explain the advantage of Component C objects. Using Component C objects is like eating a buffet. You have a choice of different foods which you can pile onto your plate in any combination or order that you want. Using traditional object oriented languages/frameworks is like eating at a restaurant. You have a choice of different meals, each with its own combination of

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-75686620060235805232011-03-19T22:04:00.000+02:002011-03-19T22:04:12.412+02:00

Just to let you know that the latest code has been uploaded into the ScreensOS repository.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-38516988313544421742011-03-18T16:37:00.000+02:002011-03-18T16:37:03.408+02:00

Hi, Sorry that I am consistently late in my updates. I have been writing loads of components such as CoreQueue, CoreState, CorePool. I am expanding the components and fixing bugs as I find them in existing components. My next component is FileXml which will manage xml in an object oriented fashion but will have a twist where the objects are allocated by the caller instead of by the component

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-45780632677198985192011-02-15T23:14:00.000+02:002011-02-15T23:14:58.304+02:00

I have been working hard on the data bitray component. I finished writing a first version of DataBitrayPaint. I am now working on enhancing the component to be able to compress/decompress/paint from one source to another. This should take me so time to figure it out and keep it simple. I will update you when I am done.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-87487718552205006702011-01-28T16:18:00.000+02:002011-01-28T16:18:16.693+02:00

Uploaded the bitmap handling component (which is endian independent thanks to FileBinary component) which reads bitmap files. However the component I want to talk about is the DataBitray component (packages/data in SVN). It allows compression and decompression of pixel buffers with some nice features: 1. In-place compression/decompression - Because the compressed data is always smaller or equal

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-79160200620734006322011-01-04T23:36:00.000+02:002011-01-04T23:36:35.866+02:00

I have just uploaded another set of files to the screens soureforge svn. Added many components such as UITouch to manage multiple touch points and FileBinary to parse binary files with a field specification. My next component is FileBitmap to manage reading and writing bitmap files. Overall I am happy with the accelerated coding of components which are being written quite quickly. My favorite

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-57713854984452270982010-12-25T19:56:00.000+02:002010-12-25T19:56:19.774+02:00

1. I just bought my first iMac top of the line (i7 2.9GHZ+SSD+8GB+1TB) which I am enjoying immensely. 2. I have ported my code over to XCode for the iPhone development. 3. I have updated my svn (under packages) with the latest components. So I am back to work with a clear development path. I have added support for inheritence+extensions for objects. For example: IOSView extends UIDisplay

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-38647408999951288712010-11-14T00:23:00.000+02:002010-11-14T00:23:40.545+02:00

I have been low on the radar because I have been working hard on the code instead of updating the blog but mostly because I didn't have anything to show. I now do have a another snapshot of my code to show. While this is in no way Screens, it does preview the object storage with some example components. I now support singleton components (components with only a single instance) and improved the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-10445231799503472982010-09-06T00:11:00.000+03:002010-09-06T00:11:19.591+03:00

You can find the latest set of components here: http://www.box.net/shared/ylgxz565id I have added some components to get the idea of how components are written. I know that the concept is a little rough around the edges and I am working hard to make it more understandable and explaining the killer app for this kind of technology. Note that while the code does compile in Visual Studio 2010

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-39585454268089517642010-08-09T22:00:00.000+03:002010-08-09T22:00:23.502+03:00

Dynamic association is my new 'magic' programming model that allows objects to be collections of functionalities that are dependent/independent of each other as needed. Most developers are used to inheritance (is-a) or containment (has-a). There advantages are many and most applications today, use them heavily in their application design. I see association (use-a) as the new way for designing

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-17717725483167509922010-08-05T00:42:00.001+03:002010-08-05T08:47:37.608+03:00

The code can be downloaded at: http://www.box.net/shared/9i4g3mbo5m Note that the code is a draft and while it does compile in VS2010, it has not been tested very much. Its just to show the direction I am taking with the Component based programming code. The licence is public domain and Screens is staying that way for the foreseeable future. I am now working on the component CoreShadow which

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-79693419372822856812010-04-05T22:54:00.001+03:002010-04-05T22:54:58.588+03:00

As you can see from my twitter updates, things are moving forward. I am slowly but surely moving up the component chain. The only nagging issue at the moment is that components can be attached freely to objects however when I depend on multiple components, the interface does not specify what components are public. For example: UIWindow uses CoreItem to manage the window hierarchy but how would I

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com3tag:blogger.com,1999:blog-7789316.post-32674067112790007002010-03-27T23:56:00.002+03:002010-03-28T00:10:49.269+03:00

Object oriented programming has existed for over 30 years however users still dont see objects at all. Even when it is object oriented, it is made totally static and fixed so that users dont get any benifit out of objects. When you see research projects show how easy objects would be for users, the first question which pops in my head is why is not here yet. The reason is simple: its easy to

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-30458329935209799782010-03-11T22:44:00.001+02:002010-03-11T22:44:27.562+02:00

Hi, I am still working on Screens as you probably can see by my twitter stream. Its still taking me forever to design the interfaces. Once I have an interface design, coding is very quick per component. I just spend alot of time perfecting my interfaces. I know… I am a perfectionist and this system will never be more than vaporware. But even if so, I owe my full time job to Screens from all the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-82707567386158281452009-10-06T09:31:00.002+02:002009-10-06T09:52:06.306+02:00

OK, Here we go again... My latest evolution of the object storage is as follows: Each object can contain an instance per component.This means that a markup object can contain the following instances:UIMarkup - Html markup instance for displayFSHtml - Html parser instanceFSXml - Xml parser instanceFSFile - File stream instance The idea is that the markup object is also a markup object, also an

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com5tag:blogger.com,1999:blog-7789316.post-28344191272301673832009-09-13T19:48:00.002+03:002009-09-13T19:53:41.371+03:00

Hi anyone who still checks this blog, I now I have not updated for a long time. I moved to Jerusalem with my family, had a lot of work to do at my full time job and my son started kindergarden. Alot has changed since I first started Screens is 2001. Screens is not dead, actually on the contrary... I never stopped working on Screens and have in fact tested a few of my ideas at work and they have

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-61021152680885299432009-02-19T17:12:00.003+02:002009-02-19T17:52:57.097+02:00

1. Don't rely on a compiler extension when doing platform indepedent codeYou will never know when your code will hit a compiler you did not anticipate. Keep it cleanand simpleand don't try to be smart. Consistency is key in writing alot of components. Avoid using tricks because their value will decrease over time because you will lose track of the tricks you used. 2. Using a 'better' language (C+

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com8tag:blogger.com,1999:blog-7789316.post-40679414668065721942008-10-13T13:13:00.001+02:002008-10-13T13:13:58.319+02:00

Screens Environment has been going since 2002 and still no releases have made the light of day. There is a single reason why Screens has taken so long and why I have no idea when it will be released. Its not because I lack time or interest. Its because of the object storage. If you look at the object oriented OS projects, none of them have made mainstream because they are not practical enough,

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com9tag:blogger.com,1999:blog-7789316.post-41016242697433604942008-10-08T15:48:00.003+02:002008-10-08T15:52:44.748+02:00

The difference between component oriented programming and object oriented programming is focus. In object oriented programming the focus is the objects themselves which is why you access methods through objects like this:CoreObject * object = new CoreObject;object->rename("My Object");In component oriented programming the focus is the components and objects are just placeholders for instances

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-68460524157271197162008-04-28T22:00:00.002+03:002008-04-28T22:03:48.645+03:00

I am going to try and use twitter for quicker updates on development and keep the blog for more milestones and other news, follow me at http://twitter.com/zhamilton1 for some live development updates on how code is the Screens code is evolving and the issues I face daily.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com5tag:blogger.com,1999:blog-7789316.post-65822743848867551632008-04-08T07:53:00.002+03:002008-04-08T08:00:45.468+03:00

Hi Everyone, Sorry for the lack of updates, I was at my wifes parents house for the last 3 weeks, so not only could I not do any coding but internet access was not as spiffy. My wife had birth to our new baby girl at 22:25 last night (monday night) weighing 3.780 kg in her 41st pregnancy week. The baby is beautiful (but then again, I am biased) and is healthy and doing very well. This is my

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com6tag:blogger.com,1999:blog-7789316.post-62668279807003859172008-03-10T23:36:00.003+02:002008-03-10T23:50:49.711+02:00

1. No Worries Don't worry... This is nothing to do with the state of PalmOS or Screens. I don't want to say anything just in case something does not happen as planned but I will not be very active on Screens in the next few weeks for some family prime-time. 2. Technical improvements I have uploaded the latest code for the shell bar and while it does not display anything at the moment on the bar

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com6tag:blogger.com,1999:blog-7789316.post-8631750466273123472008-03-05T23:55:00.001+02:002008-03-05T23:55:16.878+02:00

I added the rectangle when moving a window that shows the border that will cause the window to maximize. I still need to do a bit more design before I can finalize on the system bar and finish a first draft of its implementation. Hopefully I can have something by the middle of next week. About the patents... It does not matter since the code is already public domain and I don't mind if someone

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-10792472812907188212008-03-02T22:36:00.001+02:002008-03-02T22:36:54.027+02:00

Things are moving along again and every small step is shaping Screens into a much more usable demo. Here is a demo of the maximize/restore feature I told you all about which I hope you will like: I found it very practical and easy to use and I wonder why no one else uses this method instead of small buttons. When the shell will be finished, you will be able to minimize windows by just dragging

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com3tag:blogger.com,1999:blog-7789316.post-13146797917346522572008-03-02T00:34:00.001+02:002008-03-02T00:34:34.567+02:00

Sorry for the lack of updates but this has been a slow period since not much changes from a visual perspective but alot has changed under the hood making way for the shell bar + slider. Windows can now be maximized by dragging their title to the top of the display and can be restored by dragging the title back into the middle of the screen. I hope you like it, I will upload a video soon showing

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-92198040081184094732008-02-24T00:46:00.001+02:002008-02-24T00:46:33.372+02:00

I have added maximize/restore ability to windows and added the window title text. I will be starting shortly on the shell package which manages the Safire main system parts which is the slider menu and system bar. I am designing the last API parts of the menu. Note that because I have not implemented timers, there will be no animations in the slider but it will still give the effect. I can't

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-38349574784043026492008-02-21T20:16:00.001+02:002008-02-21T20:16:10.967+02:00

Details of my shell design are really coming along and I am starting to implement the basics to support the Safire shell. I already know more or less how the UI will look and I cannot wait to show you a demo of it. Now that all the platform main problems are behind me, I can finally start do things that are more user visible. A bunch of moving windows is not enough to spark user interest but I

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-36205522718405043172008-02-20T14:12:00.001+02:002008-02-20T14:12:00.530+02:00

I have solved the exit issue and now Screens runs like it used to before the module split. The performance is not that bad: I did not believe that Screens would improve as it has in the last 3 months. I still have alot of work ahead but these are design issues, not platform specific problems. I know how the UI will look but I need to design their components. I can't wait to show you all the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-45915304952285742342008-02-20T01:42:00.001+02:002008-02-20T01:42:19.708+02:00

I don't believe it! http://www.eskimo.com/~scs/cclass/notes/sx4aa.html It turns out that PalmOS is pre-ANSI C compiler which means that it does not know how to always initialize local arrays correctly. It took me a long time to figure this out (thank you www.live.com) OK, So let me tell you what all this work meant... It means that Screens can support modules in a very easy way. Currently I am

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-31218293042899341772008-02-19T23:53:00.001+02:002008-02-19T23:53:23.990+02:00

OK, I still cannot understand why I am getting "Invalid read from 4E560000" error but I am still trying to debug the code (even though I cannot use the debugger). However I have made a utility to allow me to create the API wrappers easily which has been uploaded including the source code.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-2280878402658437192008-02-17T01:09:00.001+02:002008-02-17T01:09:59.552+02:00

OK, Things went smoother than I thought. I have finished the API wrappers between the packages. I still have to do the final code to set up the feature memory function pointer so that I can lookup loaded modules for the associated function. It should not be that slow because I do a small string lookup for the package name and then the function is by index. Also its easy to set up for new modules

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-75957937021032403102008-02-15T13:35:00.001+02:002008-02-15T13:35:07.026+02:00

Screens is not doomed yet, however I am working on a very non UI issue which is the package/module interconnection. I have no problem loading a module. The problem is linking between the API calls which I am doing in a mostly platform independent layer which makes it hard to get it working but once its working, it will be easy for me to write new modules and connect the modules together. I also

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-16675963662990515562008-02-12T22:28:00.001+02:002008-02-12T22:28:04.811+02:00

Hi, Sorry for the lack of updates...  I have been working hard on the module side of Screens. The kernel is more or less usable and now I need to start working finally on the UI Shell module. I still need to figure out the model model in all its glory details, this really feels like the final 'big problem' in front of Screens to stop the demo from being released. The loading of modules is more or

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-33122977430360577692008-02-07T07:44:00.001+02:002008-02-07T07:44:14.874+02:00

Sorry for the lack of posts and updates this week. I have had to put some more time in my full time job which did not leave me much time when I got home to work on Screens. However I have still had to plan the next components which is the shell itself. I have a new graphical layout which I hope to test soon in code. I have had some SVN activity and I still need to upload some more changes in the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-27517420065682908332008-02-03T23:58:00.001+02:002008-02-03T23:58:01.975+02:00

Here is the latest version of Screens running on my LifeDrive without crashing and with a good enough frame rate. I decided that I would try optimizing my code first and only if all efforts fail go towards ARM. Well, It looks to me like its fast enough at the moment to continue on this path without ARM. First of all, this is the 'release' (not 'debug') compilation which improves the frame

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-32157452044464943662008-02-01T15:54:00.001+02:002008-02-01T15:54:46.536+02:00

Here is a video of Screens running on my PalmOS LifeDrive: You can see that it is very slow and its because I am doing blitting without ARM code which seems to be the way I need to go if I want Screens to have more than 1 frame per second. I hoped I would not need to go in the ARM direction but I guess I have not much of a choice at the moment. Screens still crashes on exit but what's strange

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-72664831127638474892008-01-31T22:35:00.001+02:002008-01-31T22:37:08.440+02:00

Its as slow as hell because I am using a pixel by pixel blit using the WinPaintPixel PalmOS function. I just need to find a reliable way to blit to the screen and it should be much faster. Also when I exit it still crashes but I am sure I will find the solution to the crash very soon. Also note because I don't have a blitter, there is no transparency on the Palm version. Once I use a blitter, I

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-77421023256235711512008-01-31T17:46:00.001+02:002008-01-31T17:46:47.486+02:00

Mounting VFS Folders works but what is even more cool is that the drives appear like windows drives so for example: I did not have to change a single path in my test file to test VFS browsing on the simulator. So for example C:\xec\ works also on the handheld using the first VFS slot (most devices have a single VFS slot) and mapping it to the C drive. This makes it easy for me to transition

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-68704351167741853372008-01-31T02:11:00.001+02:002008-01-31T02:11:40.558+02:00

I just uploaded the new UIList component which deals with a collection of items and deals with scrolling them in a unique way. Here is a demo of what it can do with simple strings: If you noticed at the end of the video, I run the same demo on my LifeDrive and it works (apart from the lack of font & bitmaps). I was so sure the speed was going to be terrible but I guess its not that bad after

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-85003776384574201442008-01-30T04:30:00.001+02:002008-01-30T04:30:01.250+02:00

I doubt I will actually be at 'release' for 1.0 but it will probably be for demo release. I still have alot to do, but I am very happy with the progress and how the code is very streamlined. Note that if you want to take a chance you can find the Safire.prc file here: http://screensos.svn.sourceforge.net/viewvc/screensos/Safire/garnet/make/ Note that its only been tested on the simulator and

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-54013834221789478992008-01-29T21:08:00.001+02:002008-01-29T21:08:19.999+02:00

I have finished writing the FSDisk implementation for PalmOS using the VFS API. It took much shorter time then I thought it would. I used most of the FSDisk Win32 implementation. I now need to test & debug it and fix its bugs using the PalmOS Simulator.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-54607643582348377242008-01-29T14:58:00.001+02:002008-01-29T14:58:24.619+02:00

Here is a video showing the PalmOS version running on the simulator side by side with the windows version: I have not coded for PalmOS for some years and I need to re-learn alot of the basics. Its very frustrating returning to the limited platform but its a great exercise. I am getting there, but its taking forever. I am trying as hard as I can. About compatibility, I am currently targeting

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-23709782138394676752008-01-27T23:06:00.001+02:002008-01-27T23:06:07.325+02:00

I don't believe it! I have a PRC file that is compiled from the latest source code! I found a solution for the errors I was getting in PRC-Tools by using one of the latest cygwin1.dll files which seems to suddenly remove all my previous 'cygwin alloc' problems on vista. I had to do alot of pluming for Screens to compile for PalmOS because of multi-segments. So I devised a platform independent

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-43090605139079081632008-01-26T20:48:00.001+02:002008-01-26T20:48:46.673+02:00

Screens is moving along slowly but so far, so good. I did some more bug fixes and added the check box component (which was mostly the button code). The video gives a demo of the check boxes. I still don't know how I will finish the PalmOS port since I have no way to debug or even completely compile (I can do partial compiles) Screens for PalmOS since its not supported on Vista which is a shame

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-51293072184641350912008-01-25T13:02:00.001+02:002008-01-25T13:02:42.855+02:00

I have written most of the drawing code (still have the blitting function to implement) however while it compiles, I am sure it won't run and will need alot of debugging to get it working but I do know that the structure is mostly there. I did alot of copying from a previous project I had worked on a few years ago so I still have alot of work to comment the display code. At least I know that the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-54302972136518398482008-01-24T22:17:00.001+02:002008-01-24T22:17:02.789+02:00

I have uploaded some more PalmOS components that although they have not been tested or compiled will provide me with the code to use when I can get an environment to compile in. I still have two files left to code for PalmOS to get the current platform dependent code written which is the FSDisk component which will be mapped to VFS PalmOS API functions and the UIDisplay component which maps to

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-51872778752535075072008-01-23T23:45:00.001+02:002008-01-23T23:45:35.007+02:00

Just uploaded SVN 0.39 which includes multi-line text and some minor changes to the threading component. I am amazed at the progress so far and hope that it will continue. I have decided to show you all what Screens Environment test app currently looks like. Note that this is just to test its capabilities and not how Screens will finally look in any way at all. Here is the video: I don't

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-86534116996053242992008-01-23T00:17:00.001+02:002008-01-23T00:19:49.816+02:00

I did some work the thread component to make it more self manageable. It allows to use it by just creating threads using CoreThreadNew and calling CoreThreadProcess which returns when every thread has finished. I also added support for a parameter to be passed to the thread function. I think this is one of the easiest API's for using threads.#include "CoreThread.h"void main() {CoreThreadNew(

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-30504911662858486382008-01-22T07:27:00.001+02:002008-01-22T07:28:51.854+02:00

It works even in release mode! It uses a simple setjmp/longjmp implementation which I will try to make even smaller. It uses stack copying and hope to make it with enough comments for future help to developers. It took me quite a while to get it working and there was not much information on how to use setjmp/longjmp in this design.Note that the only dependencies of the CoreThread component will

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-55516281774927751242008-01-21T07:33:00.001+02:002008-01-21T07:33:17.206+02:00

I have been trying for the last few days to try and get some basic multi-threading done however while it compiles and works wonderfully in debug mode, it is not saving/restoring the stack correctly in release mode. I am trying to figure out the differences between debug/release mode and while I turned off optimizations, it still happens. I hope I will find a solution. I am using setjmp/longjmp

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-87307869125542171332008-01-17T20:30:00.001+02:002008-01-17T20:30:04.799+02:00

I have converted the PalmOS High-Res Font to work on Screens. Its just a bitmap and an XML file that Screens uses to draw text very easily. You can easily understand the XML file where it specifies the character code, offset and width of the character in the bitmap file. Its uploaded to SVN. I am amazed at the development this month. You can tell just by looking at the number of posts this month

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-65257780063323670982008-01-16T21:10:00.001+02:002008-01-16T21:10:17.720+02:00

I have added text alignment and text in buttons so now I can display centered text in buttons which works very nicely. Screens is starting to get functional which is very nice. I do need a better font though but meanwhile I think I will take the PalmOS font and convert it to my XML/Bitmap hybrid font format so it will work with Screens. Note that I use ASCII format and not Unicode at the moment.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-72012993756085142182008-01-14T22:11:00.001+02:002008-01-14T22:24:48.991+02:00

Finally... the moment has arrived... I can draw text on-screen using a custom made font (just took a snapshot of some capital letters and threw them into a bitmap and then described them in the XML file) The format of the XML is very simple and the bitmap is just a 256 color bitmap where the palette is ignored and the index is the transparency from 0-255. If someone wants to create a better

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-16041188700745409032008-01-14T00:23:00.001+02:002008-01-14T00:23:14.110+02:00

I am very close to finishing the basic drawing of text on-screen. I have uploaded the changes already. Although I currently draw the entire font bitmap, I do draw it with a specific color. What I need to do now is mount the XML file and build an array of the characters offsets and widths so I can draw text elements easily. Note that all this code including the zip and XML code is platform

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-63351112159483217152008-01-13T00:00:00.001+02:002008-01-13T00:00:43.803+02:00

I am still getting problems with compiling for PalmOS on Vista using PRC-Tools. It works sometimes and then other times fails completely. So I am jumping between advancing the feature set of Screens and porting to PalmOS. I am a step forward in the font engine dealing with the bitmap side since the XML side is more or less complete. I hope I can find a more reliable compiling experience so that

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-78470767559851152472008-01-11T13:28:00.001+02:002008-01-11T13:28:08.975+02:00

I have decided to port to PalmOS before dealing with the text & font component so that I can know the code performance. It took me a long time to get to compile anything on vista with the PalmOS Developer Suite. Luckily I found the following article to help me compile on vista: http://charlesmcp.blog.com/1552399/ However I am still having the following error: C:\PalmOSCygwin\bin\

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com3tag:blogger.com,1999:blog-7789316.post-16749210110883499792008-01-09T22:54:00.001+02:002008-01-09T22:54:53.423+02:00

I am constantly trying different stuff to find bugs and fix them. You can see from my SVN activity that I am very active on Screens. I just dealt with little/big endian issues and now I can easily read and write data in its little or big endian format without much work. This is crucial since PalmOS is big endian while Windows is little endian. The zip & bitmap format is little endian so on

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-21589228256394879312008-01-08T00:27:00.001+02:002008-01-08T00:27:49.104+02:00

OK, I have decided to postpone zip compression to a later release since its not needed at this time for the font component. Screens can handle uncompressed zip files and mount XML files and draw bitmaps directly from within an uncompressed zip file. This functionality is exactly what I needed for my font format which is an uncompressed zip file with an XML & bmp file. I am very happy with the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-85622863351655887272008-01-06T21:04:00.001+02:002008-01-06T21:04:26.670+02:00

I don't believe how far I have come in such a short time. This last month has been unbelievable. OK, I'll control my enthusiasm... The zip component development is going very well. I now mount objects with the file names of the zip content. I still have to decompress the content yet which I might do on the fly if possible.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-89654967218427094492008-01-06T01:17:00.001+02:002008-01-06T01:17:03.438+02:00

OK, it is harder than I thought it would be and it looks like it will take some more time just to support the basic deflate compression method in a zip file. But all this information is a learning experience for me which is nice. Currently I know the number of files in a zip file but I still cannot seem to know their file name. Oh well, I will probably find it out soon. Once I know their names,

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-76047130208767937002008-01-04T15:17:00.001+02:002008-01-04T15:17:20.495+02:00

I have started working on the zip component which just like the XML component, mounts a file stream and creates child objects that allow to access the uncompressed file data easily once mounted. I am trying to support basic zip files (no encryption or other fancy features) so that it will work with my XML+bitmap font design. So far, I have already find the information I need for understanding

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-40093415049766091072008-01-04T08:56:00.001+02:002008-01-04T08:56:25.016+02:00

Q. About how what is the maximum size of the read only cache? A. The maximum size is the maximum that the allocation function allows (platform dependent). Because of its temporary nature, it just does a big allocation and if it fails, it returns NULL that it cannot give a read-only cache. The read-only cache is destroyed when you close the object. Q. Also How do I compile the SVN files? do I

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-21985106413360883322008-01-03T17:54:00.001+02:002008-01-03T17:54:07.468+02:00

I have finished coding the XML component and uploaded the changes to SVN. Tags are mounted as FSFolder objects while Attributes are mounted as FSFile objects. I am amazed how things are suddenly moving very easily. But I doubt that the font & text component will be as easy. I will probably have to create a container component first to hold both the font XML and the bitmap font, so I will see if

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-57299490802726980672008-01-03T14:04:00.001+02:002008-01-03T14:04:33.108+02:00

Just to let you know that things are moving nicely. I have nearly finished the XML component but currently lacking support for tag attributes and for the creation of the objects that are mounted under the XML file object. This will allow me to mount any XML object stream and access its tag and attributes as simple objects. Because of the object oriented design, the XML component is not aware of

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-5573660322833235202008-01-02T18:53:00.001+02:002008-01-02T18:53:28.149+02:00

It looks like I am going to have to use my own bitmap font format. However it will be using a standard 256 color bmp file for the glyphs and an XML file for explaining the glyphs in the bitmap file. These could be easily put in a zip container and when I add zip support to Screens, Screens will able to use the font directly from within the zip file. Although I don’t yet deal with 256 color

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-90863986159081096522008-01-01T17:27:00.001+02:002008-01-01T17:28:00.205+02:00

This is the furthest I have ever gone from a code perspective in Screens in the last 5 years which is something. I always find some problem (complexity, speed...) which required a re-write of the object architecture. I can now display bitmaps on-screen clipped to a region. What's cool is that the bitmap is loaded once into an element object and then the drawing is done from in-memory using a new

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-41019620265177893142007-12-30T22:12:00.001+02:002007-12-30T22:12:11.526+02:00

Uploaded another collection of fixes to SVN that make the stream support actually usable (it was written but not tested before hand). I have decided to postpone the persistence loading and saving of objects to a later date and I am focusing on the more visual elements of Screens. I am currently working on bitmap loading and I am very close to displaying 24bit bitmaps on-screen. What's nice is

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-73108940727512809952007-12-29T22:57:00.001+02:002007-12-29T22:57:02.000+02:00

Moving along... I have decided to merge the persistent storage functionality from being a separate component into the CoreObject component itself. This allows any object to be persistent and be saved and loaded from a file by just calling the CoreObjectSetAsPersistent on an object. If an object is persistent, it automatically makes its folder and its classes persistent as well. Because the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-81995931046045262732007-12-26T21:50:00.001+02:002007-12-26T21:50:01.512+02:00

This week has had less of Screens action since I had to put some more effort in my full time job. I have made progress however. For example: CoreObjectBrowse now can mount objects automatically so you can pass a path like this: \C\Users\home\Documents\Downloads and it will mount each folder until it finds the Downloads folder. I also moved the rest of the mounting functionality to the CoreObject

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-71946886072679124742007-12-23T00:40:00.001+02:002007-12-23T00:40:08.117+02:00

Finally, I have finished and tested the windows disk device component handling for folders. I still need to handle files but I doubt that will take long. What this means is that I can now browse the file system and mount directories like this: 1: FSDevice * Storage; 2: FSFolder * Users; 3: FSFolder * Home; 4: /* Get a handle to the disk storage device */

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-71967411593933241062007-12-19T23:00:00.001+02:002007-12-19T23:00:53.437+02:00

I have finished the abstract FSDevice, FSFolder and FSFile components and will start on the windows dependent implementation so that I can access the windows file system via my abstract components. When I port to PalmOS, it will be really easy since I just write a PalmOS implementation without having to change the rest of the code.

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-81629676831299776482007-12-17T23:18:00.001+02:002007-12-17T23:18:10.785+02:00

Still going strong... After talking with some of my chat friends, I am starting to work on the File Storage components. FSDevice, FSFolder and FSFile are the abstract components that I am writing which are placeholder components for the platform dependent file API's. What's nice is that I will be able to give the same interface to PalmOS RAM (where pdb/prc are folders and the records are files)

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-42017476585427006852007-12-15T21:44:00.001+02:002007-12-15T21:44:23.918+02:00

Things are going really well. I have form moving and button tapping and I am thinking what widget should be next. I am going for simplicity at first, and in later builds once I have a comfortable model add some 'graphics' to the mix. So when you get the alpha build, please judge it by its functionality and not by its graphics. I can always 'paste' bitmaps on widgets, so let's go for the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-86228510777732845772007-12-14T12:11:00.001+02:002007-12-14T12:11:04.124+02:00

Things are moving very quickly and smoothly lately. I already have forms moving correctly, faster than previous alpha versions. I will now work on some controls such as buttons, check boxes, radio buttons and so on.  Note that I still don't have a text engine so still I cannot see any text on-screen. Note that the first platform Screens works on is windows since its easier to debug and write in

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-53696510005721100702007-12-11T20:43:00.001+02:002007-12-11T20:43:04.995+02:00

The pen component has been mostly written. It was an easy task thanks to the object storage. I still have yet to face the 'road block' of the object storage that I have faced very often with every other object storage I have written. I need to now work on the passing of pen events to the elements so that a window/control can respond to a pen event. Once I have coded this I can start

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-52143481413532895272007-12-11T00:00:00.001+02:002007-12-11T00:00:38.556+02:00

Trying to keep you all updated, Still finalizing the form component which I can finally see its title, although no text (I still have to figure out which text model I am going for). I will be working on the pen component next so that I can get the form windows moving around. Note that skinning will not be an option for users in the first version. I think its more important I get something that

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-78662362365421504462007-12-09T23:04:00.001+02:002007-12-09T23:04:47.676+02:00

Finally things are going well... Thanks to some lovely users in my Windows Messenger Live Group, I have been given a direction to follow to get Screens out as quickly but cleanly as possible. I know that PalmOS is going through a rough time and I don't want Screens to miss the boat flood. I am very happy with the new design and I am already coding the form component to display windows. I

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-51083001337066361152007-11-19T21:18:00.000+02:002007-11-19T21:21:38.747+02:00

I am sorry, things are not going well... I am swamped at work and I still cannot get the drawing model of the ground. I need help because I have alot of questions and no answers. While research will give me the answers, it requires alot of time to find them out myself. I am still here... just stuck...

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com3tag:blogger.com,1999:blog-7789316.post-91956400969002622802007-11-04T10:01:00.000+02:002007-11-04T11:06:14.632+02:00

Hi Everyone, As I said in the previous post, I did not get much work done on Screens because of pressure at work, however I did find some moments here and there and the code is moving nicely forward. The feature of pointer shortcuts that I talked about in the previous post is working nicely and makes the code much cleaner and more direct. I plan to finish the basic graphical model as quickly as

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com2tag:blogger.com,1999:blog-7789316.post-56247621454576854372007-10-18T00:41:00.000+02:002007-10-18T00:51:04.114+02:00

Hi, I just wanted to update you all that this week and next week are going to have very little programming time because my full time job at NDS needs some time reinforcemant. But things are going great for Screens. As you know Screens evolves all the time and I get to rewrite it on a monthly basis to get it just that much easier. Well, it looks like its going to happen again after seeing the

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-65069544584950107882007-10-09T23:23:00.000+02:002007-10-09T23:27:24.262+02:00

Last week I spent alot of time coding because I was on vacation from work. This week however I am back at work which explains why the lack of coding. I have however tried to squeeze some time out of my day for some programming on Screens. I have finished the fill part of the rectangle class, so I can fill the screen with rectangle fills. Things are moving...

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com3tag:blogger.com,1999:blog-7789316.post-26116577799283563762007-10-05T16:06:00.000+02:002007-10-05T16:13:58.750+02:00

Things are progressing very nice. I have already finished the Shape component which deals with caching drawing to the display. It allows the windows and controls to be detailed objects while not reducing the performance of drawing to the display. This model allows to have transparency with a single off-screen buffer without requiring a seperate off-screen buffer for each window. This makes

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-23659386938786569342007-10-04T20:32:00.000+02:002007-10-04T20:49:40.266+02:00

Practice is realy the way to make something perfect. I have rewitten the object storage so many times improving over the previous when I hit a wall since it was easier to rewrite the entire code, then patch the previous design. I did not expect to write over 20 times the same object storage but I guess thats what I needed... Pratice. And yes, I have done it again... I have rewritten the code

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com0tag:blogger.com,1999:blog-7789316.post-71608683224758698042007-09-28T16:29:00.000+02:002007-09-28T16:34:29.643+02:00

I know of the disappointment... so... I spent all last night and this morning coding like crazy and finally I can actually display movable layers and draw fills and frames on them. The window class is nearly complete. I need to finish the drawing of the title and the window borders. Note that the font engine is not implemented, so I wont be seeing any text displayed any time soon but I will get

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-17879203446611185182007-09-27T19:39:00.000+02:002007-09-27T19:54:05.623+02:00

Hi, Sorry for the lack of updates... I am still working on Screens but I just did not have anything to say. I dont think that 'still working' posts are needed. Screens Environment development is realy moving forward but painfully slow. I feel that the time I have something to release, no one will be interested in it. While the object storage is fine so far, I am now working on the graphical

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com1tag:blogger.com,1999:blog-7789316.post-59567528045789975972007-08-23T10:46:00.000+03:002007-08-23T10:55:23.364+03:00

I bought my first computer a few weeks ago running Vista Premium on a HP Pavilion a6130 with a 2GB ram upgrade. Its a very beautiful computer which I am very happy with. It explains the lack of Screens online activity. I cannot even sync my lifedrive let alone I have not even installed Eclipse yet. This does not mean that Screens is dead. I am still spending time on it. Sometimes I just dont

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com6tag:blogger.com,1999:blog-7789316.post-39529899820340499622007-07-13T13:05:00.001+03:002007-07-13T13:28:57.293+03:00

Yes, the broken wheel is still rolling down the hill... Sorry for the lack of updates in the last month, I have been very active on Screens (proof is in my SVN updates) but the problem is that I still have to figure out some problems to be satisfied with Screens. One of the biggest issues I am dealing with at the moment is concrete objects which I believe is a very important feature for Screens

Zakai Hamiltonhttp://www.blogger.com/profile/16584147498688640434noreply@blogger.com5