Ir para o conteúdo

Bem-vindo ao Planet KDE

Este é um agregador de fontes que recolhe o que os colaboradores da comunidade do KDE estão a escrever nos seus ‘blogs’ respectivos, em diferentes línguas

Sexta, 22 de Abril de 2022

Eu queria algo para guardar minha lista de tarefas, então criei essa simples aplicação de lista de tarefas.

Com Tasks, você pode criar tarefas escrevendo o nome da nova tarefa no campo de texto no final da janela, e quando você deixa seu mouse sobre alguma tarefa ele mostra um botão de editar e de excluir.

Em cima da lista de tarefas tem um contador de tarefas na esquerda, que mostra o número total de tarefas, e um botão de limpar e de sobre, que remove todas as tarefas e mostra uma página de sobre, respectivamente.

Eu não quero que ele seja muito complexo, então não terá suporte para sub-tarefas, pelo menos por enquanto.

Eu consegui substituir meu uso de notas no desktop completamente com ele, e espero que consiga achar algum uso para ele também1.


  1. Tasks ainda não foi lançado. Vou começar a trabalhar nisso agora. :) ↩︎

Quinta, 21 de Abril de 2022

Welcome to KDE Gear ⚙️ 22.04!

Skip to What’s New

KDE Gear ⚙️ 22.04 brings you all the updates added to a long list of KDE apps over the last four months. KDE programs allow you to work, create and play without having to submit yourself to extortionate licenses and intrusive advertising, or surrender your privacy to unscrupulous corporations.

Below you will discover a selection of the changes added in the last four months to software designed to make your life better. But remember, there is much, much more: games, social media apps, utilities for communicating, developing and creating stuff… All these things have been worked on to give you more stability and boost your productivity.

If you want to see a full list of everything we have done, check out the complete changelog.

WARNING: There’s a lot!

Destaques

Konsole

Konsole gets snippets

Kdenlive

Kdenlive gets sections

Skip to What’s New

What is KDE Gear

KDE Gear is a set of apps and other software created and maintained by the KDE Community that release all new versions at the same time. KDE Gear may also include new apps that we deem have reached enough maturity to be included in the release.

When we announce a new version of KDE Gear (like we are doing today), you can expect the new versions to appear in your Linux distros shortly afterwards. In some distributions, new versions will appear nearly immediately – such as in the case of Neon. In others, it may take days or even weeks, as it depends on your distro’s packagers.

New versions of KDE Gear apps also pop up in independent app stores, such as FlatHub or the Snap Store; and as updates on non-Linux platforms, such as on Windows.

What’s New

Dolphin

Dolphin users will find that KDE’s powerful file manager now shows previews for more types of files and more information about each item in your file system in a more readable way. This makes it easier to determine accurately what is each thing and helps you decide what to open, move, copy, compress or erase before you even do it.

Dolphin can display thumbnails for ePub files, the dimensions of images under their previews, and give the extension .part for files that have only been partially downloaded or copied. When compressing single or several files, or whole directories, Dolphin now gives you a more meaningful file name, and also includes improvements for languages that are written from right to left.

Connectivity with MTP devices, such as cameras, now works much better overall and new users unfamiliar with Dolphin can find it when looking for applications just by searching for “Explorer”, “Finder”, “files”, “file manager” or “network share”.

Dolphin shows image dimensions under the name of the file.

Konsole

Another application that makes itself easy to find is Konsole, KDE’s powerful terminal emulator. Now, if you search for “cmd” or “command prompt”, Konsole will pop up as an option.

Of course, that is not the only news regarding Konsole. Konsole’s SSH plugin has been further enhanced and you can assign different visual profiles (with different colors for backgrounds, text, etc.) to each SSH account. Like that you always have a visual cue for where you are. And a completely new feature is Quick Commands: open a quick commands pane from Plugins > Show Quick Commands and you will be able to create short scripts you use frequently and invoke them when you need them with a couple of clicks.

Other new things are that Konsole now supports Sixel images that can be displayed right inside the window, and you can now open the current directory or any other folder you right-click on in any app, not just the file manager.

Konsole opens Sixel images directly in the window

As for increasing usability, Konsole’s scrolling performance is now twice as fast and has been adapted for touch-scrolling.

Kdenlive

The biggest news coming out of the Kdenlive project is that now macOS users can edit videos with Kdenlive on the newer M1 devices. This opens up a whole new audience of Mac users and can help make Kdenlive a serious contender in the video-editing world.

In other news, the render dialog has been revamped and it is easier to see all the available rendering options, while at the same time adding features. Two new options in particular stick out: you can create customised profiles so that your rendered movie adapts perfectly to your needs, and you can also render by zones, using the guides you set up on the timeline as references.

Kdenlive lets you create customised render profiles.

There is also initial support for 10-bit color, although this is still a work in progress, as applying any effect to a 10-bit clip will drop your video down to 8-bit color. You can look forward to full 10-bit color support in future versions of Kdenlive.

Kate

Kate is much more than a text editor. It incorporates features that make it ideal for editing HTML, LaTeX and Markdown documents and provides utilities to make it an excellent programming and development environment, including comprehensive support for Git, syntax coloring, and “snippets” — templates of commonly used code.

In today’s release, you will find Kate starts up faster and makes it easier to browse your project directories and find files. It also helps you differentiate files with the same names, but placed in different locations. Along with a menu reshuffle, enhancements to the indented layout of code, and improvements to Kate’s support on Wayland, Kate improves its overall usability, stability and range of features.

Kate’s navigation bar lets you browse directories and files easier.

Okular

Okular is KDE’s all-terrain document viewer. Apart from becoming the world’s first computer program to be awarded an eco-certification backed by a government, Okular has improved its usability and user-friendliness and now presents a welcome screen when opened without a document and alerts you immediately when you go to sign a document but have no valid digital certificates.

Okular starts with a welcomes screen when opened without a document.

And also this…

  • Elisa, KDE’s elegant and modern music player, improves its support for touch screens, is faster, more stable and you can now drag and drop music and playlist files from your file manager onto the playlist panel.
  • With Skanpage, KDE’s scanning utility, you can now share scanned documents (including multi-page PDFs) using KDE’s general sharing system, which allows you to push documents to instant messaging apps, online cloud services, social services, and through Bluetooth to other devices.
  • Spectacle’s annotation tools add functionality to crop, scale, undo, redo, and in general do many more things with the images you screenshot. Also, any annotation settings you change will be remembered the next time you startup the program.
  • Gwenview, KDE’s image viewer, detects and guides you through the installation of camera importers that are lacking support packages. There is also a new Print Preview functionality for when you need a hard copy.
  • KDE Itinerary, KDE’s travel assistant (also available for your phone), improves support for more train companies (such as Renfe and Amtrak) and airlines. It also adds more detailed information for weather and an inbuilt barcode scanner so you can scan your ticket’s information directly from the app.
  • … And much, much more

New Arrivals

Kalendar is a modern calendaring and task managing app with an attractive interface and lots of useful features you can use to sync with all your other calendars. It works on your desktop and on Plasma Mobile.

Kalendar helps you keep track of your appointments and tasks.

Full changelog here.

O KDE Gira à Volta das Aplicações

One of the Goals of KDE is to be All About the Apps. This means the KDE Community takes more charge of releasing our own software and delivering it directly to you. Although we fully support distributions that ship our software, KDE Gear 22.04 apps will also be available on these Linux app stores shortly:

Snapcraft
Flathub

Se quiser ajudar a ter mais aplicações do KDE nas lojas de aplicações, ter suporte para mais lojas e ter as aplicações melhor integradas com o nosso processo de desenvolvimento, venha dizer ‘olá’ na nossa sala de conversa ‘All About the Apps’.

Screenshots of many applications

Quarta, 13 de Abril de 2022

Um dia depois de usar alguns apps do KDE eu percebi que as telas de carregamento não eram consistentes, cada aplicativo estava implementando uma solução unica então eu criei esse LoadingPlaceholder componente pro Kirigami.

Ele lida com os seguintes estados:

  • indeterminado, quando ele não sabe quando ele vai realmente carregar (primeira parte do vídeo)
  • determinado, quando ele sabe quanto ele está realmente carregando (segunda parte do vídeo)

Como isso ajuda

Esse componente vai substituir as várias implementações achadas nos aplicativos, consequentemente melhorando nossa consistência!

Só queria compartilhar esse pequeno componente, com menos de 70 linhas de código já é possível melhorar muito nossa plataforma, cada pequena contribuição importa :)

Terça, 22 de Março de 2022

Então, ontem eu estava olhando o site OpenStreetMap.org porque eu meio que gosto de mapas e decidi construir uma POC!

Eu te apresento Coast

Você pode estar se perguntando “por que ele se chama coast?”, o fundador do OpenStreetMap se chama Steve Coast e eu achei esse um bom nome para um aplicativo de mapas.

No momento ele só consegue fazer duas coisas:

  • Procurar
  • Mover com o mouse

Mas pelo menos ele é bonito:

coast application showing the Tokyo map

E eu também fiz uma logo pra ele porque não, né?

coast application logo

Aqui está o código fonte se você está interessado nisso, só queria compartilhar minha animação com esse simples mapa! :)

Domingo, 6 de Março de 2022

Nessa ultimas duas semanas eu estava aprendendo como buscar APIs com Qt and eu finalmente consegui fazer alguma coisa funcional! Nesse post a gente vai criar uma pequena aplicação que busca informação sobre um usuário especifico do github.

Primeiras etapas

Eu vou estar usando esse tutorial Kirigami como um ponto de partida.

Primeiro a gente vai criar dois arquivos src/controller.h e src/controller.cpp e adicionar src/controller.cpp no arquivo src/CMakeLists.txt:

src/CMakeLists.txt

add_executable(... controller.cpp ...)

src/controller.h

#include <QObject>
#include <QNetworkAccessManager>

class Controller : public QObject
{
    Q_OBJECT

public:
    Q_INVOKABLE void fetch(QString username);

private:
    QNetworkAccessManager m_manager;
};

No arquivo de cabeçalho temos essa classe Controller que herda do QObject, ela tem um QNetworkAccessManager como membro que nós vamos utilizar para fazer requisições e uma função fetch que recebe um usuário do github como parametro. A macro Q_INVOKABLE é usado para que possamos chamar essa função pelo QML.

src/controller.cpp

#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonObject>
#include <QDebug>

#include "controller.h"

void Controller::fetch(QString username)
{
    if (username.isEmpty()) {
        qWarning() << "Username must not be empty";
        return;
    }

    QNetworkRequest request = QNetworkRequest(QString("https://api.github.com/users/%1").arg(username));
    QNetworkReply* reply = m_manager.get(request);

    QObject::connect(reply, &QNetworkReply::finished, [this, reply]() {
        if (reply->error()) {
            qWarning() << "Error fetching URL";
            qWarning() << reply->errorString();
        } else {
            // read data
            QString replyText = reply->readAll();

            // ask doc to parse it
            QJsonDocument document = QJsonDocument::fromJson(replyText.toUtf8());

            // we know first element in file is object, to try to ask for such
            QJsonObject object = document.object();

            qDebug() << object;
        }
        reply->deleteLater(); // make sure to clean up
    });
}

No arquivo .cpp primeiro verificamos se username está vazio, se sim mostramos um aviso e retornamos.

Depois nós criamos a request passando a URL da API do github como argumento pro QNetworkRequest e usamos uma QString para guardar o username.

Então a gente cria uma reply usando um metodo de um membro da nossa classe que a gente declarou antes, o metodo get(), que recebe a request que a gente acabou de criar como argumento e retorna uma QNetworkReply.

Então nós conectamos á um sinal do QNetworkReply que diz pra gente que está tudo pronto, verificamos se não tem um erro, se tiver mostramos um aviso e a mensagem de erro, se não tem nenhum erro nós continuamos.

Vamos guardar tudo que veio da requisição em replyData como uma QString e então transformar tudo em um QJsonDocument e guardar isso em document. O primeiro elemento da API do github é um objeto então a gente pode acessar esse objeto com document.object();

Se a gente printar isso vamos ter uma coisa tipo essa:

QJsonObject(
    {
        "avatar_url":"https://avatars.githubusercontent.com/u/52990296?v=4",
        "bio":"My KDE's gitlab profile is way more interesting",
        "blog":"fhek.gitlab.io",
        "company":"@KDE",
        "created_at":"2019-07-17T05:13:51Z",
        "email":null,
        "events_url":"https://api.github.com/users/FHEK789/events{/privacy}",
        "followers":13,
        "followers_url":"https://api.github.com/users/FHEK789/followers",
        "following":4,
        "following_url":"https://api.github.com/users/FHEK789/following{/other_user}",
        "gists_url":"https://api.github.com/users/FHEK789/gists{/gist_id}",
        "gravatar_id":"",
        "hireable":true,
        "html_url":"https://github.com/FHEK789",
        "id":52990296,
        "location":"Brazil",
        "login":"FHEK789",
        "name":"Felipe Kinoshita",
        "node_id":"MDQ6VXNlcjUyOTkwMjk2",
        "organizations_url":"https://api.github.com/users/FHEK789/orgs",
        "public_gists":0,
        "public_repos":3,
        "received_events_url":"https://api.github.com/users/FHEK789/received_events",
        "repos_url":"https://api.github.com/users/FHEK789/repos",
        "site_admin":false,
        "starred_url":"https://api.github.com/users/FHEK789/starred{/owner}{/repo}",
        "subscriptions_url":"https://api.github.com/users/FHEK789/subscriptions",
        "twitter_username":null,
        "type":"User",
        "updated_at":"2021-12-17T17:47:02Z",
        "url":"https://api.github.com/users/FHEK789"
    }
)

Eba! Nossa primeira requisação usando Qt!

Criando algumas propriedades

Agora vamos criar algumas propriedades para guardar os valores que a gente quer do documento JSON, por enquanto vamos só guardar o nome do usuário:

src/controller.h

...

class Controller : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString name READ name NOTIFY nameChanged)

    ...

Q_SIGNALS:
    void nameChanged();

private:
    QNetworkAccessManager m_manager;

    QString m_name;
};

A gente usa essa macro Q_PROPERTY pra criar propriedades, que funcionam como membros mas com algumas funções adicionais, você pode ler mais sobre isso aqui, então a gente faz nosso sinal e membro guardar o nome do usuário.

src/controller.cpp

void Controller::fetch(QString username)
{
    ...

    QObject::connect(reply, &QNetworkReply::finished, [this, reply]() {
        if (reply->error()) {
            qWarning() << "Error fetching URL";
            qWarning() << reply->errorString();
        } else {
            // read data
            QString replyText = reply->readAll();

            // ask doc to parse it
            QJsonDocument document = QJsonDocument::fromJson(replyText.toUtf8());

            // we know first element in file is object, to try to ask for such
            QJsonObject object = document.object();

            // ask object for value
            QJsonValue name = object.value(QString("name"));
            m_name = name.toString();
            Q_EMIT nameChanged();
        }
        reply->deleteLater(); // make sure to clean up
    });
}

Agora invés de pegar todos os dados, vamos pedir apenas pelo nome do usuário. Nós podemos acessar esse valor usando essa notação .value(), e então definir m_name como uma versão string do valor em JSON e emitor o sinal nameChanged para que nossa aplicação saiba que nossa propriedade mudou.

Vamos repetir esse processo pra guardar todos os dados que a gente quer, que vai se parecer com alguma coisa tipo essa:

src/controller.h

...

class Controller : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString login READ login NOTIFY loginChanged)
    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
    Q_PROPERTY(QString bio READ bio NOTIFY bioChanged)
    Q_PROPERTY(QString avatarURL READ avatarURL NOTIFY avatarURLChanged)
    Q_PROPERTY(QUrl profileURL READ profileURL NOTIFY profileURLChanged)

    ...

Q_SIGNALS:
    void loginChanged();
    void nameChanged();
    void bioChanged();
    void avatarURLChanged();
    void profileURLChanged();

private:
    QNetworkAccessManager m_manager;

    QString m_login;
    QString m_name;
    QString m_bio;
    QString m_avatarURL;
    QUrl m_profileURL;
};

src/controller.cpp

...

void Controller::fetch(QString username)
{
    ...

    QObject::connect(reply, &QNetworkReply::finished, [this, reply]() {
        if (reply->error()) {
            qWarning() << "Error fetching URL";
            qWarning() << reply->errorString();
        } else {
            // read data
            QString replyText = reply->readAll();

            // ask doc to parse it
            QJsonDocument document = QJsonDocument::fromJson(replyText.toUtf8());

            // we know first element in file is object, to try to ask for such
            QJsonObject object = document.object();

            // ask object for value
            QJsonValue login = object.value(QString("login"));
            m_login = login.toString();
            Q_EMIT loginChanged();

            QJsonValue name = object.value(QString("name"));
            m_name = name.toString();
            Q_EMIT nameChanged();

            QJsonValue bio = object.value(QString("bio"));
            m_bio = bio.toString();
            Q_EMIT bioChanged();

            QJsonValue avatarURL = object.value(QString("avatar_url"));
            m_avatarURL = avatarURL.toString();
            Q_EMIT avatarURLChanged();

            QJsonValue profileURL = object.value(QString("html_url"));
            m_profileURL = profileURL.toString();
            Q_EMIT profileURLChanged();
        }
        reply->deleteLater(); // make sure to clean up
    });
}

Declaramos alguns metodos que vão retornar essas propriedades:

src/controller.h

...

class Controller : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString login READ login NOTIFY loginChanged)
    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
    Q_PROPERTY(QString bio READ bio NOTIFY bioChanged)
    Q_PROPERTY(QString avatarURL READ avatarURL NOTIFY avatarURLChanged)
    Q_PROPERTY(QUrl profileURL READ profileURL NOTIFY profileURLChanged)

public:
    Q_INVOKABLE void fetch(QString username);

    QString login();
    QString name();
    QString bio();
    QString avatarURL();
    QUrl profileURL();

    ...
};

E definir eles no arquivo .cpp:

src/controller.cpp

...

QString Controller::login()
{
    return m_login;
}

QString Controller::name()
{
    return m_name;
}

QString Controller::bio()
{
    return m_bio;
}

QString Controller::avatarURL()
{
    return m_avatarURL;
}

QUrl Controller::profileURL()
{
    return m_profileURL;
}

Deixando nossa classe disponivel em QML

Finalmente deixamos essa classe disponivel pra nossa aplicação:

src/main.cpp

...

#include "controller.h"

int main(int argc, char *argv[])
{
    ...

    QQmlApplicationEngine engine;

    qmlRegisterSingletonInstance("org.kde.githuby", 1, 0, "Controller", new Controller);

    ...
}

qmlRegisterSingletonInstance é usado para fazer nossa classe disponivel em QML, agora a gente pode chamar ela nos nossos arquivos QML assim:

src/contents/main.qml

import QtQuick 2.15
import QtQuick.Controls 2.15 as QQC2
import QtQuick.Layouts 1.15
import org.kde.kirigami 2.19 as Kirigami

import org.kde.githuby 1.0

...

Você pode mostrar essas informação de qualquer jeito que quiser, aqui está como eu fiz:

/*
    SPDX-License-Identifier: GPL-2.0-or-later
    SPDX-FileCopyrightText: 2022 Felipe Kinoshita <kinofhek@gmail.com>
*/

import QtQuick 2.15
import QtQuick.Controls 2.15 as QQC2
import QtQuick.Layouts 1.15
import org.kde.kirigami 2.19 as Kirigami
import QtGraphicalEffects 1.15

import org.kde.githuby 1.0

Kirigami.ApplicationWindow {
    id: root

    title: i18n("githuby")

    minimumWidth: Kirigami.Units.gridUnit * 20
    minimumHeight: Kirigami.Units.gridUnit * 20
    width: Kirigami.Units.gridUnit * 25
    height: Kirigami.Units.gridUnit * 25

    header: QQC2.ToolBar {
        RowLayout {
            anchors.fill: parent

            Kirigami.SearchField {
                id: searchField
                Layout.fillWidth: true

                placeholderText: i18n("Insert github username")
                autoAccept: false
                onAccepted: Controller.fetch(text)
            }
        }
    }

    pageStack.initialPage: Kirigami.Page {
        id: page

        globalToolBarStyle: Kirigami.ApplicationHeaderStyle.None

        Kirigami.PlaceholderMessage {
            id: placeholder

            anchors.centerIn: parent
        }

        ColumnLayout {
            id: content
            visible: false

            width: parent.width - (Kirigami.Units.largeSpacing * 4)
            anchors.centerIn: parent

            Image {
                id: img

                Layout.alignment: Qt.AlignHCenter
                sourceSize.height: Kirigami.Units.gridUnit * 10
                fillMode: Image.PreserveAspectFit
                source: Controller.avatarURL

                layer.enabled: true
                layer.effect: OpacityMask {
                    maskSource: Item {
                        width: img.width
                        height: img.height
                        Rectangle {
                            anchors.centerIn: parent
                            width: img.width
                            height: img.height
                            radius: Kirigami.Units.smallSpacing
                        }
                    }
                }
            }
            Kirigami.Heading {
                Layout.alignment: Qt.AlignHCenter
                text: Controller.name
                type: Kirigami.Heading.Primary
                font.underline: mousearea.containsMouse

                MouseArea {
                    id: mousearea
                    anchors.fill: parent

                    cursorShape: Qt.PointingHandCursor
                    hoverEnabled: true

                    onClicked: Qt.openUrlExternally(Controller.profileURL)
                }
            }
            Kirigami.Heading {
                Layout.alignment: Qt.AlignHCenter
                text: Controller.login
            }
            QQC2.Label {
                Layout.fillWidth: true
                Layout.alignment: Qt.AlignHCenter
                horizontalAlignment: Qt.AlignHCenter
                text: Controller.bio
                wrapMode: Text.Wrap
            }
        }
    }
}

Como que ficou

E é assim que ela se parece: githuby app

Isso é tudo por enquanto! :)

Terça, 8 de Fevereiro de 2022

Today the KDE Community releases Plasma 5.24, a Long Term Support (LTS) release that will receive updates and bugfixes until the final Plasma 5 version, before we transition to Plasma 6.

This new Plasma release focuses on smoothing out wrinkles, evolving the design, and improving the overall feel and usability of the environment.

Things to look for in Plasma 5.24:

Destaques

Introdução

Use Overview to manage all your desktops and applications

KRunner

Discover KRunner features with the help assistant

Fingerprint Readers

Unlock the screen and authenticate apps with your fingerprints

Desktop and Panel

Plasma 5.24 desktop

The first thing you will notice is Ken Vermette’s spectacular new wallpaper for Plasma 5.24. Ken created the Honeywave wallpaper and streamed the process live on YouTube, giving Plasma a whole new look.

Ken Vermett designing the Honeywave wallpaper live on YouTube

If you happen to prefer something else as your background, you can now set your wallpaper just by right-clicking on any picture in Dolphin and selecting Set as Wallpaper from the context menu. Furthermore, if you use the Picture of the Day wallpaper plugin, it can now pull images from Simon Stålenhag’s gallery, which is full of cool and creepy sci-fi images.

Get a new wallpaper every day using the Picture of the day feature

Bring up the desktop context menu again and you will notice that there is a new Configure Display Settings item. This lets you adjust your screens’ resolution, orientation, scaling, and position relative to other monitors.

Desktop Panels are now easier to move around and stick to any edge you want, as you can now drag them from anywhere on their toolbar while in Edit Mode. And when you drag-and-drop widgets onto the desktop and move them around, they now smoothly animate moving to their final position rather than instantly teleporting there.

Looks and Themes

After the spectacular new wallpaper, the next thing you will notice are the changes to Breeze, Plasma’s default theme. It has received a visual refresh to make it more closely match the Breeze style for apps, improving the visual consistency between them.

Plasma is all about customization, and we have worked on making the process clear and simple so you can adapt your environment exactly to how you like it. That is why the default Breeze color scheme has been renamed to Breeze Classic, to better distinguish it from the Breeze Light and Breeze Dark color schemes.

Speaking of colors, Breeze now extends the feature that lets you pick accent colors (introduced in Plasma 5.23) and now lets you pick any color you’d like, should the pre-selected colors fail to tickle your fancy. Not only that, but changing the color scheme now toggles the standardized FreeDesktop light/dark color scheme preference. This means that non-KDE apps that respect this preference will automatically switch to light or dark mode based on your chosen color scheme. Global Themes can also specify and change the layouts of KDE’s Latte Dock.

A theme must not only be beautiful, but it must make life easy for users. That is why we made the focus effect for user interface controls into a large “focus ring”. This makes the item that has keyboard focus much easier to perceive at a glance.

Notificações

To make critically important Plasma notifications stand out, they now come with an orange strip on the side to visually distinguish them from less urgent messages. Meanwhile, we have improved the contrast and visibility of the header and title labels in all notifications to make them easier to read.

Another visual enhancement is that notifications about video files now display a thumbnail of the video in the notification itself, just like for image files.

System Tray and Widgets

Many widgets have received new features and subtle enhancements that improve their looks, the relevance of their information, and ease of navigating them. For example, we have added a Date always below time option for the Digital Clock. The Weather widget asks you to configure it when you add it for the first time to the tray, and now automatically searches through all available weather sources. The Battery & Brightness widget has been made clearer and now shows a more accurate title and icon for computers with no batteries. The new versions of the Clipboard and Network widgets can now be navigated with just your keyboard.

Gestor de Tarefas

When you hover the cursor above a Task Manager item, the window thumbnail tooltip that pops up is now significantly faster to load, and display a volume slider for windows playing audio.

The Task Manager’s context menus have been clarified and simplified. Start New Instance, for example, is now Open New Window and no longer appears for apps marked as having a single main window. Meanwhile, the More Actions item has been moved to the bottom of the menu and changed to just More.

Configuração do Sistema

Configuração do Sistema

Version after version, KDE developers and designers work to make System Settings easier and faster to use. You can see the progress and attention to detail in such small things as System Settings’ own settings: there were so few options that developers have moved them to the hamburger menu that you can see next to the Search text box, preventing the need to clutter up your workspace with another window.

System Setting simplified in every way

If you are using Plasma in a language other than English, we also have you covered. You can use the Search field to find terms both in your language and English without having to switch from one to the other, just in case it has not been translated yet or you are more familiar with the English term. The Add a keyboard layout dialog has been redesigned for simplicity and ease of use.

Other design and usability improvements have been added to Night Color, the speaker test sheet in System Settings’ Audio page, and the battery charge limit feature. For people wanting to fine-tune their monitors, the Display & Monitor section now shows the scale factor used for each screen as well as their proper physical resolution.

For your convenience, when you enable auto-login, you now get a warning about some changes you might want to make to your KWallet setup for optimal usability.

Gestão de Janelas

You can better leverage the power of multiple desktops in Plasma 5.24 with the new Overview effect. It is still in beta testing, but you can enable it in System Settings’ Workspace Behavior > Desktop Effects page and give it a whirl.

Gestão de Janelas

Activate it by holding down the Meta (Windows key) on your keyboard and pressing the w key to see an overview of all your open windows and virtual desktops. You can activate windows, drag and drop windows from one desktop to another, and use the powerful KRunner assistant to search, calculate and run tasks all from the same place.

In addition, the Cover Flip and Flip Switch effects are back! You can find them in the System Settings Window Management > Task Switcher page. These effects let you visually flip through open windows as if they were a deck of cards.

Among the more subtle changes are that Plasma now “remembers” which window was on which screen even when the screen in question is turned off, and performance has been improved for machines with NVIDIA video cards.

Finally, new windows are now opened in the center of the screen by default.

Discover

Discover

Discover now gives you the option to automatically restart after an update has completed. Simply click the checkbox at the bottom of the Updates page, grab a caffeinated beverage, and go enjoy a break. By the time you return, Plasma will have rebooted into the brand new updated system.

We have also added a mobile mode for when you use it on a phone: If it is on a wide screen, its home page will show a two-column card view. Open it on a phone and it will show a bottom tab bar in narrow/mobile mode.

Other improvements are that checking for updates is much faster, and the Update page is now less overwhelming, with a nicer design to select updates. Additionally, it tells you the source of the updates.

Speaking of which… Discover has supported Flatpaks for quite some time, but now locally downloaded Flatpak packages can be opened and installed with Discover, and their repositories automatically get added to your system.

Configure new Flatpak repos easily

Discover also tries to be smarter and friendlier and helps with suggestions if it can’t find exactly what you are looking for. Installation error messages are also more user-friendly and come with a new Report a problem link at the bottom of each description page. If you have a problem with an update, click the link and it takes you straight to the bug tracker page for your operating system. Developers have also included a new safety measure in Discover that stops you from uninstalling your Plasma desktop by mistake.

KRunner

KRunner

KRunner can already find documents and web pages, run commands, convert units and currencies, give you definitions of words, do high level math — and new features are being added with plugins all the time. It can be hard to keep up with everything it can do! But now it’s easy to become a KRunner whiz: click on the question mark icon on the toolbar and KRunner will show a list of available plugins and how to use them. Click on a plugin from the list and you’ll see all the information you need to use it to its fullest.

Login/Lock Screen

Fingerprint authentication is now incorporated into Plasma. You can also enroll up to 10 fingerprints and use them to unlock the screen, provide authentication when an app asks for your password, and also authenticate you when you need to run a command with sudofrom the command line.

Speaking of the lock screen, now you can put your machine to sleep or hibernate it from the lock screen without having to unlock it first.

Wayland

Wayland is the upcoming graphical system that will soon replace the aging X11 system. Wayland opens up a world of possibility for more stable and visually consistent applications, support for touch screens and devices that detect orientation, and more.

Adapting KDE’s desktop to Wayland continues at a brisk pace with a massive number of improvements, including support for colors greater than 8 bits, VR headsets with optimal performance, and drawing tablets. In that vein, when using a stylus, you can now activate other windows from their titlebars and interact more with titlebars in general. Another improvement for tactile input is that the system tray item for showing and hiding the virtual keyboard becomes active only in tablet mode, and the virtual keyboard itself only appears when you explicitly focus a text control with a touch or stylus poke.

Wayland versions of apps and components are quickly acquiring all the features that are putting them on par with their X11 equivalents. For example, you can now set a primary monitor, the Spectacle screen-grabber app has now access to the Active Window mode, and the Minimize All Windows widget now works. Likewise, many keyboard shortcuts available in X11 are all being gradually implemented; like the Meta + Tab key combo, which is used to cycle through activities, and already works in Wayland.

Outras Actualizações

  • Scrollable controls in Plasma now only change their contents when you start scrolling on them. This means you can’t accidentally change things while scrolling the view.
  • Plasma now shuts down faster, as it no longer accepts new connections after it has begun the shutdown process. This is especially helpful when using KDE Connect.

… And there’s much more going on. If you would like to see the full list of changes, check out the changelog for Plasma 5.24.

Quinta, 3 de Fevereiro de 2022

Over 120 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.

Today they all get new bugfix source releases with updated translations.

Os criadores de pacotes das distribuições e lojas de aplicações deverão actualizar os seus pacotes de aplicações.

Quinta, 6 de Janeiro de 2022

Over 120 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.

Today they all get new bugfix source releases with updated translations.

Os criadores de pacotes das distribuições e lojas de aplicações deverão actualizar os seus pacotes de aplicações.

Terça, 18 de Maio de 2021

O beta do Plasma 5.22, de versão 5.21.90, foi lançado no dia 13 de maio de 2021. Ele serve para que, num espaço de mais ou menos três semanas, mais usuários possam testar e relatar erros e regressões no sistema, para garantir um futuro lançamento mais estável para todos.

Uma semana após o lançamento do beta, no sábado, 22 de maio de 2021, teremos o Plasma Beta Review Day, o dia de caça aos bugs, começando às 5h e terminando às 10h da manhã, no fuso GMT-3 Brasília (ou das 10h às 15h horas, no fuso CEST).

Convidamos você a participar e se unir a vários outros usuários de todas as partes do mundo, para contribuir com testes e triagem de bugs, num processo estruturado em que você aprende fazendo.

Para essa reunião ao vivo e completamente online, usaremos uma sala de videoconferência da instância do BigBlueButton da KDE, o link para acesso é: https://meet.kde.org/b/dav-gmr-qzx . Você pode se unir às conversas com microfone e câmera, assistir e interagir no chat, ou apenas ficar acompanhando o movimento.

Para participar não é estritamente necessário instalar o sistema com o beta em sua máquina; você pode usar um LiveUSB com uma imagem do KDE Neon Testing/Unstable ou do openSUSE Krypton e testar, sem perigo para sua máquina, ou você pode usar uma máquina virtual. Outras distribuições têm seus próprios meios de testar o beta também. Para tirar dúvidas e conversar, é necessário saber um básico de inglês. Caso não saiba nada de inglês, podemos ajudar com seus testes e triagem no grupo do Telegram do KDE Brasil que está conectado ao IRC do #kde-brasil, não se preocupe.

No dia de caça aos bugs, você vai ver aprender a lidar com o Bugzilla e responderemos as suas perguntas sobre como reportar erros e fazer triagem, assim como adquirir prática validando relatórios e identificando duplicatas, testando o que há de novo no Plasma e, talvez, até tenhamos desenvolvedores consertando bugs que você mesmo esteja experienciando. Ao nos ajudar com a caça aos bugs você não somente estará nos ajudando a deixar o novo lançamento mais estável como também contribuindo para que os desenvolvedores tenham mais tempo para lidar com desenvolvimento, ao invés de lidar com relatórios inválidos, difíceis de entender ou duplicatas. Portanto, não deixe de participar! Sua ajuda vale muito.

Sábado, 5 de Setembro de 2020

[Esta é uma tradução do artigo original postado no Dot KDE.]

Um dia cheio de palestras fascinantes

O primeiro dia de palestras do Akademy foi bem variado e interessante, cobrindo uma grande variedade de tópicos, desde o gerenciamento de projetos de metas e avanços técnicos em tecnologias Qt e KDE até um programa de odontologia de código aberto e Linux para automóveis.

Aleix Pol, presidente da KDE, deu início ao dia exatamente às 6:00 da manhã no Brasil com um vídeo feito por Bhavisha Dhruve e Skye Fentras para dar as boas vindas a todos por participarem do evento.

Após mencionar as circunstâncias bastante únicas do Akademy deste ano, Aleix introduziu a primeira palestrante, Gina Häußge.

Gina é a criadora e mantenedora do OctoPrint, um sistema cheio de funções e bem sucedido usado para controlar sua impressora 3D por meio de uma interface web. Em sua palestra, Gina tratou tanto de suas experiências boas como das ruins ao assumir o papel de mantenedora de um projeto de código aberto independente. Ela falou sobre o sentimento de liberdade e propósito adquirido ao trabalhar com o projeto, assim como dos pontos negativos de instabilidade financeira e frequentemente se sentir sozinha a despeito de estar trabalhando em algo que serviria a centenas, talvez milhares de usuários. Apesar das desvantagens, Gina admitiu alegremente que faria tudo isso novamente se tivesse a chance e que a sensação de estar ajudando outras pessoas, além da realização que experienciou, definitivamente compensam os momentos ruins.



A palestra de Gina resumida de maneira gráfica por Kevin Ottens.

Logo após foi a hora de outro contribuidor veterano de código aberto brilhar: Jonathan Riddell tratou de como liderou uma das metas atuais da comunidade KDE: Tudo sobre os apps, o projeto no qual membros da comunidade promovem e distribuem os aplicativos da KDE com liberdade, até mesmo onde não haja a área de trabalho do Plasma da KDE. Jonathan mencionou suas motivações para propor esta meta e o resultado do trabalho feito desde seu anúncio no Akademy 2019.



Jonathan Riddell falando sobre o progresso feito na meta Tudo sobre os apps.

De modo semelhante, Niccolo Venerandi apresentou sobre a meta de Consistência. Esta meta tem o objetivo de unificar a aparência do Plasma e de todos os apps da KDE de modo a fornecer uma experiência coerente para os usuários. Niccolo mencionou o fato de que o Plasma não tem problemas sérios de consistência, e sim abordagens diferentes no design de apps que pode ocasionalmente levar a uma quantidade surpreendente de visuais e comportamentos. Niccolo então nos mostra o futuro dos aplicativos da KDE e, honestamente? Parece incrível.

As apresentações tratando individualmente das metas acabaram com Méven Car falando sobre Wayland. Já não é segredo algum que o porte do software e das tecnologias da KDE para o Wayland, o substituto para o clássico sistema de janelas X, está tendo seus altos e baixos. Por isso mesmo a comunidade KDE decidiu tornar o Wayland uma prioridade. A meta do Wayland é uma tarefa difícil que exige atualizações em múltiplos componentes e fazendo como que todo o conjunto gráfico da KDE seja refeito. Como Méven explica, no entanto, a comunidade fez bastante progresso desde o Akademy 2019.

Dando continuidade à apresentação individual das metas da KDE, Niccolo Venerandi, Méven Car, Jonathan Riddell, Lydia Pintscher e Adam Szopa se reuniram para sintetizar como foi o primeiro ano e o subsequente aprendizado em lidar com as metas.

Após a reunião, Andreas Cord-Landwehr falou por dez minutos sobre o SPDX, um sistema usado para licensiamento mais eficiente. Nesta apresentação aprendemos que identificadores do SPDX são um passo importante para permitir o uso de ferramentas automáticas que verifiquem declarações de licensiamento. Andreas explicou as vantagens de usá-las e quão simples é aplicar elas. Ele também deu um resumo curto sobre o que já foi feito em relação ao KDE Frameworks e onde contribuidores podem ajudar e dar apoio à conversão para o SPDX.

Em seguida Shawn Rutledge tratou de Edição de Markdown usando QTextDocument em outra palestra de 10 minutos. Shawn adicionou suporte ao Markdown de primeira no Qt 5.14 e como alternativa ao conjunto limitado de HTML que o QTextDocument costumava usar. Durante a palestra, ele demonstrou alguns editores WYSIWYG escritos com widgets e com Qt Quick.

Como última apresentação curta antes do almoço, Carl Schwan expôs Como criar um bom site promocional para o seu projeto. Carl é o contribuidor principal por trás das melhorias drásticas em muitos dos sites da KDE, incluindo o kde.org. Durante a palestra, Carl apresentou o tema de Jekyll da KDE, a motivação por trás do projeto, e explicou brevemente como o tema pode ser usado para criar um site da KDE. Ele também apresentou exemplos de sites com design pobre e como eles podem ser melhorados para tornar os projetos mais atrativos para usuários em potencial.



Os Akadêmicos aproveitando o período de descanso entre as palestras da manhã e da noite.

No período da tarde, as apresentações tiveram início com a palestra do conselho administrativo do KDE e.V. e relatórios dos Grupos de Trabalho. O conselho falou aos atendentes sobre todas as coisas que eles fizeram ao longo do ano desde o último Akademy. Algumas ações de destaque foram o aumento do número de três empregados pagos para cinco, a migração para o GitLab e um aumento no fundo de suporte para os membros da comunidade. O conselho então prosseguiu tratando dos detalhes das atividades do vários grupos de trabalho, embora algumas de suas apresentações tenham sido relocadas para o fim do dia devido ao tempo disponível.

O texto completo do Relatório Anual da KDE – 2019 está disponível para leitura à vontade.

E então voltamos à programação de palestras com a Atualização do gerenciamento de entrada, apresentado novamente por Shawn Rutledge. Nesta palestra, Shawn falou sobre o que está por vir e as várias metas para eventos de entrada no Qt 6.



Cornelius Schumacher contando a história da KDE Free Qt Foundation.

Enquanto isso, na sala 2, Cornelius Schumacher falou sobre a KDE Free Qt Foundation. Estabelecida em 1998, a KDE Free Qt Foundation foi fundada para manter o Qt toolkit livre para a KDE e todos os outros projetos de software livre. A fundação se manteve firme durante as mais de duas décadas de períodos ocasionalmente turbulentos que o Qt e a KDE passaram juntos. Cornelius narrou a história de como isso tudo funcionava.

E falando da The Qt Company… Um pouco depois, na sala 1, Richard Moe Gustavsen falou sobre Suporte nativo a estilos para desktop com o Qt Quick Controls 2 e o trabalho contínuo da empresa para dar suporte à escrita de aplicativos de desktop usando Qt Quick Controls 2.

Ao mesmo tempo, na sala 2, Aleix Pol tratou dos Produtos da KDE e como visualizar a relação deles com os usuários. Na palestra, Aleix introduziu um sistema para ajudar desenvolvedores a garantir que a comunidade de software livre e seus usuários sejam protegidos.

Na sequência, na sala 1 Patrick Pereira apresentou Criação rápida de protótipos QML – Desenvolvendo ferramentas para melhorar o desenvolvimento e protótipos QML. Em sua palestra, Patrick falou sobre como a criação de protótipos é feita por todo desenvolvedor de QML e como fazer isso de modo eficiente. Ele utilizou dois projetos como exemplo: QHot (um programa para atualização ao vivo de arquivos QML aninhados) e QML Online (um editor QML online feito com WebAssembly) para explicar como diminuir o tempo de desenvolvimeto e a curva de aprendizado para o QML.



Jonah Thelin dentro de seu carro falando sobre linux em carros.

Na sala 2, Johan Thelin deu início à sua palestra Linux em carros – O que que há? de dentro de seu carro. Literalmente. Johan falou de como carros ainda usam tanto software proprietário ao ponto de ser difícil encontrar as partes que são efetivamente de código aberto, mesmo quando o linux é usado por trás. Ele também falou sobre que medidas são necessárias para melhorar a situação e como software da KDE pode servir para esse tipo de uso.

Logo após essa sequência de palestras de extensão normal, houve três apresentações rápidas de 10 minutos.

Com o Flatpak, Flathub e a KDE: Um resumo geral, Albert Astals Cid introduz a platéia ao Flatpak, explica o que o Flathub é e como a KDE interage com ambos.

Nicolás Alvarez então falou de Como melhorar a infraestrutura de servidores da KDE, da formação do grupo de trabalho dos sysadmins, e explicou aos atendentes como o time de sysadmin está no processo de tornar servidores da KDE melhor gerenciáveis reduzindo “dívidas técnicas”, transferindo tarefas manuais para scripts, melhorando a documentação e tornando mais coisas testáveis localmente antes de sua inserção nos servidores reais.

Na última apresentação rápida do dia, David Edmundson deu dicas de Como ganhar um argumento com um mantenedor, uma vez que testemunhou e participou de centenas de discussões no Bugzilla e no Phabricator que acabavam se tornando impasses emocionais. Ele compartilhou com a platéia os métodos que ele viu funcionar para alcançar meio-termos produtivos e alertou de certas que atitudes que podem levar situações técnicas a experiências desagradáveis para todos.

Logo após se seguiu uma das apresentações mais surpreendentes do dia apresentada por Tej Shah, doutor em Odontologia dos EUA. Tej falou sobre seu projeto Clear.Dental e sua tentativa de converter a odonto para o lado do código aberto usando o poder do Linux, do Qt e da KDE. Ele revisou o estado dos softwares usados no tratamento de dentes (lamentável, por sinal), o problema que existe com os programas atuais, e como o Clear.Dental pode contribuir para resolver tudo isso.

Ao mesmo tempo, na sala 2, Camilo Higuita tratou de seu projeto filho, o Maui, e deu à audiência um geral sobre o que há de novo no grupo de apps, serviços, bibliotecas e infraestrutura de UI que o Maui fornece para criar programas elegantes.

Na sessão seguinte, Rohan Garg deu uma lição aos atendentes com seu Introdução ao hardware gráfico no Linux explicando como a crescente popularidade dos dispositivos ARM levou à criação de arquiteturas de plataforma com hardware gráfico mais peculiar. Ele falou sobre o básico do stack gráfico do Linux funciona e a história por trás de como chegamos aos atual design do Gallium no Mesa.

Por fim, a participante do Google Summer of Code, Amy Spark, exibiu Integrando programas de código aberto de hollywood com aplicativos KDE com o porte da tecnologia de animação da Disney para o Krita. O SeExpr dá a artistas usando o Krita acesso à geração procedural de texturas, permitindo a inclusão de detalhes ínfimos de superfície, efeitos de iluminação, superposições e outros com o aperto de um botão. Como linguagem de script, ele dá aos criadores de conteúdo a flexibilidade necessária para garantir resultados perfeitos de maneira consistente alterando o algoritmo a suas necessidades. Amy teve que superar várias barreiras técnicas durante o processo de portar, uma vez que o SeExpr foi feito originalmente para rodar em um conjunto de software proprietário específico.



David Revoy mostrando um exemplo do SeExpr sendo usado em uma imagem da webcomic "Pepper and Carrot".

Caso você tenha perdido, as palestras do dia estão disponíveis online em três blocos: um da manhã e dois para cada uma das salas usadas à tarde. Nós também gravamos todas as palestras e você poderá assistir cada uma separadamente nas plataformas de vídeo da KDE disponíveis em breve.

Amanhã nós iremos fazer streaming novamente via BigBlueButton, diretamente dos nossos servidores, e pelo YouTube.