I18NYourApp

Dev Week -- Internationalizing your application with quickly and Launchpad -- dpm and didrocks -- Tue, Jan 26

UTC

   1 [17:59] <aquarius> and I'll hand over to the wonderful dpm and didrocks who are talking about internationalisation, quickly, and Launchpad!
   2 [17:59] <dpm> thanks aquarius!
   3 [17:59] <didrocks> thanks aquarius :)
   4 [18:00] <dpm> [SLIDE 1]
   5 [18:00] <dpm> hey everyone
   6 [18:00] <dpm> and welcome to this session on internationalizating applications with Quickly (https://wiki.ubuntu.com/Quickly)
   7 [18:00] <dpm> https://wiki.ubuntu.com/Quickly
   8 [18:00] <dpm> now
   9 [18:01] <dpm> In the next hour we'll be talking on how to make applications speak your own language using several awesome technologies: Quickly, Gettext and Launchpad
  10 [18:01] <dpm> Your equally awesome speakers today (well, at least didrocks is) will be:
  11 [18:01] <didrocks> Hi, I'm Didier Roche, I work in the Ubuntu Desktop team. I'm more focused on packaging UNE (Ubuntu Netbook Edition), which is the new name of UNR (Ubuntu Netbook Remix) and some GNOME related components.
  12 [18:01] <dpm> [SLIDE 1]
  13 [18:01] <dpm> Hi my name is David Planella, I work as the Ubuntu Translations Coordinator and as such my job is to work together the wonderful Ubuntu translations teams and make sure translations keep rocking as usual. I'm also a GNOME and Ubuntu translator, and lead of the Ubuntu Catalan translation team
  14 [18:02] <dpm> So, without further ado, let's start the session by having a quick look at the main players involved in the internationalization game:
  15 [18:02] <dpm> [SLIDE 2]
  16 [18:02] <dpm> == GNU Gettext ==
  17 [18:02] <didrocks> dpm: maybe, the link to the slides for people not having lernid if you have it :)
  18 [18:03] <dpm> here it is : http://people.ubuntu.com/~dpm/Quickly-i18n.pdf
  19 [18:04] <dpm> Gettext is the underlying and most widely used technology to enable translations of Open Source projects.
  20 [18:04] <dpm> It defines a standard format of translation files translators can do their work with (PO files)
  21 [18:04] <dpm> and lets applications load those translations compiled in a binary format (MO files) at runtime.
  22 [18:04] <dpm> It has implementations for many programming languages, and amongst them, of course, Python.
  23 [18:05] <dpm> You'll find that the comprehensive gettext manual at http://www.gnu.org/software/gettext/manual/gettext.html can be a very useful reference,
  24 [18:05] <dpm> especially in those sleepless nights.
  25 [18:05] <dpm> The Python implementation of the gettext API is what we'll use to internationalize our project with Quickly today.
  26 [18:05] <dpm> Needless to say, it also comes with some nifty documentation at http://docs.python.org/library/gettext.html
  27 [18:05] <dpm> == intltool ==
  28 [18:06] <dpm> Intltool is a higher level tool that adds functionality to gettext by allowing the extraction of translatable strings from a variety of file formats
  29 [18:06] <dpm> It has also become a standard tool when implementing internationalization for OSS projects. Nearly all (if not all) GNOME projects, for example, use intltool.
  30 [18:06] <dpm> It has also become a standard tool when implementing internationalization for OSS projects. Nearly all (if not all) GNOME projects, for example, use intltool.
  31 [18:06] <dpm> For those interested in trivia, Danilo Šegan (or Данило Шеган, for those who can read cyrillic), our very own Launchpad Translations developer lead is also the co-maintainer of intltool.
  32 [18:07] <dpm> == python-distutils-extra ==
  33 [18:07] <dpm> Python-distutils-extra is a python package that makes it easy to integrate themable icons, documentation and gettext based translations in your python install and build tools, and it's basically an enhancement to python-distutils.
  34 [18:07] <dpm> The project's page is at http://www.glatzor.de/projects/python-distutils-extra/
  35 [18:08] <dpm> The three above technologies (gettext, intltool, python-distutils-extra) are transparently used by quickly, so we won't get into much more detail for now.
  36 [18:08] <dpm> There are also more aspects involved in internationalizing applications, such as font rendering, input methods, etc., but this should get you started for now.
  37 [18:08] <dpm> == Quickly ==
  38 [18:08] <dpm> I'll be very brief here and let Didier tell you more about Quickly in a bit.
  39 [18:08] <dpm> For now, it will suffice give you a teaser and tell you that it is the tool which brings back the fun in writing applications
  40 [18:09] <dpm> == Launchpad Translations ==
  41 [18:09] <dpm> Launchpad Translations ( https://translations.launchpad.net/ ) is the collaborative online tool which allows translation communities to be brought together and translate applications online through its web UI.
  42 [18:09] <dpm> Apart from the very polished UI to provide translations, it has other nice features such as message sharing across project series (translate one message in a series and it instantly propagates to all other shared series),
  43 [18:10] <dpm> global suggestions (suggestions of translations across _all_ projects in Launchpad), automatic imports of translations and automatic commits to bzr branches, several levels of permissions, and a huge translator base.
  44 [18:10] <dpm> On the right hand side of the URL I gave you you can see that there are quite a lot of projects using Launchpad to make translations easy both for developers and translators.
  45 [18:10] <dpm> I'll now hand over the mike to Didier to tell you more about what you all have wanted to hear: Quickly!
  46 [18:11] <didrocks> [SLIDE 3]
  47 [18:11] <didrocks> To follow that session, you can install Quickly on karmic or lucid simply by executing $ sudo aptitude install quickly.
  48 [18:11] <didrocks> well, if you are brave an courageous, you can also run from the trunk lp:quickly ;)
  49 [18:12] <didrocks> Once Quickly is installed, close the terminal and open a new one so that statement completion works (and you will love Quickly statement completion ;))
  50 [18:12] <didrocks> But first, what is Quickly? In a nutshell, Quickly makes it easy and fun to write apps.
  51 [18:12] <didrocks> Rick Spencer (leader of Ubuntu Desktop team) is the inspiring sources of Quickly and he started the first version of the app in May 2009.
  52 [18:12] <didrocks> In Ubuntu and more generally in GNU/Linux, we have tons of good libraries, rocking technologies and programming languages.
  53 [18:13] <didrocks> But there are so many that some times it's difficult to pick "what I should choose".
  54 [18:13] <didrocks> Not talking about deprecating technologies that you just discover their current unmaintained state once you have almost finished your apps (libglade, I'm looking at you!)
  55 [18:14] <didrocks> So, what's in Quickly?
  56 [18:14] <didrocks> Quickly has two parts: the core, which basically parses your input and templates.
  57 [18:14] <didrocks> Templates are sets of commands and code generators that are designed to work together in an end to end fashion to help developers write a certain kind of application.
  58 [18:15] <didrocks> But we can also imagine a LaTeX template, a template to manage doc…
  59 [18:15] <didrocks> A template can be written for using whatever technology in whatever language of your choice.
  60 [18:15] <didrocks> for instance, I'm working on a snippet template for awesome Jono's acire app :)
  61 [18:16] <didrocks> So, with templates, you can then create application or document set.
  62 [18:16] <didrocks> We'll focus there only on i18n with the first template that Quickly 0.2 provides: ubuntu-project (renamed ubuntu-application on the coming 0.4 release!)
  63 [18:16] <didrocks> (this template is using Glade, couchdb, has some nice trick for gedit, use bzr, and complete integration with LaunchPad and debian packaging)
  64 [18:16] <didrocks> For instance, Lernid that some of you may use to assist UDW, has been created with the ubuntu-project template. (http://www.jonobacon.org/?p=2258 for a shot of the story)
  65 [18:17] <didrocks> [SLIDE 4]
  66 [18:17] <didrocks> So, let's create first a simple ubuntu-project (assuming you are using Quickly 0.2):
  67 [18:17] <didrocks> $ quickly create ubuntu-project fooby
  68 [18:17] <didrocks> (assuming also that you successfully installed Quickly and opened a command line ;))
  69 [18:18] <didrocks> this tells Quickly to use the ubuntu-project template, and to call what is created "fooby"
  70 [18:18] <didrocks> This causes a bunch of info to be dumped to the command line, but ends with the application being run
  71 [18:18] <didrocks> What Quickly did was to copy over basically a sample application, and do some text switcheroos to customize the app
  72 [18:18] <didrocks> You can see there the ui which contains some text that needs translation.
  73 [18:19] <didrocks> To start making change to your app, cd to it (normally "$ cd fooby").
  74 [18:19] <didrocks> You can then edit your code with $ quickly edit, change the ui with $ quickly glade, and try your changes with $ quickly run
  75 [18:19] <didrocks> You can save your change with $ quickly save
  76 [18:19] <didrocks> Finally, to package, share, release your apps so that other will be, with the following commands (not all are necessary): $ quickly package / $ quickly share / $ quickly release
  77 [18:20] <didrocks> It would ask for minor things that it'll do for you as creating the package, licensing, etc.
  78 [18:20] <didrocks> We won't cover in anymore detail Quickly or ubuntu-project template here (quickly help <command> does this for you), you can find more pratical info at: https://wiki.ubuntu.com/MeetingLogs/devweek0909/QuicklyFun
  79 [18:21] <didrocks> And a detail review of Quickly there: http://blog.didrocks.fr/index.php/post/Build-your-application-quickly-with-Quickly%3A-part1 (this will kill my local Internet connection as I'm self-hosted ;))
  80 [18:21] <didrocks> You can also appreciate (or not) my French accent and see Rick and myself (jet lagged for my defense) presenting how to create an app with Quickly ubuntu-project template at http://www.youtube.com/watch?v=OOQOzPgLGLg
  81 [18:21] <didrocks> It was during last Ubuntu Developer Summit at it's starting at minute 17'.
  82 [18:22] <didrocks> David will now present you in more details what you will do in "quickly edit" and "quickly glade": adding internalization support to your app.
  83 [18:22] <dpm> Thanks Didier, I hope this got you all excited about trying out Quickly!
  84 [18:23] <dpm> As the project stands now, it has the infrastructure for internationalization in place, but we have to initialize it to enable it.
  85 [18:23] <dpm> This will include:
  86 [18:23] <dpm>   * Initializing gettext
  87 [18:23] <dpm>   * Marking strings for translation
  88 [18:23] <dpm>   * Updating the translation template
  89 [18:23] <dpm> [SLIDE 5]
  90 [18:24] <dpm> [SLIDE 5]
  91 [18:24] <dpm> First of all, we'll initialize gettext, which will basically be adding four lines of code. Here's how it goes:
  92 [18:24] <dpm>   quickly edit
  93 [18:24] <dpm> This will open all your project files in a text editor (Gedit by default)
  94 [18:24] <dpm> 1. Go to the fooby file and add the following two lines below 'import gtk', near the top of the file:
  95 [18:24] <dpm> import gettext
  96 [18:24] <dpm> import locale
  97 [18:25] <dpm> This will import the required modules for internationalization
  98 [18:25] <dpm> 2. Still on the fooby file, add the following line below the 'import logging, optparse' one, near the end of the file:
  99 [18:25] <dpm> gettext.install('fooby', unicode=True)
 100 [18:25] <dpm> This will install the _() function to mark (and call) translations as such in Python’s builtins namespace, based on the 'fooby' domain. The domain basically tells gettext where to load translations from.
 101 [18:25] <dpm> This will also save you to include 'import gettext' statements in all of your project files using gettext.
 102 [18:25] <dpm> Refer to the gettext documentation to find out more about translation domains.
 103 [18:26] <dpm> 3. Finally, add the following line to 'fooby', before the 'builder = gtk.Builder()' line
 104 [18:26] <dpm> locale.textdomain('fooby')
 105 [18:26] <dpm> This will tell GtkBuilder about the translation domain as well
 106 [18:26] <dpm> So that was it! Let's move on to marking strings for translation:
 107 [18:26] <dpm> First of all we'll tackle the .destop file
 108 [18:27] <dpm> Open the fooby.desktop.in file and prepend the Name and comment fields with an underscore (_), so they look like:
 109 [18:27] <dpm> _Name=Fooby
 110 [18:27] <dpm> _Comment=Fooby application
 111 [18:27] <dpm> This will tell intltool that this strings contain translations
 112 [18:27] <dpm> Next comes the UI. Let's see how you can mark strings in the UI for translation. Try:
 113 [18:27] <dpm>   quickly glade
 114 [18:27] <dpm> This will open your UI files in the glade editor.
 115 [18:28] <dpm> Once opened, click on the "Your application has been created! ..." label, find it in the General > Label field on the right, click on the ellipsis (the three dots) button and...
 116 [18:28] <dpm> amaze at the fact that it has already been marked as "Translatable", so you won't have to do anything.
 117 [18:28] <dpm> Right, so next comes something very important that you'll have to bear in mind for all strings you'd like to be translatable in your application:
 118 [18:28] <dpm> using the _() function call.
 119 [18:28] <dpm> This will mark them as translatable and call gettext to load the translations, and should be used for all messages you'd like to present to users.
 120 [18:29] <dpm> Let's just see how we can do this.
 121 [18:29] <dpm> Go back to your fooby file and find the "parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help="Show debug messages")" line near the bottom.
 122 [18:29] <dpm> We want the "Show debug messages" message to get shown to users in their language, so we'll enclose it with the _() function, and it will look like:
 123 [18:29] <dpm> parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help=_("Show debug messages"))
 124 [18:30] <dpm> Now we're done
 125 [18:30] <dpm> The last part will be to update the translations template.
 126 [18:30] <dpm> A translations template is a formatted text file generally named yourproject.pot
 127 [18:30] <dpm> which contains your project's translatable strings in English and what translators use as a basis for their translations.
 128 [18:30] <dpm> You should do this before each release, so that translations are put in this template and are up-to-date for translators to work on.
 129 [18:30] <dpm> It is considered good practice to announce a string freeze (that is, the period in which strings are considered to be stable) a week or two before the release, so that translators know when they can start their work.
 130 [18:31] <dpm> This can be done in several ways with quickly, let's pick one:
 131 [18:31] <dpm>   quickly package
 132 [18:31] <dpm> After running this, you'll notice that (apart from having your application packaged!) there is a 'po' folder containing the translation template, ready for translators to work on.
 133 [18:31] <dpm> If you open it, you'll notice the format and will see that all the strings you marked for translation are there.
 134 [18:31] <dpm> You can also do this with 'quickly share', 'quickly release' or directly using the python-distutils-extra command: './setup.py build_i18n'
 135 [18:32] <dpm> == Launchpad Translations ==
 136 [18:32] <dpm> If this weren't awesome enough, once you've created a project in Launchpad ('quickly share', 'quickly release' or https://help.launchpad.net/ will help you on that) you can expose it for translations,
 137 [18:32] <dpm> so that you as a developer can use the automatic bzr import/export features to basically "forget" about translations and translators can use the web UI to translate.
 138 [18:33] <dpm> Let me tell you a bit more on those:
 139 [18:33] <dpm> [SLIDE 6]
 140 [18:33] <dpm> == Automatic imports ==
 141 [18:33] <dpm> Enabling this feature will allow you to automatically import the translation template for your application into Launchpad upon commit, with no further steps required.
 142 [18:34] <dpm> So the basic workflow will be: hack, hack, hack, update template, commit, have translators automagically see the new strings in Launchpad.
 143 [18:34] <dpm> In time, Launchpad Translations will grow the ability to automatically generate the templates, so you won't have to worry about updating it and commit it, but for now, the .pot template has to be kept under revision control.
 144 [18:34] <dpm> You can find more about this at http://blog.launchpad.net/translations/import-translation-templates-from-your-projects-bazaar-branches and http://blog.launchpad.net/general/trying-out-launchpad-translations
 145 [18:34] <dpm> Even better, there's a screencast available showing how to enable this at http://blog.launchpad.net/translations/screencast-importing-translation-templates-from-a-bazaar-branch
 146 [18:35] <dpm> == Automatic exports ==
 147 [18:35] <dpm> With automatic exports, you'll be able to complete the whole circle for automation: getting translations committed automatically (daily) to a bzr branch of your choice, so that neither you nor translators have to worry to get translations into your project.
 148 [18:35] <dpm> I personally find this one of the most coolest features
 149 [18:35] <dpm> Here's more info: http://blog.launchpad.net/general/exporting-translations-to-a-bazaar-branch
 150 [18:35] <dpm> And here's a screencast on how to enable it http://blog.launchpad.net/translations/screencast-exporting-translations-to-a-bazaar-branch
 151 [18:36] <dpm> Least but not last, you might also want to find out more on what message sharing is, enabling translations between multiple project series to have strings translated automagically across those series: http://blog.launchpad.net/translations/screencast-sharing-translations-between-releases-of-the-same-project
 152 [18:36] <dpm> == Permissions ==
 153 [18:36] <dpm> One very important aspect is how you want translations permissions for your project to be. This basically means choosing who will be responsible for submitting and reviewing those translations for each language.
 154 [18:37] <dpm> Launchpad is flexible in allowing different levels of openness for translating your project.
 155 [18:37] <dpm> This generally means that you as a maintainer will have to make a decision to balance openness (open translations for everyone) with quality control (a more closed process with reviewers and a QA workflow).
 156 [18:37] <dpm> The Launchpad help page on permissions at https://help.launchpad.net/Translations/YourProject/PermissionPolicies explains very well the different permissions you can use (Open, Structured, Restricted and Closed).
 157 [18:37] <dpm> If you decide for quality, you'll next have to choose to whom you assign the translation of your project.
 158 [18:38] <dpm> Here is where translation groups come to the rescue.
 159 [18:38] <dpm> Translation groups are confederations of translation teams, one for each language you can assign as a pack to translate your project. The teams in those groups are considered to be trusted to have experience with translations and generally have a review process in place.
 160 [18:38] <dpm> Here's a list of all current translation groups: https://translations.launchpad.net/+groups
 161 [18:39] <dpm> You can see that the two biggest ones are Launchpad Translators and Ubuntu Translators.
 162 [18:39] <dpm> While you can create a translation group specific to your project, we generally encourage maintainers to choose one of the existing ones,
 163 [18:39] <dpm> in order to reuse the pool of translators and not to further fragment translations communities.
 164 [18:39] <dpm> I personally recommend choosing Restricted (or Structured), assigned to the trusted Launchpad Translators or Ubuntu Translators (if your project is Ubuntu-specific) translations groups
 165 [18:39] <dpm> I'll now leave you in didrocks' good hands to tell you more on Quickly's new to come in the internationalization front:
 166 [18:40]  * dpm hands the mike to didrocks
 167 [18:40] <didrocks> Thanks David, you know that Quickly is using automatic export/import for Quickly itself? That's just awesome, no more to bother about generating templates, uploading them, downloading the localization: just use bzr!
 168 [18:40] <didrocks> It's using Restricted permission and we already have a lot of language supported in Quickly thanks to the rocking Launchpad Translator groups :)
 169 [18:40]  * dpm knew, he's been translating Quickly into Catalan! ;)
 170 [18:41] <didrocks> amazing ;)
 171 [18:41] <didrocks> (you started it IIRC)
 172 [18:41] <didrocks> ;)
 173 [18:41] <didrocks> [SLIDE 7]
 174 [18:41] <didrocks> Quickly 0.4 will bring a lot of new experiences and commodities to the users (more than 200 commits, 6 months of hard work!) and will be delivered in lucid.
 175 [18:42] <didrocks> Regarding internationalization, all the tedious job of importing/initalizing gettext and adding _() will be done for you in all newly created apps.
 176 [18:42] <didrocks> (now that I've assisted to the session, will be easier to do the right thing ;))
 177 [18:42] <didrocks> "$ quickly add pythonfile" will also add one boiler plate file containing that for you.
 178 [18:42] <didrocks> Quickly 0.6 (don't know when it'll be available but at least in 6 months ;)) will try to achieve the automatic imports and exports previously described on each $ quickly share / $ quickly release command.
 179 [18:43] <didrocks> So, normally, you won't have to bother anymore about localization and being in sync with the awesome work of your contributors
 180 [18:43] <didrocks> just use _(…) for each string
 181 [18:43] <dpm> I think we should then announce that there won't be any need for such talks in the future, as quickly will do nearly all this for you!
 182 [18:43] <didrocks> ok, and that's it for the session, dpm, back on the field to tackle questions? ;)
 183 [18:44] <dpm> sure, didrocks, if you give me a hand with the quickly ones?
 184 [18:44] <didrocks> dpm: for great pleasure :)
 185 [18:44] <didrocks> with*
 186 [18:44] <cjohnston>  AnAnt> QUESTION: why is it advisable to export to another bzr branch ?
 187 [18:44] <dpm> you can use the main branch if you like
 188 [18:45] <dpm> in fact Lernid does IIRC
 189 [18:45] <dpm> but this adds a lot of automatic commits to the branch
 190 [18:45] <dpm> and not all developers like this
 191 [18:45] <dpm> so they use a separate b ranch for the auto-commits
 192 [18:45] <dpm> of translations
 193 [18:45] <dpm> and then merge those translations back to the main branch when they need to
 194 [18:46] <dpm> e.g before release
 195 [18:46] <dpm> next question?
 196 [18:46] <didrocks> look at: https://code.edge.launchpad.net/~quickly/quickly/quickly-po for instance (merged in Quickly trunk before release) :)
 197 [18:46] <cjohnston> < foobob> QUESTION: any plans to use transifex for the localization of ubuntu?
 198 [18:47] <dpm> that's a bit out of topic, since we're not discussing the translation of Ubuntu - in any case, as awesome as Transifex is, we'll continue using owr own awesome translations tool
 199 [18:47] <dpm> Launchpad Translations
 200 [18:47] <dpm> which has got many features no other tool has
 201 [18:47] <dpm> next questio, please?
 202 [18:47] <cjohnston> If you asked a question during the class that has not yet been answered, please ask it again.
 203 [18:48] <cjohnston> < lernid_alucardni> QUESTION: any plans to integrate Quickly with other version control systems such as git?
 204 [18:48] <didrocks> lernid_alucardni: Quickly is only the core: so, you can implement your own template using any other vcs
 205 [18:48] <didrocks> something like ubuntu-application-with-git :)
 206 [18:48] <didrocks> or a better name of course
 207 [18:49] <didrocks> but if you want to develop a template with that, you can. Quickly 0.4 is able to import commands from another template
 208 [18:49] <didrocks> so, that save a lot of typing and ease your template creations
 209 [18:50] <didrocks> I don't personnaly know very well git and I think ubuntu-application user, in the ideal case, don't have to bother with which VCS its using
 210 [18:50] <didrocks> also, moving to another VCS means loosing the tight integration with Launchpad :/
 211 [18:50] <didrocks> so, well, it's possible and if you want to give it a try, just go on #quickly, I'll help you to be on the track :)
 212 [18:51] <didrocks> next?
 213 [18:51] <cjohnston> < AnAnt> QUESTION: some projects use XML (rather than po) for translation, is that supported (or will be supported) in Launchpad ?
 214 [18:51] <dpm> Launchpad standardises on the Gettext format, so it does not directly work with xml. That said,
 215 [18:52] <dpm> you can use conversion tools to convert e.g. docbook, xml docs to PO and then import them to Launchpad
 216 [18:52] <dpm> There are some projects which successfully do that
 217 [18:52] <dpm> like for example the ubuntu-dosc
 218 [18:52] <dpm> ubuntu-docs
 219 [18:52] <dpm> also,
 220 [18:53] <dpm> Launchpad is open source, so if anyone is willing to implement other formats
 221 [18:53] <dpm> the developers will be happy to mentor them
 222 [18:53] <dpm> check out
 223 [18:53] <dpm> https://dev.launchpad.net/Getting
 224 [18:53] <dpm> and the session tomorrow on Launchpad translations under the hood
 225 [18:54] <dpm> by adiroiban and henninge
 226 [18:54] <dpm> or you can ask for help on #launchpad-dev
 227 [18:54] <dpm> sorry, I forgot to mention the tool to convert xml to PO
 228 [18:54] <dpm> that's xml2po, available in the main repositories
 229 [18:55] <dpm> and it can convert back to xml once the translations are done
 230 [18:55] <dpm> ok, next question?
 231 [18:55] <cjohnston> < bullgard47> QUESTION: You showed us wonderful translation tools. Why does a German user still find a lot of untranslated strings in Karmic GNOME programs?
 232 [18:56] <dpm> Well, there's quite a lot of translation work to do to translate a full OS - you can contribute to the German translation by joining the Ubuntu German translations team at https://launchpad.net/~ubuntu-l10n-de
 233 [18:56] <dpm> and they should get you started
 234 [18:56] <dpm> or ask us at #ubuntu-translators
 235 [18:57] <dpm> any quickly-related questions?
 236 [18:57] <didrocks> dpm: seems, that people are more focussed on i18n ones ;) You won't get any rest :)
 237 [18:57] <dpm> hehe
 238 [18:58] <dpm> I like that
 239 [18:58] <didrocks> oh, I saw that one:
 240 [18:58] <didrocks> Nafai | Question: Can quickly be configured to use an editor other than gedit?
 241 [18:58] <dpm> well spotted ;)
 242 [18:58] <didrocks> Nafai: yes, you just have to configure it with sensible-editor or export EDITOR variable in your shell
 243 [18:58] <didrocks> then, ubuntu-project template will spot your preferred editor with quickly edit
 244 [18:58] <didrocks> quickly help edit for more info :)
 245 [18:59] <cjohnston> < OwaisLone> QUESTION: Any plans for a Quickly API so that it can kinda hooked into IDEs like Anjuta and Geany?
 246 [18:59] <didrocks> OwaisLone: yes, it's on the road for 0.4
 247 [19:00] <didrocks> so, you'll get a nice API on lucid version of Quickly :)
 248 [19:00]  * didrocks taps gavel
 249 [19:00] <dpm> cool, so I think we can just to thank everyone listening to us and participating, you truly rocked! Thanks!
 250 [19:00] <didrocks> I think we should leave the field to the next session before being hit :)
 251 [19:00] <didrocks> thanks a lot everybody, feel free to ping us and join #quickly
 252 

MeetingLogs/devweek1001/I18NYourApp (last edited 2010-01-29 10:03:17 by dholbach)