Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content
Planet KDE - http://planetKDE.org/
Updated: 4 hours 35 min ago

Latte bug fix release v0.9.1

Monday 5th of August 2019 07:16:45 AM

Latte Dock v0.9.1   has been released containing important fixes and improvements!


Go get  v0.9.1   from, download.kde.orgor  store.kde.org*
-----* archive has been signed with gpg key: 325E 97C3 2E60 1F5D 4EAD CF3A 5599 9050 A2D9 110E
Fixes:
  • improve: when preview windows left click action is used then for single windows is just activating them without triggering the preview window
  • improve: consider the case when a horizontal and a vertical Latte dock/panel are touching each other and the vertical one is in "isBusy" desktop background case, in such case the horizontal view is also changing to "isBusy" state
  • fix: blurred icons for items size that should not be blurred e.g. 48px and >=64px
  • fix: geometries calculation under !compositing environment
  • fix: forward pressed/released event to applets even when parabolic effect is enabled. The issue was pretty obvious with lock/logout plasma applet
  • fix: update progress badge properly
  • fix: tasks icons pixelization when are dragged
  • fix: wayland, show preview window for grouped tasks when clicked

In Latte horizontal and vertical panels when both are using Smart Coloring mechanism are informed if the vertical panels are in Busy state (when the underlying desktop background is busy enough to require the panel background to be shown because with full transparency the contrast is not enough). In such case the horizontals panels are also changing to isBusy state. You can observe the result:

    Before / After
    v0.9.0 / v0.9.1




    Donations:

    You can find Latte at Liberapay if you want to support,    

    or you can split your donation between my active projects in kde store.

    Generating generic questions for calendar activity.

    Sunday 4th of August 2019 10:39:52 AM
    Overview

    One of the tasks for GSoC 2019, was adding multiple datasets to calendar activities, but along with the task I also planned on adding another inprovement to the activity. The activity initially used hardcoded questions and answesr regarding calenders. The dataset for which looked like

    data: [
    {
    "navigationBarVisible" : true,
    "minimumDate": "2018-01-01",
    "maximumDate": "2018-12-31",
    "visibleMonth": 1,
    "visibleYear": 2018,
    "mode": "findMonthOnly",
    "questionsExplicitlyGiven": true,
    "questionAnswers": [
    {
    "question": qsTr("Find the month starting a Thursday and having 28 days"),
    "answer": {"month": [1]}
    },
    {
    "question": qsTr("Find a month starting a Monday and having 31 days"),
    "answer": {"month": [0, 9]}
    },
    {
    "question": qsTr("Find the month between June and August"),
    "answer": {"month": [6]}
    },
    {
    "question": qsTr("Find a month starting a Saturday"),
    "answer": {"month": [8, 11]}
    },
    {
    "question": qsTr("Find a month having 30 days"),
    "answer": {"month": [3, 5, 8, 10]}
    }
    ]
    }, ... and more levels so on
    ]

    So I planned on creating an algorithm that could generate some template questions and answers. The activity has four type of questions depending in the mode. The available modes are

    // findMonthOnly --> For questions based on finding month only.
    // findYearMonthDay --> For questions based on finding year, month and day.
    // findDayOfWeek --> For questions based on finding day of week only.
    // findDay --> For questions based on finding day of a given month and year.

    So, I the algorithm should generate different questions for each type.

    Function to generate date in Range

    The first task is to create a function that would generate a random date within the given range i.e minDate and maxDate.

    function generateRandomYearMonthDay(minimumDate, maximumDate) {
    var minYear = Number(minimumDate.slice(0, 4))
    var maxYear = Number(maximumDate.slice(0, 4))
    var minMonth = Number(minimumDate.slice(5, 7))
    var maxMonth = Number(maximumDate.slice(5, 7))
    var minDate = Number(minimumDate.slice(8, 10))
    var currentYear = minYear + Math.floor(Math.random() * Math.floor((maxYear - minYear + 1)))
    var currentMonth = minMonth + Math.floor(Math.random() * Math.floor((maxMonth - minMonth + 1)))
    var currentDate
    daysInMonths[1] = (isLeapYear(currentYear)) ? 29 : 28;
    currentDate = minDate + Math.floor(Math.random() * Math.floor((daysInMonths[currentMonth - 1] - minDate + 1)))
    return { year: currentYear, month: currentMonth - 1, day: currentDate }
    }
    Function to add offset

    There are some questions which require the user to find a date, a given number of days ahead of the current date. So I created a function to calculate that date.

    function addOffsetToCurrentDate(currentDate) {
    var maxOffset = currentLevelConfig.questionAnswers.maxOffset
    var offset = Math.floor(maxOffset / 2) + Math.floor(Math.random() * Math.floor(maxOffset))
    daysInMonths[1] = (isLeapYear(currentDate.year)) ? 29 : 28;
    offset += currentDate.day
    var answerDate = 1;
    var answerMonth = currentDate.month
    var answerYear = currentDate.year
    while(offset > 0) {
    if(offset - daysInMonths[answerMonth] > 0) {
    offset -= daysInMonths[answerMonth]
    answerMonth++;
    } else {
    answerDate = offset;
    offset = 0
    }
    if(answerMonth > 12) {
    answerYear++;
    daysInMonths[1] = (isLeapYear(answerYear)) ? 29 : 28;
    answerMonth = 0;
    }
    }
    return { year: answerYear, month: answerMonth, day: answerDate, offset: offset }
    }
    Function to generate template questions

    Now there has to be a function that would return the correct question text template as per the mode of the question. So I created a function for that.

    function getTemplateQuestionText(mode, date) {
    var questionText
    if(mode == "findDayOfWeek") {
    questionText = qsTr("What day of the week is on %1?").arg(getDateInLongFormat(date))
    } else if(mode == "findDay") {
    questionText = qsTr("Select day %1?").arg(date.day)
    } else if(mode == "findMonthOnly") {
    questionText = qsTr("Find month number %1").arg(date.month + 1)
    } else {
    if(date.offset) {
    //: The second argument represents the given date in complete format(with complete month name) and the first argument represents the difference in days between given date and answer date.
    questionText = qsTr("Find the date %1 days after %2").arg(date.offset).arg(getDateInLongFormat(date))
    } else
    //: The argument represents the answer date in complete format(with complete month name)
    questionText = qsTr("Find the date %1").arg(getDateInLongFormat(date))
    }
    return questionText
    }
    Function to set question and answer values

    Finally I created a function that would set the correct values of the question and answer variables as per the selected mode.

    if(!currentLevelConfig.questionsExplicitlyGiven) {
    var randomDate = generateRandomYearMonthDay(currentLevelConfig.minimumDate, currentLevelConfig.maximumDate)
    items.score.currentSubLevel = currentSubLevel
    if(currentLevelConfig.mode == "findDayOfWeek") {
    var selectedDate = new Date(randomDate.year, randomDate.month - 1, randomDate.day)
    correctAnswer.dayOfWeek = Number(selectedDate.getDay())
    } else if(currentLevelConfig.mode == "findYearMonthDay" && currentLevelConfig.questionAnswers.maxOffset) {
    correctAnswer = addOffsetToCurrentDate(randomDate)
    randomDate.offset = correctAnswer.offset
    } else {
    correctAnswer = randomDate
    }
    items.questionItem.text = getTemplateQuestionText(currentLevelConfig.mode, randomDate)
    }

    The part of code is executed only if the questions are not explicitly given.

    Dataset contents for template questions

    If the dataset creater wants to use template function then he can define then like

    {
    "navigationBarVisible" : true,
    "minimumDate": "2018-01-01",
    "maximumDate": "2019-12-31",
    "visibleMonth": 10,
    "visibleYear": 2018,
    "mode": "findYearMonthDay",
    "questionsExplicitlyGiven": false,
    "questionAnswers": {
    "length": 5,
    "maxOffset": 90
    }
    },

    where the variable length defines the length of questionSet or the number of questions.

    KDE Usability & Productivity: Week 82

    Sunday 4th of August 2019 04:00:31 AM

    I know I say this a lot… but it’s been yet another big week for KDE’s Usability & Productivity initiative! We also have major features in development–one of which I think will be very popular and I hope to be able to announce it next week. Until then, enjoy this week’s assortment:

    New Features Bugfixes & Performance Improvements User Interface Improvements

    Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out https://community.kde.org/Get_Involved, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

    If you find KDE software useful, consider making a tax-deductible donation to the KDE e.V. foundation.

    digiKam 6.2.0 is released

    Sunday 4th of August 2019 12:00:00 AM

    Dear digiKam fans and users, after the second digiKam 6 release published in April 2019, we received lots of user feedback to consolidate this important stage of this project started 2 years ago. We are proud to quickly announce the new digiKam 6.2.0, as maintenance version. New Camera Supported by Raw Files Engine digiKam try to be the most powerful with all files provided by digital camera. Raw files support is a big challenge.

    kate-editor.org Update

    Saturday 3rd of August 2019 06:48:00 PM

    Like my personal homepage cullmann.io, I ported the kate-editor.org website to the Hugo framework.

    The new website uses zero cookies (yes, no stupid cookie question) and no kind of analytic software. It should be self-contained, too. No external resources that will leak your data to e.g. Google are requested.

    But more important: unlike before, the website content will be fully hosted in a git repository on KDE infrastructure.

    The current intermediate location is on invent.kde.org/websites/kate-editor-org.

    Before, the KDE sysadmin team just got access to a backup of the WordPress instance.

    The new website contains an import of all old pages & posts. I hopefully preserved the old URLs, but there might be some minor glitches for some older posts that still need fixing.

    Some pages still have broken markup, that needs some fixes, too.

    But all-in-all the import of the WordPress content did work really well.

    Some nice step-by-step description how to do such a port can be found in the “Moving 18 years of this personal blog from Wordpress to Hugo” post.

    If you want to contribute, feel free to send me some patch or merge request ;=)

    As a simple template for a new post, take a look at the sources of this one:

    --- title: kate-editor.org Update author: Christoph Cullmann date: 2019-08-03T20:48:00+02:00 --- Like my personal homepage [cullmann.io](https://cullmann.io), I ported the [kate-editor.org](https://kate-editor.org) website to the [Hugo framework](https://gohugo.io/). ...

    The date is important, no stuff in the future is visible on the real web server. You can hide stuff from publishing by adding draft: true to the header information. The server.sh script will still show such things on your local machine.

    Sprint ahoy

    Friday 2nd of August 2019 03:28:38 PM

    Well, I did manage to get some work done during the start of the week cause after that it was just dripping nose and back to back headaches along with a sore throat for around the next 3 days, and I also had to prepare for Krita sprints happening next week.

    Krita 4.2.5 Released

    Friday 2nd of August 2019 11:43:32 AM

    We found that Krita 4.2.4 still had a bug handling shortcuts when certain tools were active. We’ve worked hard to fix that bug as quickly as possible, and as a consequence, we’re releasing Krita 4.2.5 today. Everyone is urged to update to this new release.

    Bugs Fixed
    • Fix an assert in the transform tool when working with a tablet and touch
    • Fix continued transformation in the transform tool
    • Fix updates in the transform tool
    • Show the publication time in the welcome page news ticker in the user’s preferred short date/time format
    • Fix using the tangent-normal brush when the canvas is rotated or mirrored (BUG:404408)
    • Make it possible again to create new palettes and save them in the resource folder, instead of the current document (BUG:410137)
    • Make Krita not gobble up all available memory when loading a JPG file with specific metadata (BUG:410242)
    • Constrain assistant editors to the viewport, so they can always be manipulated
    • Make sure Krita stores changes to brush presets in the current session by default (BUG:410463)
    • Remove an assert that could be triggered when opening the first image in a session
    • Update the version of the default input settings profile, so the rotate/zoom action will be activated even if the user already had a local kritadefault.profile file
    • Fix a crash on using the move tool while the image is being opened (BUG:398968)
    • Make sure the painting tools don’t block anymore (BUG:409968,408826,409275)
    • Make the shortcut handling system more tolerant when shortcuts overlap (BUG:409968)
    • Fix a crash in the transform tool
    • Make the transform tool and the move tool more responsive
    Download Windows

    Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.

    Linux

    (If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)

    OSX

    Note: the gmic-qt is not available on OSX.

    Source code md5sum

    For all downloads:

    Key

    The Linux appimage and the source .tar.gz tarball are signed. You can retrieve the public key over https here: 0x58b9596c722ea3bd.asc. The signatures are here (filenames ending in .sig).

    Support Krita

    Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.

    Qt Creator 4.10 RC released

    Friday 2nd of August 2019 09:12:14 AM

    We are happy to announce the release of Qt Creator 4.10 RC !

    The prebuilt binaries for this release are based on a Qt 5.13.1 snapshot, which should take care of regular crashes that some of you experienced with the earlier Beta releases.
    For more details on the 4.10 release, please have a look at the blog post for Beta1 and our change log.

    Get Qt Creator 4.10 RC

    The opensource version is available on the Qt download page under “Pre-releases”, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.10 RC is also available under Preview > Qt Creator 4.10.0-rc1 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.10 RC released appeared first on Qt Blog.

    The Inside View: How Krita is Developed

    Friday 2nd of August 2019 08:20:47 AM

    In this post, I want to share with you how we’re developing Krita. Of course, the post’s title is already nonsense, since there’s no “inside” and “outside” when it comes to Krita. Krita is a free software project, and as open as it can be. If you use Krita, report issues, help people who are using Krita, show off your work, well, you’re already part of this community that makes life better for everyone who uses Krita.

    That said, you might’ve been using Krita for years, and still being a bit vague on who develops this application, how that’s organized, why people are spending time on it and what resources we have for developing Krita.

    Who are the developers

    Until 2005, all Krita development was done by volunteers, in their spare time. That year, Google started the Google Summer of Code program. Then we had students working full-time on Krita for three months; mentored by the existing volunteer team.

    For me, Krita maintainer since 2003, there was nothing more satisfying than working on Krita. In contrast with my day jobs, we actually started releasing in 2004!

    But it was clear that there was only so much that could be done by a purely volunteer, unsponsored team. Time is money, money buys development time, so since 2009, we’ve tried to sponsor development beyond Google Summer of Code. Some argued that this would kill the volunteer element in the community, but we’ve never seen a trace of that.

    So, these days, there are four people working full-time on Krita. There is Dmitry, since 2012, sponsored by the Krita Foundation through donations and fund raisers.

    Me, Boudewijn, has been funded working on Krita through a combination of donations, special projects for third-party organizations and, since 2017, the income from the Windows Store. I don’t do just coding, but pretty much all project management.

    Agata and Ivan started working full-time on Krita this year, and are funded through the income from the Steam Store. Agata is well-known as Tiar and has been supporting other Krita users for ages. Ivan has been around in the Krita community for more than ten years, first producing things like shortcut cheat sheets, and completing a Google Summer of Code project successfully in 2018.

    This year, there are four Google Summer of Code students working on Krita: Sharaf, Tusooa, Kuntal and Alberto.

    Any given week, there are a dozen people committing to Krita, so only a small part of the development community is funded. There are volunteers from many places in the world, some developing just one feature they need and asking for it to be included in Krita, others providing smaller and bigger features, bug fixes and UX improvements.

    The group of volunteers is more or less fleeting: people often come and go, but there are people who have been around for a long time. Wolthera manages our manual, with help from Raghukamath. Scott maintains the website and helps out with UX design and GUI polish. Anna codes complicated stuff, like the gamut mask feature or more recently, the hardening of the saving code.   Ahabgraybeard helps other users on the forum, Timothee designs icons, Maria makes release videos, Irina handles the bi-weekly artist interviews.

    Of course, this is who were are… Developers, manual writers, artists. It’s also important to realize what there isn’t: there isn’t a quality assurance team, so we’re counting on our users to test the nightlies and the beta releases to find issues. There isn’t a user support team, so we’re again counting  on our users to help each other out. We don’t have customer support or a marketing department. There isn’t an office, and there isn’t a legal department.

    How’s development organized

    Our main communication channel is irc, internet relay chat. Yes, it’s old-fashioned compared to something like Matrix, but it works in a timely and dependable way.

    We have a weekly meeting at 14:00 CE(S)T every Monday. The meeting doesn’t take more than an hour, and we’ll discuss various topics and make a report. The reports are archived on files.kde.org.

    New code can be put up for review on KDE’s gitlab instance, invent. Everyone with a KDE identity account can fork Krita on gitlab and create pull requests.

    Right now, all full-time developers are working on fixing bugs for Krita 4.3, but volunteers can choose what they work on to a very large extent. The only limitation is that it must fit within Krita’s vision.

    And next week we’ll have our 2019 Krita Sprint. We try to get together at least once a year. Not just the Krita contributors, but we also invite artists to our sprints. The only way to learn how people use our application is by watching them work! Sprints are intense, but also lots of fun.

    What are Krita’s resources

    Financially, we’ve got several sources of income and support. The donation page you see after downloading Krita brings in about 2000 to 2700 euros a month; the median donation is 10 euros. This goes to the Krita Foundation. The yearly fundraiser brings in between 20,000 and 40,000 euros, and this also goes to the Krita Foundation. The income from the special projects, like the HDR project, is variable, but that, like the income from the Windows Store and the Steam Store, goes to a separate company for tax reasons. All of this is around 6,000 to 10,000 euros a month, and growing.

    As you can see, nobody who is working full-time on Krita is getting filthy rich, but it does make it possible for the four full-time developers to work on a project that’s really worth it

    Our non-financial resources are provided by the wider KDE community:

    • continuous integration system (Jenkins)
    • the binary factory that creates nightly builds for Windows, Linux and macOS and releases for Windows and Linux
    • these websites krita.org and our documentation site docs.krita.org
    • mailing list (which doesn’t see so much usage anymore, but if you go back to 2003, you’ll find many interesting discussions)
    • the forum
    • bug tracker

    And of course a broad community full of people who are experts on C++, CMake, Qt and community management. And a big translator community.

    Future development

    While the developers and volunteers communicate mostly online, we occasionally get together in person with sprints. We discuss Krita of course, but we also socialize and just have a fun time! Next week we are meeting in the Netherlands for one of these sprints. We are going to be discussing many topics such as the future of Krita as well as taking a side trip to a local museum. Many of our developers are artists as well, so there is sure to be a lot of sketch pads and painting flying around.

    if this sounds something you might want to be a part of, we are always welcoming new contributors. There are a lot of different areas that we have people volunteering and developing, not just hardcore programmers. We have a getting involved section that outlines some of the areas such as testing and creating brush resources. We also have a lot of documentation on building krita and being involved with our updated contributor’s manual.

    June/July in KDE Itinerary

    Thursday 1st of August 2019 05:00:00 PM

    Another two busy months have passed since the last bi-monthly summary on KDE Itinerary’s progress. Here are the highlights.

    New Features
    • The alternative journey selection for unbound or delayed train reservations finally works for the whole journey rather than just one the selected journey segment, and is now also able to properly save a new journey with more or less segments than the previously selected one. It is now also possible to search for earlier or later journeys if the corresponding backends support that.

    • In order to know when you have to look for an alternative journey, about to be missed connections are now highlighted in the timeline, based on available real-time data.

    Real-time delay information with highlighting about to missed connections.
    • The navigation options offered per location also got a bit smarter. The “navigate to” action now uses the assumed location from the itinerary as a starting point for future elements, rather than the current location. This means that you can look at how to get to your hotel from the train station, rather than getting a route from your home to the hotel directly, for example. (On Android, this is only available with OsmAnd, not with the system map.)

    • At arrival locations, the navigation actions now also offer a real-time departure schedule for local public transport. This allows you to check how much you need to hurry to catch the next bus or train home from the airport for example, as a stop-gap measure until the app is smart enough to know where “home” is and offer the appropriate journey directly.

    • Back fields of Apple Wallet passes are now also viewable in the app, not just in KMail.

    Infrastructure Work

    There’s quite a few interesting changes in the data extractor engine and its tooling too:

    • One of the biggest changes is the newly added support for vector barcodes in PDF files, see the post on this subject for details.

    • The airport disambiguation got improved for cases of very short distances and for ambiguities on both ends of the journey. The recent Plasma sprint in València provided the following example: A flight from “Frankfurt” to “Valencia” ends up with FRA and HHN as candidates for the departure airport, and VLC and PPN for arrival. Based on the duration of the flight we can exclude PPN, as it wouldn’t be a viable option for either departure location candidate. We also know that FRA and HHN are in the same timezone, so that we can ultimately determine the timezones for the entire flight.

    • The UIC 918.3 train ticket parser now supports ticket layouts other than the European standard ones (RCT2). That’s a somewhat ASCII-art like representations of tickets that can be present in the large UIC 918.3 Aztec barcodes. The local transport operator in Nürnberg is using such barcodes for example, as encountered during the recent multi-sprint there. To support this, KItinerary Workbench is now also able to visualize UIC 918.3 ticket layouts.

    KItinerary Workbench showing the RCT2 ticket layout found inside a UIC 918.3 barcode on an ÖBB ticket.
    • Custom extractor scripts got new convenience API to reduce the amount of boilerplate code needed to create new reservation objects, as well as access to more properties of iCalendar input objects.

    • KItinerary Workbench now has a XPath evaluator with result highlighting in its DOM view, to help debugging XPath queries in custom extractor scripts. HTML to plain text conversion in the extractor now correctly skips stylesheet elements.

    KItinerary Workbench highlighting the nodes selected by a given XPath query in the DOM tree.

    KPublicTransport, the frameworks providing access to real-time public transport data received several improvements as well:

    • There is now support for handling license and attribution information. While probably one of the more boring features, it’s crucial to be compliant with the Open Data licenses of the source data, and access to that source data is ultimately what enables all the exciting things we build on top. The app will show these information now in the about page, and under the journey and departure views.
    KDE Itinerary showing a list of data sources used for the public transport information.
    • There is ongoing work to make query results accessible incrementally, even if not all backends have responded yet. Initial results are available quicker with this, but it can lead to results changing or reordering as more information come in. The new real-time departure view in the app is already using this.

    • KPublicTransport can now carry address information in its Location data type. Those are not provided by all backends, and hardly ever complete, but it allows the app to augment its knowledge about a station if address information are available.

    • Backends can now have two different location identifier types, typically one backend-specific one and one standardized one (e.g. UIC station codes or IBNRs). This addresses the fact that not every stop or station has one of the standardized identifiers, but we still want to get the standardized identifiers whenever present (as those allow augmentation with Wikidata information, and robust location comparison).

    Fixes & Improvements

    There are also plenty of smaller changes that are noteworthy:

    • Trip grouping in the app now also considers layover time as an additional criteria. A very short time between two elements likely indicates they belong to the same trip.
    • Importing data from Nextcloud/DavDroid works again with recent DavDroid versions. DavDroid changed the way they store custom iCal properties, which we rely on. The new way however is much easier to handle for us, eventually avoiding the dependency on the iCal4j library even.
    • The alternative journey view now shows the number of changes correctly.
    • Day changes on overnight flights are now automatically fixed in post-processing in many cases, as this turns out to be often wrong in the input data.
    • Calendar events generated from restaurant reservations no longer contain empty fields for optional information.
    • New or improved extractors for simplebooking.it, booking.com, easyJet, Travelport Galileo and VGN, based on booking information from the Plasma and KDE Connect sprints, and for Akademy.
    Contribute

    As usual a big thanks to everyone who donated test data, the samples from participants of the Plasma sprint in València resulted in the most extractor engine improvements this time I think :)

    If you want to help in other ways than donating test samples too, see our Phabricator workboard for what’s on the todo list, for coordinating work and for collecting ideas. For questions and suggestions, please feel free to join us on the KDE PIM mailing list or in the #kontact channel on Freenode.

    KDE Connect SMS: Nuremberg Megasprint Part 3

    Thursday 1st of August 2019 03:17:32 PM

    When interacting with other users of KDE Connect, I often notice something funny. People will often talk about how nice it is that they can control their computer from their phone (using the media controls, the mousepad plugin, or several of the others). For me, this has always been a secondary benefit. I use KDE Connect’s presentation plugin for all of my presentations but my primary goal has always been to be able to control my phone from my computer. I hate the phone keyboard, I hate the tiny screen, and I hate having to pull the thing out of my pocket.

    On a daily basis, the number 1 thing I need to do with my phone is send or read SMS. In the United States, SMS is the de facto default communication system. In Europe, I basically assume that anyone I want to communicate with uses WhatsApp. In the US, with one friend I use WhatsApp, with another one friend I use Telegram, and with my family and other friends I use SMS. (Many people use Facebook Messenger but that is still not as widespread).

    Those who have been very carefully following the KDE Connect channels might already know that we have been working on a desktop application which uses KDE Connect to load SMS conversation history and send SMS using the phone. (I have been keeping this under wraps because I know it is our #1 requested feature and I don’t want to tease anyone with a stream of “Oh yes, it’s almost there” half-promises)

    The SMS app started March 2018 at the previous KDE Connect sprint. I arrived in Barcelona with a half-written contacts synchronization plugin and the goal to never touch my phone again. In only a few days, we had the contacts plugin in its current form and the skeleton of an SMS app (based on Qt’s QML chat app tutorial). It could read the display names and avatars from the synchronized contacts and you could use the compose message box to send SMS. There was no message history yet, just some statically-created items in the QML, but everything starts somewhere!

    KDE Connect SMS v0.0

    Around May, Aleix Pol and I were talking about what the interface should look like. We agreed that it should be very “normal”, like every other chat app, so I came up with this fabulous drawing.

    Special thanks to PhotoScan for only being able to export photos with a watermark

    The history of the SMS app has more details than we need for this post. Along the way, the KDE Connect Android app was updated with many content resolvers (and many StackOverflow references) to handle getting the SMS (and MMS) history. Several GUI elements have been “borrowed” from Kaidan. High on my soon-to-do list is move the Kaidan GUI elements which could be used by any other project looking to make a chat interface.

    I am very happy with the current version of the app. I use it regularly and I find it very useful. Though it only has a few features, I have focused on fewer, more-stable features for the initial release. It can:

    • Show a list of conversation currently existing on the phone
    • Show conversation history
    • Send and display SMS
    • Display (not send) plain-text MMS including group messages
    • Understand non-text MMS
    • Update in real-time as more messages are received

    I have left several thing for future releases:

    • Start a new conversation
      • I consider this a less-common usecase than replying to an existing conversation, so I focused on other things
    • Show MMS attachments
      • This requires upgrading the Android interface to read arbritrary attachments and upgrading the GUI to do something with those (like display pictures and offer downloads for everything else)
    • Send MMS
      • The current SMS-sending interface is very basic, so it will probably be significantly modified or even replaced.

    Here is the current version of the SMS app:

    And the corresponding conversation on the phone:

    The SMS app now builds by default when you build KDE Connect so it will be officially released with the next release of KDE Connect. Hopefully I have time to iron out one or two more bugs before then!

    Check out Krita’s Youtube Channel

    Thursday 1st of August 2019 01:55:13 PM

    Even though there is a ton of Krita videos on Youtube, Krita’s own youtube channel was neglected. Until recently! Working together with Ramon Miranda of Muses and Digital Atelier fame, we’re going to publish new videos about Krita regularly. Here’s the first one!

    foss-north call for papers

    Thursday 1st of August 2019 10:13:16 AM

    The summer is flying by and it is already August. The call for papers for foss-north IoT and Security Day is still open for a few more days, so make sure to get your talk in. We are looking for talks touching on connected embedded devices and how to do them securely.

    The foss-north IoT and Security Day will be a one day event, October 21st, in central Stockholm. The venue, WTC, is located right by the central train station, so it is very easy to get there. Tickets will be made available soon. Make sure to save the date!

    Agile On The Beach: my first time

    Wednesday 31st of July 2019 06:41:29 PM

    During 2017 and 2018 I got several interesting references at events like Scale Summit and pipelineconf about an interesting event in the south-west of England about lean, agile and continuous delivery that got my attention. I decided that I could not miss it in 2019.

    2019 edition of Agile On The Beach was the 9th one. The event has gain a good reputation among agilists for being a good mix of great content and relaxed atmosphere in a beautiful environment. This is not surprising for somebody coming from the Open Source space but is not a so common combination within the lean/agile/CD world.

    I bought the tickets and reserved the accommodation on time (months before the event). As you know, I started in MBition in June. My employer was kind enough to make it easy for me to attend. So on July 10th I headed to Falmouth, Cornwall, UK to participate in Agile On The Beach during the following two days, coming back to Málaga on Saturday July 13th.

    I liked the event. I felt like home. Like if I was at Akademy, for instance. There were some outstanding talks, a great atmosphere, talented and experienced attendees, reputed speakers, good organization and nice social activities.  Yes, the trip to get there was long but I had no delays in any of the several planes and trains I had to take (who said British trains are awful?) which allowed me to invest a few hours working on each way.

    The videos has not been published yet. I will add as comments those I recommend you to check.

    Next year the event celebrates the 10th edition. They promised to do something special. If you are in the UK or are willing to invest several hours traveling to a good Lean/Agile/CD event, Agile On The Beach is a great one. But stay tuned, the number of tickets is limited and they are gone several months before the event starts.

    Krita 4.2.4 Released

    Wednesday 31st of July 2019 09:42:15 AM

    We’re releasing Krita 4.2.4 today. The most important fixes are to the shortcut input system and the saving system. Krita 4.2.3 had a bug where a message window would often pop up complaining about a shortcut not being finished properly; this should no longer happen. Anna Medonosova has hardened the saving system even more, especially when closing Krita after initiating a save operation.

    There are some more bug fixes coming soon, and we will release 4.2.5 with those fixes in about two weeks, after the coming Krita sprint.

    Additionally, we implemented a new blending mode inspired by Easy Painttool SAI’s Luminosity/Shine, please help us to test its behavior (BUG:409627).

    Known Issue

    If touch zoom and rotation doesn’t work anymore, please remove your local default.inputrc file. Go to Settings/Manage Resources and press the Open Resource Folder button. Enter the input folder and remove all files in that folder.

    Bugs Fixed
    • Make it possible to use dots in filenames (note that that still might confuse your OS) (BUG:409765)
    • Fix regression on softness sensor on Default Circle autobrush tip (BUG:409758)
    • Clear any leftover points in the line tool on each use so there are no false starts (BUG:408439)
    • Do not reset the opacity to zero when moving more than one shape at a time (BUG:409131)
    • Do not ignore rotation in the bristle brush engine (BUG:384231)
    • Fix cursor drift when using pan/zoom/rotate (BUG:409460)
    • Fix a crash when creating an RGB image after the last used color model was CMYK (BUG:409916)
    • Use Qt’s QImageIO image import/export filter for PPM files instead of our own, broken implementation. (BUG:409714)
    • Fix updating the brush size in the toolbar using shortcuts or drag (BUG:408331)
    • Make generated gradient names translatable (BUG:410034)
    • Fix a crash that could happen when closing Krita after deleting a session (BUG:409909)
    • Fix a bug in the color picker that made it possible for the active foreground color to be transparent
    • Fix a logic error in the Separate Image plugin (BUG:410308)
    • Update the notes for the LargeRGB color profile (BUG:410023)
    • Fix the filename reference for Rec.709 profiles
    • Add a workaround for the KisShortcutsMatcher assert (BUG:408826)
    Download Windows

    Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.

    Linux

    (If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)

    OSX

    Note: the gmic-qt is not available on OSX.

    Source code md5sum

    For all downloads:

    Key

    The Linux appimage and the source .tar.gz tarball are signed. You can retrieve the public key over https here: 0x58b9596c722ea3bd.asc. The signatures are here (filenames ending in .sig).

    Support Krita

    Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.

    Markdown and support of embedded mathematics

    Tuesday 30th of July 2019 09:32:27 PM
    Hello everyone!

    In the previous post I mentioned that Cantor now handles embedded mathematical expressions inside of Markdown, like $...$ and $$...$$ in accordance with the Markdown syntax.

    In the past Cantor for a long time didn’t have any support for Markdown and only have simple text entry type for comment purposes. Markdown entry type was added only in 2018 by kqwyf. Internally, this was realized by using the Discount library, which converts markdown syntax to the to html code which is then passed to Qt for final the rendering (Qt supports limited set of the html syntax).

    Discount library actually supports integration with LaTeX: text inside LaTeX expressions like $$...$$, \(...\), \[...]\ is passed to the output html string without modifications (except html escaping).

    As you see Discount doesn't support embedded mathematics with single delimiter $...$ that is used in Jupyter very frequently. Of course, for my Jupiter integration projects ignoring this type of statements was not an option. I decided to report this issue in Discount bug tracker because all the other options solve this problem purely in Cantor had other problems.

    Fortunately, the author of Discount reacted very soon (thanks to him for that) and suggested code changes for supporting the single-delimited math. Unfortunately, the changes didn't get into master branch yet. To proceed further in Cantor I decided to copy required Discount’s code having all the relevant changed into Cantor’s repository as a third party library.

    Independent of the support for the single-delimiter mathematics, there is a big problem with the embedded mathematical expressions - you need to somehow find these mathematical statements in output html string. In the initial implementation I simply searched for $$ in the result string but this could lead to "search collisions".

    The dollar sign could be inside of a Markdown code block or inside of a quote block. Here, the dollar signs shouldn't treated as part of the embedded mathematics. After some further testing of couple of other implementations on Cantor sidethe conclusion was obvios - the identification and labeling of positions of embedded mathematics in the html string, produced by Discount, should be done directly inside Discount itself.

    At this moment, the version of Discount added to Cantor’s repository had two additional functional fixes on top of the officially released version of this library. First, Discount copies all LaTeX expressions during the processing of markdown syntax to a special string list, which is then used by Cantor to search for LaTeX code. Second, a useful change was to add an ASCII non-text symbol to every math expression. This symbol is used as a search key which greatly reduces the likelihood for a string collision, still theoretically possible, though.

    For example, if Discount will find (according Markdown syntax) math expression $\Gamma$, then it will write the additional symbol and the expression iin the output html string will be $<symbol>\Gamma$ and Cantor will search exactly this text.

    I think, that's all.  Maybe this doesn’t look like a complex problem but solving this problem was a task that took the most time and it took me two months to fix it. So, I think the problem and its solution deserved a separate blog post.

    At this moment, what I called "maximum plan" (I have mentioned this concep in this post) of the Jupyter support in Cantor is mostly finished. So, in the next post I plan to show how Cantor now handles test notebooks and what I’ll plan to do next.

    Migrating to a Static Site

    Monday 29th of July 2019 10:00:00 PM

    Hello static site...

    I've been writing really nothing on my previous blog, and the whole Wordpress install was too much overkill, besides doing a static website in python sounds way better to a programmer ;-)

    So, i'm using Pelican and plan to revert back all my customizations that make sense.

    And of course

    Strokes are Working Now

    Monday 29th of July 2019 03:02:36 AM

    Okay, good news today. I have been porting DefaultTool to the new node-replacing system and it is working now, finally, at least for the part I have already done.

    The work involves combining a number of different modules in Krita: the stroke system,KoInteractionTool and its interaction strategies, and, well, the COW mechanism in Flake.

    KoInteractionTool is the class used to manage the interaction with vector shapes, and is subclassed by DefaultTool. The behaviours of KoInteractionTool (and thus DefaultTool) are defined by KoInteractionStrategys. Upon the press of the mouse button, DefaultTool creates an instance of some subclass of KoInteractionStrategy, say, ShapeMoveStrategy, according to the point of the click as well as keyboard modifiers. Mouse move events after that are all handled by the interaction strategy. When the mouse is released, the interaction strategy’s finishInteraction() is called, and then createCommand(). If the latter returns some KUndo2Command, the command is added to the undo history. Till now it sounds simple.

    So how does the stroke system come in? I have experimented the interaction strategy without the stroke system (https://invent.kde.org/tusooaw/krita/commit/638bfcd84c622d3cfefda1e5132380439dd3fdc2), but it is really slow and even freezes Krita for a while sometimes. The stroke system allows the modification of the shapes to run in the image thread, instead of the GUI thread. A stroke is a set of jobs scheduled and run by a KisStrokesFacade (here, KisImage). One creates the stroke in a strokes facade using a stroke strategy, which defines the behaviour of the stroke. After creation, jobs can be added to the stroke and then executed at some later time (it is asynchronous).

    So combining these two, we have an interaction strategy and a stroke strategy – when the interaction strategy is created, we start the stroke in the image; when there is mouse move, we add individual jobs that change the shapes to the stroke; when the mouse released, we end the stroke. My discussion with Dmitry firstly tended to make the interaction strategy inherit the stroke strategy but later it proves not a viable solution since the interaction strategy is owned and deleted by KoInteractionTool while the stroke strategy is owned by the stroke — which will lead to double deletion. So we divide it into two classes instead: the interaction strategy starts the stroke, and the stroke strategy takes a copy of the current active layer upon creation; when handling mouse move events, a job is added to the stroke to modify the current layer; finally when the interaction finishes, the interaction strategy ends the stroke and creates an undo command if the layer has been changed.

    A problem I found lies in the final stage–if the mouse is released as soon as being pressed and no undo command is created, Krita will simply crash. It does not happen when I use gdb to start Krita so it seems to be a timing issue though it leads to difficulty for debugging as well. Dmitry used a self-modified version of Qt to produce a backtrace, indicating the problem probably lies in KisCanvas2‘s canvasUpdateCompressor, which is not thread-safe. However, after I changed it to KisThreadSafeSignalCompressor, the crash still happens, unfortunately.

    The final inspiration comes from the comments in KisThreadSafeSignalCompressor, though. It indicates we cannot delete the compressor from other threads — we have to use obj->deleteLater() instead, since it lies in the gui thread. And aha, that is the problem. The stroke strategy’s destructor is executed in the image thread; if the undo command is not created, there is only one reference to our copied KisNode, namely in our stroke strategy, so it has to be destructed there. However, upon the creation of the KisNode, it is moved into the gui thread. So it simply means we cannot let it be deleted in the image thread. The solution looks a little bit messy, but it works:

    1
    2
    3
    4
    5
    KisNode *node = m_d->originalState.data(); // take the address from KisSharedPtr
    node->ref(); // prevent KisSharedPtr from deleting the node
    m_d->originalState.clear(); // now node is not being referenced by any KisSharedPtr
    node->deref(); // the reference count is now zero again
    node->deleteLater(); // it will be deleted by the event loop, later

    My KDE Onboarding Sprint 2019 report

    Sunday 28th of July 2019 09:01:02 PM

    This week I took part on the KDE Onboarding Sprint 2019 (part of what's been known as Nuremberg Megasprint (i.e. KDEConnect+KWin+Onboarding) in, you guessed it, Nuremberg.

    The goal of the sprint was "how do we make it easier for people to start contributing". We mostly focused on the "start contributing *code*" side, though we briefly touched artists and translators too.

    This is *my* summary, a more official one will appear somewhere else, so don't get annoyed at me if the blog is a bit opinionated (though i'll try it not to)

    The main issues we've identified when trying to contribute to KDE software is:
    * Getting dependencies is [sometimes] hard
    * Actually running the software is [sometimes] hard

    Dependencies are hard

    Say you want to build dolphin from the git master branch. For that (at the time of writing) you need KDE Frameworks 5.57, this means that if you run the latest Ubuntu or the latest OpenSUSE you can't build it because they ship older versions.

    Our current answer for that is kdesrc-build but it's not the most easy to use script, and sometimes you may end up building QtWebEngine or QtWebKit, which as a newbie is something you most likely don't want to do.

    Running is hard

    Running the software you have just built (once you've passed the dependencies problem) is not trivial either.

    Most of our software can't be run uninstalled (KDE Frameworks are a notable exception here, but newbies rarely start developing KDE Frameworks).

    This means that you may try to run make install, which if you didn't pass -DCMAKE_INSTALL_PREFIX pointing somewhere in your home you'll probably have to run make install as root since it defaults to /usr/local (this will be fixed in next extra-cmake-modules release to point to a somewhat better prefix) that isn't that useful either since none of your software is looking for stuff in /usr/local. Newbies may be tempted to use -DCMAKE_INSTALL_PREFIX=/usr but that's *VERY* dangerous since it can easily mess up your own system.

    For applications, our typical answer is use -DCMAKE_INSTALL_PREFIX=/home/something/else at cmake stage, run make install and then set the environment variables to pick up things from /home/something/else, a newbie will say "which variables" at this stage probably (and not newbies too, I don't think i remember them all). To help with that we generate a prefix.sh in the build dir and after the next extra-cmake-release we will tell the users that they need to run it for things to work.

    But still that's quite convoluted and I know from experience answering people in IRC that lots of people get stuck there. It's also very IDE unfriendly since IDEs don't usually have the "install" concept, it's run & build for them.

    Solutions

    We ended up focusing on two possible solutions:

    * Conan: Conan "the C/C++ Package Manager for Developers" (or so they say) is something like pip in the python world but for C/C++. The idea is that by using Conan to get the dependencies we will solve most of the problems in that area. Whether it can help or not with the running side is still unclear, but some of our people involved in the Conan effort think they may either be able to come up with a solution or get the Conan devs to help us with it. Note Conan is not my speciality by far, so this may not be totally correct.

    * Flatpak: Flatpak is "a next-generation technology for building and distributing desktop applications on Linux" (or so they say). The benefits of using flatpak are multiple, but focusing on onboarding are. "Getting dependencies is solved", dependencies are either part of the flatpatk SDK and you have them or the flatpak manifest for the application says how to get and build them and that will automagically work for you as it works for everyone else using the same manifest. "Running is solved" because when you build a flatpak it gets built into a self contained artifact so running it is just running it, no installing or environment variable fiddling is needed. We also have [preliminary] support in KDevelop (or you can use Gnome Builder if you want a more flatpak-centric experience for now). The main problem we have with flatpak at this point is that most of our apps are not totally flatpak-ready (e.g. Okular can't print). But that's something we need to fix anyway so it shouldn't be counted as a problem (IMHO).

    Summary

    *Personally* i think Flatpak is the way to go here, but that means that collectively we need to say "Let's do it", it's something we all have to take into account and thus we have to streamline the manifest handling/updating, focus on fixing the Flatpak related issues that our software may have, etc.

    Thanks

    I would like to thank SUSE for hosting us in their offices and the KDE e.V. for sponsoring my attendance to the sprint, please donate to KDE if you think the work done at sprints is important.

    Latte Dock v0.9, "...a world to discover..."

    Sunday 28th of July 2019 08:39:02 PM


    Welcome Latte Dock v0.9.0!

    After a full year of development a new stable branch is finally available! This is a version full of innovations, improvements and enhancements that improve the entire experience at all areas. I have written plenty of articles for introduced major features and in the same manner this article will focus only on highlights.


    You can get  v0.9.0  from, download.kde.orgor  store.kde.org*
    -----* archive has been signed with gpg key: 325E 97C3 2E60 1F5D 4EAD CF3A 5599 9050 A2D9 110E
    - youtube presentation -

    New Colors painting

    Latte can now paint itself based on the current active window and when it is transparent can provide the best possible contrast for the underlying desktop background. You can read more at Latte and a Colors tale...
    - top panel colored from kwrite color scheme -


    Indicators

    New indicators are now provided and are also self-packaged. You can install them from Latte Effects page  and you can find them online at kde store. You can already find Unity and DaskToPanel styles. You can read more at Latte and an Indicators tale...
    - unity indicators style-
    - dashtopanel indicators style -


    Multiple Layouts Environment


    With Latte you can have different layouts used at different Plasma Activities and at the same you can now share layouts to other layouts in order to achieve Shared Docks/Panels. You can read more at Latte and a Shared Layouts dream... 
    - Top Panel layout shared to two other layouts -


    Flexible Settings

    All Dock/Panel settings have been redesigned in order to improve their meaning and at the same time give a way to the user to adjust their width/height scales according to their screen. You can read more at Latte and Flexible settings...



    Improved Badges

    Badge experience has been rethought and improved. New options have been added in order for the user to choose more prominent notification badges or use 3D style for them instead of the Material one used as default.
    - persistent notification badge and shortcut badges -
      

    Documentation and Reports

    At Latte Global preferences you can now find some diagnostic reports in order to debug your layouts. If you are a developer and you are interested in Latte development you can now find plenty of information at kde techbase. Read more at
    Latte, Documentation and Reports...



    Fixes/Improvements

    Plenty, plenty, plenty... v0.9 provides you much smoother and bug free experience compared to previous versions. Many areas have been redesigned and improved at areas.




    Latte Development team

    Because the community might have not been updated properly, Latte Development team is currently just me and this is the situation for the past two years. So for the upcoming development circle I will focus only on bug fixing and supporting the current massive features list. For new features I am not interested at all except if that feature enhances my own personal workflow. For any new features there should be an implementation to be discussed in order to be accepted and for any new features requests at bugs.kde.org I will leave them open for a month; if no developer is found then they will be closed afterwards.


    Requirements

    Minimum:
    • Qt >= 5.9
    • Plasma >=5.12
    Proposed:
    • Qt >= 5.12
    • Plasma >=5.15
     

    Donations

    You can find Latte at Liberapay if you want to support,    

    or you can split your donation between my active projects in kde store.

    More in Tux Machines

    Late Coverage of Confidential Computing Consortium

    • Microsoft Partners With Google, Intel, And Others To Form Data Protection Consortium

      The software maker joined Google Cloud, Intel, IBM, Alibaba, Arm, Baidu, Red Hat, Swisscom, and Tencent to establish the Confidential Computing Consortium, a group committed to providing better private data protection, promoting the use of confidential computing, and advancing open source standards among members of the technology community.

    • #OSSUMMIT: Confidential Computing Consortium Takes Shape to Enable Secure Collaboration

      At the Open Source Summit in San Diego, California on August 21, the Linux Foundation announced the formation of the Confidential Computing Consortium. Confidential computing is an approach using encrypted data that enables organizations to share and collaborate, while still maintaining privacy. Among the initial backers of the effort are Alibaba, Arm, Baidu, Google Cloud, IBM, Intel, Microsoft, Red Hat, Swisscom and Tencent. “The context of confidential computing is that we can actually use the data encrypted while programs are working on it,” John Gossman, distinguished engineer at Microsoft, said during a keynote presentation announcing the new effort. Initially there are three projects that are part of the Confidential Computing Consortium, with an expectation that more will be added over time. Microsoft has contributed its Open Enclave SDK, Red Hat is contributing the Enarx project for Trusted Execution Environments and Intel is contributing its Software Guard Extensions (SGX) software development kit. Lorie Wigle, general manager, platform security product management at Intel, explained that Intel has had a capability built into some of its processors called software guard which essentially provides a hardware-based capability for protecting an area of memory.

    Graphics: Mesa Radeon Vulkan Driver and SPIR-V Support For OpenGL 4.6

    • Mesa Radeon Vulkan Driver Sees ~30% Performance Boost For APUs

      Mesa's RADV Radeon Vulkan driver just saw a big performance optimization land to benefit APUs like Raven Ridge and Picasso, simply systems with no dedicated video memory. The change by Feral's Alex Smith puts the uncached GTT type at a higher index than the visible vRAM type for these configurations without dedicated vRAM, namely APUs.

    • Intel Iris Gallium3D Is Close With SPIR-V Support For OpenGL 4.6

      This week saw OpenGL 4.6 support finally merged for Intel's i965 Mesa driver and will be part of the upcoming Mesa 19.2 release. Not landed yet but coming soon is the newer Intel "Iris" Gallium3D driver also seeing OpenGL 4.6 support. Iris Gallium3D has been at OpenGL 4.5 support and is quite near as well with its OpenGL 4.6 support thanks to the shared NIR support and more with the rest of the Intel open-source graphics stack. Though it's looking less likely that OpenGL 4.6 support would be back-ported to Mesa 19.2 for Iris, but we'll see.

    The GPD MicroPC in 3 Minutes [Video Review]

    In it I tackle the GPD MicroPC with Ubuntu MATE 19.10. I touch on the same points made in my full text review, but with the added bonus of moving images to illustrate my points, rather than words. Read more Also: WiringPi - Deprecated

    today's howtos