April 23, 2017

Ya he hablado de este evento antes, pero es que me parece tan fabuloso y ahora tengo mucha más información que me apetece promocionarlo un poco más. Y es que se ya publicado ya el programa de actividades de Linux&Tapas 2017 de León, así como puesto a la venta algún que otro merchandising del encuentro.

Programa de actividades de Linux&Tapas 2017 de León

Programa de actividades de Linux&Tapas 2017 de LeónComo es tradición desde hace unos años, se va a celebrar el próximo 6 de mayo  Linux&Tapas 2017 de León en el casco antiguo de León, concretamente en el conocido Barrio Húmedo, donde unos locales ya han confirmado que serán utilizados para la parte gastronómica del evento y otros individuos han decidido pasar la tarde contando sus batalitas en forma de charlas.

Lo podéis ver todo en el programa de actividades que ya ha sido publicado:

12:30 – 13:00: Quedada en la Plaza de la Catedral de León

13:00 -16:30: Feria de la tapa lyt17

17:00 – 20:00: Ponencias en la Fundación Sierra Pambley:

  • “Radio Universitaria, ¡en el aire Libre!” Eloy
  • “El cuento de la gallina de los datos de oro”. Pablo Marinero
  • “Is it a game or is it real?” Fran
  • ” Autodefensa Digital”. Jorge SoydelBierzo

21:00 – ∞: Fiesta de despedida

Además, si quieres llevarte un recuerdo inolvidable del evento te informo que también se han elaborado camisetas del mismo, realizadas por gráficas Quearte que se han encargado también de la cartelería y las chapas. Se pueden reservar una de ellas por el módico precio de 15€ reservándolas previamente. Si te interesa no dejes de visitar la entrada del blog donde se cuentan los detalles.

 

 

Si estuviera por la zona ni me lo pensaba, así que si tú lo estás no dudes en inscribirte. Y si te pilla lejos pero te apetece ir, tampoco te lo pienses e inscribirte también. Simplemente viendo la página de anteriores eventos ya da ganas de ir.

 

 

Más información: Linux&Tapas 2017

April 22, 2017

Eventos, eventos, eventos, el mundo del Software Libre está lleno de eventos donde compartir conocimientos y experiencias. Hoy me toca hablar de los eventos patrocinados por la Comunidad de KDE de Barcelona.  Hace unos días se presentó una nueva ponencia dedicada a Nftables en las charlas de Barcelona Free Software. Una forma de conocer un proyecto que nace con la idea de mejorar nuestros sistemas GNU/Linux.

Nftables en las charlas de Barcelona Free Software

Siguen las charlas de la temporada 2016-17 del grupo Barcelona Free Software. En esta ocasión se ha vuelto a cambiar la sede, así que atentos y no os despistéis.

En este caso se trata de Nftables, un proyecto que según leeemos en la Wikipedia,  proporciona filtrado de paquetes y clasificación de paquetes en Linux, destinado a reemplazar los frameworks existentes iptables, ip6tables, arptables y ebtables.

Esta charla será presentada por Pablo Neira Ayuso, desarrollador recomendado por la FSFE, el cuál ha estado desarrollando nftables desde hace un tiempo, aportando su contribución al Kernel.

Nftables en las charlas de Barcelona Free Software
Recuerda los datos importantes:

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 viernes 28 de abril!

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, profesiones y muchos más, para después hacer un “meetup”, es decir, un encuentro presencial en algún lugar convenido, donde nunca faltan las cervezas.

April 21, 2017

We were just a bunch of nice-looking guys and girls :) hanging wifi routers over the windows and trying not being intimidated by an unceasing rain when we had the Brazilian KDE Summit (Akademy-BR) in Praia do Forte (BA) back in 2010. This was somehow the birth of LaKademy (Latin-American KDE Summit), started in 2012 and now having its fifth edition taking place in Belo Horizonte (Minas Gerais) from 29th April to 1st May.

LaKademy is an effort to promote the culture of FLOSS, hacking sessions, and collaborative work inside the Latin-American KDE community. It is also a way to let people know about the Brazilian/Latin-American KDE community, the sort of work we usually do, and how newcomers can start their journeys into the free software world. And, of course, is the place to strengthen relationships, make new friends, and let people fall in love about such an amazing FLOSS community <3.

Sixteen contributors will attend LaKademy 2017, interested in contributions to translation, promo, artwork, Atelier, Umbrello, KDE-Edu, Dolphin, KDE Games, KDevelop, and Kdenlive. The traditional LaKademy promo meeting will happen on 30th morning, where we make a retrospect of 2016 actions and start thinking about what we want to do for 2017/2018.

See you in Belo Horizonte and stay tuned for LaKademy 2017 news and photos :)

butterfly

The spring has arrived, so we took our brooms and swept the bugs from under the carpets and out of the door.

We meticulously noted down all the classes, orders, families, species, and other details of what we found and removed, which you can look up in our spring cleaning log.

Get Qt Creator 4.2.2

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.2.2 is also available through an update in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

The post Qt Creator 4.2.2 released appeared first on Qt Blog.

It is five days left until foss-north 2017, so it is high time to get your ticket! Please notice that tickets can be bought all the way until the night of the 25th (Tuesday), but catering is only included is you get your ticket on the 24th (Monday), so help a poor organizer and get your tickets as soon as possible!

And just to reiterate what’s on the menu. This is a full day conference with two tracks and many interesting speakers from many projects, including Debian, Wikimedia, KDE, systemd, PulseAudio, Nextcloud, PostgreSQL, OpenRISC, flatpak, AsteroidOS and more.

Last year, over 30% of the tickets was sold in the last 48h. This year, we cannot provide catering for the ones buying tickets the last 24h, so hopefully the peak will come earlier. For now, we have 93 persons on the visiting list, but there are chairs for 100 more!

Un mes más los miembros de KDE España se reunieron alrededor de sus pantallas, micrófonos y cámaras web para hablar un rato sobre temas relacionados con el mundo KDE. De esta forma se grabó el decimoctavo podcast que estuvo dedicado a KDE Edu, la rama educativa de la Comunidad. Espero que sea de vuestro agrado.

KDE Edu decimoctavo podcast de KDE España

El cuarto podcast de vídeo de la tercera temporada de KDE España titulado KDE Edu, las aplicaciones educativas de KDEse grabó el pasado 18 de abril utilizando los servicios de Google sin ningún problema técnico destacable, si obviamos una sonrojante interrupción que sufrí.

Los participantes del decimoséptimo vídeo podcast fueron:

  • Ruben Gómez Antolí, miembro de KDE España y que siguió realizando las labores de presentador.
  • Baltasar Ortega (@baltolkien), secretario de KDE España y creador y editor del presente blog, qué puso el punto de vista del profesor y que también realizó labores de presentador.
  • Albert Astals (@tsdgeos) ,ex-presidente de KDE España, ex-miembro de la junta de KDE e.V. y responsable de múltiples proyectos dentro de KDE como Blinken o KGeograpfhy.
  • Aleix Pol (@AleixPol), ex-presidente de KDE España y vicepresidente de KDE e.V., que puso el punto de vista del desarrollador de KDE que ha creado aplicaciones tan significativas como Kalgebra.

KDE Edu

A lo largo de casi la hora y cuarto que duró el vídeo podcast se habló tanto de la motivación de la rama educativa de KDE, las aplicaciones de la suite (aunque un par se quedaron sin nombrar), de cómo formar parte de ellas y del caso de GCompris, cuya migración GTK a Qt es significativa y marca un camino a seguir, el asalto al mundo de los móviles.


Además, gracias al trabajo de VictorHck (no os perdáis su blog) ya está disponible el podcast en archive.org.

Espero que os haya gustado, si es así ya sabéis: “Manita arriba“, compartid y no olvidéis visitar y suscribiros al canal de Youtube de KDE España.

Como siempre, esperamos vuestros comentarios que os aseguro que son muy valiosos para los desarrolladores, aunque sean críticas constructivas (las otras nunca son buenas para nadie). Así mismo, también nos gustaría saber los temas sobre los que gustaría que hablásemos en los próximos podcast.

Aprovecho la ocasión para invitaros a suscribiros al canal de Ivoox de los podcast de KDE España que pronto estará al día.

We release 17.04 with a redesigned profile selection dialog to make it easier to set screen size, framerate, and other parameters of your film. Now you can also play your video directly from the notification when rendering is finished. Some crashes that happened when moving clips around on the timeline have been corrected, and the DVD Wizard has been improved.

Please note that while this major release may seem to have few features development is at full throttle in the refactoring branch. You can monitor the progress here.

Since we missed by a whisker getting updated PIM (kontact, kmail, akregator, kgpg etc..) into Zesty for release day, and we believe it is important that our users have access to this significant update, packages are now available for testers in the Kubuntu backports landing ppa.

While we believe these packages should be relatively issue-free, please bear in mind that they have not been tested as comprehensively as those in the main ubuntu archive.

Testers should be prepared to troubleshoot and hopefully report issues that may occur. Please provide feedback on our mailing list [1], IRC [2], or optionally via social media.

After a period of testing and verification, we hope to move this update to the main backports ppa.

You should have some command line knowledge before testing.
Reading about how to use ppa purge is also advisable.

How to test KDE PIM 16.12.3 for Zesty:

Testing packages are currently in the Kubuntu Backports Landing PPA.

sudo add-apt-repository ppa:kubuntu-ppa/backports-landing
sudo apt-get update
sudo apt-get dist-upgrade

1. Kubuntu-devel mailing list: https://lists.ubuntu.com/mailman/listinfo/kubuntu-devel
2. Kubuntu IRC channels: #kubuntu & #kubuntu-devel on irc.freenode.net

April 20, 2017

Today KDE Applications 17.04 was released.

It includes Okular 1.1, it contains a nice set of features:
* Add annotation resize functionality
* Add support for auto-calculation of form contents via JavaScript
* Allow to rotate the page view using two-finger pinches on a touchscreen
* Change pages in presentation mode by swiping on touch screen
* Added support for Links that change the Optional Content visibility status
* Allow to disable automatic search while typing
* Allow to create bookmarks from the Table Of Contents

This release was brought to you by Albert Astals Cid, Oliver Sander, Luigi Toscano, Martin T. H. Sandsmark, Tobias Deiminger, Antonio Rojas, Burkhard Lück, Christoph Feck, Elvis Angelaccio, Gilbert Assaf, Heiko Becker, Hrvoje Senjan, Marco Scarpetta, Miklós Máté, Pino Toscano, Yuri Chornoivan.

April 18, 2017

First I would like to answer a few questions that I had on my latest entry:

1 – KActionRunner is *not* a unified-menu, and it does not tries to be. It shouldn’t be used to display the menu of the application in a unified way.

2 – Somebody told me that this looked like the Eclipse “Quick Access” feature, and that’s exactly what this is.

Changes in the code currently on my machine, *not merged yet*:

  • Enabled in every K-App that uses KXmlGui
  • ctrl + alt + space triggers the Action Runner
  • Search for the action you wanna trigger
  • Trigger it.

Obligatory Screenshoot running on KDevelop:

I certainly need to iron out a few things before trying to merge this, so I’m not doing a review again this soon (my older review was shut down pretty fast ��

  • Prettier delegate displaying more information about the Action
  • Display the list of actions when you type (currently it completes inline)
  • don’t crash on exit

I’m using it on all my KDE applications locally and this is starting to behave the way I want.

 

This is a guest post by 2016 Qt Champion Ben Lau.

Ben has a long history with Qt, and many interesting projects on GitHub.

Here’s an idea from him on making multithreading simpler in some cases.

The Basics

Multithreading programming may not be difficult at the first glance. You have to pay attention to your shared data to avoid race conditions/deadlocks. So you learn mutex and semaphore and do it carefully. The result works perfectly on your machine.

But one day, your program hangs. You spend an hour to trace out the problem and find out the order of code execution is not same as your expectation. So you add a few mode condition checking and fix the problem.

After a few week of development, the program is getting more complicated. And it begins to crash randomly. This time even after a day you still can’t figure out what is wrong and admit that it is totally out of control.

Does that sound like a familiar story? It is not rare to find complaints about random crashes/hangs due to misuse of a thread. Is it really difficult to write multithreaded programs?

The answer is yes and no. It depends on your software requirement and architecture.

In this article, it is going to introduce a lock-free multithreaded programming method by using QtConcurrent and AsyncFuture. These make multithreaded programming easier.

Let’s take an example. The code below shows an asynchronous ImageReader class. The readImageWorker function will be executed on another thread that won’t block the UI. QFuture represents the result of computation and reports the status change.

class ImageReader : public QObject {
public:
    QFuture<QImage> read(const QString& fileName);
};

QFuture<QImage> ImageReader::read(const QString &fileName)
{
    auto readImageWorker = [](const QString &fileName) {
        QImage image;
        image.load(fileName);
        return image;
    };
    return QtConcurrent::run(readImageWorker, fileName);
}

Example of use

ImageReader reader;

QFuture future = reader.read(INPUT);

QFutureWatcher *watcher = new QFutureWatcher();

connect(watcher, &QFutureWatcher::finished,
 [=]() {
 setImage(future.result());
 });

watcher->setFuture(future);

Multithreaded programming with QtConcurrent is pretty easy. It just takes an input, then produce an output later. QtConcurrent handles all of the low-level threading primitives.

But it is limited to the condition that the concurrent function does not access shared data with other threads. If that happens, it may still need a lock in order to maintain a critical session. That will fall back to the old traditional way.

Make it support Image caching

The above example is quite an ideal case. And of course, a real world problem is usually not that simple. Let’s change the requirement – Make it support image caching.

QFuture ImageReader::read(const QString &fileName)
 {
 auto readImageWorker = [](const QString &fileName) {
 QImage image;
 image.load(fileName);
 return image;
 };

QFuture future = QtConcurrent::run(readImageWorker, fileName);

QFutureWatcher *watcher = new QFutureWatcher(this);

auto updateCache = [=]() {
 m_cache[fileName] = future.result();
 watcher->deleteLater();
 };

connect(watcher, &QFutureWatcher::finished, updateCache);
 watcher->setFuture(future);
 return future;
 }

The class declaration:

class ImageReader : public QObject {
 public:
 bool isCached(const QString& fileName) const;
 QImage readCache(const QString& fileName) const;
 QFuture read(const QString& fileName);
 private:
 QMap<QString,QImage> m_cache;
 };
 bool ImageReader::isCached(const QString &fileName) const
 {
 return m_cache.contains(fileName);
 }

QImage ImageReader::readCache(const QString &fileName) const
 {
 return m_cache[fileName];
 }

Before getting an image, you have to query is the cache available:

if (reader.isCached(INPUT)) {
 setImage(reader.readCache(INPUT));
 return;
 }
 QFuture future = reader.read(INPUT);

This solution works, but the API is not ideal. Because it would violate the “Tell, don’t ask” principle. The best way is to combine readCache() and read() into a single function that always returns a QFuture object. But there is a problem, QFuture/QtConcurrent can only obtain a result from a thread. It is quite odd to start a thread but the data is already available. To get rid of this problem, we need a 3rd party library.

AsyncFuture

AsyncFuture is a C++ library that could converts a signal into a QFuture type and uses it like a Promise object in Javascript. It provides a unified interface for asynchronous and concurrent tasks. The library only contains a single header file, so that it is very easy to bundle in your source tree. Or you may install it by qpm.

Project Site:
https://github.com/benlau/asyncfuture

Let’s rewrite the above function with AsyncFuture:

QFuture ImageReader::read(const QString &fileName)
 {
 if (m_cache.contains(fileName)) {
 // Cache hit. Return an already finished QFuture object with the image
 auto defer = AsyncFuture::deferred();
 defer.complete(m_cache[fileName]);
 return defer.future();
 }

if (m_futures.contains(fileName)) {
 // It is loading. Return the running QFuture
 return m_futures[fileName];
 }

auto readImageWorker = [](const QString &fileName) {
 QImage image;
 image.load(fileName);
 return image;
 };

auto updateCache = [=](QImage result) {
 m_cache[fileName] = result;
 m_futures.remove(fileName);
 return result;
 };

QFuture future = AsyncFuture::observe(QtConcurrent::run(readImageWorker, fileName)).context(this, updateCache).future();
 m_futures[fileName] = future;
 return future;
 }

This time it is almost perfect. The deferred object provides an interface to complete/cancel a QFuture manually. That could replace readCache() by returning an already finished future object.

Moreover, it has added a new feature to avoid duplicated image reading. In case you have made requests to load the same image twice before it is cached, the original design would start two threads which are totally wasting CPU power. This version solves it by keeping all the running future in a future pool and return that future for duplicated read.

Make the example more complicated

Currently the example is very simple. Let’s try to make it more complicated.

Requirements:

  1. Add a readScaled(fileName, size) function that returns an image which is scaled to specific size
  2. Code reuse is a must
  3. The scaling must be done in another thread to emulate a high CPU usage function
  4. Load cached image if available
  5. But scaled image do not need to keep in cache

The most optimistic solution is to make use of the result of read() directly. That mean you have to create a thread that depends on the result of another thread. That is a bit hard to get it works with only QtConcurrent and probably it needs to use a lock. But it can be easy to be done with AsyncFuture’s future chaining feature.

QFuture ImageReader::readScaled(const QString &fileName, const QSize &size)
 {
 auto scaleImageWorker = [=](QImage input) {
 return input.scaled(size);
 };
 auto callback = [=](QImage result) {
 return QtConcurrent::run(scaleImageWorker, result);
 };
 QFuture input = read(fileName);
 QFuture output = AsyncFuture::observe(input).context(this, callback).future();
 return output;
 }

First of all, it calls read() function to obtain an image from QFuture. It doesn’t care about the caching mechanism as it is already handled by the read() function.

Then it creates a new future object to represent the whole work flow of the chain:

QFuture output = AsyncFuture::observe(input).context(this, callback).future();
                                                                     ^^^^^^^^^

A chain begins with a observe() function, then followed by an observer function to bind the callback to the observed future, and that will create a new future object to represent the result of the callback.

auto callback = [=](QImage result) {
 return QtConcurrent::run(scaleImageWorker, result);
 };

You may wonder if it is alright to run another worker function within the callback function. In fact, this is a feature of AsyncFuture. It provides a chainable API that works like a Promise object in JavaScript. If the callback returns a QFuture object, it will be added to the chain. Then the final output future will depend on the returned future. Therefore, the output future is in fact represents the result of read() , callback() and scaleImageWorker(). The flow could be visualised by this diagram:

sequence-diagram_promises

Diagram: The workflow of readScaled() – it shows how it uses a single QFuture to represent the result of a multiple steps task.

Conclusion

Using QtConcurrent without sharing data between threads could make multithreaed programming easier because it doesn’t need to manage an access lock. But real world problems are usually more complicated. A task may not be able to complete without interaction from other threads. In this case, it may still need an access lock to protect critical session. But once you have used it, it will fall back to the old traditional way, and probably it may get the same problem mentioned at the beginning.

In this article an alternative solution is presented: Use Concurrent API together with asynchronous callback then chain them into a sequence by a promise like API. It works by breaking down a task into multiple steps. Whanever a concurrent function seeks for extra information from another thread, it should just terminate itself and pass the control back to the main thread. So that it doesn’t need an access lock that may raise issues like deadlocks and race conditions.

The whole workflow could be represented by a QFuture object, a unified interface for all kind of asynchronous workflow.

However, this doesn’t mean we get rid of locks completely. They are still necessary for some scenarios. So choose your solution case by case.

The post Multithreaded Programming with Future & Promise appeared first on Qt Blog.

In a previous blog post we introduced clazy, a clang plugin which makes the compiler understand Qt semantics, allowing you to get compile-time warnings about Qt best practices ranging from unneeded memory allocations to misuse of API, including fix-its for automatic refactoring.

Today we’ll do a round-up and present the checks related to connect statements, Qt containers (including QString) and misc Qt facilities.

Connects

1. old-style-connect

Finds connect() statements still using the old SIGNAL()/SLOT() syntax. The Qt …

The post Uncovering 32 Qt best practices at compile time with clazy appeared first on KDAB.

April 17, 2017

We have released a bugfix update of Calligra. The 3.0.1 version contains the following fixes:

General

  • Fix crash in move command when using arrow keys
  • Respect container boundaries when moving shapes by arrow keys
  • Remove shape manipulation handles when the tool is deactivated
  • Always display shapes in the the same order in the ‘Add shape’ docker

Sheets

  • Improve formatting of scientific numbers
  • Fix save/load of cell borders

Plan

  • Bug 376469: Bad month calendar in Work & Vacation
  • Day numbers where not initialized correctly.
  • Manually entered dates where not parsed correctly.
  • Use default currency symbol if the currency symbol is not explicitly set

Chart

  • Fix crash when chart type is changed
  • Fix crash when a chart component is deleted
  • Fix crash when x- or y-axis is removed
  • Fix ui when editing axis label
  • Limit moving chart components to chart boundaries
  • Fix edit font dialog: Keep the axis fonts QFont size in sync with
    KCharts fontSize
  • Fix save/load of axis label font size and font family
  • Save/load legend alignment flags
  • Do not save axis label if it is not visible
  • Always do legend alignment when legend becomes visible.
  • Make axis dimensions translatable
  • Add undo command for hide/show titles
  • Add undo command for add/remove axis
  • Respect margins/spacing
  • Handle resizing in a reasonable way

April 16, 2017

Hi to everyone!!
I’m really proud to have designed the banner for Kubuntu 17.04.
I used the beautiful Ken Vermette wallpaper as a base. I hope you like it!

rect4147a

You can find it on Kubuntu.org


April 15, 2017

Ideas and Concepts

In the last 3 months I played with the awesome feature of Notebookbar. This experimental feature give the user the possibility to use a tabbed toolbar like Microsoft does, but it offers more, much more. I like the idea from the LibreOffice UX team about the context based toolbar. Advantage of the different UI elements:

Toolbar

Toolbars are great to offer the users the most frequently used actions. You can group them and with the Notebookbar you can arrange them in different sizes, with and without labels. The disadvantage is that you can’t show all functions from LibreOffice in the toolbar.

Menubar

The benefit of a menu bar is that you can sort all actions into a useful structure, and the experienced users know where to find actions that they used only from time to time. The disadvantage of a menubar is that you have to navigate through the structure.

Sidebar

The sidebar is great to group sections of actions, and you have a lot of vertical space, so I decided to use some layout examples from the sidebar.

Tabbed Toolbar

The benefit is that you can show all actions within the toolbar because actions are placed on different tabs. The problem is that the user have to know where the actions are.

Grouped Toolbar

The LibreOffice UX team introduced the toolbar with contextual section, that I like much because users can assign actions to different groups and label them. The Notebookbar offers also the option to place button in different sizes onto the canvas, which is used in the variant with contextual section to draw attention to more relevant actions.

Advanced Grouped Toolbar

My proposal starts with the variant “contextual sections” and extends it to the menubar. In addition I’m a fan of consistency so this is my idea:

ToolbarLayoutsOrigin.png

Groupedbar full

The idea is to combine the top level structure from the main menu with grouped toolbar sections.Sections always start with one big labeled icon followed by two rows with 24px icons and labels if needed. Next to the section label a menu is placed at bottom right that provides access to less often used functions from this group. Furthermore small buttons open dialogs from the group (e.g. Paragraph settings on the Format section). The label is also a drop down menu like in the menubar.

So I have the benefit of a toolbar where you can show the main actions for different groups by one click. Advanced actions for a group via smaller icons and a group label to support orientation in the UI. With the bottom menu you get all actions for one group with two clicks.

The drawback of this solution is that 10 sections or more exceeds the common width of 1280px. Ribbons solve this problem  with tabs, I’ll do it per contextually showing sections, depending on the screen resolution. he extended grouped toolbar was designed with 1920px (full HD screen resolution) in mind, but will also work on 1280px and on 2560px Screens.

Groupedbar compact

The design is the same as for the extended grouped toolbar but with only one icon row and a second row with the group labels. For users how don’t need the section labels, those can be hidden to save even more space.

What’s done

This isn’t just a mockup, it’s a real UI file – you can/should test the extended grouped toolbar and the single line toolbar. Thanks to Szymon Kłos

LibreOffice Theme

Unfortunately there are some open bugs:

  1. Switching section depending on the context is not as smooth and flicker-free as possible (see switch between text view and table view) Bug 107083
  2. The group labels don’t work as known from the menubar. Implemented as just a label makes…, because something like the drop down menubar behavior isn’t available yet. Bug 107084
  3. Theming work now with firefox personas it would be nice if I could define system colors without personas. Bug 107128
  4. Show/hide the label row isn’t possible with a simple action. Bug 107085
  5. There are some missing content views like for print and for insertdraw. This bug is still open for the other content based toolbars. Bug 106505 and 107127
  6. The priority content for the notebookbar need some improvement. Bug 107129
  7. Show/hide button labels depending on the windows size. Bug 106566
  8. The action expander for e.g. Paste, Table, … should be right to the label instead of vertical align. Than the alignment of the labels is perfect. Bug 106564

Download

I’d like to integrate the two layouts into LibreOffice master asap you can download a daily build for your System. You can download the .ui files and move them to /share/config/soffice.cfg/modules//ui see „How to create your own Notebookbar“.

Help is very welcome.


April 13, 2017

Codenamed “Zesty Zapus”, Kubuntu 17.04 continues our proud tradition of integrating the latest and greatest open source technologies into a high-quality, easy-to-use Linux distribution.

The team has been hard at work through this cycle, introducing new features and fixing bugs.

Under the hood, there have been updates to many core packages, including a new 4.10-based kernel, KDE Frameworks 5.31, Plasma 5.9.4 and KDE Applications 16.12.3.

The Kubuntu Desktop has seen some exciting improvements, with newer versions of Qt, updates to major packages like Krita, Kdenlive, Firefox and LibreOffice, and stability improvements to the Plasma desktop environment.

For a list of other application updates, upgrading notes and known bugs be sure to read our release notes.

Download 17.04 or read about how to upgrade from 16.10.

As an Easter treat here is a quick taster of some of the animation goodies coming to Qt 3D along with Qt 5.9. In this post we will briefly outline the steps needed to create a simple Qt 3D application and the assets it uses to produce this little animation: continue reading

The post Qt 3D Animation Easter Teaser appeared first on KDAB.

April 12, 2017

Hi! Today I'm here to share an experience and show you an Application that I did last weekend. On the last Saturday, I went to an event called Progressive Web Apps Roadshow made by Google. It's an event that is going around the world, where Googlers talk about Progressive Web Apps and why they are [...]


Thanks to the work of our volunteers, with a special mention to Matthias Heil and Karin Cienkowski, we’re happy to announce the official opening of the German portal of WikiToLearn. We hope it will be of great service to the German community and we’re sure it will help creating even more free textbooks for everyone to use.

If you speak German, we encourage you to become part of it, by using Feynman’s technique! Pick a topic you love, and write some chapters on it, explaining it to someone else. You will have a big positive impact on the world, and you will learn the subject with great efficiency.

The homepage of WikiToLearn in GermanThe homepage of WikiToLearn in German

63 pages are already live, including a small course introducing Python programming with Qt and KDE to high school students. What are you waiting for? Start sharing your knowledge: digitize your notes, talk to an institution close to you or just start editing some new content!

And remember:

Nur wenn Wissen geteilt wird, kann neues enstehen

…and of course, if you get stuck, you can always get help on the official Telegram channel or on the community chat.

L'articolo WikiToLearn: now available in German! sembra essere il primo su Blogs from WikiToLearn.

qtws_berlin

Build for Tomorrow
Deliver Today

The 14th annual Qt World Summit is returning to Berlin! Be sure to join the Qt event of the year taking place 10-12 of October at bcc, Berlin Congress Center.

Get ready for five tracks of inspiration as we bring the latest details on what is happening with Qt. From innovative demos to expert presentations, inspiring Speakers and the coolest applications imaginable. Whether you’re looking to take a deep technical dive or seeking business insights, we have something for everyone at this year’s Qt World Summit

Designed for business people and developers alike, the Qt event of the year has something for everyone who is envisioning, innovating and implementing tomorrow’s devices and applications.

At Qt World Summit in Berlin, get on the inside track on how software is driving the future of IoT. Learn the secrets to creating user experiences that stand out and are a pleasure to use – and a pleasure to build. See how you can maximize development performance for embedded, desktop, and mobile devices. Be a part of the biggest Qt event in 2017 – check out all the latest demos and Qt applications, meet with other Qt users and developers from all around the world and across multiple industries.

Tickets available now

register_early

Head over to the Qt World Summit website and click Register to make sure you are among the first to get your tickets.

Qt Contributors’ take note

This year we will not hold a separate Qt Contributors’ Summit, but we are inviting all Qt Contributors to a pre-event before Qt World Summit.

So mark your calenders, October 9th and 10th are the days, and the place is bcc.

To register, go to the Qt World Summit website and click Register, Qt Contributors’ Days are included in the ticket list with a nominal fee.


The post Qt World Summit 2017 Early Bird Tickets Now Available! appeared first on Qt Blog.

A small new feature that I have added to Qt 5.8 is the possibility of disabling narrowing conversions in the new-style QObject::connect statement. In this short blog post I would like to share with you why I thought this was useful and therefore implemented it.

The problem

Since Qt 5.0, the new-style, PMF-based (pointer to member function-based) QObject::connect will check at compile time if the signal’s signature is compatible with the slot’s one.

For instance, let’s consider these two …

The post Disabling narrowing conversions in signal/slot connections appeared first on KDAB.

April 11, 2017

In 100.0, Qt developers have even more capabilities for adding mapping and geographic analysis to native apps than ever before. 3D geographic visualization, 2D vector tiled basemap support, enriched error handling in the API, and additional geoprocessing tools are just a few of the new highlights.

Esri is proud to announce the commercial release of ArcGIS Runtime SDK 100.0 for Qt. This is quite a revolutionary and innovative release for ArcGIS developers. The API architecture is continuing to evolve for those of you who are looking to build great native applications for a wide range of devices and platforms!

In addition, Qt developers have more app deployment and design options. These include the following:

  • Support for writing C++ apps that can target all platforms, including macOS, iOS and Android. Esri is committed to providing as many developer options for Qt developers as possible!
  • Support for separating your QML and C++ business logic. Enabling support for this design pattern frees up the Qt developer to adopt best-design practices while writing great GIS apps!

A few of the highlighted features include, but are definitely not limited to:

  • 3D visualization – On desktop platforms, 3D has been brought to the ArcGIS Runtime for native app development. Build 3D scenes with raster, tiled and vector data sets including 3D specific symbology for enhancing viaualization of your geographic data. 

esri-globe-300

  • Maps and scenes – The Map object has been split out from the view that displays it, to represent the model or viewmodelcomponent in a Model-View-Controller (MVC) or Model-View-ViewModel (MVVM) architecture. This same design is also implemented for Scene objects.

maps-and-scenes-300

  • Military symbology API – On desktop platforms, the API and workflow for using Military symbology has been greatly simplified in this release.

military-symbology-api-200x200

  • Go offline – To make things easy for you, the APIs for common operations such as editing, searching, geocoding or routing are the same whether you are online or offline.

There are too many capabilities to describe in this short post, so go check it out yourself. You’ll be surprised by how much you can achieve with ArcGIS Runtime SDK 100.0 for Qt.

We invite you all to download v100 and get started today!

 

 

The post ArcGIS Runtime SDK 100.0 by Esri is here appeared first on Qt Blog.

(a bit sick, so I’ll not write too much)

Sometimes I create a small widget for my own usecase and never blog about it, but this one I think it should be pushed upstream. It’s a small KComboBox that uses a KActionCollection based model to display *all* of the actionCollection’s actions.

The use case for me is really straigth forward – a lot of applications have *tons* of menu / toolbar options, sometimes none of them is visible to the user (unless the user knows where to look at), sometimes the user knows that something exists but cannot find it because the menus are huge, but he remembers the name, or parts of it. I know that this is true for me regarding Kate and the amount of possible programming languages it suports:

My idea is simple: if it’s easy for us to search for thousands of applications using a search line, it should also be fine to do the same thing for the possible actions on any application. thus, KActionRunner was programmed (in about an hour, so lot’s of bugs should still be there.)

The same rules apply for all software, default should be simple, but powerfull when required, and I do think this widget adds both things: it will still keep the defaults clean and it will make more power actions more easily discoverable.

I’ll also change the Delegate to make it more friendly to this post win98 era, but for now that’s what I have.

The code is currently in review, and I do belive that in it’s current state it will not pass ;), but it’s a Wip, and a Wip is for that. if there’s enougth love for that idea I’ll polish it.

In two weeks I’ll be in Augsburg at the 16th Augsburger Linux-Infotag.

Here you’ll have a chance to meet in person, have a look at the latest and greatest Plasma Desktop and see what’s coming up for Plasma 5.10 and other future goodies!

Date: Saturday, 22 April 2017
Time: 9:30 – 17:30
Place: Hochschule Augsburg, Fakultät für Informatik, Friedbergerstr. 2

April 10, 2017

Continuing my series about how input works in KWin/Wayland I want to discuss a brand new feature we implemented for Plasma 5.10. This year we had a developer sprint in Stuttgart and discussed what kind of touchpad and touch screen gestures we want to support and how to implement it. Now the result of this discussion got merged into our master branch and we are currently discussing which actions to use by default.

Gesture Recognizer

Touchpad and touch screen gestures are kind of similar so the approach we took is able to handle both of them. We introduced a GestureRecognizer which is able to recognize gestures (surprise) in a very abstract way. It doesn’t know how the input events look like, whether a touch screen, touchpad, mouse or whatever input device generated the event.

To use the GestureRecognizer a Gesture needs to be registered. The Gesture describes the actual Gesture which needs to be recognized. E.g. how many fingers need to participate in the gesture (for our touch screen gestures it is one, for our touchpad gestures it is four), the direction of the gesture (leftwards, rightwards, downwards, upwards), the minimum distance, the trigger position, etc. etc.

Now input events can be fed into the GestureRecognizer and the GestureRecognizer decides whether a Gesture is active or becomes non-active. As said this is absolutely generic, it doesn’t care how the events are triggered.

This alone does not yet allow to do anything with it, we don’t have any way to use the GestureRecognizer yet.
At this point our implementations for touchpad and touch screen divide. We have different existing implementations which are more suited than trying to have something shared for both.

Touchpad gestures

For touchpad gestures our global shortcuts handling is used. GlobalShortcutsManager is a KWin internal (!) mechanism to register some internal actions to tigger in a global way through input events. The GlobalShortcutsManager gained a GestureRecognizer and various areas in KWin can now register a QAction as a global touchpad gesture.

So far we still haven’t reached the elements we discussed in the previous posts like InputEventFilter. There is of course an InputEventFilter which feeds events into the GlobalShortcutsManager. This filter got extended to support touchpad gestures and now we have the full stack together:

  • libinput reports a touchpad gesture event
  • InputEventFilter passes the touchpad gesture event to the GlobalShortcutsManager
  • The GlobalShortcutsManager passes the information to the GestureRecognizer
  • The GestureRecognizer triggers the QAction
  • something happens

By default the following gestures are supported:

  • 4 finger swipe down: Present Windows
  • 4 finger swipe up: Desktop Grid
  • 4 finger swipe left/right: desktop next/previous

Screen edge support for touch

For touch screen gestures we used a different area in KWin which already provides a fairly similar functionality: Screen edge activation for mouse events.

It’s similar in the way that it activates an action when an input event happens at a screen edge. The main difference is the direction of the input event: for mouse it’s towards the edge, for touch it is from the edge.

The ScreenEdges gained a GestureRecognizer (you see there are two different, independently acting GestureRecognizers) and every Edge defines a Gesture. The Gesture is only passed to the GestureRecognizer if the Edge is reserved for a touch action. Each Edge can have a different action configured and of course you can configure different (or same) action for touch and mouse on the same Edge. When a Gesture for an Edge gets started we provide the same visual feedback as for the edges started through mouse events.

For ScreenEdges there is also a dedicated InputEventFilter which now gained support for touch events and feeds the touch events into the GestureRecognizer.

But there is more to it. This feature got backported to X11. Our X11-standalone platform plugin gained support for XInput 2.2 and touch events. KWin now listens for touch events on X11 and passes these events into the GestureRecognizer of the ScreenEdges. Thus the feature which we implemented on Wayland for Wayland is also available on X11 and directly usable for all users – be it on X11 or on Wayland.

Touchpad gestures are unfortunately only available on Wayland.

I just received another anonymous happiness package, this time personal:

You have worn many hats in open source over the years, not just as a contributor, but also as a mentor. I put a lot of high value into your thought-out opinions and insights. You have a unique and open-minded way of thinking about things, in open source and personal things alike. I’m thankful that we have people like you in open source communities to build better software and also to build better communities. I am lucky to have someone like you around. Thanks for being there always.

Lots of love.

What can I say? �� I am feeling overwhelmed. Thank you so much to whoever has sent me this bit of love!

 

L'articolo Thank you for your love <3 sembra essere il primo su Blogs from WikiToLearn.

Dear anonymous happiness sender,

I woke up this morning to your love message for the WikiToLearn community, sent through happinesspackets.io. The e-mail address used to send the packet is only read by a few people, so I am reposting this love for the whole community to enjoy. Here are the contents of the packet:

I feel totally overwhelmed, excited and very, very grateful. Thank you for caring. You people are just unbelievable. You are a bunch of craziest, most awesome and the most positive people I’ve ever met. You inspire me to give back to the community.

I wish I could express properly what I’m feeling right now.

Thanks for everything guys. Sending hugs, you crazy, amazing people!

What can I say, if not sharing the love for the amazing community that got together? Your words are beautiful and inspiring, and I personally feel extremely happy to have contributed, in my little part, to create such great vibes.

Dear anonymous sender, I do not know who you are, but lots of thanks and love to you too. ��

Love only grows if shared.

 

L'articolo WikiToLearn Happiness Packet received! sembra essere il primo su Blogs from WikiToLearn.

Could you tell us something about yourself?

My name is Marcos Ebrahim. I’m an Egyptian artist and illustrator specialized in children’s book art, having 5 years experience with children’s animation episodes as computer graphics artist. I have just finished my first whole book as children’s illustrator on a freelance basis that will be on the market at Amazon soon. I’m also working on my own children’s book project as author and illustrator.

What genre(s) do you work in?

Children’s illustrations and concept art in general or children’s book art specifically.

Do you paint professionally, as a hobby artist, or both?

Because I’m not a member of any children’s illustration agencies, associations or publishing houses yet, I’m now doing this work on a small scale as a freelancer. I changed careers to be an illustrator a few months ago, so I can’t call myself a professional yet. I hope to achieve that soon.

Whose work inspires you most — who are your role models as an artist?

Nathan Fowkes‘ works and illustrations. I found this illustrator and concept artist on a website that called him “the master of value and colour”. I was lucky engough to study online (an art program by Schoolism) under his supervision and learn a lot. However, I’m not a brilliant student ��

Other great illustrators and artists I like: Goro Fujita, Marco Bucci, Patrice Barton, Will Terry, Lynne Chapman, John Manders and many others. I always look forward to seeing their art works to learn from them.

How and when did you get to try digital painting for the first time?

About three years ago, when I was trying to use my new Wacom Intuos tablet for painting and drawing, practicing studies from the great Renaissance masters as fan art.

What makes you choose digital over traditional painting?

Let me describe it like this: “The Undo-Time Machine — the great digital button”. Beside the ability to make changes in illustrations easily, I found its benefit when I tried to work with authors and they asked me to make changes that I couldn’t have made in traditional painting without redoing the illustration from scratch.

How did you find out about Krita?

I used to surf Youtube for viewing Illustrations and artists demo their work. Then I heard about Krita as open source art software. So I decided to search more and found out that the illustrations made with it could be similar to my work, so I should devote some of my time to know more about it and try it. Then I searched out more learning videos on Youtube. Frankly, the most impressive and helpful one was a long video tutorial by the art champion of the Krita community, David Revoy, making a whole comic page from scratch using Krita. He showed the whole illustration process, as well as the brushes and tools he provides for others to use (thank you very much!).

What was your first impression?

I think the Krita program has a user-friendly interface and tools that become more familiar when I configure the shortcuts similarly to most popular other art programs. This make it easier to work without the need to learn many things in a short time.

What do you love about Krita?

I think the most wonderful thing is the brush sets and the way they look like real-world tools. In addition some other tools like the transformation tool (perspective) and the pop-up tool.

Also I can say that working with Krita is the first time that I can work on one of my previous sketches and achieve a good result (according to my current art skills) that I’m happy with.

What do you think needs improvement in Krita? Is there anything that really annoys you?

As I mentioned to the Krita team, there are some issues that we could call bugs. However, I know that Krita is in development and the great Krita team makes things better from one version to another and add new features all the time. Thanks to them and hoping that they will continue their great work!

What sets Krita apart from the other tools that you use?

I think that Krita, as open-source art software, could soon compete with commercial art software if it continues on this path (fixing bugs and adding new features).

If you had to pick one favourite of all your work done in Krita so far, what would it be, and why?

Frankly, I’ve only recently started to use Krita and I’ve finished only two pictures. One I could call an illustration, the other is the background of my art blog, trying to use the wrap tool to make a tiled pattern. You can see this in the screenshots.

What techniques and brushes did you use in it?

I prefer to make a sketch, then work on it adding base colors and adjusting
the lighting value to reach the final details.

Where can people see more of your work?

I add new works to my art blog once or twice every month or more
often, depending on the time I have available and whether I make anything
new.

http://marcosebrahimart.tumblr.com

And also here:
https://www.behance.net/MarcosEbrahim
http://marcosebrahim.deviantart.com/gallery/
https://www.artstation.com/artist/marcosebrahim

Anything else you’d like to share?

All the best wishes to the great Krita team for continuing success in their
work in developing Krita open source software for all artists and all people.

April 09, 2017

This is not a GNOME vs Plasma comparison, this specifically for Ubuntu and its users, considering the innovative vision they had till now. Just very personal thoughs ordered by importance for Ubuntu success in my opinion.

1. Windows-like experience by default

The most important reason for me is that the new Ubuntu user generally was a Windows user. Plasma by default has a Windows-like look and feel: panel at the bottom with an icon to open a menu and search/launch applications and files, a task manager and a system tray. I installed Plasma to many Windows users during the years and they found it more intuitive than Ubuntu Unity and probably than GNOME 3. In fact I tried GNOME 3 many times but it took a while before I was able to understand the GNOME’s vision for workflow. It’s very interesting and innovative, but it’s imposed by default and you will learn how to use it well only if you want to do so or if you are a very experinced user of other particular UI. The Windows user that try Linux just want a working environment. I saw that Windows users that tried Plasma were satisfied from the first moment, start working and after a while (days, weeks) they customized their UI and explore new workflows, probably when they have free time and aren’t stressed by work.

2. Unity-like experience with one click

Who like Unity experience can easily get it from a fresh Plasma installation by using a Look&Feel package. There is already a package for that on KDE Store. Eventually, the Ubuntu installer could provide a choice at the end of the process asking which experience the user prefer (Windows-like/Plasma-default, Unity-like, Mac OS-like etc).

3. Simple by default, powerful when needed

KDE software, including Plasma and KDE Applications, is generally very simple and intuitive by default, but provides advanced features that user can easily discover with its own curiosity. Instead GNOME has a precise vision about minimalism, that means very elegant product but often also missing very important features for productivity.

4. Plasma Mobile

KDE is developing its alternative to Android with many tech things in common with Ubuntu Touch. Ubuntu enthusiasts’ experience with Qt and QML could be used in Plasma Mobile world. At the moment Ubuntu Touch apps can run in Plasma Mobile.

5. Convergence is the future

The original idea about convergence of UIs born in KDE. Canonical developed it with Ubuntu Touch and now Plasma Mobile and Kirigami are continuing that vision. Convergence is pursued also by Google and Microsoft and in the future it will be a very common feature. Smartphones becoming desktop PCs when plugged to keyboard, mouse and monitor, tablet becoming laptop, files and configurations shared across different form-factor devices are here. Plasma and Kirigami takes advantage of the best technologies for this purpose like Qt/QML and Wayland.

6. Kirigami apps that run everywhere

Let’s be honest: Plasma Mobile and others will not be real alternatives to Android in the short term. But being in the mobile world, on Android or iOS, is very important for every software manufacturer and in fact KDE litterally did a revolution with KDE Connect that improve the desktop experience with Android. But think also to apps like Nextcloud, both available on Linux desktop and Android that sync our files. To provide a better Plasma and KDE software experience we need this kind of companion apps on Android and iOS. Kirigami is here to provide a cross-platform UI framework for Linux Desktop, Windows, Mac OS, Android, iOS and Plasma Mobile.

7. Qt is not a Linux-thing only

Though Gtk could be a good product, its focus is on Linux desktop and it’s developed mostly for GNOME’s vision. KDE software uses Qt instead, that is one of the best products in the industry and it’s available on Windows, Mac OS, Android and iOS. While many developers prefer Gtk for their Linux apps, if the purpose is promoting FOSS we should open to other platforms and as I said, especially on Android and iOS because we currently don’t have a mobile alternative platform.

8. KDE Neon and its innovations

KDE Neon provides a new way to join development by providing a complete set of builds, including directly from git-stable and git-unstable repositories. Also, using Docker images of KDE Neon users are able to quickly test new features providing feedbacks or to hunt bugs. I find very useful to try a daily build to check if a bug was fixed before I report it.

9. Integration with KDE Store

KDE software, including Plasma and Applications, can download very different types of addons from KDE Store without visiting any Web page, directly from applications: Plasma widgets, Plasma themes, Freedesktop icons, Service Menus for Dolphins, skins for Yakuake and many many others. We all see the success of Google Play Store and Apple’s one, the KDE Store and OpenDesktop in general is a step forward hosting addons. KDE integrations for them is continously improving: also Plasma Discover, the KDE’s software center, can manage addons from the KDE Store.

10. Breeze

Very personal thought: Breeze theme looks more modern and it’s adopted also in non-KDE products, for example Breeze icons are now used in Libreoffice.


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.