On 23rd of April 2015, Mihai Șucan passed away due to metastatic cancer caused by
My name is Mihai and I work on the
Firefox developer tools. When it comes to web development, I like
both server-side and client-side work. I am mainly interested in web browsers, web standards and related
11 October 2009, 11:26
I want to update all of you on the latest happenings around the PaintWeb project.
Now that the summer has ended, I am starting to become busier with studies, but ... I still got the chance to work on
some PaintWeb-related stuff. I moved out most of the things I had noted down in the TODO wiki page. These items are now showing in the issues tracker of the project, each being properly categorized, tagged and with more details.
I have also made some clean-up for the project front page, updated existing documentation and I have included some new
documentation about web browser bugs affecting PaintWeb, and about Moodle integration.
Martin Langhoff has reviewed the code and published a proposal for merging PaintWeb into the Moodle CVS HEAD (for the Moodle 2 release). In response to further feedback I have made it easier to
configure the PaintWeb packaging process, and I published more documentation about this.
Last, but not least, I am beginning to make PaintWeb snapshot builds available for download.
That's about all. Have fun!
7 September 2009, 16:04
Two days ago I have uploaded a snapshot of the PaintWeb code and the integration
scripts for Moodle
2.0 and Moodle 1.9, as required for the Google Summer of Code program. This snapshot contains only the code I contributed
up until 14th of August 2009, and you can download it from the
Google Summer of Code 2009 Moodle project site. Obviously, this code is provided only for recording the milestone I reached for the GSOC project deadline. Any
paint tool user is supposed to get the latest code from my Git repository
or from the PaintWeb project site.
Thanks to Anthony Borrow and Jordan Tomkinson, today a Moodle 2.0 with PaintWeb test site has been published. So, now you can try PaintWeb directly in Moodle. Make sure you login with the teacher account: user.
Password is: demo.
To try the paint tool, I have created a test course, and I added a glossary activity. Inside the glossary activity
there's a concept I added. Go ahead and play with the glossary: add, edit or delete concepts. In the TinyMCE editor you can create new images and edit them seamlessly.
It should be noted that Moodle 2.0 and the paint tool integration are both under development. This means that Moodle
devs have not yet completed upgrading all the code which deals with the HTML editors - so, other pages where TinyMCE
is used might not have PaintWeb enabled because the configuration is still in "legacy mode" (no file attachments are
Anyone is welcome to provide me with feedback on the user experience, and any other thoughts.
gsoc2009, moodle, paintweb.
31 August 2009, 16:28
Beside bug fixing and polishing PaintWeb in the past weeks, I have also prepared a presentation about all the work I
did this summer, as part of my Google Summer of Code project. As such, I talked about my GSOC project at the Linux and Virtual Learning Environments 2009 seminary on Friday, the 28th of August.
You can download the presentation slides in Romanian and in
English (PDF). You may also watch the slides online at Scribd.com,
Romanian and in
English. Any feedback is welcome!
arad, gsoc2009, lvle, moodle, paintweb, romania, talks.
21 August 2009, 09:34
Since my previous blog post I did some polishing to the Moodle 2.0 integration. Dan
Poltawski from the Moodle community has provided his valuable feedback. He suggested I switch the parsing of the data URL
to a regular expression and that I warn users before submitting a form while editing an image with unsaved changes. I made
both of these changes and now I am looking forward for more feedback.
This blog post is more about the overall Google Summer of Code
conclusions. So, here we go. I started from a simple PaintWeb demo application,
I did the following:
- Split the whole code into multiple files: per drawing tool, per extension, per language.
Created a new configuration file which allows changing almost any option inside PaintWeb, including keyboard
shortcuts, tools, extensions and more.
- Reorganized the entire code, followed more strict coding guidelines, more naming consistency, etc.
Wrote jsdoc-formatted comments for every function and method. Based on the code now I can generate a complete and
PaintWeb API reference documentation.
Changed the way PaintWeb loads: the whole GUI is loaded using an
XMLHttpRequest from the server and added into the page. The PaintWeb demo was a stand-alone Web application,
but now PaintWeb is a component which can only be used within another Web application - in a similar fashion to how TinyMCE can be used.
Developed a new API for PaintWeb extensions, tools and "commands".
This allows new developers to
easily extend and modify PaintWeb at any time.
Implemented a new PaintWeb extension: MouseKeys. This allows users to draw with the keyboard - no mouse is needed.
Reimplemented keyboard shortcuts support such that it works much better across different Web browsers. You can learn
about this work from the latest tutorials I wrote for Dev.Opera about
keyboard accessibility in Web applications.
- Made important performance improvements for the OLPC XO.
or on the base code of PaintWeb.
Implemented a new GUI for PaintWeb, with better keyboard
accessibility, and with a new logo.
Implemented a new "application events" API which allows developers to hook into PaintWeb by means of events. For
example, developers can listen for events like "imageSave" or "imageSizeChange". Such application events are used
heavily in the new interface implementation.
- Implemented numerous selection tool improvements and fixes.
- Implemented a new "Hand" tool for dragging the image inside the viewport.
- Made some important fixes for the Eraser tool.
- Made PaintWeb behave better with huge images - around 6000 x 6000 pixels.
Made improvements to the Text tool and implemented better cross-browser compatibility. Also, attempted Opera compatibility with no luck.
Made PaintWeb ready for "production use" by properly packaging the whole Web application. The PaintWeb packaging process is driven by a Makefile.
Wrote "some" PaintWeb documentation.
Wrote a hefty TinyMCE 3 plugin for easy PaintWeb
integration into TinyMCE 3.
Updated some patches for TinyMCE 3 integration into Moodle 1.9.
Implemented Moodle 1.9 and Moodle 2.0 integration - with different levels
of success. That is, Moodle 2.0 integration is succesful and working properly, while the Moodle 1.9 integration still
requires additional work due to the lack of a file API.
That's about all I did over this summer. I am very pleased with the results. In some cases, the results are beyond my
initial expectations. For example, I did not expect to have so much PaintWeb documentation done over the summer.
Writing the code for all of the above was fun and a pleasure for me.
The Moodle community has been really great and friendly. I appreciate all the feedback I got from the whole community.
What's next? Well, I hope this GSOC marks the beginning of a fruitful collaboration
with Moodle and with the overall open-source community. I would like to continue work on Moodle 1.9 and 2.0 integration,
and further improve PaintWeb. I certainly do not want to abandon the project. :)
I must thank Helen Foster and
Martin Langhoff for their constant support over the summer,
with feedback and testing. For example, Martin has provided important help with the performance work for the OLPC XO, together with Robert O'Callahan from
Mozilla. And Helen was always ready to answer any GSOC-related questions. ;)
Last, but not least, thanks to Olli Savolainen and Jose Cedeno - two of the Moodle GSOC students who were very helpful, by testing PaintWeb and by providing valuable feedback.
gsoc2009, moodle, paintweb.
14 August 2009, 10:36
Together with my mentor, Martin Langhoff, we have decided that it's better for me to focus on the Moodle 2.0 integration of PaintWeb. This is because Moodle 1.9 lacks a file
API sufficiently advanced to meet the needs of PaintWeb usage. Martin opened a relevant thread in the Moodle forums
about storing images as attachements to text fields - it's
worth reading to understand why PaintWeb integration is far from trivial. Moodle 2.0 has the solution to our problem: the
new File API.
Focusing on Moodle 2.0 integration does not mean we do not want to complete the work started for Moodle 1.9. However,
we want to have PaintWeb ready for core integration, for the Moodle 2 final release. The plan is for me to resume work
on Moodle 1.9, some time later.
The Moodle developers are hard at work for the new Moodle 2.0. They've done numerous improvements. If you like Moodle
1.9, you will love Moodle 2.0. Integrating PaintWeb into the new version was much nicer and quicker.
I completed the integration of PaintWeb into TinyMCE, and I also made the image save action to work quite well. Images
are saved in the draft file area, as is the rule for any textarea-attached file.
If you want to get the Moodle 2.0 code with PaintWeb, get it from my Git branch. Instructions:
git clone git://repo.or.cz/moodle/mihaisucan.git ~/src/moodle
git checkout -b mdl20-paintweb origin/mdl20-paintweb
You might be interested to read the
technical details about the Moodle 2.0 integration work, published at Moodle Docs.
Since my last blog post, I also made important updates for the entire PaintWeb documentation.
Olli Savolainen has provided me with more suggestions which I implemented. Thus, I changed
the color to yellow, for the "plugin bar" of the TinyMCE plugin. I also made the "Save" and "Cancel" buttons look better.
Last, but not least, based on his suggestion I found a fix for the "Edit" overlay button, for Firefox. For some reason,
the button was not easily clickable in Gecko-based browsers. The problem is now gone. Thank you very much, Olli!
For better usability, I made the whole PaintWeb GUI resizable. Now, users are no longer stuck with the fixed
dimensions. The TinyMCE plugin has been updated to synchronise the size of the editor area with the size of the
PaintWeb image viewport, for a better user experience.
You can go ahead and try the updated PaintWeb+TinyMCE demo.
With the latest work, I am meeting the Google Summer of Code project goals: the development and integration of a paint
tool inside Moodle via TinyMCE. There's only some polishing work left to do, and code reviewing from more Moodle
gsoc2009, moodle, paintweb, tinymce.
4 August 2009, 11:15
I would like to update you all on the latest happenings in the
Moodle and PaintWeb land.
I have fixed some bugs in my TinyMCE plugin which prevented it from working properly in Firefox 3.0. I also made a
number of improvements to the plugin and PaintWeb itself: images can now be saved as JPEG, not only as PNG. In Opera
10 and Firefox 3.5 developers can now save Canvas images as JPEG - which is great. Thus, when you edit a JPEG image,
PaintWeb uses the JPEG format to update the file. Another improvement for the plugin is now you can click the PaintWeb
icon in the TinyMCE toolbar even when an image is not selected. When you do this, a dialog comes up which allows you
to create a new empty image - you can setup image dimensions, background color and other options.
PaintWeb now offers better visual feedback when the image you are editing is transparent. Background color support is
now improved, albeit it's missing a GUI option to change it at will - this is going to be implemented some time after
the end of GSOC. Also, as explained above, PaintWeb can now save images as JPEG, thus I should provide a GUI feature
for users to pick the file format they want.
Moodle 1.9 integration has progressed up to the level that now PaintWeb is entirely usable and I am quite happy with
the result. Image save is currently implemented in two ways: images are saved as data URLs or as files inside the
Moodle data directory. Both saving method have advantages and disadvantages. Me and Martin, we are currently
discussing ways of improving image saving as files. You can read all the gory
details about the Moodle 1.9 integration of PaintWeb in a Moodle Docs wiki page I wrote.
In related news, I have created a Twitter account for "ROBO Design" (for me
and my twin brother). You can follow our updates on Twitter as they happen. Additionally, I published the
Planet ROBO Design site, where you can follow all the updates
on what we do (and I mean all updates). This small "planet" aggregates all the feeds related to us - it's a single place
where you can follow anything we do.
Don't forget you can always try the PaintWeb demos
online. Any feedback is always welcome!
gsoc2009, moodle, paintweb, twitter.
24 July 2009, 12:21
I am getting closer to having a Moodle demo ready with PaintWeb integrated. Wednesday I had a very fruitful discussion with my mentor, Martin, on how I should proceed with the implementation
of file saving inside the Moodle data directory. We have come to a conclusion which I am about to implement. More details
For now, I have registered a Moodle Git repository mirror
over at repo.or.cz. I have also registered a Moodle "fork" where I publish my Moodle branches. You can do:
git clone git://repo.or.cz/moodle/mihaisucan.git ~/src/moodle-mihai
git checkout -b mdl19-paintweb origin/mdl19-paintweb
With that, you can easily and quickly get an always up-to-date Moodle 1.9 stable branch with TinyMCE 3 and PaintWeb integrated. You can already play with PaintWeb in Moodle.
If you only want the TinyMCE 3 editor you can do:
git checkout -b mdl19-tinymce3 origin/mdl19-tinymce3
The TinyMCE 3 branch holds Moodle 1.9 stable with the latest TinyMCE 3 integrated. The work I did on this branch is
best explained in a Moodle forum discussion.
When you want to update your branch simply invoke
git pull. Please also check the official documentation
how to use Git.
In related news, Opera Software has published the final part of the article serie I wrote about
keyboard accessibility in Web applications. This article details the cross-browser compatibility layer implementation for keyboard events used by PaintWeb.
git, gsoc2009, moodle, opera, paintweb, tinymce, tutorials.
17 July 2009, 11:05
The Google Summer of Code midterm evaluations passed without any problems for me, yay!
I have began work on integrating PaintWeb into Moodle. I will integrate my project into the stable Moodle 1.9 branch and into the upcoming Moodle 2.0 release.
Moodle 1.9 has a very old TinyMCE release (version 2.0) which is not used by
default - the even older HTMLArea is still used. Both do not work in Opera and Google Chrome. For this reason Martin Langhoff,
my mentor, and other Moodle community members have worked on patches to switch to the modern TinyMCE 3 editor. A
clean port of TinyMCE 3 to Moodle 1.9 is available on the
The clean port is quite well done, but again, it was "outdated", being from october 2008.
For PaintWeb I took the work Martin did and updated it to the latest Moodle 1.9 stable branch, the latest TinyMCE 3
version, and made additional fixes. One fix was to make the editor show up in Opera, Safari and Chrome, and another
fix was for the script which converts TinyMCE language files to Moodle language files.
PaintWeb integration into Moodle 1.9 will come as a patch on top of the TinyMCE 3 patch. Currently I got PaintWeb
loading fine in TinyMCE, inside Moodle. More work is needed to get file save working. For PaintWeb I did some assorted
fixes for the Makefile, for the overall keyboard accessibility, for multi-language support, and I did improvements to
the TinyMCE plugin.
You can download the updated TinyMCE 3 patch for Moodle 1.9.
The package includes usage instructions.
In other related news, Opera Software has published the second part of the article I wrote about
keyboard accessiblity in Web applications. This article describes the inner workings of the MouseKeys extension for PaintWeb. Make sure you checkout the
updated and improved
source code of the MouseKeys extension in the PaintWeb code tree.
Have fun until the next time!
gsoc2009, moodle, opera, paintweb, tinymce, tutorials.
8 July 2009, 14:03
In the past week there was important progress on PaintWeb. I have
published several wiki pages about PaintWeb on Google Code - this documentation comes as an overview or a guide to the entire codebase and the API reference. You can read about how to integrate PaintWeb into your Web application, how to extend PaintWeb, how to package PaintWeb yourself with the Makefile, and how to use the new TinyMCE plugin.
I have completed a new
TinyMCE plugin which allows you to easily and quickly integrate PaintWeb. This plugin allows users to click an "Edit" button which is
overlayed on top of the editable images. The plugin also includes a context menu item (right-click and choose "Edit image"),
and a toolbar button.
I have published a new demo page which shows the latest TinyMCE and PaintWeb working together. Enjoy!
Moodle integration is currently being planned. I wrote my thoughts and questions in a Moodle Docs wiki page about the paint tool integration.
Last, but not least, for the purpose of tracking progress, I have attached a packaged PaintWeb snapshot to the Moodle tracker issue associated with my project.
Olli Savolainen has created some very good mockups as proposals to improve the PaintWeb user interface. His feedback is very much appreciated, and I really hope to get to implement his suggestions as soon as possible.
On a related note, for those interested on
how PaintWeb implements keyboard shortcuts, Opera Software has just published the first part of a series of articles I wrote on this topic. More articles will
be published soon at the Opera Developer community site.
Have fun testing PaintWeb and reading articles about it. Don't forget that I am always looking forward for feedback!
api, documentation, gsoc2009, moodle, opera, paintweb, tinymce, tutorials.
2 July 2009, 19:52
Since my last blog post I have completed the user interface polishing for PaintWeb: the Color Mixer and the Color Picker are both working fine now.
Today I have completed work on packaging. I also generated the complete API reference documentation from the source code.
You can go and play with the PaintWeb demo at the
For packaging I use a Makefile, YUICompressor,
jsdoc-toolkit, PHP and some bash scripts. First of all, I merge all the
small PHP script which encodes the string using
json_encode(). Once I have the hefty script, I use the
YUICompressor tool to make it a lot smaller.
For the PaintWeb interface stylesheet I use the YUICompressor in combination with a simple PHP script I wrote. The PHP
script inlines the PNG images using data URIs. This helps a
lot in reducing the number of elements being downloaded.
Here are the numbers, for those curious of the packaging results. Before packaging:
files, 33.9 KB;
- One XHTML file, 14.9 KB;
- One CSS file, 21.8 KB;
- 47 images (PNGs), 206.5 KB;
- A total of 70 files, 703.7 KB.
That's quite much. Here's what the current level of packaging gives us:
is not always loaded;
Three JSON files, 33.9 KB. The JSON files are left untouched, the configuration example stays the same - with all
the comments in it. It's up to the integrator to choose what he/she does with the file (at the moment).
- One CSS file, 297.1 KB - with all the images inlined;
- A total of only 6 files, worth of 461.7 KB.
That's better, but there's room for more. You should always enable gzip compression on your Apache server. Here's what a properly configured server can give you:
- Three JSON files, 8 KB;
- One CSS file, 99 KB;
- A total of six files, and only 142 KB.
That's much better now. To properly configure your server, make sure you enable gzip compression in your .htaccess file:
console in your Web browser. On my local system it takes less than a second, depending on the browser I use. Go ahead
and try PaintWeb yourself. Also make sure you check
out the API reference.
In the coming days I will be publishing guides on PaintWeb development, extensibility and general code overview. This
Moodle integration is ready to begin!
apache, api, documentation, gsoc2009, makefile, moodle, paintweb, performance, yui.
28 May 2009, 11:55
This week I have completed my work on performance testing and improvements for PaintWeb on the OLPC XO laptop.
During testing it became obvious that something other than the actual Canvas painting was very slow on the XO. The
main performance culprit is that the default Gecko-based browser is configured to render pages using 134 DPI instead of the default 96
DPI. Generally web browsers render pages using 96 DPI. If the XO web browser would do the same the texts and the images
would be far too small - the
XO display is an odd 200 DPI screen perceived as 134 DPI.
PaintWeb's drawing performance was hugely affected by the bilinear scaling of the Canvas elements being done by the
browser on the XO. When I configured the browser to render the page using 96 DPI, the web application became a lot
Martin Langhoff, my mentor, got in contact with Robert O'Callahan from Mozilla. He provided us with lots of help in finding a solution for the performance issue.
We did think about having a CSS property to change the DPI only for the Canvas
elements, or a different CSS property to disable scaling, or some proprietary API for changing the DPI on a single page.
None of these are good ideas, because they allow web developers to start coding for specific DPIs - this is not desired.
Gecko scales pages using integer scaling factors - that's 1, 2, 3, etc - it doesn't use floating point numbers. In a
normal Gecko build the scaling factor for 134 DPI is 1 - because 134 / 96 = 1, so you do not get any scaling. You can
have a scaling factor of 2 or higher if you go above 192 DPI.
Gecko is patched on the XO in a way that it forces
the browser to scale pages using floating-point scaling factors as well. Therefore, for 134 DPI the pages are scaled and
they look really good on the XO screen.
The final solution which I implemented into PaintWeb is to simply scale down the Canvas elements in my document. If I
accurately scale down the elements, Gecko is sufficiently optimized to cancel any scaling and you do not notice any
performance impact. This works really great.
In Gecko 1.9.1 (Firefox 3.5) I can detect the DPI used
for rendering the page with CSS 3 Media Queries. I use this in
PaintWeb. However, the XO only has Gecko 1.9.0 for now, so I cannot determine the DPI. I am forced to do user agent
sniffing to check if the browser runs on the OLPC XO. If it does, then I scale down the Canvas elements using a
different way of calculating the scale-down factor - because Gecko is patched - and I always consider the page is
render using 134 DPI. Fun, huh? ;)
On Opera, on the XO, I did all my testing using 100% zoom level. It ran much better
than Gecko, for obvious reasons (no scaling, yay). Once I fixed the Gecko scaling issue, Opera came second. For some
reason Canvas draws much faster in Gecko than in Opera on the OLPC XO.
Opera cannot render pages using different DPI values other than 96. People use zoom, so, for consistency, I use an old
measure the zoom level (thanks Arve). Based on
this I scale down the Canvas elements. For some zoom levels, like 200%, the scaling is cancelled and PaintWeb works better.
Unfortunately, Opera does not allow non-integer pixel values, thus the scaling-down is generally not effective...
Another important performance improvement in PaintWeb is the use of timer-based canvas drawing. This means that mouse
move events are either cancelled or coalesced into one. For example, redrawing a polygon with a lot of points for
every mouse move is very slow. The tools in PaintWeb use timers to update the canvas every few milliseconds. This
approach makes PaintWeb feel faster.
Lastly, I now avoid going into the global scope, for things like
intensive - not too much code is executed for each mouse move event. Such changes become more important the more code you
run. This will be important for the color space visualization I have.
The loading performance will improve greatly once I will make a packager for PaintWeb. Additionally, I will continue
to constantly check the overall performance of the web application on the OLPC XO.
Go ahead and try PaintWeb from SVN trunk. Lots of thanks to Robert
for his great help and to Martin for his assistance and for finding the Gecko patches.
Currently I am working on the new user interface, stay tuned!
Update May 31, 2009: Just published a page on the OLPC wiki about the HTML Canvas performance on the OLPC XO laptops. The page includes code snippets explaining how to work-around the scaling issue.
canvas, css, dpi, gecko, gsoc2009, moodle, olpc, opera, paintweb, performance.
14 May 2009, 11:09
I have been working on the PaintWeb code refactoring and now I am nearing
completion. The initial PaintWeb 0.5 alpha code was more of a demo - it was all in a single big script. I have now added
jsdoc comments almost everywhere and I did split the code into multiple files - per tools, per extensions, per language,
and more. I have also made important changes to the API. Now
any external code can easily add/remove tools, extensions and keyboard shortcuts.
For more developer-related information please read the latest forum thread I posted on the Moodle forums.
For teachers and potential users of PaintWeb inside Moodle, I have prepared a list of questions on how you would use the paint tool in Moodle.
Martin, my mentor, suggested early in my GSOC application process to also apply
for the OLPC Contributors program. So I did, and my project was accepted.
Even if the OLPC XO has a slow CPU by today's expectations, it's only 400 Mhz, the system works quite nicely. It has
256 MB of RAM and 1GB of disk capacity. The Sugar interface and the activities provided are amazing. People who hear
about these laptops do not know to appreciate the numerous doors such laptops open, doors to knowledge, for all those
children who receive them. They help a lot in learning about computing, maths, music, and more.
The Sugar interface is quite well thought-out. I like the concept of having the neighbourhood, group, home and
The default browser, is some Python application embedding Gecko - on par with Firefox 3.0. The performance of the
browser is lacking.
Opera 10 alphas start much faster and feel snappier. The paint tool
feels sluggish as well.
The Gnash plugin
is more of a problem rather than a solution. I installed Flash Player 10, which is sluggish, but at least it works. The
system can play Youtube high-quality videos and even uncompressed DVD videos, with Mplayer over the wireless connection. Flash Player cannot play Youtube videos.
Battery life is good - I can use it about three hours without any problems.
Since last week I have been working on the performance of the PaintWeb application, with the OLPC XO-1 laptop. After
several tests, I have managed to improve things sufficiently such that the paint tool is now usable in Opera 10 on the
XO. Unfortunately, in Browse.xo it's not, at least not by default.
The main performance culprit affecting PaintWeb on the XO is their use of layout.css.dpi. Gecko allows
users to change the
DPI used for rendering Web pages, in order to makes fonts and images smaller or bigger.
So, on the XO the browser is set to use DPI 134, instead of DPI 96. This makes the fonts and images render bigger - with
DPI 96 they would all be way too small. PaintWeb and all the pages feel much slower because Gecko performs bilinear image
When I set layout.css.dpi to 96, drawing in PaintWeb becomes real-time. I was amazed to see it works so well.
It's like on my desktop computer. And ... it's even faster than in Opera 10. ;)
If you want, check out the
performance tests yourself. Spoiler: Webkit is the fastest and Gecko is the slowest when running synthetic tests. Obviously, more performance
tests will come - these are only limited to the pencil tool and to the main
ev_canvas() event handler from
Next on my of list things to do is a new GUI and a packager for the entire
code. Loading PaintWeb is now slower due to the amount of code comments and the increasing number of files. The packager
will compress/minify all the files into a single one.
That's all for now. Any feedback is welcome!
canvas, css, dpi, gecko, gsoc2009, moodle, olpc, opera, paintweb, performance, webkit.
23 April 2009, 14:58
I have great news this time! I have applied to work for the
Moodle project over the summer within the Google Summer of Code program. My project proposal has been accepted. This means that
over the summer I will be working on integrating the PaintWeb project into
Moodle. Part of this work will also include a complete code reorganization and several important improvements.
Locally I have already started working towards code reorganization and a complete rework of the keyboard shortcuts
support inside PaintWeb is ready. This work will become public very soon.
I am really glad to be working with one of the best open-source educational software. The Moodle community has been
very nice and they welcomed me warmly. Congratulations to every student who has been accepted this year!
On a related note, Opera Software has published a tutorial I wrote about how you can start developing your own paint tool. The code presented is strongly based on my work for PaintWeb. Another new tutorial is now being prepared for
Best luck to everybody and stay tuned for more!
gsoc2009, moodle, opera, paintweb, tutorials.