Tuxpaint doc magic - en to sv translation catalogue (488 entries)

note: Icon denoting configuration options
en: Configuration option
sv: Konfigurationsalternativ

note: Icon denoting keyboard shortcuts
en: Keyboard shortcut
sv: Tangentbordsgenväg

note: Icon denoting differences in features between versions
en: Version variation
sv: Variation av version

note: "Shift" key on a keyboard
en: Shift
sv: Skift

note: "Control" (Ctrl) key on a keyboard
en: Control
sv: Kontroll

note: "Command" (⌘) key on a macOS keyboard
en: &#8984; (Command)
sv: &#8984; (Kommando)

note: "Option" key on a (Mac) keyboard
en: Option
sv: Alternativ

note: "Tab" key on a keyboard
en: Tab
sv: Flik

note: Left arrow key on a keyboard
en: Left Arrow
sv: Pil vänster

note: Right arrow key on a keyboard
en: Right Arrow
sv: Pil höger

note: Enter aka Return key on a keyboard
en: Enter / Return
sv: Enter / Retur

note: "+" and "-" keys on the numeric keypad of a keyboard
en: Keypad Plus (+)
sv: Knappsats Plus (+)

en: Keypad Minus (-)
sv: Knappsats Minus (-)

note: Copyright string, with args representing starting year, latest year, and contributor(s)
en: Copyright &copy; %1$d-%2$d by %3$s; see <a href="../../AUTHORS.txt">AUTHORS.txt</a>.
sv: Copyright © %1$d-%2$d av %3$s; se <a href="../../AUTHORS.txt">AUTHORS.txt</a>.

note: The 'username' part of a file path (e.g., "/home/username/xyz" on Linux, "/Users/username/xyz" on macOS, etc.) (Perhaps German "Nutzername", French "identifiant", Dutch "gebruikersnaam", etc.)
en: username
sv: användarnamn

note: === Paths to certain files and folders under Windows === (FIXME: Localize any others parts of paths that get localized under Windows)
en: Program Files
sv: Programfiler

en: Users
sv: Användare

en: Library
sv: Bibliotek

en: <b>Note:</b> Called once for each Magic tool your plugin claims to contain (by your "<code>get_tool_count()</code>").
sv: <b>Observera:</b> Anropas en gång för varje Magic-verktyg som ditt plugin påstår sig innehålla (genom ditt<code>"get_tool_count()</code>").

en: <b>Note:</b> For each Magic tool your plugin claims to contain (reported by your "<code>get_tool_count()</code>" function), this function will be called for each mode the tool claims to support (reported by your "<code>modes()</code>" function).
sv: <b>Obs:</b> För varje Magic-verktyg som ditt plugin påstår sig innehålla (rapporterat av din "<code>get_tool_count()</code>"-funktion), kommer denna funktion att anropas för varje läge som verktyget påstår sig stödja (rapporterat av din "<code>modes()</code>"-funktion).

en: <b>Note:</b> Added to Tux Paint %1$s; Magic API version %2$s.
sv: <b>Obs:</b> Tillagd till Rita med Tux %1$s; Magic API-version %2$s.

en: <b>Note:</b> Changed most recently in Tux Paint %1$s; Magic API version %2$s.
sv: <b>Notera:</b> Senast ändrad i Rita med Tux %1$s; Magic API version %2$s.

en: Tux Paint Magic Tool Plugin API Documentation
sv: Rita med Tux Magic Tool Plugin API-dokumentation

en: Magic Tool Plugin API Documentation
sv: Dokumentation av API för Magic Tool Plugin

en: various contributors
sv: olika bidragsgivare

en: Table of Contents
sv: Innehåll

en: Prequisites
sv: Förutsättningar

note: ------------------------------------------------------------
en: Interfaces
sv: Gränssnitt

en: 'Magic' tool plugin functions
sv: plugin-funktioner för "Magic"-verktyget

en: Common arguments to plugin functions
sv: Vanliga argument till plugin-funktioner

en: Required Plugin Functions
sv: Nödvändiga plugin-funktioner

en: Plugin "housekeeping" functions
sv: Plugin "hushållning" funktioner

en: Plugin event functions
sv: Plugin-händelsefunktioner

en: Tux Paint Functions and Data
sv: Rita med Tux Funktioner och data

en: Pixel Manipulations
sv: Pixelmanipulationer

note: FIXME: Zoom Scale
en: Helper Functions
sv: Hjälpfunktioner

en: Informational
sv: Information

en: Sound Functions
sv: Ljudfunktioner

en: Tux Paint System Calls
sv: Systemanrop för Rita med Tux

en: Color Conversions
sv: Färgkonverteringar

en: Helper Macros in %s
sv: Hjälpmakron i %s

en: Constant Definitions in %s
sv: Konstant Definitioner i %s

note: ------------------------------------------------------------
en: Compiling
sv: Kompilera

en: Linux and other Unix-like Platforms
sv: Linux och andra Unix-liknande plattformar

en: Windows
sv: Fönster

note: FIXME ------------------------------------------------------------
en: Installing
sv: Installerar

note: FIXME ------------------------------------------------------------
en: Creating plugins with multiple effects
sv: Skapa plugins med flera effekter

note: ------------------------------------------------------------
en: Example Code
sv: Om det anges söker GCode-visaren efter en rad som börjar med den här strängen. Om det hittas hoppas alla GCode upp till den punkten över. Detta kan användas för att hoppa över GCode för "rensa/munstyckesrensning" i tittaren. Observera att sökningen är fallkänslig. Exempel: <code>; layer 1</code>

note: ------------------------------------------------------------
en: Getting Help
sv: Få hjälp

en: Glossary
sv: Ordlista

note: ------------------------------------------------------------
en: Overview
sv: Översikt

en: Tux Paint's 'Magic' tools come as a set of 'plugins' which are loaded when Tux Paint starts up.
sv: Rita med Tux's "Magic"-verktyg kommer som en uppsättning "plugins" som laddas när Rita med Tux startar.

en: This division allows more rapid development of 'Magic' tools, and allows programmers to create and test new tools without needing to integrate them within the main Tux Paint source code.  (Users of more professional graphics tools, such as GIMP, should be familiar with this plugin concept.)
sv: Denna uppdelning möjliggör en snabbare utveckling av "magiska" verktyg och gör det möjligt för programmerare att skapa och testa nya verktyg utan att behöva integrera dem i Rita med Tuxs källkod.  (Användare av mer professionella grafikverktyg, t.ex. GIMP, bör känna till detta plugin-koncept)

note: ------------------------------------------------------------
en: Prerequisites
sv: Förutsättningar

en: Tux Paint is written in the <a href="http://en.wikipedia.org/wiki/C_(programming_language)">C programming language</a>, and uses the Simple DirectMedia Layer library ('libSDL', or simply 'SDL'; available from <a href="https://www.libsdl.org/">https://www.libsdl.org/</a>). Therefore, for the moment at least, one must understand the C language and how to compile C-based programs.  Familiarity with the SDL API is highly recommended, but some basic SDL concepts will be covered in this document.
sv: Rita med Tux är skrivet i <a href="http://en.wikipedia.org/wiki/C_(programming_language)">programspråket C</a> och använder biblioteket Simple DirectMedia Layer ("libSDL", eller bara "SDL"; finns på <a href="https://www.libsdl.org/">https://www.libsdl.org/).</a> Därför måste man, åtminstone för tillfället, förstå C-språket och hur man kompilerar C-baserade program.  Det rekommenderas starkt att man känner till SDL API, men några grundläggande SDL-koncept kommer att behandlas i detta dokument.

en: Those who create 'Magic' tool plugins for Tux Paint must provide some interfaces (C functions) that Tux Paint may invoke.
sv: De som skapar plugins för "magiska" verktyg för Rita med Tux måste tillhandahålla vissa gränssnitt (C-funktioner) som Rita med Tux kan anropa.

en: Tux Paint utilizes SDL's "SDL_LoadObject()" and "SDL_LoadFunction()" routines to load plugins (shared objects files; e.g., "<code>.so</code>" files on Linux or "<code>.dll</code>" files on Windows) and find the functions within.
sv: Rita med Tux använder SDL:s rutiner "SDL_LoadObject()" och "SDL_LoadFunction()" för att ladda plugins (filer med delade objekt, t.ex. "<code>.so</code>"-filer i Linux eller "<code>.dll</code>"-filer i Windows) och hitta funktionerna i dem.

en: In turn, Tux Paint provides a number of helper functions that the plugin may (or sometimes is required to) use.  This is exposed as a C structure (or "<code>struct</code>") which contains pointers to functions and other data inside Tux Paint.  A pointer to this structure gets passed along to the plugin's functions as an argument when Tux Paint invokes them.
sv: Rita med Tux tillhandahåller i sin tur ett antal hjälpfunktioner som plugin-programmet kan (eller ibland måste) använda.  Detta exponeras som en C-struktur (eller<code>"struct</code>") som innehåller pekare till funktioner och andra data i Rita med Tux.  En pekare till denna struktur skickas vidare till plugin-funktionerna som ett argument när Rita med Tux anropar dem.

en: Plugins should <code>#include</code> the C header file "<code>tp_magic_api.h</code>", which exposes the 'Magic' tool plugin API. Also, when you run the C compiler to build a plugin, you should use the command-line tool "<code>tp-magic-config</code>" to get the appropriate compiler flags (such as where the compiler can find the Tux Paint plugin header file, as well as SDL's header files) for building a plugin. (See "<a href="#compiling">Compiling</a>", below.)
sv: Plugins bör <code>#inkludera</code> C-huvudfilen<code>"tp_magic_api.h</code>", som exponerar plugin-API:et för verktyget "Magic". När du kör C-kompilatorn för att bygga ett plugin bör du också använda kommandoradsverktyget<code>"tp-magic-config</code>" för att få lämpliga kompilatorflaggor (till exempel var kompilatorn kan hitta Rita med Tux-pluginhuvudfilen, liksom SDLs huvudfiler) för att bygga ett plugin. (Se<a href="#compiling">"Kompilering</a>" nedan.)

en: The C header file and command-line tool mentioned above are included with Tux Paint &mdash; or in some cases, as part of a "Tux Paint 'Magic' Tool Plugin Development package".
sv: C-huvudfilen och kommandoradsverktyget som nämns ovan ingår i Rita med Tux - eller i vissa fall som en del av ett "Rita med Tux 'Magic' Tool Plugin Development package".

en: 'Magic' tool plugins <i>must</i> contain the functions listed below. <b>Note:</b> To avoid 'namespace' collisions, each function's name must start with the shared object's filename (e.g., "blur.so" or "blur.dll" would have functions whose names begin with "<code>blur_</code>").  <i>This includes private functions</i> (ones not used by Tux Paint directly), unless you declare those as '<code>static</code>'.
sv: plugins för "Magic"-verktyg <i>måste</i> innehålla de funktioner som anges nedan. <b>Observera:</b> För att undvika kollisioner i namnrymden måste varje funktionsnamn börja med det delade objektets filnamn (t.ex. skulle "blur.so" eller "blur.dll" ha funktioner vars namn börjar med<code>"blur_</code>"). <i>Detta inkluderar privata funktioner</i> (sådana som inte används direkt av Rita med Tux), såvida du inte deklarerar dem som<code>"statiska</code>".

en: Here is a description of arguments that many of your plugin's functions will need to accept.
sv: Här följer en beskrivning av de argument som många av funktionerna i ditt plugin måste acceptera.

en: Pointer to a C structure containing pointers to Tux Paint functions and other data that the plugin can (and sometimes should) use. The contents of this struct are <a href="#tpfuncs">described below</a>.
sv: Pekare till en C-struktur som innehåller pekare till Rita med Tux-funktioner och andra data som insticksprogrammet kan (och ibland bör) använda. Innehållet i denna struktur <a href="#tpfuncs">beskrivs nedan.</a>.

en: Note: The <code>magic_api</code> struct is defined in the C header file "<code>tp_magic_api.h</code>", which you should include at the top of your plugin's C source file:
sv: Observera: Strukturen <code>magic_api</code> definieras i C-headerfilen<code>"tp_magic_api.h</code>", som du bör inkludera högst upp i ditt plugins C-källfil:

en: An index the plugin should use to differentiate different 'Magic' tools, if the plugin provides more than one.  (If not, "which" will always be 0.) See <a href="#multiple">"Creating plugins with multiple effects"</a>, below.
sv: Ett index som insticksprogrammet ska använda för att skilja mellan olika "Magic"-verktyg, om insticksprogrammet tillhandahåller mer än ett.  (Om inte, kommer "which" alltid att vara 0.) Se <a href="#multiple">"Skapa insticksprogram med flera effekter"</a> nedan.

en: A snapshot of the previous Tux Paint canvas, taken when the the mouse was first clicked to activate the current magic tool.  If you don't continuously affect the image during one hold of the mouse button, you should base your effects off the contents of this canvas. (That is, read from "<code>snapshot</code>" and write to "<code>canvas</code>", below.)
sv: En ögonblicksbild av den föregående Rita med Tux-bilden, tagen när musen först klickades för att aktivera det aktuella magiska verktyget.  Om du inte kontinuerligt påverkar bilden under ett musklick, bör du basera dina effekter på innehållet i denna canvas. (Det vill säga, läs från<code>"snapshot</code>" och skriv till<code>"canvas</code>", nedan)

en: The current Tux Paint drawing canvas.  Your magical effects should end up here!
sv: Den aktuella Rita med Tux-ritningsduken.  Dina magiska effekter bör hamna här!

en: A pointer to an SDL 'rectangle' structure that you use to tell Tux Paint what part of the canvas has been updated.  If your effect affects a 32x32 area centered around the mouse pointer, you would fill the SDL_Rect as follows:
sv: En pekare till en SDL-"rektangel"-struktur som du använder för att tala om för Rita med Tux vilken del av duken som har uppdaterats.  Om din effekt påverkar ett 32x32-område centrerat runt muspekaren fyller du SDL_Rect på följande sätt:

en: Or, if your effect changes the entire canvas (e.g., flips it upside-down), you'd fill it as follows:
sv: Om din effekt ändrar hela duken (t.ex. vänder den upp och ner) fyller du den på följande sätt:

en: Note: "<code>update_rect</code>" is a C pointer (an "<code>SDL_Rect *</code>" rather than just an "<code>SDL_Rect</code>") because you need to fill in its contents. Since it is a pointer, you access its elements via "<code>-&gt;</code>" (arrow) rather than "<code>.</code>" (dot).
sv: Obs:<code>"update_rect</code>" är en C-pekare (en<code>"SDL_Rect *</code>" snarare än bara en<code>"SDL_Rect</code>") eftersom du måste fylla i dess innehåll. Eftersom det är en pekare kommer du åt dess element via<code>"-&gt;"</code>(pil) snarare än "<code>.</code>" (punkt).

en: Your plugin is required to contain, at the least, all of the following functions.
sv: Ditt insticksprogram måste minst innehålla alla följande funktioner.

en: <b>Note:</b> Remember, your plugin's function names must be preceded by your plugin's filename.  That is, if your plugin is called "<code>zoom.so</code>" (on Linux) or "<code>zoom.dll</code>" (on Windows), then the names of your functions must begin with "<code><b>zoom_</b></code>" (e.g., "<code>zoom_get_name(...)</code>").
sv: <b>Observera:</b> Kom ihåg att plugin-programmets funktionsnamn måste föregås av plugin-programmets filnamn.  Det vill säga, om ditt plugin heter<code>"zoom.so</code>" (på Linux) eller "<code>zoom.dll</code>" (på Windows), måste namnen på dina funktioner börja med "<code><b>zoom_</b></code>" (t.ex. "<code>zoom_get_name(...)</code>").

en: The plugin should return an integer value representing the version of the Tux Paint 'Magic' tool plugin API the plugin was built against. The safest thing to do is return the value of <code>TP_MAGIC_API_VERSION</code>, which is defined in "<code>tp_magic_api.h</code>".  If Tux Paint deems your plugin to be compatible, it will go ahead and use it.
sv: Insticksprogrammet bör returnera ett heltalsvärde som representerar versionen av Rita med Tux 'Magic' tool plugin API som insticksprogrammet byggdes mot. Det säkraste är att returnera värdet av <code>TP_MAGIC_API_VERSION</code>, som definieras i<code>"tp_magic_api.h</code>".  Om Rita med Tux anser att ditt plugin är kompatibelt kommer det att fortsätta och använda det.

en: <b>Note:</b> Called once by Tux Paint, at startup. It is called first.
sv: <b>Obs:</b> Anropas en gång av Rita med Tux, vid uppstart. Den anropas först.

en: The plugin should do any initialization here. Return '1' if initialization was successful, or '0' if not (and Tux Paint will not present any 'Magic' tools from the plugin).
sv: Plugin-programmet bör göra alla initialiseringar här. Returnera '1' om initieringen lyckades, eller '0' om den inte gjorde det (och Rita med Tux kommer inte att presentera några 'Magic'-verktyg från insticksprogrammet).

en: <b>Note:</b> Called once by Tux Paint, at startup. It is called after "<code>api_version()</code>", if Tux Paint believes your plugin to be compatible.
sv: <b>Obs:</b> Anropas en gång av Rita med Tux, vid uppstart. Det anropas efter<code>"api_version()</code>", om Rita med Tux anser att ditt plugin är kompatibelt.

en: The <code>disabled_features</code> value contains bits set for any Tux Paint features relevant to Magic tools which have been disabled in this session. Test using the C bitwise 'and' operator, '<code>&amp;</code>'. The features are defined in <code>tp_magic_api.h</code>:
sv: Värdet <code>disabled_features</code> innehåller bits som ställts in för alla Rita med Tux-funktioner som är relevanta för Magic-verktyg som har inaktiverats i den här sessionen. Test med hjälp av C:s bitvisa operator "och",<code>"&amp;".</code> Funktionerna är definierade i <code>tp_magic_api.h:</code>:

en: Magic tool controls (paint vs fullscreen)
sv: Kontroll av magiska verktyg (färg vs helskärm)

en: Magic tool size
sv: Storlek på magiskt verktyg

en: Your Magic tool(s) may wish to react differently depending on whether one or more features have been disabled. (For example, the "Brick" Magic tool always offered two tool variations: large and small. With the addition of the size feature, only one tool is necessary. However, with the size option disabled, the plugin is able to revert back to providing two separate tools.)
sv: Ditt/dina magiska verktyg kan vilja reagera på olika sätt beroende på om en eller flera funktioner har inaktiverats. (Till exempel har det magiska verktyget "Brick" alltid erbjudit två verktygsvarianter: stort och litet. Med tillägget av storleksfunktionen behövs bara ett verktyg. Men när storleksalternativet är inaktiverat kan plugin-programmet återgå till att tillhandahålla två separata verktyg)

en: The <code>complexity_level</code> variable contains the "complexity level" that Tux Paint magic tools may offer &mdash; that is, the expertise level of the user. The levels are defined in <code>tp_magic_api.h</code>:
sv: Variabeln <code>complexity_level</code> innehåller den "komplexitetsnivå" som Rita med Tux magiska verktyg kan erbjuda - det vill säga användarens expertisnivå. Nivåerna definieras i <code>tp_magic_api.h:</code>:

en: Novice
sv: Novis

en: Beginner
sv: Nybörjare

en: Advanced (default)
sv: Avancerad (standard)

en: Your Magic tool(s) may wish to react differently depending on the expertise level of the user, either simplifying how each tool works, or excluding one or all of them entirely. (For example, the 1-, 2-, and 3-point perspective toolsets are totally inactive when in "novice" mode. In "beginner" mode, the drawing tools are available, but the tools to edit the vanishing point positions are disabled; the default vanishing points are used. In fact, in "beginner" mode, an additional 3-point perspective drawing tool appears, with alternative vanishing points.)
sv: Ditt/dina Magic-verktyg kanske vill reagera olika beroende på användarens kunskapsnivå, antingen genom att förenkla hur varje verktyg fungerar eller genom att utesluta ett eller flera av dem helt. (Till exempel är verktygsuppsättningarna för 1-, 2- och 3-punktsperspektiv helt inaktiva i läget "nybörjare". I "nybörjarläget" är ritverktygen tillgängliga, men verktygen för att redigera vanishing-punkternas positioner är inaktiverade; standardvanishing-punkterna används. I själva verket visas i "nybörjar"-läget ytterligare ett ritverktyg för 3-punktsperspektiv, med alternativa vanishingpunkter)

en: This should return the number of Magic tools this plugin provides to Tux Paint.
sv: Detta ska returnera antalet magiska verktyg som detta plugin tillhandahåller till Rita med Tux.

en: <b>Note:</b> Called once by Tux Paint, at startup.  It is called after your "<code>init()</code>", if it succeeded.
sv: <b>Obs:</b> Anropas en gång av Rita med Tux, vid start.  Den anropas efter din<code>"init()</code>", om den lyckades.

en: <b>Note:</b> You may wish to resond differently, based on whether certain features have been disabled (e.g., 'paint' versus 'entire picture' controls, or 'Magic sizes' controls).
sv: <b>Obs:</b> Du kanske vill svara på olika sätt beroende på om vissa funktioner har inaktiverats (t.ex. kontroller för "paint" kontra "entire picture" eller kontroller för "Magic sizes").

en: This lets you tell Tux Paint what modes your tool can be used in; either as a tool the user can paint with, or a tool that affects the entire drawing at once.
sv: Här kan du tala om för Rita med Tux vilka lägen ditt verktyg kan användas i; antingen som ett verktyg som användaren kan måla med eller som ett verktyg som påverkar hela ritningen på en gång.

en: You must return a value that's some combination of one or more of available modes:
sv: Du måste returnera ett värde som är en kombination av ett eller flera av de tillgängliga lägena:

en: freehand paint (click and drag)
sv: måla på fri hand (klicka och dra)

en: applies to full image with one click
sv: gäller för hela bilden med ett klick

en: freehand paint, with preview (click and drag)
sv: frihandsmålning, med förhandsgranskning (klicka och dra)

en: applies to an area around the mouse, with one click
sv: gäller för ett område runt musen, med ett klick

en: e.g., if your tool is only one that the user can paint with, return "<code>MODE_PAINT</code>".  If the user can do both, return "<code>MODE_PAINT | MODE_FULLSCREEN</code>" to tell Tux Paint it can do both.
sv: t.ex. om ditt verktyg är det enda som användaren kan måla med, returnera<code>"MODE_PAINT</code>".  Om användaren kan göra båda, returnera<code>"MODE_PAINT | MODE_FULLSCREEN</code>" för att tala om för Rita med Tux att den kan göra båda.

en: This should return a string containing the name of a magic tool. This will appear on the button in the 'Magic' selector within Tux Paint.
sv: Detta bör returnera en sträng som innehåller namnet på ett magiskt verktyg. Detta kommer att visas på knappen i "Magic"-väljaren i Rita med Tux.

en: Tux Paint will <code>free()</code> the string upon exit, so you should wrap it in a C <code>strdup()</code> call.
sv: Rita med Tux kommer att <code>free()</code> strängen vid avslutning, så du bör linda in den i ett C <code>strdup()</code> -anrop.

en: Use this to group tools together within sections of the 'Magic' selector.  A number of groups are pre-defined within an <code>enum</code> found in "<code>tp_magic_api.h</code>":
sv: Använd detta för att gruppera verktyg tillsammans inom sektioner av "Magic"-väljaren.  Ett antal grupper är fördefinierade i ett <code>enum</code> som finns i<code>"tp_magic_api.h</code>":

en: Tools that distort the shape of the image, like Blur, Emboss, and Ripples
sv: Verktyg som förvränger bildens form, t.ex. Blur, Emboss och Ripples

en: Tools that mostly affect the colors of the image without distortion, like Darken, Negative, and Tint
sv: Verktyg som främst påverkar bildens färger utan att förvränga dem, t.ex. Darken, Negative och Tint

en: Tools that warp or move the entire picture, like Shift, Flip, and Waves
sv: Verktyg som förvränger eller flyttar hela bilden, t.ex. Shift, Flip och Waves

en: Tools that generally paint new content at the cursor position, like Grass, Bricks, and Rails
sv: Verktyg som i allmänhet målar nytt innehåll vid markörens position, som Grass, Bricks och Rails

en: Tools that paint in multiple places at once, like Kaleidoscope and the Symmetry tools
sv: Verktyg som målar på flera ställen samtidigt, t.ex. Kalejdoskop och Symmetry-verktygen

en: Tools that apply decorations to the entire picture, like Blinds and Checkboard
sv: Verktyg som applicerar dekorationer på hela bilden, t.ex. Blinds och Checkboard

en: Special-purpose artistic tools, like Flower, the String tools, and the Rainbow-arc-drawing tools.
sv: Specialverktyg för konstnärliga ändamål, t.ex. Flower, String-verktygen och Rainbow-arc-ritverktygen.

en: This should return an SDL_Surface containing the icon representing the tool.  (A greyscale image with alpha, no larger than 40x40.) This will appear on the button in the 'Magic' selector within Tux Paint.
sv: Detta bör returnera en SDL_Surface som innehåller ikonen som representerar verktyget.  (En gråskalebild med alfa, inte större än 40x40.) Detta kommer att visas på knappen i "Magic"-väljaren i Rita med Tux.

en: Tux Paint will free ("<code>SDL_FreeSurface()</code>") the surface upon exit.
sv: Rita med Tux kommer att frigöra ("<code>SDL_FreeSurface()</code>") ytan när den avslutas.

en: This should return a string containing the description of how to use a particular magic tool. This will appear as a help tip, explained by Tux the Penguin, within Tux Paint.
sv: Detta bör returnera en sträng som innehåller en beskrivning av hur man använder ett visst magiskt verktyg. Detta kommer att visas som ett hjälptips, förklarat av pingvinen Tux, i Rita med Tux.

en: In other words, if your plugin contains two tools, one which works in paint mode only, and the other that works in both paint mode and full-image mode, your plugin's "<code>get_description()</code>" will be called three times.
sv: Med andra ord, om ditt plugin innehåller två verktyg, ett som bara fungerar i färgläge och det andra som fungerar i både färgläge och fullbildsläge, kommer ditt plugins<code>"get_description()</code>" att anropas tre gånger.

en: Return a '1' if the 'Magic' tool accepts colors (the 'Colors' palette in Tux Paint will be available), or '0' if not.
sv: Returnerar en "1" om "Magic"-verktyget accepterar färger (paletten "Colors" i Rita med Tux kommer att vara tillgänglig), eller "0" om inte.

en: Return how many size variations the 'Magic' tool accepts, in the given mode (i.e., '<code>MODE_PAINT</code>' or '<code>MODE_FULLSCREEN</code>). Return a '0' if the 'Magic' tool should not offer sizing options. Returning '1' is the same as returning '0'.
sv: Returnerar hur många storleksvariationer som 'Magic'-verktyget accepterar i det angivna läget (dvs.<code>'MODE_PAINT</code>' eller<code>'MODE_FULLSCREEN</code>). Returnera '0' om 'Magic'-verktyget inte ska erbjuda storleksalternativ. Att returnera '1' är samma sak som att returnera '0'.

en: Return the default size the 'Magic' tool should start out with, in the given mode. This will be the default setting for the tool the first time it is used during a Tux Paint session. If Tux Paint is being invoked with the sizing option disabled, this will be the only size requested by Tux Paint.  Return a number between '1' and the amount you returned in <code>accepted_sizes()</code>.
sv: Returnerar den standardstorlek som verktyget "Magic" ska börja med i det angivna läget. Detta kommer att vara standardinställningen för verktyget första gången det används under en Rita med Tux-session. Om Rita med Tux anropas med storleksalternativet avaktiverat kommer detta att vara den enda storlek som Rita med Tux begär.  Returnera ett tal mellan '1' och det belopp som du returnerade i <code>accepted_sizes()</code>.

en: The plugin should do any cleanup here.  If you allocated any memory or used SDL_Mixer to load any sounds during <code>init()</code>, for example, you should <code>free()</code> the allocated memory and <code>Mix_FreeChunk()</code> the sounds here.
sv: Plugin-programmet bör göra all upprensning här.  Om du har allokerat något minne eller använt SDL_Mixer för att ladda några ljud under <code>init()</code>, till exempel, bör du <code>frigöra(</code> ) det allokerade minnet och <code>Mix_FreeChunk()</code> ljuden här.

en: <b>Note:</b> This function is called once, when Tux Paint exits.
sv: <b>Obs:</b> Denna funktion anropas en gång när Rita med Tux avslutas.

en: <code>switchin()</code> is called whenever one of the plugin's Magic tools becomes active, and <code>switchout()</code> is called whenever one becomes inactive.  This can be because the user just clicked a specific Magic tool (the current one is switched-out, and a new one is switched-in).
sv: <code>switchin()</code> anropas när ett av plugin-programmets magiska verktyg blir aktivt, och <code>switchout()</code> anropas när ett blir inaktivt.  Detta kan bero på att användaren just har klickat på ett specifikt magiskt verktyg (det aktuella verktyget kopplas ut och ett nytt kopplas in).

en: It can also happen when user leaves/returns from the selection of "Magic" tools when doing some other activity (i.e., using a different tool, such as "Text" or "Brush", activating a momentary tool, such as "Undo" and "Redo", or returning from a dialog &mdash; possibly with a new picture when it switches back &mdash; such as "Open", "New" or "Quit").  In this case, the same Magic tool is first 'switched-out', and then 'switched-back-in', usually moments later.
sv: Det kan också hända när användaren lämnar/återvänder från valet av "magiska" verktyg när han/hon utför någon annan aktivitet (t.ex. använder ett annat verktyg, som "Text" eller "Brush", aktiverar ett tillfälligt verktyg, som "Undo" och "Redo", eller återvänder från en dialog - eventuellt med en ny bild när den växlar tillbaka - som "Open", "New" eller "Quit").  I detta fall är samma magiska verktyg först "utslaget" och sedan "inslaget igen", vanligtvis några ögonblick senare.

en: Finally, it can also happen when the user changes the 'mode' of a tool (i.e., from paint mode to full-image mode).  First <code>switchout()</code> is called for the old mode, then <code>switchin()</code> is called for the new mode.
sv: Slutligen kan det också hända när användaren ändrar "läge" för ett verktyg (t.ex. från färgläge till fullbildsläge).  Först anropas <code>switchout()</code> för det gamla läget, sedan anropas <code>switchin()</code> för det nya läget.

en: These functions allow users to interact in complicated was with Magic tools (for example, a tool that lets the user draw <i>multiple</i> freehand strokes, and then uses that as input such as handwriting &mdash; normally, the user could click somewhere in the canvas to tell the Magic tool they are 'finished', but if they switch to another tool, the Magic tool may want to undo any temporary changes to the canvas).
sv: Dessa funktioner gör det möjligt för användare att interagera på komplicerade sätt med Magic-verktyg (t.ex. ett verktyg som låter användaren rita <i>flera</i> streck på fri hand och sedan använder det som indata, t.ex. handskrift - normalt kan användaren klicka någonstans i målarduken för att tala om för Magic-verktyget att de är "klara", men om de byter till ett annat verktyg kanske Magic-verktyget vill ångra alla tillfälliga ändringar i målarduken).

en: These functions could also be used to streamline certain effects; a behind-the-scenes copy of the entire canvas could be altered in some way when the user first switches to the canvas, and then pieces of that copy could be drawn on the canvas when they draw with the Magic tool.
sv: Dessa funktioner skulle också kunna användas för att effektivisera vissa effekter; en bakomliggande kopia av hela duken skulle kunna ändras på något sätt när användaren först växlar till duken, och sedan skulle delar av den kopian kunna ritas på duken när användaren ritar med Magic-verktyget.

en: Tux Paint will call this function to inform the plugin of the RGB values of the currently-selected color in Tux Paint's 'Colors' palette.  (It will be called whenever one of the plugin's Magic tools that accept colors becomes active, and whenever the user picks a new color while such a tool is currently active.)
sv: Rita med Tux anropar denna funktion för att informera insticksprogrammet om RGB-värdena för den aktuella valda färgen i Rita med Tuxs palett "Colors".  (Funktionen anropas när ett av plugin-programmets magiska verktyg som accepterar färger blir aktivt, och när användaren väljer en ny färg medan ett sådant verktyg är aktivt)

en: Generally, Magic tools will not alter the canvas in any way when receiving an updated color, but it is possible. (For example, the "Zoom" and "Perspective" tools apply effects which uses the current color choice as a solid background. The effects may be adjusted with subsequent click/drag operations, but you may also adjust the background color, without altering the zoom level or perspective, by simply picking a new color.)
sv: I allmänhet kommer Magic-verktygen inte att ändra målarduken på något sätt när de får en uppdaterad färg, men det är möjligt. (Till exempel använder verktygen "Zoom" och "Perspective" effekter som använder det aktuella färgvalet som en solid bakgrund. Effekterna kan justeras med efterföljande klick/drag-operationer, men du kan också justera bakgrundsfärgen, utan att ändra zoomnivån eller perspektivet, genom att helt enkelt välja en ny färg)

en: Tux Paint will call this function to inform the plugin of the 'Magic' tool size option chosen. (It will be called whenever one of the plugin's Magic tools that accept sizes becomes active, and whenever the user picks a new size while such a tool is currently active.)
sv: Rita med Tux anropar denna funktion för att informera insticksprogrammet om det valda storleksalternativet för "Magic"-verktyget. (Den anropas när ett av plugin-programmets magiska verktyg som accepterar storlekar blir aktivt, och när användaren väljer en ny storlek medan ett sådant verktyg är aktivt)

en: Generally, Magic tools will not alter the canvas in any way when receiving an updated size, but it is possible.
sv: I allmänhet kommer Magic-verktygen inte att ändra duken på något sätt när de får en uppdaterad storlek, men det är möjligt.

en: The plugin should apply the appropriate 'Magic' tool on the '<code>canvas</code>' surface.  The (x,y) coordinates are where the mouse was (within the canvas) when the mouse button was clicked, and you are told which 'mode' your tool is in (i.e., '<code>MODE_PAINT</code>' or '<code>MODE_FULLSCREEN</code>).
sv: Plugin-programmet ska tillämpa lämpligt "Magic"-verktyg på<code>"canvas</code>"-ytan.  (x,y)-koordinaterna är var musen befann sig (inom canvasen) när musknappen klickades, och du får veta vilket "läge" ditt verktyg är i (dvs.<code>"MODE_PAINT</code>" eller<code>"MODE_FULLSCREEN</code>").

en: The plugin should report back what part of the canvas was affected, by filling in the (x,y) and (w,h) elements of '<code>update_rect</code>'.
sv: Plugin-programmet bör rapportera tillbaka vilken del av duken som påverkades genom att fylla i elementen (x,y) och (w,h) i<code>"update_rect</code>".

en: The contents of the drawing canvas immediately prior to the mouse button click is stored within the '<code>snapshot</code>' canvas.
sv: Innehållet i teckningsytan omedelbart före musklicket lagras i<code>"snapshot</code>"-ytan.

en: The plugin should apply the appropriate 'Magic' tool on the '<code>canvas</code>' surface.  The (ox,oy) and (x,y) coordinates are the location of the mouse at the beginning and end of the stroke.
sv: Plugin-programmet bör tillämpa lämpligt "Magic"-verktyg på<code>"canvas"</code>-ytan.  Koordinaterna (ox,oy) och (x,y) är musens position i början och slutet av strecket.

en: Typically, plugins that let the user "draw" effects onto the canvas utilize Tux Paint's "<code>line()</code>" 'Magic' tool plugin helper function to calculate the points of the line between (ox,oy) and (x,y), and call another function within the plugin to apply the effect at each point. (See "<a href="#tpfuncs">Tux Paint Functions and Data</a>," below).
sv: Plugins som låter användaren "rita" effekter på duken använder vanligtvis Rita med Tux's<code>"line()</code>" 'Magic' tool plugin-hjälpfunktion för att beräkna punkterna på linjen mellan (ox,oy) och (x,y), och anropar en annan funktion inom pluginet för att tillämpa effekten vid varje punkt. (Se<a href="#tpfuncs">"Rita med Tux-funktioner och data</a>" nedan).

en: Note: The contents of the drawing canvas immediately prior to the mouse button click remains as it was (when the plugin's "<code>click()</code>" function was called), and is still available in the '<code>snapshot</code>' canvas.
sv: Obs: Innehållet i ritningsytan omedelbart före musklicket förblir detsamma som det var (när plugin-programmets "<code>click()</code>"-funktion anropades) och är fortfarande tillgängligt i<code>"snapshot</code>"-ytan.

en: The plugin should apply the appropriate 'Magic' tool on the '<code>canvas</code>' surface.  The (x,y) coordinates are where the mouse was (within the canvas) when the mouse button was released.
sv: Plugin-programmet bör använda lämpligt "Magic"-verktyg på<code>"canvas"</code>-ytan.  (x,y)-koordinaterna är var musen befann sig (inom duken) när musknappen släpptes.

en: The plugin should report back what part of the canvas was affected, by filling in the (x,y) and (w,h) elements of 'update_rect'.
sv: Plugin-programmet bör rapportera tillbaka vilken del av duken som påverkades genom att fylla i elementen (x,y) och (w,h) i "update_rect".

en: <b>Note:</b> The contents of the drawing canvas immediately prior to the mouse button click remains as it was (when the plugin's "<code>click()</code>" function was called), and is still available in the 'snapshot' canvas.
sv: <b>Obs:</b> Innehållet i ritningsytan omedelbart före musklicket förblir detsamma som det var (när plugin-programmets "<code>click()</code>"-funktion anropades) och är fortfarande tillgängligt i "snapshot"-ytan.

en: Tux Paint provides a number of helper functions that plugins may access via the "<code>magic_api</code>" structure, sent to all of the plugin's functions. (See "<a href="#toolfuncs">Required Plugin Functions</a>," above.)
sv: Rita med Tux tillhandahåller ett antal hjälpfunktioner som plugins kan komma åt via strukturen<code>"magic_api</code>", som skickas till alla plugins funktioner. (Se<a href="#toolfuncs">"Obligatoriska plugin-funktioner</a>" ovan.)

en: Retreives the pixel value from the (x,y) coordinates of an SDL_Surface. (You can use SDL's "SDL_GetRGB()" function to convert the Uint32 'pixel' to a set of Uint8 RGB values.)
sv: Hämtar pixelvärdet från (x,y)-koordinaterna för en SDL_Surface. (Du kan använda SDL:s funktion "SDL_GetRGB()" för att konvertera Uint32 'pixel' till en uppsättning Uint8 RGB-värden)

en: Sets the pixel value at position (x,y) of an SDL_Surface. (You can use SDL's "SDL_MapRGB()" function to convert a set of Uint8 RGB values to a Uint32 'pixel' value appropriate to the destination surface.)
sv: Ställer in pixelvärdet vid position (x,y) för en SDL_Surface. (Du kan använda SDL:s funktion "SDL_MapRGB()" för att konvertera en uppsättning Uint8 RGB-värden till ett Uint32 "pixel"-värde som passar för destinationsytan)

en: Applies an XOR (exclusive-or) operation to the pixel at coordinates (x,y) of the SDL_Surface.  Applying an XOR again at the same position will return the pixel to the original value.  Useful for displaying temporary 'rubberband' lines, outlines, and crosshairs, while utilizing a Magic Tool.
sv: Tillämpar en XOR-operation (exklusiv-eller) på pixeln vid koordinaterna (x,y) i SDL_Surface.  Om du gör en XOR-operation igen på samma position återställs pixeln till originalvärdet.  Användbar för att visa tillfälliga "gummibandslinjer", konturer och hårkors, samtidigt som du använder ett magiskt verktyg.

en: This accepts an existing SDL surface and creates a new one scaled to an arbitrary size.  (The original surface remains untouched.)
sv: Detta accepterar en befintlig SDL-yta och skapar en ny som skalas till en godtycklig storlek.  (Den ursprungliga ytan förblir orörd.)

en: The "<code>keep_aspect</code>" flag can be set to '1' to force the new surface to stay the same shape (aspect ratio) as the original, meaning it may not be the same width and height you requested.  (Check the "<code>-&gt;w</code>" and "<code>-&gt;h</code>" elements of the output "SDL_Surface *" to determine the <i>actual</i> size.)
sv: Flaggan<code>"keep_aspect</code>" kan sättas till '1' för att tvinga den nya ytan att behålla samma form (bildförhållande) som originalet, vilket innebär att den kanske inte har samma bredd och höjd som du begärde.  (Kontrollera elementen<code>"-&gt;w</code>" och<code>"-&gt;h</code>" i utdata "SDL_Surface *" för att avgöra den <i>faktiska</i> storleken)

en: Returns '1' if the (x,y) location is within a circle of a particular radius (centered around the origin: (0,0)).  Returns '0' otherwise. Useful to create 'Magic' tools that affect the canvas with a circular brush shape.
sv: Returnerar '1' om (x,y)-positionen ligger inom en cirkel med en viss radie (centrerad runt origo: (0,0)).  Returnerar '0' i annat fall. Användbart för att skapa "magiska" verktyg som påverkar duken med en cirkulär penselform.

en: This function calculates all points on a line between the coordinates (x1,y1) and (x2,y2).  Every 'step' iterations, it calls the 'callback' function.
sv: Denna funktion beräknar alla punkter på en linje mellan koordinaterna (x1,y1) och (x2,y2).  Varje 'steg'-iteration anropar den funktionen 'callback'.

en: It sends the 'callback' function the (x,y) coordinates on the line, Tux Paint's "<code>magic_api</code>" struct (as a "<code>void *</code>" pointer which you need to send to it), a 'which' value, represening which of the plugin's 'Magic' tool is being used, and the current and snapshot canvases.
sv: Den skickar (x,y)-koordinaterna på linjen till "callback"-funktionen, Rita med Tuxs<code>"magic_api</code>"-struktur (som en<code>"void *</code>"-pekare som du måste skicka till den), ett "which"-värde som representerar vilket av plugin-programmets "Magic"-verktyg som används, och de aktuella och snapshot-bilderna.

en: Example prototype of a callback function that may be sent to Tux Paint's "<code>line()</code>" 'Magic' tool plugin helper function:
sv: Exempel på prototyp av en callback-funktion som kan skickas till Rita med Tux's<code>"line()</code>" 'Magic' tool plugin helper-funktion:

en: Example use of the "<code>line()</code>" helper (e.g., within a plugin's <code>draw()</code> function):
sv: Exempel på användning av<code>"line()</code>"-hjälpen (t.ex. inom ett plugins <code>draw()</code> -funktion):

en: This function allows you to avoid re-processing the same pixels multiple times when the user drags the mouse across an area of the canvas, thus increasing Tux Paint's response time, especially with math-heavy effects.
sv: Med den här funktionen kan du undvika att bearbeta samma pixlar flera gånger när användaren drar musen över ett område på duken, vilket ökar Rita med Tuxs svarstid, särskilt med matematiktunga effekter.

en: If your effect's "<code>click()</code>", "<code>drag()</code>" and/or "<code>release()</code>" functions take the contents of the source surface ("<code>snapshot</code>") and always create the same results in the desintation surface ("<code>canvas</code>"), you should wrap the effect in a call to "<code>api-&gt;touched()</code>".
sv: Om din effekts<code>"click(</code>)"-,<code>"drag(</code>)"- och/eller<code>"release(</code>)"-funktioner tar innehållet i källytan ("<code>snapshot</code>") och alltid skapar samma resultat i målytan (<code>"canvas</code>"), bör du linda in effekten i ett anrop till<code>"api-&gt;touched(</code>)".

en: This function simply returns whether or not it had already been called for the same (x,y) coordinates, since the user first clicked the mouse. In other words, the first time you call it for a particular (x,y) coordinate, it returns '0'.  Future calls will return '1' until the user releases the mouse button.
sv: Denna funktion returnerar helt enkelt om den redan har anropats för samma (x,y)-koordinater sedan användaren först klickade på musen. Med andra ord, första gången du anropar den för en viss (x,y)-koordinat returnerar den '0'.  Framtida anrop kommer att returnera '1' tills användaren släpper musknappen.

en: <b>Note:</b> Magic effects that continuously affect the destination surface ("<code>canvas</code>") (ignoring the "<code>snapshot</code> surface) have no reason to use this function.  The "Blur" and "Smudge" tools that ship with Tux Paint are examples of such effects.
sv: <b>Obs:</b> Magiska effekter som kontinuerligt påverkar destinationsytan (<code>"canvas</code>") (utan hänsyn till<code>"snapshotytan</code> ") har ingen anledning att använda denna funktion.  Verktygen "Blur" och "Smudge" som medföljer Rita med Tux är exempel på sådana effekter.

en: A string containing the version of Tux Paint that's running (e.g., "%s").
sv: En sträng som innehåller den version av Rita med Tux som körs (t.ex. "%s").

en: Returns the width (<code>canvas_w</code>) and height (<code>canvas_h</code>) of the drawing canvas (in pixels).
sv: Returnerar bredden<code>(canvas_w)</code> och höjden (<code>canvas_h</code>) på teckningsytan (i pixlar).

en: A '1' is returned if the mouse button is down; '0' otherwise.
sv: En '1' returneras om musknappen är nedtryckt; '0' annars.

en: This string contains the directory where Tux Paint's data files are stored.  For example, on Linux, this may be "<code>/usr/share/tuxpaint/</code>".
sv: Denna sträng innehåller den katalog där Rita med Tuxs datafiler lagras.  På Linux kan detta till exempel vara<code>"/usr/share/tuxpaint/</code>".

en: Magic tools should include an icon (see "<code>get_icon()</code>", above) and are encouraged to include sound effects, it's useful for plugins to know where such things are located.
sv: Magiska verktyg bör innehålla en ikon (se<code>"get_icon(</code>)", ovan) och uppmuntras att innehålla ljudeffekter, det är användbart för plugins att veta var sådana saker finns.

en: When compiling and installing a plugin, the "<code>tp-magic-config</code>" command-line tool should be used to determine where such data should be placed for the installed version of Tux Paint to find them. (See "<a href="#installing">Installing</a>," below.)
sv: Vid kompilering och installation av ett insticksprogram bör kommandoradsverktyget<code>"tp-magic-config</code>" användas för att avgöra var sådana data ska placeras för att den installerade versionen av Rita med Tux ska hitta dem. (Se<a href="#installing">"Installera</a>" nedan.)

en: <b>Note:</b> If your plugin is installed locally (e.g., in your "<code>~/.tuxpaint/plugins/</code>" directory), rather than globally (system-wide), the "<code>data_directory</code>" value will be different. (e.g., "<code>/home/<i>username</i>/.tuxpaint/plugins/data/</code>").
sv: <b>Obs:</b> Om ditt plugin är installerat lokalt (<code>t.</code>ex. i din katalog<code>"~/.tuxpaint/plugins/</code>"), snarare än globalt (systemövergripande), kommer värdet<code>"data_directory</code>" att vara annorlunda. (<code>t.ex. "<i>/home/användarnamn/</i>.tuxpaint/plugins/data/</code>").

en: This function plays a sound (one loaded by the SDL helper library "SDL_mixer").  It uses SDL_mixer's "<code>Mix_SetPanning()</code>" to set the volume of the sound on the left and right speakers, based on the '<code>pan</code>' and '<code>dist</code>' values sent to it.
sv: Denna funktion spelar upp ett ljud (ett som laddats av SDL-hjälpbiblioteket "SDL_mixer").  Den använder SDL_mixers<code>"Mix_SetPanning()</code>" för att ställa in ljudets volym på vänster och höger högtalare, baserat på värdena<code>"pan</code>" och<code>"dist</code>" som skickas till den.

en: A '<code>pan</code>' of 128 causes the sound to be played at equal volume on the left and right speakers.  A '<code>pan</code>' of 0 causes it to be played completely on the left, and 255 completely on the right.
sv: En<code>"pan"</code> på 128 innebär att ljudet spelas upp med samma volym i vänster och höger högtalare.  En<code>"pan</code>" på 0 gör att ljudet spelas upp helt till vänster och 255 helt till höger.

en: The '<code>dist</code>' value affects overall volume.  255 is loudest, and 0 is silent.
sv: Värdet<code>"dist"</code> påverkar den totala volymen.  255 är högst och 0 är tyst.

en: The '<code>pan</code>' and '<code>dist</code>' values can be used to simulate location and distance of the 'Magic' tool effect.
sv: Värdena<code>"pan</code>" och<code>"dist</code>" kan användas för att simulera plats och avstånd för "Magic"-verktygets effekt.

en: This function stops playing a sound played by <code>playsound()</code>. It is useful to silence effects when the user stops using the tool (in your '<code>release</code>' function).
sv: Denna funktion stoppar uppspelningen av ett ljud som spelas upp av <code>playsound().</code> Det är användbart för att tysta effekter när användaren slutar använda verktyget (i din<code>"release</code>"-funktion).

en: Call this function to determine whether a magic tool sound effect is still currently playing. Can be used by magic tools that pause and unpause their sounds (see below) to determine whether it's time to start a new sound &mdash; call %1$s instead of %2$s.
sv: Anropa denna funktion för att avgöra om en ljudeffekt från ett magiskt verktyg fortfarande spelas upp. Kan användas av magiska verktyg som pausar och avpausar sina ljud (se nedan) för att avgöra om det är dags att starta ett nytt ljud - anropa %1$s istället för %2$s.

en: A '1' is returned if a sound is playing; '0' otherwise.
sv: En "1" returneras om ett ljud spelas upp, annars en "0".

en: Pauses the magic tool sound effect; it may be unpaused to resume playing. Useful when a magic tool sound is very long; avoid repeatedly playing just a short clip of the beginning when the user draws small strokes by starting (%1$s) and stopping (%2$s) the sound. Use %3$s to determine whether you can unpause or must play from the start.
sv: Pausar ljudeffekten för det magiska verktyget; den kan avpausas för att återuppta uppspelningen. Användbart när ett magiskt verktygsljud är mycket långt; undvik att upprepade gånger spela bara ett kort klipp av början när användaren ritar små streck genom att starta (%1$s) och stoppa (%2$s) ljudet. Använd %3$s för att avgöra om du kan avbryta eller måste spela upp från början.

en: Resumes a paused magic tool sound effect, if one was playing.
sv: Återupptar en pausad ljudeffekt för det magiska verktyget, om en sådan spelades.

en: Asks Tux Paint to animate and draw one frame of its progress bar (at the bottom of the screen).  Useful for routines that may take a long time, to provide feedback to the user that Tux Paint has not crashed or frozen.
sv: Ber Rita med Tux att animera och rita en bildruta i förloppsindikatorn (längst ned på skärmen).  Användbar för rutiner som kan ta lång tid, för att ge feedback till användaren om att Rita med Tux inte har kraschat eller frusit.

en: This function notifies Tux Paint of special events.  Various values defined in "<code>tp_magic_api.h</code>" can be 'or'ed together (using C's boolean 'or': "<code>|</code>") and sent to this function.
sv: Denna funktion meddelar Rita med Tux om speciella händelser.  Olika värden som definieras i<code>"tp_magic_api.h</code>" kan kombineras (med hjälp av C:s booleska 'or':<code>"|</code>") och skickas till denna funktion.

en: The contents of the canvas has been flipped vertically.
sv: Innehållet på duken har vänts vertikalt.

en: If a 'Starter' image was used as the basis of this image, it should be flipped too, and a record of the flip should be stored as part of Tux Paint's undo buffer stack.  Additionally, the fact that the starter has been flipped (or unflipped) should be recorded on disk when the current drawing is saved.
sv: Om en "Starter"-bild användes som grund för den här bilden ska den också vändas, och en registrering av vändningen ska lagras som en del av Rita med Tuxs buffertstapel för ångerrätt.  Dessutom ska det faktum att startbilden har vänts (eller inte vänts) sparas på disken när den aktuella teckningen sparas.

en: Similar to <code>SPECIAL_FLIP</code>, but for magic tools that mirror the contents of the canvas horizontally.
sv: Liknar <code>SPECIAL_FLIP</code>, men för magiska verktyg som speglar innehållet i duken horisontellt.

en: Each time the user clicks in the canvas while using your Magic tool, a new snapshot of the canvas is added to the "Undo" history. This allows the user to click "Undo" to return the image to the state it was in just before they clicked with your Magic tool. They may click "Redo" to bring the change back.
sv: Varje gång användaren klickar i duken medan han eller hon använder Magic-verktyget läggs en ny ögonblicksbild av duken till i "Undo"-historiken. Detta gör det möjligt för användaren att klicka på "Undo" för att återställa bilden till det tillstånd den befann sig i precis innan de klickade med ditt Magic-verktyg. De kan klicka på "Redo" för att återställa ändringen.

en: However, some more sophisticated Magic tools require one or more steps to take place before the final "effect" is reached.  For example, "Filled Polygon" requires placing at least three connected points, then connecting the first and last point together, to create a shape that gets added to the canvas. In the meantime, an interactive preview of the shape &mdash; an outline with large dots representing each point &mdash; is drawn onto the canvas. (The points may be moved, or even removed, prior to finishing the shape.)
sv: Vissa mer sofistikerade Magic-verktyg kräver dock att ett eller flera steg utförs innan den slutliga "effekten" uppnås.  Till exempel kräver "Filled Polygon" att du placerar minst tre sammankopplade punkter och sedan kopplar ihop den första och den sista punkten för att skapa en form som läggs till på duken. Under tiden ritas en interaktiv förhandsgranskning av formen - en kontur med stora prickar som representerar varje punkt - på duken. (Punkterna kan flyttas, eller till och med tas bort, innan formen är klar)

en: The <code>retract_undo()</code> API function may be used by a Magic tool to tell it to discard the "Undo" snapshot it just took, as a way to prevent previews shown during multi-step actions from appearing on the canvas when using the "Undo" and "Redo" commands.
sv: API-funktionen <code>retract_undo()</code> kan användas av ett Magic-verktyg för att beordra det att kasta bort den "Undo"-bild som det just tog, som ett sätt att förhindra att förhandsvisningar som visas under åtgärder i flera steg visas på duken när kommandona "Undo" och "Redo" används.

en: This is an advanced feature.
sv: Detta är en avancerad funktion.

en: Converts an 8-bit sRGB value (one between 0 and 255) to a linear floating point value (between 0.0 and 1.0).
sv: Konverterar ett 8-bitars sRGB-värde (ett värde mellan 0 och 255) till ett linjärt flyttalsvärde (mellan 0,0 och 1,0).

en: Converts a linear floating point value (one between 0.0 and 1.0) to an 8-bit sRGB value (between 0 and 255).
sv: Konverterar ett linjärt flyttalsvärde (ett värde mellan 0,0 och 1,0) till ett 8-bitars sRGB-värde (mellan 0 och 255).

en: Converts 8-bit sRGB values (between 0 and 255) to floating-point HSV (Hue, Saturation and Value) values (Hue between 0.0 and 360.0, and Saturation and Value between 0.0 and 1.0).
sv: Konverterar 8-bitars sRGB-värden (mellan 0 och 255) till HSV-värden (Hue, Saturation och Value) med flyttal (Hue mellan 0,0 och 360,0, och Saturation och Value mellan 0,0 och 1,0).

en: Converts floating-point HSV (Hue, Saturation and Value) values (Hue between 0.0 and 360.0, and Saturation and Value between 0.0 and 1.0) to 8-bit sRGB values (between 0 and 255).
sv: Konverterar HSV-värden (Hue, Saturation och Value) med flyttal (Hue mellan 0,0 och 360,0 och Saturation och Value mellan 0,0 och 1,0) till 8-bitars sRGB-värden (mellan 0 och 255).

en: For more information, refer to the <a href="http://en.wikipedia.org/wiki/SRGB">sRGB article at Wikipedia</a> and the <a href="http://en.wikipedia.org/wiki/HSV_color_space">HSV Color Space article at Wikipedia</a>.
sv: Mer information finns i <a href="http://en.wikipedia.org/wiki/SRGB">artikeln om sRGB på Wikipedia</a> och <a href="http://en.wikipedia.org/wiki/HSV_color_space">artikeln om HSV-färgrymden på Wikipedia.</a>.

en: Along with the "<code>magic_api</code>" C structure containing functions and data described above, the <code>tp_magic_api.h</code> C header file also contains some helper macros that you may use.
sv: Förutom C-strukturen<code>"magic_api</code>" som innehåller funktioner och data som beskrivs ovan, innehåller C-huvudfilen <code>tp_magic_api.h</code> också några hjälpmakron som du kan använda.

en: The minimum (<code>min</code>) or maxinum (<code>max</code>) of 'x' and 'y'.  For example, <code>min()</code> will return the value of 'x' if it is less than or equal to 'y', otherwise it will return 'y'.
sv: Minimum<code>(min)</code> eller maximum<code>(max)</code> av 'x' och 'y'.  Till exempel kommer <code>min()</code> att returnera värdet på 'x' om det är mindre än eller lika med 'y', annars kommer det att returnera 'y'.

en: A value, clamped to be no smaller than 'lo', and no higher than 'hi'. (That is, if 'value' is less than 'lo', then 'lo' will be used; if 'value' is greater than 'hi', then 'hi' will be used; otherwise, 'value' will be used.)
sv: Ett värde som inte får vara mindre än "lo" och inte högre än "hi". (Det vill säga, om "värde" är mindre än "lo", används "lo"; om "värde" är större än "hi", används "hi"; i annat fall används "värde")

en: <b>Example:</b> <code>red = clamp(0, n, 255);</code> will set the variable 'red' to be the value of the variable 'n', but without allowing it to become less than 0 or greater than 255.
sv: <b>Exempel:</b> <code>red = clamp(0, n, 255);</code> kommer att sätta variabeln "red" till värdet av variabeln "n", men utan att tillåta att den blir mindre än 0 eller större än 255.

en: <b>Note:</b> This macro is simply a <code>#define</code> of: "<code>(min(max(value,lo),hi))</code>".
sv: <b>Observera:</b> Detta makro är helt enkelt en <code>#definition</code> av: "<code>(min(max(värde,lo),hi))".</code>.

en: The following is a summary of constant values that are set (via "<code>#define</code>") within the 'Magic' tool API header file.
sv: Följande är en sammanfattning av de konstantvärden som ställs in (via<code>"#define</code>") i huvudfilen för verktygs-API:et 'Magic'.

en: This integer value represents which version of the Tux Paint 'Magic' tool API the header corresponds to.
sv: Detta heltalsvärde representerar vilken version av Rita med Tux 'Magic' tool API som rubriken motsvarar.

en: It should be referenced by your magic tool's "<code>api_version()</code>" function, to inform the running copy of Tux Paint whether or not your plugin is compatible.
sv: Det bör refereras till av ditt magiska verktygs<code>"api_version()"</code>-funktion, för att informera den löpande kopian av Rita med Tux om ditt plugin är kompatibelt eller inte.

en: <b>Note:</b> This version number does not correspond to Tux Paint's own release number (e.g., "%s").  The API will not change every time a new version of Tux Paint is released, which means plugins compiled for earlier versions of Tux Paint will often run under newer versions.
sv: <b>Obs:</b> Detta versionsnummer motsvarar inte Rita med Tux's eget versionsnummer (t.ex. "%s").  API:et kommer inte att ändras varje gång en ny version av Rita med Tux släpps, vilket innebär att plugins som kompilerats för tidigare versioner av Rita med Tux ofta kommer att köras under nyare versioner.

en: These are flags for Tux Paint's "<code>special_notify()</code>" helper function.  They are described <a href="#special_notify">above</a>.
sv: Dessa är flaggor för Rita med Tuxs hjälpfunktion<code>"special_notify()</code>".  De beskrivs <a href="#special_notify">ovan</a>.

en: Use the C compiler's "<code>-shared</code>" command-line option to generate a shared object file ("<code>.so</code>") based on your 'Magic' tool plugin's C source code.
sv: Använd C-kompilatorns kommandoradsalternativ<code>"-shared</code>" för att generera en fil med delade objekt ("<code>.so</code>") baserat på C-källkoden för ditt verktygsplugin 'Magic'.

en: Use the "<code>tp-magic-config --cflags</code>" command, supplied as part of Tux Paint &mdash; or in some cases, as part of a "Tux Paint 'Magic' Tool Plugin Development package" &mdash; to provide additional command-line flags to your C compiler that will help it build your plugin.
sv: Använd kommandot<code>"tp-magic-config --cflags</code>", som levereras som en del av Rita med Tux - eller i vissa fall som en del av ett "Rita med Tux 'Magic' Tool Plugin Development package" - för att tillhandahålla ytterligare kommandoradsflaggor till din C-kompilator som hjälper den att bygga ditt plugin.

en: Command-Line Example
sv: Exempel på kommandoraden

en: As a stand-alone command, using the GNU C Compiler and BASH shell, for example:
sv: Som ett fristående kommando, till exempel med GNU C-kompilatorn och BASH-skalet:

en: <a name="grave"><b>Note:</b></a> The characters around the "<code>tp-magic-config</code>" command are a grave/backtick/backquote ("<code><b><font size=+1>`</font></b></code>"), and not an apostrophe/single-quote ("<code><b><font size=+1>'</font></b></code>"). They tell the shell to execute the command within (in this case, "<code>tp-magic-config ...</code>"), and use its output as an argument to the command being executed (in this case, "<code>gcc ...</code>").
sv: <a name="grave"><b>Observera:</b></a> Tecknen runt kommandot<code>"tp-magic-config</code>" är en grav/backtick/backquote ("<code><b><font size=+1>`</font></b></code>"), och inte en apostrof/enkel citationstecken ("<code><b><font size=+1>'</font></b></code>"). De talar om för skalet att det ska utföra kommandot i kommandot (i det här fallet<code>"tp-magic-config .</code>..") och använda resultatet som ett argument till kommandot som ska utföras (i det här fallet<code>"gcc</code>...").

en: Makefile Example
sv: Makefile Exempel

en: A snippet from a Makefile to compile a Tux Paint "Magic" tool plugin might look like this:
sv: Ett utdrag från en Makefile för att kompilera en Rita med Tux "Magic" tool plugin kan se ut så här:

en: The first line sets up Makefile variable ("<code>CFLAGS</code>") that contains flags for the compiler. "<code>-Wall</code>" asks for all compiler warnings to be shown.  "<code>-O2</code>" asks for level 2 optimization. "<code>($shell tp-magic-config --cflags)</code>" runs "<code>tp-magic-config</code>" to retrieve additional compiler flags that "Magic" tool plugins require.  (The "<code>$(shell ...)</code>" directive is similar to the <a href="#grave"><b><font size=+1>`</font></b> ("grave")</a> character in the BASH shell examples, above.)
sv: Den första raden sätter upp Makefile-variabeln ("<code>CFLAGS</code>") som innehåller flaggor för kompilatorn.<code>"-Wall</code>" ber om att alla kompilatorvarningar ska visas. <code>"-O2</code>" begär optimering på nivå 2. "<code>($shell tp-magic-config --cflags)"</code> kör<code>"tp-magic-config</code>" för att hämta ytterligare kompilatorflaggor som "Magic"-verktygets insticksprogram kräver.  (Direktivet "$<code>(shell ...)</code>" liknar tecknet <a href="#grave"><b><font size=+1>`</font></b> ("grav")</a> i BASH-skalexemplen ovan)

en: The next line defines a Makefile target, "<code>my_plugin.so</code>", and states that it <i>depends on</i> the C source file "<code>my_plugin.c</code>".  (Any time the C file changes, "<code>make</code>" will know to recompile it and produce an updated "<code>.so</code>" file. If the C file hadn't changed, it won't bother recompiling.)
sv: På nästa rad definieras ett Makefile-mål,<code>"my_plugin.so</code>", och det anges att det är <i>beroende av</i> C-källfilen<code>"my_plugin.c</code>".  (Varje gång C-filen ändras vet<code>"make</code>" att den ska kompileras om och producera en uppdaterad "<code>.so</code>"-fil. Om C-filen inte hade ändrats skulle den inte bry sig om att kompilera om)

en: The last line defines the command "<code>make</code>" should run when it determines that it needs to (re)compile the "<code>.so</code>" file.  Here, we're using "<code>gcc</code>", with "<code>-shared</code> and "<code>$(CFLAGS)</code>" command-line arguments, like above. "<code>-o my_plugin.so</code>" tells the C compiler that the output file should be "<code>my_plugin.so</code>".  The last argument is the C file to compile, in this case "<code>my_plugin.c</code>".
sv: Den sista raden definierar det kommando som<code>"make</code>" ska köra när det bestämmer att det behöver (om)kompilera filen "<code>.so</code>".  Här använder vi<code>"gcc</code>", med kommandoradsargumenten<code>"-shared</code> och<code>"$(CFLAGS</code>)", som ovan.<code>"-o my_plugin.so</code>" talar om för C-kompilatorn att utdatafilen ska vara<code>"my_plugin</code>.<code>so</code>".  Det sista argumentet är C-filen som ska kompileras, i det här fallet<code>"my_plugin.c</code>".

en: <b>Note:</b> Commands listed below a Makefile target should be intented using a single <b>tab</b> character.
sv: <b>Observera:</b> Kommandon som listas under ett Makefile-mål ska anges med ett enda <b>tabbtecken</b>.

en: Advanced Makefile
sv: Avancerad Makefile

en: An even more generalized Makefile might look like this:
sv: En ännu mer generaliserad Makefile kan se ut så här:

en: As before, there are lines that define the command "<code>make</code>" should run when it determines that it needs to (re)compile the "<code>.so</code>" file(s).  However, more general terms are used...
sv: Precis som tidigare finns det rader som definierar kommandot som<code>"make</code>" ska köra när det upptäcker att det behöver (om)kompilera "<code>.so</code>"-filen/filerna.  Här används dock mer allmänna termer...

en: "<code>$(CC)</code>" gets expanded to your default C compiler (e.g., "<code>gcc</code>").  "<code>-shared</code>" and "<code>$(CFLAGS)</code>" are command-line arguments to the compiler, like above. "<code>-o $@</code>" tells the C compiler what the output file should be; "<code>make</code>" replaces "<code>$@</code>" with the name of the target, in this case "<code>my_plugin_1.so</code>" or "<code>my_plugin_2.so</code>". And finally, the last argument is the C file to compile; "<code>make</code>" replaces "<code>$&lt;</code>" with the target's dependency, in this case "<code>my_plugin_1.c</code>" or "<code>my_plugin_2.c</code>".
sv: <code>"$(CC)</code>" utökas till din standardkompilator för C (t.ex.<code>"gcc</code>"). <code>"-shared</code>" och<code>"$(CFLAGS</code>)" är kommandoradsargument till kompilatorn, som ovan.<code>"-o $@</code>" talar om för C-kompilatorn vad utdatafilen ska vara;<code>"make</code>" ersätter<code>"$@</code>" med namnet på målet, i det här fallet<code>"my_plugin_1.so</code>" eller<code>"my_plugin_2</code>.<code>so</code>". Och slutligen är det sista argumentet den C-fil som ska kompileras; "<code>make</code>" ersätter<code>"$&lt;</code>" med målets beroende, i det här fallet<code>"my_plugin_1</code>.c" eller<code>"my_plugin_2</code>.c".

en: Use the "<code>tp-magic-config</code>" command-line tool, supplied as part of Tux Paint &mdash; or in some cases, as part of a "Tux Paint 'Magic' Tool Plugin Development package" &mdash; to determine where your plugins' files should go.
sv: Använd kommandoradsverktyget<code>"tp-magic-config</code>", som levereras som en del av Rita med Tux - eller i vissa fall som en del av ett "Rita med Tux 'Magic' Tool Plugin Development package" - för att bestämma var dina plugins filer ska placeras.

en: Shared Object
sv: Delat objekt

en: Use "<code>tp-magic-config --pluginprefix</code>" to determine where the plugin shared object ("<code>.so</code>") files should be installed.  The value returned by this command will be the global location where the installed copy of Tux Paint looks for plugins (e.g., "<code>/usr/lib/tuxpaint/plugins</code>").
sv: Använd<code>"tp-magic-config --pluginprefix</code>" för att bestämma var plugin shared object ("<code>.so</code>")-filerna ska installeras.  Det värde som returneras av detta kommando är den globala plats där den installerade kopian av Rita med Tux letar efter insticksprogram (<code>t.ex. "/usr/lib/tuxpaint/plugins</code>").

en: Alternatively, you may use "<code>tp-magic-config --localpluginprefix</code>" to find out where Tux Paint expects to find local plugins for the current user (e.g., "<code>/home/<i>username</i>/.tuxpaint/plugins</code>").
sv: Alternativt kan du använda<code>"tp-magic-config --localpluginprefix</code>" för att ta reda på var Rita med Tux förväntar sig att hitta lokala plugins för den aktuella användaren (<code>t.ex. "<i>/home/username/</i>.tuxpaint/plugins</code>").

en: As stand-alone commands, using the BASH shell, for example:
sv: Som fristående kommandon, t.ex. i BASH-skalet:

en: <b>Note:</b> See the <a href="#grave">note above regarding the "<font size=+1><b>`</b></font>" (grave) character</a>.
sv: <b>Obs:</b> Se <b>anmärkningen</b> <a href="#grave">ovan angående tecknet "<font size=+1><b>`"</b></font>(grav).</a>.

en: Documentation
sv: Dokumentation

en: Use the "<code>tp-magic-config --plugindocprefix</code>" command to determine where documentation for your "Magic" tools should go. The value returned by this command will be the location where the documentation to the installed copy of Tux Paint is stored. The main documentation includes a link to a folder where "Magic" tools' documentation is expected to be installed</p> (e.g., "<code>/usr/share/doc/tuxpaint/magic-docs</code>").
sv: Använd kommandot<code>"tp-magic-config --plugindocprefix</code>" för att bestämma var dokumentationen för dina "Magic"-verktyg ska placeras. Det värde som returneras av detta kommando är den plats där dokumentationen till den installerade kopian av Rita med Tux lagras. Huvuddokumentationen innehåller en länk till en mapp där dokumentationen för "Magic"-verktygen förväntas installeras</p> (<code>t.ex. "/usr/share/doc/tuxpaint/magic-docs</code>").

en: <b>Note:</b> It's best to include both HTML and plain-text versions of your documentation.  An "<code>html</code>" subdirectory exists within the "<code>magic-docs</code>" directory, and is where the HTML versions should go.
sv: <b>Observera:</b> Det är bäst att inkludera både HTML- och klartextversioner av din dokumentation.  Det finns en underkatalog<code>"html</code>" i katalogen<code>"magic-docs</code>", och det är där HTML-versionerna ska läggas.

en: <b>Note:</b> Currently, there is no "<code>--localplugindocprefix</code>" option.
sv: <b>Observera:</b> För närvarande finns det inget alternativ<code>"--localplugindocprefix</code>".

en: Icons, Sounds and other Data Files
sv: Ikoner, ljud och andra datafiler

en: Use the "<code>tp-magic-config --dataprefix</code>" command, supplied as part of Tux Paint, to determine where data files (PNG icon, Ogg Vorbis sound effects, etc.) should be installed. The value returned by this command will be the same as the value of the "<code>data_directory</code>" string stored within the "<code>magic_api</code>" structure that your plugin's functions receive (e.g., "<code>/usr/share/tuxpaint/</code>").
sv: Använd kommandot<code>"tp-magic-config --dataprefix</code>", som ingår i Rita med Tux, för att bestämma var datafiler (PNG-ikoner, Ogg Vorbis-ljudeffekter etc.) ska installeras. Värdet som returneras av detta kommando kommer att vara detsamma som värdet på strängen<code>"data_directory</code>" som lagras i strukturen<code>"magic_api</code>" som funktionerna i ditt insticksprogram tar emot (<code>t.ex. "/usr/share/tuxpaint/</code>").

en: For locally-installed plugins (for the current user only), use "<code>tp-magic-config --localdataprefix</code>".  It will return the value of "<code>data_directory</code>" string that locally-installed plugins will see within their "<code>magic_api</code>" structure (e.g., "<code>/home/<i>username</i>/.tuxpaint/plugins/data/</code>").
sv: För lokalt installerade insticksprogram (endast för den aktuella användaren) använder du<code>"tp-magic-config --localdataprefix</code>".  Den returnerar värdet på strängen<code>"data_directory</code>" som lokalt installerade insticksprogram ser i sin<code>"magic_api</code>"-struktur (<code>t.ex. "<i>/home/username/</i>.tuxpaint/plugins/data/</code>").

en: <b>Note:</b> Tux Paint's default Magic tool plugins install their data within "<code>magic</code>" subdirectories of Tux Paint's "<code>images</code>" and "<code>sounds</code>" data directories (e.g., "<code>/usr/share/tuxpaint/images/magic/</code>").  You are encouraged to do the same.
sv: <b>Observera:</b> Rita med Tuxs standardinsticksprogram för verktyget Magic installerar sina data i underkatalogerna<code>"magic</code>" i Rita med Tuxs datakataloger<code>"images</code>" och<code>"sounds</code>" (<code>t.ex. "/usr/share/tuxpaint/images/magic/</code>").  Vi uppmuntrar dig att göra detsamma.

en: Putting it Together in a Makefile
sv: Sammanställa allt i en Makefile

en: A snippet from a more generalized Makefile might look like this:
sv: Ett utdrag från en mer generell Makefile kan se ut så här:

en: The first three lines set up Makefile variables that contain the paths returned by the "<code>tp-magic-config</code>" command-line tool. (The "<code>$(shell ...)</code>" directive is similar to the <a href="#grave"><b><font size=+1>`</font></b> ("grave")</a> character in the BASH shell examples, above.)
sv: De tre första raderna ställer in Makefile-variabler som innehåller de sökvägar som returneras av kommandoradsverktyget<code>"tp-magic-config</code>". (Direktivet<code>"$(shell ...)</code>" liknar tecknet <a href="#grave"><b><font size=+1>`</font></b> ("grave")</a> i BASH-skalexemplen ovan)

en: Below that is an "<code>install</code>" target in the Makefile. (Invoked by, for example, "<code>$ sudo make install</code>" or "<code># make install</code>".)
sv: Under det finns ett<code>"install</code>"-mål i Makefile. (Påkallas av till exempel<code>"$ sudo make install</code>" eller<code>"# make install</code>")

en: The "<code>install</code>" target uses "<code>mkdir -p</code>" to make sure that the plugin directory exists, then uses "<code>cp</code>" to copy all plugin ("<code>.so</code>") files into it, and invokes "<code>chmod</code>" to make sure they are readable.
sv: Målet<code>"install</code>" använder<code>"mkdir -p</code>" för att se till att plugin-katalogen finns, använder sedan<code>"cp</code>" för att kopiera alla plugin ("<code>.so</code>")-filer till den och anropar<code>"chmod</code>" för att se till att de är läsbara.

en: It then does a similar series of commands to install icon files ("<code>.png</code>" images) and sound effects ("<code>.ogg</code>" files) into subdirectories within Tux Paint's data directory, and to install documentation ("<code>.html</code>" and "<code>.txt</code>" files) within Tux Paint's documentation directory.
sv: Därefter utförs en liknande serie kommandon för att installera ikonfiler ("<code>.png</code>"-bilder) och ljudeffekter ("<code>.ogg</code>"-filer) i underkataloger i Rita med Tuxs datakatalog och för att installera dokumentation ("<code>.html</code>"- och "<code>.txt</code>"-filer) i Rita med Tuxs dokumentationskatalog.

en: <b>Note:</b> The above Makefile example assumes the user will have priveleges to install Tux Paint plugins system-wide.
sv: <b>Obs:</b> Makefile-exemplet ovan förutsätter att användaren har behörighet att installera Rita med Tux-plugins i hela systemet.

en: Plugins for Tux Paint may contain more than one effect.  If you have multiple effects that are similar, it may make sense to place them in one plugin file, to reduce overhead and share code.
sv: Plugins för Rita med Tux kan innehålla mer än en effekt.  Om du har flera effekter som liknar varandra kan det vara vettigt att placera dem i en plugin-fil för att minska overhead och dela kod.

en: These following suggestions can help you create plugins that contain multiple effects:
sv: Följande förslag kan hjälpa dig att skapa plugins som innehåller flera effekter:

en: Use a C "<code>enum</code>" to enumerate the effects, and count them.
sv: Använd C<code>"enum</code>" för att räkna upp effekterna och räkna dem.

en: ONE_TOOL
sv: ETT_VERKTYG

en: ANOTHER_TOOL
sv: ANNAT_VERKTYG

en: AND_YET_ANOTHER_TOOL
sv: OCH_YTTERLIGARE_ETT_VERKTYG

en: Return the value of "<code>NUM_TOOLS</code>" when "<code>get_tool_count()</code>" is called, and compare "<code>which</code>" values sent to other functions with the other enumerated values.
sv: Returnera värdet på<code>"NUM_TOOLS</code>" när<code>"get_tool_count()</code>" anropas, och jämför<code>"which"</code>-värden som skickas till andra funktioner med de andra uppräknade värdena.

en: Create arrays of "<code>NUM_TOOLS</code>" length to contain effect-specific data.
sv: Skapa arrayer av längden<code>"NUM_TOOLS</code>" för att innehålla effektspecifika data.

en: my_plugin_snd_filenames[%s]
sv: my_plugin_snd_filnamn[%s]

en: my_plugin_snds
sv: min_plugin_snds

en: Use a C "<code>for</code>"-loop to load or create the effect-specific data (such as loading sound effects during your "<code>init()</code>").
sv: Använd en C<code>"for</code>"-loop för att ladda eller skapa effektspecifika data (t.ex. ladda ljudeffekter under din<code>"init()</code>").

en: Becomes, for example, %s
sv: Blir till exempel %s

en: Similarly, do the same to free them later (such as freeing sound effects during your "<code>shutdown()</code>").
sv: På samma sätt kan du göra för att frigöra dem senare (t.ex. frigöra ljudeffekter under din<code>"shutdown()</code>").

en: Use "<code>which</code>" values sent to your functions as an index into those arrays (e.g., for playing the appropriate sound effect for a tool).
sv: Använd<code>"which"</code>-värden som skickas till dina funktioner som ett index i dessa matriser (t.ex. för att spela upp lämplig ljudeffekt för ett verktyg).

en: <b>Note:</b> Even if your plugin currently contains only one effect, it may be useful to follow the steps above so that you can add a new variation of an effect with little effort.  ("<code>NUM_TOOLS</code>" will simply be '1', your arrays will be of length '1', etc.)
sv: <b>Observera:</b> Även om ditt plugin för närvarande bara innehåller en effekt, kan det vara bra att följa stegen ovan så att du kan lägga till en ny variant av en effekt med liten ansträngning.  ("<code>NUM_TOOLS</code>" kommer helt enkelt att vara '1', dina arrayer kommer att ha längden '1', etc.)

en: For more information, check the Tux Paint website: <a href="https://tuxpaint.org/">https://tuxpaint.org/</a>, and the Simple DirectMedia Layer library website: <a href="http://www.libsdl.org/">http://www.libsdl.org/</a>.
sv: Mer information finns på webbplatsen för Rita med Tux: <a href="https://tuxpaint.org/">https://tuxpaint.org/</a> och på webbplatsen för biblioteket Simple DirectMedia Layer: <a href="http://www.libsdl.org/">http://www.libsdl.org/.</a>.

en: Additionally, other Tux Paint developers and users can be found on the "<code>tuxpaint-devel</code>" and "<code>tuxpaint-users</code>" mailing lists: <a href="https://tuxpaint.org/lists/">https://tuxpaint.org/lists/</a>.
sv: Dessutom finns andra utvecklare och användare av Rita med Tux på e-postlistorna<code>"tuxpaint-devel</code>" och<code>"tuxpaint-users</code>": <a href="https://tuxpaint.org/lists/">https://tuxpaint.org/lists/.</a>.

en: See "%s"
sv: Se "%s"

en: Refer to the "<code>%s</code>" <i>man page</i>.
sv: Se manuskriptet "<code>%s</code>" <i>man page</i>.

en: Definition not yet presented.
sv: Definitionen har ännu inte presenterats.

en: alpha
sv: alfa

en: grave
sv: grav

en: red
sv: röd

en: green
sv: grön

en: blue
sv: blå

en: hue
sv: nyans

en: saturation
sv: mättnad

en: value
sv: värde

en: boolean 'or'
sv: boolean 'eller'

en: dot
sv: punkt

en: star
sv: stjärna

en: arrow
sv: pil

en: C header file
sv: C-huvudfil

en: header
sv: sidhuvud

en: header file
sv: huvudfil

en: pointers
sv: pekare

en: "<code>&amp;</code>". A symbol in C that allows you to refer to the memory address of a variable; that is, a pointer. (For example, consider "<code>int i;</code>". Later, "<code>&amp;i</code>" refers to the memory where "<code>i</code>" is stored, not the value of "<code>i</code>" itself; it is a 'pointer to "<code>i</code>"'.)
sv: <code>"&amp;"</code>. En symbol i C som gör det möjligt att referera till minnesadressen för en variabel, dvs. en pekare. (Tänk till exempel på<code>"int i;</code>". Senare hänvisar<code>"&amp;i</code>" till minnet där "<code>i</code>" är lagrat, inte värdet på "<code>i</code>" i sig; det är en "pekare till<code>"i</code>"")

en: bitwise operator
sv: bitvis operator

en: "<code>&amp;</code>". A symbol in C that acts as a bitwise "and" operator. Only bits set in both values will be returned. For example, "<code>11 &amp; 6</code>" compares the binary values '1011' to '0110'. Only the bit in the 2's place is set, so the result is <code>2</code> ('0010').
sv: <code>"&amp;"</code>. En symbol i C som fungerar som en bitvis "och"-operator. Endast bitar som är inställda i båda värdena returneras. Till exempel jämför<code>"11 &amp; 6</code>" de binära värdena '1011' med '0110'. Endast biten på 2:ans plats är inställd, så resultatet blir <code>2</code> ('0010').

en: Application Programming Interface.
sv: Gränssnitt för applikationsprogrammering.

en: A value sent to a function.
sv: Ett värde som skickas till en funktion.

en: "<code>-&gt;</code>". A symbol in C that references an element within a pointer to a struct.
sv: <code>"-&gt;"</code>. En symbol i C som refererar till ett element inom en pekare till en struktur.

en: "Binary digit." Bits are the basic storage unit in a computer's memory, disk, networking, etc. They represent either 0 or 1. (Compared to a decimal digit, which can be anything between 0 and 9.) Just as a series of decimal digits can represent a larger number (e.g., "1" and "5" is fifteen (15)), so can bits (e.g., "1" and "0", is two). In decimal, we go from right to left: ones place, tens place, hundreds place, thousands place, etc. In binary, it is: ones place, twos place, fours place, eights place, etc.
sv: "Binär siffra." Bitar är den grundläggande lagringsenheten i en dators minne, disk, nätverk etc. De representerar antingen 0 eller 1. (Jämfört med en decimalsiffra, som kan vara allt mellan 0 och 9.) Precis som en serie decimalsiffror kan representera ett större tal (t.ex. "1" och "5" är femton (15)), kan även bitar göra det (t.ex. "1" och "0" är två). I decimal går vi från höger till vänster: ettor, tior, hundratal, tusental osv. I binära tal är det: ettor, tvåor, fyror, åttor osv.

en: A mathematical operation that results in a true value if either operand is true. ("1 | 0", "0 | 1" and "1 | 1" all result in "1". "0 | 0" results in "0".)
sv: En matematisk operation som resulterar i ett sant värde om en av operanderna är sann. ("1 | 0", "0 | 1" och "1 | 1" resulterar alla i "1". "0 | 0" resulterar i "0")

en: A unit of memory made up of 8 bits. As a signed value, it can represent -128 through 127. As an unsigned value, it can represent 0 through 255. As a series of bits, for example, the byte "00001100" represents the decimal value 12.
sv: En minnesenhet som består av 8 bitar. Som ett signerat värde kan det representera -128 till 127. Som osignerat värde kan det representera 0 till 255. Som en serie bitar representerar t.ex. byten "00001100" det decimala värdet 12.

en: callback
sv: återuppringning

note: FIXME
en: C function
sv: C-funktion

note: FIXME
en: C function prototype
sv: Prototyp för C-funktion

en: prototype
sv: prototyp

en: function
sv: funktion

en: C enumeration
sv: C-uppräkning

en: A construct in C that allows you to label numeric values (usually starting at 0 and incrementing by one). (e.g., "<code>enum { ONE, TWO, THREE };</code>"
sv: En konstruktion i C som gör det möjligt att märka numeriska värden (som vanligtvis börjar på 0 och ökar med ett). (t.ex.<code>"enum { ONE, TWO, THREE };</code>"

en: channel
sv: kanal

en: click
sv: klick

en: The action of pressing a button on a mouse, tapping a touchscreen, or pressing a stylus to a tablet.
sv: Att trycka på en knapp på en mus, trycka på en pekskärm eller trycka en penna mot en surfplatta.

en: drag
sv: dra

en: release
sv: utgåva

en: tap
sv: peka

en: coordinates
sv: koordinater

en: A set of numbers corresponding to a physical position; for example, in a two-dimensional (2D) image, "X" and "Y" coordinates specify the position across (left-to-right) and down the image, respectively. In SDL, the coordinates (0,0) is the top-leftmost pixel of a surface.
sv: En uppsättning siffror som motsvarar en fysisk position; till exempel i en tvådimensionell (2D) bild anger "X"- och "Y"-koordinaterna positionen tvärs över (från vänster till höger) respektive nedåt i bilden. I SDL är koordinaterna (0,0) den längst upp till vänster belägna pixeln på en yta.

en: dimensions
sv: dimensioner

en: C pointer
sv: C-pekare

en: A variable that contains the location of a piece of memory; usually used to 'point' to another variable. Since C functions can only return one value as a result, pointers are often sent to functions to allow the function to change the values of multiple variables. (For example, Tux Paint's "<code>rgbtohsv()</code>" and "<code>hsvtorgb()</code>".)
sv: En variabel som innehåller platsen för en del av minnet; används vanligtvis för att "peka" på en annan variabel. Eftersom C-funktioner bara kan returnera ett värde som resultat, skickas ofta pekare till funktioner för att funktionen ska kunna ändra värdena för flera variabler. (Till exempel Rita med Tuxs<code>"rgbtohsv()</code>" och<code>"hsvtorgb()</code>")

note: Name of a void* pointer sent to API functions by Tux Paint
en: pointer
sv: pekare

note: FIXME
en: C structure
sv: C-struktur

en: A construct in C that allows you to declare a new variable 'type' which may contain other types within. For example, SDL's "<code>SDL_Rect</code>" contains four integer values, the coordinates of the rectangle (X,Y), and its dimensions (width and height).
sv: En konstruktion i C som gör att du kan deklarera en ny variabel "typ" som kan innehålla andra typer. SDL:s<code>"SDL_Rect</code>" innehåller till exempel fyra heltalsvärden, rektangelns koordinater (X,Y) och dess dimensioner (bredd och höjd).

en: A C statement that defines a substitution that can occur later in the code. Generally used for constant values (e.g., "<code>#define RADIUS 16</code>"; all instances of "<code>RADIUS</code>" will be replaced with "<code>16</code>"), but can also be used to create macros. Typically placed within C header files.
sv: En C-sats som definierar en substitution som kan förekomma senare i koden. Används vanligen för konstanta värden (t.ex. "<code>#define RADIUS 16</code>"; alla förekomster av<code>"RADIUS</code>" ersätts med<code>"16</code>"), men kan också användas för att skapa makron. Placeras vanligtvis i C-headerfiler.

en: The size of an object, in terms of its width (left to right) and height (top to bottom).
sv: Ett objekts storlek i form av dess bredd (från vänster till höger) och höjd (uppifrån och ned).

en: "<code>.</code>". A symbol in C that references an element within a struct.
sv: "<code>.</code>". En symbol i C som refererar till ett element inom en struktur.

en: The action of moving a mouse while the button remains held, or moving a finger or stylus across a screen or tablet, without removing it.
sv: Att flytta en mus medan knappen hålls intryckt, eller att flytta ett finger eller en penna över en skärm eller surfplatta utan att ta bort den.

en: The action of releasing a mouse button, or removing a finger or stylus from a screen or tablet.
sv: Att släppa en musknapp eller att ta bort ett finger eller en pekpenna från en skärm eller surfplatta.

en: A variable stored within a C structure. (Example: "<code>w</code>" and "<code>h</code>" elements of SDL_Surface store the surface's width and height, respectively.)
sv: En variabel som lagras inom en C-struktur. (Exempel: elementen<code>"w</code>" och<code>"h</code>" i SDL_Surface lagrar ytans bredd respektive höjd)

note: FIXME
en: floating point
sv: flyttal

note: FIXME
en: integer
sv: heltal

en: An <code>SDL_Surface</code> element (a pointer to an <code>SDL_PixelFormat</code> structure) that contains information about a surface; for example, the number of bits used to represent each pixel).
sv: Ett <code>SDL_Surface-element</code> (en pekare till en <code>SDL_PixelFormat-struktur</code> ) som innehåller information om en yta, t.ex. antalet bitar som används för att representera varje pixel.)

en: A C function that frees (deallocates) memory allocated by other C functions (such as "<code>strdup()</code>").
sv: En C-funktion som frigör (deallokerar) minne som allokerats av andra C-funktioner (t.ex. "<code>strdup(</code>)").

en: GNU C Compiler
sv: GNU C-kompilator

en: The GNU C compiler, a portable Open Source package for compiling and linking programs written in the C programming language.
sv: GNU C-kompilatorn, ett portabelt Open Source-paket för kompilering och länkning av program skrivna i programspråket C.

en: GNU Image Manipulation Program, an Open Source image manipulation and paint program.
sv: GNU Image Manipulation Program, ett bildmanipulerings- och färgprogram med öppen källkod.

en: An Open Source image manipulation and paint program.
sv: Ett bildmanipulerings- och färgprogram med öppen källkod.

en: The "<code><font size=+1>`</font></code>" character; used by the BASH shell to use the output of a command as the command-line arguments to another.
sv: Den "<code><font size=+1>`</font></code>"; används av BASH-skalet för att använda utdata från ett kommando som kommandoradsargument för ett annat.

en: The "Bourne Again Shell", a Unix shell and command language.
sv: "Bourne Again Shell", ett skal- och kommandospråk för Unix.

en: shell
sv: skal

en: Hue, Saturation and Value.
sv: Färgton, mättnad och värde.

note: FIXME
en: colorspace
sv: färgrymd

en: Red, Green, Blue, and Alpha.
sv: Röd, grön, blå och alfa.

en: An SDL_image function that loads an image file (e.g., a PNG) and returns it as an "<code>SDL_Surface *</code>".
sv: En SDL_image-funktion som laddar en bildfil (t.ex. en PNG) och returnerar den som en<code>"SDL_Surface *</code>".

en: A C statement that asks the compiler to read the contents of another file (usually a header file).
sv: En C-sats som ber kompilatorn att läsa innehållet i en annan fil (vanligtvis en header-fil).

en: linear
sv: linjär

en: macro
sv: makro

en: A C construct that looks similar to a C function, but is simply a #define that is expanded 'inline'. For example, if you declared the macro "<code>#define ADD(A,B) ((A)+(B))</code>", and then used it with "<code>c = ADD(1,2);</code>", that line of code would literally expand to "<code>c = ((1) + (2));</code>", or more simply, "<code>c = 1 + 2;</code>".
sv: En C-konstruktion som ser ut som en C-funktion, men som helt enkelt är en #define som expanderas "inline". Om du till exempel deklarerade makrot<code>"#define ADD(A,B) ((A)+(B))</code>" och sedan använde det med<code>"c = ADD(1,2);</code>", skulle den kodraden bokstavligen expandera till<code>"c = ((1) + (2));</code>", eller enklare uttryckt,<code>"c = 1 + 2;</code>".

en: A C structure that is passed along to a plugin's functions that exposes data and functions within the running copy of Tux Paint.
sv: En C-struktur som skickas vidare till ett plugins funktioner som exponerar data och funktioner i den löpande kopian av Rita med Tux.

en: A utility that automatically determines which pieces of a larger program need to be recompiled, and issues the commands to recompile them.
sv: Ett verktyg som automatiskt avgör vilka delar av ett större program som behöver kompileras om och ger kommandon för att kompilera om dem.

en: A text file used by the "make" utility; it describes the relationships among files in your program, and the commands for updating each file. (For example, to compile a human-readable source-code file into a computer-readable executable program file.)
sv: En textfil som används av verktyget "make"; den beskriver förhållandena mellan filerna i ditt program och kommandona för att uppdatera varje fil. (Till exempel för att kompilera en mänskligt läsbar källkodsfil till en datorläsbar körbar programfil)

en: Magic tool
sv: Magiskt verktyg

en: One of a number of effects or drawing tools in Tux Paint, made available via the "Magic" tool button.
sv: En av ett antal effekter eller ritverktyg i Rita med Tux, som görs tillgängliga via verktygsknappen "Magic".

en: (A pointer to) a C structure defined by SDL_mixer that contains a sound.
sv: (En pekare till) en C-struktur som definieras av SDL_mixer och som innehåller ett ljud.

en: An SDL_mixer function that frees (deallocates) memory allocated for an SDL_mixer sound 'chunk' ("<code>Mix_Chunk *</code>").
sv: En SDL_mixer-funktion som frigör (avallokerar) minne som allokerats för en SDL_mixer-ljud "chunk" ("<code>Mix_Chunk *</code>").

en: An SDL_mixer function that loads a sound file (WAV, Ogg Vorbis, etc.) and returns it as a "<code>Mix_Chunk *</code>".
sv: En SDL_mixer-funktion som laddar en ljudfil (WAV, Ogg Vorbis, etc.) och returnerar den som en<code>"Mix_Chunk *</code>".

en: namespace
sv: namnrymd

en: plugin
sv: instick

en: Portable Network Graphics. An extensible file format for the lossless, portable, well-compressed storage of raster images. It's the file format Tux Paint uses to save images, and for its brushes and stamps. It's an easy way to store 32bpp RGBA images (24bpp true color with full 8bpp alpha transparency), excellent for use in graphics programs like Tux Paint.
sv: Portable Network Graphics. Ett utbyggbart filformat för förlustfri, portabel och välkomprimerad lagring av rasterbilder. Det är det filformat som Rita med Tux använder för att spara bilder och för sina penslar och stämplar. Det är ett enkelt sätt att lagra 32bpp RGBA-bilder (24bpp äkta färg med full 8bpp alfa-genomskinlighet), utmärkt för användning i grafikprogram som Rita med Tux.

en: A libSDL function that frees (deallocates) memory allocated for an SDL surface ("<code>SDL_Surface *</code>").
sv: En libSDL-funktion som frigör (deallokerar) minne som allokerats för en SDL-yta ("<code>SDL_Surface *</code>").

en: A libSDL function that, given a <code>Uint32</code> pixel value (e.g., one returned from the Tux Paint's Magic tool API helper function "<code>getpixel()</code>"), the format of the surface the pixel was taken from, and pointers to three <code>Uint8</code> variables, will place the Red, Green and Blue (RGB) values of the pixel into the three <code>Uint8</code> variables. (Example: "<code>SDL_GetRGB(getpixel(surf, x, y), surf-&gt;format, &amp;r, &amp;g, &amp;b);</code>".)
sv: En libSDL-funktion som, med tanke på ett <code>Uint32-pixelvärde</code> (t.ex. ett som returneras från Rita med Tux's Magic tool API-hjälpfunktionen "getpixel<code>()</code>"), formatet på ytan som pixeln togs från och pekare till tre <code>Uint8-variabler</code>, placerar pixelns RGB-värden (rött, grönt och blått) i de tre <code>Uint8-variablerna</code>. (Exempel:<code>"SDL_GetRGB(getpixel(surf, x, y), surf-&gt;format, &amp;r, &amp;g, &amp;b);</code>"

en: A libSDL function that, given the format of a surface and <code>Uint8</code> values representing Red, Green and Blue values for a pixel, returns a <code>Uint32</code> pixel value that can be placed in the surface (e.g., using Tux Paint's Magic tool API helper function "<code>putpixel()</code>"). (Example: "<code>putpixel(surf, x, y, SDL_MapRGB(surf-&gt;format, r, g, b));</code>".)
sv: En libSDL-funktion som, givet formatet på en yta och <code>Uint8-värden</code> som representerar röda, gröna och blå värden för en pixel, returnerar ett <code>Uint32-pixelvärde</code> som kan placeras i ytan (t.ex. med hjälp av Rita med Tux's Magic tool API-hjälpfunktion<code>"putpixel()")</code>. (Exempel:<code>"putpixel(surf, x, y, SDL_MapRGB(surf-&gt;format, r, g, b));</code>".)

en: A library on top of libSDL that can load various kinds of image files (e.g., PNG) and return them as an "<code>SDL_Surface *</code>".
sv: Ett bibliotek ovanpå libSDL som kan ladda olika typer av bildfiler (t.ex. PNG) och returnera dem som en<code>"SDL_Surface *</code>".

en: A library on top of libSDL that can load various kinds of sound files (WAV, Ogg Vorbis, etc.) and play back multiple sounds at once (mix them).
sv: Ett bibliotek ovanpå libSDL som kan läsa in olika typer av ljudfiler (WAV, Ogg Vorbis, etc.) och spela upp flera ljud samtidigt (mixa dem).

en: A C structure defined by libSDL that represents a rectangular area. It contains elements representing the coordinates of the top left corner of the rectange (x,y) and the dimensions of the rectangle (w,h).
sv: En C-struktur som definieras av libSDL och som representerar ett rektangulärt område. Den innehåller element som representerar koordinaterna för rektangelns övre vänstra hörn (x,y) och rektangelns dimensioner (w,h).

en: (A pointer to) a C structure defined by libSDL that contains a drawing surface.
sv: (En pekare till) en C-struktur som definieras av libSDL och som innehåller en rityta.

en: shared object
sv: delat objekt

en: A piece of code that's compiled separately from the main application, and loaded dynamically, at runtime.
sv: En del av koden som kompileras separat från huvudapplikationen och laddas dynamiskt vid körning.

en: The Simple DirectMedia Layer (libSDL) is a programming library that provides portable low-level access to a video framebuffer, audio output, and mouse and keyboard input. (See: <a href="http://www.libsdl.org/">http://www.libsdl.org/</a>)
sv: Simple DirectMedia Layer (libSDL) är ett programmeringsbibliotek som ger portabel lågnivååtkomst till en videoramabuffert, ljudutgång samt mus- och tangentbordsinmatning. (Se: <a href="http://www.libsdl.org/">http://www.libsdl.org/</a>)

en: A C function, related to "printf()", which takes a 'format' string and one or more additional arguments, and puts them together. "snprintf()" takes the resulting output and stores it into a string, making sure not to go beyond the string's buffer size (which must also be supplied). For example, assume a string "<code>char str[20];</code>" has been declared; "<code>snprintf(str, 20, "Name: %s, Age: %d", "Bill", 32);</code>" will store "Name: Bill, Age: 32" into '<code>str</code>'.
sv: En C-funktion, relaterad till "printf()", som tar en "format"-sträng och ett eller flera ytterligare argument och sätter ihop dem. "snprintf()" tar den resulterande utdata och lagrar den i en sträng, och ser till att inte gå utöver strängens buffertstorlek (som också måste anges). Anta till exempel att en sträng<code>"char str[20]</code>;" har deklarerats;<code>"snprintf(str, 20, "Namn: %s, Ålder: %d", "Bill", 32);</code>" lagrar "Namn: Bill, Ålder: 32" i<code>'str</code>'.

en: "<code>*</code>". A symbol in C that, when used in the declaration of variables (e.g., arguments to a function), denotes that the variable is a pointer. (For example, "<code>int * p;</code>" means that "<code>p</code>" is a <i>pointer</i> to an integer.) When used next to a pointer, it 'dereferences' the variable. (For example, later "<code>*p = 50;</code>" assigns the value of 50 to the memory that "<code>p</code>" points to; it does not change the value of "<code>p</code>", which is still a pointer to an integer. In essence, it changed the integer that's being pointed to.)
sv: <code>"*</code>". En symbol i C som, när den används i deklarationen av variabler (t.ex. argument till en funktion), anger att variabeln är en pekare. (Till exempel<code>"int * p;</code>" betyder att<code>"p</code>" är en <i>pekare</i> till ett heltal.) När den används bredvid en pekare "dereferencerar" den variabeln. (Till exempel, senare<code>"*p = 50;</code>" tilldelar värdet 50 till det minne som "<code>p</code>" pekar på; det ändrar inte värdet på "<code>p</code>", som fortfarande är en pekare på ett heltal. I själva verket ändras det heltal som pekas ut)

en: A C function that allocates enough memory to store a copy of a string, copies the string to it, and returns a "<code>char *</code>" pointer to the new copy.
sv: En C-funktion som allokerar tillräckligt med minne för att lagra en kopia av en sträng, kopierar strängen till det och returnerar en<code>"char *</code>"-pekare till den nya kopian.

en: A header file that defines Tux Paint's Magic tool API.  Plugins must '<code>#include</code>' it.
sv: En header-fil som definierar Rita med Tuxs API för magiska verktyg.  Plugins måste<code>'#inkludera</code>' den.

en: A command-line program that provides information about the installed version of Tux Paint to plugin developers (such as what C compiler flags they should compile with, and where plugin shared objects and data files should be installed).
sv: Ett kommandoradsprogram som ger information om den installerade versionen av Rita med Tux till plugin-utvecklare (t.ex. vilka C-kompilatorflaggor de ska kompilera med och var plugin-delade objekt och datafiler ska installeras).

en: A 32-bit, unsigned integer (defined by libSDL). In other words, four bytes that can represent 0 through 4,294,967,295. (Typically used to hold enough information to store three or four bytes representing a pixel's color; i.e., RBGA value).
sv: Ett 32-bitars, osignerat heltal (definierat av libSDL). Med andra ord, fyra byte som kan representera 0 till 4 294 967 295. (Används vanligtvis för att hålla tillräckligt med information för att lagra tre eller fyra byte som representerar en pixels färg; dvs. RBGA-värde).

en: An 8-bit, unsigned integer (defined by libSDL). In other words, a byte that can represent 0 through 255.
sv: Ett 8-bitars, osignerat heltal (definierat av libSDL). Med andra ord, en byte som kan representera 0 till 255.

en: unsigned
sv: osignerad

en: In C, a variable that can store a numeric value can be declared as either "signed" (the default), or "unsigned". In the former case, one bit of the value is used to denote the sign of the value (either positive or negative). In the latter case, the value can only be positive, but benefits from one extra bit of storage for the number. A signed byte (8 bits), for example, can represent any number between -128 and 127. An unsigned byte can go up to 255, but it cannot go below 0. For the purposes of graphics in SDL, unsigned values should be used for RGB values, since each channel (red, green and blue) may be between 0 (off) and 255 (brightest).
sv: I C kan en variabel som kan lagra ett numeriskt värde deklareras som antingen "signerad" (standard) eller "osignerad". I det förra fallet används en bit av värdet för att ange värdets tecken (antingen positivt eller negativt). I det senare fallet kan värdet bara vara positivt, men det finns en extra lagringsbit för talet. En signerad byte (8 bitar) kan t.ex. representera vilket tal som helst mellan -128 och 127. En osignerad byte kan gå upp till 255, men den kan inte gå under 0. För grafik i SDL bör osignerade värden användas för RGB-värden, eftersom varje kanal (röd, grön och blå) kan vara mellan 0 (släckt) och 255 (ljusast).

en: variable
sv: variabel

en: A construct in computer programming that contains a value which can be referenced again later by referring to the variable's name, and typically changed later. For example, a variable to hold someone's age could be declared as an integer: "<code>int age</code>;". It can be examined later &mdash; e.g., "<code>if (age &gt;= 18) { /* they are an adult */ } else { /* they are not an adult */ }</code>" &mdash; as well as modified later &mdash; e.g., <code>age = 32; /* set age to 32 */</code>
sv: En konstruktion i datorprogrammering som innehåller ett värde som kan refereras till igen senare genom att hänvisa till variabelns namn, och vanligtvis ändras senare. Till exempel kan en variabel som innehåller någons ålder deklareras som ett heltal:<code>"int age</code>;". Den kan undersökas senare - t.ex.<code>"if (age &gt;= 18) { /* they are an adult */ } else { /* they are not an adult */ } }</code>" - och även ändras senare - t.ex. <code>age = 32; /* set age to 32 */</code>

en: See also: "%s"
sv: Se även: "%s"

en: See also:
sv: Se även nedan:

en: An example of a "Magic" tool plugin for Tux Paint
sv: Ett exempel på ett "Magic"-verktygsplugin för Rita med Tux

en: Inclusion of header files
sv: Inkludering av huvudfiler

note: Describing purpose of some #include directives
en: For "%s"
sv: För "%s"

note: Describes purpose of "tp_magic_api.h" #include
en: Tux Paint "Magic" tool API header
sv: Rita med Tux "Magic" verktyg API-huvud

note: Describes purpose of "SDL_image.h" #include
en: For IMG_Load(), to load our PNG icon
sv: För IMG_Load(), för att ladda vår PNG-ikon

note: Describes purpose of "SDL_mixer.h" #include
en: For Mix_LoadWAV(), to load our sound effects
sv: För Mix_LoadWAV(), för att ladda våra ljudeffekter

en: Tool Enumerations:
sv: Verktygsuppräkningar:

note: Label of enum representing one of the example tools
en: TOOL_ONE
sv: VERKTYG_ONE

note: Label of enum representing one of the example tools
en: TOOL_TWO
sv: VERKTYG_TWO

note: Describes how a particular enum ends up represented as an int value
en: Becomes '%d'
sv: Blir '%d'

en: Lists of filenames for sounds and icons to load at startup:
sv: Listor med filnamn för ljud och ikoner som ska laddas vid start:

note: Name of char* array of sound file filenames
en: sound_filenames
sv: ljud_filnamn

en: tool_one
sv: verktyg_ett

en: tool_two
sv: verktyg_två

note: Name of char* array of icon filenames
en: icon_filenames
sv: ikon_filnamn

en: NOTE: We use a macro called "%s" below in some arrays of strings (char *'s) that hold the names and descriptions of our "Magic" tools.  This allows the strings to be localized into other languages.
sv: OBS: Vi använder ett makro som heter "%s" nedan i vissa matriser med strängar (char *) som innehåller namn och beskrivningar av våra "Magic"-verktyg.  Detta gör att strängarna kan lokaliseras till andra språk.

en: A list of names for the tools
sv: En lista med namn för verktygen

note: Name of char* array of tool names
en: tool_names
sv: verktygsnamn

note: Name of one of the example tools
en: A tool
sv: Ett verktyg

note: Name of one of the example tools
en: Another tool
sv: Ett annat verktyg

en: How to group the tools with other similar tools, within the 'Magic' selector:
sv: Hur man grupperar verktygen med andra liknande verktyg, inom "Magic"-väljaren:

note: Name of int array of which group each tool belongs to
en: tool_groups
sv: verktyg_grupper

en: A list of descriptions of the tools
sv: En lista med beskrivningar av verktygen

note: Name of char* array of tool descriptions
en: tool_descriptions
sv: verktyg_beskrivningar

note: Description of one of the example tools
en: This is example tool number %d.
sv: Detta är exempel på verktygsnummer %d.

en: Our global variables:
sv: Våra globala variabler:

en: Sound effects:
sv: Ljudeffekter:

note: Name of Mix_Chunk* array of sound file data
en: sound_effects
sv: ljud_effekter

en: The current color (an "RGB" -- red, green, blue -- value) the user has selected in Tux Paint (for tool 1):
sv: Den aktuella färgen (ett "RGB"-värde (röd, grön, blå) som användaren har valt i Rita med Tux (för verktyg 1):

en: The size the user has selected in Tux Paint (for tool 2):
sv: Den storlek som användaren har valt i Rita med Tux (för verktyg 2):

note: Part of the name of size-related variables
en: size
sv: storlek

en: Our local function prototypes:
sv: Våra lokala funktionsprototyper:

en: These functions are called by other functions within our plugin, so we provide a 'prototype' of them, so the compiler knows what they accept and return.  This lets us use them in other functions that are declared _before_ them.
sv: Dessa funktioner anropas av andra funktioner inom vårt plugin, så vi tillhandahåller en "prototyp" av dem, så att kompilatorn vet vad de accepterar och returnerar.  Detta gör att vi kan använda dem i andra funktioner som deklareras _före_ dem.

note: Name of int argument sent to API functions by Tux Paint, for which tool is being interacted-with
en: which
sv: som

note: Name of int argument sent to API functions by Tux Paint, for which mode a tool is in
en: mode
sv: läge

note: Name of SDL_Surface* argument sent to API functions by Tux Paint, the drawing canvas; the target where effects should go
en: canvas
sv: målarduk

note: Name of SDL_Surface* argument sent to API functions by Tux Paint, a snapshot of the drawing canvas prior to effects being applied
en: snapshot
sv: ögonblicksbild

note: Name of SDL_Rect* argument sent to API functions by Tux Paint, where the rectangle surrounding updates to the canvas will be plugged in by the API
en: update_rect
sv: uppdatering_rect

note: Name of a local variable for storing filenames (concantation of data path + name of individual file)
en: filename
sv: filnamn

note: Name of an int argument representing the old X coordinate of the mouse (vs plain "x")
en: old_x
sv: gammal_x

note: Name of an int argument representing the old Y coordinate of the mouse (vs plain "y")
en: old_y
sv: gammal_y

en: Setup Functions:
sv: Inställningsfunktioner:

en: API Version check
sv: Kontroll av API-version

en: The running copy of Tux Paint that has loaded us first asks us what version of the Tux Paint 'Magic' tool plugin API we were built against.  If it deems us compatible, we'll be used!
sv: Den löpande kopian av Rita med Tux som har laddat oss frågar oss först vilken version av Rita med Tux 'Magic' tool plugin API vi byggdes mot.  Om det anser att vi är kompatibla kommer vi att användas!

en: All we need to do here is return "%1$s", which is defined (%2$s) in the header file "%3$s".
sv: Allt vi behöver göra här är att returnera "%1$s", som definieras (%2$s) i headerfilen "%3$s".

en: Initialization
sv: Initiering av Samhain

en: This happens once, when Tux Paint starts up and is loading all of the 'Magic' tool plugins.  (Assuming what we returned from %s was acceptable!)
sv: Detta händer en gång, när Rita med Tux startar och laddar alla plugins för "Magic"-verktyget.  (Förutsatt att det vi fick tillbaka från %s var acceptabelt!)

en: All we're doing in this example is loading our sound effects, which we'll use later (in %1$s, %2$s, and %3$s) when the user is using our Magic tools.
sv: Allt vi gör i det här exemplet är att ladda våra ljudeffekter, som vi kommer att använda senare (i %1$s, %2$s och %3$s) när användaren använder våra Magic-verktyg.

en: The memory we allocate here to store the sounds will be freed (aka released, aka deallocated) when the user quits Tux Paint, when our %s function is called.
sv: Det minne vi allokerar här för att lagra ljuden kommer att frigöras (aka released, aka deallocated) när användaren avslutar Rita med Tux, när vår %s-funktion anropas.

note: Name of a Uint8 argument containg a bitmask of disabled Tux Paint features
en: disabled_features
sv: inaktiverade_funktioner

note: Name of a Uint8 argument containing Tux Paint's complexity/expertise level
en: complexity_level
sv: komplexitet_nivå

en: Assemble the filename from the "%s[]" array into a full path to a real file.
sv: Sätt ihop filnamnet från "%s[]"-matrisen till en fullständig sökväg till en riktig fil.

en: Use "%1$s" to figure out where our sounds should be. (The "%2$s" command would have told us when we installed our plugin and its data.)
sv: Använd "%1$s" för att ta reda på var våra ljud ska vara. (Kommandot "%2$s" skulle ha berättat för oss när vi installerade vårt plugin och dess data)

en: Trying to load %s sound file
sv: Försöker ladda %s ljudfil

en: Try to load the file!
sv: Försök att ladda filen!

en: Report our tool count
sv: Rapportera vårt verktygsantal

en: Tux Paint needs to know how many 'Magic' tools we'll be providing. Return that number here.  (We simply grab the value of '%s' from our 'enum' above!)
sv: Rita med Tux behöver veta hur många "Magic"-verktyg vi kommer att tillhandahålla. Returnera det numret här.  (Vi tar helt enkelt värdet på '%s' från vår 'enum' ovan!)

en: When Tux Paint is starting up and loading plugins, it will call some of the following setup functions once for each tool we report.
sv: När Rita med Tux startar upp och laddar insticksprogram anropar den några av följande installationsfunktioner en gång för varje verktyg vi rapporterar.

en: Load our icons
sv: Ladda våra ikoner

en: When Tux Paint is starting up and loading plugins, it asks us to provide icons for the 'Magic' tool buttons.
sv: När Rita med Tux startar upp och laddar in plugins ber den oss att tillhandahålla ikoner för verktygsknapparna "Magic".

en: Use "api->data_directory" to figure out where our sounds should be. (The "tp-magic-config --dataprefix" command would have told us when we installed our plugin and its data.)
sv: Använd "api->data_directory" för att räkna ut var våra ljud ska vara. (Kommandot "tp-magic-config --dataprefix" skulle ha berättat för oss när vi installerade vårt plugin och dess data)

en: We use "%s" (which of our tools Tux Paint is asking about) as an index into the array.
sv: Vi använder "%s" (vilket av våra verktyg som Rita med Tux frågar om) som ett index i matrisen.

en: Trying to load %s icon
sv: Försöker ladda %s-ikonen

en: Try to load the image, and return the results to Tux Paint:
sv: Försök att ladda bilden och returnera resultatet till Rita med Tux:

en: Report our 'Magic' tool names
sv: Rapportera våra namn på "Magic"-verktyg

en: When Tux Paint is starting up and loading plugins, it asks us to provide names (labels) for the 'Magic' tool buttons.
sv: När Rita med Tux startar upp och laddar in plugins ber den oss att ange namn (etiketter) för verktygsknapparna "Magic".

en: Get our name from the "%s[]" array.
sv: Hämta vårt namn från matrisen "%s[]".

en: We use '%s' (which of our tools Tux Paint is asking about) as an index into the array.
sv: Vi använder '%s' (vilket av våra verktyg som Rita med Tux frågar om) som ett index i matrisen.

en: Return a localized (aka translated) version of our name, if possible.
sv: Returnera en lokaliserad (även kallad översatt) version av vårt namn, om möjligt.

en: We send "%s" the English version of the name from our array.
sv: Vi skickar "%s" den engelska versionen av namnet från vår array.

en: Finally, duplicate the string into a new section of memory, and send it to Tux Paint.  (Tux Paint keeps track of the string and will free it for us, so we have one less thing to keep track of.)
sv: Slutligen duplicerar du strängen till en ny del av minnet och skickar den till Rita med Tux.  (Rita med Tux håller reda på strängen och frigör den åt oss, så att vi får en sak mindre att hålla reda på)

en: Report our 'Magic' tool groups
sv: Rapportera våra "magiska" verktygsgrupper

en: When Tux Paint is starting up and loading plugins, it asks us to specify where the tool should be grouped.
sv: När Rita med Tux startar upp och laddar in plugins ber den oss att ange var verktyget ska grupperas.

en: Return our group, found in the "%s[]" array.
sv: Returnera vår grupp, som finns i matrisen "%s[]".

en: Return grouping/ordering number
sv: Returnera grupperings-/beställningsnummer

en: When Tux Paint is starting up and loading plugins, it asks us to provide a numeric value used for sorting 'Magic' tools within a group.  Tools will be ordered based on this number, and those with the same number will be sorted alphabetically by their localized name (see '%s').
sv: När Rita med Tux startar upp och laddar insticksprogram ber den oss att ange ett numeriskt värde som används för att sortera "Magic"-verktyg inom en grupp.  Verktygen sorteras utifrån detta nummer, och de som har samma nummer sorteras i alfabetisk ordning efter sitt lokaliserade namn (se '%s').

en: Report our 'Magic' tool descriptions
sv: Rapportera våra beskrivningar av "Magic"-verktyget

en: When Tux Paint is starting up and loading plugins, it asks us to provide descriptions of each 'Magic' tool.
sv: När Rita med Tux startar upp och laddar in plugins ber den oss att ge beskrivningar av varje "Magic"-verktyg.

note: Name of a char* variable to hold the Magic tool's description, in English (from C source)
en: our_desc_english
sv: vår_desc_engelska

note: Name of a char* variable to hold the Magic tool's description, localized via gettext()
en: our_desc_localized
sv: vår_beskrivning_lokaliserad

en: Get our description from the "%s[]" array.
sv: Hämta vår beskrivning från matrisen "%s[]".

en: Return a localized (aka translated) version of our description, if possible.
sv: Returnera en lokaliserad (även kallad översatt) version av vår beskrivning, om möjligt.

en: We send "%s" the English version of the description from our array.
sv: Vi skickar "%s" den engelska versionen av beskrivningen från vår matris.

en: Report whether we accept colors
sv: Rapportera om vi accepterar färger

en: Report what modes we work in
sv: Rapportera vilka lägen vi arbetar i

en: Both of our tools are painted (neither affect the full-screen), so we're always returning 'MODE_PAINT'
sv: Båda våra verktyg är målade (inget av dem påverkar helskärmen), så vi returnerar alltid 'MODE_PAINT'

en: Report whether the tools offer sizing options
sv: Rapportera om verktygen erbjuder storleksalternativ

en: Return our default sizing option
sv: Återgå till vårt standardstorleksalternativ

en: Shut down
sv: Stäng av

en: Tux Paint is quitting.  When it quits, it asks all of the plugins to 'clean up' after themselves.  We, for example, loaded some sound effects at startup (in our %s() function), so we should free the memory used by them now.
sv: Rita med Tux håller på att avslutas.  När programmet avslutas ber det alla plugins att "städa upp" efter sig själva.  Vi laddade till exempel några ljudeffekter vid start (i vår funktion %s()), så vi bör frigöra det minne som används av dem nu.

en: Free (aka release, aka deallocate) the memory used to store the sound effects that we loaded during %s:
sv: Frigör (aka release, aka deallocate) minnet som används för att lagra ljudeffekterna som vi laddade in under %s:

en: Functions that respond to events in Tux Paint:
sv: Funktioner som reagerar på händelser i Rita med Tux:

en: Affect the canvas on click:
sv: Påverkar duken vid klick:

en: In our case, a single click (which is also the start of a drag!) is identical to what dragging does, but just at one point, rather than across a line.
sv: I vårt fall är ett enda klick (som också är början på en dragning!) identiskt med vad dragning gör, men bara på en punkt i stället för över en linje.

en: So we 'cheat' here, by calling our "%s()" function with (x,y) for both the beginning and end points of a line.
sv: Därför "fuskar" vi här genom att anropa vår funktion "%s()" med (x,y) för både start- och slutpunkterna för en linje.

en: Affect the canvas on drag:
sv: Påverkar duken vid dragning:

en: Call Tux Paint's "%s" (line-traversing) function.
sv: Anropa Rita med Tuxs "%s"-funktion (linjeövergång).

en: It will calculate a straight line between (%1$s,%2$s) and (x,y). Every N steps along that line (in this case, N is '1'), it will call _our_ function, "%3$s()", and send the current X,Y coordinates along the line, as well as other useful things (which of our 'Magic' tools is being used and the current and snapshot canvases).
sv: Den kommer att beräkna en rak linje mellan (%1$s,%2$s) och (x,y). För varje N steg längs linjen (i det här fallet är N '1') anropar den _vår_ funktion, "%3$s()", och skickar de aktuella X,Y-koordinaterna längs linjen, samt andra användbara saker (vilket av våra "Magic"-verktyg som används och de aktuella och ögonblicksbildsdukarna).

en: If we need to, swap the X and/or Y values, so that the coordinates (%1$s,%2$s) is always the top left, and the coordinates (x,y) is always the bottom right, so the values we put inside "%3$s" make sense:
sv: Om det behövs kan du byta ut X- och/eller Y-värdena så att koordinaterna (%1$s,%2$s) alltid är längst upp till vänster och koordinaterna (x,y) alltid är längst ned till höger, så att de värden vi anger i "%3$s" blir meningsfulla:

en: Fill in the elements of the "%s" SDL_Rect structure that Tux Paint is sharing with us, therefore telling Tux Paint which part of the canvas has been modified and should be updated.
sv: Fyll i elementen i "%s" SDL_Rect-strukturen som Rita med Tux delar med oss, och talar därför om för Rita med Tux vilken del av duken som har ändrats och bör uppdateras.

en: Play the appropriate sound effect
sv: Spela upp lämplig ljudeffekt

en: We're calculating a value between 0-255 for where the mouse is horizontally across the canvas (0 is the left, ~128 is the center, 255 is the right).
sv: Vi beräknar ett värde mellan 0-255 för var musen befinner sig horisontellt över duken (0 är vänster, ~128 är mitten, 255 är höger).

en: These are the exact values Tux Paint's "%s()" wants, to determine what speaker to play the sound in. (So the sound will pan from speaker to speaker as you drag the mouse around the canvas!)
sv: Det här är de exakta värden som Rita med Tuxs "%s()" vill ha för att avgöra vilken högtalare ljudet ska spelas upp i. (Så ljudet kommer att panorera från högtalare till högtalare när du drar musen runt på duken!)

en: Left/right pan
sv: Vänster/höger panorering

en: Near/far distance (loudness)
sv: Nära/långt avstånd (loudness)

en: Affect the canvas on release:
sv: Påverka duken när den släpps:

en: Neither of our effects do anything special when the mouse is released from a click or click-and-drag, so there's no code here...
sv: Ingen av våra effekter gör något speciellt när musen släpps från ett klick eller en klick-och-drag, så det finns ingen kod här...

en: Accept colors
sv: Acceptera färger

en: When any of our 'Magic' tools are activated by the user, if that tool accepts colors, the current color selection is sent to us.
sv: När något av våra "Magic"-verktyg aktiveras av användaren, om verktyget accepterar färger, skickas det aktuella färgvalet till oss.

en: Additionally, if one of our color-accepting tools is active when the user changes their chosen, we'll be informed of that as well.
sv: Om något av våra färgaccepterande verktyg är aktivt när användaren ändrar sitt val kommer vi dessutom att informeras om det.

en: The color comes in as RGB (red, green, and blue) values from 0 (darkest) to 255 (brightest).
sv: Färgen anges som RGB-värden (rött, grönt och blått) från 0 (mörkast) till 255 (ljusast).

en: We simply store the RGB values in the global variables we declared at the top of this file.
sv: Vi lagrar helt enkelt RGB-värdena i de globala variabler som vi deklarerade högst upp i den här filen.

en: Accept sizes
sv: Acceptera storlekar

en: When any of our 'Magic' tools are activated by the user, if that tool offer's sizes, the current size selection is sent to us.
sv: När något av våra "Magic"-verktyg aktiveras av användaren, om verktyget erbjuder storlekar, skickas det aktuella storleksvalet till oss.

en: Additionally, if the user changes the tool's size, we'll be informed of that as well.
sv: Om användaren ändrar verktygets storlek får vi dessutom information om detta.

en: The size comes in as an unsigned integer (%1$s) between 1 and the value returned by our %2$s() function during setup.
sv: Storleken kommer in som ett osignerat heltal (%1$s) mellan 1 och det värde som returneras av vår %2$s()-funktion under installationen.

en: Store the new size into the global variable we declared at the top of this file.
sv: Spara den nya storleken i den globala variabeln som vi deklarerade högst upp i den här filen.

en: The Magic Effect Routines!
sv: Den magiska effekten Rutiner!

en: Our 'callback' function
sv: Vår "callback"-funktion

en: We do the 'work' in this callback.  Our plugin file has just one. Some 'Magic' tool plugins may have more, depending on the tools they're providing.  Some have none (since they're not click-and-drag painting-style tools).
sv: Vi gör "arbetet" i denna återuppringning.  Vår plugin-fil har bara en. Vissa plugins för "magiska" verktyg kan ha fler, beroende på vilka verktyg de tillhandahåller.  Vissa har inga (eftersom de inte är klick-och-drag-verktyg i målningsstil).

en: Our callback function gets called once for every point along a line between the mouse's previous and current position, as it's being dragged.
sv: Vår callback-funktion anropas en gång för varje punkt längs en linje mellan musens föregående och nuvarande position, när den dras.

en: Our callback pays attention to '%s' to determine which of our plugin's tools is currently selected.
sv: Vår callback uppmärksammar '%s' för att avgöra vilket av pluginets verktyg som för närvarande är valt.

en: For technical reasons, we can't accept a pointer to the Tux Paint API's "%s" struct, like the other functions do.
sv: Av tekniska skäl kan vi inte ta emot en pekare till Rita med Tux API:s struktur "%s", som de andra funktionerna gör.

en: Instead, we receive a 'generic' pointer (a "%1$s"). The line below declares a local "%2$s" pointer variable called "api", and then assigns it to the value of the 'generic' pointer we received.
sv: Istället får vi en "generisk" pekare (en "%1$s"). Raden nedan deklarerar en lokal "%2$s"-pekarvariabel som heter "api" och tilldelar den sedan värdet på den "generiska" pekaren som vi fick.

en: The "%1$s" seen below casts the generic "%2$s" pointer into the 'type' of pointer we want, a pointer to a "%3$s" struct.)
sv: "%1$s" nedan kastar den generiska "%2$s"-pekaren till den "typ" av pekare vi vill ha, en pekare till en "%3$s"-struktur)

en: This function handles both of our tools, so we need to check which is being used right now.  We compare the '%s' argument that Tux Paint sends to us with the values we enumerated above.
sv: Den här funktionen hanterar båda våra verktyg, så vi måste kontrollera vilket som används just nu.  Vi jämför argumentet '%s' som Rita med Tux skickar till oss med de värden vi räknade upp ovan.

en: Tool number 1 simply draws a single pixel at the (x,y) location. It acts as a 1x1 pixel brush.
sv: Verktyg nummer 1 ritar helt enkelt en enda pixel på (x,y)-platsen. Det fungerar som en 1x1 pixel-pensel.

en: We use "%1$s()" to convert the RGB value we receive from Tux Paint for the user's current color selection to a '%2$s' pixel value we can send to Tux Paint's "%3$s()" function.
sv: Vi använder "%1$s()" för att konvertera RGB-värdet som vi får från Rita med Tux för användarens aktuella färgval till ett "%2$s"-pixelvärde som vi kan skicka till Rita med Tuxs "%3$s()"-funktion.

en: Tool number 2 copies a square of pixels (of the size chosen by the user) from the opposite side of the canvas and puts it under the cursor.
sv: Verktyg nummer 2 kopierar en kvadrat med pixlar (av den storlek som användaren väljer) från den motsatta sidan av duken och placerar den under markören.

en: Here we have simply use Tux Paint's "%1$s()" routine to pull pixel values from the '%2$s', and then "%3$s()" to draw them right into the '%4$s'.
sv: Här har vi helt enkelt använt Rita med Tuxs "%1$s()"-rutin för att hämta pixelvärden från "%2$s" och sedan "%3$s()" för att rita dem direkt i "%4$s".

en: Note: %1$s() and %2$s() are safe to use, even if your X,Y values are outside of the SDL surface (e.g., negative, or greater than the surface's width and/or height).
sv: Obs: %1$s() och %2$s() är säkra att använda även om dina X,Y-värden ligger utanför SDL-ytan (t.ex. negativa eller större än ytans bredd och/eller höjd).

en: Switch-In event
sv: Switch-In händelse

en: This happens whenever a Magic tool is enabled, either because the user just selected it, or they just came back to 'Magic' after using another tool (e.g., Brush or Text), and this was the most-recently selected Magic tool.
sv: Detta händer när ett magiskt verktyg är aktiverat, antingen för att användaren just har valt det eller för att användaren återvände till "Magic" efter att ha använt ett annat verktyg (t.ex. Brush eller Text) och detta var det senast valda magiska verktyget.

en: (This also applies to momentary tools, like Undo and Redo, and image-changing tools such as New and Open.)
sv: (Detta gäller även momentana verktyg som Undo och Redo och bildförändrande verktyg som New och Open)

en: It also happens when a Magic tool's mode changes (we will first receive a call to '%s()', below, for the old mode).
sv: Det händer också när ett Magic-verktygs läge ändras (vi kommer först att få ett anrop till '%s()', nedan, för det gamla läget).

en: Our example doesn't do anything when we switch to, or away from, our Magic tools, so we just do nothing here.
sv: Vårt exempel gör ingenting när vi byter till, eller från, våra Magic-verktyg, så vi gör ingenting här.

en: Switch-Out event
sv: Händelse för avstängning

en: This happens whenever a Magic tool is disabled, either because the user selected a different Magic tool, or they selected a completely different tool (e.g., Brush or Text).
sv: Detta händer när ett magiskt verktyg inaktiveras, antingen för att användaren har valt ett annat magiskt verktyg eller för att användaren har valt ett helt annat verktyg (t.ex. Brush eller Text).

en: (And in that case, our %s() function will be called moments later.)
sv: (Och i så fall kommer vår funktion %s() att anropas en stund senare)

en: It also happens when a Magic tool's mode changes (we will then receive a call to '%s()', above, for the new mode).
sv: Det händer också när ett Magic-verktygs läge ändras (vi får då ett anrop till '%s()', ovan, för det nya läget).
