Articoli

Pubblicato il

symlinks on fat32 devices

You can use posixovl:

  • install posixovl (i.g. via synaptic);
  • rename /sbin/mount-posixovl -> mount-posixovl.orig;
  • create a new mount-posixovl in sbin:

#!/bin/bash
# wrapper for mount.posixovl to conform with common mount syntax
# with this wrapper posixovl can be used in fstab

# location of the original mount.posixovl
origposixovl="/sbin/mount.posixovl.orig"

# gather inputs
while [ $# -gt 0 ]; do
        if [[ "$1" == -* ]]; then
                # var is an input switch
                # we can only use the -o or -F switches
                if [[ "$1" == *F* ]]; then
                        optsF="-F"
                else
                        optsF=""
                fi
                if [[ "$1" == *o* ]]; then
                        shift
                        optsfuse="-- -o $1"
                else
                        optsfuse=""
                fi
                shift
        else
                # var is a main argument
                sourcedir="$1"
                shift
                if [[ "$1" != -* ]]; then
                        targetdir="$1"
                        shift
                else
                        targetdir="$sourcedir"
                fi
        fi
done

# verify inputs
if [ "$sourcedir" == "" ]; then
        echo "no source specified"
        exit 1
fi
if [ "$targetdir" == "" ]; then
        echo "no target specified"
        exit 1
fi

# build mount.posixovl command
"$origposixovl" $optsF -S "$sourcedir" "$targetdir" $optsfuse

  • add to /etc/fstab something like this (depending on the name of your device):

LABEL=Basic402 /media/duns/basic2 vfat user,rw,noauto,uid=1000,gid=1000,iocharset=iso8859-1,shortname=mixed,showexec,utf8 1 2
/media/duns/basic2 /mnt/e-reader posixovl noauto 0 0

  • create a script, like this: 

#!/bin/bash
wmctrl -c mount.posixovl.orig
mount /media/duns/basic2
mount.posixovl -F /media/duns/basic2 /mnt/e-reader
krusader --left /mnt/e-reader/ebooks --right /mnt/zippati/eBooks

done!

Pubblicato il

customize grub in KDE Neon

0) Avoid Grub customizer: absolutely useless.

1) You can modify /etc/default/grub uncommenting GRUB_THEME=”/boot/grub/themes/breeze/theme.txt”

2) Then you can modify /boot/grub/themes/breeze/theme.txt: for example you can

  • add a background: adding, in # General settings, a line such as “desktop-image: “your-image-in-the-same-folder.png” (obviously you have to put, as root, that image into the folder);
  • reducing the height for menu items, in “+ boot_menu”: “item_height = 15” (not: 33)

3) do “sudo update-grub”

fine tuning

a) you can change the screen resolution (in /etc/default/grub);

  • give this command “xrandr” in order to know the supported resolutions 
  • then uncomment/modify GRUB_GFXMODE=”your desired resolution”

b) you can create your own pf2 font file, with grub-mkfont:
for example “sudo grub-mkfont –output=/boot/grub/fonts/DejaVuSans-10.pf2  –size=10 /usr/share/fonts/truetype/dejavu/DejaVuSans.ttf”

c) per installare nell’mbr
sudo grub-install /dev/sda

Pubblicato il

thermal monitor plasmoid not working

As explained here, if you have a bug in the thermal monitor plasmoid, to fix it you can change main.qml in .local/share/plasma/plasmoids as following (updated 22 feb 2020, adding “: []” after “property var systemmonitorAvailableSources”):

/*
 * Copyright 2015  Martin Kotelnik
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
import QtQuick 2.2
import QtQuick.Layouts 1.1
import QtGraphicalEffects 1.0
import org.kde.plasma.plasmoid 2.0
import org.kde.plasma.core 2.0 as PlasmaCore
import “../code/model-utils.js” as ModelUtils
import “../code/config-utils.js” as ConfigUtils

Item {
    id: main

    anchors.fill: parent

    property bool vertical: (plasmoid.formFactor == PlasmaCore.Types.Vertical)
    property bool planar: (plasmoid.formFactor == PlasmaCore.Types.Planar)

    property bool initialized: false

    // configuration
    property int temperatureUnit: plasmoid.configuration.temperatureUnit
    property string configuredResources: plasmoid.configuration.resources
    property int baseWarningTemperature: plasmoid.configuration.warningTemperature
    property int baseMeltdownTemperature: plasmoid.configuration.meltdownTemperature
    property int updateInterval: 1000 * plasmoid.configuration.updateInterval

    property int itemMargin: 5
    property double itemWidth:  0
    property double itemHeight: 0

    property color warningColor: Qt.tint(theme.textColor, ‘#60FF0000’)
    property var textFontFamily: theme.defaultFont.family

    Plasmoid.preferredRepresentation: Plasmoid.fullRepresentation

    property double aliasFontSize: itemHeight * plasmoid.configuration.aliasFontSize * 0.01
    property double temperatureFontSize: itemHeight * plasmoid.configuration.temperatureFontSize * 0.01
    property double iconFontSize: itemHeight * plasmoid.configuration.iconFontSize * 0.01
    property double temperatureRightMargin: itemHeight * plasmoid.configuration.temperatureRightMargin * 0.01
    property double iconBottomMargin: itemHeight * plasmoid.configuration.iconBottomMargin * 0.01
    property bool enableLabelDropShadow: plasmoid.configuration.enableLabelDropShadow

    property var systemmonitorAvailableSources : []
    property var systemmonitorSourcesToAdd

    property int numberOfParts: temperatureModel.count

    property double parentWidth: parent !== null ? parent.width : 0
    property double parentHeight: parent !== null ? parent.height : 0

    property double widgetWidth: 0
    property double widgetHeight: 0

    Layout.preferredWidth: widgetWidth
    Layout.preferredHeight: widgetHeight

    property bool debugLogging: false

    function dbgprint(msg) {
        if (!debugLogging) {
            return
        }
        print(‘[thermalMonitor] ‘ + msg)
    }

    onParentWidthChanged: setWidgetSize()
    onParentHeightChanged: setWidgetSize()
    onNumberOfPartsChanged: setWidgetSize()

    function setWidgetSize() {
        if (!parentHeight) {
            return
        }
        var orientationVertical = false
        if (planar) {
            var contentItemWidth = parentHeight
            var contentWidth = numberOfParts * contentItemWidth + (numberOfParts-1) * itemMargin
            var restrictToWidth = contentWidth / parentWidth > 1
            itemWidth = restrictToWidth ? (parentWidth + itemMargin) / numberOfParts – itemMargin : contentItemWidth
        } else if (vertical) {
            orientationVertical = true
            itemWidth = parentWidth
        } else {
            itemWidth = parentHeight
        }
        itemHeight = itemWidth
        widgetWidth = orientationVertical ? itemWidth : numberOfParts * itemWidth + (numberOfParts-1) * itemMargin
        widgetHeight = orientationVertical ? numberOfParts * itemHeight + (numberOfParts-1) * itemMargin : itemHeight
    }

    FontLoader {
        source: ‘../fonts/fontawesome-webfont-4.3.0.ttf’
    }

    Image {
        id: noResourceIcon;

        anchors.centerIn: parent

        visible: temperatureModel.count === 0

        height: itemHeight
        width: height

        source: ‘../images/thermal-monitor.svg’
    }

    ListView {
        id: listView

        anchors.centerIn: parent
        width: widgetWidth
        height: widgetHeight

        orientation: !planar && vertical ? ListView.Vertical : ListView.Horizontal
        spacing: itemMargin

        model: temperatureModel

        delegate: TemperatureItem {}
    }

    /*
     *
     * One object has these properties: temperature, alias and other
     *
     */
    ListModel {
        id: temperatureModel
    }

    Component.onCompleted: {
        plasmoid.setAction(‘reloadSources’, i18n(‘Reload Temperature Sources’), ‘system-reboot’);
        reloadAllSources()
        setWidgetSize()
    }

    onBaseWarningTemperatureChanged: {
        tryReloadSources()
    }

    onBaseMeltdownTemperatureChanged: {
        tryReloadSources()
    }

    onConfiguredResourcesChanged: {
        dbgprint(‘configured resources changed’)
        tryReloadSources()
    }

    function tryReloadSources() {
        if (!initialized) {
            dbgprint(‘applet not initialized -> no reloading sources’)
            return
        }
        reloadAllSources()
    }

    function getSystemmonitorAvailableSources() {
        if (!systemmonitorAvailableSources) {
            systemmonitorAvailableSources = systemmonitorDS.sources
        }
        return systemmonitorAvailableSources
    }

    function action_reloadSources() {
        reloadAllSources()
    }

    function reloadAllSources() {

        dbgprint(‘reloading all sources…’)

        var resources = ConfigUtils.getResourcesObjectArray()

        temperatureModel.clear()

        if (!systemmonitorSourcesToAdd) {
            systemmonitorSourcesToAdd = []
        }

        if (systemmonitorDS.connectedSources === undefined) {
            systemmonitorDS.connectedSources = []
        }

        if (udisksDS.connectedSources === undefined) {
            udisksDS.connectedSources = []
        }

        if (nvidiaDS.connectedSources === undefined) {
            nvidiaDS.connectedSources = []
        }

        if (atiDS.connectedSources === undefined) {
            atiDS.connectedSources = []
        }

        systemmonitorSourcesToAdd.length = 0
        systemmonitorDS.connectedSources.length = 0
        udisksDS.connectedSources.length = 0
        udisksDS.cmdSourceBySourceName = {}
        nvidiaDS.connectedSources.length = 0
        atiDS.connectedSources.length = 0

        ModelUtils.initModels(resources, temperatureModel)

        for (var i = 0; i < temperatureModel.count; i++) {
            var tempObj = temperatureModel.get(i)
            var source = tempObj.sourceName

            if (source === ‘group-of-sources’) {

                dbgprint(‘adding group: ‘ + tempObj.alias)

                for (var childSource in tempObj.childSourceObjects) {

                    dbgprint(‘adding source (for group): ‘ + childSource)

                    addSourceToDs(childSource)

                }

            } else {

                addSourceToDs(source)

            }
        }

        ModelUtils.rebuildModelIndexByKey(temperatureModel)

        initialized = true

        dbgprint(‘reloadAllSources() DONE’)
    }

    function addSourceToDs(source) {

        if (source.indexOf(‘udisks/’) === 0) {

            var diskLabel = source.substring(‘udisks/’.length)
            var cmdSource = ModelUtils.getUdisksTemperatureCmd(diskLabel)
            udisksDS.cmdSourceBySourceName[cmdSource] = source

            dbgprint(‘adding source to udisksDS: ‘ + cmdSource)

            addToSourcesOfDatasource(udisksDS, cmdSource)

        } else if (source.indexOf(‘nvidia-‘) === 0 && nvidiaDS.connectedSources.length === 0) {

            dbgprint(‘adding source to nvidiaDS’)

            addToSourcesOfDatasource(nvidiaDS, nvidiaDS.nvidiaSource)

        } else if (source.indexOf(‘aticonfig’) === 0 && atiDS.connectedSources.length === 0) {

            dbgprint(‘adding source to atiDS’)

            addToSourcesOfDatasource(atiDS, atiDS.atiSource)

        } else {

            dbgprint(‘adding source to systemmonitorDS: ‘ + source)

            if (getSystemmonitorAvailableSources().indexOf(source) > -1) {
                dbgprint(‘adding to connected’)
                addToSourcesOfDatasource(systemmonitorDS, source)
            } else {
                dbgprint(‘adding to sta’)
                systemmonitorSourcesToAdd.push(source)
            }

        }

    }

    function addToSourcesOfDatasource(datasource, sourceName) {
        if (datasource.connectedSources.indexOf(sourceName) > -1) {
            // already added
            dbgprint(‘source already added: ‘ + sourceName)
            return
        }
        datasource.connectedSources.push(sourceName)
    }

    PlasmaCore.DataSource {
        id: systemmonitorDS
        engine: ‘systemmonitor’

        property string lmSensorsStart: ‘lmsensors/’
        property string acpiStart: ‘acpi/Thermal_Zone/’

        onSourceAdded: {

            if (source.indexOf(lmSensorsStart) === 0 || source.indexOf(acpiStart) === 0) {

                systemmonitorAvailableSources.push(source)
                var staIndex = systemmonitorSourcesToAdd.indexOf(source)
                if (staIndex > -1) {
                    addToSourcesOfDatasource(systemmonitorDS, source)
                    systemmonitorSourcesToAdd.splice(staIndex, 1)
                }

            }

        }

        onNewData: {
            var temperature = 0
            if (data.value === undefined) {
                dbgprint(‘data for source ‘ + sourceName + ‘ not yet available’)
            } else {
                temperature = parseFloat(data.value)
            }
            ModelUtils.updateTemperatureModel(temperatureModel, sourceName, temperature)
        }
        interval: updateInterval
    }

    PlasmaCore.DataSource {
        id: udisksDS
        engine: ‘executable’

        property var cmdSourceBySourceName

        onNewData: {

            dbgprint(‘udisks new data – valid: ‘ + valid + ‘, stdout: ‘ + data.stdout)

            var temperature = 0
            if (data[‘exit code’] > 0) {
                dbgprint(‘new data error: ‘ + data.stderr)
            } else {
                temperature = ModelUtils.getCelsiaFromUdisksStdout(data.stdout)
            }

            ModelUtils.updateTemperatureModel(temperatureModel, cmdSourceBySourceName[sourceName], temperature)
        }
        interval: updateInterval
    }

    PlasmaCore.DataSource {
        id: nvidiaDS
        engine: ‘executable’

        property string nvidiaSource: ‘nvidia-smi –query-gpu=temperature.gpu –format=csv,noheader’

        onNewData: {
            var temperature = 0
            if (data[‘exit code’] > 0) {
                dbgprint(‘new data error: ‘ + data.stderr)
            } else {
                temperature = parseFloat(data.stdout)
            }

            ModelUtils.updateTemperatureModel(temperatureModel, ‘nvidia-smi’, temperature)
        }
        interval: updateInterval
    }

    PlasmaCore.DataSource {
        id: atiDS
        engine: ‘executable’

        property string atiSource: ‘aticonfig –od-gettemperature | tail -1 | cut -c 43-44’

        onNewData: {
            var temperature = 0
            if (data[‘exit code’] > 0) {
                dbgprint(‘new data error: ‘ + data.stderr)
            } else {
                temperature = parseFloat(data.stdout)
            }

            ModelUtils.updateTemperatureModel(temperatureModel, ‘aticonfig’, temperature)
        }
        interval: updateInterval
    }

    Timer {
        interval: updateInterval
        repeat: true
        running: true
        onTriggered: {
            ModelUtils.computeVirtuals(temperatureModel)
        }
    }

}

Pubblicato il

link, rather than embed images in odb file

Today I followed this way: link rather than embed the images, so that the odb file can remain of small size.
1. in edit view add a text box in your form and
2. convert it (replace with) to a image control
3. in normal view double click on the new box and select the image, which will not embedded, but linked.

with mysql

If you use a mysql database you can set the field as varchar (at least 150 char) and insert the location, such as http://localhost/your-path/yourfile.jpg.
Then you can add this field as data in the text box (as above).
Pubblicato il

avoid blur in sddm screen and lock screen

1) login screen

SDDM Breeze 5.13.0 main.qml has:

Code: Select all
        WallpaperFader {
            visible: config.type == “image”
            anchors.fill: parent
            state: loginScreenRoot.uiVisible ? “on” : “off”
            source: wallpaper
            mainStack: mainStack
            footer: footer
            clock: clock
        }

Changing

Code: Select all
visible: config.type == “image”

to

Code: Select all
visible: false

Image

Testing – no blur at here.

2) lock screen

 You have to change LockScreenUi.qml in /usr/share/plasma/look-and-feel/org.kde.breeze.desktop/contents/lockscreen as well, adding the same row:

visible: false

in  WallPaperFader

Pubblicato il

adb connect via wi-fi

  • Connect Android phone and host machine to same WiFi network
  • Connect Android phone to host machine using USB cable (to start with)
  • Run adb tcpip 5555 from a command prompt
  • Run adb shell “ip addr show wlan0 | grep -e wlan0$ | cut -d” ” -f 6 | cut -d/ -f 1″ to obtain the phone’s IP address
  • Disconnect USB cable and run adb connect < ip_address > :5555
Pubblicato il

videochiamate (whatsapp e simli) su linux

Sconsigliatissimo whatdesk (via snap): non fa video né audio chiamate; fa le stesse cose di whatsappweb, solo consumando molto più spazio e memoria.

Un po’ meglio Franz, anche come appimage, che però fa videochiamate solo con Skype, non con Whatsapp o Icq (anche lì: fa lo stesso delle corrispondenti pagine web).