graphics@linux

Hichart

2011-12-11T14:26:00.001-08:00

The other day I had to make a web app for a shopping window contest. Of course I used django and within a couple of days I had everything up and running. In earlier editions I had to rely on Joomla for technical reasons. There is nothing wrong with Joomla but it is just not the right thing for this task. I also wanted to plot the votes on a chart in realtime and stumbled upon "chartit". Maybe I was just to stupid to get it to work, I played around with it but then I decided to let it be and use the hichart javascript library. The main reason I didn't insist using chartit was an encoding error. Unfortunately, in python you sometimes find that english native speakers develop useful modules or libraries just to find out that they only work with ascii. In the case of chartit I was surprised because by digging around I found an article of the author where he warmly recommends to always use unicode instead of string objects. Anyway, I also think that it is not that difficult to use chartit with django, IMHO there isn't really a need of a django app. Right now I am thinking of making a walkthrough tutorial about how to use hichart as soon as I have got some time.

Creating a Calendar App with Django

2011-12-02T22:26:00.001-08:00

I am supposed to maintain the webserver of a town hall somewhere in Spain and right now I am planning to port part of it to Django. This has to be done quickly, so this is just the right project to check if django's slogan "for perfectionists with deadlines" can keep promises.

Yes, I said "I am supposed to" because the whole system I have to work with makes a lot of trouble to the point that it has become impossible to do anything useful on the site. It is mainly a proxy error that appears every twenty minutes and makes the webserver unreachable for five minutes.
Anything that is not the webserver (proxy, firewalls, etc.) is (or better said should be) maintained by the sys admin. Unfortunately, anything more complicated than plugging cables into a computer or changing toner cartridges is far beyond the scope of her capacity.
Luckily my "contact person" at the town hall is into IT technology and is aware of the problem, so we decided to start hosting the web externally. On the one hand it's a pitty, becaus having the server in-house offers some very nifty possibilities to integrate web services into the workflow. However, this requires a competent IT department which simply does not exist in our place. But workflow integration is one of the reasons to switch the event calendar to django.

Until now, we have used the gcalendar plugin with a public google calender to publish events, unfortunately a couple of days ago it stopped working as well and I didn't manage to put it again into orbit. I found quite a few posts from people that experienced the same problem. This forces me to start working on a new solution right now. So, lets get into gears.

The Design

The first part is quite simple, we need a data model with the following parts:

date: date
starts: time
ends: time, optional
venue: foreign key => table with venues
category: foreign key => table with categories
title: varchar(50)
description: text
price:varchar(50)
Picture: image

So far, so good, this is the information that gets published. The model, until now is pretty self explaining. The reason for the price to be varchar instead of decimal is simple: quite often pricing depends on conditions, or needs some extra information, so it is easier and more flexible to keep it as a varchar.

For some events you may also need an end date. However these are things like exhibitions, tournaments, courses, etc. and there should be a different dat model, because they have quite a different data structure. We will come to that later.

Maintenance of the data will be done by various people so we also need some fields for meta data:

user => reference to the user model
creation date: timestamp
modification date: timestamp

The whole creation process of a month's event calender is a workflow that until now is structured rather informally. So we need at least one field that shows the status of the entry:

status: "in progress", "for approval", "approved", "published"

Especially the last two status have important implications. Once an event is approved, it cannot be changed unnoticed. Any change reverses the status to "for approval". Once the event is published, it cannot be changed in any way without explit intervention of the person in charge of approving.

The model implementation

So, let's start with implementation, but before, a word of warning to those not familiar with python and django: Python is not php and django is not a cms. In my opinion, django and thus python is the most efficient way to build complex dynamic web sites and web apps. However, you need to have some understanding of how it works and you need a good service provider like webfaction. The following is _not_ a walkthrough tutorial but rather a proof of concept and a source of inspiration/information for those who want to know more about django.

We suppose that we have already created a project, now we need to create an application that contains all the requiered functionality including models, views, templates, forms and the url dispatcher.

In the project folder we invoke
./manage.py startapp events

This creates the necessary empty files we still have to fill with our code. Next, we have to register the newly created app with the project by adding the line 'ayto.events' to INSTALLED_APPS, where "ayto" is the name of the project and events the name of our newly created app. Now we can start working on our model. We open the generated file models.py and start with the following import statements:

# -*- coding: utf-8 -*-
from django.db import models
from django.contrib.auth.models import User
from datetime import datetime
#The following module contains some custom model Fields, The names are self explaining
#You will find similar code or snippets on the Internet. Use Google or replace these
#fields in the model by standard fields.
from ayto.CustomFields import ResizedImageField, ResizedImageFieldFile, MarkdownTextField

I import the User model because we are going to define References to users to keep track of who has done what on the data. From a module called CustomFields I import some custom tailored field types. After that I define some functions to handle naming of image uploads.

#The following stuff is to manage naming policy of image uploads
def rand_key(size):
    """returns a random string that can be used to create random filename. 
    Size is the length of the string"""
    return "".join([random.choice(string.letters + string.digits)
                          for i in range(size)])

def upload_to(prefix, instance, filename):
    file_root, file_ext = os.path.splitext(filename.lower())
    file_root = file_root.replace(" ","_")
    file_root = file_root.replace("-","_")
    return "%s/%s_%s%s" % (prefix, file_root, rand_key(8), file_ext)

def upload_to_venue(instance, filename):
    return upload_to("venue", instance, filename)
    
def upload_to_category(instance, filename):
    return upload_to("category", instance, filename)

def upload_to_event(instance, filename):
    return upload_to("event", instance, filename)

What follows now is the straight forward definition of the data models. They are self explaining.

#Models go here
class Venue(models.Model):
    """Describes the venues, Opening hours, location, etc."""
    name = models.CharField(u"Nombre", max_length=50)
    opening_hours = models.TextField(u"Horarios")
    address  = models.TextField(u"Dirección")
    description  = MarkdownTextField(u"Descripción")
    #we resize uploaded pics th 185px, because the will used as thumb on the web.
    picture = ResizedImageField(upload_to = upload_to_venue, 
                                max_width=185, max_height=185)

    created = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)
    user = models.ForeignKey(User)

    class Meta:
        verbose_name = u"Lugar"
        verbose_name_plural = u"Lugares"
        ordering = ['name']
    
    def __unicode__(self):
        return self.name

class Category(models.Model):
    """Different types of events like cinema, cinema for kids, theatre, etc.
    picture is an image that can be used for an event if there is no image
    for the event itself"""
    name = models.CharField(u"Nombre", max_length=50)
    picture = ResizedImageField(upload_to = upload_to_category, 
                                max_width=185, max_height=185, blank=True, null=True)
    created = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)
    user = models.ForeignKey(User)
    
    class Meta:
        verbose_name = u"Categoría"
        verbose_name_plural = u"Categorías"
        ordering = ['name']
    
    def __unicode__(self):
        return self.name
   
class Event(models.Model):
    """Any event that does'nt span over various days.
    comments is used for internal comments that are not meant for publication"""
    title = models.CharField(u"Título", max_length=50)
    description = MarkdownTextField(u"Descripción")
    comments = models.TextField(u"Comentarios")
    date = models.DateField()
    starts = models.TimeField(blank=True, null=True)
    ends = models.TimeField(blank=True, null=True)
    price = models.CharField(default="Entrada gratuita", max_length=50)
    venue = models.ForeignKey(Venue)
    category = models.ForeignKey(Category)
    picture = ResizedImageField(upload_to = upload_to_event, 
                                max_width=185, max_height=185, 
                                blank=True, null=True)
    
    status = models.IntegerField()
    created = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)
    user = models.ForeignKey(User)
    
    class Meta:
        verbose_name = u"Evento"
        verbose_name_plural = u"Eventos"
        ordering = ['date','starts']
    
    def __unicode__(self):
        return self.title

Thats it, folks. The models themself take less than 70 lines of code and leaving out all the extra information in the meta classes could be boiled down to even less than 50 lines. Everything, including comments and doc strings still fits in a hundred lines of code. All functionality for adding, retrieving, updating, filtering and deleting data are included. And we get Django's user model with session management for free. Do this with php and go bunkers! (I know, I shouldn't say that...)

Creating the database

Now we have to create all these tables in our MySQL/PostGres database, but wait, let Django do this for you:
./manage.py syncdb

That's it. Syncdb will create all the tables that you have defined in your models, taking care of foreign keys, primary keys, indices, etc. They only drawback is that, once the tables are created, you have to do any changes on the models/tables manually.

Accessing data

Python comes with batteries included, so does Django. With some lines of code you get a full fledged CRUD Interface. You just have to create a module admin.py in the app and register your model with the django admin. Here is the code:

from ayto.events.models import Venue, Category, Event
from django.contrib import admin

admin.site.register(Venue)
admin.site.register(Category)
admin.site.register(Event)

And this is what it looks like:

Of course, there is still a lot to be done. The admin interface is nice for accessing data and I can now store event information in the database. However it is definitely no enough for a good workflow, so we still have to create forms for people who introduce event data and those who approves data. But before I start with this all the event data I am going to add to the database needs to be shown to the public. Therefore I am going to define the public views, in other words the web page that will present the data to the public.

In Django this is done by a module called "views.py". This is remarkable because similar systems like Ruby on Rails or Turbogears call this part "controller". The Django developers say that in one place you define what is shown (views.py) and in the other place (the templates) you define how it is shown, but in the end both are part of the view according to the VMC pattern. Anyway, in views you define functions that handle requests they basically all look more or less like:

def index(request): 
    values = dict()
    events = models.events.objects.all()
    values['events'] = events
    return render_to_response('events/index.html', values)

The function takes at least a request object as argument. This object contains lots of information you may need for different tasks. Then you get the data from one of the data model and pass it to a dictionary. Finally you load a template, pass the dict to it and return the rendered webpage. That's it, without a line of SQL, thanks of Django's ORM. In real life things are a bit more complex, it is up to you to split up complexity into neat little bits of code to keep it clean and tidy.

OK, that's it for now folks, I have to keep working on the project. I'll tell you later how it goes.

gimp roadmap

2011-11-20T00:22:00.001-08:00

About two weeks ago the gimp folks updated their roadmap. The priority right now is to get the single window interface ready and to support layer groups in version 2.8. In fact, those two feature will increase considerably user acceptance outside the Open Source World.

Vrsion 2.10 will be the last one of the 2.X branch and will see incorporation of the code produced during the Google Summer of Code Projects. The port to gtk 3 is going to be the next major step.

Django

2011-11-13T01:36:00.000-08:00

I've been programming in python for many years now and I love it. The great thing about python is that you can use it for lots of different purposes: as a desktop calculator, a quick'n dirty script language, as a high level programming language or as a built-in script language for automizing jobs with scribus, inkscape, blender, gimp, etc.

The python console is useful for debugging and as a desktop calculator

No I have come to love django as well. I have made a couple of bigger projects with turbogears and now I am developing my second project with django. It is a promotional site for active holidays, so I needed to have something way more flexible than an out-of-the-box cms. One of the reasons for picking django was the automatic admin interface. The biggest challenge when you build a highly dynamic content site is the admin interface. It often takes more effort to build the backend than the actual website. With django, you get the admin interface for free.

Django comes with a very powerful but easy-to-use ORM (object relational mapper). With an ORM, every table is represented as a class in which every attribute represents a column and an instance of a class represents a row of data (a dataset). the following represents a snippet representing a table:
(the indentation is not correct due to some editor issue)

class Site(models.Model):
    name = models.CharField(max_length = 50)
    url = models.URLField()
    description_en = models.TextField()
    description_es = models.TextField()
    description_de = models.TextField()
    image = ResizedImageField(upload_to = upload_to_sites, 
                              max_width=185, 
                              max_height=185)

class Meta:
    verbose_name = _("Site")
    verbose_name_plural = _("Sites")

def __unicode__(self):
    return self.name

The good thing about this not only that you don't have to write raw sql any more, thus avoiding trouble and security issues, you also have a clean data model that django uses to dynamically build the admin interface.

The admin site is not just "take it or leave it". You can tweak lots of things, group fields together and so on, it only take a couple of lines of extra code.

Another nice thing about django is the url dispatcher. It is both simple and powerful. Well, in theory it is simple, it is basically a list of regular expressions the requested url is matched against. If you are familiar with regex, it's a snap, for mortals it can be frustrating. However, once you got the trick, you will _love_ it, because of its power en flexibility.

One of django's best known feature is its templating language. Although Jinja2, a very similar but faster templating engine, has drawn away some users, django templating engine is still widely used also outside the django world.

It supports inheritence, so you can make a base template and just override the parts of it in child templates. Use of programming logic within the templates is very limited by design: this forces developers to place code where it belongs - in the controller. That said, django support the vmc paradigm although they have given it a slightly different name I can't remember right now.

At the beginning the learning curve might be a bit steep, not because of its difficulty but because of the amount of conventions and complexity of the system. But this is not really a problem becaus django is very well documented, after the first tutorial you will grasp the concepts without problems

GEGL and babl, a further step towards gimp 2.8

2011-03-16T09:56:00.000-07:00

After a year of work new versions of GEGL, the new non-destructive image processing core which will be used in the next generation of the Gimp, and babl, a bitmap format conversion library, are out with several major changes.
The new version of GEGL features code created during Google Summer of Code 2010 by Danny Robson and Michael Muré. Danny Robson created GEGL operations for loading and saving RGBE images (HDR), merging exposure brackets into HDR and three tonemapping operations, as well as a matting operation. You can read more about his project here.

Michael Muré created a new map-absolute operations that provides pixel mapping render capability for new Cage transform tool, expected in upcoming GIMP 2.8.

Another major change is support for pluggable buffers that will assist transition of GIMP to using GEGL buffers directly, as well as provide means of using arbitrary buffers (think Google Maps).

JPEG2000 and PPM loaders and savers for GEGL were contributed by Mukund Sivaraman, and some existing GIMP filters were ported to GEGL operations by Alexia Death, Barak Itkin and Andy Gill.
The babl library has less changes, but one of the important ones is support for n-component formats.

Scribus 1.4 rc2 is out

2011-03-16T09:51:00.000-07:00

About a week ago the Scribus team published the second release candidate for the 1.4 version. With the appearance of this version, the 1.3.x will soon come to an end.

Great Auk

2011-02-20T21:23:00.000-08:00

I originally put this photograph on the blog by accident. However, I am going to leave it here, in the end it also shows some design (of my new Great Auk) although it is not graphic design. By the way, the plans were lofted with QCad on Linux

Is competing with proprietary software useful?

2011-02-18T21:35:00.000-08:00

I have left my job at the town hall. Personal reasons, I am not going to get into details. As I don't want to let people down I have started to show the person around who is going to take over. Funny enough, he got the job through me. He is an excellent designer, but as most of them at least in Spain, he is a photoshopper, an adobist. The workflow in the town hall is built around linux and free software for several reasons, some of which are: no money, no need for software up to the level of adobe cs5, safety (the LAN is completely contaminated with hundreds, if not thousands of trojans and I didn't want to have problems in my own work flow because of the hopeless incompetence of our network administration) and complience with UE directives.

As I said, Gregorio, the new designer is used to MAC. While I was telling him how I fulfilled different types of work, we couldn't avoid comparing Adobe Software with what I have been using (gimp, inkscape, scribus, openoffice). After a while I started wondering if it is really useful to compare proprietary software with free software. I came to the conclusion that it depends on what you are after.

The first thing, one needs to bear in mind is the fact that proprietary software needs to offer a lot more than free software for a simple reason: they want to charge you an awful lot of money, so they have to give you some awfully good reasons to spend a small fortune on it. In that sense, Adobe does a better job than a lot of other software companies, they give you added value for money. For a printer, or a company that work in the creative sector, a set of design software is an important part of production and any advantage that software gives you, may translate into faster production output and thus, money.

On the other hand, free software gives you a lot of value as well, but for free. And as long as you don't need to optimize and speed up to the top in order to survive on a highly competitive market, you will be better off with free software.

First of all you usually have a big, active and helpful user community to give you support. Software companies have seen this advantage and that quality of support is frecuently better than that of a support line, so a lot of them have copied this model. Curious enough, for what I have seen, quality of given solutions usually is still better on mailing lists and forums of free software. It's the spirit to give something back that drives people to be helpful.

Second you are not stuck with your licensed copy. Say, for example, you are away from your workplace and urgently need to do a job on a computer that hasn't any of the needed software installed. With proprietary software you are stuck here, with free software you just download, install (all major free software runs on multiple platforms) and start working. If you have portable versions of the apps on your pendrive, even better.

Third, proprietary software often comes with features that are helpful and useful on production level, the average Joe will never need, even if Joe does a professional job.

I think, that free software is not lacking features, it's only that its development is slower. In proprietary software, implementing new features is always needed to make sure you keep your market share and to have marketing arguments for making people buy your software. In free software, a new feature is added only if somebody wants it, somebody implements it and the project leader accepts it, which means, in the same way proprietary software picks up new ideas from free software, open software projects can get inspired by proprietary software.

Coming back to the initial question, if it makes any sense to compare apps from both worlds: As long as the goal is to pick up new ideas, to get inspired, to learn from the good and the bad ideas, it makes a lot of sense to put free and proprietary software next to each other. However, you will always have to take into account the different development cycles of both worlds.

BlenderNation is looking for authors

2011-02-17T08:00:00.000-08:00

If you are an experienced Blender user, this may be interesting for you:
BlenderNation is looking for two authors with a good English knowledge, wordpress skills and - of course - good knowledge of what is going on in the Blender Community. for more details, have a look here.

Cutting edge graphics software meets free culture

2011-02-13T01:31:00.001-08:00

Developers and users of Free, Libre and Open Source graphics software will meet May 10-13 in Montreal at the sixth annual Libre Graphics Meeting (LGM).

Gimp looking for two contributors

2011-02-13T00:25:00.000-08:00

Peter Sikking of m+mi works has been a long-time contributor to the Gimpto working on GIMP's usability. m+mi works is now looking for two interns to work on GIMP's interaction design for 3-6 months. You will work in Berlin and as contributor to the GIMP project you will travel to Libre Graphics Meeting in May, in Montreal. +info

Gtk 3.0 released

2011-02-12T23:27:00.000-08:00

On 10th of february the third generation of the gtk toolkit has seen daylight. The change of the major number indicates a codebreak towards the earlier versions of gtk. However, porting gtk2 based apps shouldn't be difficult to port to 3.0, because differences are not as big as they were when gtk 1 changed to 2.0. Some of the most important changes are:

All the drawing is done through Cairo now
Theming is done through stylesheets with css syntax
More flexible geometry management, which will make frontend design easier
Easy application support and adding of a GtkApplication class that handles a lot of the platform integration aspects of writing an application

I suppose it will take some time to have python bindings for gtk3 available.
For more details, have a look at the project page

Generating random textures with Gnofract

2011-02-04T07:56:00.000-08:00

Gnofract is an easy to use fractal generator. The downside is that you have to compile it yourself, but this isn't difficult. First you get the gzipped tarball from sourceforge and unpack it onto your local filesystem. The next step is to make sure you have a compiler installed and that dependencies are fulfilled. To do this you fire up your package manager (Yast or synaptic, depending on your distro) and install the development files for libpng, libjpg and python - these packages usually end on -dev or -devel or something similar. Once you have done this you open up a terminal window, change into the gnofract4d-3.13 directory and run ./setup build. If everything works fine you will then find an executable called gnofract4d. That's it basically.

When you start gnofract4d you will see a mandelbrot fractal you can select a part of it and zoom into it again and again.

In order to change the fractal you do Tools => Formula Browser. For our purpose we are going to select the Buffalow.

Now you select an area at the bottom right and keep selecting and zooming until you find a pattern that you like. You save that part as png and open it with the Gimp. Now you apply a couple of filters like movement blur - this part is mainly try and error. Here are a couple of examples:

ultrasound

yin - yan

raindrops on glass

Resources for graphic designers

2011-02-01T05:27:00.000-08:00

I have started to collect information about all types of resources for people who deal with graphic design on Linux. It is still a work in progress but is already quite complete. Interested? have a look here

Scribus 1.4 scheduled for end of march

2011-01-29T09:37:00.000-08:00

Good news for those impaciently waiting for the next major release of Scribus: the 1.4 release is scheduled for 31st of march. With two months to go there are 35 issues on the tracker, 16 of which have already been closed. The closing of some of these issues are real milestones, for example the undo/redo of text frames.

Calligra Suite

2011-01-27T04:01:00.001-08:00

More or less by accidents I have stumbled over Calligra Suite, which seems to be a fork or an effort of rebranding of KOffice. The modern and appealing design of the project web shows the will to give the project a good push forward. The idea of rebranding makes a lot of sense because the strength of KOffice is under the hood and use of these technologies are by no means limited to office apps.
Especially for the graphics sector there are some very interesting possibilities, as you can combine/embed different document types, thus using the best possible app for different tasks.
Imagine for example a leaflet: The Background could be done with carbon14, Images are Krita flakes and the text and layout work would be done with Kword.
This sounds really good but it will probably still take quite a long way to get this ready for production. For further details, have a look here

Blender wins PortalPrograma's Open Source award

2011-01-26T23:35:00.000-08:00

Portal Programa has recently published the list of their reader's top app list. On top of the list is the 3d modeler Blender, followed by Firefox. The fact that a graphics app has made it to become the number one beating even the number two of web browsers shows the increasing importance of open source in the graphics world.

Koffice

2011-01-26T04:33:00.003-08:00

Last week, the KOffice team announced the release of version 2.3.1, the first bugfix release in the 2.3 series. The changes in Krita are the following:

limit size of custom patterns to fit 1000×1000 — avoid memory problems
fix error in memory handling. This means really large images are more feasible now
disable the tile pooler, saving memory for really large images
fix crash when editing a brightness contrast filter in the action editor
Do not crash on startup when loading the tutorial if always start with template is checked

LibreOffice 3.3 has just been published

2011-01-25T03:58:00.000-08:00

The announcement of the OpenOffice fork last septembre made it onto the front page of all the specialized press las septembre. Now, LibreOffice has just announced its first release: LibreOffice 3.3.

One of the most remarkable difference of LibreOffice with respect to OpenOffice is the fact that community commitments are going to make it to the code with less problems, which means that development may be more dynamic, faster and possibly more innovative. During 2011 LibreOffice will have to show the world that it is able to deliver a consistent and reliable development. I wish them all the best.

DjangoCon Europe

2011-01-24T01:56:00.001-08:00

The DjangoCon Europe 2011 organizing committee, chaired by Remco Wendt, has just announced that DjangoCon Europe 2011 will be held in Amsterdam, the Netherlands, from June 6-10 2011. The conference itself will take place on June 6-8, the sprint days will be June 9-10. Though the word was already put out on twitter, the announcement is now available on the official site, http://www.djangocon.eu.

Joomla 1.6 is out

2011-01-24T01:21:00.000-08:00

A couple of weeks ago, the Joomla Community announced the immediate release of the long awaited 1.6 version of Joomla CMS. Some of the drawbacks of Joomla such as limited access control are now history. Here are the most substantial changes:

Finer access controls for viewing and editing content with configurable user groups and viewing levels
A user-defined category structure, from simple one-level to complex multi-level categories
Installation improvements allowing for multiple extension installations in one package, updatable with a single click
Expanded language support for easy production of multi-lingual sites (you needed Joomfish until now)
Start and end publishing times for modules with more control over where they display,
Fresh new templates and semantic markup to please the eye as well as the search engines
More creative control through template styles

Skencil (the good ol' Sketch) revived

2011-01-23T01:27:00.000-08:00

Yes, this has been a real big surprise. Bernhard Herzog's Sketch, that was later renamed to Skencil, was one of the most promising vector drawing apps in the late 90's / beginning of the new millenium.

One of the most outstanding facts about it is that it is written in python and can be said to be the first python scriptable vector drawing program. However, with the beginning of the port to gtk, the project died. Fortunately, a new forge appeared some time ago, the sK1 Project. Now it seems, that a new effort is going to be made to take up the old skencil codebase and revive the project. These are really good news. See what's going to happen in 2011. You will find more detailed information at the SK1 homepage.

Gimp 2.8 about to come

2011-01-23T01:06:00.000-08:00

The open source graphics community has been waiting a long time for the 2.8 version of the number one image manipulation app that was scheduled for just after Christmas. However the developer team has just publisched an announcement on the official gimp homepage about the release being postponed. Broken tablet support seems to be one of the show stoppers, the other one seems to be the switch to the completely new user interface.

The new user interface is without doubt an important and long awaited step forward. However, the real biggy is going to be the GEGL integration, a graph based image processing framework that will be used in all GIMP-3.0.

GEGL will enable non destructive editing, i.e. all transformations to a layer/object such as scaling or rotating can be repeated without loss of quality. Until now, if you apply a transformation just to find out you have overdone things or you didn't hit it on the first try, you had to undo the transformation before giving it another try, otherwise you would risk loss of quality. With GEGL transformations are handled as in vector apps like inkscape. Talking about vector graphics: GEGL will hopefully also enable on-canvas creation of vector shapes, something that photoshop users have been using for a long time.

New web design for Inkscape

2011-01-22T10:22:00.000-08:00

Inkscape has announced a complete revamp of their webpage. Although the current one is well organized and easy to navigate, a redesign is well appreciated. If you are curious what it's going to look like, you can see a preview here

Poor man's document flow

2011-01-22T06:41:00.000-08:00

If you think about document flow in terms of open source, you are most likely thinking of Alfresco. Alfresco is an impressing piece of software but has some severe drawbacks. First of all you have to cope with quite a steep learning curve and second alfresco is anything but lightweight.

There is a bunch of packages that are very well suited to build a python powered full stack document server. But before python comes into gears you have to set up a Linux/Samba/Postgres or Mysql/Apache server.

You will almost certainly want to set up mod_wsgi for the views. Depending on the complexity of your views you can use anything from werkzeug to django.

Another important part is the pyinotify package. It enables you to monitor folders on your linux system and helps you trigger actions as soon as somebody copies/opens/changes a file in the monitored folder(s).

The triggered actions have no limit - python comes with so many batteries included that you can do almost anything - sending the document via mail, load it up to a web server, make a backup or version copy, change read/write access, owner, you name it.

One of the most common and important tasks may be file conversion. Here you can play the same trick as alfresco does - you can run an openoffice / libreoffice instant with the -s option and use it for type conversion even for closed source formats like word.

And of course, you will keep track of the document flow using a SQL database such as PostGres or MySql using one of the excellent objectrelational mappers, starting from the built-in django model, SQLObject (my favourite) or SQLAlchemy.

I don't know if anybody has already thought of building a full stack document flow system in python, but this would definitely a very useful idea.