=== Jack is now known as Guest63657 === marrusl is now known as marrusl_afk === marrusl_afk is now known as marrusl === yofel_ is now known as yofel [07:32] p === Quintasan_ is now known as Quintasan === davidcalle_ is now known as davidcalle [11:18] hi [11:18] anyone? [11:19] help [11:19] cuc === jbernard_ is now known as jbernard [15:14] Hello [16:59] hello everyone, Ubuntu App Developer Week is starting in a few minutes! [16:59] hellp dpm [16:59] hello :) [16:59] o/ [17:00] yofel: surprise to see you here :/ [17:00] :P [17:00] :) [17:01] * DraZoro says hi all [17:01] I think its time :/ [17:01] !time [17:02] let's wait for a few minutes for the first speaker to turn up... [17:02] c2tarun: uh... lol? [17:03] sorry I'm late [17:03] !time [17:03] :P [17:04] jryannel, no worries [17:05] Everyone welcome the first speaker of today. It's Qt's jryannel, who's going to talk about Qt Quick: Elements/Animations/States [17:05] jryannel: hello :) [17:06] Hi all, [17:06] Before we do, plase download: http://get.qt.nokia.com/training/QtQuickforCppDevelopers/slides/qml-composing-uis.pdf [17:06] wait a sec, why hasnt Classbot +m'd the place yet? shouldn't it be doing that? [17:07] Can I continue? [17:08] There are also the examples/labs available at: http://get.qt.nokia.com/training/QtQuickforCppDevelopers/addons/addon-qml-composing-uis.zip [17:09] This is part of our Qt Quick Essentials Training Material. Available to download from: http://qt.nokia.com/developer/learning/online/training/materials/qt-essentials-qt-quick-edition === basso_ is now known as basso [17:10] We skip the first slides (we covered it roughtly yesterday) and go ahead to slide 21 (Anchors) [17:10] We learned yesterday we can position elements by x, y and width/height. [17:11] Often we want to layout elements [17:11] this is done with anchors [17:11] A anchors is another contract [17:12] It says roughly this element shall always be on the left site of the other element [17:12] anchors.left: other.left [17:12] So also when you move one element the other will always follow [17:13] You have top/bottom/left/right anchors [17:13] and also horizontalCenter/verticalCenter [17:13] Slide 22:Anchors [17:13] This is an example how to use anchors [17:14] remember you can reference other elements by id [17:14] anchors.centerIn: rectangle1 [17:14] centerIn centers rectangle1 in this element (width and height is not changed) [17:15] We jump to slide 25: Margins === ChanServ changed the topic of #ubuntu-classroom to: Welcome to the Ubuntu Classroom - https://wiki.ubuntu.com/Classroom || Support in #ubuntu || Upcoming Schedule: http://is.gd/8rtIi || Questions in #ubuntu-classroom-chat || Event: Ubuntu App Developer Week - Current Session: Qt Quick: Elements/Animations/States - Instructors: jryannel [17:16] An anchors fixes on eelement to another element. [17:16] Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/14/%23ubuntu-classroom.html following the conclusion of the session. [17:17] For reference: We use the slides at: http://qt.nokia.com/developer/learning/online/training/materials/qt-essentials-qt-quick-edition [17:17] Called; Composing User Interfaces [17:17] We are on slide 25 [17:17] A margin provides some space between the anchoring [17:17] Slide: 26 [17:18] Here we see a rectangle containing 2 elements (image + text) [17:18] image and text shall be vertical centered and have some spacing between [17:19] The image is anchored on the left side of the parent's left side [17:19] and has on the left side 1/16th of space of the width of the parent [17:19] and sure the image is vertical centered [17:20] similar applies to the text. But instead of anchored to the parent it's anchored to the image [17:20] The anchors.baseline is important for text to anchors according to the textbaseline [17:21] Anchors are also described in more detail at: http://doc.qt.nokia.com/4.7-snapshot/qml-anchor-layout.html#anchor-layout [17:21] So besides of positioning elements by x,y we can also anchors them with margins. [17:22] Often you want to anchor element in a row or column or a grid. For this we have spezialised elements [17:23] They are called Column, Row, Grid [17:23] They are helper elements to avoid writing common code [17:24] See http://doc.qt.nokia.com/4.7-snapshot/qml-positioners.html for more information [17:25] anchors can be used to produce very powerful ui and also felxible from the screen dimensions [17:26] Okay. Let's go to the next module. We jump over module user interaction and go direct to states [17:26] Please download: http://get.qt.nokia.com/training/QtQuickforCppDevelopers/slides/qml-states-transitions.pdf [17:27] A state describes your ui in different "phases" [17:27] E.g. in simple terms it defines how properties values shall be in these different phases [17:28] If you problem downloading: http://qt.nokia.com/developer/learning/online/training/materials/qt-essentials-qt-quick-edition [17:28] Then choose: States and Transitions [17:29] So think about a stop and a go light. Both are represented by a rectangle [17:29] See 6 [17:29] Slide Nr. 6 [17:30] in a "go" state we want one rectangle green in the "stop" state we want the other rectangle red. [17:30] Slide: 7 [17:31] We describe the states with the states property. [17:31] Which is an array of State elements [17:31] a property array is marked with [ ] [17:32] state go has the name "go" and state "stop" is names stop. [17:32] Both describe changes to properties to elements declared earlier [17:32] "stop" state changes the color of stop_light to red [17:32] and go_light's color to "black" [17:33] How to switch between the states? [17:33] use the state property and assign the state name [17:33] Slide: 8 [17:33] Setting the State [17:34] each element has a state property and a states property [17:34] states is the array of states and state contains the name of the current state. [17:35] onClicked: parent.state == "stop" ? parent.state = "go" : parent.state = "stop" [17:35] onClicked is a clicked handler from the mousearea. [17:35] A mousearea is an area which received mouse clicks, presses, releases... [17:36] we first ask for the current state and if it's "stop" we change it to "go". [17:36] Qt Quick recognizes the change and updates the ui based on the state [17:37] very simple [17:37] We jump to slide: 12 [17:37] Another example, little bit more complicated. [17:38] Qe have a text in a rectangle [17:38] Additional we have a image (clear_button) which is clickable through the mousearea. [17:38] When the image is clicked the text of the text_field is set to "" [17:39] Slide: 13 [17:39] we define 2 states "with text" and "without text" [17:40] "with text" shall be active when the text_field is NOT empty [17:40] the "without text" shall be active when text_field is empty [17:42] Based on the property change notification which allows the property binding "when" is evaluated everytime the text changes [17:42] Side note: A text element will only accept input when it's focused. [17:43] This can be done by clicking in the TextInput or requesting focus with "focus : true" [17:43] When going from one state to another we have a state transition [17:44] State A -> (Transition) -> State B [17:44] Slide: 16 (Transition) [17:45] The red button changes it's color to black via a transition. [17:45] This transition in this case shall be a color animation. [17:45] (Same applies to the black/green button our go button) [17:46] Slide: 17 [17:46] Remember we have the states "go" and "stop" in an earlier example [17:47] We add transitions with the transitions [ ] array property [17:47] Each Transition element describes a transition from one state to another state [17:47] from, to describe when transition is called [17:48] Inside we use an animation (more about animations later) [17:48] so States -> Transitions -> Animations [17:48] We will see animations can also be used standalone and in other situations. [17:49] Let's leave this module and go to: QML Animations [17:49] Please download: http://get.qt.nokia.com/training/QtQuickforCppDevelopers/slides/qml-animations.pdf [17:49] I hope you all have flatrates :_) [17:50] An animation generally describes a property change according to a easing curve and duration. [17:51] So instead for example an elements position shall be changes from x:0 to x:100 it shall not go immediately [17:51] It should go in a defined way from 0 to 100 in maybe 1second and first a little bit faster and then slower. [17:52] There are 10 minutes remaining in the current session. [17:52] Slide: 6 in the qml-animations.pdf titled "Number Animations" [17:53] We have in general NumberAnimation, ColorAnimations, RotationAnimations and PropertyAnimations [17:54] We use here: NumberAnimation on x { .... } [17:54] Means it will animate x from 0 to 150 in 1 sec (1000msecs) [17:55] This will done automatically when the component (qml file) is loaded [17:55] Slide 8: PropertAnimations [17:56] Here we use an animation as a standalone animation. We need to specify the target and which properties we want to animate. with running: true you specify it shall run when the component is loaded. [17:57] There are 5 minutes remaining in the current session. [17:57] If you would give the animation an id (e.g. id: anim ) you could also start it with anim.start() [17:57] You can find more about Animations and Transitions at: http://doc.qt.nokia.com/4.7-snapshot/qdeclarativeanimation.html [17:58] I think this it it for now. I will make a 10min break and be back with the next session [17:59] Thanks for listening :) === tubadaz is now known as tubadaz_away === tubadaz_away is now known as tubadaz === ChanServ changed the topic of #ubuntu-classroom to: Welcome to the Ubuntu Classroom - https://wiki.ubuntu.com/Classroom || Support in #ubuntu || Upcoming Schedule: http://is.gd/8rtIi || Questions in #ubuntu-classroom-chat || Event: Ubuntu App Developer Week - Current Session: Qt Quick: Rapid prototyping - Instructors: jryannel [18:02] Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/14/%23ubuntu-classroom.html following the conclusion of the session. [18:10] Before I continue on rapid prototyping... some remarks to animations [18:10] There are several ways to use animtions: [18:10] * Animation on [18:11] * Animation { } // standalone [18:11] * Animation during a state transition [18:12] * Behavior on // when property changes than always with the specified animation [18:12] You can nest animations with ParallelAnimation and Sequential Animation. [18:13] There is also a PauseAnimation, which waits some time before continue with the next animation in a group [18:13] IMPORTANT!!: If an element is anchored for example on the left and right, x can't be animated!! [18:14] anchoring is stronger!! [18:14] if an element is anchored on left and right, sure y can be animated and also the height. but not the width and x [18:16] All of this is available as a 5 1/2 hour talk here: http://qt.nokia.com/developer/learning/online/training/training-day-at-developer-days-2010 [18:16] Just make yourself a nice video evening instead of watching lord of the rings [18:16] Coming to "Qt Quick Prototyping" [18:17] Please have a look at: http://qt.nokia.com/developer/learning/online/talks/developerdays2010/tech-talks/qt-quick-rapid-user-interface-prototyping [18:18] Sorry I planned to have a screen sharing available. I hope at least some of you can watch the video [18:18] Anyway I will explain about the thoughts behind... [18:19] Qt Quick was designed to bridge the gap between "designers" and "developers" [18:20] In a normal design driven project you have [18:20] designers, which think about the user interaction, graphics and nowadays animation (e.g. motions) [18:21] Then they use tools like Flash or paper or PhotoShop to sketch the ui. [18:21] Present beautiful design to their bosses and then ... [18:21] They throw these design to the c++ developer and ask them to implement this. [18:22] Sure the result will be miles away from the the sketch. It's a different technology maybe even different HW on embedded [18:23] Qt Quick allows designers early on to work with the same technologies as all the other developers [18:23] Sure these kind of designers should now how to work e.g. with HTML/JavaScript of Flash/ActionScript. For them it's pretty easy to come to Qt Quick [18:24] The result is that at any time developers and designers work on the same code base and it's easy to sketch a first ui prototype ... [18:25] and then the prototype goes over nicely into production code [18:26] By this you can shorten the time to market but also ensure the that the UI is really that what someone asked for. Pixelperfect [18:27] Qt Quick is fast to code. So that you can create many different prototypes easily and then just ask you users, which one they like best [18:27] Another aspect id that the ui code is cleanly seprated from the c++ code. [18:28] This allows you to unit test your models and business logic and heavy lifting... [18:28] and push a simple and clean qml API towards the ui developers [18:29] Qt Creator contains a design mode, which allows you to drag-n-drop ui elements (and your custom components) on a surface to sketch your ui [18:30] When you are in a qml file hit the button on the left "Design" [18:30] in Qt Creator [18:31] Here you can create a first sketch. But finally you want to switch to your code (editor) to make the more complicated stuff [18:31] So an interaction designer creates "wireframes" e.g. like on http://balsamiq.com/ [18:32] A graphics designer makes nice graphics to the wireframe, e.g. with photoshop, gimp, inkscape, ... [18:33] A motion designer thinks about how ui elements should be animated. [18:33] This is currently how I see designers. I'm not a designer I'm a programmer and I always wondered how they work === tubadaz is now known as tubadaz_away [18:35] We have material for designers ready at: http://qt.nokia.com/developer/learning/online/training/materials/qt-quick-for-designers [18:35] Especially module 6 talks about the different designer roles. [18:36] If you target a UI different from a standard desktop UI you want to have a design affine person in your team. [18:36] Especially with Qt Quick. This makes it really efficient. [18:37] If you target a standard desktop UI you want to create a set of standard UI elements or use/extend the elements produce by the Qt Components project [18:37] See https://qt.gitorious.org/qt-components [18:39] I posted this link already yesterday: http://labs.qt.nokia.com/2011/03/10/qml-components-for-desktop/ [18:39] When I prototype a UI I always start with rectangles [18:40] I normally use black background and white borders. [18:40] Just make sure you get the dimensions right. Maybe add some text to label an element [18:40] Then concentrate on the application logic [18:41] E.g. when I press here what should be happen? [18:41] At then end you look into the animations. [18:41] When something changes, then how. Should it fade (animation on opacity), should it fly in (animation on x) === tubadaz_away is now known as tubadaz [18:42] Should it fly and fade (parallel animation on opacity and x) [18:43] You should extract components early on (e.g. mybutton, mytextedit, mycheckbox, etc... [18:43] Then you concentrate on the more details and bring in the graphics, colors, gradients, etc... [18:44] Make sure you get the structure right. give application wide used elements a good id. [18:45] Mark internal properties with '_ [18:46] Try to avoid to be to dependent on your c++ backend, I use a bool _debug property to guard sometimes those dependencies [18:46] Try not to create a reusable component which can be reused in all projects in the future. [18:47] Designers think more in reuse by copy. Just make the element work for your needs. Qt Quick can be fast adapted anyway [18:47] I guess that's it is for now. Any questions? [18:49] Take care and hope you enjoined this lengthy talk :) [18:49] Ohh, one link at the end [18:50] https://gitorious.org/qtmediahub, a XMBC (MediaCenter) clone in qt [18:50] And https://gitorious.org/qmlshowcase. [18:51] qmlshowcase was produced for a customer in one afternoon! Check it out [18:52] There are 10 minutes remaining in the current session. [18:57] There are 5 minutes remaining in the current session. [18:59] Thanks jryannel for this Qt Quick marathon as a great starter for the day! Next up: mterry will tell us about Rapid Application Development with a tool you can never get enough of: Quickly! [18:59] yay [18:59] Just real quick: I have notes here if you're interested: https://wiki.ubuntu.com/Quickly/AppDeveloperWeek11.04 [18:59] I'll add a link to the meeting logs there after the fact too [19:00] So, I'm Michael Terry, a maintainer of Quickly [19:00] https://wiki.ubuntu.com/Quickly [19:00] Quickly is a template-based system for writing applications [19:00] quickly, easily, and hopefully fun [19:01] At it's heart, it's just a system of templates with boilerplate code and a few commands [19:01] But all the templates are currently Ubuntu-focused, so that's where it gets the most attention [19:01] Each template makes opinionated choices for you, so the app author can just focus on writing their app === ChanServ changed the topic of #ubuntu-classroom to: Welcome to the Ubuntu Classroom - https://wiki.ubuntu.com/Classroom || Support in #ubuntu || Upcoming Schedule: http://is.gd/8rtIi || Questions in #ubuntu-classroom-chat || Event: Ubuntu App Developer Week - Current Session: Rapid App Development with Quickly - Instructors: mterry [19:02] We try to give him/her the recommended technologies by default [19:02] Logs for this session will be available at http://irclogs.ubuntu.com/2011/04/14/%23ubuntu-classroom.html following the conclusion of the session. [19:02] oh, whoops [19:02] well, the logs might not have that starting part [19:03] Quickly in Ubuntu 10.10 has three templates: ubuntu-application, ubuntu-cli, and ubuntu-pygame [19:03] In Ubuntu 11.04, we're adding a new template, ubuntu-flash-game [19:03] A new command "submitubuntu" which helps get your app into the Software Center [19:03] And we've redesigned the project layouts a bit [19:04] I'll note when I'm talking if something applies only to the 11.04 version or not [19:04] If anyone has any questions as I go through this, please let me know in the classroom [19:04] classroom-chat that is [19:04] So today, I'm just going to give a bit of an overview for how to use Quickly [19:04] And what it can do [19:05] It's simple enough to get started. Just "sudo apt-get install quickly" [19:05] This will install a bunch of packages, which are development tools and documentation [19:05] But most importantly, it will install Quickly :) [19:06] Now I'll show you how to create a little throw-away app we can practice on here [19:06] "quickly create ubuntu-application test-project" [19:06] This will create a new directory "test-project", put a lot of boilerplate in there, and open your new project [19:06] You'll see that a window and some widgets and dialogs have been created for you [19:07] That's part of the boilerplate I mentioned before [19:07] You can customize this as much as you want, but Quickly gives you something to hit the ground running with [19:07] Now you want to enter your project directory: "cd test-project" [19:08] And here, if you typed "quickly tutorial" you would get a nice tutorial about how to make changes in the project you've just created [19:08] That's a good command to note for later [19:08] But I'm going to move on and explain some of that myself [19:08] Though the tutorial is valuable, and you should consider running through it later [19:08] So the first thing you're likely to want to change is how the app looks [19:09] In your project directory, you can type "quickly design" [19:09] And Glade will open up [19:09] Glade is a tool that lets you edit GTK interfaces by clicking around [19:09] Kinda like Visual Basic, but without any of the code elements [19:09] Glade by itself doesn't integrate with code [19:10] But Quickly matches them up for you [19:10] * mterry pauses for a sec, any questions? [19:11] OK, so let's talk a bit about Glade. If you're not familiar with it, it can be a bit intimidating [19:11] You've got your "tool palette" of widgets on the left [19:11] The middle is where you see what you're building [19:11] And the right is where you can select widgets from the widget tree or edit the currently selected widget [19:11] If you just click directly in the middle on the widget you want, it will be selected [19:11] Or if you find it in the widget tree in the upper right [19:12] In GTK, widgets are layed out in boxes, either horizontal (HBox) or vertical (VBox) [19:12] So you first create a box, then add widgets to it. And you can next boxes for more complicated layouts [19:13] Once you add a widget to a box, you can change its position in the box by going to the Packing tab in its properties box in the bottom right [19:13] There you'll also be able to change how any widget is given space [19:13] You can see the Expand and Fill properties [19:13] Most things start taking up all the space they can, but that's not always the effect you want [19:14] Those are common properties to adjust to get the layout you want === AndrewMC is now known as Guest80546 [19:14] Another thing to note is that when adding icons or menu items, you often want to use stock items where possible. That will use the correctly themed icon and automatically add translated text where appropriate === Guest80546 is now known as AndrewMC [19:15] Speaking of translations, you can choose translation options for any label in the properties box (like whether it is translated or to leave comments for the translator) [19:15] OK, enough Glade [19:16] You can play with it as needed and just remember that you can always Undo any mistake you make or don't know how to correct :) [19:16] So remember, "quickly design" to edit your UI [19:16] You can make new dialogs inside Glade, but it's better to let Quickly make them for you, so that they are hooked up correctly in code [19:17] So let's say you want to add a cool new dialog. You can type the following: "quickly add dialog save-dialog" (for a fictional Save dialog you wanted to add) [19:17] After you do this, you should probably close Glade and re-open it with "quickly design" [19:17] Now Glade will see your new dialog and you can edit it as you like [19:18] Specifics and code examples of adding dialogs are also in the "quickly tutorial" tutorial [19:18] But I'll be brief here [19:18] From your main window, you need to import the new code module that Quickly made: "from project_name.DialogName import DialogName" [19:19] So for this project, that would actually be "from test_project.SaveDialog import SaveDialog" [19:19] Then you use normal GTK code to run it and check the result: [19:19] d = DialogName() [19:19] response = d.run() [19:19] if response == gtk.RESPONSE_OK: [19:20] #do your stuff [19:20] d.destroy() [19:20] And that's it! [19:20] Pretty simple to make a dialog [19:21] Now, if you want to respond to what the user does, you're going to need to listen to GTK signals [19:21] Real briefly, when the user does something like click a button, GTK emits a signal that you can respond to, like "clicked" [19:22] Important signals that you may care about are that buttons emit the "clicked" signal, menu items emit the "activated" signal [19:22] It's really easy to handle these signals [19:22] Let's say you want to handle a menu item press in your main window [19:22] You first note what the menu item is called in Glade [19:22] You can check this from the widget tree in the upper right [19:22] Remember that name [19:23] Now in the code, you can add a new function named like: [19:23] def on_menuitem1_activated(self, widget, data=None): [19:23] and inside that function, add the code that should happen when the menu item is pressed [19:24] Quickly already provides some code for common menu items like Quit and About, but not all of the default menu items have code already [19:24] In Ubuntu 10.10, you'll also need to go into Glade and point it at your new function [19:24] There is a "Signals" tab in the bottom right [19:24] And go there and enter the name of the function you just created next to the "clicked" signal [19:25] In Ubuntu 11.04, Quickly can do this for you, as long as you name it like above: on_WIDGET_SIGNAL [19:25] So a "clicked" signal on "button1" would be on_button1_clicked [19:25] * mterry pauses for a sec. Any questions? [19:26] hobbsc asked: Is quickly generating gtk2 or 3? [19:26] hobbsc, GTK 2 for now. I'd like to move it to 3 next cycle [19:27] But in keeping with using the recommended tools, GTK 2 is still the default toolkit for Ubuntu 11.04 [19:27] I believe Ubuntu will be ported to 3 next cycle, so Quickly should move along with it [19:27] OK. So if you want to edit the code that Quickly makes [19:28] incorrect, asked about PyGI vs PyGTK [19:28] PyGTK won't support GTK 3, so we'd have to move to PyGI at the same time. Quickly doesn't currently use PyGI [19:29] So if you want to edit the code, you can just open up the test_project folder in your project and look at all the code. Or run "quickly edit" [19:30] You'll see for example that your main TestProjectWindow class has a function "finish_initializing". This is the recommended hook for inserting your own startup code [19:30] In Ubuntu 11.04, there will be a test_project_lib folder that contains code that Quickly "owns" and it isn't recommended you touch it. But you can take or leave the code there yourself. There will be one entry point in the main TestProjectWindow class that you control [19:31] So let me talk about debugging real briefly [19:31] The usual recommended method is just adding print statements and seeing what effect that has. :) [19:31] It's quick, dirty, and easy [19:32] If you are interested in more comprehensive debugging, especially if you want to be able to ask your users for log files, you can use the logging framework [19:32] The sample code Quickly makes does that, so you can see code examples [19:32] It by default won't spit out messages unless you're running your app in verbose mode [19:32] Or if you're debugging something very complicated, you can use pdb, which is a python debugger [19:33] It's a bit difficult to use, so I just recommend using print statements [19:33] Oh, I forgot! If you want to run your app after you close it, use "quickly run" [19:33] And "quickly help" should give you a list of commands [19:34] So now we come to the exciting stuff. So far, Quickly has just been a jump-start to your app development [19:34] But it also integrates with Launchpad to help you publish, share, and maintain your software [19:35] For example, it keeps your code in bzr and you can save your changes with "quickly save" [19:35] Or if you have a Launchpad project, it can upload tarballs and make announcements [19:35] crazedpsyc asked: When might logging be better than print statements? I think printing some error messages that identify the line of code that has the problem and what the problem is is much more useful, because users usually don't bother to find and read log files [19:36] crazedpsyc, for errors that you "expect" to see in the field like a file that didn't open or an unexpected corner of your code [19:36] I would recommend logging [19:37] I think print statements are most useful just for yourself when you're hunting down some problem [19:37] So that is, your app should probably ship with just logging lines [19:37] But when I'm futzing with it, I like to add print lines to find where the problem is [19:38] So let's talk a bit about packaging [19:38] This is something that is normally difficult to do, but Quickly tries to make easy [19:39] You have different "levels" of complexity here. You can create a local Ubuntu package, you can share your package with testers, you can publish a new final version of your package, or you can even put your package in the Software Center [19:39] Let's start simple [19:39] "quickly package" will package up your current code and create a .deb file for you [19:40] But before you do that, actually, it's probably a good idea to set up some metadata [19:40] You can open the setup.py file that Quickly made for you: "gedit setup.py" [19:40] Near the bottom are some fields like author name, etc [19:40] You also probably want to edit the AUTHORS file and put your name and email there [19:41] And if you had a particular license in mind besides GPL-3, you can run "quickly license BSD" or whatever license you like [19:41] GPL-3 is the default though [19:41] You may also want to edit test-project.desktop.in and change the application properties so it shows up in the right application category in the menus [19:41] You can see a list of the correct categories here: http://standards.freedesktop.org/menu-spec/latest/apa.html [19:42] OK, now that we did all that bookkeeping, you can make your package [19:42] You could have made it before too, Quickly will just fill in bogus info for you [19:42] But it's better to have it all nice and correct :) [19:42] So now after a "quickly package" you'll have a .deb file [19:42] You can double click on this in the file manager and install it into your system for testing [19:43] And you can share that .deb via email or a web site for a small number of people [19:43] But if you want wider testing [19:43] You may want to consider creating a PPA [19:43] PPAs are a little bit more involvement for you, but it makes it so much easier to test your app that it's probably worth it for you in order to have more testers [19:44] So Launchpad has some good documentation on what you need to do here, https://help.launchpad.net/Packaging/PPA [19:44] But you'll need an SSH key and a GPG key [19:44] https://help.launchpad.net/YourAccount/CreatingAnSSHKeyPair [19:44] https://help.launchpad.net/YourAccount/ImportingYourPGPKey [19:44] Those are a couple more Launchpad help pages for how to make those [19:45] Once Launchpad knows about you and you've created the PPA, you're ready to tell Quickly [19:45] You should set DEBEMAIL and DEBFULLNAME environment variables for the benefit of "quickly package". This will note that you were the one that created the package, otherwise Launchpad won't accept it [19:45] So set them like: [19:45] export DEBEMAIL="oliver.twist@example.com" [19:46] export DEBFULLNAME="Oliver Twist" [19:46] If you put those lines in your ~/.bashrc file, they will be set up for you every time you log in [19:46] OK, now you're all set [19:47] So if you enter "quickly share --ppa testing" it will create a new in-progress package with a version like 0.1~public1 and push it to the PPA you specify on the command line [19:47] So if you have a testing PPA, which is recommended, you can easily get feedback by sharing a new package every now and then [19:48] If you want to actually make a full release, you can do "quickly release --ppa release" and Quickly will increment the number for you and push it to the the PPA you specify [19:48] Just like the share command [19:48] By default, Quickly will pick YEAR.MONTH versioning [19:48] But you can specify the version you want to the release command [19:48] Run "quickly help release" for details [19:49] And now finally, there is a new command in Ubuntu 11.04 that lets you prepare an upload for acceptance into the Ubuntu Software Center [19:49] "quickly submitubuntu" [19:50] This creates and publishes a package to a PPA just as quickly release does [19:50] So you can pass --ppa and such [19:50] The package will have files installed into /opt as required [19:50] The package will also have special metadata that is used by the Software Center (like where the screenshot lives and such) [19:50] (See https://wiki.ubuntu.com/AppReviews for how to get approved) [19:51] You can create the same kind of package without uploading it by using "quickly package --extras" [19:51] This will generate the /opt packaging and such for you to test with [19:51] There are 10 minutes remaining in the current session. [19:51] incorrect mentioned integration with Eclipse [19:52] That is something I'd like to see happen too, but we haven't focused on that yet [19:52] Also integration with Anjuta and any other IDEs out there [19:52] We'd like to make it easy for that to happen [19:52] But we figured most programmers are familiar with the command line so we haven't rushed to IDE interaction [19:53] Again, the current set of templates (ubuntu-application, ubuntu-cli, ubuntu-pygame, and ubuntu-flash-game) are just what we've done [19:53] But it's hopefully easy to make a template of your own [19:53]