jump to navigation

Qt Spotted on TV, Again. January 4, 2014

Posted by tumaix in planetkde-tomazcanabrava.
add a comment

 

font: qt-on-tvhttp://moviecode.tumblr.com/post/72189242007/in-the-tv-series-revolution-the-source-code-of-an

Subsurface 4.0.1 Released January 3, 2014

Posted by tumaix in planetkde-tomazcanabrava.
add a comment

background

Get it while it’s deep and cold. <3

Subsurface 4.0 has been released December 16, 2013

Posted by tumaix in planetkde-tomazcanabrava, uncategorized.
2 comments

The Subsurface developer team is proud to announce the release of the next major version of Subsurface.

Subsurface4Banner

With version 4.0 we switched to Qt as our UI toolkit. This caused the need to do a complete rewrite of a large chunk of the Subsurface code base. We decided to keep much of the logic and core of the existing code around, but used the opportunity for quite a bit of cleanup and many improvements.

The basic concepts are the same, most of the basic features are the same, but trying to create a concise list of changes that summarizes the more than 1600 commits that have gone in since version 3.1 seems a daunting task.

Here are some of the highlights:

  • new map widget with a spinning globe to visualize dive locations ( Thanks Marble  Team)
  • much more “native” look and feel under Windows and Mac ( Thanks to Qt )
  • ability to edit dives “in place”: simply click on an entry in the Dive Notes or Equipment tabs to start editing
  • more data about each dive is presented in the Dive Notes and can be edited without separate dialogs and without having to go through context menues
  • graphical editor for dive profiles for manually added dives
  • better information overlay for the dive profile
  • addition of a “ruler” tool in the profile window that allows measuring of many properties between two points in the profile
  • better tag system with both predefined user-specified free text tags
  • better integration with divelogs.de (upload & download support)
  • ability to show the user manual from within the application without a life internet connection and without opening the manual in an external browser window
  • better statistics (with per-trip statistics available)

As always in a massive rewrite like this, there are still a small handful of known bugs and issues — please check the ReleaseNotes and our bug tracker. The two biggest missing features (compared to 3.1.1) are

  • Filter->Select Events is not implemented
  • Dive planner has been disabled for now

Divers, Free Divers, Tech Divers and Lovers, Rejoice. December 7, 2013

Posted by tumaix in planetkde-tomazcanabrava, uncategorized.
add a comment
Subsurface 3.9.2, the second public beta for Subsurface 4.0 has been released.
We fixed the vast majority of the known bugs, we added documentation and translations (but help with both is still welcome)… we think we’re fairly close to a final release.
Please take a look, give it a spin, file bugs and give us feedback.

Subsurface – What the heck? November 29, 2013

Posted by tumaix in planetkde-tomazcanabrava.
6 comments

It’s well known fact that the Linux mascot is a penguin, named Tux, but did anyone wondered how did the tux became the linux mascot? I’ll tell one thing about Linus Torvalds, He likes to Dive. I mean, he really likes to dive. and Penguins also dive. Proof?

diving

 So Linus was diving around and realized that Linux didn’t have a proper Opensource Software for organizing Penguins sightseeings, What he did? He wrote one. That’s what subsurface is all about. A Dive Log application from Divers, for Divers that works on Linux ( And on Mac and Windows too ). It supports acquiring the dive – data from most of the dive computers that are selled around the world via the awesome libdivecomputer, and also is pretty sleek. It was mainly written in Gtk till version 3.0, but now it’s ported to Qt ( 4.0 for the time being, since we rely on marble for the globe ) but plans for 5.x are being discussed.

But since Subsurface is not a ‘KDE’ app, why the hell it’s here on planetkde?

  1. I’m syndicated, yeah, really.
  2. We use KDE Code ( had to fork some classes because didn’t want to rely on the whole kdelibs just for 2 little widgets, but I’m mainly sure this will change in KF5 )
  3. We use Marble
  4. KDE is about the People that creates code too. :)

And While we prepared Subsurface we also killed a few Qt and Marble bugs ( upstreamed ), what about that?

If you are a diver, If you are a wannabe diver, if you know someone that dives, Tell them that there’s an awesome Dive Logging Application

More information? Go to the subsurface webpage.

Subsurface Switches to Qt November 28, 2013

Posted by tumaix in planetkde-tomazcanabrava.
5 comments

It’s been a long, long while since I don’t blog here, and most of my old blogposts were about Rocs, well.. not anyomore. I joined the Subsurface team about six months ago. It was a program written in Gtk mostly by Linus Torvalds and Dirk Hohndel, and they were opened to switch to Qt, why… why shouldn’t we jump ahead and help the transition to be smooth as it could? So Thiago Macieira and Myself jumped in to help, And it’s been a lot of learning from all sides.

It’s been quite a while – but we have been hard at work. We have migrated Subsurface from Gtk to Qt over the past 6 months. And given the magnitude of this change, we decided to go with a public beta (or two, or three, depending on how things go) before releasing Subsurface 4.

New in version 3.9.1 (compared to Subsurface 3.1):

I don’t even know where to begin. This is a complete rewrite of the UI. The basic concepts are the same, most of the basic features are the same, but trying to create a concise list of changes that summarizes the more than 1200 commits that have gone in since 3.1 seems a daunting task.

Maybe we’ll come up with something better in time for the final release of Subsurface 4.0. :-)

Known issues:

  • integration with divelogs.de is still missing
  • we have reports of occasional crashes on Windows when trying to close the window by clicking on the little x in the window decoration instead of using Alt-F4, Ctrl-q, or File->Quit
  • Filter->Select Events is not implemented
  • Translations are extremely incomplete
  • Documentation has just been started

These last two points are important. Because if you have always wondered “oh I wish I could contribute, too bad I can’t program” – this is your chance. ANYONE can help us with Documentation, and almost anyone (ok, this
does require that you speak a language besides English) can help with translations. Please send us email at subsurface@hohndel.org if you would like to contribute.

You can find Windows and Mac binaries at the usual downloads location. Linux users are more likely to have to build from source. Get the source from git and follow the instructions in the INSTALL file (not from this website, those are still for the Gtk version).

A few words from Dirk:

Working with the Qt community has been a blast.
+Linus Torvalds still may not be a huge C++ fan – but even he submitted C++/Qt patches. Who would have thought.

 

snapshot6

How cute can modeling be ? November 18, 2013

Posted by Sandro Andrade in planetkde-sandroandrade, planetqt-sandroandrade.
8 comments

Heya planet,

It’s been a long time since my last post (as usual :) – hopefully that’s going to change in next months). A lot of things have happened in QtModeling land tough. In case you haven’t read my previous ‘call for arms‘ and ‘XMI serialization and metamodel plugins‘ posts, QtModeling is intended to provide a complete and flexible infrastructure for software (meta)modeling, (automated) architecture design and analysis, model recovery, and whatever comes in mind when you think about software models. Although we are still far from have those features fully available, some interesting capabilities are quite functional.

MOF/UML Metamodel Implementation

The new refactored templates for automatic metamodel implementation make programmatic model manipulation easier by taking ownership of properties with ‘composite’ aggregation and automatically removing elements from all involved property lists when it’s deleted. While Qt properties features described in QTBUG-17301 are still being considered, QtModeling extends Qt property system by defining roles for aggregation, opposite association ends, redefined and subsetted properties, and derived and derived union constructors. Some UML functionalities defined as derived properties/operations still miss implementation but basic features involving class and components diagrams are already in place. XMI serialization, profiles and stereotypes definitions/applications, and imported elements/packages are also currently available.

When building QtModeling, the following Qt Add-ons modules will be available:

  • QtModeling: defines base classes for model elements (QModelingElement and QModelingObject) and QXmiWriter/QXmiReader classes for XMI serialization.
  • QtModelingWidgets: provides two new model classes (QModelingObjectModel and QModelingObjectPropertyModel) and two new view classes (QModelingObjectView and QModelingObjectPropertyEditor) for manipulating models and model element’s properties.
  • QtUml: implements the full UML 2.4.1 metamodel. It comprises 239 classes which are 91.83% automatically implemented by templates. The remaining code represents derived properties and are being implemented on demand.
  • QtMof: implements the full MOF (Meta Object Facility) 2.4.1 metamodel. It comprises 51 classes also almost entirely implemented automatically.
  • QtDuSE: implements the DuSE language/metamodel (part of my PhD research) for automated software architecture design and analysis.
  • QtSADuSEProfile: defines an UML Profile for automated software architecture design of self-adaptive systems. This is required by SADuSE – a specific DuSE design space instance devoted to self-adaptive systems design.
  • Qt metamodel plugins: bind the previous model modules as Qt plugins used during XMI serialization.

DuSE-MT

DuSE-MT is a software modeling framework built on top of QtModeling which provide underlying mechanisms for defining new modeling languages (metamodels), creating models described in available languages (currently UML, MOF, and DuSE), manipulate models via JavaScript, and basic constructs for UML diagrams.

DuSE-MT

DuSE-MT defines a plugin-based architecture (shamelessly :) inspired by Qt Creator’s one), which supports not only Qt metamodel plugins but also extensions implementing new DuSE-MT functionalities such as concrete syntax handling, architecture recovery, automated architecture design, and so on. One of the good things of being a professor is to have students eager to graduate :) and willing to do their final projects in some Qt/KDE related project. Let’s see what happens …

DuSE-MT Plugins

Model Scripting

DuSE-MT’s JavaScript Console allows for defining scripts which might, for example, verify well-formedness rules and/or extend/change the currently opened model. For instance, if you know in advance you are going to use Java to implement the currently modeled system, you might use the following script to verify if any multiple inheritance was found in your model:

DuSE-MT JavaScript Console

While a full OCL parser isn’t already available, such kind of scripts can be really useful (actually it’s even more expressive than OCL since it’s not limited to read-only operations).

QML for UML Concrete Syntax

It’s really amazing how QML seems to be born to make certain things real without much pain :) Even in such highly dynamic cases with many requirements for integrating with C++ objects, QML property binding and some new defined QML items can rapidly gives you some nifty diagrams:

DuSE-MT UML Concrete Syntax

Wondering how much QML code was required to do that ? Here it is:

import QtQuick 2.0

UmlElement {
    UmlSlot {
        id: nameSlot
        anchors.top: parent.top
        Text {
            id: label
            text: element.name
            anchors.centerIn: parent
        }
    }
    UmlSlot {
        id: attributeSlot
        anchors { top: nameSlot.bottom; topMargin: -1 }
        height: (parent.height - nameSlot.height)/2
        ListView {
            model: element.ownedAttributes
            anchors { fill: parent; margins: 4 }
            delegate: Text {
                text: visibility(modelData.visibility) + modelData.name + ": " + (modelData.type ? modelData.type.name:"<no type>")
            }
        }
    }
    UmlSlot {
        anchors { top: attributeSlot.bottom; topMargin: -1; bottom: parent.bottom }
        ListView {
            model: element.ownedOperations
            anchors { fill: parent; margins: 4 }
            delegate: Text {
                text: visibility(modelData.visibility) + modelData.name
            }
        }
    }
    function visibility(visibilityEnum)
    {
        switch (visibilityEnum) {
        case 0: return " "
        case 1: return "+"
        case 2: return "-"
        case 3: return "#"
        case 4: return "~"
        }
    }
}

… and for UML associations:

import QtQuick 2.0
import QtModeling.Uml 1.0
import "util.js" as Util

Relationship {
    name: element.name
    relationshipType: "association"
    source: Util.findQuickItem(parent, element.memberEnds[0].class_.name)
    target: Util.findQuickItem(parent, element.memberEnds[0].type.name)
    sourceAggregation: aggregation(element.memberEnds[0].aggregation);
    targetAggregation: aggregation(element.memberEnds[1].aggregation);
    sourceMultiplicity: element.memberEnds[0].lowerValue.value + ".." + element.memberEnds[0].upperValue.value
    targetMultiplicity: element.memberEnds[1].lowerValue.value + ".." + element.memberEnds[1].upperValue.value
    function aggregation(aggregationEnum)
    {
        switch (aggregationEnum) {
        case 0: return "none"
        case 1: return "shared"
        case 2: return "composite"
        }
    }
}

… where Relationship is a new QML item we implemented based on QPainter API (I still need to learn how to use the new SG API). With such things done, UML concrete syntax implementation becomes the simple creation of QML files with names matching the corresponding UML metamodel element (UmlNode, UmlState, and so on).

QtOptimization

Supporting automated architecture design involves, among other things, the use of some search-based approach to find out several candidate architectures and then choose one that satisfies some specific quality attribute criteria. Elitist population-based algorithms have been successfully applied in such scenario because of their improved performance and fast convergence. If you’ve already played before with JMetal or some other framework for multi-objective optimization, that’s exactly what QtOptimization is intended to be. Currently, only NSGA-II (Nondominated Sorting Genetic Algorithm) is implemented (QNsga2 class), in conjunction with classes for bitwise mutation (QBitwiseMutationOperator), crossover (QCrossoverOperator), polynomial mutation (QPolynomialMutationOperator), simulated binary crossover (QSbxCrossoverOperator), and tournament selection (QTournamentSelectionOperator) operators.

Here is a brief description on how to use QtOptimization for a single-variable/two-objective optimization problem:

// Define objective function 1
class MyObjectiveFunction1 : public QObjectiveFunction
{
public:
    explicit MyObjectiveFunction1(QtOptimization::OptimizationGoal optimizationGoal = QtOptimization::OptimizationMinimizes) :
        QObjectiveFunction(optimizationGoal) {}
    virtual qreal evaluateOnIndividual(const QIndividual *individual) const
    {
        qreal x = individual->realVariableValue(0);
        return x*x;
    }
};

// Define objective function 2
class MyObjectiveFunction2 : public QObjectiveFunction
{
public:
    explicit MyObjectiveFunction2(QtOptimization::OptimizationGoal optimizationGoal = QtOptimization::OptimizationMinimizes) :
        QObjectiveFunction(optimizationGoal) {}
    virtual qreal evaluateOnIndividual(const QIndividual *individual) const
    {
        qreal x = individual->realVariableValue(0);
        return (x-2)*(x-2);
    }
};

QNsga2 nsga2;
MyObjectiveFunction1 *f1 = new MyObjectiveFunction1;
f1->setOptimizationGoal(QtOptimization::OptimizationMinimizes);
MyObjectiveFunction2 *f2 = new MyObjectiveFunction2;
f2->setOptimizationGoal(QtOptimization::OptimizationMinimizes);
nsga2.setObjectiveFunctions(QList<QObjectiveFunction *>() << f1 << f2);

nsga2.setSelectionOperator(new QTournamentSelectionOperator);
nsga2.setCrossoverOperator(new QSbxCrossoverOperator(0.9, 5.0));
nsga2.setMutationOperator(new QPolynomialMutationOperator(0.5, 10.0));
nsga2.createRandomPopulation(48);

// Improve population by 250 generations
for (int i = 0; i < 250; ++i) {
    nsga2.appendNewPopulation();
    nsga2.reducePopulation(48);
}

We’re currently implementing some quality indicators for Pareto-fronts and finish integration of such features in DuSE-MT in order to support better automated architecture design and analysis.

So, interesting stuff coming … I’d really love to see those things effectively integrated in QtCreator, KDevelop, and Umbrello. If you are willing to join the effort, fell free to try it from gitorious and don’t hesitate to contact me if you face any trouble.

See you,

 

Finding the Unloved, in the Valentine’s Day. February 15, 2013

Posted by tumaix in planetkde-tomazcanabrava.
2 comments

Open Your Hearts, Tt’s Adoption Time.

It’s 2013, and the world didn’t end last year like the scientific prediction of a holywood movie.

326797-mayan-calendar-doomsday-memes-end-of-the-world-predictions-mocked-by-m

Unfortunately, not everyone scaped, it seems that while the world didn’t end literally, a lot of developers have abandonned their children, their beloved apps and went to the city of Caracol to survive the mayan’s holywood prediction, and have not ever appeared back.

800px-Panorama_atop_Caracol
This left us with a bunch of applications that are in need of someone to care for them, to hug them at night and say that everything’s gonna be all right. But we lack the manpower for that, and that’s why we are asking your help to revive some applications, that are waiting ( some of them for years ) to have people working with them again.

sad_puppy

Some applications are used by people everyday, but no one is taking care of fixing stuff, implementing new stuff, porting things, improving it to the new decade that’s comming in.

tumblr_lu5hasUADB1qcriito1_400

If you are a developer and remember of an application that’s abandoned, please put it in the wiki, if you remember of something that can be done with it, also add as an GSoC 2013 idea’s page. The whole world will thank you, and you will not make baby konqui cry.

sad_dragon_by_mrsbobetski

If you are interested in taking care of an application and are ‘just’ a student, a hobbyst or don’t program for a long time, fear not, because you will join an amazing community of friends, coders, artists, programmers, shrinks, animal lovers and popcorn ( because I like popcorn ). You will increase your programming skills and work with state of the art developers like Aaron Seigo, David Faure and Thiago Macieira ( and many, many others ) that are behind KDE, Qt and the blue universe itself.

ps. And helping it will make you a great person, and because it’s Valentine’s, remember that only one thing matters if you are in love:

chickenbasic

QtMof/QtUml: XMI serialization and metamodel plugins January 21, 2013

Posted by Sandro Andrade in planetkde-sandroandrade, planetqt-sandroandrade.
4 comments

Hi there,

A lot has happening since my last post about QtMof/QtUml - a Qt5 add-on module devoted to (meta-)modeling and model-driven support in Qt (currently in Qt Playground). Auto-generation of meta-models has been further improved, making of use Qt5′s new features for metatypes, XMI serialization is already in place even though not all specified configuration parameters are currently supported by now. In addition, QtUmlEditor example has been a full testbed for QtMof/QtUml and can probably be useful as a working application afterwards.

Demo video here

Meta-models (like MOF and UML) are now implemented as Qt plugins. That enables editor (and XMI serializer) to be fully independent from modeling language and also sets the stage to deal with user-defined meta-models. We are currently implementing the OCL (Object Constraint Language) parser which will allow users to define and execute ‘sanity checks’ and conformance rules on models. That will also enhance auto-generation of meta-models since a lot of operations and derived properties can indeed by specified in OCL (as already happen in Uml meta-model).

How to try it !

Contribute !

As usual, any help with testing, developing, and reviewing is quite welcome :) Maybe we can expect some model-driven features in QtCreator and KDevelop in a near future ? :)

See you …

2012 Recap for me in KDE. January 2, 2013

Posted by tumaix in planetkde-tomazcanabrava.
1 comment so far

2012 is not the best year for me in the KDE team, I almost didin’t coded, heal life issues keep me busy in a way that I couldn’t avoid. I did a few things however:

  • The program that I started as an University Project back in 2008, Rocs, is now being used in universities around the world for teaching Graph Theory and Data Structures. ( Much thanks to Andreas (CoLa) and Wagner Reck ( wiglot ) for helping me on improve my initial mess into a true opensource project. If you are a teacher or computer scientist student and never heard of Rocs for Data Structures / Graph Manipulation, do a favor for yoursellf and go take a look.
  • I’v spend this year much money on KDE related stuff: Bougth one kick ass Konqui Costume ( that costed around 2,200 EUR, + shipping )  and 2k buttons with konqui paintings to be used everywhere in events. It was used sucessfully in FISL and LatinoWare, the two biggest events in latin americas ( one with around 8k participants and the other with around 5k ). The konqui costume was partially sponsored by Blue Systems ( Thanks o/ ), the company that sponsor the work of Aleix Pol and other great KDE hackers.
  • I’v Been into the two more importants events for KDE in the latin americas, the LaKademy and FISL, LaKademy was the one place that I hacked, tought. It was done primarely to tight the community in the latinamericas – One thing that I like very much is that the people in KDE-BR is like a family, Sandro, Aracele, Filipe, Lamarque, Wagner, Me, Camila, Henrique. We didn’t know anyone, KDE introduced us all, now we all are friends and BFF’s. <3
  • I’v tried to do a internship for KDE with 6 students from one university that I have good relationship with, this experiment failed miserabily and I’ll try to do it again in the future but not in the same way that I did. The students did a few things, but at turtle paces, two quit in the first week, two did nothing for two months, while I was trying and trying to help them, they didn’t want help ( or work… ), that’s a real problem with “Free Software Groups” on universities that I’ll talk more in other post. But seriously, if you don’t want to work, don’t ask for a job. The code that they did will eventually end on KDE 4.11 ( since 4.10 passed by and they didn’t delivered. -.-’ )

This is my small resume for KDE in 2012, I hope 2013 is a better year :)

 

Follow

Get every new post delivered to your Inbox.