May 24, 2018

Este año estoy dejando de lado a los eventos que organiza los chicos de Barcelona Free Software. Se me pasa promocionar sus charlas, y eso que siempre creo que son muy interesantes. Espero que me perdonen y que vean mi buena voluntad promocionando la próxima charla en la que tendremos a Docker en los meetups de Barcelona Free Software. Si pudiera, no me lo perdería.

Docker en los meetups de Barcelona Free Software

Docker en los meetups de Barcelona Free SoftwareSegún podemos leer en la página de la Wikipedia, Docker es un proyecto de código abierto que automatiza el despliegue de aplicaciones dentro de contenedores de software, proporcionando una capa adicional de abstracción y automatización de Virtualización a nivel de sistema operativo en Linux.

Así que si quieres saber más Docker te propongo que asistas al próximo Meetup del Barcelona Free Software donde el gran Alex Fiestas no solo nos lo presentará y nos animará a realizar un taller en vivo.

Los datos importantes de Docker en los meetups de Barcelona Free Software son los siguientes:

Además, recuerda que tendremos el usual “networking” con cerveza gratis incluida. Este meetup está organizado por KDE España, la asociación nacional de usuarios y desarrolladores de KDE, un proyecto de software libre que crea el Plasma Desktop y cientos de aplicaciones usando Qt y QML

No te lo pienses. ¡Te esperamos el martes 29 de mayo

Más información: Barcelona Free Software

¿Qué es Meetup?

Las charlas de Barcelona Free Software se organizan mediante Meetup, una red social que tiene una diferencia básica respecto a otras redes sociales, ya que  promueve la formación de grupos en torno a intereses con el fin de que sus miembros se conozcan cara a cara.

Es decir, los usuarios establecen contacto a través de grupos digitales nuevos o ya creados, partiendo de intereses comunes como política, libros, juegos, películas, salud, mascotas,

Now that Qt 5.11 is released, it is finally time to upgrade the last Qt 1.0 applications out there… No, not really. �� I want to take a look at how well we have kept compatibility in Qt over the years since the first official release.

Qt guarantees source and binary compatibility between minor releases, and we take that seriously. Making sure that you don’t have to rewrite (or even recompile) your application when you upgrade to a newer version of Qt is important to us. However, there are times when we need to make bigger changes in order to keep Qt up to date. This is done in major releases. Since the release of Qt 1.0 in 1996 (almost twenty-two years ago), we have broken source compatibility four times: in 2.0, 3.0, 4.0 (some of you may remember that as a painful transition), and 5.0.

We do try to keep breakages to a minimum, even in the major releases, but the changes do add up. This raises the question: How hard would it be to port a Qt application from Qt 1.0 to 5.11?

To find an answer to this question, I took the tutorial example from the Qt 1.0 release, and tried to compile it against Qt 5. Since the Qt archives only go back to version 1.41, I actually had to retrieve it from ancient history which has been preserved through four different source code control systems …but I digress. Its name is t14 because it is the 14th and final chapter of the tutorial.

Here are the steps I needed to make to get it to build and run.

  • Import tutorial 14 from Qt 1.0 10 files changed, 798 insertions(+)

    This is the state of the art: the official recommendation from Troll Tech (we weren’t Trolltech yet) on how to write programs with Qt 1.0, in 1996.

  • Translate to qmake 3 files changed, 2 insertions(+), 148 deletions(-)
    tmake
    Before qmake, there was tmake. tmake was written in Perl. The basic syntax was the same, except that qmake no longer allows embedding Perl code in the project files. This is probably for the best…

    Also, tmake was not public, so we would generate Makefiles for the release packages. Having completely different internal and external build systems added excitement to the release process.

  • Fix include file names 4 files changed, 8 insertions(+), 8 deletions(-)
    includenames
    Back in the old days, Windows only allowed eight character file names. We did have proper include files on Unix, but if you wanted your code to be portable, you had to use wonderful names like "qscrbar.h" and "qbttngrp.h".
  • Add missing includes 1 file changed, 3 insertions(+)

    Dependency on indirect includes was a problem back then as well.

  • Change TRUE/FALSE to true/false 1 file changed, 13 insertions(+), 13 deletions(-)
    truefalse
    Kids these days. They don’t know how lucky they are. We had to make our own bool type.
  • Fix things moved to the Qt:: namespace 3 files changed, 15 insertions(+), 15 deletions(-)
    namespace
    The Qt namespace was introduced in 1998 … as a class, since we didn’t have those fancy namespaces back then.
  • Remove “name” argument 6 files changed, 26 insertions(+), 26 deletions(-)
    objectname
    All constructors of QObject subclasses used to take the object name as a parameter.
  • The QScrollBar API has changed 1 file changed, 5 insertions(+), 5 deletions(-)
    scrollbarapi
    Sometimes we have to get rid of old, bad APIs. Having individual setter functions is much better than a constructor that takes 7 arguments.
  • Use QString instead of const char * 2 files changed, 2 insertions(+), 2 deletions(-)
    qstring
    QString has been in Qt since 1994. It used to be 8 bit Latin1 with an automatic cast to const char*, so the API would use const char * arguments. Unicode support was introduced in Qt 2.0.
  • warning() is called qWarning() now 1 file changed, 1 insertion(+), 1 deletion(-)

    We avoid putting identifiers into the global namespace. Except for the letter ‘Q’. We own that.

  • Remove calls to old QApplication functions 1 file changed, 2 deletions(-)
    qapp
    Qt does the right thing automatically these days. In 1996, most displays used 8 bits per pixel. You had to tell Qt if you wanted to use other colors than the 256 standard ones.
  • Replace QAccel with QShortcut 1 file changed, 4 insertions(+), 3 deletions(-)
    shortcut
    QShortcut is more powerful and easier to use, and the name is not an abbreviation. It was introduced in 2004.
  • Fix repaint logic 1 file changed, 7 insertions(+), 7 deletions(-)
    repaint
    In the ’90s, we could just paint directly onto the widgets whenever we wanted. Nowadays everything is buffered and composed, so we have to make an update request, and later repaint the widget when we get a go-ahead. Fortunately, this simplifies the logic.
  • QObject::killTimers() doesn’t exist anymore 2 files changed, 3 insertions(+), 2 deletions(-)
    killtimer
    This function was just too dangerous. It would kill all timers belonging to an object, including those used by Qt internally. Now you have to kill timers individually.
  • QWMatrix is now QMatrix 1 file changed, 2 insertions(+), 2 deletions(-)

    A simple name change.

  • QWidget::setBackgroundColor() is gone. 1 file changed, 3 insertions(+), 1 deletion(-)
    realbackgroundcolor
    Background color is no longer a separate concept: it’s wrapped inside QPalette together with all the other color roles. Also, child widgets are now transparent by default. We have to tell Qt to draw the background.
  • Can’t fill pixmap with contents of widget anymore 1 file changed, 1 insertion(+), 1 deletion(-)
    pixmapfill
    We use a transparent pixmap instead, since Qt supports that now.
  • Rectangle painting has changed since Qt 1.0 1 file changed, 1 insertion(+), 1 deletion(-)
    drawrect
    This is the worst incompatibility so far: In Qt 4.0 QPainter::drawRect() was changed so that “a stroked rectangle has a size of rectangle.size() plus the pen width”. Therefore, we need to subtract the pen width (i.e. 1) before passing the rectangle to QPainter.

Now we have a fully functional port of the tutorial example, and here is a screenshot:

t14 take one

Oops… Some of the text is clipped. It turns out that the example used hardcoded sizes and positions for most of the elements, and font sizes have changed a bit since 1996. The solution is to use QLayout, which was not available in Qt 1.0 (the first version was added in Qt 1.1, and it was completely rewritten for 2.0).

With this change, everything looks as it should:

t14 with layouts

So, what did we learn? It did not take that much effort to port tutorial 14 from Qt 1.0 to Qt 5.11. It probably took me longer to write this blog post. Most of the 1.0 API still lives on in recognizable form. The incompatible changes have improved the usability, readability and safety of Qt code.

This was just a small example, of course. Porting a full-sized application across multiple major versions would probably be more difficult. Fortunately, we have a vibrant Qt ecosystem with several companies offering consultancy services .

The post Porting guide from Qt 1.0 to 5.11 appeared first on Qt Blog.

May 23, 2018

Seguimos con un estrés que no se acabará hasta agosto. Así que toca artículo rápido pero intenso, ya que me voy aprovechar del gran trabajo realizado por el gran elav en que nos permite echar un vistazo al futuro Plasma 5.13, cuya beta vimos hace casi una semana. Yo, de vosotros, no me lo perdía.

Un vistazo al futuro Plasma 5.13

Un vistazo al futuro Plasma 5.13En palabras de elav “En el siguiente video les muestro de forma rápida algunas de las características que se avecinan con esta nueva versión de Plasma, una versión además que, según sus desarrolladores, han estado trabajando arduamente para continuar convirtiendo a Plasma en un escritorio liviano y sensible, que cargue y funcione rápidamente, pero que mantenga todas las funciones con un aspecto y tacto pulidos. ”

De esta forma, empezando desde la pantalla de presentación, elav nos va mostrando el nuevo fondo de pantalla, la renovada y adaptativa Preferencias del Sistema, el optimizado consumo de RAM, la integración con los navegadores, la pantalla de bloqueo, transparencias en los menús y submenús,  y un largo etcétera.

No me enrollo más y os recomiendo disfrutar del vídeo de menos de 14 minutos Plasma 5.13.

Las novedades de Plasma 5.13

El próximo 12 de junio se lanzará, si todo va según lo previsto, el nuevo escritorio de la Comunidad KDE, el cual promete venir cargado de novedades, algunas de las cuales se resumen en la lista inferior.

  • Mejoras en la integración de los navegadores web.
  • Mayor optimización de recursos para equipos de poca potencia.
  • Nuevos efectos visuales como el desenfoque (blur).
  • Mejoras en Wayland.
  • Retoques en las Preferencias del Sistema.
  • Nuevas pantalla de bloqueo y de autentificación.
  • Mejoras en el gestor de aplicaciones Discover.
  • Nuevo y precioso fondo de pantalla.

Y un buen número de pequeños detalles que seguro que nos ofrecerán el mejor Plasma 5 de la serie, como nos vienen acostumbrando versión tras versión.

Más información: KDE.org

Hi everyone,

The first week of the coding period was great and I got to learn a lot of new things. My mentors help me on every stage and the work is going on as planned ��

The aim of my project is to create kids interest in drawing, designing, animations, and graphics through educational activities in GCompris. I started with the “Drawing” activity. This activity will provide the tools and workspace to the kids for drawing beautiful arts and know about the basic drawing tools. This activity was started in the previous GSoC, but it still requires a lot of work and new tools implementations. The main aim is to provide as much as possible canvas region to draw on. I and my mentors decided to make a foldable-panels based UI. Here is the first look at the activity, it still needs a lot of work on UI, which I have planned to do in upcoming weeks.

paint

For displaying different brushes, stamps, and settings for a tool available, we will be displaying a pop-up for these settings. First look at the tools mode ->

paint

Improvement in the overall UI is still in progress. Other than this, I have been working on refactoring the current code for this activity and breaking the whole code into various elements. For the next week, my main task is to complete the overall UI of this activity and add more geometries for drawing.

I’d appreciate your feedback on the work done so far and suggestions on the improvement of this activity.

Work branch -> https://cgit.kde.org/gcompris.git/log/?h=gsoc_asagtani_paint

Link to proposal -> https://www.dropbox.com/s/79jq0ltkg4rv8ir/GSoC_KDE_amit.pdf?dl=0

Happy coding ��

May 22, 2018

The forthcoming new release of Plasma 5.13 will have some lovely new features such as rewritten System Settings pages and Plasma Browser Integration.  But we need testers.

Incase you missed it the Plasma 5.13 release announce has a rundown of the main features.  If you are an auditory learner you can listen to the Late Night Linux Extra podcast where Jonathan “great communicator” Riddell talks about the recent sprint and the release.

You can test it out with the KDE neon Developer Edition Git-Stable ISO which you can download now.  Git-stable includes beta builds of KDE’s software.  Or you can try the latest KDE neon Docker image which runs the desktop inside Xephyr with a simple command of neondocker -e dev-stable.

What have the public been saying about Plasma 5.13 beta? Let’s pick some random comments from Reddit:

br_shadow – Plasma is by far the best linux DE

Thanks br_shadow!

aturfer 26 points  – I’m going to make another financial donation to the KDE project.

Good idea aturfer!

mleko69 

> KDE Plasma

> lightweight

What a time to be alive

Oh yes it is mleko69!

masteryod 17 points 

Holy shit that changelog is amazing!

We try to please mastyod!

tnsittpsif190 points I am so pleased with KDE and the development team. I love the workflow it offers. It is both, beautiful and professional at the same time.

We succeed in pleasing tnsittpsif!

So give it a try, report problems, 2.5 weeks until final is out.

Hi,
Yesterday I came back from 3,5 days of Krita Sprint in Deventer. Even if nowadays I have less time for Krita with my work on GCompris, I’m always following what is happening and keep helping where I can, especially on icons, and a few other selected topics. And it’s always very nice to meet my old friends from the team, and the new ones! ��

A lot of things were discussed and done, and plans have been set for the next steps.
I was in the discussions for the next fundraiser, the Bugzilla policies, the next release, the resources management rewrite, and defining and ordering the priorities for the unfinished tasks.

I did start a little the french translation for the new manual that is coming soon, mostly porting the existing translation of the FAQ and completing it. Again about the manual I gave a little idea to Wolthera who was looking at reducing the size of png images.. result is almost half smaller, around 60Mo for 1000pages, not bad ��

I discussed with Valeriy, the new maintainer of kcm-wacomtablet, about some little missing feature I would like to have, and built the git version to test on Mageia 6. Great progress already, and more goodies to come!

As we decided to make layer names in default document templates translatable, we defined a list of translatable keywords to use for layer names in those default templates. The list was made by most artists present there (me, Deevad, Wolthera, Raghukamath and Bollebib).

Also I helped Raghukamath who was fighting with his bluish laptop screen to properly calibrate it on his Linux system, and he was very happy of the result.

Many thanks to Boudewijn and Irina who organised and hosted the sprint in their house, to the Krita Foundation for the accommodation and food, and to KDE e.V. for the travel support that made it possible to gather contributors from many different countries.

You can find more info about this sprint on the Krita website:

Krita 2018 Sprint Report

Sigo con el repaso al último gran evento de KDE España con una breve resumen de una tarde de sábado en Akademy-es 2018 de Valencia, un repaso a lo que aconteció el 12 de mayo en la capital del Turia ya hace más una semana. Y es que el tiempo pasa rápido e inexorable y mis ocupaciones, lamentablemente, no hacen más que subir.

Una tarde de sábado en Akademy-es 2018 de Valencia

Después de la gran paella, tanto en tamaño como en sabor, es el momento de seguir con la Akademy-es. Y como es costumbre, se empiezan con las lighting talks, pequeñas charlas de unos cinco minutos que no son más que pequeñas píldoras de grandes proyectos libres.

  • 15:00 – 16:00 Charlas Relámpago

En esta ocasión, las charlas relámpago corrieron a cargo de Aleix Pol con Plasma Mobile y KDE Connect,  de Antonio Larrosa, con las novedades de openSUSE , Alex Fiestas con Docker  y Raúl Rodrigo que nos dio la respuesta a la pregunta de porqué Lliurex no utiliza KDE.

  • 16:05 – 16:40 Descubriendo Plasma DiscoverAleix Pol, Vicepresidente de KDE eV

Vuelve a subir al estrado Aleix Pol, que nos hablar de una de las aplicaciones que sigue evolucionando y mejorando versión a versión, y que se está convirtiendo en una aplicaciones killer para el ecosistema KDE: Discover.

A lo largo de su charla nos habló del nacimiento de la aplicación, su trabajo con los diseñadores, su estado actual y su futuro.

 

  • 16:45 – 17:20 Los proyectos Wikimedia, más que una enciclopedia – Santiago Navarro, presidente de Wikimedia España

Santiago Navarro, como es habitual, no solo nos cuenta que es la Wikipedia sino que que nos abre la mente al gran proyecto que es la Wikimedia. Como siempre, las  preguntas se convierte en un tiempo casi tan interesante que el de la charla.

Descanso y foto de grupo

  • 17:40 – 18:15 Slimbook, KDE y Linux CenterAlejandro López, Slimbook Team

Llega el momento de uno de los patrocinadores del evento. Alejandro nos cuenta en una charla tanto el nacimiento de Linux Center, un espacio que promete dar mucho que hablar en un futuro, y de sus ultrabooks con sistemas GNU/Linux instalados.

  • 18.20 – 18.55 Usa protecciónAdrián Chaves, traductor de KDE al Gallego

Aunque utilizar sistemas GNU/Linux es muy seguro, siempre debemos tener en cuenta algunas precauciones a la hora de trabajar con nuestro ordenador. Adrián nos lo cuenta con todo tipo de detalles.

  • 19.00 – 19.35 La Asociación KDE España: ¿Qué hicimos, qué hacemos, qué podemos hacer?José Millán, Tesorero de KDE España

Para finalizar, nada mejor que conocer un poco más a la asociación que lleva más de 10 años llevando la palabra del Software Libre y del Proyecto KDE por toda la geografía hispánica. De la mano de Jose repasamos pasado, presente y futuro de KDE España, teniendo incluso cierto tiempo para las preguntas.

 

Tras la última charla llega la Asamblea de KDE España, donde seguimos perfilando el dominio del mundo las líneas maestras de actuación de la asociación para el próximo año.

Finaliza así la tarde, quedándonos el acto social de la noche, pero eso me lo guardo para otra entrada.

KDAB is a major sponsor of this event and a key independent contributor to Qt as our blogs attest.

Every year, dedicated Qt contributors gather at Qt Contributors’ Summit to share with their peers latest knowledge and best practices, ensuring that the Qt framework stays at the top of its game. Be a Contributor to Qt!

We look forward to meeting you in Oslo!

The post KDAB at Qt Contributor’s Summit 2018, Oslo appeared first on KDAB.

This weekend, Krita developers and artists from all around the world came to the sleepy provincial town of Deventer to buy cheese — er, I mean, to discuss all things Krita related and do some good, hard work! After all, the best cheese shop in the Netherlands is located in Deventer. As are the Krita Foundation headquarters! We started on Thursday, and today the last people are leaving.

Image by David Revoy

Events like these are very important: bringing people together, not just for serious discussions and hacking, but for lunch and dinner and rambling walks makes interaction much easier when we’ve gone back to our IRC channel, #krita. We didn’t have a big sprint in 2017, the last big sprint was in 2016.

So… What did we do? We first had a long meeting where we discussed the following topics:

  • 2018 Fund Raiser. We currently receive about €2000 a month in donations and have about eighty development subscribers. This is pretty awesome, and goes a long way towards funding Dmitry’s work. But we still want to go back to having a yearly fund raiser! We aim for September. Fund raisers are always a fun and energizing way to get together with our community. However, Kickstarter is out: it’s a bit of tired formula. Instead we want to figure out how to make this more of a festival or a celebration. This time the fund raiser won’t have feature development as a target, because…
  • This year’s focus: zarro bugs. That’s what bugzilla used to tell you if your search didn’t find a single bug. Over the past couple of years we’ve implemented a lot of features, ported Krita to Qt5 and in general produced astonishing amounts of code. But not everything is done, and we’ve got way too many open bug reports, way too many failing unittests, way too many embarrassing hits in pvs, way too many features that aren’t completely done yet — so our goal for this year is to work on that.
  • Unfinished business: We identified a number of places where we have unfinished business that we need to get back to. We asked the artists present to rank those topics, and this is the result:
    • Boudewijn will work on:
      • Fix resource management (https://phabricator.kde.org/T379).
      • Shortcut and canvas input unification and related bugs
      • Improved G’Mic integration
    • Dmitry will work on:
      • Masks and selections
      • Improving the text layout engine, for OpenType support, vertical text, more SVG2 text features.
      • SVG leftovers: support for filters and patterns, winding mode and grouping
      • Layer styles leftovers
    • Jouni will work on animation left-overs:
      • frame cycles and cloning
      • Transform mask interpolation curves
    • Wolthera will work on
      • Collecting information about missing scripting API
      • Color grading filters
  • Releases. We intend to release Krita 4.1.0 June 20th. We also want to continue doing monthly bug-fix releases. We’ve asked the KDE system administrators whether we can have nightly builds of the stable branch so people can test the bug fix releases before we actually release them. Krita 4.1 will have lots of animation features, animation cache swapping, session management and the reference images tool — and more!

We also discussed the resource management fixing plan, worked really hard on making the OpenGL canvas work even smoother, especially on macOS, where it currently isn’t that smooth, added ffmpeg to the Windows installer, fixed translation issues, improved autosave reliability, fixed animation related bugs and implemented support for a cross-channel curves filter for color grading. And at the same time, people who weren’t present worked on improving OpenEXR file loading (it’s multi-threaded now, among other things), fixed issues with the color picker and made that code simpler and added even more improvements to the animation timeline!

And that’s not all, because Wolthera, Timothee and Raghukamath also finished porting our manual to Sphinx, so we can generate off-line documentation and support translations of the manual. The manual is over 1000 pages long!

There were three people who hadn’t attended a sprint before, artist Raghukamath, ace windows developer Alwin Wong and Valeriy Malov, the maintainer of the KDE Plasma desktop tablet settings utility, who improved support for cintiq-like devices during the weekend.

And of course, there was time for walks, buying cheese, having lunch at our regular place, De Rode Kater, and on Sunday the sun even started shining! And now back to coding!

Image by David Revoy.

The 2018 Krita sprint was sponsored by KDE e.V. (travel) and the Krita Foundation (accommodation and food).

After more than a year of work, I’m pleased to release another version of heaptrack, the Linux memory profiler! The new version 1.1.0 comes with some new features, significant performance improvements and – most importantly – much improved stability and correctness. If you have tried version v1.0 in the past and encountered problems, update to the new v1.1 and try again!

Notable Changes

The most effort during this release cycle was spent on improving the correctness of heaptrack. The initial version suffered from bugs that could lead to corrupted or truncated data files. Heaptrack v1.1 is generally much better in this regard, and you should be able to use it in more situations than before. Furthermore, attaching heaptrack to an already-running process will catch more allocations and thus produce more accurate data. To verify the quality of the heaptrack code base, more tests have been added as well. These tests also finally enable us to use Valgrind or the Sanitizers on most of the heaptrack code, which wasn’t possible previously.

Additionally, some important new features have been added which greatly improve the usability of heaptrack:

  1. When extended debug information is available, stack traces now include inlined frames.
  2. Split debug information in separate files is now supported.
  3. Compressed debug information is properly handled.
  4. The embedded flamegraph view is now searchable.

Finally, quite some work went into optimizing heaptrack to further reduce its overhead. The initial version was quite good already from a performance point of view, but version 1.1 is even better! Most notably, the analysis of large data files is now often much faster. This is in great parts due to the new optional dependency on zstd. This fantastic state-of-the-art compression algorithm greatly reduces the CPU overhead during recording while compressing the heaptrack data. But not only that – decompression at analysis time is significantly reduced compared to the standard gzip compression. In case you wonder: Data files are now often slightly smaller too!

Last but not least, heaptrack v1.1.0 can be downloaded as a portable AppImage which should run on most 64bit Linux systems in use these days!

Download heaptrack v1.1.0

If possible, wait for your distribution to provide you with an updated package for heaptrack v1.1.0. Otherwise, download the AppImage, make it executable and run it. If neither of these two options works for you, grab the sources and compile the code for your target platform:

The GPG signatures have been created by Milian Wolff with the key A0C6B72C4F1C5E7C.

Many thanks to the various people who contributed to this release. Please continue to hand in your patches, preferably via KDE’s phabricator instance or via heaptrack on GitHub. Bugs can be reported on bugs.kde.org.

If your company needs commercial support for heaptrack, then get in touch with us at KDAB. We offer workshops and trainings specifically about profiling and debugging on Linux.

The post Heaptrack v1.1.0 release appeared first on KDAB.

WebAssembly is now supported by all major web browsers as a binary format for allowing sand-boxed executable code in web pages that is nearly as fast as native machine code. Qt for WebAssembly makes it possible to run Qt applications on many web browsers without any download steps or special server requirements (other than serving the wasm file).

To give you a closer look, we compiled some demos. For best performance, use Firefox.

Here is the complete list along with some descriptions:

http://example.qt.io/qt-webassembly/opengl/hellowindow/hellowindow.html
An example which renders a Qt logo using OpenGL calls. This example shows that you can also use this for custom OpenGL code.

http://example.qt.io/qt-webassembly/SensorTagDemo/SensorTagDemo.html
A larger example of an interesting industry automation use case. In principle, it is possible to show live data retrieved using Qt WebSockets, but this is just showing generated dummy data for illustration purposes.

http://example.qt.io/qt-webassembly/quickcontrols2/gallery/gallery.html
A gallery of available controls in Qt Quick Controls 2. This shows that you can use Qt Quick and Qt Quick Controls 2 to make your web-deployed applications.

http://example.qt.io/qt-webassembly/widgets/richtext/textedit/textedit.html
A simple text editor, written with Qt Widgets. This example shows that you can also use Qt Widgets to create your web-deployed applications.

As always, let us know what you think!

The post Qt for WebAssembly – check out the examples! appeared first on Qt Blog.

May 21, 2018

Earlier this year, I had the chance to speak about one of KDE community's cool projects that is helpding developers erase the line between desktop and mobile/tablet UI's with ease. I'm referring to the Kirigami UI framework - a set of QtQuick components targetted at the mobile as well as desktop platforms. This is particularly … Continue reading Revisiting my talk at FOSSASIA summit, 2018

Well, It's been a week since the coding period started. There were quite some implementations out of the pre-plans and were huge. They got me very nervous at first. Such changes meant big updation in the code base and lots of time to have everything in place and with no warnings/errors ( well I can't …

Are you using Kubuntu 18.04, our current LTS release?

We currently have the Plasma 5.12.5 LTS bugfix release available in our Updates PPA, but we would like to provide the important fixes and translations in this release to all users via updates in the main Ubuntu archive. This would also mean these updates would be provide by default with the 18.04.1 point release ISO expected in late July.

The Stable Release Update tracking bug can be found here: https://bugs.launchpad.net/ubuntu/+source/plasma-desktop/+bug/1768245

A launchpad.net account is required to post testing feedback as bug comments.

The Plasma 5.12.5 changelog can be found at: https://www.kde.org/announcements/plasma-5.12.4-5.12.5-changelog.php

[Test Case]

* General tests:
– Does plasma desktop start as normal with no apparent regressions over 5.12.4?
– General workflow – testers should carry out their normal tasks, using the plasma features they normally do, and test common subsystems such as audio, settings changes, compositing, desktop affects, suspend etc.

* Specific tests:
– Check the changelog:
– Identify items with front/user facing changes capable of specific testing. e.g. “weather plasmoid fetches BBC weather data.”
– Test the ‘fixed’ functionality.

Testing involves some technical set up to do, so while you do not need to be a highly advanced K/Ubuntu user, some proficiently in apt based package management is advisable.

Details on how to enable the propose repository can be found at: https://wiki.ubuntu.com/Testing/EnableProposed.

Unfortunately that page illustrates Xenial and Ubuntu Unity rather than Bionic in Kubuntu. Using Discover or Muon, use Settings > More, enter your password, and ensure that Pre-release updates (bionic-proposed) is ticked in the Updates tab.

Or from the commandline, you can modify the software sources manually by adding the following line to /etc/apt/sources.list:

deb http://archive.ubuntu.com/ubuntu/ bionic-proposed restricted main multiverse universe

It is not advisable to upgrade all available packages from proposed, as many will be unrelated to this testing and may NOT have been sufficiently verified as updates to assume safe. So the safest but a little involved method would be to use Muon (or even synaptic!) to select each upgradeable packages with a version containing 5.12.5-0ubuntu0.1 (5.12.5.1-0ubuntu0.1 for plasma-discover due to an additional update).

Please report your findings on the bug report. If you need some guidance on how to structure your report, please see https://wiki.ubuntu.com/QATeam/PerformingSRUVerification. Testing is very important to the quality of the software Ubuntu and Kubuntu developers package and release.

We need your help to get this important bug-fix release out the door to all of our users.

Thanks! Please stop by the Kubuntu-devel IRC channel or Telegram group if you need clarification of any of the steps to follow.

Yes, folks. This year SIGGRAPH 2018 is in Canada and we’ll be there at the Qt booth, showing off our latest tooling and demos. These days, you’d be surprised where Qt is used under the hood, even by the biggest players in the 3D world!

SIGGRAPH 2018 is a five-day immersion into the latest innovations in CG, Animation, VR, Games, Digital Art, Mixed Reality and Emerging Technologies. Experience research, hands-on demos, and fearless acts of collaboration.

Meet us at SIGGRAPH 2018!

Book your place for the most exciting 3D event of the year!

The post KDAB at SIGGRAPH 2018 appeared first on KDAB.

KDAB is proud to be bronze sponsor at Italian C++ Conference, the largest conference in Italy specifically focused on C++ development for professionals, students and businesses using C++.

It’s free, organized by the Italian C++ community, and there’s Italian icecream to think about too… It’s an offer you can’t refuse ��

Sign up and see you in Milan in June!

The post KDAB at Italian Cpp 2018 appeared first on KDAB.

There are many ways to understand a community.

For instance, Kevin Ottens has been writing about understanding the KDE community by the “green blobs” method, showing who is active when. Lays Rodrigues has written about using Gource to show Plasma growing up. Nate Graham describes the goings-on in the KDE community nearly every week.

Those are, roughly: a metric-, a visual-, and a story-based approach to understanding the community, over different timescales. But understanding of a system doesn’t come from a single dimension, from a single axis of measurement. It comes from mixing up the different views to look the system as a whole.

To that end, I’m going to apply Kevin’s and Lays’s approaches to .. well, not to something Nate has written, but to a recent this-week-in-Elisa post by Matthieu Gallien. The relevant period is april 22nd (the release of Elisa 0.1.1) to may 16th (latest post on Elisa progress).

ComDaAn is the toolbox Kevin has come up with for dealing with activity and centrality. It’s a Python3 application — it almost works with Python2, except that timestamp-formatting in Python2 does not support the %z flag (in spite of the documentation). No strange dependencies, and easy_install or system packages get everything (even on FreeBSD). The green-blobs tool is called activity.py and can take a date range to limit what is shown, for instance ComDaAn/activity.py -f 2018-04-21 -u 2018-05-16 ~/src/kde/elisa/ , which gives us this (image links to an actual HTML page with all the fanciness).

Image of contributions to Elisa

Elisa Contributors, 2018-04-22 — 2018-05-16

Gource is what Lays used to show off Plasma development. I used the same video (regenerated locally) as a blinkenlights show at the KDE booth at FOSS-North. Gource also takes a date range, for instance , which gives us this (image links to the video).

Elisa Gource Screenshot

A moment in Elisa time

The time period here is short; it’s unwise to draw any conclusions from any of these visualisations. They do support the story that Matthieu tells, and the natural order of things is that the main developer does the most commits, with features and fixes coming (ir)regularly from others. The movie shows that the structure of Elisa (or the source code, at least) remains stable over this period. Together, the visualisations along different axes enliven the story of Elisa — and running those tools over a longer period of months can help understand how the community around that application grows and changes.

[[ As an aside, there’s a really neat use of Gource out there: instead of visualising source-code changes, use it to watch other kinds of events, like those that DTrace can provide from a running system. FreeBSD users can enjoy Devin Teske’s dwatch-gource, which uses dwatch to produce logs suitable for gource, and then make a movie of what their system is doing. Maybe not great for parties, but excellent for figuring out why the desktop is suddenly slow while building Qt, LLVM and GCC in parallel (all three with -j8). ]]

I like to cook. And sometimes store my recipes. Over the years I have tried KRecipes, kept my recipes in BasKet notes, in KJots notes, in more or less random word processor documents.

I liked the free form entering recipes in various notes applications and word processor documents, but I lacked some kind of indexing them. What I wanted was free-ish text for writing recipes, and some thing that could help me find them by tags I give them. By Title. By how I organize them. And maybe by Ingredient if I don’t know how to get rid of the soon-to-be-bad in my refridgerator.

Given I’m a software developer, maybe I should try scratch my own itch. And I did in the last month and a half during some evenings. This is also where my latest Qt and modern C++ blog posts comes from

The central bit is basically a markdown viewer, and the file format is some semi structured markdown in one file per recipe. Structured in the file system however you like it.

There is a recipes index which simply is a file system view with pretty titles on top.

There is a way to insert tags into recipes.

I can find them by title.

And I can find recipes by ingredients.

Given it is plain text, it can easily be synced using Git or NextCloud or whatever solution you want for that.

You can give it a spin if you want. It lives here https://cgit.kde.org/scratch/sune/kookbook.git/. There is a blueprint for a windows installer here: https://phabricator.kde.org/D12828

There is a markdown file describing the specifics of the file format. It is not declared 100% stable yet, but I need good reasons to break stuff.

My recipe collection is in my native language Danish, so I’m not sure sharing it for demo purposes makes too much sense.

Once more in Florence, QtDay Italy is almost upon us and we’ll be there.

Giuseppe D’Angelo will be giving a talk on Gammaray, KDAB’s open source profiling and debugging tool.

GammaRay is a “high-level debugger”, able to show the status of various Qt subsystems inside an application, with an easy to use interface (that does not require any knowledge of Qt internals). GammaRay can, amongst other things, show the properties of any QObject in the application, show the status of all state machines, inspect and debug layouting and stacking of both widgets and Qt Quick applications, analyze raster painting, show the 3D geometry in a Qt3D scene, and much more.

This talk introduces the basics of GammaRay usage, with some interesting cases as examples of problem solutions.

See you in Florence!

The post QtDay Italy, May 23-24 appeared first on KDAB.

May 20, 2018

This week was mainly focused on three things

  • Enable loading/unloading of QML plugins in Falkon
  • Adding permission to existing plugin infrastructure for allowing plugin in incognito
  • Developing QML Bookmarks API similar to WebExtension API

Enable loading/unloading of QML plugins in Falkon

QML plugins will now be loaded into Falkon from the subdirectory qml in the standard plugin paths, similar to Python plugins. Also in metadata.desktop file for plugin, the main entry file (QML) can be specified so that the plugin named X can have the entry file Y.qml.

Adding permission to existing plugin infrastructure for allowing plugin in incognito

Plugins will now support permission to allow them in incognito mode. Also the information for plugins is moved from ini files to sql database.

Falkon_Preference

Developing QML Bookmarks API similar to WebExtension API

The following table demonstrates the browser compatibility of WebExtension API for Falkon compared with other browsers.

Falkon Chrome Edge Mozilla
BookmarkTreeNode
BookmarkTreeNodeType ❌*
BookmarkTreeNodeUnmodifiable ❌*
CreateDetails ❌*
create
get
getChildren
getRecent
getSubTree ❌*
getTree ❌*
move
onChange
onChildrenReordered ❌*
onCreated
onImportBegan
onImportEnded
onMoved
onRemoved
remove
search
update

To enable the support of API's marked with ❌*, the additional API includes:

  • BookmarkTreeNode.type
  • BookmarkTreeNode.parent
  • Bookmarks.rootItem, Bookmarks.toolbarFolder, Bookmarks.menuFolder, Bookmarks.unsortedFolder
  • Bookmarks.lastUsedFolder
  • Bookmarks.isBookmarked

Currently I am, with a great help from my mentor David Rosca, working on developing autotests for the Bookmarks API.

Happy Summers :)

The other day, some user of Extra CMake Modules (A collection of utilities and find modules created by KDE), asked if there was an easy way to query cmake for wherever the KDEInstallDirs points to (KDEInstallDirs is a set of default paths that mostly is good for your system, iirc based upon GNUInstallDirs but with some extensions for various Qt, KDE and XDG common paths, as well as some cross platform additions). I couldn’t find an easy way of doing it without writing a couple of lines of CMake code.

Getting the KDE_INSTALL_(full_)APPDIR with default options is:

$ cmake -DTYPE=APPDIR ..
KDE_INSTALL_FULL_APPDIR:/usr/local/share/applications

and various other options can be set as well.

$ cmake -DCMAKE_INSTALL_PREFIX=/opt/mystuff -DTYPE=BINDIR ..
KDE_INSTALL_FULL_BINDIR: /opt/mystuff/bin

This is kind of simple, but let’s just share it with the world:

cmake_minimum_required(VERSION 3.0)
find_package(ECM REQUIRED)
set (CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

include(KDEInstallDirs)

message("KDE_INSTALL_FULL_${TYPE}: " ${KDE_INSTALL_FULL_${TYPE}})

I don’t think it is complex enough to claim any sorts of copyrights, but if you insist, you can use it under one of the following licenses: CC0, Public Domain (if that’s in your juristiction), MIT/X11, WTFPL (any version), 3-clause BSD, GPL (any version), LGPL (any version) and .. erm. whatever.

I was trying to get it to work as a cmake -P script, but some of the find_package calls requires working CMakeCache. Comments welcome.

Cheap talk

Last weekend, I went to İstanbul to attend Özgür Yazılım ve Linux Günleri (Free Software and Linux Days 2018) to represent LibreOffice. We had 3 presentations during the event about LibreOffice Development and The Open Document Format. We had booth setup with stickers, flyers, roll-up etc. These were all thanks to The Document Foundation’s supports! You can find detailed information about the event from here : https://wiki.documentfoundation.org/Events/2018/OYLG2018

Summary of the event ��

I came back from the event in Monday and since then, I have been working on the Workspace KCM rewrite and single/double click bug fix so just find time to write blog. Workspace KCM rewrite and single/double click bug fix are done and the code is pushed to the master. If you’re on the dev unstable repo, and if you have updated your system in the last 4 days, just go to “System Settings > Desktop Behavior > Workspace” and check it. You should be using new Workspace KCM �� But there are more. I finished a new design for it yesterday and it’ll be pushed soon, after some discussion with maintainers.
See the evolution of Workspace KCM :

KCM Rewrite

Single/double click bug fix

Kirigami redesign

Show me the code

1. The old Workspace KCM is rewritten in QML. Commit is here.
2. In Wayland, there was no “single/double click” options and in Xorg, it was under “Mouse KCM” but this doesn’t make sense. When user change the setting, it doesn’t affect only mouse, it affects whole system because it is not about input devices. So we discussed the issue and decided to move the setting to Workspace KCM. This also solved the issue for Wayland. In short, single/double click options is moved to Workspace KCM. Commit is here.
3. Workspace KCM is redesign by using Kirigami and the code has same improvement. See the work from here (D12973) and here (D12974).

Finally

These were very active days for me. I have been in lots of discussions, did have lots of conversations. Basically I understand how things going on in the background. Nate and Roman are great mentors, friends and the KDE is a great community.

Now, my todolist is as following:
1. Rewrite Touchpad KCM in QtQuick.
2. Rewrite Mouse KCM in QtQuick.

Hope to see you next week! ��


The post This Week in KDE, Part 2 : OYLG, Workspace KCM, Single/Double Click appeared first on Bir Coder'ın Günlüğü.

This week we announced a beta of the upcoming KDE Plasma 5.13 release, and so far the internet seems pretty excited about it. �� But we’re nowhere near done, and here’s another week of Usability and Productivity enhancements to highlight:

New Features

Bugfixes

UI Polish & Improvement

See all the names of people who worked hard to make the computing world a better place? That could be you next week! Getting involved isn’t all that tough, and there’s lots of support available. Give it a try today! It’s easy and fun and important.

If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal.

Become a patron Donate using Liberapay donate with PayPal

May 19, 2018

KDevelop 5.2.2 and 5.2.3 released

We today provide a stabilization and bugfix release with version 5.2.2 and 5.2.3. 5.2.2 was tagged 6 weeks ago, but we never managed to release it because we did not have the patience to fix the Windows installers in time due to a broken CI. Windows installers are provided for 5.2.3 again. We'll only provide source tarballs for 5.2.2 and we encourage everyone to just skip this release and use 5.2.3 which contains a few more bug fixes.

This is a bugfix-only release, which introduces no new features and as such is a safe and recommended update for everyone currently using KDevelop 5.2.1.

You can find the updated Windows 32- and 64 bit installers, the Linux AppImage, as well as the source code archives on our download page.

Please let us know of any issues you encounter when using KDevelop on the bug tracker, in the mailing lists for development or users (kdevelop@kde.org, kdevelop-devel@kde.org), or in the comment section of this release announcement.

Change log

kdevelop

  • KDevelop : support whitespace between the '#' and 'include' (or 'import'). (commit. fixes bug #394200. code review D12903)
  • Shell: Display generic project managers again. (commit. code review D12279)
  • Github: Fix Github repositories not fetched. (commit. fixes bug #392553. code review D11980)
  • Avoid emptry entries in project files filter list. (commit. code review D11912)
  • Note org.kdevelop.IBasicVersionControl@kdevgit as dep for kdevghprovider. (commit. code review D11823)
  • Never assert when the assert can fire sporadically. (commit. See bug #357585)
  • Sublime: Release space in tab bar when no status. (commit. See bug #314167)
  • Shell: Save entries of recent projects action. (commit. fixes bug #385915)
  • Lldb: don't issue command when there's no env variables to set, fix Bug 391897. (commit. code review D11524)
  • Fix crash when activating code completion item. (commit. fixes bug #391742)
  • Do not add return type to constructors declaration when editing definition in signature assistant. (commit. fixes bug #365420. code review D11291)
  • Make lambda introduce a context in DU chain. (commit. fixes bug #387994. code review D11303)
  • Fix bug 384082 - cppcheck is checking CMake generated files. (commit. fixes bug #384082. code review D11041)
  • Never run qmlplugindump on plugins that already offer plugins.qmltypes. (commit. code review D10872)
  • Fix CodeCompletion of Strongly Typed Enum. (commit. code review D10738)
  • Make sure qmlplugindump works on my system. (commit. code review D10782)
  • Make sure we don't crash when stopping all jobs. (commit. code review D10874)
  • Help automoc to find metadata JSON files referenced in the code. (commit. code review D10693)
  • Link against KF5::Purpose if it's available. (commit. code review D9921)
  • Properly quote expected string value in lldb formatter unittests. (commit. code review D9929)
  • Unbreak the GDB QUrl pretty printer test. (commit. code review D9922)
  • Unbreak QtPrintersTest::testQString. (commit. code review D9923)
  • Also unbreak QtPrintersTest::testQByteArray. (commit. code review D9924)
  • Work around bug in kLineEdit. (commit. code review D9809. fixes bug #373004)
  • Fix crash when stopping process. (commit. code review D9858)
  • Performance: Reuse the global icon loader. (commit. code review D9783)
  • Cache ProblemPointers per translation unit. (commit. fixes bug #386720. code review D9772)
  • Only set CMAKE_AUTOMOC_MACRO_NAMES with KF5 < 5.42. (commit. code review D9778)
  • Format comments before setting them on the DUChain. (commit. code review D9472)
  • Set toolbar/toolbutton font on quickopen line edit. (commit. code review D9481)

kdev-python

  • Ensure that codestyle.py always returns something on stdout to unlock m_mutex. (commit. fixes bug #392031. code review D11474)
  • Fix crash with contexts opened in the baseclass list of a class definition. (commit. fixes bug #389326)
  • Fix appstream metadata filename and some content, and install it. (commit. code review D9488)

kdev-php

No changes

kfunk Sun, 2018/05/20 - 00:00
Category

Comments

Thank you for your work! I use Kdevelop everyday and I'm happy to see a new version.

After almost two years, here comes a new version of Doxyqml, the QML filter for Doxygen. This new version adds a new command-line option: --namespace to wrap the generated C++ in a namespace, and makes the parser more robust. Nothing ground-breaking, but some nice changes nevertheless.

What's interesting with this project is that I don't use it these days, but it still receives contributions from time to time. This puts me in the unusual position (for me) where most of my contributions to the project are reviewing code, cleaning things, a bit of infrastructure (I just added code coverage checks: 88%, not too bad) and release management.

Surprisingly, I like doing this, I am happy to see this little tool remains useful enough that others keep it alive.

All that to say, you can now pip install --upgrade doxyqml to get the latest version, and enjoy documenting your QML components!

@tetris4 wrote:

Also available in Italian and Taiwanese Mandarin.

Hello everyone!

On your next system upgrade you will receive all the latest versions of KDE’s Plasma, Applications and Frameworks, in addition to several other package updates. For more details and the full changelogs on KDE’s software releases, you can read the official announcements:

Other noteworthy package updates include wine 3.8, skypeforlinux 8.20.0.9 and pypy 6.0.0.

Konqis by KDE under CC BY-SA

It should be safe to answer yes to any replacement question by the package manager application. If in doubt or if you face another issue in relation to this update, please ask or report it below.

Most of our mirrors take 12-24 hours to synchronize with the central repositories on the origin server. Use the mirror status web page to see when your mirror of choice last synchronized.

Enjoy!

Posts: 1

Participants: 1

Read full topic

May 18, 2018



Plasma 5.13 Beta

KDE Plasma 5.13 Beta

Thursday, 17 May 2018. Today KDE unveils a beta release of Plasma 5.13.0.

Members of the Plasma team have been working hard to continue making Plasma a lightweight and responsive desktop which loads and runs quickly, but remains full-featured with a polished look and feel. We have spent the last four months optimising startup and minimising memory usage, yielding faster time-to-desktop, better runtime performance and less memory consumption. Basic features like panel popups were optimised to make sure they run smoothly even on the lowest-end hardware. Our design teams have not rested either, producing beautiful new integrated lock and login screen graphics.


New in Plasma 5.13


Plasma Browser Integration

Plasma Browser Integration is a suite of new features which make Firefox and Chrome, and Chromium-based browsers work with your desktop. Downloads are now displayed in the Plasma notification popup just as when transferring files with Dolphin. The Media Controls Plasmoid can mute and skip videos and music playing from within the browser. You can send a link to your phone with KDE Connect. Browser tabs can be opened directly using KRunner via the Alt-Space keyboard shortcut. To enable Plasma Browser Integration, add the relevant plugin from the addon store of your favourite browser.



Plasma Browser Integration for Downloads
   

Plasma Browser Integration for Media Controls

Plasma Browser Integration for Downloads and Media Controls


System Settings Redesigns

Our settings pages are being redesigned. The KDE Visual Design Group has reviewed many of the tools in System Settings and we are now implementing those redesigns. KDE's Kirigami framework gives the pages a slick new look. We started off with the theming tools, comprising the icons, desktop themes, and cursor themes pages. The splash screen page can now download new splashscreens from the KDE Store. The fonts page can now display previews for the sub-pixel anti-aliasing settings.



Desktop Theme


Font Settings


Icon Themes

Redesigned System Settings Pages


New Look for Lock and Login Screens

Our login and lock screens have a fresh new design, displaying the wallpaper of the current Plasma release by default. The lock screen now incorporates a slick fade-to-blur transition to show the controls, allowing it to be easily used like a screensaver.



Lock Screen


Login Screen

Lock and Login Screen new Look





Improved Blur Effect in the Dash Menu

Improved Blur Effect in the Dash Menu

Graphics Compositor

Our compositor KWin gained much-improved effects for blur and desktop switching. Wayland work continued, with the return of window rules, the use of high priority EGL Contexts, and initial support for screencasts and desktop sharing.





Discover's Lists with Ratings, Themed Icons, and Sorting Options

Discover's Lists with Ratings, Themed Icons, and Sorting Options

Discover

Discover, our software and addon installer, has more features and sports improvements to the look and feel.

Using our Kirigami UI framework we improved the appearance of lists and category pages, which now use toolbars instead of big banner images. Lists can now be sorted, and use the new Kirigami Cards widget. Star ratings are shown on lists and app pages. App icons use your local icon theme better match your desktop settings. All AppStream metadata is now shown on the application page, including all URL types. And for users of Arch Linux, the Pacman log is now displayed after software updates.

Work has continued on bundled app formats. Snap support now allows user control of app permissions, and it's possible to install Snaps that use classic mode. And the 'snap://' URL format is now supported. Flatpak support gains the ability to choose the preferred repository to install from when more than one is set up.


Much More

Other changes include:

  • A tech preview of GTK global menu integration.
  • Redesigned Media Player Widget.
  • Plasma Calendar plugin for astronomical events, currently showing: lunar phases & astronomical seasons (equinox, solstices).
  • xdg-desktop-portal-kde, used to give desktop integration for Flatpak and Snap applications, gained support for screenshot and screencast portals.
  • The Digital Clock widget allows copying the current date and time to the clipboard.
  • The notification popup has a button to clear the history.
  • More KRunner plugins to provide easy access to Konsole profiles and the character picker.
  • The Mouse System Settings page has been rewritten for libinput support on X and Wayland.
  • Plasma Vault has a new CryFS backend, commands to remotely close open vaults with KDE Connect, offline vaults, a more polished interface and better error reporting.
  • A new dialog pops up when you first plug in an external monitor so you can easily configure how it should be positioned.
  • Plasma gained the ability to fall back to a software rendering if OpenGL drivers unexpectedly fail.



GEdit with Title Bar Menu
  

Redesigned Media Player Widget
  

Connect an External Monitor

GEdit with Title Bar Menu. Redesigned Media Player Widget. Connect an External Monitor Dialog.



Live Images

The easiest way to try it out is with a live image booted off a USB disk. Docker images also provide a quick and easy way to test Plasma.

Download live images with Plasma 5
Download Docker images with Plasma 5

Package Downloads

Distributions have created, or are in the process of creating, packages listed on our wiki page.

Package download wiki page

Source Downloads

You can install Plasma 5 directly from source.

Community instructions to compile it
Source Info Page

Feedback

You can give us feedback and get updates on Facebook
or Twitter
or Google+.

Discuss Plasma 5 on the KDE Forums Plasma 5 board.

You can provide feedback direct to the developers via the #Plasma IRC channel, Plasma-devel mailing list or report issues via bugzilla. If you like what the team is doing, please let them know!

Your feedback is greatly appreciated.

Now that the beta 1 release of Qt 3D Studio 2.0 is out, let’s go through the steps involved in trying it out for real.

Pre-built runtime binaries

As outlined in last year’s post, the runtime component of Qt 3D Studio has undergone significant changes. This means that the Viewer application that is launched whenever pressing the green “Play” button in Qt 3D Studio and, more importantly, the C++ and QML APIs with the engine underneath, have all been rewritten in the familiar Qt-style C++ on top of Qt 3D. In practice the runtime is an ordinary Qt module, providing both C++ libraries with classes like Q3DSWidget, Q3DSPresentation, etc. and a QML plugin Studio3D and friends.

The releasing of the pre-built binaries for the runtime has improved a lot for version 2.0: there is now a dedicated entry in the Qt installer which will install the necessarily files alongside the normal Qt installation, so pulling in the runtime via QT += 3dstudioruntime2 or by import QtStudio3D 2.0 in QML will work out of the box in a fresh Qt installation. No more manual building from sources is needed (except when targeting certain platforms).

Let’s Install

At the moment Qt 3D Studio binaries are provided for Windows and macOS. Linux may be added in future releases. It is worth noting that this does not mean the runtime is not suitable for running on Linux (or Android or QNX or INTEGRITY, for that matter) – it, like the most of Qt, will build (cross-compile even) and run just fine, assuming a well-working OpenGL implementation is available for your platform. (however, glitches can naturally be expected with less stable and complete graphics stacks) So while we expect the design work in the Qt 3D Studio application done on Windows or macOS for now, Qt applications using the created 3D presentations can be developed on and deployed to all the typical Qt target platforms.

When launching the online installer, take note of the following entries. Note that the layout and the location of these items may change in the installer in beta 2 and beyond. What is shown here is how things look as of 2.0 beta 1.

The runtime depends on Qt 5.11, meaning it must be installed together with 5.11.0 (or a future release, here we will use the release candidate).

In the example run shown on the screenshots we opted for Visual Studio 2015, but choosing something else is an option too – the installer takes care of downloading and installing the right set of pre-built binaries for the Qt 3D Studio runtime.

q3dsb1inst1

q3dsb1inst2

Once installation is finished, you will have the Qt 5.11 RC, a recent version of Qt Creator, Qt 3D Studio 2.0 beta 1, and the necessary runtime libraries all in place.

Let’s Design

Launching Qt 3D Studio and opening the example project from <installation root>\Tools\Qt3DStudio-2.0.0\examples\studio3d\SampleProject should result in something like the following.

q3dsb1screenshot

For details on what can be done in the designer application, check the documentation. Speaking of which, the documentation for Qt 3D Studio has been split into two parts in version 2.0: the runtime has its own documentation set with the API references, introduction, system requirements, and other topics. (the links are currently to doc-snapshots, the contents will move to doc.qt.io later on)

Let’s Code

Designing the presentation is only half of the story. Let’s get it into a Qt application.

Here we will code an example from scratch. Regardless, you may want to look at the runtime’s examples first. These ship in <installation root>examples\Qt-5.11.0\3dstudioruntime2.

q3dsb1screenshot2
The qmldatainput example in action

For now, let’s start with an empty project. Launch Qt Creator and create a new, empty Qt Quick project targeting Qt 5.11.

q3dsb1screenshot3

The application template gives us a main QML file like this:

q3dsb1screenshot4

When the runtime is installed correctly alongside Qt, we can add the following to make our Qt Quick application load up a Qt 3D Studio presentation and compose it with the rest of the Qt Quick scene.

    ...
    import QtStudio3D 2.0
    
    Window {
        ...
        Studio3D {
            anchors.fill: parent
            anchors.margins: 10
            Presentation {
                source: "file:///c:/QtTest/Tools/Qt3DStudio-2.0.0/examples/studio3d/SampleProject/SampleProject.uip"
            }
        }
    }

(replace c:\QtTest as appropriate)

In many real world applications it is quite likely that you will want to place the presentation’s files and assets into the Qt resource system instead, but the raw file references will do as a first step.

Launching this gives us quite impressive results already:

q3dsb1screenshot5

What we see there is the live Qt 3D Studio presentation rendered by the new Qt3D-based engine into an OpenGL texture which is then used by the Qt Quick scenegraph when drawing a textured quad for the Studio3D element. The keyframe-based animations should all run as defined in the Qt 3D Studio application during the design phase.

Now, a common misconception is that Qt 3D Studio is merely a designer tool and the scenes created by it are static with no runtime modifications possible when loaded up in Qt applications. This is pretty incorrect since applications have full control over

Future versions of Qt 3D Studio are expected to extend the capabilities further, for example with adding APIs to spawn and destroy objects in the scene dynamically.

Let’s change that somewhat annoying text in the middle of the scene, using a button from Qt Quick Controls 2. Whenever the button is clicked, the attribute corresponding to the text rendered by the Text node in the Qt 3D Studio scene will be changed.

Option 1: Direct Attribute Access

q3dsb1screenshot6

When digging down the scene structure at the left of the timline pane, take note of the fact that the Text node has a convenient, unique name already (DateAndTime). This is good since it means we can refer to it without further ado in the application code:

...
import QtQuick.Controls 2.2

Window {
    ...

    Studio3D {
        anchors.fill: parent
        anchors.margins: 10
        Presentation {
            id: pres
            source: "file:///c:/QtTest/Tools/Qt3DStudio-2.0.0/examples/studio3d/SampleProject/SampleProject.uip"
        }

        Button {
            text: "Change text"
            anchors.bottom: parent.bottom
            anchors.horizontalCenter: parent.horizontalCenter
            onClicked: pres.setAttribute("DateAndTime", "textstring", "Hello World")
        }
    }
}

For details on this approach, check out the documentation for Presentation and the attribute name table.

q3dsb1screenshot7
Clicking the button results in changing the ‘textstring’ property of the Text node in the Qt 3D Studio presentation. The change is then picked up by the Qt 3D Studio engine, leading to changing the rendered text.

Option 2: Data Input

While changing properties via setAttribute & co. is simple and effective, Qt 3D Studio also supports another approach: the so-called data inputs. With data inputs, the designers of the 3D scene decide which attributes are controllable by the applications and assign custom names to these. This way a well-known, fixed interface is provided from the designers to the application developers. The example presentation we are using here exposes the following data inputs. (and note the orange-ish highlight for Text String in the Inspector Control in the bottom right corner)

q3dsb1screenshot8

The name dateAndTime is associated with the textstring property of the DateAndTime Text node. Let’s control the value via this approach:

...
import QtQuick.Controls 2.2

Window {
    ...

    Studio3D {
        anchors.fill: parent
        anchors.margins: 10
        Presentation {
            id: pres
            source: "file:///c:/QtTest/Tools/Qt3DStudio-2.0.0/examples/studio3d/SampleProject/SampleProject.uip"

            property string text: ""
            DataInput {
                name: "dateAndTime"
                value: pres.text
            }
        }

        Button {
            text: "Change text"
            anchors.bottom: parent.bottom
            anchors.horizontalCenter: parent.horizontalCenter
            onClicked: pres.text = "Hello World"
        }
    }

Here the Text node starts up with a textstring value of “” (but note there is no actual reference to “textstring” anywhere in the application code), while clicking the button results in changing it to “Hello World”. What’s more, we can now use the usual QML property binding methods to control the value.

That is all for now. Expect more Qt 3D Studio related posts in the near future.

The post Get Started with Qt 3D Studio 2.0 beta 1 appeared first on Qt Blog.

KDE Student Programs is happy to present our 2018 Google Summer of Code students to the KDE Community.

Welcome Abhijeet Sharma, Aman Kumar Gupta, Amit Sagtani, Andrey Cygankov, Andrey Kamakin, Anmol Gautam, Caio Jordão de Lima Carvalho, Chinmoy Ranjan Pradhan, Csaba Kertesz, Demetrio Carrara, Dileep Sankhla, Ferencz Kovács, Furkan Tokac, Gun Park, Iván Yossi Santa María González, Kavinda Pitiduwa Gamage, Mahesh S Nair, Tarek Talaat, Thanh Trung Dinh, Yihang Zhou, and Yingjie Liu!


KDE Google Summer of Code mentors at Akademy 2017. Photo by Bhushan Shah.


Students will work on
improving KStars for Android.

This year digiKam, KDE's professional photo management application, has three students: Tarek Talaat will be working on supporting Twitter and One Drive services in digiKam export, Thanh Trung Dinh on Web Services tools authentication with OAuth2, and Yingjie Liu on adding the possibility to manually sort the digiKam icon view.

Plasma, KDE's graphical desktop environment, will also be mentoring three students. Abhijeet Sharma will be working on fwupd integration with Discover (KDE's graphical software manager), Furkan Tokac will improve handling for touchpads and mice with Libinput, and Gun Park will port keyboard input modules to Qt Quick and expand scope to cover input method configuration for System Settings.

Another project with three students is Krita, KDE's popular graphic editor and painting application. Andrey Kamakin will improve multithreading in Krita's Tile Manager; Iván Yossi Santa María González (ivanyossi) will optimize Krita Soft, Gaussian and Stamp brushes mask generation to use AVX with Vc Library; and Yihang Zhou (Michael Zhou) is creating a Swatches Docker for Krita.

GCompris, the suite of educational programs and games for young learners, takes two students: Aman Kumar Gupta will port all GTK+ piano activities and get it one step closer to version 1.0, and Amit Sagtani will work on creating bitmap drawing and animation activities while preparing Gcompris for version 1.0.

Labplot, KDE's application for scientific data plotting and analysis, also mentors two students. Andrey Cygankov will add support for import data from web-service in LabPlot, and Ferencz Kovács will be working on plotting of live MQTT data.


Falkon, a new member of the KDE family,
will also get some GSoC love.

Okular, KDE's PDF and document viewer, gets another two students: Chinmoy Ranjan Pradhan will be working on verifying signatures of PDF files, while Dileep Sankhla will implement the FreeText annotation with FreeTextTypeWriter behavior.

For Falkon, a community developed web browser and a new member of the KDE family, Anmol Gautam will be working on JavaScript/QML extension support, and Caio Jordão de Lima Carvalho will finish LVM support and implement RAID support in KDE Partition Manager and Calamares (an advanced system installer).

Csaba Kertesz (kecsap) will aim to improve the desktop and the Android version of KStars, KDE's planetarium program, while Kavinda Pitiduwa Gamage will work on KGpg, KDE's graphical key management application, to make it better.

Mahesh S. Nair will expand Peruse Creator, adding more features to KDE's easy-to-use comic book reader. Finally, Demetrio Carrara will be working on the WikitoLearn production-ready Progressive Webapp (PWA).

Traditionally, Google Summer of Code starts with an introduction period where students get to know their mentors, after which they start coding. The coding period for 2018 has began on May 14, and will last until August 6. We wish all our students a productive, successful, and fun summer!

Simple greeting post for guests to get to know about my GSoC topic.

Hello all! This is my first time writing about my work progress in a blog, so some things are still awkward for me. And it is also my first time participating in GSoC and there are many things new to me. I’m cooperating with KDE organisation or rather with one of their projects, named Krita.

I hope that I will gain a great experience from working with and learning from community and manage to accomplish all my tasks for this summer. The coding has already started, so wish me luck :).


Older blog entries

 

 


Planet KDE is made from the blogs of KDE's contributors. The opinions it contains are those of the contributor. This site is powered by Rawdog and Rawdog RSS. Feed readers can read Planet KDE with RSS, FOAF or OPML.