Back from GUADEC 2013

It has been a very intense week at GUADEC and not just because of the heat of course! I managed to attend several interesting talks, got to know lots of new people and managed to answer some questions that have been in my head for months now.

Regarding to the talks, I speacially enjoyed Juan Pablo Ugarte's one, "Rich custom user interfaces with Glade and CSS" where he showed us, how to creat an awesome presentation using Glade & CSS. What a work! I also enjoyed Lennart Poettering's talk about "Sandboxing applications for GNOME". I could even understand what he was talking about this time! "GNOME and ownCloud" by Jan-Christoph Borchardt was another favourite one.

Appart from these talks, I also got inspired by Fabiana Simões with her fullstory on how to report a UX bug properly and by Ekaterina Gerasimova and Shindu Sundar with their "done is better than perfect" statement.

I also attended the "Women in Tech" and "Web Development" hackfests, both super interesting. I missed more men in the "Women in Tech" hackfest though, but the good thing, is that we talked about how to solve this "issue". We also did some brainstorming and had some good ideas on how to make it easier for newcomers, and other communities to get involved.

The good, and maybe the best thing for me at GUADEC, is what you learn out of the talks. This time I went to GUADEC with the intention of finding myself a new project to work on, to find my place in the GNOME project. In this search, I had the chance to talk to a bunch of people who were very interested on helping me out, even if they did not really know that they were doing it. For this reason, I want to thank Joanmarie Diggs, for paying me attention without even knowing me and trying to really help me to find the place. Also to Fabiana Simões and Andreas Nilsson, who showed themselfes very welcoming when I joined the Web Developer hackfest, and in the last place but not less important, to Marina Zhurakhinskaya for a great long "therapeutic" walk from Česka to the dormitory. Thank you all for making me feel very welcome!

Also, congratulations to all of the volunteers and organizers, who made this event possible, and once again, thank you very much to the GNOME Foundation for sponsoring my trip. Looking forward to Strasbourg 2014!

Another round!

I am packing my stuff right now. In a couple of hours, I will be on my way to Brno for another GUADEC round!!! I'm so excited!

This could not be possible without the help of the GNOME Foundation. Thank you very much and hope to see you all there!

A suitcase full of good memories: GUADEC 2012

A Coruña old town.Thanks to Daniel Siegel for this pic!

It has been a week since I came back from GUADEC and hispanic-GUADEC 2012 in A Coruña. Thanks to the GNOME Foundation, I had the chance to attend both events this year!

"Sharing smiles with Chees" talk. Thanks to Julita Inca for this pic!

"GOPW and GSoC Programs" talk. Thanks to Ana Rey for this pic!

This was definitely, the best GUADEC so far for me. I started attending this event 3 years ago at The Hague. I did not know many people by then, was inexperienced and not very involved as a developer in the community yet. With my second GUADEC (Berlin Desktop Summit 2012) I took part of the local team in the organisation, which gave me the chance to enjoy it "from the other side", but did not let me attend the conference. This year was completely different though. I already knew lots of people, was part of the community in a much more active way (developing, organising, spreading the word, participating in the GOPW...), and was not just an attendant but also a speaker ("Sharing smiles with Cheese" lightning talk and "GOPW & GSoC programs" talk). Now I can say, that I have seen and enjoyed the conference, from every perspective.

It was also really interesting and great for me, to see how the number of participating women in the conference, attending and giving talks, has increased so much since the first time I attended. I feel proud and happy when I think about it. This is an evidence that the programs and effort invested on them are really working!

And the GOscar goes to... 

• The organisers and volunteers, who made a great job all the time, and made everything happen in an uncomplicated and smooth way.
• The great selection of tracks.
• My Outreach Game team (Stefano Candori, Marta Maria Casetti, Richard Schwarting and Rüdolfs Mazurs) and all the "hunted people", that made us win the GUADEC 2012 Outreach Games!!

• Marina Zhurakhinskaya, who helped me collecting information for my "GOPW & GSoC programs" talk.
• The "Queimada Ceremony".
• The fair trade products for the conference breaks.
• The GNOME Outreach Program Year Book 2012 and all the people who made it possible! It has the information of the interns that participated or are still participating in this last year GOPW and GSoC rounds!

GNOME Outreach Year Book 2012.

GOPW & GSoC students and mentors. Thanks to Ana Rey for this pic!

• All those cafeteria nights at the Rialta residence.
• The sport's day!!! Yayyy, we had volleyball this time!!
• All of you, who make GUADEC happen every year!

Guess what!

I will need...

• Willingness to earn and share knowledge and experience - checked.
• Willingness to have fun - checked.
• Willingness to know new people and meet all of those I haven't seen in the last year - checked.
• Willingness to sleep less and talk more - checked.
• Plane tickets - checked.
• My laptop - checked.

Where am I going?
You are right!!

This could not be possible without the help of the GNOME Foundation. Thank you very much and hope to see you all there!

Promoting GOPW and GSoC in Gran Canaria

After a long holiday, I completely forgot to show you this, my latest small contribution to GNOME. From Gran Canaria, at the University of Las Palmas de Gran Canaria (ULPGC) with love...

Tic tac tic tac in Cheese

Look at this image for a second, don't you notice something different?

Right!! Soon and after some polishing, when you record a video in Cheese, you will be able to see how much time you have already recorded!!

Enjoy!

** Update ** : You can see the changes now in the Cheese repository.

Very hot in Cheese!

It has been some time since I wrote my last post. It seems to be that this year's cold in Spain has been one of the worse ones in the last years, and I was one of its victims twice, yayyy!

Apart from surviving this cold, I have been lately working on improving hotplug connection of camera devices in Cheese.

Some history:

Hotplug is a feature that has been recently introduced in Cheese. First, I worked on the common case, removing or adding a camera whenever they were not the first or last device. These two left cases, needed a bit further investigation.

I have been now working on "adding the first device" case. I thought that this would be a simple and straight forward task, but it hasn't been. It hasn't been, due to the nature of Cheese, since it was developed without considering hotplug connections and the code was structured in a way that made it difficult to do "non-very intrusive / for working in all the cases" changes.

What did I learn from this?

1. It would be nice to work on refactoring Cheese.
2. Do not get so frustrated if something takes you longer than expected and finish it. Somebody told me once: "If you think something is going to take you one week, double that time, and you will get what you will really need". So true...
3. Using 'export CLUTTER_DEBUG=script' before executing a program that uses Clutter and *.json files for its UI, can be very useful. Thanks to Emmanuele Bassi for this hint!

The changes are still in a working branch of the Cheese repository.

By the way, I just realized that there are just two weeks left for the end of the GOPW! Where is all the time gone??

PackageKit in Cheese

As I already mentioned in one of my last posts, the sharing functionality in Cheese uses nautilus-sendto, which is a runtime dependency, and we wanted to do it our best to let the user/developer/maintainer know about it:

  1. By checking the dependency at configure time.

  2. By writing a comment in the README file.

  3. By using PackageKit to install the package at runtime. If the package is not installed, and the user tries to use the sharing functionality, PackageKit will be used to install it at runtime. 

The adventure

The PackageKit bit has been quite challenging for me, and I have to admit that it took me much longer than expected :(! I have learned a lot of new things though!

The first problem I had, was that I spent a few days working on dbus-glib, which I later discovered through Dave, that was deprecated. The source of the problem and biggest issue for me was, that both of the examples I followed in the PackageKit FAQ and the Vala tutorial, were obsolete and using dbus-glib. I have already talked with Richard Hughes about the first example and marked the second one as obsolete in the Vala tutorial wiki.

After this discovery, I started using the C API and the org.freedesktop.PackageKit.Transaction interface, which offers the InstallPackages method. I realised of course, that all the examples I looked at, used the org.freedesktop.PackageKit.Modify interface instead, but from my last experience, and since I did not see this interface documented anywhere in the API, I just went on working using the 'Transaction' interface. It also took me a long time to get it 'almost' working, but it never did completely. Another failure!

While I was in the middle of this frustrating process, Dave found out, that the 'Modify' interface was actually not obsolete, and pointed me to a very interesting link that took him some time to find and explained us why all the examples we saw, were using the 'Modify' interface. We both wondered why this was not documented and so hidden, and agreed that this should be somewhere more visible.

After making all the changes in the code again to use D-Bus and the 'Modify' interface instead, I talked to Richard Hughes regarding all these issues. He was really nice, and informed me that the reason why this was not documented in the API, was because the API is just documenting the 'system interface', since the 'session interface' isn't really part of the core PackageKit project but a reference implementation that both KDE and GNOME provide. He also pointed me to another very useful link and agreed on the need of a better entry in the PackageKit FAQ, to provide the users with all these information and documentation, something I will be helping with.

Gained knowledge
I could resume what I have learned about PackageKit in a few paragraphs, that I hope will be useful for you in the future.

There are two different levels of API in PackageKit:

  - The system API: It is the 'Transaction' interface, which is more low level, but allows the developer to control everything, including things like GPG keys and EULAs. Everything is explained in the PackageKit reference manual.

  - The session API: It is the 'Modify' and 'Query' interface, which allows the developer to install a package without taking care of the low level part. This is the one used in Cheese. The documentation in this case, is not so visible as I already mentioned before, but you can find what you need in the git.gnome.org repositories under the /src and /docs directories of gnome-packagekit.

Dave wrote a nice generic synchronous example of PackageKit usage in Vala, using the 'Modify' interface:

[DBus (name = "org.freedesktop.PackageKit.Modify")]
interface Packagekit : Object {
    public abstract void install_package_names (uint xid, string[] packages,
                                                                            string interaction) throws IOError;}

int main () { 
    Packagekit pk;
    try {
        pk = Bus.get_proxy_sync (BusType.SESSION, "org.freedesktop.PackageKit",
                                                   "/org/freedesktop/PackageKit");
        string[] packages = {"nautilus-sendto" };
        var interaction = "hide-confirm-search,hide-finished,hide-warning";
        pk.install_package_names (0, packages, interaction);
    } catch (IOError error) {
        critical ("D-Bus error: %s", error.message);
        return 1;
    }
    return 0;
}

This is basically what you need to know if you want to install any package at runtime in your application using PackageKit, and do not want to bother with the details. I have used the asynchronous version of it for Cheese.

PackageKit in Cheese.

This has been a long post, but as you can see, it was quite an adventure to get here! I will write soon with more news!

How great would it be if...

I have been constantly thinking about something in the last months. Unconsciously, it all started when I did my first contribution to GNOME, then I got addicted, and more and more contributions came, and together with that, more research, reference manuals I had to read, APIs I had to use, the GOPW (GNOME Outreach Program for Women)... and then there it was, a NEED!

How many of you did not feel that documentation was incomplete or non understandable at some point and were desperately looking for an example or source of inspiration?? In my case, I usually look in some project under git.gnome.org, and it helps in most of the cases. What about if we had some kind of 'Google Code Search' tool that would search in all the available code at git.gnome.org? Something like a 'GNOME Code Search'! How great would that be??

What do you guys think? Which approach would you take for doing something like this?

Add 'Share' functionality to Cheese - check!

Great news! The sharing functionality I have been lately working on, have been merged into Cheese master! Now, users will be able to share pictures and videos within different technologies! This needs some improvement though.

First of all, nautilus-sendto needs a good check in the configure.ac file. We are talking here about a runtime dependency, and it would be really nice to have a hint for the user in the form of a message at configure time if nautilus-sendto is not installed on their system or they have the wrong version of it. I already tried something, but it is not completely working, and therefore had to be dropped from the patch for the merge:

# Check for nautilus-sendto runtime dependency.
NAUTILUS_SENDTO_DEP_MSG="This is a runtime dependency just needed for using the sharing functionality in Cheese."
NAUTILUS_SENDTO_REQUIRED=2.91.0

AC_PATH_PROGS([NAUTILUS_SENDTO], [nautilus-sendto], [notfound])
AS_IF([test "x$NAUTILUS_SENDTO" = "xnotfound"],

   [AC_MSG_WARN([Unable to find nautilus-sendto >= $NAUTILUS_SENDTO_REQUIRED in the path. $NAUTILUS_SENDTO_DEP_MSG])],

   [NAUTILUS_SENDTO_SYSTEM=`nautilus-sendto --version | $SED 's/nautilus-sendto //g'`
    AS_VERSION_COMPARE([$NAUTILUS_SENDTO_SYSTEM], [$NAUTILUS_SENDTO_REQUIRED],
         [NS_VERSION_COMPARE=0],
         [NS_VERSION_COMPARE=1],
         [NS_VERSION_COMPARE=1])
    AS_IF([test $NS_VERSION_COMPARE = 0],
       [AC_MSG_WARN([Unable to check the version of nautilus-sendto, it is probably too old. At least $NAUTILUS_SENDTO_REQUIRED is required. $NAUTILUS_SENDTO_DEP_MSG])])])

The problem with this solution, is that it will only work for those versions of nautilus-sendto that include support for the --version argument, currently just nautilus-sendto master, since this is a feature I also worked on during the nautilus-sendto integration, and was merged about a week ago. This means, that old versions of nautilus-sendto will not recognize this argument, and therefore return an error message ("Could not parse command-line options: Unknown option --version"), that AS_VERSION_COMPARE will use, comparing a version number with a string, instead of a version number with another version number, which will of course make the check useless. In the meantime, while I work on finding an improved solution, the user will be informed in two ways in case they hit this problem: through the UI by an insensitive 'Share' action and through the README file.

There are other bits that also need some improvement. As I already explained a few blog posts ago, for accomplishing this task,  I used nautilus-sendto, that internally uses libsocialweb, which needs to have some libsocialweb accounts first set up for working. Right now, the only way for setting those accounts up is using Bisho, that is also giving some problems. The idea now and next challenge, is to use GOA (GNOME Online Accounts) in libsocialweb instead, at least, and just for the moment, for the Google services, so my next tasks will be to focus on porting the current libsocialweb YouTube service to use GOA, and to fix all of those underlying bits that are not working correctly, to make the sharing functionality work really well!

As you can see, I do not get bored. I will be back soon with more news!

Avoid using busy-waiting or spinning technique

Busy-waiting, or in other words, spinning, happens when a process repeatedly executes a loop of code to see if a condition is true, while waiting for an event to occur. This means, that the processor will be waiting for the task to be finished in order to go on executing other tasks, which means, that in general this technique should be avoided, since it consumes time of the processor that could be used, wasting it on useless activity. The solution would be to use an asynchronous approach.

Thinking in asynchronous terms is hard though, synchronous API is simpler in many ways, so most of us tend to use it. It is also usually a quicker hack, but not because of this reason it is the best option.

In order to let Cheese users launch several nautilus-sendto dialogs, to send several pictures each time, and change the form of the cursor from when Cheese was busy with nautilus-sendto to when it was not and all of these without blocking the UI, I needed to take an asynchronous approach. I do not have experience with it, so I of course did it the "easy way", spinning the loop (spin_event_loop()) and this was the result (please, take into account that I removed all the code that was not necessary for this explanation):

public void files_share() {

    try {
       main_window.set_busy_cursor();
       Pid child_pid;
       Process.spawn_async("/", argv, null SpawnFlags.SEARCH_PATH, null, out child_pid);
       main_window.set_normal_cursor();
    }

} 

public void set_busy_cursor() {
   get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.WATCH));

   spin_event_loop();
}
public void set_normal_cursor() {
   get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.LEFT_PTR));
   spin_event_loop();
}
public bool spin_event_loop() { 
   while (Gtk.events_pending()) // Busy-waiting
     {...}

} 

After submitting my first patch with this code, Dave was the one who made the review, and he suggested me to not use the spinning technique. Now it is obvious after reading the above mentioned reasons why :P. At first I was a little bit "afraid" of using asynchronous API. It looked completely akward to me, but then I also discovered through him, that GIO and GLib have some nice API to make asynchronous operations simpler. GIO offers GSimpleAsyncResult, which I personally did not find specially pretty, but still very useful. Sushi uses it and has some nice examples in its code. On the other hand, GLib has g_child_watch_add() (ChildWatch.add()), which sets a function to be called (child_finished()) when a child exits, and was the best approach for my case and the one I decided to replace the spinning technique with:

public void files_share () {

   try {

      Pid child_pid;

      if (Process.spawn_async("/", argv, null,

                                             SpawnFlags.SEARCH_PATH | SpawnFlags.DO_NOT_REAP_CHILD,

                                             null, out child_pid))

      {

         ChildWatch.add (child_pid, child_finished);

         if (num_children == 1)

            window.get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.WATCH));

      }

   }

}
void child_finished (Pid pid, int status) {

   Process.close_pid(pid);

   if (num_children == 0)

      window.get_window().set_cursor(new Gdk.Cursor(Gdk.CursorType.LEFT_PTR));
}

All of these has been totally new for me and I am very happy I learned some bits of it. It definitely improved the code a lot!

Hopefully, all these changes will be merged to master very soon. I will keep you informed!

Integrating nautilus-sendto in Cheese

Among other things, last week I have been very focused and working on the integration of nautilus-sendto in Cheese.

First, I spent some time playing around with nautilus-sendto, and during this process, I filed some bugs and made patches for them too. I first could not compile master during maintainer mode due to some deprecated symbols that I replaced at the end in the form of a patch. After that, I have been having problems with the libsocialweb plugin, which is loaded by nautilus-sendto. At run time, the nautilus-sendto dialog did not show any of the libsocialweb offered technolgies. After talking to Bastien about this issue, he informed me, that in order to show the above mentioned accounts in nautilus-sendto, it is necessary to create your own libsocialweb accounts with Bisho (MeeGo configuration tool for libsocialweb social network aggregator) first. Once the accounts have been created, nautilus-sendto should show those accounts in its dialog. I also filed a bug and submitted a patch updating the README file of nautilus-sendto with this information, which was not available anywhere and updated the diagram I used in my last post with the following one:

Sharing videos and images with Cheese.

The truth is, that even using Bisho now, nautilus-sendto is not showing the libsocialweb accounts for me, which is something I have to go on investigating.

Bisho is also not very stable. It is currently showing just 3 different account types: Facebook, Twitter and Flickr, and just Flickr is working. After what has happened with Meego and the integration of GNOME Online Accounts (GOA) in GNOME, it might be nice and wise to migrate from Bisho, to GOA, another thing I filed a bug about.

Bisho.

After getting familiar with nautilus-sendto, I started working on the integration itself and made a small wrapper in Cheese. Now we can say, that Cheese has the capacity to share images and videos through different technologies. Look that I just said the capacity, which does not mean that is completely working yet! For my changes, I have created a new "shareable-media" branch in Cheese that you are very welcome to test!

This is how it is currently looking in the UI:

Share images and videos Cheese option.

 Integration of nautilus-sendto in Cheese.

I have also realised, that multiple selection of images and videos is not completely working on Cheese. A user is able to select several images and videos that are together one next to the other, but not different separate ones, which is something we will also try to fix.

This, improving the current code and fixing the different issues within nautilus-sendto and Bisho are the next points in my TODOs list. Lots of fun!! :))

I will write back soon with more updates! Thanks for reading!

GNOME Outreach Program for Women 2011: The goals

As I already announced a few weeks ago, I had the honour to be selected as an intern for the GNOME Outreach Program for Women 2011 (GOPW)! I will be working on the Cheese project and mentored by David King.

My main goal, and proposed one, from the outset, was to provide Cheese with support for uploading recorded videos to YouTube. Analysing the problem, I decided that I would like to solve it in a way from the beginning, that would permit to extend this feature with other social sharing technologies for sharing images and videos in Cheese in the future. After talking about all of these ideas with Dave, he pointed me to libsocialweb. Later on, and talking to Bastien Nocera about what the plan was, he pointed me to nautilus-sendto, a convenience application to send files via email, bluetooth or instant messenger, which internally uses libsocialweb already and is what I am finally going to use for my purpose, extending my main goal a bit from sharing in Youtube, to sharing in general.

The following diagram should give you an overview of the whole general idea:

 

I am very excited to see all of this working already! I will try to keep you up to date with the whole process.

Thanks for reading!

Autotools Project Manager, part 5: [current status MERGED]

After all the work, I can already announce and celebrate, that the plugin for giving Qt Creator support for autotools projects, has been merged today into Qt Creator! I could not have finished my time at Openismus GmbH and series of posts related to the plugin in a better way. I am very happy of the result and hope it will be helpful for those who love autotools. Enjoy and see you soon!

Cheese Architecture

During the process of trying to understand the internals of Cheese and together with Dave, we created a diagram that I rewrote in dot language and which I think will be very useful for all of those who want to start contributing to the project or are simply curious about it. It took us some time to put the pieces together, but here is the result!

Created using Graphviz.

Did I mention before that I love Graphviz? It is so, but on this occasion it took me a while to get the layout and the legend the way that I wanted. In order to reorder the subgraphs (each of the external boxes: UI, libcheese, libcheese_gtk, System and Legend), I needed to create some transparent nodes and connections to lie to the rank system that dot uses. You can check out the code on my GitHub repository for more details.

The diagram will be available as part of the Cheese documentation for the next 3.3.2 release, coming out next Monday the 21st of November. 

Enjoy!

Embracing the changes

Right now I am writing from what is still my bedroom, and my bed. If you had a look around, you could see 7 boxes full of books, clothes, gadgets, things that I need, things that I do not need at all but I feel stupidly attached to. All of them sum up my almost 4 years abroad, not that I can put all the great people that I got to know along the way into my boxes. Those, I keep in my memories and my heart. I just ask myself, how much stuff is a person able to collect in such a short period of time??

These last years have been full of good, and also bad, moments and cherished people. I can say that I learnt something new every day, lived in 7 different places, learned a new language, worked in different companies… It was a great and long adventure, a precious piece of my life, also with big emotional costs, but still, just a part of the adventure. And like every good story, and as Freddie Mercury said, "the show must go on", and my show is just starting!

The destination of these 7 boxes is Gran Canaria; it is also mine. I am moving back home for now and I am really excited about all the new things that are awaiting me in the future. My time at Openismus has come to an end, and therefore, I will have time now to finish my studies—something I really wanted to do a long time ago. I also have the honour to say and re-announce, that I have been selected as one of the interns for the GNOME Outreach Program for Women! This means, that you will still keep on hearing from me! I have been very lucky, I must say, and will be mentored by David King to work on the Cheese project. I cannot wait to start!

Autotools Project Manager, part 4: Moving from Gitorious to Gerrit.

After the first code review from the Qt Creator team, and due to the new Nokia changes related to open governance, this project has been migrated from Gitorious to Gerrit. This migration has blocked the development of the project more than expected, mainly due to the bureaucratic processes involved, but now things are back to normal, and after a second review it seems that we are closer to seeing the plugin become part of Qt Creator.

Also two great pieces of news. The first, is that the configure.ac file is now highlighted in the autotools project. Credit goes to Friedrich W. H. Kossebau, who pointed me to the right place and person in order to make this happen. The second, is that Mathias Hasselmann  has come up with a great idea: a script for converting devhelp books into Qt help collections.

As you see, all good news! Now, let's go on making Qt Creator rock!

Update: Since there is no way to have even read access to Gerrit unless one has an account in their Qt Bug Tracker Jira system, I will go on keeping the Gitorious repository up to date with all the changes. Enjoy!

Autotools Project Manager, part 3: The Merge Request

During the Desktop Summit 2011, I had the chance to meet some of the guys working on the Qt Creator (QTC) team. I took advantage of this opportunity and talked to them about the AutotoolsProjectManager plugin. After some discussion, among other things about the lack of available documentation and the intention of making a merge request (MR), I was invited to visit the Nokia office in Berlin. So, last week, I had a very interesting and productive evening there and got to talk to some of the developers, Tobias Hunger, Daniel Molkentin and Oswald Buddenhagen, as well as to Leena Miettinen (in charge of the Qt tools documentation), all of who I have to thank for their patience and the time they took to help me. After the visit and their great advice, I had some homework to do (fix some code style issues, add the documentation and code completion…) to get the plugin prepared for the MR. Now, it is finally available in gitorious, waiting to be reviewed by the QTC team! Let's keep fingers crossed!

Desktop Summit 2011: happy and proud.

I know that it has been two weeks since the Desktop Summit 2011 Berlin came to an end, but I really wanted to write this post.

It is my desire to express loudly and publicly how happy and proud I am. Happy because everything worked better than good, because being a member of the organization has been one of the most gratifying (and also exhausting :-)) experiences this last year. As the volunteering coordinator, I could not be prouder of all the volunteers. You simply did a great job and made things happen. Thanks to the core team for being such a great one, to all the volunteers, also to all of you who volunteered at the last minute, and to all of the attendees for attending and for their understanding when things did not work right out of the box.

Working together with the KDE and GNOME community was a fantastic experience where I got to know lots of interesting people who I hope I will keep in touch with. I will miss all the KDE guys next year at GUADEC! 

See you hopefully soon at any geeky conference!

Autotools Project Manager, part 2: The Plugin.

During the last past weeks, as I already announced and as part of my trainee program at Openismus GmbH, I have been working on a plugin for autotools support to be used with Qt Creator. The project is still in an early state of development, but already offers some nice features and is ready for its first release.

What can the plugin do?

• Load an autotools project and work with it in QTC.
• Syntax highlighting for Makefile.am files.
• Automatic project tree update if the Makefile.am or configure.ac file is changed.
• Configuration of build steps (autogen, autoreconf, make and configure).
• Build and run an autotools project from within QTC.
• Automatic code completion.

Some ideas for the future:

• Add syntax highlighting for the configure.ac file.
• Detect whether autogen.sh runs configure, and allow the user to configure that, to avoid a second configure run.
• Improve the parser. Autotools can generate several/different types of binares, libraries or other kind of targets. The current parser, checks for bin_PROGRAM binaries. If the output produces one of them, the parsing will be successful, if there are more, the parsing will not be successful. This should be changed to a more *Anjuta like* Makefile.am parsing style, which takes into account the existence of multiple outputs among other complex things. In the meantime, and as a suggestion of the Qt Creator's developers, I am using a ProjectExplorer::CustomExecutableRunConfiguration, which allows the user to choose which executable he/she wants to run, in case there is any.

How to use the plugin:

• Download the project from gitorious.
• Follow the README file for installation instructions.
• See that the plugin is recognized and loaded by Qt-Creator, by selecting Help -> About Plugins in QTC. The AutotoolsProjectManager plugin should be listed as part of the Build System plugins.
• Open an autotools project in Qt-Creator, using File -> Open File or Project... In the prompted dialog-box, select the Makefile.am from your project. This is the only way a user can use the autotools plugin. Thus, a Makefile.am must always exist before hand. 
• The first time an autotools project is opened with Qt-Creator, a dialog-box pops up and the user will be able to select the build directory. Qt-Creator then puts a .user file in the directory so it doesn't need to ask again. Only in-source building is working right now.
• After clicking on the Finish button of the Autotools Wizard, Qt-Creator should show the project's tree structure at the left side hand. The root node should show the project name and all project files should be listed and editable from there. 
• At this point, building and running the application should work. This will execute autogen.sh or autoreconf, configure and make. The first time, when running the application, a dialog will ask you to choose the executable's location, then, QTC will remember it for the following times. Ideally, this will be changed in the future, to be done in a more automated way.
• When selecting Projects->Build Settings from Qt-Creator on the left side bar, notice the typical autotools build steps (autogen.sh/autoreconf, configure, make). You may configure some parameters such as adding new configure parameters or changing the build directory (though, as I mentiond before, only in-source building is working at the moment).

As always, all comments and feedback is very welcome. Have fun!