We’ve been having a bit of a Anaconda custom partitioning UI thrown down the past couple of days in #anaconda to try to make some more progress on it.

You may recall, the direction we’d most recently taken the mockups involved a UI centered around the mount points that are / will be created on the system:

We hashed out some issues to address with this approach. Some we have addressed over the course of our discussion, some we haven’t. Here’s how it broke down:

Issue #1: If you have more than one mount point of the same type on the system, you have an odd name clash.

See, we let you select whatever hard drives / storage devices you want as part of the installation. Now, the drives you select may not be blank / nicely-formatted. Rather, they may have pre-existing OS installations on them, and some of those you might want to keep around – maybe you just want to install in the available empty space on the drive(s). The UI above assumes you’re only displaying mount points for one OS.

• What if I have a Fedora 16 installation on a 1 TB disk that I want to keep around, and I just want to give Fedora 17 a try in my 500GB of free space on the same physical drive? Well, if I have my Fedora 16 partitioned with /, /home, /var, swap, etc., those mount points will show up in the left bar in the mockup right alongside the new /, /home, /var, etc. that I’m creating for my new install. Oops.
• What if I want to blow away that Fedora 16 install and install Fedora 17 fresh in the same space? When those F16 mount points show up, how do I know if they are the F16 ones that I should delete/format, or if autopart already handled that and they are my new Fedora 17 ones?

So we thought through a few ways to accounts for this:

A dropdown between OSes

(Ignore the emblems, we were playing with them for another idea.)

It’s uncluttered since you only see one OS at a time. You know which OS you’re looking at so you know what the mount points are for. It’s not super-discoverable, though; it’s also a tad clunky visually – I’m not sure it’s very common to have a dropdown embedded in the left sidebar of a screen layout like this. Generally I don’t like dropdowns as a main navigation elements like this because I think they are physically harder to target than alternatives (a made more crystal clear to me than ever with spending the past week wearing a brace on the wrist of my primary hand. Sigh.)

So, meh.

A Nested Tree

You know, I’m sure there is a time and place for nested trees, but I try to avoid them like the plague. Depending on the implementation of course, sadly they often depend on targeting an area that is on average 12×12 pixels in size – not cool. Implemented properly, clicking either the [+] or [-] icon will toggle opening up a section of the tree, but this isn’t always possible. For example, in Nautilus’ list view, you can only click the [+] or [-] icon – clicking on the name of the folder opens up that folder fully in an icon view. Ick.

We didn’t bother mocking this one up. Don’t mean to hate on you nested tree luvas out there. If I’m nuts for this attitude, school me (*politely*) in the comments.

Ditching the system vs data labels and using those labels to demarcate OS

This one is pretty clean, but it will likely require a scrollbar. Also! It means the system vs. data slider up at the top will make a lot less sense and probably will need to be ditched as well. :-/

Cell-phone style nav of the mount point list

Yeah. I put this mockup in a subdirectory called ‘crackrock.’ I have actually never seen this done before (have you?) It seems like an interesting way to separate out the different OS mount point listings without using a tree view, but it’s kind of an odd pattern and would probably confuse people.

Accordion-style nav of the mount point list

This is the one that Chris is working on today. (Thanks ebassi for helping figure out how!) The Accordion menu is a common UI design pattern, and while for some installs it will require a scrollbar, I think it maybe solves the problems in the best manner here.

What do you think?

Issue #2: When do we do autopart?

David Lehman and I also talked about in which scenarios do we auto-partition a device for the user vs. let them decide what to do. If you have a disk with a contiguous chunk of space that meets the minimum space required for autopart, we *can* do autopart – it doesn’t require a completely formatted disk/device. We decided that we should allow you to autopart a disk and then customize it; you might want to use the autopart scheme as a guide to start from in your customizations.

One idea on the table is that instead of doing autopart on the free space that’s available by default, we’ll leave it blank and have an ‘empty list message’ that says something like, ‘you have no partitions; create some below or click here to have us create them for you.’

Here is a mockup showing this:

Issue #3: How can we make it less confusing to understand which partitions are getting wiped and which are safe / going to be left alone?

(Not sure on this one.)

I think we should think about what should the default behavior be – wipe it all and opt-in to preserving select partitions, leave everything alone and opt-in to wiping select partitions, or install side-by-side and leave what’s there alone.

One thing to consider is to have a flag users could set when they choose to disk to indicate that if it’s okay to wipe the whole thing, and by default preserve the data. Maybe? Or maybe use the settings (‘gear’ icon) in the custom partitioning screen’s left nav bar’s bottom to let them do this, although at this point we are speaking in terms of mount points/partitions and not devices so I believe this is too late.

Issue #4: Will we support mounting the same mountpoint from different OSes?

I think we decided not to support that since mounting the same home from different OSes is not an advisable thing to do. For example, if you have different versions of the same app sharing the same .config directory, odd things can go down. Mounting simpler stuff than /home, like a /srv across OSes/ is simple to do post-install so there isn’t a lot of advantage of doing it in the install. (And you could always script it if you wanted to in a kickstart post. Remember, at least the plan is to support inheriting settings from detected KS files when you use the Anaconda UI.)

Issue #5: Can people remove devices in the custom partitioning screen?

What if their disk is full and all they want is to reformat a root device and assign some mountpoints — no device removal/creation?

The two cases where someone ends up in custom part are:

• (A) They opted in *before* the disk space reclaiming UI – they already had plenty of space so the space reclaim UI wasn’t offered up to them.
• (B) They did disk reclaiming and still came up short.

Issue #5 here is clearly case B. To reformat a root device and assign mountpoints, they could one-by-one hit the ‘-’ icon in the bottom of the left sidebar in the custom partitioning screen to remove partitions from the device and re-add them. How do we know to format it? Should we always format if all partitions are removed from a device in our custom partitioner?

Issue #6: Is the intention that the interface will be pre-populated with all the filesystems on the devices selected for installation?

Yeh, I think it’s a good idea. If you had a disk/device you wanted to preserve the filesystem of in its entirety, you wouldn’t have selected it on the device selection screen. This means that if a device you selected has a filesystem present on it and you’ve made it as far as the custom partitioning screen, you either want to blow it away or keep it around. If you want to keep it around, you’re likely to be a bit anxious (especially with a re-vamped installer ) about whether or not the data is going to make it, especially if you are lazy like me and don’t do backups in this situation AS WE OF COURSE RECOMMEND THAT YOU ACTUALLY DO! (Do as I say, not as I do!!) To see that the data is there on screen I think maybe helps with this anxiety. Although to be honest, maybe thinking about storage this much has made me focus too much on anxiety-aversion.

But yeah, nobody wants their data to get blown away so I do believe being able to see it there safe and sound (maybe with some further reassuring indicator it won’t be touched – one idea is to grey out the options on it unless you explicitly say yeh I want to blow it away, see mockup below) is a good idea.

Thoughts?

So…

That’s where we’re at right now with the custom partitioning UI. Do note that the custom partitioning UI is opt-in only, except in the case where you don’t have enough space for install and the space reclaim UI wasn’t able to squeeze your filesystems small enough to make room. (And honestly in that case, it is too, although the default option in that scenario is ‘Sorry Charlie, time to quit the installer.’)

As you can see, we have a number of open issues or directions we’re starting to explore, so if you have thoughts, (polite) admonitions, or brilliant ideas, let us know in the comments! We also have these discussions very informally in #anaconda on irc.freenode.net, and your (polite) participation is certainly welcomed there.

OMG you’re redesigning the anaconda installer?

Yes!

• Why oh why are we doing this? Learn here.
• You can read lots more of my scribblings about the project in this blog’s ‘anaconda’ category.
• We also have a Fedora wiki page for the project.
• Drop by #anaconda on irc.freenode.net if you’d like to get involved or simply voice your opinions.

(Polite Panda for Fedora 19?)

In 2009, I wrote a driver to make the infra-red remote on my original MacBookAir work out-of-the-box on Linux. The driver was rejected upstream on the basis that the device would soon be supported through more generic means. In the meanwhile, it lived in Fedora's kernel tree, and I took some notes about implementing pairing, so that only your remote would work with your computer.

I'm posting this now because I wanted to poke at a MacOS X application today, and couldn't for the life of me remember the name of the program to monitor disk-activity. Hope this finds its way to a search engine near you.

• Launched the System Preferences, Security, and unlock the panel.
• In a terminal: sudo fs_usage -f filesys -w and check the output when enabling/disabling the remote.
• We can see the modified file is /Library/Preferences/com.apple.driver.AppleIRController.plist
• Installed PlistEditPro and opened the file up.
• Now try to pair a remote (menu and next together)
• You can see the UID value changing in the file. I named the remotes I had available to me:
• New remote: UID = 145 
• Old clean remote: UID = 24
• Old dirty remote: UID = 227 
• After adding some debug to the aforementioned appleir driver, in Linux, I got:
• New remote: appleir: received (5 bytes) 25 87 e0 91 02
• Old clean remote: appleir: received (5 bytes) 25 87 e0 18 03
• Old dirty remote: appleir: received (5 bytes) 25 87 e0 e3 02
• So the 4th byte is the remote's UID.

Now one could implement remote pairing using a sysfs attribute, a udev helper to apply the pairing across reboots, and PolicyKit helper to set and save the paired UID.

A hand rendering I did for a house by Adriana Furst. Below is also a little test with the cycles renderer. Doing exterior lighting with cycles is a bit tricky, but it can surely give amazing results, I need to try more...

You may have noticed some exciting things happening. Issue 1.4 has been quietly released. A new libregraphicsmag.com website (designed by the ever capable Ana Carvalho) has come along with it. It’s all pretty exciting.

If you’re a subscriber (or a non-subscriber who has ordered a copy of 1.4)  anywhere in the Americas, you may be wondering where your magazine has gotten to. Never fear! It’s soon to be on the way. While the European edition (printed in Porto, Portugal) has been out since late-April, we’ve had a couple technical and logistical glitches with the Canadian print. Today though, finally, after some waiting and wrangling, it’s going to print. So, if you are in the Americas, expect issue 1.4 to hit your doorstep or mailbox in the next two weeks.

Thanks for your support, and sorry for the delay.

The href=http://yorik.uncreated.net/guestblog.php?2012=28>factory project we've been doing with href=http://www.mariofrancisco.com.br>Mário Francisco Arquitetura is finally out. Here go a sample of the execution drawings...

Krita is a painting and sketching program by KDE. It is a part of the Calligra Suite, and offers an end–to–end solution for creating digital painting files from scratch by masters. 

Well my journey with Krita began when I first heard about it from my friends, who had done SoK last year. And, I was mesmerized by the sketches of david revoy. It was then that I wanted to contribute to Krita and help in its being a great digital painting tool, although it still is great!!

This year for GSoC, I had selected a project in Krita from the KDE ideas page, Perspective Drawing.  Following are a few details of the same:

Krita is a 2D painting tool, but artists often need to give the illusion of depth. Krita has two tools to help the user draw perspective correctly: the perspective grid and the perspective assistant. The latter is more advanced, but needs improvements to become a real star feature. It needs to be expanded by allowing real 3D objects to be important and put into perspective. This means rotation, setting the vanishing point, scaling, and then integration with the paint tools. At the same time, to get into the codebase, the student should implement other missing features in the perspective assistant.[1]

In this project the perspective assistant has to get all the functionality in the perspective grid. That is just a part of the project, the majority of the time is to be devoted to creating an import function, such that a blender mesh can be imported. Now, this mesh should also be modifiable, that is, it can be rotated, scaled etc and then the mesh can be used in a similar way as the perspective assistant. The proper details of the timeline of the work have been provided in my proposal.

This Sunday, May 20th, the western half of the US will be treated to an annular solar eclipse.

Annular means that the moon is a bit farther away than usual, so it won't completely cover the sun even if you travel to the eclipse centerline. Why? Well, the moon's orbit around the earth isn't perfectly circular, so sometimes it's farther away, sometimes nearer. Remember all the hype two weeks ago about the "supermoon", where it was unusually close at full moon? The other side of that is that during this eclipse, at new moon, the moon is unusually far away, and therefore a little smaller, not quite big enough to cover the sun.

Since the sun will never be totally covered, make sure you have a safe solar filter for this one -- don't look with your naked eyes! You want a solar filter anyway, if you have any kind of telescope or even binoculars, because of next month's once-in-a-lifetime Venus transit (I'll write about that separately). But if you don't have a solar filter and absolutely can't get one in time, read on -- I'll have some suggestions later even for people without any sort of optical aid.

But first, the path of the eclipse. Here in the bay area, we're just a bit south of the southern limit of the annular path, which passes just south of the town of Redway, through Covelo, just south of Willows, then just misses Yuba City and Auburn. If you want to be closer to the centerline, go camping at Lassen National Park or Lake Shasta, or head to Reno or Tahoe If you're inclined to travel, NASA has a great interactive 2012 eclipse map you can use to check out possible locations.

Even back in the bay area, we still get a darn good dinner show. The partial eclipse starts at 5:17 pm PDT, with maximum eclipse at 6:33. The sun will be 18 degrees above the horizon at that point, and 89% eclipsed. Compare that with 97% for a site right on the centerline -- remember, since this is an annular eclipse, no place sees 100% coverage. The partial eclipse ends at 7:40 -- still well before sunset, which isn't until 8:11.

Photographers, if you want a shot of an annular eclipse as the sun sets, you'll need to head east, to Albuquerque, NM or Lubbock, TX. A little before sunset, the centerline also crosses near a lot of great vacation spots like Bryce, Zion and Canyon de Chelly.

I mentioned that even without a solar filter, there are ways of watching the eclipse. The simplest is with a pinhole. You don't need to use an actual pin -- the size and shape of the hole isn't critical, as you can see in this image of the sun through the leaves of a tree during a 2005 eclipse in Malta. If you don't have a leafy tree handy, you can even lace your fingers together and look at the shadow of your hands. This eclipse will be very low in the sky, continuing through sunset, so you may need to project its shadow onto a wall rather than the ground.

If you have some time to prepare, take a piece of cardboard and punch a few holes through it. Try different sizes -- an actual pinhole, a BBQ skewer, a 3-hole punch, maybe even bigger holes up to the size of a penny. You might also try using aluminum foil -- you can get very clean circular holes that way, which might give a crisper image. Here's a good page on eclipse pinhole projection. What works best? I don't remember! It's been a very long time since the last eclipse here! Do the experiment! I know I will be.

If you do have a telescope or binoculars but couldn't get a solar filter in time, don't despair. Instead of looking through the eyepiece, you can project the sun's image onto a white screen or even the ground or a wall. Use a cheap, low-power eyepiece -- any eyepiece you use for solar projection will get very hot, and you don't want to risk ruining a fancy one.

Point the telescope at the sun -- it's easy to tell when it's lined up by watching the shadow of the telescope -- and rotate the eyepiece so that it's aimed at your screen, which can be as simple as a sheet of paper. Be careful where that eyepiece is aimed -- make sure no one can walk through the path or put their hand in the way, and if you have a finderscope, make sure it's covered. This solar projection method works with binoculars too, but you'll want to mount them on a tripod so you don't have to hold them the whole time.

Of course, another great way to watch the eclipse is with your local astronomy club. I expect every club in the bay area -- and there are a lot of them -- will have telescopes out to share the eclipse with the public. So check with your local club -- San Jose Astronomical Association, Peninsula Astronomical Society, San Francisco Sidewalk Astronomers, San Francisco Amateur Astronomers, or any of the others on the AANC's list of Amateur Astronomy Clubs in Northern California or the SF Chronicle's list of astronomy clubs.

This eclipse should be pretty cool -- and a great chance to test out your solar equipment before next month's Venus transit.

When I went to put the event on my wall calendar last month, I discovered the calendar already had an entry for May 20: it's the start of Bear Awareness Week. So if you head up to Lassen or Shasta to watch the eclipse, be sure to be aware of the bears! (Also, maybe I should get a calendar that's a little more in tune with the sky.)

At the recent Ubuntu Developer Summit, I managed to convince a few people (after assurances that there would be no permanent damage) to plug a USB stick into their machines so we could watch Xorg crash and wedge their console. What was this evil thing, you ask? It was an AVR microprocessor connected to USB, acting as a USB HID Keyboard, with the product name set to “%n”.

Recently a Chrome OS developer discovered that renaming his Bluetooth Keyboard to “%n” would crash Xorg. The flaw was in the logging stack, triggering glibc to abort the process due to format string protections. At first glance, it looks like this isn’t a big deal since one would have to have already done a Bluetooth pairing with the keyboard, but it would be a problem for any input device, not just Bluetooth. I wanted to see this in action for a “normal” (USB) keyboard.

I borrowed a “Maximus” USB AVR from a friend, and then ultimately bought a Minimus. It will let you put anything you want on the USB bus.

I added a rule for it to udev:

SUBSYSTEM=="usb", ACTION=="add", ATTR{idVendor}=="03eb", ATTR{idProduct}=="*", GROUP="plugdev"

installed the AVR tools:

sudo apt-get install dfu-programmer gcc-avr avr-libc

and pulled down the excellent LUFA USB tree:

git clone git://github.com/abcminiuser/lufa-lib.git

After applying a patch to the LUFA USB keyboard demo, I had my handy USB-AVR-as-Keyboard stick ready to crash Xorg:

-       .VendorID               = 0x03EB,
-       .ProductID              = 0x2042,
+       .VendorID               = 0x045e,
+       .ProductID              = 0x000b,
...
-       .UnicodeString          = L"LUFA Keyboard Demo"
+       .UnicodeString          = L"Keyboard (%n%n%n%n)"

In fact, it was so successfully that after I got the code right and programmed it, Xorg immediately crashed on my development machine. :)

make dfu

After a reboot, I switched it back to programming mode by pressing and holding the “H” button, press/releasing the “R” button, and releasing “H”.

The fix to Xorg is winding its way through upstream, and should land in your distros soon. In the meantime, you can disable your external USB ports, as Marc Deslauriers demonstrated for me:

echo "0" > /sys/bus/usb/devices/usb1/authorized
echo "0" > /sys/bus/usb/devices/usb1/authorized_default

Be careful of shared internal/external ports, and having two buses on one port, etc.

© 2012, Kees Cook. This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 License.

This blog entry had tons of sarcasm prior to posting, but I edited it all out. I’m not a complete monster, you know.

So, I was googling for something today and stumbled upon a 3 weeks old (that is, nobody cares about it anymore) interview with Jane Silber, CEO of Canonical.

As a person currently employed in marketing, I certainly know how important it is to focus on good things that your company does when you are spreading PR with a big shovel. It’s more or less OK to make controversial statements, if you can keep the game on, but telling outright lies? No, I don’t think so.

Here is an interesting excerpt:

“The fact that GNOME and other projects now value design,” Silber stops, perhaps to reconsider the boldness of what she is about to say. “If you go back three years ago nobody was talking about design, nobody was doing user research. It is actually something we have had great influence on, by calling attention to it and putting our efforts there. I think, whether you like Unity or not, its existence has helped raise the bar across a number of projects. That is something that we feel good about; you can attribute that to our leadership in that area, even if it’s not our code and our design.”

Can you see what’s wrong with it? Let’s chop it up into smaller bits.

The fact that GNOME and other projects now value design

*sigh* She just had to say that, yeah?

If you go back three years ago nobody was talking about design

Dear Ms. Silber, I suggest you go five years ago, or even more, and discover Tango project. In 2007 I did an interview with them for GNOME Journal. It is real, and there is proof.

Probably you would  also like to find out that Ascender Corp. was comissioned by Redhat to create Liberation fonts and delivered them in early 2007. That  was just how many years prior to Ubuntu font family?

nobody was doing user research

How about Sun having done a usability study of GNOME in 2001, several years before Canonical was even conceived?

I think, whether you like Unity or not, its existence has helped raise the bar across a number of projects.

That, at least, is true.

That is something that we feel good about; you can attribute that to our leadership in that area,

And this is what it was all about: leadership.

I don’t believe that anyone who’s been with the company since 2004 could possibly not know all of that. So what was that? Canonical claims to have invented design and user research in free software? When did they start acting in the worst traditions of Microsoft et al.?

It's pretty simple, really... Fluxbox has a "fluxbox-remote" tool that can be used to send commands to fluxbox, such as "Close" or "Fullscreen". So the trick is simply to add launchers to your taskbar (in this case href=http://fbpanel.sourceforge.net/>fbpanel), and set "fluxbox-remote Close" or any other as their command line:

I added a new object type for the Drawing module of FreeCAD. It is a clip plane object, it behaves like a group, you can place it inside a page (which happens by default when pressing the button), and add view objects to it by dragging them in the tree view. It has X, Y,...

Sirko brought up the idea to organise a hackfest together with developers of applications for Linux desktops and experts interested in colour management. The idea behind that event was to bring interested developers together, support them in implementing color management in their software and move forward that topic across desktops and distributions.

During the recent LGM we found a chance to involve Richard Hughes and planed together about what we like to do during the hackfest. We spotted three main areas of interest: desktop applications including window managers, web browsers and printing. These topics are already worked on, but in a scattered way.

As example, Gwenview is a really great application for managing pictures. But it has no color management implemented yet. Color management in KWin is worked on during the GSoC this year, but in the opposite color management in the compositing manager mutter on the GNOME side is far away as can be read here. Not many web browsers support color management and if they who do, it is often incomplete. The SVG v2 standard will for example introduce additional color management features compared to SVG v1. So it is now the right time to get these implemented in order to be well prepared. For the KDE printing stack there is also a GSoC project this year, but also the Linux Foundation has a working group for this topic.

So, by meeting in person in one place, we want to get something done and build a good understanding of the role of each participating group for a working end to end colour management.

The hackfest will very likely happen in Brno in the Czech Republic at the Red Hat offices. A good time appears later this year 16th till 19th November. Now we like to collect more ideas, speak to people and sort financial issues.

We have a lot of pictures from the LGM 2012. Here are some of the best galleries!

• Nicu
• Tom’s drawing

Please add your gallery as a comment to this post (we will integrate them in the list)

Help us preparing the LGM final report we will need for all our
communications with sponsoring organizations, whether they are
corporate, non-profit or public.

From each team present at LGM 2012 we need a short text telling in a
lively manner, including a good quote to summarize, what was
accomplished at LGM this year and how important LGM is in the
development cycle of your project. Get to the point. It doesn’t have
to be long. It only has to say the important things!

To the Project Feedback form »

Of course, your very welcome to publish the summary also in your Blog
or Website.

Please write and send before Monday, May 21st.

We would also encourage you to fill our participant feedback form:

To the Participant Feedback form »

Each person having participated is invited to give feedback and help
us improve the LGM!
(well, if somebody wants to write the reasons why he or she
didn’t travel to Vienna, his / her feedback is also very welcome!)

No field is mandatory: just fill the ones that matter to you.

Thanks again for participating at the LGM 2012!

Europes biggest event arround Linux and Open Source – LinuxTag, is’nt far away anymore and Oyranos will participate on it. LinuxTag take its place in Berlin from 23.-26. May on the exhibition area arround the Funkturm. On saturday the 26th of May I will present together with Sirko an talk about colour management – “Bring Color To The Game“. The talk will not introduce Oyranos as CMS, it will more explain what color management is and about the actual status on free desktops. We want as well to talk about what a user needs to get colour management running. During LinuxTag I will be reachable on the openSUSE booth for questions and introduction into profiling and bring some colorimeters.

In my last blog post about Awwation, I had talked about live thumbnails. What I’ve discovered is that since <use> references the original SVG, the editor becomes really slow as you add more presentation nodes to the timeline, because the changes are reflected in real-time across all the thumbnails. For short presentations this isn’t really a problem, so I’m keeping this feature as it is till I figure out a more efficient solution.

My other pet peeve was that the presentation would not animate in several browsers – particularly Opera. This has now been fixed with the latest version of the Sozi script, which is much faster and seems to work on all major browsers – I’ve tested on IE9, Safari, Firefox, Chrome, Arora, the iOS browser, and the one on my phone: the Nokia N950 developer device.
So that’s it for the presentations. I’ve also tried to make the editor work across all browsers – the saving with the FileSaver polyfill worked only in Chrome, and since I really want everything to be done client-side, I have used a tiny script, Downloadify, that saves the presentation using flash if you’re not using Chrome.
Oh, and now instead of the default name aww.svg, you now get a system dialog asking you for the filename and location for the generated presentation.

The next major thing I finished off was the support for offline theming.
I’ve cloned the Google Fonts Collection and base64-encoded some fonts and embedded them into the CSS theme files, so you don’t have to do any CSS @import for the fonts from Google’s CDN. Next, I’m XHRing the theme files (statically hosted along with the editor) and injecting the CSS response into the presentation when you pick a theme, instead of stuffing an @import between <style> tags. Oh, and since there’s no @import URL anymore, I can use a relative path to the theme file for the XHR and therefore the theme can be retrieved from the same static hosting as the editor, and the theming in the editor and the presentations works offline, too.

So, now everything in the presentation works offline, except for images.
Images are a different breed – right now, the image embdedding functionality from SVG-edit takes URLs to remote images. Ideally, in the editor, I want to retrieve the images and embed their base64 dataURL in the SVG, but this will require a cross-domain request, which is a security problem and therefore disallowed by browsers. I could allow the user to read in an image from their local machine with the HTML5 File API, but sadly this isn’t supported by IE9.
So right now, you need an internet connection to view presentations with images. Hopefully I can figure out a solution soon for this.

Interestingly, I’ve been able to successfully create an Awwation entirely on my phone using the editor, from within Mobile Firefox! In it’s current state, there are many more things that can be used to make the Awwation editor more touch-friendly though.

Now that I’ve graduated from college, I should have some free time to work on this project. These days, I particularly enjoy working from The Chocolate Room, a popular cafe chain here in Ahmedabad, where they have really nice coffee and crushed ice drinks for the summer. Nothing better than great coffee to to help you code. And they have power sockets for people like me to plug in their laptops, so that’s great!

Summary: If you have performance problems using the JACK Audio-Connection-Kit and the fglrx ATI grpahics card driver, switching to radeon may solve them. Unity 3D and radeon can work, but leftovers of other drivers might get in the way. Also: Proprietary, binary blobs smell bad and Ubuntu’s infrastructure around those drivers is dodgey.

On Ubuntu 11.10, I switched graphics cards and thus drivers from nvidia to fglrx without much of a problem.

I recently upgraded to Ubuntu 12.04 and was quite pleased by how smooth that went and glad for not having to reconfigure and reinstall a bunch of stuff. As with every release so far, some issues might have disappeared, but a very noticable new one arrived: focus-follows mouse combined with auto-raise does no longer work reliably. So far I failed to identify the pattern for the cases where windows are not raised, when they should be.

After a while, I wanted to get back to music production with JACK and Ardour. My system was still configured for JACK to run in realtime mode, but I got many disconnects, often right when Ardour brought up its main window. I found out this only happened with Unity 3D, not with 2D. So it seemed like either one or the combination of Unity 3D and the fglrx driver interfered with realtime mode. A fellow #lad inhabitant knowledgeable about this realtime kernel business suspects that the 3D accleration part of the fglrx driver is not preemptable.

Where does one even report bugs about that proprietary blob? And how would one diagnose what exactly goes wrong?

Now I could use Unity 2D, but I really miss window drop-shadows, dislike the look and different notification animations for the Launcher icons and hate the fact that the Dash doesn’t react to the same shortcut I configured while using the 3D version.

Initially, I thought I would need the fglrx driver for Unity 3D, but still wanted to try switching to radeon. The Additional Drivers dialog claimed that neiter of the 2 ATI options were active, but lsmod told me otherwise. I have some Wacom-related stuff in my xorg.conf, which had to be moved out of the way, to get that thing to work. After a reboot, radeon was in use, but Unity decided to drop back to 2D. The cause: Xlib: extension "GLX" missing on display ":0.0". The solution was purging any trace of fglrx and nividia(!) from my system. Also, for good measure, but I suspect it’s unnecessary: sudo apt-get install —reinstall libgl1-mesa-glx libgl1-mesa-dri xserver-xorg-core; sudo dpkg-reconfigure xserver-xorg.

Now I have a working Unity 3D, using radeon, no disconnects or xruns galore using JACK and Ardour. Only new problem so far: shaky mouse pointer on the login screen.

Filed under: Planet Ubuntu, Ubuntu

GNOME 3 introduced a new style of icons we call symbolic. Last year, Meg Ford joined the effort we kicked off with Lapo and did a great job extending the theme coverage, without us having any style guidelines in place yet. This year, we’ll have another Woman Outreach program participant joining the effort, so I’ve edited a little video introduction on how we design these icons along with a little overview of all the icon styles currently in place.

The Technikum Wien provided a nice place and great support for the LibreGraphicsMeeting. Many thanks to them. LGM happened together with the Linuxwochen Wien and developers and users could talk about graphics and arts themes. Additionally to the one presentation track over all days, we had BoF’s and workshops. Some of us took the chance to present to a non LGM audience and meet people there too.

The LGM talks covered lots of OpenCL projects. That means modern GPU computing power is available to open source graphics components in a much broader way. As the use of OpenCL is supported by the Mesa software implementation, there is some kind of guarantee, that OpenCL programs will run on elder hardware. That means OpenCL can be used without the need for developers to provide a fallback mechanism, which simplifies adoption.

The colour management talks provided lively discussions around many topics like printing, displaying and open hardware. We discussed as well the impact of introducing colour management in frameworks like GEGL. As mizmo showed interest, I explained the most basic terms of ICC rendering intents in a small BoF using ICC Examin. Animtim compiled and installed Oyranos from sources and wrote already a small tutorial on how to build Oyranos on kubuntu-12.04.

The presentation of Markus Raab about the Elektra configuration gave to me some impressive insights into the concepts and flexibility of that small framework. The really cool thing about this library is it can abstract a lot of details and provide additional features, which can be added on run time like DBus support. He announced a new release of Elektra as version 0.8.0 during the event.

The metalab was for most people from countries without a similar open hardware/open source collaboration zone a impressive visit. We all enjoyed to could stay there for some hours and felt, this place is much in the spirit of most LGM contributors.

During Nathan Willis workshop about the Create wiki, we discussed to start a email list for create users. That list is supposed to provide help and talk about experiences with graphics applications and help from users for users.

Sirko (alias gnokii) and Tobias (alias houz) played diplomat and managed to channel information in a way that Richard Hughes and I could finally meet in a productive atmosphere and continued talking about technical issues. At the end we found a mod to work again together on standards inside the OpenICC collaboration project. I am pretty happy with that change. So, thanks to all parties who helped with that.

Tatica, Pete, Sirko and I walked around on the last day in Vienna and relaxed in the café above.

University of Chicago Press has a Carl Zimmer book, A Planet of Viruses, as their free monthly e-book.

I know Zimmer is a good writer. but the ebook, despite being free, is encumbered with Adobe's version of DRM, which unlocks via a Windows or Mac program. I use Linux, and wanted to read the book on a Nook. Was I out of luck?

Happily, the instruction page they sent when I signed up for the book helpfully included a section for Linux users. Hooray, U. Chicago! It said Adobe Digital Editions will run under Wine, the Windows emulator. I'd been meaning to try that anyway, and a Carl Zimmer book seemed like the perfect excuse.

And overall, it worked pretty well, with only a few snags. Here are the steps I had to follow:

Authorizing a book using Adobe Digital Editions in Linux on Wine

Install wine (on Ubuntu, I used apt-get install wine).

Download the Adobe Digital Editions setup.exe

Run: wine setup.exe (this should install ADE inside your .wine directory)

Copy the file, e.g. URLLink.acsm, into .wine/drive_c/My\ Documents/ Don't bother trying to open it with ADE -- the program won't open anything except PDF and epub. Curiously, the only ways to open the file from ADE are to drag the file onto the ADE window or to pass it as a commandline argument:
wine start .wine/drive_c/My\ Documents/URLLink.acsm

Now ADE should download your book and display it. You can read it there, if you want. But you won't want to -- it's not a good reading interface.

Authorizing a device with Adobe Digital Editions under Wine

Now how do you get it into your ebook reader? ADE running under Wine doesn't recognize devices such as ebook readers. so nothing will be copied automatically. But you can copy it manually.

• Plug in your ebook reader.
• Mount the device wherever you like -- /media/nook, /nook or whatever.
• With ADE not running (quit it if it's running), map a drive letter to the mount point:
  • Run winecfg
  • Click the Drives tab
  • Click Add...
  • Choose a drive letter (I chose D:)
  • Under Path: type in the mount point, like /nook
  • Click Show Advanced
  • Set the Type: to Floppy disk
  • Click OK to save it
• Now the drive is mapped. Re-run ADE:
  wine .wine/drive_c/Program\ Files/Adobe/Adobe\ Digital\ Editions/digitaleditions.exe
  ADE should now see the device and ask you if you want to authorize it.
• In ADE, drag the chosen book onto the left sidebar entry for the device.
• umount the reader ... and now your new book should show up in the library.

In theory, the drive letter should stay mapped, so you should be able to use it for opening future books. Just remember to mount your device to the same location before running ADE under wine.

A little talk I gave about Seder-Masochism-in-progress and Civil Disobedience at Brooklyn Law School’s “Legal Hackathon” several weeks ago.

A few weeks ago I was again teaching my course, interaction design for the real world, at the FH Vorarlberg, Austria. As always, the course evolved further: a feedback session for draft documentation was built in this year, which proved to be very valuable.

Also I made headway with stamping out non‑designer vocabulary. Last year the taboo word was ‘intuitive,’ this year it was the phrase ‘the user.’ Interaction designers speak of ‘users’ in plural, to get the message across that there are many of them and that they are a diverse group.

working the seam

The real‐world design challenge that the students worked on was, like every year, from the GIMP project. This year I picked the Liquid Rescale plugin. It implements seam carving, which means that it finds the uninteresting portions of an image, and modifies only these to grow/shrink an image.

an example from meetthegimp.org, mind the cows…

But things are not that easy. There is plenty of parameters to drive this and just about all of them are necessary:

The most important of all these parameters are the preservation and discard masks, which let users specify which parts of the image (or more precise: the layer) are interesting and uninteresting, respectively.

scenarios + variants

To flesh out the essential use of Liquid Rescale, we made a few user scenarios:

1. simple resizing, also in relation to a composition (say, a collage);
2. precise control while resizing, using the preservation and discard masks;
3. make objects disappear without a trace, using the discard mask;
4. creative abuse, beyond the hi‑fidelity intentions of the tool.

The students used these scenarios for their evaluation of the interaction of the existing tool. With their insight into the good and the bad, the students were ready to brainstorm better solutions. This year the students were asked to do this in four directions.

This was in reply to two open questions. The first one was ‘should Liquid Rescale be a plugin in a dialog or a toolbox tool?’ The second one had to do with layer abuse: those preservation and discard masks have to be in the layer stack. So I asked the student to brainstorm the direction of using layers and the opposite: not use layers.

After the brainstorming the student teams picked their own course, while designing their solution.

three team results

And now the design results of the student teams. First let me make clear that the work of all three teams is available under the GNU Free Documentation License 1.2. I present them in team order.

team one

• members: Ana Beatriz Bravo Rojas + Elena Zabrodina
• design concept document (pdf, 5.4 MB)

Team one decided on keeping Liquid Rescale a plugin in a dialog. But they worked real hard on reducing the area occupied by the parameter controls, thus optimising the area available for previewing the layer that is being worked on:

I like that they designed these compact controls as a flexible system (quite a challenge), which can be used in different aspect ratios:

Team one settled for using layers to represent the preservation and discard masks and also designed the output of the tool to automatically appear as new layers.

team two

• members: Isabel Schmidt + Simon Wenglein
• design concept document (pdf, 4.6 MB)

Team two did the oposite of team one. They redesigned Liquid Rescale into a toolbox tool, which means it works fully interactive on the canvas. Since there are ample options they designed collapsing sections for them. Below left we see all sections collapsed; on the right all of them expanded:

Also they designed the preservation and discard masks out of the layer stack. They live inside the tool instead, where they can be created, worked on and managed:

Below you can see how team two designed a mask editing session. I like that they did not take the ‘making masks equals painting’ metaphor for granted. Instead they adapted the free/poly selection tool for mask definition needs:

team three

• members: Alexandra Genewein, Katrin Seidel + Nicolai Pritzl
• design concept document (pdf, 2 MB)

Team three also redesigned Liquid Rescale into a toolbox tool. Also with collapsing sections in the tool options. Below we see their take on the collapsed (left) and expanded (right) layout:

Team three gave their own twist to the preservation and discard masks. Treading the middle way, they made it optional whether these would be stored as layers. Below we see the mask edit session, using the established ‘making masks equals painting’ metaphor:

Thumbs up to team three for documenting their design with their pencil drawings. Working in pencil is the norm during my class and as long as it is clear, it is also fine for design documentation.

postscript

Again I had a great week at the FH in Dornbirn this year. The evolving course set‑up, and the fact that every year the design challenges stress different aspects of interaction design craftsmanship, keep things fresh and exciting. I would like to thank all the students for the hard work they put in and for the energy they returned.

Thanks to 100s of bugreports we've done over a 100 fixes in just 2 weeks; enough to deserve a...

Join +Bassam Kurdali Saturday at High Noon in a Google hangout to chat about the Tube production (May 12 at 12pm EST)

Alexandre Prokoudine published a great, funny interview with Bassam and me over at Libre Graphics World: Tube Open Movie Founders on Art, War and Blender

LGM Talk about the Tools of Tube: Libre Graphics Meeting is a great conference well attended by developers of free/open source software–all the programs we use in the making of Tube. Since we weren’t able to be at the meeting in Vienna this year, we prepared a short remote talk for the group. It’s mainly about some of the tools we’ve written as part of the Tube Open Movie production, and we thought it would be nice to share!

Summer internship applications are open until the email deadline of Thursday May 17, at 5pm (EDT).

In the 3 days left on Tube’s Kickstarter campaign, can we reach full production funding?! You can help by getting the word out to your people, and we’ll finish in a massive success — thanks for your support!

Hey everyone!

The graphic that you see above is the architecture model for libCmpx – the key library used in getting printer color management to work in Krita. There is a slightly more detailed description on the ColourWiki page, but the entire library can be summarized as an application interface to calibrate printer settings (based on a selected ICC profile), as well as to generate a color-managed, print-ready PDF file.

With last week’s work of prepping the libCmpx code for development all finished, I will now proceed to fine-tune both libCmpx ‘Selector’ and ‘Renderer’ code. Both these modules – with the help of Ghostscript and Oyranos – actually do the work to make print color management happen. Of course, with the abstraction that was recently implemented in libCmpx, the Krita developer and user will not know about the kind of work they are doing inside the library. Such is the magic of abstraction!

In addition to the code updates, I’ve mostly been busy setting up the library’s test application. The “libCmpx Test Dialog” is a print dialog simulator that will be used for development work, making sure that the library is in good shape to be included into Krita. It is now housed in libCmpx git, but is not quite ready yet (it should be fixed by the end of the weekend).

Onward now to some serious coding…!

-Joe

The SVG Working Group had a three day Face-to-Face meeting in Hamburg this week. The last day was devoted to working with the CSS Working Group on joint items. I attended most of it via telephone. A lot of the discussions had to do with stategies for getting SVG2 out or with technical stuff. But there were a number of things that might be of interest to Inkscape users and others.

• Paint Order: It was resolved that the SVG will allow the order in which fill, stroke, and markers for a single graphics element are painted to be specified. At the moment the stroke is always painted on top of the fill, and markers on top of everything. Being able to paint the fill on top of the stroke is quite important for text.
  

  A letter with various paint orders.

• Marker Clipping: At the moment, in order to avoid the path from showing under the tip of an arrowhead, the arrowhead must extend past the end of the path. In Inkscape, this prevents things like snapping the arrow tip to a line since the path end is not at the same place as the arrow tip. One of the SVG group members is going to work out a way to specify a clipping region for a marker that would apply to the path below thus eliminating this problem.
  

  Demonstration of the use of marker clipping. The red dotted line indicates the clipped area. Clipping only applies to the path the marker is attached to.

• Marker positioning: The current spec only allows markers placed at the ends of a path or at nodes. The WG agreed that more complex marker placement would be supported, For example one will be able to alternate between two markers and place them every 20px along a path.
  

  A path with markers. The markers are placed by distance along path.

• Masking: Masks will gain an attribute to specify whether to use alpha or luminance in the masking calculation.
• Screening Filter Primitive: The group was supportive of my proposal to add a screening filter primitive. It would not be added to the SVG2 specification directly but to the CSS/SVG joint filters specification that has been split out from the SVG spec.
• Gradients Along/Across Paths (and Variable Stroke Opacity): While group members were interested in this, it turns out to be quite difficult to implement so the group pushed this off to the future. (The Adobe rep said that it was a real pain to export it to other formats.) If Inkscape were to support this somehow (mesh fallback?), it would help push it into the spec.
• New Stroke Join: Coming from Johan Engelen’s Power Stroke work inside Inkscape, I propsed that the SVG2 specification add a new stroke-join option. Currently you have the choice of beveled, rounded, or mitered. When a path contains two curved segments joined at a sharp point, the mitered option doesn’t look so good. Johan’s Power Stroke allows an “extrapolated” join where the curvature of the paths is taken into account. The SVG WG liked this idea and approved it subject to defining the math needed precisely. One factor in its adoption will be than none of the graphics libraries used by the browsers includes such a join.
  

  The existing join styles with the proposed extrapolated join style.

More details about the Krita workshop I made at Libre Graphics Meeting last week:

The goal of this workshop was to teach my workflow to use Krita for comics-style drawing.
After some explanations about my hardware and shortcuts setup (as some of you may know I use a joypad for all my shortcuts, using Qjoypad to map the keys, as my tablet-setup desn’t allow me for a keyboard access easily), I started opening a sketch of a “Libre Graphics Captain” super-hero that I prepared for the occasion:

Then I explained how I ink and color it quickly. For the ink, most important points are to choose the right presets, and to be confortable drawing energic strokes , using a lot the canvas pan and rotation shortcuts to adapt the canvas position to your movement. Then for color, a first step to fill the areas with base colors, then a few layers over it using blending modes to apply shadows and highlights, using the “layer groups + alpha disable” mask trick, and a final layer using color-smudge brush to paint details/corrections. I did the demo on the face only, to fit the workshop timing; also I added a few modifications following the audience suggestions :

Then I finished it at home, here is the final result (you can notice I’ve re-painted all the light as I made them in the wrong direction at the workshop …) :

Again I want to say that I’m very happy of how the place was filled with great people and everyone was very interested, asking good questions.
Thanks for coming!

I’m finally using this great plugin for Flash, that even works with Ye Olde Macromedia Flash 8 (considered by most animators to be the best version ever made, far superior to Adobe’s crippled messes). The Library Symbol renaming tools alone have made me a fan.

Recently I have been receiving requests to clarify the GIMP UI strategy surrounding GEGL, so I thought I’d write a catch‑up blogpost about my 2010 LGM lecture. There I tackled this GIMP UI challenge: a first outline for a UI for a fully GEGLed GIMP. The thinking about this UI, and the discussions with Øyvind Kolås (the GEGL‐meister himself), have been going on for years. Its introduction will be the most profound change to GIMP in the foreseeable future.

two minutes of fame

I started off my lecture with introducing GEGL, the graph‐based image processing engine that is slowly, but surely, being integrated into GIMP. I could spend quite some time taking us through the complete GEGL graph (linked) below:

…and this is only a small one. Instead, here is the essence of it in four easy steps:

1. there are input boxes that load an existing image, or render some vector shapes or text;
2. there are chains of operation boxes that perform things like blur or change opacity of whatever gets fed into them;
3. there are composer boxes that take two inputs and put one over the other, combining them in a certain way (think layer modes: normal, dodge, multiply);
4. there are output boxes that either display the grand result on a screen, or export it to graphics file formats like png or jpeg.

so…great

Thus GEGL processes graphics by hooking up the boxes, inputs–to–output. Why does that matter? Well, because it is non‐destructive: the images in the input boxes are never modified.

If the structure of above graph is written to a file—apart from the input images, all other boxes are just snippets of XML—and a year later it is re‑opened in GIMP, then each of the operations and their parameters; each of the vector shapes or text can be freely changed. Even the input images could be swapped out for different ones. The result is a changed image composition, without any loss of quality.

It is exactly this promise of non‐destructive editing that played a big part in me joining the GIMP project years ago. I could see how that could lead to the end of some of the major workflow bottlenecks in today’s graphics software.

UI modelling

The integration of GEGL in GIMP is a disruption; it changes the rules of what one can do and how one can work. This is not a bad thing, it is a refreshing change. An interesting question is: how does the user interaction of GIMP have to change, in order to harnesses all this new power? In general there is a big urge, especially with developers, to just display the graph on the screen:

I call this the boxes and hoses model. If it looks familiar to you, it is because it has been around for decades: it is called visual programming. Which again explains why developers tend to choose this type of solution. One day a direct representation of the graph will appear in GIMP, as something extra. This is because the product vision defines GIMP as (also) being ‘a platform for programming cutting-edge image processing algorithms, by scientists and artists.‘

activity centre

To find out what the main UI in GIMP should be, we take from the product vision what the main activities are that GIMP is made for: ‘high-end photo manipulation’; ‘creating original art from images’; ‘producing icons, graphical elements of web pages and art for user interface elements.’

As a next step, it pays off to look at the nature of these activities. Users start with images or basic shapes (vectors) and apply image manipulation operations, one after another, to achieve the desired result. Users organise their work in layers and GIMP composites the result. Schematically that looks like this:

In short: a work (a composition) consists of layers, each with its sequence (in time) of operations. Now we got the start of a model for the UI. That list of layers we know already, as the layers dialog. The sequence of operations for the layer, we can call that the operations dialog:

disclaimer

Keep in mind that the user interaction shown in the image above, and all the ones below, is not a true mockup. It is more a diagram—with in part grotesque proportions—to show the principles of how the UI works.

We can see that the four GEGL elements are covered: The image material to start with: loaded pixels or rendered vectors; the layers that control the bulk of the compositing; the chains of operations; the output to the screen in the big image window.

Yes, the image window is the place for judging one’s work and for doing the actual work, hands‑on. The image window deserves a couple of times more screen space than any GEGL graph manipulation. Reversing this relationship (as shown earlier) is completely disregarding the nature of the activity.

back to the future

Adding an operation works as before: use a toolbox tool or invoke a menubar item. Here Gaussian blur is invoked and it appears at the top of the operations list:

Now it gets more interesting: revisiting the past. No matter if it was done five seconds or five months ago, one can recall any previous operation applied to this layer and readjust it. Here the curves for this layer are revisited. While adjusting, the output updates through the complete chain of operations, including colorise and blur:

A lot of layers dialog behaviour can be reused for the operations dialog. ‘Eye’ toggles can be used to show/hide the operations:

Drag and drop can be used to rearrange the order of operations. The result of that may turn out to be more subtle than you think. Because GEGL processes everything in 32bit floating point, it will be much harder to get the rounding and clipping artefacts you get with 8‐ or 16‑bit integer processing. Only when an operation does not commutate by nature (i.e. the order matters), then it gets interesting to experiment with the order of operations.

Of course copy and paste of operations, between layers of the same or different files works. Dragging and dropping of operations on another layer copies or moves them, a modifier key (shift or ctrl) will sort that out. And before I forget: selecting some operations in the operations dialog and invoking ‘Make macro’ would be a good, natural way to get that started.

the holy trinity

Before we continue with more GEGL user interaction, here is a pop quiz. I took this b+w photo of the brilliantly named Kloten airport and coloured part of it red:

My question is: how did I apply that red?

1. directly with a tool from the toolbox;
2. making a selection, then invoking a menu item;
3. using a layer with a layer mask.

Well, I have forgotten how I did it (it’s been a while) and you will never guess. My point is that it does not matter. All three methods listed above are a combination of an operation (apply red) and a greyscale mask, controlling where it is applied and how much. All three methods are fully equivalent, it does not matter to the software—or the viewer.

It does matter to users. Given the context, composition structure, the graphics material and the end‑goal, each user knows exactly which of the three methods she/he prefers. There is a million different use cases and only the individual user on the spot can take the right decision. It follows that each of the three methods is equally important and needs to be equally available to users. This I call the holy trinity of image manipulation.

pagan practices

However, at the moment, you quite often see the following: ‘if you want this feature, you’ll have to use it on its own, extra layer.’ This is layer abuse. I get misquoted on this so let me clarify: users never abuse layers, developers do. Here are some examples of layer abuse:

• the only way to do a non‐destructive operation is via an adjustment layer
• only one vector shape per vector layer;
• only one block of text on a text layer;
• the output of a filter plugin is always put on a new layer;
• the result of using a toolbox tool is always put on a new layer.

The problem is with ‘only,’ ‘always’ and ever more layers, whether users want them or not.

reformation

The abuse listed above is straightforward to fix. Quite a bit of it has to do with enabling users to redo or revisit the image manipulation. That is solved by the operations dialog.

Furthermore, there can be as many vector shapes and text blocks on a layer as one likes. Just show them—and stack ’em—as sub‑layer elements in the layers dialog. And when then one of these sub‑layer elements is allowed to be actual pixels, then it is clear that the whole notion of special vector/text layer can disappear:

Layer abuse has to stop. Developers should never force users to use another layer. Only users decide how many layers they want to use, purely as their own personal way to organise their work.

more blessings

So apart from that no image manipulation is exclusive to a layer, what are further implications of the dogma of the holy trinity?

paint with anything

Yep, with anything, also all the plugins that appear in the Filters menu. Also the obscure ones that you and I, and anyone on the GIMP team have never heard of. Just dip your brush in it and smear it on the canvas. Thinking of combining it with paint dynamics just blows my mind. It just takes one tool (Filter brush?) to enable this.

adjustment layers with anything

You see, I have nothing against accomplishing things with layers. It is perfect when you got a collage made out of dozens of layers and then want to apply some treatments to the whole thing. It just takes one adjustment layer with any number of operations to get that done. Again, with anything.

behind the mask

As mentioned, all three image manipulation methods consist of an operation and greyscale mask, controlling where it is applied and how much. The interaction for these masks can be analogous to that of layer masks:

This means that both the parameters of the operation and also the ‘where and how much’ can be revisited and adjusted, a second later or a year later.

in triplicate

By now you may be thinking ‘wow, every image manipulation must be possible in three different ways, does that mean that one day GIMP will contain three times more stuff than today?’ Well no. I have already mentioned two measures—Filter brush, adjustment layers with anything—that will make large strides towards fulfilling the holy trinity. And even today the trinity is partially in place at GIMP.

Take for instance composition, putting pixels on top of pixels. Sounds like the exclusive domain of the layer stack, no? Well, even today you can use toolbox tools to do the same thing: the Clone tool and its 90%‑identical cousin, the Heal tool. And the menu item to compose is called Paste. Yes, the current layers dialog interaction while pasting should go. The GIMP team is agreed on this for years. Instead paste is an operation on the current layer:

weird science

There is a fifth element to GEGL graphs, that I have been keeping under wraps in this blogpost until now: cloning. This is taking an in‑between result in the GEGL graph, anything from a simple vector to a huge sub‐tree, and ‘teleporting’ one or more clones of this result to another position in the graph:

The original and the clones can have the same or a different position on the canvas; undergo the same or completely different operations; be composited in the same or a completely different manner. The magic is of course in that when the original (the input to cloning) is updated, every clone immediately updates, with all further operations and compositing applied on top. This is going to be liberating, because of the amount of work this saves.

Let me give an example. Let’s take the scan of a snowflake and fix it up with a number of graphics operations. We clone the result 99 times and spread these over five layers to compose our snowscape. We make ever flake a different size and a different colour. Already laborious, no? And now, we decide we are not satisfied with how refined the snowflakes are. Solution: fix the original with more/less/different/updated operations, all 100 flakes will immediately show the improved refinement—in their different sizes and colours.

send in the clones

My plan for the user interaction of cloning is to make it a variant of pasting: Paste as clone. This includes doing further operations on the pasted (as clone) material, before closing off the paste (you can always revisit the paste operation and modify all of it). And as Ville Pätsi pointed out a while ago, there needs to be a way from each clone to access the original. A button or link on the Paste clone operation in the operations dialog might do the trick.

There is more tricky stuff coming up with this cloning, like cloning layers or layer groups. And to go fully meta on this: I am asking myself why chains of operations cannot be cloned and applied to different input material. But Øyvind is not up for that.

two more things

To wrap all this up I have two benchmarks that have developed out of the GEGL discussions. They are alternate manifestations of the holy trinity and they are serious tests of the direction the GIMP user interaction is taking.

First, in a future version of GIMP, if users really envision their work as one single layer—not that unusual with photographs—then they will simply be able to close the layers dialog. Their work will not be impeded in any way by this, everything is still available to them (twice, as toolbox tool and menu) with no limits in the sophistication with which they can express themselves:

Second, in a future version of GIMP, if users are really not interested in switching operations on/off; rearranging operations or revisiting the past, then they will simply be able to close the operations dialog. Their work will not be impeded in any way by this, everything is still available to them with no limits in the sophistication with which they can express themselves:

You could even combine the two benchmarks and GIMP would still work, without a hitch.

aftermath

Directly after the lecture at the LGM, Øyvind Kolås pointed out one flaw, one thing I had not thought of: those greyscale masks, that play such a central role, are not pixmaps. They are GEGL sub‐graphs themselves. Which creates the possibility of near‐endless drill‐down: operations with greyscale masks, which contain operations with greyscale masks, which contain… et cetera.

Is that a fatal flaw? Is that going to blow up my plan to reduce the complexity of the GEGL graph to a linear list of operations? Do we just have to confront users with the whole graph? Let not kid ourselves about the complexity of that graph. In practice, I’d say that a simple GIMP file starts at ten times the number of boxes in the example at the top, quickly moving to a hundred times and then beyond.

not my problem

To developers—especially the ones that are working up to their elbows in GEGL graphs—this problem looks like one of navigating the graph and making edits. But to me it looks like another problem needs to be solved: how can users navigate their working context? Already today GIMP users are doing this navigation. Which layer, which layer mask are they editing, or is it the quick mask?

It will have to wait for another day, but when this context navigation is going to be designed, the one thing not to lose sight of is the image window. Everything evolves around it, including this navigation, and feedback of the working context has to be inside it. I certainly think we can do a better job than currently happens with the layer masks.

And when this context navigation has been designed, taking into account the holy trinity and the two benchmarks, then the operations dialog can show the simple list of operations performed in that context, in their natural order.

Allan has done a great job giving an overview of what we’ve been focusing on recently among the design team. This still leaves some room for me to give a peek on some of the details of what’s coming.

One of the decisions we made for GNOME 3 in terms of identity, was embracing Dave Crossland’s Cantarell and its open source pedigree and making the typeface our own. So far I have only been humbly shaping minor aspects of the typeface, but a long standing issue has been left long untouched, support for Cyrillic. Typeface design is certainly going outside my comfort zone. Luckily most of the glyphs can be dealt with by borrowing from their latin counterparts. The major part of the work involved (and will involve) some shape tweaks, metrics and hinting. Again, the bold weight poses bigger challenges at small sizes, which is our main focus.

As you can see, there’s still some tweaking left to do on the shapes and hints before rolling out 0.0.9, but those not intimidated by jhbuild, please give it a go so you can help me identify issues that aren’t apprent to me. Another set Cantarell needs to support is Greek, as it’s stylistictically required to keep close to the Latin set.

Last year I bought a Wacom Bamboo tablet to enjoy my free time studying some digital art with Krita and MyPaint. I lent it to my girlfriend for a few months after 2011 Christmas so she could have some fun too. Angela was here in Natal last week (while the Lakademy was happening in Porto Alegre, south of Brazil ) and she brought it back. I askd her to bring it to me so I could use it while I am working in my GSoC project.

just a test i made when Krita 2.4 was still in Alpha 3

It takes some time to get used to this kind of input device but after that it's really fun to do things with it. I really love drawing, but the reason why I bought a tablet was that my  painting skills it's quite low. I get jealous very easily from other artists works.
Anyway, another point: Angela bought my Qt4 book too, since I had left it in Teresina after I moved to Natal.

I am not a KDE (not even a Qt ) experienced programmer, so the book will help a lot in some things I am doing. For instance, I corrected some points in my granular particles simulation and now I have some right values in it's output. Although some errors persists, I got some key values right. It's just some numbers in a text file, but as soon I eliminate some Batman lyrics (NaNs are one of my nightmares), the next step it's to pass the generated values to a sequence of QImages and see if the particles got the right pixels and the right movements.

a speed painting Angela made with my wacom

As I said in previous posts, this project it's not a easy one. It requires a real-time approach to a not so common particle type. The simulation I did have some serious performance drawbacks. For just a few particles (200 particles in the data set randomly initialized and distributed in a euclidean plane of size 100x100 units) the simulation takes almost 3 minutes to run 1000 steps, with a few wrong outputs !! It's a really bad result.

After that, I gathered a handfull of books related to the topic. Physics and engineering are the fundamentals, but a real-time approach it's the more important feature in the project. I got a book with my university advicer about real-time collision detection in the hope that it will help me do a better job in this simulation.

Real-time collisions, linear algebra, engineering math and Qt/C++ : the tools for the job

Another point is that I'm thinking of trying to see the actual state of it using a OpenCL approach. I have access to a relative good computer in the university: a i3 intel processor with 4Gb of RAM with a NVidia graphics board. With that, what need to be done it's some self-training in this tecnology. I never coded in OpenCL before and the talk around here is that it's really hard. I check it out with a few OpenCL tutorials and I have to agree with the guys: it's really tough. A simple hello world pass through all kinds of concepts, from context creation, through devices association to kernel programming. Fortunately, I found a few books about it too.

Anyway, if you want to check it out the actual state of my simulation, the repository is hosted in my gitorious account. I did not allowed merge requests since the code it's quite unstable, but it's well commented and have some references if you want to understand it better. I'm already writting another post with the theory behind the simulation, doing a more extensive and well detailed explanation of the concepts (some few drawings and formulas for our enlightment :)

Until next round!

This is a new fluxbox theme I made, with matching gtk3 and qtcurve themes. Download from http://yorik.uncreated.net/scripts/themes/whiteaway.zip

Fedora 17′s grub2 screen won’t be the ugly black and white thing you saw in Fedora 16. The reason for the ugliness in Fedora 16′s grub splash is that it was the first release we used grub2 and there were some missing files that prevented the theme from working at all. We punted on it because grub’s splash is not shown by default and we had higher-priority issues to work on for Fedora 16.

Spot and Peter Jones figured out how to get grub2 theming to work properly for Fedora 17 so we have this design now, put together as we hashed it out on the Fedora design team list. It’s using the background from Alexander Smirnov’s excellent fireworks design; the menu box is slightly modified from the grub2 default shipped theme (called ‘starfield.’)

I made a video showing it as well, but it’s shaky and nothing amazing. One thing visible in the video though – there’s a quick flicker before the graphical boot menu comes up, and after rebooting multiple times to try to read it Spot figured out it says something about a missing en.mo.gz locale file. If you have any ideas on how we can fix this issue, please let me know

Anyway, when Fedora 17 comes out, if you opt-in to displaying grub you’ll have something nicer to look at.

A few days ago, while I was away on LGM, Silvio Heinrich (a cool coder -and- painter from the Krita team) added the new Dulling mode to his “Color smudge” engine.
So it’s now possible, in the “Smudge Rate” properties panel of this brush engine, to choose between “Smearing” or “Dulling” Smudge modes.
“Smearing” is the old behavior (morel like a classic smudge)
“Dulling” is the new mode, doing color mix similar to mypaint or other famous painting softwares.

This is a very good news, so I’ve already added 3 presets in the default pack using this wonderful feature.

Here is a screenshot showing a quick flower painted mostly with this engine (except the light effect at the center);
Also you can see the added presets, which are the “purple strokes” ones.

Localisation/Internationalization

The simple difference between an “s” and a “z” is a small but vital representation of the theme for issue 2.1 of Libre Graphics magazine. While the two letters sound the same when used in words like “localisation” and “internationalization,” the cultural baggage attached to them differs. They indicate the way small regional differences are played out, the way choices are made on national and regional levels, for reasons of culture, heritage or simply backlash.

In software, localisation and internationalisation go hand in hand, with internationalisation forming the framework into which localisation is slotted. Creating a piece of software representing a notional no-place allows customisation, serving very real some-places. In technology, art, design and everyday life, we see countless examples of artefacts walking the line between localisation and internationalisation. From the no-place, wordless, pictorial instructions for assembling flat-pack furniture to the clothing hang tag written in six languages, we find different tactics for coping with our small world.

We’re looking for work, both visual and textual, exploring issues of regionalisation, localisation, internationalisation and globalisation. Whether it’s the cultural differences in the significance of colour, or the unique problems of non-latin type, we want to hear about and see it. We invite submissions for articles, showcases, interviews and anything else you might suggest. Proposals for submissions (no need to send us the completed work right away) can be sent to submissions@libregraphicsmag.com. The deadline for submissions is May 31, 2012.

Localisation/Internationalization is the first issue in volume two of Libre Graphics magazine. Libre Graphics magazine is a print publication devoted to showcasing and promoting work created with Free/Libre Open Source Software. We accept work about or including artistic practices which integrate Free, Libre and Open software, standards, methods and licenses.

The LGM 2012 is over. After one week of hard working the LGMers are traveling home with lot of new ideas which will keep them busy for the next months. (If you find one wandering around in the Metalab, please send him/her home!)
In the next days we will publish a report with more details about what happened in Vienna: stay tuned!
Just one more thing for tonight: the 50+ people who you see in the group picture and who were at the final talk, decided by acclamation to put the next LGM in the hands of Marcos and Femke: see you next year in Madrid!

OK, I’m back from LGM and happy to announce that we have all keyframes for the Demo finished!

Yes, that’s it, the hardest phase is over! *clap* *clap* *clap*  ^___^

Some statistics: In 62 days Nikolay made 154 keyframe images. It took 343 workhours for him and 184 workhours from my side (I was doing basic drafts and corrections – more on that here – plus administrative work).

You can find all results on the wiki.

Our fundraising campaign is failed, but we’ve raised $641 out of $2200 – and it’s not a plain zero, you know. ^_^ I’ve repaid all full promised amount to Nikolay by adding my personal funds so we have this phase closed in all means. Now it’s good time to ask a question

What’s next?

The current status of the project is that we have no enough funds to proceed with the next phase (Vectorization and Tweening). Yes, the campaign is failed. But. It’s not an amount of money what is valuable for us, but the people who really care about the project. The campaign shown that there ARE such people. And we just can’t disappoint their expectations. So what we want to do is to stick with planned schedule and try to release the Demo in November by “no-matter-what”.

Right now we want to take some break to have a breath and charge our batteries. In May we plan to dedicate our time for doing some commercial animation projects to get a basic funds for the next stage. Maybe we will run fundraising for the next phase as well, I’m not sure about that yet, but it’s clear that we need to have some basic amount to cover the expenses. In terms of creative demands, the “Vectorization and Tweening” phase is less hard than the “Keyframes drawing”, but it requires more work and resources. Well, it’s hard to explain such things… ^_^”  Ideally, as we will depend much on Synfig Studio on this phase, I also would like  to have one developer seat sponsored as well. *waves to Carlos*

So, we’re at recharging. Please don’t be surprised if we will be a little bit silent this month.  If everything turn out well, we will get back at full throttle to the Morevna Project in 9th of June. So, stay tuned, don’t bore to us! And thank you to all who supported us during the last two months! We love you! Cheers!

Here is a little tutorial to help you install the powerful Oyranos Color-Management-System on Kubuntu 12.04
(at least on a KDE/Plasma desktop, as the Kolor-manager simple interface is on the KDE systemsettings panel, I’m not sure how to use it on other desktops).

So first thing to do is to add the getdeb repository to your system, as the latest Oyranos core is available from there.
- download the GetDeb repository installer , then double-click on it and install.
-in a terminal, run:
sudo apt-get update
sudo apt-get install build-essential git oyranos liboyranos-dev oyranos-icc oyranos-doc kdelibs5-dev xcalib libyajl-dev

Now that oyranos core is installed, you’ll want to use kolor-manager, which is a simple interface to setup oyranos easily.
Unfortunately, it’s not packaged yet on get-deb, so you’ll have to build it.

You’ll have to download the sources on a folder called, for example, sources/ ,
then create a build folder in it to make the build,
then install in another separate folder, called for example kdetest.
All this in your home, so it’s not mixed with system packages.

So to do all this, in the terminal:

mkdir sources
cd sources
git clone git://anongit.kde.org/kolor-manager.git
cd kolor-manager
mkdir build
cd build/
cmake .. -DCMAKE_INSTALL_PREFIX=home/USERNAME/kdetest
make
make install

Then in .profile (hidden file in your home folder, if it doesn’t exist already create one), add this line:
export KDEDIRS=$KDEDIRS:/home/USERNAME/kdetest
In case if you need several of these paths (like here I’ve another one for calligra/krita), separate them with : like this:
export KDEDIRS=$KDEDIRS:/home/USERNAME/kde4/inst:/home/USERNAME/kdetest
(of course replace USERNAME with your session name)

Now Restart your session, and you’ll can find the color management in the systemsettings panel

Then in the parameters, you can define default profiles for all kinds of colorspaces.
I leave you the fun to discover all the features inside… Enjoy!

(Note: Like always when you build software, it depends on libraries installed on your system. I’ve tried to list all those needed in the apt-get install line, but I may have missed some as I already built several other softwares here… So if you have an issue at some point, feel free to send me an email using the contact form, with the output of the terminal pasted in it, so I can identify any missing libraries or other issues and fix this tutorial.)

(Note2: If you only want the Oyranos packages and no other update from get-deb, you can disable the repository after installing it so it doesn’t bring unwanted updates next time you’ll update your system. This is easy to do using Muon or Synaptic package managers for example…)

Check the blog for live streams, pictures and reports from the film studio crew. Open Set Filming -...

I spent 5 days in Vienna, participating at the Libre Graphics Meeting 2012. It is conference full of developers, artists and users connected to open-source tools. You can meet there MyPaint, Gimp, Inkscape or Scribus developers. At least I did! Or you can meet some independent developers who created cool custom open-source tools and very nice people interested in design.

Besides the regular program we visited Metalab. It’s part of the Hackerspace scene. It is a great place for hackers to meet and build stuff. Not just code, but also hardware, photography or food. Metalab is full of interesting geeky stuff like laser cutter, 3D printer or game consoles since the age of Atari! Pity that something like that is not close enough to me. I had very nice conversions with LGM friends there. Let’s review the conference from my point of view. But first I would like to thank KDE for sponsoring me the travel expenses!

TL;DR: Very interesting stuff everywhere.

First day of the conference was full of color management talks. Richard Hughes talked about ColorHug and colord. ColorHug is interesting piece of open source hardware: display colorimeter. It allows you to calibrate your screen for accurate color matching. More information on the official website.

Kai-Uwe Behrmann talked about OpenICC and Oyranos. Chris Lilley about color management in SVG2. I don’t understand this topics, but I read very good article about it recently, so if you are confused about it, go ahead and read it. It is important topic, if you print photos or you want to calibrate two monitors to show the colors in the same visual way.

Second half of the day started with lovely Russian Valek Filippov. He was talking about re-lab project which is about reverse engineering of the proprietary formats for the compatibility reasons. I used oletoy from this project back then when I was working on Calligra. For investigating Excel files it was really great and helped me a lot! Valek’s presentation was followed by Fridrich Strba (who comes from Slovakia by the way, go Slovakia! :-]), he talked about LibreOffice and support of the proprietary graphics formats in LO.

Igor Novikov presented the restart of the sK1 Project. Next presentation by Behdad Esfahbod was very interesting, he was talking about rendering of the text on the GPU. With this approach you can free CPU from performance CPU-consuming tasks like rasterization. It’s way to go on low-performance devices like smart phones.

Ramon Miranda is involved in Gimp, MyPaint and Krita as the artist and the creator of brush presets. He is famous for his GIMP Paint Studio. His presentation was important for me as he was talking about painting and that is always interesting to me. His background lays in traditional art and he is exploring digital painting. And he is exploring it very successfully producing nice art. Very talented painter and nice man.  Martin Renold (Maxy), original creator, developer, maintainer gave talk about “Predictive painting” in MyPaint. I could not miss it. I always like to talk with Martin about painting algorithms.

Tom Lechner talked about lovely tool, his Laidout contains many fancy tools not available in other packages. I liked that you could put pictures on curve for example. HarfBuzz, the free text shaping engine by Behdad Esfahbod catched my attention too.

From the “An awesome FLOSS design collaboration work-flow” by Máirín Duffy and Emily Dirsh, Sparkleshare caught my attention. It’s a git-backed, dropbox-like system that automatically checks in and pushes files to a shared git repository.

On Friday I started with Powerstroke in Inkscape. Very nice effects were demoed. You need Inkscape trunk for Powerstroke to be able to play with it. We might take some inspiration either for Karbon or maybe even for some vector brush engine for Krita.

Then train of GIMP related talks started. Peter Sikking, interaction design guru, and Kate Price talked about text handling in GIMP. OpenCL in Gegl and GIMP by Victor Oliveira: Mesa is implementing OpenCL support! NVidia, AMD and Intel provide proprietary solutions so far. Øyvind Kolås a.k.a. pippin with some Gimp developer mitch talked about Gegl integration in GIMP. Recently a huge step was made towards integrating this very fast, important back-end (e.g. 16 bit per channel) for pixel buffers. Many pictures with goats were presented.

Tube Open Movie by Bassam Kurdali was actually remote presentation. Bassam sent video to organizers and it was projected for the whole audience. Then he answered some questions through #lgm IRC channel.

Saturday started with our presentation about Krita. Together with Timothee Giet, a.k.a. Animtim, we presented some new workflow improvements in Krita. Curve brush, multi-hand and mirror painting caught some attention too. Tom Lechner had nice suggestion for multi-hand tool: Escher-like strokes. Then we showed some piece of art done by Krita. Timothee Giet then continued with his talk about animation with Synfig studio.

Then I attended Krita workshop about workflow to create illustrations and comics with Krita where Timothee showed Krita in the real-world usecase. It was very well attended workshop, around 22 people there, full room of people. We found some problems with Krita 2.4 in Fedora package. Now I realize that it was probably disabled feature shortly before release and already available in master (full-screen canvas with ‘Tab’ key). I use Fedora, but I never use the packages, because you can’t have installed both. Krita 2.3 is by the way very old. Please refrain from using it. Krita 2.3 misses so many work and features, many of those that Timothee presented in his workflow. You can get Krita 2.4 for Fedora 16 in testing KDE repo. Few problems found at the workshop: old 2.3 version, disabled feature in 2.4 and brush editor is too big for netbooks

Closing talk by Louis Desjardins. It was decided that the next LGM is going to be in Madrid, Spain. Handshakes with familiar faces, visiting Vienna and travel back home. It was great time to be there.

The event was covered by blogposts and ideas from talks were picked on twitter/identi.ca. Here are few I found:

Ideas from talks I
Ideas from talks II
Nicu Bunu
Timothee a.k.a. Animtim

Hello Fellows!

It's kind of late, since the result came this Monday, but I want to notify that my proposal was accepted for this year Google Summer of Code! :D




Krita have a lot of awesome brushes, whose is fun to play with (checkout this KDE forum thread to see the works  that artists have done using it), so I wanted to do something that could be a nice new feature. Then, I proposed a sandpainting brush for Krita.







After I saw some videos of this type of art, I was a bit lost of how I could accomplish such a beautiful effect on a canvas. I searched through the web about similar effects and particle system in game engines is the closest concept. However, most particle systems do not deal with the singularities of granular particle system. Sometimes sand acts like fluids and sometimes acts like a deformable solid. So sand simulation it's not very similar to particle systems used to simulate fluids like water.

But eventually, I found the exact concept that I was looking for :  computational granular dynamics, used in the simulations and predictions of avalanches, land slides and general powder technology. So, after some papers and books chapters I got the idea to develop the project: simulate sand particles usind a discrete element modelling based particle layer. It's not a easy task, since the real time aspect of the sand spreading movement it's crucial, but I believe that with some problem relaxations I could make this work in the due time. :)

Soon enough I will show some results in simulations that I've been doing. Not much visual results but it's something.

Until next time!

This last thursday Boudwewijn schedule a skype chat group to present the main concepts of the Krita development. It was really nice, since a more dynamic interaction was made with the students. It answered some doubts I had and important features was explained. It covered from the KDE and Calligra foundation of Krita to dockers and resource management of the software.




I am posting here a few notes about what I got from it and some notes on how I imagine some of these will affect directly in my project. If any concept that I wrote here is wrong, please, leave a comment correcting me. This would be really helpful and more than welcome!

Color Management

I am familiar with color models concept, but not so familiar with color spaces. This was a good point in the presentation. It clarified to me that I do not have to worry about how to deal with these spaces since the color management libraries take care of it. Although I have some interest to understand how to manage colors, I think I will have to leave that for another time.

Tiles

Krita tiles was a really new concept to me. After you talk about the advantages of divide the pixels in groups, it makes sense and we question ourselves why we didn't though about that before. Dmitry posted in the mail group a nice article about the Krita tiles. I believe I have to take some time to discuss this point with him. In my project I'll deal with a considerable amount of particles so a full understaning on this framework will garantee a better performance of the brush. In one of the books I'm reading, a improvement in the grain interactions performance is done with the division of the space in tiles, although is suggested to divide the 2D region or in uniform Voronoi tiles or in a hexagonal grid. I think that in a general way, the effects are the same for the application, so the tile form doesn't play a mean role.

Data Structure and Image composition

This was one of the trickiest definitions of the presentation. In a program like Krita, which have a big amount of processing and operations done at pixels, it's expected that we should have a not so straightforward data structure.

The base class of the image components is the KisBaseNode class. It takes care of other nodes, layers and selections of the image. However this class do not have anything to do with its peers. For that, we use a KisNode, which is the parent class for Layers and Masks. Along with that, every node has a representation of it, which we call the Projection of that node. It's a rendered result of the layer, with the processed data applied. For the composition of the final image result, a multithread structure is behind each node. Then to produce the result in the parent node, the setDirty method will pass through all the way up to it.

I don't know if in the future I will need to modify or create a new layer type since the feeling of live sandpainting would need a lot of updates in the canvas. I asked that in the chat group and probably I will not need to do it. For instance, the closest feature in Krita that deals with this kind of painting is the Deform Brush. It modifies the closest pixels several times and updates the canvas after each mouse movement, so it's more or less what I wanted.

Canvas and Tool Handling

The canvas take care of the user interaction through mouse, keyboard and tablet, paints the decorations and the visible image results. It has two implementations: one based on OpenGL and another based on QPainter. I had to look directly on the code to understand this better, but i think the main reason to have two implementations is that if the user have OpenGL on his/her computer, a better perfomance widget can be used. Otherwise, the QPainter based canvas will be used. Both classes inherit from KisAbstractCanvasWidget, so both has to have the same event handling.

When we modify something with a tool, the canvas have a Tool Proxy, which manages the current tool. So, when we change from some tool to another, the native events are mapped to the newly chosen tool. Then, when the tool does a operation, it requires a canvas update so the user can get the result.

Painting

I didn't have much trouble to understand this point. Pentalis helped me a lot in this part. I even made a simple paintop modifying one of the paintops plugins in the source code. The Chalk Brush have a simple implementation and it was easy to understand the code and modify it. Most of my doubts in doing it was in the underlying structure, like how paint devices and layers worked together, but the presentation answered most of it.

Filters, Resources, Imports and Exports

These features wasn't so hard to understand. Filters have the usual concept and is applyed in a multi-threaded stateless way. It is implemented as plugins in Krita. Imports and Exports use the KoFilter class as base of the implementation and invokes KoFilterChain to do the sequence of operations to complete the conversions. Resources are managed using KoResourceServer and manages resources of one type at a time. To represent the resource itself we use a KoResource as base class.

That's it

This was what I got from the presentation. I have some notes about other questions that came after, but I believe that I have to write it with more visual details to a full undestanding about what I'm working on. My particle simulation didn't work as I was expecting and I have to spend some time debugging it. Pentalis suggested that, after the simulation is working, I write the positions updates in QImages so we could have the visual feel of the particles moving. After that, I have to formulate how I will do this visual feeling in Krita, but I believe that with this brief background I will be able to do it.

See you later!

Back from the Libre Graphics Meeting, it’s been a crazy week with tons of cool people.
The event was happening in parallel with the Linuxwochen one in the FH Technikum, so the place was really filled with cool geeks, lots of good vibes in the place… :.)

Very interesting talks and workshops:
°Regarding color management I now want to get a ColorHug device, and I’m very happy and gratful to Kai-Uwe for helping me on getting his powerful Oyranos CMS software working right on Kubuntu 12.04. Complete tutorial to come next blog post

°Ricardo and Ana made a great presentation on fonts improvements for the web using some magic scripts, I’ll have to give a try and experiment with this.
And I’ve been happy they brought some Libre Graphics Magazine 1.3 and latest 1.4, so I could complete my collection

°Ramon Miranda made a nice show with his impressing painting work, showing the power inside the tools we have in free software, and giving his vision for the future of floss painting tools.. So cool I finally met him in real life, and we spent a lot of time talking about digital paiting tools and other things… Lot of fun!

°Martin Renold made an interesting talk about “predictable painting” related to his work on the mypaint brush, as if you don’t know he’s the original creator of mypaint… Now I see where the original coolness of mypaint comes from… With Jon Nordby (another important mypaint coder) also being there this year again, that was more representation of the mypaint team than last year and I’m sure it’ll help them to get things impoving fast in their cool painting software… Very cool people

°Tom Lechner made a talk about his software Laidout, an experimental publishing tool that is very interesting, I should dig in when I’ve some time… As his soft, his artistic work is crazy, very good work. Much respect! So I’ve been glad to meet him this year again.

°The Scribus Team had an official workshop and some ponctual group-talk about how to improve scribus… Things are likely to evolve quicker than before, I’ve good hopes from what I’ve heard. Definitely the free software tool for traditional publishing work

°Mairin Duffy and Emily Dirsh made some clever work on collaboration tools for free minded designers ;.)
Very interesting talk, I’m sure I’ll use these tools at some point…
A few interesting links to explore the subject HERE, HERE and HERE.

°Johan Engelen presented his work on Powerstroke, that is an awesome line width system for the vector graphics editor Inkscape. This kind of system already existed since a long time in synfig studio in a more simple way (but since a recent update came almost like this powerstroke feature with the “advanced outlines”), so I see how this will improve greatly the possibilities to use inkscape and synfig together when the conversion will be possible in the .sifz export from inkscape… Awesome things to come!

°CONGRATS TO THE GIMP TEAM for the 2.8 release, that happened right during LGM! The Goats are invading the place, and things are getting awesome with EXR support, opencl acceleration, gimp is here to stay the best floss image manipulation software … Also GEGL power is jumping beyond the barriers of Gimp and is already invading mypaint, and even some could go in exotic lands of Synfig, and who knows, maybe some could reach to pass the wall of Krita (as pippin told me, to make it short, that it can now be used as a kind of bindings without replacing another current system)

°Femke Snelting and Marcos Garcia talked about their activities for the Libre Graphics Reasearch Units that is a collaboration between four european Media-labs associations involved in free graphics artistic creation culture. It’s good to see such serious work on creating structures to develop such things. And of course this can be a big help to other libre graphics projects.

°A surprising “Remote talk” of Bassam Kurdali, director of the “Tube” Open Movie using Blender 3D for animation in a distributed pipeline. Crazy demo shots of rendering, making-of… at least one representation of Blender at LGM for this year, even if remote, is better than nothing. video available here.

And many other good talks, sorry for those I missed… This year’s program was so huge it was anyway impossible for 1 person to see everything :.D

Then the last day morning was busy for me:
-It started with the collaborative talk I did with Lukas Tvrdy, where he presented what happened since last year in Krita while I illustrated his words showing the features on the software.
-I made a talk/demo about synfig studio to introduce the basic history, concept and features. I prepared a (too big) demo that I had to fast-forward a bit, so I’ll convert it in an online tutorial soon.
-Two more talks related to synfig studio: first Konstantin Dmitriev (aka Zelgadis) presented the Morevna project and more precisely the Remake tool, that is a valuable little software that make workflow on a big-scaled project using Synfig and/or blender (and/or any software having a CLI available for rendering) much easier.
Third synfig studio talk was by Diego (aka eldruin), a coder from synfig team, presenting the possibilities to enhance synfig studio in the current state, sending a message to all potentially interested coders to join the fun!
-Then I made the Krita workshop about drawing comics-style illustration. For me it’s been a success as the room was filled, and mostly with great people whose I love the work, so it was an honor for me to have so much attention. We discovered some issues in Krita 2.4 packaging on Fedora that’s missing some features… But globally everyone learned a lot and was happy… It last almost 2 hours… mission complete!

Also many other surprises, like discovering the Vienna metalab, an impressive hackerspace where the community is really great and friendly. Knowledge-sharing power! Thanks to Pepi for the tour and for introducing me to Kallaballa, who showed me his work on a hack to make Gimp play sound/noise/music, called SoundFumble (thank you for uploading it so fast! ). It was so impressive that he managed to have a quick demo/live show with it at the LGM before the end. Everyone there was amazed

Too bad the Tupi talk was cancelled, I didn’t have news about this but I’m a little sad the Tupi maintainer couldn’t make it happen…

Now I’m waiting for the cool photos taken there to spread all over the web. Too bad almost all the talks have not been recorded, but I’m lucky there was a video camera running the saturday morning, so my talks should be online some day soon.

Again many thanks to everyone who came to participate in any way and made this wonderful event happen…

See you next year… (in Madrid so !?!)

I've mostly been enormously happy with my upgrade from my old Archos 5 to the Samsung Galaxy Player 5.0. The Galaxy does everything I always wanted the Archos to do, all those things the Archos should have done but couldn't because of its buggy and unsupported Android 1.6.

That is, I've been happy with everything except one thing: my birdsong app no longer worked.

I have a little HTML app based on my "tweet" python script which lets you choose from a list of birdsong MP3 files. (The actual MP3 files are ripped from the excellent 4-CD Stokes Field Guide to Western Bird Songs set.) The HTML app matches bird names as you type in characters. (If you're curious, an earlier test version is at tweet.html.)

On the Archos, I ran that under my WebClient Android app (I had to modify the HTML to add a keyboard, since in Android 1.6 the soft keyboard doesn't work in WebView text fields). I chose a bird, and WebView passed off the MP3 file to the Archos' built-in audio player. Worked great.

On the Samsung Galaxy, no such luck. Apparently Samsung's built-in media player can only play files it has indexed itself. If you try to use it to play an arbitrary file, say, "Song_Sparrow.mp3", it will say: unknown file type. No matter that the file ends in .mp3 ... and no matter that I've called intent.setDataAndType(Uri.parse(url), "audio/mpeg"); ... and no matter that the file is sitting on the SD cad and has in fact been indexed already by the media player. You didn't navigate to it via the media player's UI, so it refuses to play it.

I haven't been able to come up with an answer to how to make Samsung's media player more flexible, and I was just starting a search for alternate Android MP3 player apps, when I ran across Play mp3 in SD Card, using Android's MediaPlayer and Error creating MediaPlayer with Uri or file in assets which gave me the solution. Instead of using an intent and letting WebView call up a music application, you can use an Android MediaPlayer to play your file directly.

Here's what the code looks like, inside setWebViewClient() which is itself inside onCreate():

            @Override
            public boolean shouldOverrideUrlLoading(WebView view, String url) {
                if (url.endsWith(".mp3")) {
                    MediaPlayer mediaPlayer = new MediaPlayer();
                    try {
                        mediaPlayer.setDataSource(getApplicationContext(), Uri.parse(url));
                        mediaPlayer.prepare();
                        mediaPlayer.start();
                    }
                    catch (IllegalArgumentException e) { showMessage("Illegal argument exception on " + url); }
                    catch (IllegalStateException e) { showMessage("Illegal State exception on " + url); }
                    catch (IOException e) { showMessage("I/O exception on " + url); }
                }
            }

showMessage() is my little wrapper that pops up an error message dialog. Of course, you can handle other types, not just files ending in .mp3.

And now I can take the Galaxy out on a birdwalk and use it to help me identify bird songs.

Calling all students (18+), recent graduates, and professionals wanting to ply their 3D skills in libre software:

Join Bassam and the URCHN crew this summer on the Tube Open Movie production, hosted by the Bit Films animation incubator at Hampshire College, Massachusetts. Helmed by Chris Perry, formerly of Pixar and Rhythm & Hues, the program draws together a lot of talent, so although the internships are unpaid, it promises to be a very stimulating and fruitful space. These positions offer an opportunity to improve your skills, develop your reel, and make useful contacts in the industry. There is a possibility that housing can be offered.

The official internship period runs from Monday June 4, 2012 through Friday August 31, 2012. Applications are due (via email) no later than Thursday May 17, 2012 at 5pm (EDT). We understand that this may be short lead time for those needing to make visa and travel arrangements. Because the project is ongoing, the internship period is flexible; if in doubt, apply!

Although it may not provide as immersive an experience, we are open to considering very strong applicants to a remote internship. Remote interns would join the already global team using web-based project management software, SVN, video calls and IRC.

Please read carefully the open positions announcement and FAQ! Have more questions? Email us: internships@bitfilms.com

At Libre Graphics magazine, we try very hard to support the free expression of creativity by just about everyone. We fundamentally believe that one of the major tools of creativity is the repurposing of older work, rebuilding and modifying it to make it new, to say different things. Not only is repurposing important, but copying and modifying are ways of learning. Countless people have learned to draw by copying characters from cartoons or comics.

Now, because so much visual creation has moved to the realm of the digital, there are so many more opportunities to learn and work from the creative products of others. That’s why we make our source materials available, and why we show our working process through the activity stream of our Git repository. We believe that having unrestricted access to both the output and the source of a creative work is vital.

That access is one of our major reasons for being against Digital Rights Management. DRM, in many of its uses, does a lot to prevent the sharing and opening of digital works. At turns, it prevents people from viewing works on multiple platforms, from cutting up and modifying, from doing a lot of things that digital platforms are especially good at. It prevents us from doing things that, depending on which country we live in, we have the legal right to do. DRM puts technically-enforced locks on your ability to use and enjoy digital works.

We have our own reasons for supporting the Day Against DRM. The reasons above, about creativity, transparency and learning from each other. To learn about plenty of other reasons, and to take action, visit DayAgainstDRM.org.

Day Against DRM is an initiative from our friends at the Free Software Foundation, who do all kinds of other excellent work.

Hi everyone.

This is my first pre-GSoC update for the Krita color-managed printing project.  Although the official start of Google Summer of Code is not until May 22, it is nevertheless a good idea to get the ball rolling early.

Last week I have been polishing up the libCmpx code and improving its color-management abstraction.  The original prototype library (XCPD) lacked proper abstraction in its code, and was a little difficult to read and understand. The recent structure change in libCmpx should make things easier for me to work during the summer, as well as providing a cleaner interface for when the library is eventually implemented in Krita.

In a few more days, I will post on my blog and on ColourWiki an updated diagram of the libCmpx structure.  In addition, I will begin creating a new test suite for libCmpx in order to make sure that the library is up to snuff prior to integration.

I will be picking up the pace in the coming weeks and will provide much more substantial updates – May 12 will be the first day that I am able to work full-time on the project.

-Joe

I’m at LGM this year, and so far it’s rocking pretty hard. The number one question people have asked is “how do I get the screen profile for a window“. I figured this should be easy to get using colord, and then spent a few minutes working on some proof-of-concept code. This ballooned into a couple of hours doing it properly asynchronously and making it work correctly on multihead, and the result was a few hundred lines of complicated code with quite a few exit points. I don’t want people to add 300 lines of boilerplate to their project just to map a GtkWindow to a .icc filename.

So I’m now shipping an additional optional colord-gtk helper library in colord that allow you to use one async function to get the profile a given widget should use. There’s a demo available here.

The alternative is of course to read the X11 _ICC_PROFILE atom, but that does not support multi-head, and really won’t work when we move to Wayland. It’s also not a lot of fun grabbing lots of binary data from the xserver in a GUI program. In the long term future we’ll be doing full screen color management in shaders, with full toolkit support using Wayland, but that’s a few years from being reality. If you’ve got any ideas or have comments about the API, let us know on the mailing list. Thanks.

I bought a Miata yesterday! My new baby. It's a 2000, in a lovely color Mazda calls "twilight blue mica". (You can see Miata pictures here, if you're so inclined.)

I'd forgotten how much nicer sports cars are to drive. I retired my last X1/9 more than a year ago, and have been driving mushy street vehicles since then. The Miata surprises me every time I get into it with its immediacy -- throttle, brake, steering, everything happens now.

It does have some used-car glitches that I need to sort out (some of them maybe even severe), but in general it's a great car: in stock trim it handles a lot like the street-prepared X1/9, even on crappy Kumho tires. Of course, that could be new owner infatuation talking. Ask me again in a few months. :-)

But really what I wanted to write about was the extremely strange warning sticker that came plastered to the driver's side window. I didn't really look at the sticker until the second day after I drove the car home, and then did a double-take. It says:

While use of all seat belts reduce the chance of ejection, failure to install and use shoulder harnesses with lap belts can result in serious or fatal injuries in some crashes. Lap-only belts increase the chance of head and neck injury by allowing the upper torso to move unrestrained in a crash and increase the chance of spinal column and abdominal injuries by concentrating excessive force on the lower torso. Because children carry a disproportionate amount of body weight above the waist, they are more likely to sustain those injuries. Shoulder harnesses may be available that can be retrofitted in this vehicle. For more information call the Auto Safety Hotline at 1-800-424-9393.

If you look at the photo I took of the sticker, note the shoulder belt anchor at the right edge of the frame. It's a normal stock shoulder belt, just like you'll find in any car -- this is a 2000 model, for crying out loud, not a 1970.

A web search on the error message led me to Section 27314.5 of the California Vehicle Code, which states that

27314.5. (a) (1) Subject to paragraph (3), no dealer shall sell or offer for sale any used passenger vehicle of a model year of 1972 to 1990, inclusive, unless there is affixed to the window of the left front door or, if there is no window, to another suitable location so that it may be seen and read by a person standing outside the vehicle at that location, a notice, printed in 14-point type, which reads as follows:

... followed by the text on my sticker. It goes on:

(2) The notice shall remain affixed to the vehicle pursuant to paragraph (1) at all times that the vehicle is for sale.

So the dealer must have put this sticker on. But why? Reading on:

(3) The notice is not required to be affixed to any vehicle equipped with both a lap belt and a shoulder harness for the driver and one passenger in the front seat of the vehicle and for at least two passengers in the rear seat of the vehicle.

The dealer must not have read as far as paragraph (3).

I also found that, despite the fact that the DMV's website still links to the page I linked above, that statute was in the process of being repealed by CA Assembly Bill 2679. Except that if you click on "Read latest draft", apparently they changed their minds again in the latest version of AB 2679 and are now going to keep the warning in.

Maybe instead of leaving it unchanged or striking it, they should change it to make it clearer that it only applies to cars without shoulder harnesses installed ... if there are any such cars. Haven't shoulder harnesses been mandatory in US cars since the early 1970s? Wikipedia says they've been mandatory in the front seat since 1968 ... but the citation they give for that goes to a page that no longer exists, so that may be off by a few years.

In any case, anyone buying a car so old it doesn't have a shoulder harness and only "may" be able to have one retrofitted to it probably understands there may be some safety issues in a 40-year-old car, and doesn't need a warning sticker.

This morning at 9:00 the LGM has started!
Everybody is here, many took the time to enjoy some sightseeing under the hot Austrian sun and the first evening meetings have already happened at the Metalab and in our flats.
Have a nice Libre Graphics Meeting!

Anyone who has looked at a Scribus preferences file (scribus.rc) will be aware that the sheer amount of settings is daunting. There’s a C++ file named prefsstructs.h that defines on 470 lines of code 29 data structures too hold various settings. And these are just dumb structs, without any code to read/write to XML (or even getters/setters or default values or scripter support). So how can we clean up this mess?

Take for example this struct and its corresponding section in the scribus.rc file:

//Document Setup
struct DocumentSetupPrefs
{
    QString pageSize; //! Default page size of a document
    int pageOrientation; //! Default orientation of the page
    double pageWidth; //! Width of a page
    double pageHeight; //! Height of a page
    MarginStruct margins; //! Margins for a page
    MarginStruct bleeds; //! Bleeds for a page
    int marginPreset; //! Use a preset ratio margin setup
    int pagePositioning; //! Show pages in 1,2,3,4 pages side by side on screen
    int docUnitIndex; //! The index of the default unit
    bool AutoSave;
    int AutoSaveTime;
    bool saveCompressed;
};

and

<DocumentSetup UnitIndex="0" MarginBottom="40.000" PageHeight="841.890"
    PageSize="A4" MarginLeft="40.000" PageOrientation="0"
    PageWidth="595.276" AutoSave="1" MarginTop="40.000"
    MarginPreset="0" BleedBottom="0.000" PagePositioning="0"
    BleedRight="0.000" AutoSaveTime="600000" BleedTop="0.000"
    MarginRight="40.000" SaveCompressed="0" BleedLeft="0.000"/>

Now wouldn’t it be nice if you’d just define the structure of the settings and the C++ class would be generated automatically?

Defining structure with RelaxNG

My favorite language to define XML structures is RelaxNG compact. A RelaxNG definition for the DocumentSetup element might look like this:

element DocumentSetup {
      attribute PageSize { xsd:string },
      attribute AutoSave { xsd:boolean },
      attribute AutoSaveTime { xsd:integer },
      attribute BleedBottom { xsd:decimal },
      attribute BleedLeft { xsd:decimal },
      attribute BleedRight { xsd:decimal },
      attribute BleedTop { xsd:decimal },
      attribute MarginBottom { xsd:decimal },
      attribute MarginLeft { xsd:decimal },
      attribute MarginPreset { xsd:integer },
      attribute MarginRight { xsd:decimal },
      attribute MarginTop { xsd:decimal },
      attribute PageHeight { xsd:decimal },
      attribute PageOrientation { xsd:integer },
      attribute PagePositioning { xsd:integer },
      attribute PageWidth { xsd:decimal },
      attribute SaveCompressed { xsd:boolean },
      attribute UnitIndex { xsd:integer }
    }

This already has a similar structure to our C++ struct. Unfortunately for each of the MarginStructs ‘bleeds’ and ‘margins’ we have four XML attributes. There are several ways to model this with RelaxNG. I choose to represent the MarginStructs with XML elements:

element DocumentSetup {
      attribute PageSize { xsd:string },
      attribute AutoSave { xsd:boolean },
      attribute AutoSaveTime { xsd:integer },
      attribute MarginPreset { xsd:integer },
      attribute PageHeight { xsd:decimal },
      attribute PageOrientation { xsd:integer },
      attribute PagePositioning { xsd:integer },
      attribute PageWidth { xsd:decimal },
      attribute SaveCompressed { xsd:boolean },
      attribute UnitIndex { xsd:integer },
      (element Bleed {
            attribute Bottom { xsd:decimal },
            attribute Left { xsd:decimal },
            attribute Right { xsd:decimal },
            attribute Top { xsd:decimal }
      }&
      element Margin {
            attribute Bottom { xsd:decimal },
            attribute Left { xsd:decimal },
            attribute Right { xsd:decimal },
            attribute Top { xsd:decimal }
      })
    }

In RelaxNG element definitions must follow any attribute definitions. By separating the elements with ‘&’ (instead of a comma) we allow any order of those elements.

We now use a named definition for the four MarginStruct attributes:

grammar {
      MarginStructDef = (attribute Bottom { xsd:decimal },
            attribute Left { xsd:decimal },
            attribute Right { xsd:decimal },
            attribute Top { xsd:decimal }),
      DocumentSetupDef = element DocumentSetup {
            attribute PageSize { xsd:string },
            attribute AutoSave { xsd:boolean },
            attribute AutoSaveTime { xsd:integer },
            attribute MarginPreset { xsd:integer },
            attribute PageHeight { xsd:decimal },
            attribute PageOrientation { xsd:integer },
            attribute PagePositioning { xsd:integer },
            attribute PageWidth { xsd:decimal },
            attribute SaveCompressed { xsd:boolean },
            attribute UnitIndex { xsd:integer },
            (element Bleed { MarginStructDef }&
            element Margin { MarginStructDef })
      }
    }

A corresponding XML fragment might look like this:

<DocumentSetup
    AutoSave="1" AutoSaveTime="600000" SaveCompressed="0"
    PageHeight="841.890" PageWidth="595.276" MarginPreset="0"
    PageSize="A4"  PageOrientation="0" PagePositioning="0"  UnitIndex="0" >
    <Margin Left="40.000" Right="40.000" Bottom="40.000" Top="40.000" />
    <Bleed Bottom="0.000" Right="0.000" Top="0.000" Left="0.000" />
</DocumentSetup>

Annotating for automatic code generation

Starting with the RelaxNG definition a simple approach would be to create a C++ class for every element definition and a C++ member for each attribute. But let’s say we want to have more control over the code generation process. RelaxNG allows to enhance the grammar with arbitrary attributes. We’ll take advantage of that in order to define names and data types:

namespace impl = "http://www.scribus.info/RelaxNG/implementation"

grammar {
      MarginStructDef = (attribute Bottom { xsd:decimal },
            attribute Left { xsd:decimal },
            attribute Right { xsd:decimal },
            attribute Top { xsd:decimal })
      DocumentSetupDef =
            [impl:name = "DocumentSetupPrefs" impl:template = "simple-settings"]
            element DocumentSetup {
                  [impl:datatype = "QString" impl:name = "pageSize"]
                  attribute PageSize { xsd:string },
                  attribute AutoSave { xsd:boolean },
                  attribute AutoSaveTime { xsd:integer },
                  [impl:name = "marginPreset"]
                  attribute MarginPreset { xsd:integer },
                  [impl:name = "pageHeight"]
                  attribute PageHeight { xsd:decimal },
                  [impl:name = "pageOrientation"]
                  attribute PageOrientation { xsd:integer },
                  [impl:name = "pagePositioning"]
                  attribute PagePositioning { xsd:integer },
                  [impl:name = "pageWidth"]
                  attribute PageWidth { xsd:decimal },
                  [impl:name = "saveCompressed"]
                  attribute SaveCompressed { xsd:boolean },
                  [impl:name = "docUnitIndex"]
                  attribute UnitIndex { xsd:integer },
                  (
                  [impl:datatype = "MarginStruct" impl:name = "bleeds"]
                  element Bleed { MarginStructDef } &
                  [impl:datatype = "MarginStruct" impl:name = "margins"]
                  element Margin { MarginStructDef })
      }
    }

Ok, now we have a RelaxNG definition that includes all information needed for defining the DocumentSetupPrefs class and how to write it to XML. So what happens next? A nice aspect of RelaxNG compact is that it has an equivalent RelaxNG XML form.

Preparing RelaxNG for XML processing

There is a pair of powerful tools for handling RelaxNG definitions: Jang and Trang. We will use Trang to convert the above RelaxNG compact grammar to RelaxNG XML:

<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns:impl="http://www.scribus.info/RelaxNG/implementation" xmlns="ht
tp://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XML
Schema-datatypes">
   <define name="MarginStructDef">
   ...
   </define>
   <define name="DocumentSetupDef">
      <element name="DocumentSetup" impl:name="DocumentSetupPrefs"
               impl:template="simple-settings">
         <attribute name="PageSize" impl:datatype="QString"
                    impl:name="pageSize">
            <data type="string"/>
         </attribute>
         <attribute name="AutoSave">
            <data type="boolean"/>
         </attribute>
         ...
         <attribute name="UnitIndex" impl:name="docUnitIndex">
            <data type="integer"/>
         </attribute>
         <interleave>
            <element name="Bleed" impl:datatype="MarginStruct"
                     impl:name="bleeds">
               <ref name="MarginStructDef"/>
            </element>
            <element name="Margin" impl:datatype="MarginStruct"
                     impl:name="margins">
               <ref name="MarginStructDef"/>
            </element>
         </interleave>
      </element>
   </define>
</grammar>

Ok, that looks like something that can be processed easily. We just have to expand <ref> elements with their definitions and then iterate over the grammar. At first I thought about using XQuery to do this, since XQuery is cool and is ideal to parse XML. But it’s not so good in producing plain text, so I’ll look into an alternative approach using Python. Stay tuned for part 2!

Yesterday the results of the Fedora 18 release name election were announced.

Fedora 18 is going to be called Spherical Cow.

Wait, what? Yes, Spherical Cow.

“/doh” by Hobvias Sudoneighm (striatic on Flickr), used under a CC-BY 2.0 license.

Tatica broke the news about the Fedora 18 release name in Vienna to Emichan and me and we have been discussing it tonight. We all have some concerns with it.

Spherical Cows Falling Flat

Fellow Fedorans, don’t you think this has gone a step too far now? We don’t want to Fedora to be a joke, right? What message are we sending about Fedora with these kinds of names? Even if we had the best, most amazing artwork ever paired with a flawless user experience, don’t you think a name like ‘Spherical Cow’ makes it seem as if we as a community don’t care about Fedora or that we don’t believe Fedora is something to be taken seriously? If we believe in free software and we want users to adopt it, how can we convince them to take it seriously with names like this?

“Beefy Miracle,” as Tatica pointed out, has been a challenge for Spanish-speaking Fedora Ambassadors to explain to potential Fedora users at events. Ambassadors are asked quite frequently what the differences are between Fedora and other Linux OSes. Traditionally, the answer has been that Fedora is more for professionals and that it’s a serious distro that takes a progressive stance towards adopting new technology. Whether or not you agree with this answer, it is certainly undermined by silly names, putting our ambassadors in an odd position.

Now, Beefy Miracle, while very much a Fedora community inside-joke and very silly, has had a devout following for a long time and is part of the history of Fedora itself, and he has served as the generic face of Fedora in the generic-logos package. So, I think the extra effort for supporting Beefy Miracle is something that many Ambassadors, including Tatica, do not mind.

But Spherical Cow? Really? What does “Spherical Cow” have to do with Fedora? Where are the “Spherical Cow” devotees? Where is the connection to our community? I don’t see it.

Beefy Miracle aside, we don’t believe that we should have wacky names every release. Furthermore, our names are random and follow a complex and hard-to-understand “is-a” test that causes confusion to pretty much anybody who tries to join in the naming process:

• The complex and non-obvious “is-a” rule makes the naming process seem rather exclusive and difficult, discouraging new participants.
• Since so many folks suggesting names don’t understand the “is-a” rule, a lot of names are suggested that can’t be used, creating a lot of work for the folks running the naming process in checking and rejecting the names that don’t fit.
• The names, for the most part, require some explanation and even with explanation, they are difficult to understand. A community with inside jokes you don’t understand doesn’t feel very welcoming. It’s okay to have inside jokes; what’s wrong is to externalize those inside jokes at the level of the release name which is currently publicized fairly widely.
• The end result is a stream of random names that are completely unrelated, without any common thread or sense about them:
  • Yarrow
  • Tettnang
  • Heidelberg
  • Stentz
  • Bordeaux
  • Zod
  • Moonshine
  • Werewolf
  • Sulphur
  • Cambridge
  • Leonidas
  • Constantine
  • Goddard
  • Laughlin
  • Lovelock
  • Verne
  • Beefy Miracle
  • Spherical Cow

“Sad Panda” by maalokki on Flickr), used under a CC-BY 2.0 license.

We’re Not Alone

I don’t think Tatica, Emichan, and myself are alone in this thinking. There was a lot of support for our position in a Fedora advisory-board list thread last month. Here are some highlights from that thread:

• Seth Vidal said:
  

  I think we should drop the naming process altogether. For the following reasons:

  1. the names do not serve any use
  2. the names are a waste of time and effort to administer the process
  3. no one remembers the names.
  4. the names are potentially divisive.

• Bruno Wolff said:
  

  I don’t think the ‘is a’ process has resulted in consistant good pools of names.

• David Nalley said:
  

  Now that we’ve had Zod and Beefy Miracle – is there really any point continuing?

• Jaroslav Reznik said:
  

  The perception of the name inside the project, the core people (for us, Beefy Miracle has something magical and you can imagine Bacon!) will be different compared to outside ones. For them it could be more difficult to understand it – some people could be offended (even we don’t see reason), some people who understand fun would be just laughing, some would be angry…

  So I don’t think we have a problem inside our community but that *outside* perception could actually sound not the way we wanted it.

• Seth Vidal also said:
  

  I stopped participating or caring in the names a long time ago and from asking around to some of my peers, I’m not alone.

• Jason Brooks said:
  

  Names can be useful, but Fedora hasn’t made much use of them.

I think my favorite quote from the thread is from Matthias Clasen:

I agree – the naming thing started as a fun game, then it got ‘standardized’, and now it is just one more process that has stopped to be either fun or useful. Apart from the problems that Seth has listed, others have pointed out that the expected connection of the release name to the artwork is more often than not problematic.

Time to reevaluate and come up with something fresh and fun that we can do for each release.

Along this line, a suggestion from mario juliano grande balletta:

My only suggestion, based on being new with Fedora, and still full of energy and excitment to work with all of you, is simply stay positive, focus on the fun, smile, find ways to agree, look for the good, insist on being happy, focus on the new, and make changes!

Well, come on then! Let’s do this as a community, okay? We agree with many of the sentiments in the thread that having a release number without any kind of name is a bit cold, especially as our version numbers climb higher and higher. The recent release naming process election results suggest you may feel similarly:

• 550 Fedorans are in favor of keeping the release name, but potentially exploring a new process for developing it.
• 384 Fedorans do not support keeping release names.

A Proposal to Move Forward

Here is our (Emichan, Tatica, and me) suggestion for moving forward on this:

1. As a community, let’s propose different schemes along which we can come up with release names moving forward (Fedora 19 and beyond.) These schemes should result in nice names that won’t be quickly exhausted and will reflect on Fedora positively in some way. Let’s take until June 1 to do this.
2. Once we’ve had a sufficient period of time to come up with naming schemes, let’s decide on the naming scheme we want to use together as a community.
3. For Fedora 19, we can follow a naming process very similar to the one we follow today. The only difference: there is no “is-a” rule for vetting names. The names are instead vetted for adherence to our selected naming scheme, as well as vetted by the entire community for suitability / non-offensiveness, by the Board, and by the Red Hat legal team as well.

We have a wiki page we’ve started with Feodra naming theme suggestions. Please submit your ideas to it.

Thoughts?

Here we have a Tube Open Movie postcard / A5 suitable for printing! Rather than ship them all over the world, we offer the print-ready files [front, back] (in CMYK with bleed margins in place). We hope anyone who wants to help promote the project and campaign knows of a few spots to post them or pass them around. If you want to show the image on the web, better to use the ones displayed. Thanks for helping us get the word out!

Over the last year my interview-taking activity considerably accelerated. I’ve had some wins and some fails, but I think I’m getting the hang of this. Hence I’d like to share some simple techniques and basic principles of doing interviews that don’t suck.

1. Ask sensible questions. Even if you absolutely adore the person you are interviewing, resist the urge to find out what color or book or sex position is his/her favorite. Even celebrities find this stupid and annoying. Your keywords here are: insightful, thought-provoking. Your job is to publish an interview that people will like to get back to after a while to check for presented facts or opinions. You can’t do that without the next principle, which is….

2. Research, research, research. Read as much as possible to understand the person’s background, how the story you are covering evolved, what other influential people ever said (especially opponents). It gives you a 360° view on the subject and helps asking questions that are interesting. It also shows the interviewed person that you did your homework, so the person will be more inclined to be most outspoken with you. Which is what you are looking for.

3. Pick one main theme and build the interview around it. Find a trending topic, one big reason to interview the person. Make sure the person has a hands-on knowledge on this topic.

4. Don’t be afraid to ask controversial questions. I’ll tell you that: it’s bloody annoying to read interviews where both sides readily agree on everything so much that they nearly box tonsils. Leave that crap for teenage magazines. The person you are interviewing doesn’t have to be right (for a given value of right), but if his/her reply wasn’t interesting, you failed.

5. If you have additional questions, just ask. Because you never know. During one of the interviews I recently did, I asked a quite innocent question just to clarify some stuff I heard, and the answer revealed some particularly interesting facts. Asking additional questions is a must to make sure that the person gets to the point and actually answers your question. Otherwise your readers will get bored and leave unsatisfied.

6. Don’t start the interview with the “introduce yourself” nonsense. Just write a one or two paragraphs long profile text as an introduction. I broke that rule when interviewing David Revoy right after the release of Sintel. Sure, I got away with that, but  it’s only because the rest of the text was interesting.

7. Make sure the interview has a well articulated end. Personally, I bloody hate the “thank you for answering my questions, %username%, I absolutely love you! — why, thank you for asking me those, and what a nice hair style you have!”. Yuk! Get the person to say something emotionally about the main topic of the interview so that it would somehow sum up what he/she thinks. Do it surreptitiously, if you can.

8. Edit the text. Unless you are asking some really technical questions that demand long replies just to explain a concept (and there are ways to deal with that, too), your reader shouldn’t bang the head against a wall of text. The interview also shouldn’t contain paragraphs full of ums, ers, and suchlike just because you think it’s cool to keep the conversation style. The difficult part is keeping original tone while editing, and there is no simple advice here other than “understand your conversation partners”. It takes time to learn this through trial and error.

9. Feel free to reorder questions/answers. If you have a long, long conversation (especially face to face), the interview will divert from the topic as many times as it can. Some interesting details related to previously asked questions might float up as well. The net outcome should be a text where conversation flows from A to B, and questions are logically connected. And read again the Tip #7.

10. Done editing? Send the final text for approval. What I’ve found out is that fairly often people have some last minute edits to what they said, especially when interviews take days or weeks (yes, it does happen). And if you do some serious editing, they really want having a look at the result before it goes online.

TL;DR: research, be bold, edit away like there is no tomorrow. And treat your job seriously.

Oh, and you can troll me all you like for not following any of those principles

Paul Miller, a tech journalist for The Verge, is leaving the Internet for a year. He’s an avid StarCraft II player, and writes about (and on) the web for a living. He’s going to continue to use a computer (offline) and continue to write for The Verge.

Miller is a great writer and I get the impression he lives online in the same way I do. I’m looking forward to living UN-vicariously through him as he documents his experience. His video introducing his project is also well done:

After a short delay, the Windows installer for 0.63.05 has been published. ...

After a short delay, the Windows installer for 0.63.05 has been published. ...

It’s the last days of keyframes drawing campaign and this week was especially interesting, because besides of usual drawing of Ivan and Morevna Nikolay was working on the shots where we have many new characters. They all are appear in the Demo only once or twice, but some of them will play a significant role in the whole movie. So you will see a lot of new faces – Doctor-Sister with her husband Businessman, Mechanic-Sister with her husband Rocker, Rapper (who is a husband of Priestess-Sister) and musicians from the bar. Some of them more detalized, some less but still it’s been a big work. I don’t name who is who, I think it’s easy to guess by looking at the picture.

Regarding to the whole keyframes drawing process. We are on the edge of the deadline (1st of May), but we still have 2 days. It was decided to use 3D models for some long-distance shots with complex camera turns and movements (I’m referring to shots 07, 38, 41 and 53). So we have 7 keyframes left. I’m sure Nikolay will finish them in the next two days.

It looks like our fundraising campaign is failing. It’s 2 days left and we still have $1619 to go. Anyway, it’s awesome to see that we have done that far and we are very grateful to everyone who gave us their support! The fact that you all believe in this project make us feel so warm and we will do our best to continue with our efforts and proof that your faith is no waste. Thank you!

Tomorrow I’m taking off in my trip to Libre Graphics Meeting 2012  (2-5 May, Austria) and exactly at the 1st of May I’ll be on the road.  I’ll post the final report about the keyframes drawing and our plans for the future as soon as I will get back. And of course if some of you have a chance to be at this great event – will be happy to meet you there!

Finally, it’s been a long time since I was posting my favourite “work-in-progress” drafts. They are kind of outdated already (since all those keyframes are finished), but I won’t feel as myself if I won’t post them now. ^__^

Everyone, have exciting week!

... when make spends maybe 15 CPU minutes thinking really hard, with no output, and then says Nothing to be done for `slowcheck'. The mind boggles at how slow it might have been otherwise.

Venus has been a beautiful sight in the evening sky for months, but at the end of April it's reaching a brightness peak, magnitude -4.7.

By then, if you look at it in a telescope or even good binoculars, you'll see it has waned to a crescent. That's a bit non-obvious: when the moon is a crescent, it's a lot fainter than a full moon. So why is Venus brightest in its crescent phase?

It has to do with their orbits. The moon is always about the same distance away, about 385,000 km or 239,000 miles (I've owned cars with more miles than that!), though it varies a little, from 362,600 km at perigee to 405,400 km at apogee.

When we look at the full moon, not only are we seeing the whole Earth-facing surface illuminated, but the central part of that light is reflecting straight up off the moon's surface. When we look at a crescent moon, we're seeing light that's near the moon's sunrise or sunset point -- dimmer and more spread out than the concentrated light of noon -- and in addition we're seeing less of it.

Venus, in contrast, varies its distance from us immensely. We can't see Venus when it's "full", because it's on the other side of the sun from us and lost in the sun's glow. It'll next be there a year from now, in April of 2013. But if we could see it when it's full, Venus would be a distant 1.7 AU from us. An AU is an Astronomical Unit, the average distance of the earth from the sun or about 89 million miles, so Venus when it's full is about 170 million miles away. Its disk is a tiny 9.9 arcseconds (an arcsecond is 1/3600 of a degree) -- about the size of Mars this month.

In contrast, when we look at the crescent Venus around the end of this month, although we're only seeing about 28% of its surface illuminated, and that only with glancing twilight rays, it's much closer to us -- less than half an AU, or about 45 million miles -- and its disk extends a huge 37 arcseconds, bigger than Jupiter this month.

Of course, eventually, as Venus pulls between us and the sun, its crescent gets so slim that even its huge size can't compensate. So its peak brightness happens when those two curves cross, when the disk is somewhere around 27% illuminated, as happens at the end of this month and the beginning of May.

Exactly when? Good question. The RASC Handbook says Venus' "greatest illuminated extent" is on April 30, but PyEphem and XEphem say Venus is actually brighter from May 3-8 ... and when it emerges from the sun's glare and moves into the morning sky in June, it'll be slightly brighter still, peaking at magnitude -4.8 in the first week of July.)

Tracking Venus with PyEphem

When I started my Shallow Sky column this month, I saw the notice of Venus's maximum brightness and greatest illuminated extent in the RASC Handbook. But I wanted more details -- how much did its distance and size really change, when would the brightness peak again as it emerged from the sun's glare, when would it next be "full"?

PyEphem made it easy to calculate all this. Just create an ephem.Venus() object, calculate its values for any date of interest, then print out parameters like phase, mag, earth_distance and size. In just a few minutes of programming, I had a nice table of Venus data.

import ephem

venus = ephem.Venus()

print '%10s   %6s %6s %6s %6s' % ('date', '%', 'mag', 'dist', 'size')
def print_venus(when) :
    venus.compute(when)
    fmt = '%02d-%02d-%02d   %6.2f %6.2f %6.2f %6.2f'
    trip = when.triple()
    print fmt % (trip[0], trip[1], trip[2],
                 venus.phase, venus.mag, venus.earth_distance, venus.size)

# Loop from the beginning of 2012 through the middle of 2013:
d = ephem.date('2012')
end_date = ephem.date('2013/6/1')
while d < end_date :
    print_venus(d)
    # Add a week:
    d = ephem.date(d + ephem.hour * 24)

I've found PyEphem very handy for calculations like this -- and it's great to be able to double-check listings in other publications.

After years of work, the blender.org team is proud to present a completely modernized Mesh system!

Heya folks, Fateh and I just posted a video update, it includes a small behind the scenes peak at production during the past week. Check it out!

Everyone talks about DuckDuckGo these days: how it’s so unevil compared to Google and their new service agreement, how it doesn’t pass your search quieres to those sneeky webmasters etc.

But what about the traffic quality? I’ve just had a sneeky look at my GA account for pesky data on evil Libre Graphics World. So far for April the average numbers are:

Visits per page: 3,25
Duration of visits: 00:04:59
Bounce rate: 59,32%

What are its neighbors for the same period in terms of traffic quality?

Site	Visits per page	Duration of visits	Bounce rate
ubuntuforums.org	3,38	00:04:40	53,19%
inkscape.org	3,39	00:02:25	38,64%
blog.meetthegimp.org	4,83	00:05:20	31,43%
vimeo.com	3,04	00:05:04	48,15%
forums.cgsociety.org	4,14	00:03:14	64,29%
davidrevoy.com	4,83	00:03:27	50,00%

Bottom line: DuckDuckGo doesn’t provide what I would qualify as astonishing performance (after all, I know that LGW has some on-page issues that contribute to it). Even so, DDG is almost like a friendly website with related content and overlapping audience. And that’s with me being a lazy arse and not really doing much SEO on LGW, if any at all.

The new version of the cross platform Colour Management System comes with new features and bug fixes.

• ccxxmake can create correction matrixes using a reference colorimeter
• support JPEG in cctiff, tiffgamut and extracticc
• support display calibration and profiling on display without VideoLUT
• support directing colour patches to a web browser for measurements and profiling

The ChangeLog contains the full list of modifications.

About: ArgyllCMS is the primary tool set in the open source world to access colour measurement devices and to create ICC profiles. Together with it’s colour conversion and analysis capabilities it is located in the tool box of many colour management professionals. Several freely distributed graphical front ends exist for ease of handling.

So with some great feedback and great suggestions from you, I’ve been iterating more on the partition resize screen for Anaconda.

I started out by poking around with the visual design of the drag handles, and Robin had the idea to make the space between partitions draggable and to use a model where you only drag between two partitions at a time. I think it will make more sense to do it that way, at least in this iteration. Initially I wanted there to be a free bucket on the right side that would grow as you shrank the partitions, but I think that makes it a little confusing as to how you would re-grow that partition if you changed your mind. Non-intuitive in the manner that the affect of your dragging can be displaced by more than just the next box over and it might not be immediately apparent to you that you can grow your partition even though it isn’t immediately adjacent to a block of free space.

Smooge had the idea that there should be a clear indicator of how much you can squeeze down a given partition, so now the partitions have a lightly-colored graph to indicate their relative fullness (white means free space.)

Nicolas suggested a pie chart rather than a bar graph to get users out of the mindset that this is meant to be an accurate representation of how space is laid out on-disk: I will be exploring that in another round but decided not to try it this time.

Puppy Dog’s Tails brought up the point that not displaying partitions based on whether or not their resizing is supported might not be the best idea. I do agree with his rationale and have found myself in the trap he described many times (“Hmm, it’s gone! Is it a bug, or was that intentional, or what?”) so I put an un-supported VFAT partition (yes, I forgot to label it ‘VFAT’ in the mockup, oops) in this round of mockups to represent that. Another concern Puppy Dog’s Tails brought up was “Disks need some free space to operate efficiently. Perhaps some naive user will take all the free space and allocate it to Fedora and be surprised when they boot back into Windows and it complains or runs slowly.” To answer that, the intention here (as achievable as it may or may not be, David Lehman will probably know the answer to that ) is to not let the users put themselves in that situation. I’m thinking a 500 MB buffer or so might be reasonable but David will probably know best there; the main point is we shouldn’t allow users to shoot themselves in the foot like that and absolutely shouldn’t take every last drop of free space since it’s probably not practical in most situations.

Okay, so here’s the thinking in this round:

Display partitions that we can’t resize

Here we’re showing a tiny EFI partition that can’t be resized. It’s small enough it doesn’t have a label on the graph, so you must click it to get a little label to pop up below it.

Display details on resizeable partition

Here we’ve clicked on the ‘BOOTCAMP’ partition and get a little extra information displayed about it below: the max we can make it right now is 50 GB, the smallest we can make it is 30 GB. That max 50 GB comes from the free space available; would it be useful to give it a max based on all free space on the drive (would be roughly 54 GB since there’s about 4 GB free on the ‘Macintosh HD’ partition, it appears.) What do you think? Is the ‘max you could do *right now*’ or ‘max you could do if you squeezed everything else’ more useful (noting this is a UI for making space for an installation of Fedora, not a generic partition manager)?

Deleting a partition

The best way to make space is to delete, delete, delete! This screen is already a lightbox though, and as misguided / foolish as it may be, one of my goals for the Anaconda redesign is that there shall be no more than one level of lightbox or pop-up here. (The current Anaconda suffers from some crazy nested pop-uppage.) But it seems a bit rash to let someone wipe an entire partition in one click without warning when they click that little ‘x’ in the partition’s upper left corner. So why not have a confirm button nested inside the partition’s box with a warning below?

Well, I’ll tell you why not. It’s a bit of a squeeze for smaller partitions. This is where I want to explore Puppy Dog’s Tail’s idea of having two vertical bars – then the graphs will be constrained horizontally, meaning I’ll have consistent horizontal space for a button like this. Maybe…. Maybe…. We’ll see if it works out, that’ll be round 3.

Do note the model here (at least, the intention!) is that you’re queueing up changes to the partition layout, none of which will be committed until you click ‘Reclaim space.’ This means you don’t really delete that partition until you click ‘Reclaim space.’ So maybe the confirm button is overkill. Maybe it’d be better to have a ‘Reset partitions’ button or something to restore the original layout?

What do you think?

Deleting a partition with no room to breathe

Here’s what I mean: the button doesn’t really have enough space… oh and by the way, the stuff under ’160GB Hard Disk’ in the left list are just me puttering around, I’m not sure if it makes sense to list the partitions there as well (current thinking on that is no, it’s redundant.)

Okay, again, these are all rough and just my current thinking after playing around in Inkscape and reading through your comments for an afternoon. Your feedback on the last couple of posts was incredibly helpful so if you’re willing to give it another go to help fuel this onward, please feel free in the comments!

(Note on the sources for this: the sources for these screens and the earlier ones are in the main Anaconda index.svg, in the ‘screen-destination-reclaim-*’ layers. )

In my last post about Anaconda’s UX redesign, there were a couple of mockups that featured draggable diagrams for managing space on a disk, allowing you to shrink its partitions as possible:

I’ve been thinking about the best way to make the partitions look draggable. They only need to be draggable horizontally; the mockup above shows a diagonal drag handle making it seem as if the space could potentially be dragged upwards as well as horizontally (it can’t.) I’ve looked around different UI patterns for this; it seems a lot rely on the mouse hovering over the area to be dragged and the pointer changing to indicate draggability. I’m not sure that’s enough; I think there should be more visual clues that something is draggable that don’t require you to mouse over them to determine draggability.

So here are some mockups I did just experimenting with different looks; some are definitely more successful than others, I think. What do you think?

When I upgraded to Firefox 11 a month or so ago, I got a surprise: I couldn't invoke firefox from other applications any more. Clicking on a link in an app such as xchat just gave me the Firefox Profile Manager dialog, instead of opening the link in the browser I was already running.

I couldn't find anything written about it, so I've been putting up with it, copying each link then switching to the desktop where Firefox is running and middleclick-pasting it into the browser. But this morning, I did a new round of searching, and finally found the answer, in bug 716110. and its duplicate, 716361.

Quoting from bug 716110::

[The developers] changed the -no-remote flag's behavior in a
surprising, backward incompatible way. Before, it just meant "start a
new instance." Now, it also means "don't listen for remote commands."

Apparently the change went in for Firefox 9, because of bug 650078.

Indeed, that was the problem. I have multiple Firefox profiles, so I use -no-remote -P profilename when I start Firefox, so each profile doesn't conflict with one that might already be running.

But with Firefox 9 or later, you can't do that. Instead, run your first, primary profile without -no-remote; then if you start up other profiles later, run them with -no-remote so they don't conflict with the first one. That works okay for my typical usage, fortunately: I have a main Firefox window I run all day, and only start up other profiles for short periods.

But since not everyone uses this model, fortunately, some upcoming Firefox version will fix the problem by adding a new runtime flag, -new-instance, to do what -no-remote used to do: start up a window for a new profile, rather than talking to the running Firefox. Here's the new --help text:

-no-remote	Do not accept or send remote commands; implies -new-instance.\n
-new-instance	Open new instance, not a new window in running instance.\n

The web Command Line Options page doesn't seem to have been updated yet, but perhaps it will when the Firefox with the fix is released.

Of course, it would have been much simpler if Firefox just honored the -P flag and used whatever profile it was given, as suggested by a commenter in bug 650078. But bsmedberg replies that the complexity of the code makes that difficult.

The new arguments look more sensible than the old -no-remote, though it's frustrating that it was so hard to find information about changes like this. All three bugs are filled with comments from people who, like me, lost a lot of time trying to figure out what broke and how to launch URLs remotely after the change. Thanks to Ryan for clarifying the issue and filing the bug to fix the problem, and to Jed, who added the new flag with his first Mozilla patch. Hooray for open source!

There are only a few days until the 7th edition of LGM begins. We can proudly announce the talks schedule at this time.

As it does every year, the Libre Graphics Meeting focuses on individual and group interaction with an emphasis towards free media and the free software that produces it. This year, the program for Libre Graphics Meeting contains a lot of talks about new developments in the world of free graphics and design software. The schedule for the talks contains more then 40 talks.

The talks are not the only points in the program of Libre Graphics Meeting. Every day there are hacking sessions, meetings, and workshops planned as well. LGM’s strength comes from the presenters who talk about their work and inspire others by sharing their experiences, techniques, and best practices.

If you are interested in the program, you can find it here.

The 7th edition of the Libre Graphics Meeting will help bring the development of free graphic software forward in LGM tradition. Whether you are a developer, an artist, or an enthusiast, you can be a part of this year’s event. If you decide to visit the 7th Libre Graphics Meeting, you can register here. There is no entrance fee and it’s not too late to participate with an Lightning Talk or a BoF-session.

The Libre Graphics Meeting needs still the support with the travelling costs for speakers, however. There is a Pledgie campaign for gathering the money that we still need. So if you are a user of tools like Scribus, GIMP, Inkscape, or any of the many other projects that are participating in LGM, making a pledge is a great way to say ‘Thank You’ to the developers of the tools you use.

OpenICC obtained three project slots for the Google Summer of Code 2012
stipends. That means three students can work again this year full time over
three summer months on colour management projects. Thanks to Google for
organising and sponsoring the program.

Here are in short the projects:

Joseph Simon will continue to work on PDF colour management for the
KDE/Linux printing stack. To have a real world project he choose to implement
Colour Management for Krita Printing.

Casian Andrej will work on ICC KWin colour correction using the X Color
Management spec. That way KWin gets a clear path toward consistent colour
output on the desktop.

Nitin Chada will work on different toolkit dependent renderers for a
XForms subset inside the Simple Toolkit Abstraction project. That standalone project shall enable modules to present
options inside dialogs or embedded in host applications.

Lets have a successful coding summer and deserve the trust Google putted in
the OpenICC organisation and with that in the participating students.

With a little delay we are happy to publish binary packages of the latest 0.63.05 for Mac. Enjoy!...

For a while we've been using dbus-test-runner in various DBus related projects to create a clean DBus session bus for our test suites. This also makes it so that we can test on headless systems that don't have a standard DBus configuration like what is available on most developer's desktop systems. This release we even got it into the Ubuntu archives so we could run our test suites on package builds. As our testing has gotten more mature and we've increased the number of builds on the Ubuntu QA Jenkins server we need to have better reporting, something like what gtester or Google Test can provide, which is difficult with an external utility.

To handle this we've taken dbus-test-runner, turned it entirely inside out, and created libdbustest. This allows for managing the DBus service that is being used in the test setup to be managed by the test framework. Which means you can have a DBus Session per test, or share them, or what ever you need. You've got choices that can match what you're trying to test. I created a small example using gtester that is part of the dbus-test-runner test suite. I expect that we'll be able to port of more of the various ubuntu-menu-bar projects' test suites in the coming weeks.

For those faithful users of the dbus-test-runner command line utility, no worries, it exists and just uses libdbustest. I expect no regressions as it passes the original test suite, and even maintains the code coverage numbers that we worked on in an earlier post. It does have a place in some testing, I expect it's usage to remain as another way to test applications and interfaces.

At this point I've merged the basic ideas behind what we're trying to achieve, but there's still a lot of time to work on the API and make it perfect. If you've got requirements or ideas please share them and let's make this useful for everyone. Also we need documentation and GObject introspection support so this little guy can be used for Python and Javascript testing as well. There's a lot of work to do, but I'm excited where this project is going.

The Krita printer color management proposal has been accepted into the 2012 Google Summer of Code!

The initial phase of this project will actually begin right now – it will involve fine-tuning the libCmpx interface, looking over the possible areas of integration in Krita, and formulating a game plan with my mentor and the key people involved with printing and color management. The official coding period begins in late May, so there is time at the moment to lay down a three-month strategy.

This project will be a huge undertaking for me, especially since color-managed printing under Linux is essentially on the cusp of becoming a reality. But I will do my best in the coming months!

-Joe

• Hands-free woodworking.

Nobody refers to “Running Fedora Verne” and choosing the name every few months is just a giant waste of time and waste of a very busy legal team that has to review and research each stupid name. I think “Beefy Miracle” is a ridiculous name that really takes the edge off an otherwise most professional release.

Just have the next release name as Fedora 18 and be done with the nonsense names once and for all.

At officially 1:27pm EST Saturday, we heard the BOOM that pushed us over the threshold to achieve real funding. Since Kickstarter pledges are not guaranteed until the target is met, it feels in a way like this is the real beginning. Looking back over the slog of reaching the production mid-point by keeping a low overhead, trading lots of favors and putting anything earned back into Tube, I can only say what a fine day indeed! Mega-thanks to our earliest supporters for their solidarity and incredible backing.

Tube is designed to scale with the resources we have. You can see from the project video that we are hard at work making the movie, in tandem with running its campaign — and we want the result to be amazing. Crucially, further funds will allow us to focus on Tube without interruption, give commissions to our valiant crew and make new hires. Budget permitting, Bassam made this sketch of what other passengers on the train might look like:

In the next few days we’ll post a video update about this week in production, showing some of the cool tools we’ve developed to help us (and you!). Let’s keep momentum building, and make this a totally awesome movie under the clock we’ve set ticking.

In my last Awwation update I talked about the new CSS Themes support.

This time, I have another improvement. In the old version, the timeline strip had bad thumbnails. I was using canvg to render the SVG onto a Canvas and then drawing the Canvas bitmap as a snapshot:

This time, I’ve dropped the Canvas approach altogether since I discovered the <use> SVG element. <use> allows you to ‘href’ to an SVG element residing in the DOM and display a ‘reference’ to that SVG. You can also add overriding properties such as a viewBox and transforms.

In action:

Now you can pick any element as a path node in the presentation timeline, and a snapshot of it as it exactly as it appears in the document, during the presentation, will be shown in the strip. How is this better than Prezi’s strip? Well, here, changes are reflected as they happen – so, if I’m moving an element around in the editor, you can see it moving around in the strip too!

Again, I will be short. Our keyframes drawing phase is coming to an end – there’s only 9 days left. Still a lot to do, but it’s almost finished. To be honest I already can’t wait to put all those images into Synfig and see how it all will look vectorized and tweened!

See latest images

I've been fighting a bug in Android's WebView class for ages: on some pages, clicking FeedViewer's back arrow (which calls WebView::goBack()) doesn't go back to the previous page. Instead, it jumps to some random position in the current page. If you repeat it, eventually, after five or so tries (depending on the page), eventually goBack() will finally work and you'll be back at the previous page.

It was especially frustrating in that it didn't happen everywhere -- only in pages from certain sites. I saw it all the time in pages from the Los Angeles Times and from Make Magazine, but only rarely on other sites.

But I finally tracked it down: it's because those pages include the HTML <iframe> tag. Apparently, if a WebView is on a page (at least if it's a local page) that contains N iframes, the first N calls to goBack will jump somewhere in the document -- probably the location of the associated iframe, though I haven't verified that -- and only on the N+1st call will the WebView actually go back to the previous page.

The oddest thing is, this doesn't seem to be reported anywhere. Android's bug tracker finds nothing for webview iframe goback, and web searching hasn't found a hint of it, even though I see this in Android versions from 1.6 through 2.3.5. How is it possible that other people haven't noticed this? I wonder if it only happens on local file:// URLs, and not many people use those.

In any case, I'm very happy to have found the answer at last. It was easy enough to modify FeedMe to omit iframes (and who wants iframes in simplified HTML anyway?), and it's great to have a Back button that works on any page.

I stumbled over a weird error during a package setup, which turned out a PEBCAC error. The full traceback:

[...]
File "/home/roman/.buildout/eggs/zope.interface-3.6.3-py2.6-linux-x86_64.egg/zope/interface/adapter.py", line 583, in subscribers
    subscription(*objects)
File "/home/roman/.buildout/eggs/Products.CMFUid-2.2.1-py2.6.egg/Products/CMFUid/UniqueIdAnnotationTool.py", line 86, in handleUidAnnotationEvent
    uid_handler.unregister(ob)
AttributeError: 'NoneType' object has no attribute 'unregister'

I went throught my whole code and type setup unable to find the mistake I’ve made unless I saw the problem. I imported a configuration module for an ArcheTypes content type declaration from a separate package which was not declared in the setup.py of my new package, e.g.:

$ cat my.package.event.py
from separate.package.config import PROJECTNAME
from plone.directives.form import Schema

class IMyType(Schema): ...

If you stumble over this error, make sure your imports are sane.

So there’s a path in the storage flow of the Fedora installer redesign where if you don’t have enough free disk space to complete an install right now, but you have enough latent space available in your partitions if you were to shrink them. We offer to let you shrink them to continue the install in this situation. (This is highlighted in yellow in the flow chart above.) A partition should be considered shrinkable if it has at least one 500 MB+ of contiguous space within a shrinkable partition (not HFS journaled, not VFAT, not EFI, etc. etc.).

Here’s the screen you get should you end up in that situation:

So we’ve been talking about what happens when you click on that ‘Reclaim space’ button.

Tree list approach

First I took a tree list approach. While I hate tree lists, my brain was hurting around the concept that the general ‘list of parent items on the left, click on one, and details about its children are present on the right’ pattern that I find everywhere in the GNOME UI is typically only used for viewing details and not acting on them. There are some cases where you can act on them, but not in this, ‘check off the partitions you want to shrink across disks to get a grand total you shrink in one go’ shopping cart kind of pattern. If that makes sense. I got hung up on this, so I fell back on old reliable tree list.

“There must be a better way,” I told myself. This tree-list thing looks very 1998, and I think that’s being kind.

Click-and-drag approach

We had poked around with draggable partition blocks early on in the mockups for custom partitioning, so I thought maybe revisiting a clicky-draggy interface here might make some sense.

One issue here is when Chris looked at this, he assumed it was meant to represent the layout on disk. See I was thinking the ‘Free’ block could represent all free, unpartitioned space on the disk, and it would grow as you dragged the Firefox-textbox-style drag handles inward on any partition that was shrinkable. Is it a big problem if the diagram doesn’t represent the physical layout of space on the disk? I’m wondering if there’s some way to make it look, um, less ‘accurate’ or representative in that way so we don’t have any kind of cognitive dissonance screwing up how folks read this screen.

Click-and-drag approach with more block data

I think Chris very rightly classified this one as TMI. However, the idea here is you click on a block in the diagram and you get extended information about it below, in this case, that there are 3 blocks of particular sizes contained in the ‘free’ category.

Click-and-drag approach with less block data than before

An attempt at less TMI.

Where to go from here?

Well, what do you think? Is this approach generally the right one? Have any ideas on how to make the graph feel less like it’s representational of the actual layout of blocks on disk? Overall impressions?

We’ll probably be discussing this in #anaconda on Freenode tomorrow.

My new toy: a Samsung Galaxy Player 5.0!

So far I love it. It's everything my old Archos 5 wanted to be when it grew up, except the Archos never grew up. It's the same size, a little lighter weight, reliable hardware (no random reboots), great battery life, fast GPS, modern Android 2.3, and the camera is even not too bad (though it certainly wouldn't tempt me away from my Canon).

For the record, Dave got a Galaxy Player 4.0, and it's very nifty too, and choosing between them was a tough choice -- the 4-inch is light and so easy to hold, and it uses replaceable batteries, while the 5-inch's screen is better for reading and maps.

USB-storage devices don't register

I love the Galaxy ... but there's one thing that bugs me about it. When I plug it in to Linux, dmesg reports two new storage devices, one for main storage and one for the SD card. Just like most Android devices, so far.

The difference is that these Samsung devices aren't fully there. They don't show up in /proc/partitions or in /dev/disk/by-uuid, dmesg doesn't show sizes for them, and, most important, they can't be mounted by UUID from an fstab entry, like

UUID=62B0-C667   /droidsd    vfat   user,noauto,exec,fmask=111,shortname=lower 0 0

That meant I couldn't mount it as myself -- I had to become root, figure out where it happened to show up this time (/dev/sdf or wherever, depending on what else might be plugged in), mount it, then do all my file transfers as root.

I found that if I mounted it explicitly using the device pathname -- mount /dev/sdf /mnt -- then subsequently the device shows up normally, even after I unmount it. So I could check dmesg to find the device name, mount it as root, unmount as root, then mount it again as myself using my fstab entry. What a pain!

A kernel expert I asked thought it looked like the Samsung is pretending to be a removable device, but only "plugging in" when the system actually tries to access it. Annoying. So how do you get Linux to "access" it?

Udev: still an exercise in frustration

The obvious solution is a udev rule. Some scrutiny of /lib/udev/rules.d/60-persistent-storage.rules found some rules that did this intriguing thing: IMPORT{program}="ata_id --export $tempnode".

Naturally, this mysterious ata_id is undocumented. It's hidden in /lib/udev/ata_id, and I found this tiny ata_id man page online since there's none available in Ubuntu. Running ata_id /dev/sdf seemed to do what I needed: it made the device show up in /proc/partitions and /dev/disk/by-uuid, and after that, I could mount it without being root.

I created a file named /etc/udev/rules.d/59-galaxy.rules, with the rule:

KERNEL=="sd[b-g]", SUBSYSTEMS=="usb", ATTRS{idVendor}=="04e8", SYMLINK+="galaxy-%k-%n", IMPORT{program}="ata_id --export $tempnode"

When I tested it with udevadm test /block/sdf, not only did the rule trigger correctly, but it actually ran ata_id and the device became visible -- even though udevadm test states clearly no programs will be run. How do I love udev -- let me count the ways.

But a reboot revealed that udev was not actually running the rule when I actually plugged the Galaxy in -- the devices did not become visible. Did I mention how much I love udev?

Much simpler: a shell alias

But one thing I'd noticed in all this: side by side with /dev/disk/by-uuid is a directory called /dev/disk/by-id. And the Samsung devices did show up there, with names like usb-Android_UMS_Composite_c197022a2b41c1ae-0:0.

Faced with the prospect of spending the rest of the day trying random udev rules, rebooting each time since that's the only way to test udev, I decided to cheat and find another way. I made a shell alias:

alias galaxy='sudo sh -c "for d in /dev/disk/by-id/usb-Android*; do /lib/udev/ata_id --export \$d; done"'

Typing galaxy will now cause the Samsung to register both devices; and from then on I can mount and unmount them without needing root, using my normal fstab entries.

Update: This works for the Nook's main storage, too -- just add x/dev/disk/by-id/usb-B_N_Ebook_Disk* to the list -- but it doesn't work reliably for the Nook's SD card. The SD card does show up in /dev/disk/by-id along with main storage; but running ata_id on it doesn't make its UUID appear. I may just change my fstab entry to refer to the /dev/disk/by-id device directly.

AND NOW FOR AN EASILY FORWARDED SUMMARY

Animation with substance. The crowd funds it, the crowd owns it.

Elephants Dream, the original open movie directed by Bassam Kurdali, proved it possible to make high quality 3D animated films using free/libre tools in a studio setting. The Tube Open Movie is a new experiment, this time in distributed collaboration — a love letter to free software and open culture that marks their convergence with independent filmmaking.

Tube is inspired by the Gilgamesh poem, which comes down to us as an incomplete, conflicting set of fragments and variations, the clay tablet remnants of more than a few ruined libraries. The epic centers on the Sumerian king that ruled in ancient Iraq, who for his tyranny the gods teach friendship and loss, and through them, the fear of his own death. In the end, the immortality he achieves is different to the one he first seeks. Nearly five thousand years later, Gilgamesh, a woman and a soldier, rushes into a station in pursuit of a paper blown about by the passing of trains. In an ever-accelerating vortex, her hero’s journey becomes the animation’s own frames.

The finished film and its mountain of data assets will be released under CC Attribution-ShareAlike, meaning that you can use them for anything — even commercial appropriation — at no charge, but you are required to allow others to reuse your work on the same terms.

Your support will enable us to complete a movie in which a passionate volunteer team has invested years of hard labor. We hope you will check it out and spread the word.

http://kickstarter.com/projects/1331941187/the-tube-open-movie

(Production blog at http://URCHN.ORG)

Dear sponsors!

Everyone who donated $40 or more, please take your time to look at the credits page to ensure that your name is spelled correctly. If you find a mistake please contact us.

Thank you very much for your support!

Just yesterday we launched Tube’s first major campaign, with the goal of raising at least $22K as a bare-bones budget for this production phase. After only one day, backing has surpassed our expectations — already we are halfway to the target! And with further funding we can work faster, make greater claims on the time of our amazing crew, hire additional artists, and finish Tube in 7 months with even more impressive results. Big love to everyone who contributed, in whatever form — THANK YOU! If you can, please spread the word and help us turn this campaign into an inspiring precedent.

Check it out at Kickstarter!

WebM version coming soon.

Once upon a time, like 5 weeks ago, there used to be the longstanding plan to, at some point in the future, port GIMP to GEGL.

We have done a lot of refactoring in GIMP over the last ten years, but its innermost pixel manipulating core was still basically unchanged since GIMP 1.2 days. We didn’t bother to do anything about it, because the long term goal was to do all this stuff with GEGL, when GEGL was ready. Now GEGL has been ready for quite a while, and the GEGL porting got assigned a milestone. Was it 2.10, 3.0, 3.2, I don’t remember. We thought it would take us forever until it’s done, because nobody really had that kind of time.

About 5 weeks ago, I happened to pick up Øyvind Kolås, aka Pippin the Goatkeeper to stay at my place for about a week and do some hacking. After one day, without intending it, we started to do some small GEGL hacking in GIMP, just in order to verify an approach that seemed a good migration strategy for the future porting.

The Problem: All the GimpImage’s pixels are stored in legacy data structures called TileManagers, which are kept by high level objects called GimpDrawables. Each layer, channel, mask in GIMP is a GimpDrawable.

A typical way to do things is:

TileManager *tiles = gimp_drawable_get_tiles (drawable);
PixelRegion region;

pixel_region_init (&region, tiles, x, y, w, h, TRUE);

/* do legacy stuff on the pixel region in order to change pixels */

After the GEGL porting, things would look like that:

GeglBuffer *buffer = gimp_drawable_get_buffer (drawable);

/* do GEGL stuff on the buffer, like running it through a graph in order to change pixels */

Just, how would we get there? Replacing the drawable’s tile manager by a buffer, breaking all of GIMP at the same time while we move on porting things to buffers instead of tile managers? No way!

The Solution: A GeglBuffer’s tiles are stored in a GeglTileBackend, and it’s possible to write tile backends for arbitrary pixel storage, so why not write a tile backend that uses a legacy GIMP TileManager as storage.

After a few hours of hacking, Pippin had the GimpTileBackendTileManager working, and I went ahead replacing some legacy code with GEGL code, using the new backend. And it simply worked!

The next important step was to make GimpDrawable keep around a GeglBuffer on top of its TileManager all the time, and to add gimp_drawable_get_buffer(). And things just kept working, and getting easier and easier the more legacy code got replaced by GEGL code, the more GeglBuffers were being passed around instead of TileManagers and PixelRegions.

What was planned as a one week visit turned into 3 weeks of GEGL porting madness. At the time this article is written, about 90% of the GIMP application’s core are ported to GEGL, and the only thing really missing are GeglOperations for all layer modes.

As a totally unexpected extra bonus, there is now even a GEGL buffer tile backend in libgimp, for plug-ins to use, so also plug-ins can simply say gimp_drawable_get_buffer(drawable_ID), and use all of GEGL to do their stuff, instead of using the legacy pixel region API that also exists on the plug-in side.

GIMP 2.10’s core will be 100% ported to GEGL, and all of the legacy pixel fiddling API for plug-ins is going to be deprecated. Once the core is completely ported, it will be a minor effort to simply “switch on” high bit depths and whatever color models we’d like to see. Oh, and already now, instead of removing indexed mode (as originally planned), we accidentally promoted indexed images to first class citizens that can be painted on, and even color corrected, just like any other image. The code doing so doesn’t even notice because GEGL and Babl transparently handle the pixel conversion magic.

The port lives in the goat-invasion branch in GIT. That branch will become master once GIMP 2.8 is relased, so the first GIMP 2.9 developer release will already contain the port in progress.

If you want to discuss GIMP and GEGL things with us face to face, join us at this year’s Libre Graphics Meeting in Vienna, in two weeks from now, a lot of GIMP people will be there; or simply check out the goat-invasion branch and see the goats yourself.

If you have some Euros to spare, consider donating them to Libre Graphics Meeting, it’s one of the few occasions for GIMP developers, and the people hacking on other projects, to meet in person; and such meetings are always a great boost for development.

During the 3 crazy weeks, quite some work time hours were spent on the port, thanks to my employer Lanedo for sponsoring this via “Labs time”.

I’m joining Red Hat on May 2nd, where I’ll be working with the Open Source and Standards team. We’ll be working hard to help all of the projects that Red Hat contributes to kick ass at growing community. I have known several of the team from years gone past, and interviewing for the position was frankly a pleasure.

I’d like to thank Karsten Wade for thinking of me and making the connections back in February. When my future boss described the position and the team to me around then, and asked me whether I might be interested, I couldn’t help myself from saying “I think you just described my dream job”. I know you’re supposed to show restraint and play hard to get in these situations, but I got carried away.

Red Hat is one of the few companies out there that could tempt me away from independent consulting. They have a range of projects covering the server, desktop, middleware, cloud services and virtualisation. They are the top, or one of the top, corporate contributors to dozens of projects I use every day. I love the Red Hat philosophy of working with communities to make great Free and Open Source software.

Of course, that doesn’t mean that everything is roses. There are projects within Red Hat (or that Red Hat contributes heavily to) which need to improve their community processes, that could do a better job of promoting themselves, or that have hung on to former business models post-acquisition, at the expense of community growth. And it’ll be our job to fix those issues. It’ll be challenging, it’ll be a slow, incremental process. But I have no doubt that it will be very rewarding. I’m looking forward to it!

As it was mentioned in a blogpost before, Oyranos will participate in the 7th edition of Libre Graphics Meeting, which is held in Vienna from 2nd until 5th of May at UAS Technikum Vienna. The schedule is published since a few days and so I can tell that the talks I submitted are accepted.

Most of the talks about color management topics will be held on the first day. The first talk of this day will be held from Richard Hughes and introduces the ColorHug. Then my first talk “Evolving Concepts for Colour Management” will follow. Chris Lilley from W3C will inform after my talk about the status of color managment in SVG2. Then the “competiting” color managment will present there developments since the last LGM, Oyranos will start with “Colour Management a la Greek” followed by Richard Hughes “colord – Linux Color Management Framework, One Year On“. Last talk of the color management talks will be “Taxi DB – Call A Cab To Bring The Colors” which will be delivered from Sirko.
The rest of the talks of the first day are mostly topics like: “Re-lab project. Formats reverse engineering: tools and results” or “Import filters for vector graphic formats in LibreOffice: the reverse- and straight engineering fun“.
The rest of the week will be filled with a lot of talks, workshops and project meetings/hacking sessions. I will also give an workshop about Hughins eye on thursday 1pm.

Many great people already announced their presence and probably many other will come too. If you are into Free software and doing anything graphic related, this is the place where you should go. And the best thing is, Linuxwochen Vienna will be held at the same time and place, so there will not be only talks and workshops about graphic topics.

But the Libre Graphics Meeting needs still some support raising the money for the travel costs for speakers, there is a  pledgie where you can donate.

I will not write much today. It’s only two weeks left before deadline, so we are in hurry to finish all keyframes to the date. This week was a very productive, BTW. ^__^ Stay tuned!

Latest Images

José Luis Romero L. asked me for a Logo for LinuxMaya, the honduran Linux users group. I said yes, mainly because it was an interesting opportunity, stylistically, and a welcome break from my currently more layout and interaction-design heavy job.

From their self-description, they are a group of professional and enthusiast users of Free Software and GNU/Linux, who want to spread the word about Free Software and offer expertise in Honduras and Central America.

Now it would be cute if one could express such ideas in a logo, but it’s all so damn abstract and shared by many projects. The first responsibility of a logo is to be recognisable. So I focused on the name and found inspriation in mayan symbols and stone carving.

A few small sketches:

The final result:

Filed under: Logos, Planet Ubuntu

Last week, I blogged about how I wrote the first iteration of Awwation, an HTML5 Prezi clone. Somehow the blog post surfaced onto the front pages of Slashdot, and /r/programming for a couple of days, and the project got a decent following on Github (it was a trending repo that day!).

This prompted me to polish the code a bit to make it presentable to potential contributors, and now the app is in a somewhat usable state.

The first iteration was rather bland, so I thought it would be a good idea to have presentation themes like Prezi does. As it turns out, this was easy – SVG can be styled using CSS.

So here’s a sample CSS theme for Awwation:

@import url(http://fonts.googleapis.com/css?family=Berkshire+Swash);

text {
    font-family: 'Berkshire Swash', cursive;
    text-shadow: 0px 0px 8px rgba(150, 150, 150, 1);
}

rect {
    stroke: #AEAEFF;
}

ellipse {
    stroke: #FF0000;
}

That’s it, really.

And here’s a new ‘Themes’ menu, with the above theme in action:

What next? A theme creator tool would be a good idea. I’ve opened an issue for that. Contributions are welcome.

While wandering through the Web, I came across a simple but nice demo of CSS3 Animations: a spinning newspaper cover like one would see in an old black and white movie. It would be just perfect for a personal website I have but there is one problem: the example uses an image, JPEG to be exact. I want to be able to easily change the text. No problemo… I can just substitute a <div> for the <img> element and then fill that how I want.

To begin, I followed the demo example and used the following CSS:

.newspaper {
animation-name: spinning;
animation-duration: 1s;
animation-timing-function: ease;
animation-iteration-count: 1;
animation-direction: normal;
}
@keyframes spinning {
0% {width:10px; height: 7px; transform:rotate(0deg);}
100% {width:468px; height: 330px; transform:rotate(1440deg);}
}


One thing to note is that this CSS won’t actually work in any browser at the moment. Firefox and Webkit based browsers support CSS3 Animations but only using prefixes (i.e. -moz-, -webkit-). While prototyping and testing in multiple browsers I found it convenient to use the “-prefix-free” JavaScript code that automatically adds the necessary prefixes (read the documentation about how to use it locally with Chrome and Opera). After you get everything working, you can manually add the prefixes if you need to avoid using JavaScript.

I added a <div> for the newspaper name and immediately came across the first problem. The text doesn’t scale. Following the given example, I adjusted the @keyframe to include “font-size: 0%” and “font-size: 100%”. This didn’t work as expected. The fonts scaled alright, but as they scaled the font size was being rounded to an integer. This lead to discrete jumps in font size which caused visable effects in the text layout.

I have to admit my CSS box-model fu is sadly lacking. I was having trouble getting everything to layout correctly. Later I realized that I had introduced a typo in my CSS style sheet. <rant>I personally hate how HTML5 has gone the route of allowing errors to go unnoticed. Coming from a programming background, I much prefer that my HTML/CSS crashes and burns when there is a syntax error. I’ve wasted more time trying to understand why something isn’t working the way I think it should only to discover later I was missing a simple colon.</rant>

Given the frustrations I was having with CSS layout and with the font-sizing problem (which was a show stopper), I decided to try inline SVG for the layout. This worked out suprising well and within a few minutes I had the layout I wanted. (It helped that I was able to recycle some of the CSS classes I had already defined.) I still had a problem with how the animation was working. The transformation origin was moving so the spinning was starting around the top-left corner. At this point I realized that the @keyframes CSS was not optimal. There was no need to change the width, height, and font-size when a scaling could be simply added to the transform. I change the appropriate lines to:

0% { transform:scale(0) rotate(0deg);}
100% { transform:scale(1) rotate(1440deg); }

Now the amination worked as expected.

Once I got the SVG version working, I went back and tackled the CSS/HTML version. It took quite awhile, but I finally got it to look (almost) like the SVG version. Having completed that exercise I can give the following summary:

SVG Advantages:

• Easy layout. No dealing with collapsing margins, shifting borders, paddings, floats, vertical centering hacks. The one problem I came across was that paths must be defined in terms of user units (pixels) and not the percentages that I used everywhere else.
• Easy to add vertical separators of random length.

CSS Advantages:

• SVG does not have text wrapping but one can use a <p> inside <foreignobject>.
• SVG text cannot automatically be vertically centered. Changing font-size requires manually shifting text.

Here are the final figures. Note that these are just PNGs. For a look at the spinning SVG and HTML covers go to my website (it is too difficult to get these to work inside the blog).

SVG/CSS

HTML/CSS

Well, I got into a Photoshop vs. Gimp pissing match. Sigh. Lots of rich manure left behind in the aftermath. Why not try to plant a seed and grow a useful vegetable from it?

So here’s a quick screencast (created using GNOME Shell’s built-in screen recorder with audio using a trick posted to GNOME bugzilla by my colleague Dan Allen) that shows how to do some of the things folks more used to Photoshop told me they wished they could do in Gimp. I also threw in a little demo of the Gimp Paint Studio plug-in that I’m in the process of packaging up for Fedora.

Should you happen upon this and have questions about how to do other stuff you’re used to in Photoshop (or any bitmap tool) and can’t figure out in the Gimp, let me know and I’ll try to screencast it. With the new trick configured in my GNOME shell setup, it is so dead simple to do screencasts I’m looking for excuses to do more!

UPDATE: Uh, the link to the video off of the thumbnail preview actually works now Thanks to ‘k’ for pointing it out in the comments!

Finalmente é lançado o Krita 2.4, primeiro release realmente pronto para uso por artistas profissionais. Ja faz um tempo que acompanho a lista dos desenvolvedores e os caras colocaram muito esforço em cima dessa versão. Estabilidade foi a principal delas, resultando numa aplicação bastante agradável de se produzir.






As principais melhorias foram a integração de novos pincéis, aumento no desempenho do programa, pintura espelhada (gera-se cópias refletidas da pincelada feita em um ou mais eixos definidos no canvas ), melhoria na sensibilidade de pressão via tablet, compartilhamento (usando as funções do desktop semântico Nepomuk ) e Quick access wheel (acessar de maneira mais ágil as ferramentas favoritas do artista).

Quick-access wheel

Também tem um instalador experimental para Windows do Calligra em que o Krita esta integrado, mas é ainda o RC 2. Caso alguém se aventure por lá, dá um feedback aqui ;).



Para mais informações, tem este PDF com descrição completa das novas funcionalidades e este tópico no fórum do KDE com produção artística, pra se
ter ideia do que o programa é capaz.

It’s time again to start thinking about articles, tutorials and images for Issue # 38 of Blenderart Magazine.

The theme for this issue is “Power of Compositing”

Blender’s Composite Editor provides a powerful method for enhancing your images and animations as well providing an endless number of fun ways to create special effects. This issue we are going to focus on the Compositor and how to use it to create some nice effects as well as look at how it can improve our workflows and projects.

Looking for tutorials or “making of” articles on:

• How to use the Compositor to create amazing images/animations
• Special effects
• Using The Motion Tracker
• Using the Compositor with Cycles
• How you use the compositor in your work flows/ projects

 

*warning: lack of submissions could result in an entire issue of fuzzy bunnies, puffy hearts and a galley filled with random images off my hard drive …. …… goes off to check number and variety of images on my hard drive …. just in case.

Articles

Send in your articles to sandra
Subject: “Article submission Issue # 38 [your article name]“

Gallery Images

As usual you can also submit your best renders based on the theme of the issue. The theme of this issue is “Power of Compositing”. Please note if the entry does not match with the theme it will not be published.

Send in your entries for gallery to gaurav
Subject: “Gallery submission Issue # 38″

Note: Image size should be of 1024x (width) at max.

Last date of submissions June 5, 2012.

Good luck!
Blenderart Team

 

Yeah! Finally the Krita team is proud to release the 2.4 version, along with the Calligra suite.
Check the annoucement on the website.
This release is dedicated in memory of Jean Giraud aka Moebius, whose work has always been a great source of inspiration, and will stay in my memory.

To celebrate this release, I’ve uploaded the tutorial videos from “Comics with Krita” DVD on my youtube channel:

Also the complete DVD is now available on bittorent, thanks to Freetorrent.fr.
You can still order the dvd+comic-book pack to support the Krita, enjoy the printed copy of the comics and have an original copy of the dvd for your collection ;.)

Enjoy!