Zen

Translation

type: Fenced code block
<![CDATA[
LUA ERROR : rating too high : 6
stack traceback:
[C]: in ?
[C]: in function '__newindex'
./configdir/luarc:10: in function <./configdir/luarc:7>
LUA ERROR : rating too high : 6
]]>
206/2070 · 207

Sign in to save the translation.

English Dutch Actions
It is possible to send a lua command to darktable via its DBus interface. The method `org.darktable.service.Remote.Lua` takes a single string parameter which is interpreted as a lua command. The command will be executed in the current lua context and should return either nil or a string. The result will be passed back as the result of the DBus method.
Het is mogelijk om een lua-commando naar darktable te sturen via de DBus-interface. De methode `org.darktable.service.Remote.Lua` neemt een enkele stringparameter die wordt geïnterpreteerd als een lua-opdracht. De opdracht wordt uitgevoerd in de huidige lua-context en moet nul of een tekenreeks retourneren. Het resultaat wordt teruggegeven als het resultaat van de DBus-methode.
If the Lua call results in an error, the DBus method call will return an error `org.darktable.Error.LuaError` with the lua error message as the message attached to the DBus error.
Als de Lua-aanroep resulteert in een fout, retourneert de DBus-methodeaanroep een fout `org.darktable.Error.LuaError` met het lua-foutbericht als het bericht dat is gekoppeld aan de DBus-fout.
adding a simple shortcut
een eenvoudige snelkoppeling toevoegen
So far, all our scripts have done things during startup. This is of limited use and doesn't allow us to react to real user actions. To do more advanced things we need to register a function that will be called on a given event. The most common event to react to is a keyboard shortcut.
Tot nu toe hebben al onze scripts dingen gedaan tijdens het opstarten. Dit is van beperkt nut en stelt ons niet in staat te reageren op echte gebruikersacties. Om meer geavanceerde dingen te doen, moeten we een functie registreren die bij een bepaalde gebeurtenis wordt aangeroepen. De meest voorkomende gebeurtenis om op te reageren is een sneltoets.
darktable = require "darktable"

local function hello_shortcut(event, shortcut)
darktable.print("Hello, I just received '"..event..
"' with parameter '"..shortcut.."'")
end

darktable.register_event("shortcut",hello_shortcut,
"A shortcut that prints its parameters")
darktable = require "darktable"

local function hello_shortcut(event, shortcut)
darktable.print("Hello, I just received '"..event..
"' with parameter '"..shortcut.."'")
end

darktable.register_event("shortcut",hello_shortcut,
"A shortcut that prints its parameters")
Now start darktable, go to "preferences > shortcuts > lua > A shortcut that prints its parameters", assign a shortcut and try it. You should see a nice message printed on the screen.
Start nu darktable, ga naar "voorkeuren> snelkoppelingen> lua> Een snelkoppeling die de parameters afdrukt", wijs een snelkoppeling toe en probeer het. Je zou een leuk bericht op het scherm moeten zien verschijnen.
Let's look at the code in detail. We first define a function that takes two strings as input parameters. The first one is the type of event triggered ("shortcut") and the second is the name of the shortcut ("A shortcut that prints its parameters"). The function itself calls `darktable.print`, which will print the message as an overlay in the main window.
Laten we de code in detail bekijken. We definiëren eerst een functie die twee strings als invoerparameters nodig heeft. De eerste is het type gebeurtenis dat wordt geactiveerd ("snelkoppeling") en de tweede is de naam van de snelkoppeling ("Een snelkoppeling die de parameters ervan afdrukt"). De functie zelf roept `darktable.print` aan, die het bericht als een overlay in het hoofdvenster zal afdrukken.
Once that function is defined, we register it as a shortcut callback. To do that we call `darktable.register_event` which is a generic function for all types of events. We tell it that we are registering a shortcut event, then we give the callback to call and finally, we give the string to use to describe the shortcut in the preferences window.
Zodra die functie is gedefinieerd, registreren we deze als een snelkoppeling. Om dat te doen noemen we `darktable.register_event` wat een generieke functie is voor alle soorten gebeurtenissen. We vertellen het dat we een snelkoppelingsgebeurtenis registreren, dan geven we de callback om te bellen en tot slot geven we de string die moet worden gebruikt om de snelkoppeling in het voorkeurenvenster te beschrijven.
Let's try a shortcut that is a little more interactive. This one will look at the images the user is currently interested in (selected or moused-over) and increase their rating:
Laten we een snelkoppeling proberen die iets interactiever is. Deze zal de afbeeldingen bekijken waarin de gebruiker momenteel geïnteresseerd is (geselecteerd of met muis overgegaan) en hun beoordeling verhogen:
darktable = require "darktable"

darktable.register_event("shortcut",function(event,shortcut)
local images = darktable.gui.action_images
for _,v in pairs(images) do
v.rating = v.rating + 1
end
end,"Increase the rating of an image")
darktable = require "darktable"

darktable.register_event("shortcut",function(event,shortcut)
local images = darktable.gui.action_images
for _,v in pairs(images) do
v.rating = v.rating + 1
end
end,"Increase the rating of an image")
At this point, most of this code should be self explanatory. Just a couple of notes:
Op dit punt zou het grootste deel van deze code voor zichzelf moeten spreken. Even een paar opmerkingen:
Instead of declaring a function and referencing it, we declare it directly in the call to `darktable.register_event` this is strictly equivalent but slightly more compact.
In plaats van een functie te declareren en ernaar te verwijzen, declareren we deze direct in de aanroep van `darktable.register_event`. Dit is strikt equivalent maar iets compacter.
`image.rating` is a field that gives the star rating of any image (between 0 and 5 stars, -1 means rejected).
`image.rating` is een veld dat de sterrenclassificatie van een afbeelding geeft (tussen 0 en 5 sterren, -1 betekent afgewezen).
`darktable.gui.action_images` is a table containing all the images of interest. darktable will act on selected images if any image is selected, and on the image under the mouse if no image is selected. This function makes it easy to follow darktable's UI logic in lua.
`darktable.gui.action_images` is een tabel met alle afbeeldingen die van belang zijn. darktable werkt op geselecteerde afbeeldingen als er een afbeelding is geselecteerd, en op de afbeelding onder de muis als er geen afbeelding is geselecteerd. Deze functie maakt het gemakkelijk om de UI-logica van darktable in lua te volgen.
If you select an image and press your shortcut a couple of times, it will work correctly at first but when you have reached five stars, darktable will start showing the following error on the console:
Als je een afbeelding selecteert en een paar keer op jouw snelkoppeling drukt, zal deze eerst correct werken, maar wanneer je vijf sterren hebt bereikt, zal darktable de volgende fout op de console weergeven:
<![CDATA[
LUA ERROR : rating too high : 6
stack traceback:
[C]: in ?
[C]: in function '__newindex'
./configdir/luarc:10: in function <./configdir/luarc:7>
LUA ERROR : rating too high : 6
]]>
![CDATA[
LUA ERROR : rating too high : 6
stack traceback:
[C]: in ?
[C]: in function '__newindex'
./configdir/luarc:10: in function <./configdir/luarc:7>
LUA ERROR : rating too high : 6
]]>
This is lua's way of reporting errors. We have attempted to set a rating of 6 to an image, but a rating can only go as high as 5. It would be trivial to add a check, but let's go the complicated way and catch the error instead:
Dit is lua's manier om fouten te melden. We hebben geprobeerd een beoordeling van 6 voor een afbeelding in te stellen, maar een beoordeling kan maar tot 5 gaan. Het zou triviaal zijn om een vinkje toe te voegen, maar laten we de gecompliceerde weg gaan en in plaats daarvan de fout opvangen:
darktable.register_event("shortcut",function(event,shortcut)
local images = darktable.gui.action_images
for _,v in pairs(images) do
result,message = pcall(function()
v.rating = v.rating + 1
end)
if not result then
darktable.print_error("could not increase rating of image "..
tostring(v).." : "..message)
end
end
end,"Increase the rating of an image")
darktable.register_event("shortcut",function(event,shortcut)
local images = darktable.gui.action_images
for _,v in pairs(images) do
result,message = pcall(function()
v.rating = v.rating + 1
end)
if not result then
darktable.print_error("could not increase rating of image "..
tostring(v).." : "..message)
end
end
end,"Increase the rating of an image")
`pcall` will run its first argument and catch any exception thrown by it. If there is no exception it will return `true` plus any result returned by the function. If there is an exception it will return `false` and the error message of the exception. We simply test these results and print them to the console.
`pcall` zal zijn eerste argument uitvoeren en elke uitzondering opvangen die erdoor wordt gegenereerd. Als er geen uitzondering is, wordt `true` geretourneerd plus elk resultaat dat door de functie wordt geretourneerd. Als er een uitzondering is, wordt 'false' geretourneerd en de foutmelding van de uitzondering. We testen deze resultaten eenvoudig en printen ze naar de console.
Scripting with Lua
Scripten met Lua
darktable comes with a versatile scripting interface language for functionality enhancement.
darktable wordt geleverd met een veelzijdige scriptinterfacetaal voor functionaliteitsverbetering.
building user interface elements
gebruikersinterface-elementen bouwen
Our previous example was a bit limited. In particular the use of a preference for the export path wasn't very nice. We can do better than that by adding elements to the user interface in the export dialog.
Ons vorige voorbeeld was een beetje beperkt. Met name het gebruik van een voorkeur voor het exportpad was niet erg prettig. We kunnen beter dan dat door elementen toe te voegen aan de gebruikersinterface in het exportdialoogvenster.
UI elements are created via the `darktable_new_widget` function. This function takes a type of widget as a parameter and returns a new object corresponding to that widget. You can then set various fields in that widget to set its parameters. You will then use that object as a parameter to various functions that will add it to the darktable UI. The following simple example adds a lib in the lighttable view with a simple label:
UI-elementen worden gemaakt via de functie `darktable_new_widget`. Deze functie neemt een type widget als parameter en retourneert een nieuw object dat overeenkomt met die widget. Je kan vervolgens verschillende velden in die widget instellen om de parameters in te stellen. Je gebruikt dat object dan als parameter voor verschillende functies die het toevoegen aan de gebruikersinterface van de darktable. Het volgende eenvoudige voorbeeld voegt een lib toe aan de bibliotheekweergave met een eenvoudig label:
local my_label = darktable.new_widget("label")
my_label.label = "Hello, world !"

dt.register_lib("test","test",false,{
[dt.gui.views.lighttable] = {"DT_UI_CONTAINER_PANEL_LEFT_CENTER",20},
},my_label)
local my_label = darktable.new_widget("label")
my_label.label = "Hello, world !"

dt.register_lib("test","test",false,{
[dt.gui.views.lighttable] = {"DT_UI_CONTAINER_PANEL_LEFT_CENTER",20},
},my_label)
There is a nice syntactic trick to make UI elements code easier to read and write. You can call these objects as functions with a table of key values as an argument. This allows the following example to work. It creates a container widget with two sub-widgets: a label and a text entry field.
Er is een leuke syntactische truc om de code van UI-elementen gemakkelijker te lezen en te schrijven. Je kan deze objecten aanroepen als functies met een tabel met sleutelwaarden als argument. Hierdoor kan het volgende voorbeeld werken. Het maakt een containerwidget met twee subwidgets: een label en een tekstinvoerveld.
local my_widget = darktable.new_widget("box"){
orientation = "horizontal",
darktable.new_widget("label"){ label = "here => " },
darktable.new_widget("entry"){ tooltip = "please enter text here" }
}
local my_widget = darktable.new_widget("box"){
orientation = "horizontal",
darktable.new_widget("label"){ label = "here => " },
darktable.new_widget("entry"){ tooltip = "please enter text here" }
}
Now that we know that, let's improve our script a bit.
Nu we dat weten, laten we ons script een beetje verbeteren.
darktable = require "darktable"

local scp_path = darktable.new_widget("entry"){
tooltip ="Complete path to copy to. Can include user and hostname",
text = "",
reset_callback = function(self) self.text = "" end
}

darktable.register_storage("scp_export","Export via scp",
function( storage, image, format, filename,
number, total, high_quality, extra_data)
if not darktable.control.execute(scp "..filename.." "..
scp_path.text
) then
darktable.print_error("scp failed for "..tostring(image))
end
end,
nil, --finalize
nil, --supported
nil, --initialize
darktable.new_widget("box") {
orientation ="horizontal",
darktable.new_widget("label"){label = "target SCP PATH "},
scp_path,
})
darktable = require "darktable"

local scp_path = darktable.new_widget("entry"){
tooltip ="Complete path to copy to. Can include user and hostname",
text = "",
reset_callback = function(self) self.text = "" end
}

darktable.register_storage("scp_export","Export via scp",
function( storage, image, format, filename,
number, total, high_quality, extra_data)
if not darktable.control.execute(scp "..filename.." "..
scp_path.text
) then
darktable.print_error("scp failed for "..tostring(image))
end
end,
nil, --finalize
nil, --supported
nil, --initialize
darktable.new_widget("box") {
orientation ="horizontal",
darktable.new_widget("label"){label = "target SCP PATH "},
scp_path,
})
printing labeled images
gelabelde afbeeldingen afdrukken
The first example showed us the very basics of lua and allowed us to check that everything was working properly. Now let's do something a little bit more complex. Let's try to print a list of images that have a "red" label attached to them. But first of all, what is an image?
Het eerste voorbeeld liet ons de basis van lua zien en stelde ons in staat om te controleren of alles goed werkte. Laten we nu iets ingewikkelders doen. Laten we proberen een lijst met afbeeldingen af te drukken waaraan een "rood" label is bevestigd. Maar allereerst, wat is een beeld?

Loading…

User avatar cotcot

Translation added

  1. darktable
  2. dtdocs
  3. Dutch
<![CDATA[
LUA ERROR : rating too high : 6
stack traceback:
[C]: in ?
[C]: in function '__newindex'
./configdir/luarc:10: in function <./configdir/luarc:7>
LUA ERROR : rating too high : 6
]]>
![CDATA[
LUA ERROR : rating too high : 6
stack traceback:
[C]: in ?
[C]: in function '__newindex'
./configdir/luarc:10: in function <./configdir/luarc:7>
LUA ERROR : rating too high : 6
]]>
2 years ago
Browse all string changes

Things to check

XML syntax

The translation is not valid XML

Reset

Glossary

English Dutch
No related strings found in the glossary.

String information

Source string description
type: Fenced code block
Flags
no-wrap
Source string location
content/lua/simple-shortcut.md
String age
2 years ago
Last updated
2 months ago
Source string age
3 years ago
Translation file
po/content.nl.po, string 4125