#. extracted from helpcontent2/source/text/simpress/guide.oo
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://qa.openoffice.org/issues/enter_bug.cgi?subcompon"
"ent=ui&comment=&short_desc=Localization+issue+in+file%3A+helpcontent2%2Fsourc"
"e%2Ftext%2Fsimpress%2Fguide.oo&component=l10n&form_name=enter_issue\n"
"POT-Creation-Date: 2019-08-21 18:38+0200\n"
"PO-Revision-Date: 2019-07-24 00:31+0000\n"
"Last-Translator: Matthias <mseidel@apache.org>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: sv\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"X-Accelerator-Marker: ~\n"
"X-Generator: Pootle 2.5.1.3\n"
"X-Merge-On: location\n"
"X-POOTLE-MTIME: 1563928275.000000\n"

#: orgchart.xhp%23tit.help.text
msgid "Creating a Flowchart"
msgstr "Skapa ett flödesschema"

#: orgchart.xhp%23bm_id3150439.help.text
msgid ""
"<bookmark_value>connectors; using</bookmark_value><bookmark_value>flowcharts<"
"/bookmark_value><bookmark_value>organization "
"charts</bookmark_value><bookmark_value>hot spots in "
"flowcharts</bookmark_value><bookmark_value>interactions; hot "
"spots</bookmark_value>"
msgstr ""
"<bookmark_value>förbindelser; använda</bookmark_value><bookmark_value>flödess"
"cheman</bookmark_value><bookmark_value>organisationsscheman</bookmark_value><"
"bookmark_value>aktiva punkter i "
"flödesscheman</bookmark_value><bookmark_value>interaktioner; aktiva "
"punkter</bookmark_value>"

#: orgchart.xhp%23hd_id3150439.3.help.text
msgid ""
"<variable id=\"orgchart\"><link href=\"text/simpress/guide/orgchart.xhp\" "
"name=\"Creating a Flowchart\">Creating a Flowchart</link></variable>"
msgstr ""
"<variable id=\"orgchart\"><link href=\"text/simpress/guide/orgchart.xhp\" "
"name=\"Skapa ett flödesschema\">Skapa ett flödesschema</link></variable>"

#: orgchart.xhp%23hd_id3159153.39.help.text
msgid "To create a flowchart:"
msgstr "Så här skapar du ett flödesschema:"

#: orgchart.xhp%23par_id3152482.40.help.text
msgid ""
"Select a tool from the <emph>Flowchart</emph> toolbar on the "
"<emph>Drawing</emph> bar."
msgstr ""
"Välj ett verktyg på verktygsraden <emph>Flödesschema</emph> på verktygsraden "
"<emph>Ritverktyg</emph>."

#: orgchart.xhp%23par_id3150715.41.help.text
msgid "Drag a shape in your slide."
msgstr "Infoga en figur i dokumentet."

#: orgchart.xhp%23par_id3154486.42.help.text
msgid "To add more shapes, repeat the last steps."
msgstr "Upprepa de sista stegen om du vill lägga till fler former."

#: orgchart.xhp%23par_id3146967.43.help.text
msgid ""
"Open the <emph>Connectors </emph>toolbar on the <emph>Drawing</emph> bar, "
"and select a connector line."
msgstr ""
"Öppna verktygsraden <emph>Förbindelser</emph> på verktygsraden "
"<emph>Ritobjekt</emph> och välj en förbindelselinje."

#: orgchart.xhp%23par_id3149945.44.help.text
msgid ""
"Move the pointer over the edge of a shape so that the connection sites "
"appear."
msgstr "Flytta pekaren över kanten på en figur så att förbindelsepunkter visas."

#: orgchart.xhp%23par_id3146871.45.help.text
msgid ""
"Click a connection site, drag to a connection site on another shape, and "
"then release."
msgstr ""
"Klicka på en förbindelsepunkt, dra till en annan förbindelsepunkt på en "
"annan figur och släpp upp musknappen."

#: orgchart.xhp%23par_id3145824.46.help.text
msgid "To add more connectors, repeat the last steps."
msgstr "Upprepa de sista stegen om du vill lägga till fler förbindelser."

#: orgchart.xhp%23par_id3153036.47.help.text
msgid "You now have the basic outline for your flowchart."
msgstr "Du har nu lagt grunden till ditt flödesschema."

#: orgchart.xhp%23hd_id3155255.48.help.text
msgid "To add text to the shapes on your flowchart"
msgstr "Så här lägger du till text i figurerna i flödesschemat"

#: orgchart.xhp%23par_id3150865.49.help.text
msgctxt "orgchart.xhp#par_id3150865.49.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: orgchart.xhp%23par_id3145592.50.help.text
msgid "Double-click the shape, and type or paste your text."
msgstr "Dubbelklicka på figuren och skriv eller klistra in texten."

#: orgchart.xhp%23par_id3154504.51.help.text
msgid ""
"Click the <emph>Text</emph> icon on the <emph>Drawing</emph> bar, and drag a "
"text object over the shape. Type or paste your text into the text object."
msgstr ""
"Klicka på ikonen <emph>Text</emph> på verktygsraden <emph>Ritverktyg</emph> "
"och dra ett textobjekt över figuren. Skriv eller klistra in texten i "
"textobjektet."

#: orgchart.xhp%23hd_id3153730.52.help.text
msgid "To add a color fill to a shape:"
msgstr "Så här lägger du till en färgfyllning i en figur:"

#: orgchart.xhp%23par_id3155930.53.help.text
msgid "Select the shape, and choose <emph>Format - Area</emph>."
msgstr "Markera figuren och välj <emph>Format - Yta</emph>."

#: orgchart.xhp%23par_id3145348.54.help.text
msgctxt "orgchart.xhp#par_id3145348.54.help.text"
msgid "Select <emph>Color</emph>, and then click a color in the list."
msgstr "Klicka på <emph>Färger</emph> och klicka på en färg i listan."

#: orgchart.xhp%23hd_id3150934.56.help.text
msgid "To add some hot spots that call other slides:"
msgstr "Så här lägger du till aktiva punkter som öppnar andra sidor:"

#: orgchart.xhp%23par_id3145300.57.help.text
msgid ""
"Assign <link href=\"text/simpress/01/06070000.xhp\" name=\"interactions\""
">interactions</link> to some objects on your slide. "
msgstr ""
"Tilldela <link href=\"text/simpress/01/06070000.xhp\" name=\"interaktioner\""
">interaktioner</link> till ett eller flera objekt på sidan. "

#: orgchart.xhp%23par_idN10898.help.text
msgid "Select the object, then choose <emph>Slide Show - Interaction</emph>."
msgstr ""
"Markera objektet och välj sedan <emph>Bildskärmspresentation - "
"Interaktion</emph>."

#: orgchart.xhp%23par_idN108A0.help.text
msgid ""
"Select an interaction in the dialog. For example, select to go to the next "
"slide when the user clicks the object."
msgstr ""
"Markera en interaktion i dialogrutan. Välj t.ex. om du vill flytta till "
"nästa bild när användaren klicka på objektet."

#: orgchart.xhp%23par_id3153922.32.help.text
msgid ""
"<link href=\"text/simpress/02/10100000.xhp\" name=\"Connectors\""
">Connectors</link>"
msgstr ""
"<link href=\"text/simpress/02/10100000.xhp\" name=\"Förbindelse\""
">Förbindelse</link>"

#: orgchart.xhp%23par_id3156257.33.help.text
msgid ""
"<link href=\"text/simpress/02/10030200.xhp\" name=\"Glue points\">Glue "
"points</link>"
msgstr ""
"<link href=\"text/simpress/02/10030200.xhp\" name=\"Fästpunkter\""
">Fästpunkter</link>"

#: palette_files.xhp%23tit.help.text
msgid "Loading Color, Gradient, and Hatching Lists"
msgstr "Ladda färg-, gradient- och skrafferingslistor"

#: palette_files.xhp%23bm_id3154510.help.text
msgid ""
"<bookmark_value>colors;loading "
"lists</bookmark_value><bookmark_value>gradients;loading "
"lists</bookmark_value><bookmark_value>hatching;loading "
"lists</bookmark_value><bookmark_value>loading;colors/gradients/"
"hatchings</bookmark_value>"
msgstr ""
"<bookmark_value>Färger; läsa in "
"tabeller</bookmark_value><bookmark_value>Gradienter; läsa in "
"tabeller</bookmark_value><bookmark_value>Skraffering; läsa in "
"tabeller</bookmark_value><bookmark_value>Läsa in; "
"färger/gradienter/skrafferingar</bookmark_value>"

#: palette_files.xhp%23hd_id3154510.48.help.text
msgid ""
"<variable id=\"palette_files\"><link href=\"text/simpress/guide/"
"palette_files.xhp\" name=\"Loading Color, Gradient, and Hatching Lists\">"
"Loading Color, Gradient, and Hatching Lists</link></variable>"
msgstr ""
"<variable id=\"palette_files\"><link href=\""
"text/simpress/guide/palette_files.xhp\" name=\"Ladda färg-, gradient- och "
"skrafferingslistor\">Ladda färg-, gradient- och "
"skrafferingslistor</link></variable>"

#: palette_files.xhp%23par_id3156385.73.help.text
msgid ""
"You can use lists to organize colors, gradients, or hatching patterns. "
"$[officename] provides several lists that you can load and use in your "
"document. If you want, you can add or delete elements from a list, or even "
"create custom lists. "
msgstr ""
"Du kan använda listor om du vill strukturera färger, gradienter eller "
"skraffreringsmönster. I $[officename] finns flera listor som du kan hämta "
"och använda i dokumenten. Om du vill kan du lägga till eller ta bort element "
"från en tabell eller skapa egna tabeller. "

#: palette_files.xhp%23hd_id3155961.74.help.text
msgid "To load a color list:"
msgstr "Så här laddar du en färgtabell:"

#: palette_files.xhp%23par_id3154656.47.help.text
msgid ""
"Choose <emph>Format - Area</emph>, and then click the <emph>Colors</emph> "
"tab."
msgstr ""
"Välj <emph>Format - Yta</emph> och klicka på fliken <emph>Färger</emph>."

#: palette_files.xhp%23par_id3152896.75.help.text
msgid "Click the <emph>Load Color List</emph> button."
msgstr "Klicka på knappen <emph>Ladda färgtabell</emph>."

#: palette_files.xhp%23par_id3151239.76.help.text
msgid ""
"Locate the color list that you want to load, and then click <emph>Open</emph>"
". A color list file has the format [filename].soc."
msgstr ""
"Leta rätt på färgtabellen som du ska ladda och klicka på <emph>Öppna</emph>. "
"En färgtabellfil har formatet [filnamn].soc."

#: palette_files.xhp%23par_id3154762.77.help.text
msgid ""
"To save a color list, click the <emph>Save Color List</emph> button, enter a "
"filename, and then click <emph>Save</emph>."
msgstr ""
"Om du vill spara en färgtabell klickar du på knappen <emph>Spara "
"färgtabell</emph>, anger ett filnamn och klickar på <emph>Spara</emph>."

#: palette_files.xhp%23bm_id3149871.help.text
msgid "<bookmark_value>colors; default colors</bookmark_value>"
msgstr "<bookmark_value>färger; standardfärger</bookmark_value>"

#: palette_files.xhp%23par_id3149871.71.help.text
msgid ""
"The CMYK list is optimized for print colors, whereas the colors in the Web "
"and the HTML lists are optimized for displays using a resolution of 256 "
"colors."
msgstr ""
"CMYK-listan är optimerad för utskriftsfärger, och färgerna i listorna Webb "
"och HTML är optimerade för en upplösning med 256 färger."

#: palette_files.xhp%23hd_id3150435.78.help.text
msgid "To load a gradient list:"
msgstr "Så här laddar du en gradienttabell:"

#: palette_files.xhp%23par_id3150393.79.help.text
msgid ""
"Choose <emph>Format - Area</emph>, and then click the <emph>Gradients</emph> "
"tab."
msgstr ""
"Välj <emph>Format - Yta</emph> och klicka på fliken "
"<emph>Färggradienter</emph>."

#: palette_files.xhp%23par_id3146322.80.help.text
msgid "Click the <emph>Load Gradients List</emph> button."
msgstr "Klicka på knappen <emph>Ladda färggradienttabell</emph>."

#: palette_files.xhp%23par_id3149946.81.help.text
msgid ""
"Locate the gradient list that you want to load, and then click "
"<emph>Open</emph>. A gradient list file has the format [filename].sog."
msgstr ""
"Leta rätt på gradienttabellen som du ska ladda och klicka på "
"<emph>Öppna</emph>. En gradienttabellfil har formatet [filnamn].sog."

#: palette_files.xhp%23par_id3150740.82.help.text
msgid ""
"To save a gradients list, click the <emph>Save Gradients List</emph> button, "
"enter a filename, and then click <emph>Save</emph>."
msgstr ""
"Om du vill spara en gradienttabell klickar du på knappen <emph>Spara "
"färggradienttabell</emph>, anger ett filnamn och klickar på "
"<emph>Spara</emph>."

#: palette_files.xhp%23hd_id3153036.83.help.text
msgid "To load a hatching list:"
msgstr "Så här laddar du en skrafferingstabell:"

#: palette_files.xhp%23par_id3155255.84.help.text
msgid ""
"Choose <emph>Format - Area</emph>, and then click the <emph>Hatching</emph> "
"tab."
msgstr ""
"Välj <emph>Format - Yta</emph> och klicka på fliken <emph>Skraffering</emph>."

#: palette_files.xhp%23par_id3153004.85.help.text
msgid "Click the <emph>Load Hatches List</emph> button."
msgstr "Klicka på knappen <emph>Ladda skrafferingstabell</emph>."

#: palette_files.xhp%23par_id3154505.86.help.text
msgid ""
"Locate the hatches list that you want to load, and then click "
"<emph>Open</emph>. A hatches list file has the format [filename].soh."
msgstr ""
"Leta rätt på skrafferingstabellen som du ska ladda och klicka på "
"<emph>Öppna</emph>. En skrafferingstabellfil har formatet [filnamn].soh."

#: palette_files.xhp%23par_id3149881.87.help.text
msgid ""
"To save a hatches list, click the <emph>Save Hatches List</emph> button, "
"enter a filename, and then click <emph>Save</emph>."
msgstr ""
"Om du vill spara en skrafferingstabell klickar du på knappen <emph>Spara "
"skrafferingstabell</emph>, anger ett filnamn och klickar på "
"<emph>Spara</emph>."

#: palette_files.xhp%23par_id3155437.72.help.text
msgid ""
"<link href=\"text/shared/01/05210000.xhp\" name=\"Format - Area\">Format - "
"Area</link>"
msgstr ""
"<link href=\"text/shared/01/05210000.xhp\" name=\"Format - Yta\">Format - "
"Yta</link>"

#: layers.xhp%23tit.help.text
msgid "About Layers"
msgstr "Om nivåer"

#: layers.xhp%23bm_id3149018.help.text
msgid "<bookmark_value>layers; definition</bookmark_value>"
msgstr "<bookmark_value>Nivåer; definition</bookmark_value>"

#: layers.xhp%23hd_id3149018.9.help.text
msgid ""
"<variable id=\"layers\"><link href=\"text/simpress/guide/layers.xhp\" name=\""
"About Layers\">About Layers</link></variable>"
msgstr ""
"<variable id=\"layers\"><link href=\"text/simpress/guide/layers.xhp\" name=\""
"Om nivåer\">Om nivåer</link></variable>"

#: layers.xhp%23par_id3146313.3.help.text
msgid ""
"Layers are available in $[officename] Draw, not in $[officename] Impress. "
"Layers allow you to assemble elements on a page that are related. Think of "
"layers as individual workspaces that you can hide from view, hide from "
"printing, or lock. "
msgstr ""
"Nivåer används i $[officename] Draw, inte i $[officename] Impress. Med hjälp "
"av nivåer kan du samla element på en sida som är relaterade till varandra. "
"Nivåer är som enskilda arbetsområden som du kan dölja i en vy, dölja från "
"utskrift eller spärra. "

#: layers.xhp%23par_id7036957.help.text
msgid ""
"Layers do not determine the stacking order of objects on your page, except "
"for the <emph>Controls</emph> layer which is always in front of other "
"layers. "
msgstr ""
"Nivåer bestämmer inte staplingsordningen för objekten på sidan, med undantag "
"för <emph>Kontroller</emph>-nivån som alltid placeras framför andra nivåer. "

#: layers.xhp%23par_id1614734.help.text
msgid ""
"The stacking order of objects on your page is determined by the sequence in "
"which you add the objects. You can rearrange the stacking order by <item "
"type=\"menuitem\">Modify - Arrange</item>. "
msgstr ""
"Staplingsordningen för objekten på sidan bestäms utifrån vilken ordning du "
"lägger till dem. Du kan ändra staplingsordningen med hjälp av <item type=\""
"menuitem\">Ändra - Placering</item>. "

#: layers.xhp%23par_id398876.help.text
msgid "The areas on a layer that do not contain objects are transparent."
msgstr ""
"De områden på en nivå som inte innehåller några objekt är genomskinliga."

#: layers.xhp%23par_id3146962.12.help.text
msgid "$[officename] Draw provides three default layers:"
msgstr "I $[officename] Draw finns tre standardnivåer:"

#: layers.xhp%23par_id3153073.13.help.text
msgid "Layout"
msgstr "Layout"

#: layers.xhp%23par_id3149053.14.help.text
msgid "Controls"
msgstr "Kontroller"

#: layers.xhp%23par_id3150391.15.help.text
msgid "Dimension Lines"
msgstr "Måttlinjer"

#: layers.xhp%23par_id3156397.16.help.text
msgid ""
"You cannot delete or rename the default layers. You can add your own layers "
"by <item type=\"menuitem\">Insert - Layer</item>."
msgstr ""
"Du kan inte ta bort eller byta namn på standardnivåer. Du kan lägga till "
"egna nivåer med hjälp av <item type=\"menuitem\">Infoga - Nivå</item>."

#: layers.xhp%23par_id3150534.17.help.text
msgid ""
"The <emph>Layout</emph> layer is the default workspace. The "
"<emph>Layout</emph> layer determines the location of title, text, and object "
"placeholders on your page."
msgstr ""
"Nivån <emph>Layout</emph> är standardarbetsområdet. <emph>Layout</emph>-"
"nivån bestämmer placeringen av rubriker, text och objektplatshållare på "
"sidan."

#: layers.xhp%23par_id3150742.18.help.text
msgid ""
"The <emph>Controls</emph> layer can be used for buttons that have been "
"assigned an action, but that should not be printed. Set the layer's "
"properties to not printable. Objects on the <emph>Controls</emph> layer are "
"always in front of objects on other layers."
msgstr ""
"Nivån <emph>Kontroller</emph> kan användas för knappar som tilldelats en "
"åtgärd men som inte ska skrivas ut. Ställ in nivåns egenskaper på ej "
"utskrivbara. Objekt på <emph>Kontroller</emph>-nivån placeras alltid framför "
"objekt på andra nivåer."

#: layers.xhp%23par_id3153085.19.help.text
msgid ""
"The <emph>Dimension Lines</emph> layer is where you draw, for example, the "
"dimension lines. By switching the layer to show or hide, you can easily "
"switch these lines on and off."
msgstr ""
"Nivån <emph>Måttlinjer</emph> använder du för att rita t.ex. måttlinjer. "
"Genom att växla mellan att visa och dölja nivån kan du enkelt välja att visa "
"linjerna eller inte."

#: layers.xhp%23par_id3154507.2.help.text
msgid ""
"You can lock a layer to protect its contents, or hide a layer and its "
"contents from view or from printing. When you add a new layer to a page, the "
"layer is added to all of the pages in your document. However, when you add "
"an object to a layer, it is only added to the current page. If you want the "
"object to appear on all of the pages, add the object to the master page (<"
"item type=\"menuitem\">View - Master</item>)."
msgstr ""
"Du kan låsa en nivå om du vill skydda innehållet, eller dölja nivån och dess "
"innehåll från att visas eller skrivas ut. När du lägger till en ny nivå på "
"en sida, läggs nivån till på alla sidor i dokumentet. När du lägger till ett "
"objekt på en nivå, läggs det emellertid bara till på den aktuella sidan. Om "
"du vill att objektet ska visas på alla sidor, lägger du till det på "
"bakgrundssidan (<item type=\"menuitem\">Visa - Bakgrund</item>)."

#: html_import.xhp%23tit.help.text
msgid "Importing HTML Pages Into Presentations "
msgstr "Importera HTML-sidor till presentationer "

#: html_import.xhp%23bm_id3146121.help.text
msgid ""
"<bookmark_value>importing; presentations with "
"HTML</bookmark_value><bookmark_value>presentations; importing "
"HTML</bookmark_value><bookmark_value>HTML; importing into "
"presentations</bookmark_value><bookmark_value>text documents;inserting in "
"slides</bookmark_value><bookmark_value>inserting; text in "
"presentations</bookmark_value>"
msgstr ""
"<bookmark_value>importera;presentationer med "
"HTML</bookmark_value><bookmark_value>presentationer;importera "
"HTML</bookmark_value><bookmark_value>HTML;importera till "
"presentationer</bookmark_value><bookmark_value>textdokument;infoga i "
"bilder</bookmark_value><bookmark_value>infoga;text i "
"presentationer</bookmark_value>"

#: html_import.xhp%23hd_id3146121.1.help.text
msgid ""
"<variable id=\"html_import\"><link href=\"text/simpress/guide/html_import."
"xhp\" name=\"Importing HTML Pages Into Presentations \">Importing HTML Pages "
"Into Presentations </link></variable>"
msgstr ""
"<variable id=\"html_import\"><link href=\"text/simpress/guide/html_import."
"xhp\" name=\"Importera HTML-sida till presentation\">Importera HTML-sida "
"till presentation</link></variable>"

#: html_import.xhp%23par_id3150750.2.help.text
msgid ""
"You can import any text file, including text in HTML documents, into a slide."
msgstr ""
"Du kan importera alla typer av textfiler, inklusive text i HTML dokument "
"till en sida."

#: html_import.xhp%23hd_id3155443.11.help.text
msgid "To insert text from a file into a slide:"
msgstr "Så här infogar du text från en fil till en sida:"

#: html_import.xhp%23par_id3146313.4.help.text
msgid ""
"In the slide where you want to insert the text, choose <emph>Insert - "
"File</emph>."
msgstr ""
"Öppna den sida där texten ska infogas och välj <emph>Infoga - Fil</emph>."

#: html_import.xhp%23par_id3150207.5.help.text
msgid "Select \"Text\" or \"HTML Document\" as the <emph>File type</emph>."
msgstr "Välj \"Text\" eller \"HTML dokument\" i listan <emph>Filformat</emph>."

#: html_import.xhp%23par_id3148610.12.help.text
msgid ""
"Locate the file containing the text that you want to add, and then click "
"<emph>Insert</emph>."
msgstr ""
"Leta rätt på filen med texten som ska läggas till och klicka på "
"<emph>Infoga</emph>."

#: html_import.xhp%23par_id3153915.6.help.text
msgid ""
"If the text file contains more text than can be inserted into a single "
"slide, you can divide the text over several slides."
msgstr ""
"Om textfilen innehåller mer text än vad som får plats på en sida, kan du "
"dela upp texten på flera sidor."

#: html_import.xhp%23par_id3149126.7.help.text
msgid "Double-click in the inserted text to enter edit mode."
msgstr "Dubbelklicka i den infogade texten för att byta till redigeringsläge."

#: html_import.xhp%23par_id3143228.8.help.text
msgid ""
"Select all of the text that lies below the visible slide area and press <"
"switchinline select=\"sys\"><caseinline select=\"MAC\">Command "
"</caseinline><defaultinline>Ctrl</defaultinline></switchinline>+X."
msgstr ""
"Markera all text som inte får plats på bilden och tryck <switchinline select="
"\"sys\"><caseinline select=\"MAC\""
">Kommando</caseinline><defaultinline>Ctrl</defaultinline></switchinline>+X."

#: html_import.xhp%23par_id3153811.9.help.text
msgid ""
"Choose <emph>Insert – Slide</emph>, and then press <switchinline select=\""
"sys\"><caseinline select=\"MAC\">Command "
"</caseinline><defaultinline>Ctrl</defaultinline></switchinline>+V."
msgstr ""
"Välj <emph>Infoga - Bild</emph> och tryck på <switchinline select=\"sys\"><"
"caseinline select=\"MAC\""
">Kommando</caseinline><defaultinline>Ctrl</defaultinline></switchinline>+V."

#: html_import.xhp%23par_id3147297.10.help.text
msgid "Repeat steps 1 to 3 until all of the text is on slides."
msgstr "Upprepa steg 1 till 3 tills all text finns på bilder."

#: html_export.xhp%23tit.help.text
msgid "Saving a Presentation in HTML Format"
msgstr "Spara en presentation i HTML-format"

#: html_export.xhp%23bm_id3155067.help.text
msgid ""
"<bookmark_value>exporting;presentations to "
"HTML</bookmark_value><bookmark_value>saving;as "
"HTML</bookmark_value><bookmark_value>presentations; exporting to "
"HTML</bookmark_value><bookmark_value>HTML; exporting from "
"presentations</bookmark_value>"
msgstr ""
"<bookmark_value>Exportera; presentationer till "
"HTML</bookmark_value><bookmark_value>Spara;som "
"HTML</bookmark_value><bookmark_value>Presentationer; exportera till "
"HTML</bookmark_value><bookmark_value>HTML; exportera från "
"presentationer</bookmark_value>"

#: html_export.xhp%23hd_id3155067.1.help.text
msgid ""
"<variable id=\"html_export\"><link href=\"text/simpress/guide/html_export."
"xhp\" name=\"Saving a Presentation in HTML Format\">Saving a Presentation in "
"HTML Format</link></variable>"
msgstr ""
"<variable id=\"html_export\"><link href=\"text/simpress/guide/html_export."
"xhp\" name=\"Spara en presentation i HTML-format\">Spara en presentation i "
"HTML-format</link></variable>"

#: html_export.xhp%23par_id3153246.2.help.text
msgid "Open the presentation that you want to save in HTML format."
msgstr "Öppna presentationen som ska sparas i HTML-format."

#: html_export.xhp%23par_id3149502.3.help.text
msgctxt "html_export.xhp#par_id3149502.3.help.text"
msgid "Choose <emph>File - Export</emph>."
msgstr "Välj <emph>Arkiv - Exportera</emph>."

#: html_export.xhp%23par_id3148842.4.help.text
msgid ""
"Set the <emph>File type</emph> to <emph>HTML Document ($[officename] Impress)"
" (.html;.htm)</emph>."
msgstr ""
"Ange <emph>Filformat</emph> till <emph>HTML dokument ($[officename] Impress) "
"(.html;.htm)</emph>."

#: html_export.xhp%23par_id3143228.8.help.text
msgid "Enter a <emph>File name</emph>, and then click <emph>Export</emph>."
msgstr ""
"Skriv ett namn i rutan <emph>Filnamn</emph> och klicka på "
"<emph>Exportera</emph>."

#: html_export.xhp%23par_id3153808.5.help.text
msgid "Follow the instructions in the <emph>HTML Export</emph> Wizard."
msgstr "Följ instruktionerna i guiden <emph>HTML-export</emph>."

#: html_export.xhp%23par_id3151391.6.help.text
msgid ""
"<link href=\"text/shared/autopi/01110000.xhp\" name=\"HTML Export AutoPilot\""
">HTML Export Wizard</link>"
msgstr ""
"<link href=\"text/shared/autopi/01110000.xhp\" name=\"Guide för HTML-export\""
">Guide för HTML-export</link>"

#: html_export.xhp%23par_id3150394.7.help.text
msgid ""
"<link href=\"text/simpress/01/01170000.xhp\" name=\"File - Export\">File - "
"Export</link>"
msgstr ""
"<link href=\"text/simpress/01/01170000.xhp\" name=\"Arkiv - Exportera\">"
"Arkiv - Exportera</link>"

#: masterpage.xhp%23tit.help.text
msgid "Applying a Slide Design to a Slide Master "
msgstr "Använda en sidformatmall på en bildbakgrund "

#: masterpage.xhp%23bm_id3152596.help.text
msgid ""
"<bookmark_value>slide designs</bookmark_value><bookmark_value>slide masters; "
"designing</bookmark_value><bookmark_value>backgrounds; "
"slides</bookmark_value><bookmark_value>slides; "
"backgrounds</bookmark_value><bookmark_value>master pages, see slide "
"masters</bookmark_value>"
msgstr ""
"<bookmark_value>sidformatmallar</bookmark_value><bookmark_value>bakgrundssido"
"r; designa</bookmark_value><bookmark_value>bakgrunder; "
"bilder</bookmark_value><bookmark_value>bilder; "
"bakgrunder</bookmark_value><bookmark_value>huvudsidor, se "
"bakgrundssidor</bookmark_value>"

#: masterpage.xhp%23hd_id3152596.13.help.text
msgid ""
"<variable id=\"masterpage\"><link href=\"text/simpress/guide/masterpage.xhp\""
" name=\"Applying a Slide Design to a Slide Master\">Applying a Slide Design "
"to a Slide Master</link></variable>"
msgstr ""
"<variable id=\"masterpage\"><link href=\"text/simpress/guide/masterpage.xhp\""
" name=\"Applying a Slide Design to a Slide Master\">Använda en sidformatmall "
"på en bakgrunddssida</link></variable>"

#: masterpage.xhp%23par_id3154017.14.help.text
msgid ""
"Every slide in a presentation has exactly one slide master, also known as "
"master page. A slide master determines the text formatting style for the "
"title and outline and the background design for all slides that use this "
"slide master."
msgstr ""
"Varje bild i en presentation har en bildbakgrund, även kallad sidformatmall. "
"En bildbakgrund bestämmer textformatmallen för rubrik och disposition samt "
"bakgrundsdesign för alla bilder som använder denna bildbakgrund."

#: masterpage.xhp%23hd_id3149018.25.help.text
msgid "To apply a new slide master"
msgstr "Så här använder du en ny bildbakgrund"

#: masterpage.xhp%23par_id3154702.19.help.text
msgid "Select <emph>Format - Slide Design</emph>."
msgstr "Välj <emph>Format - Sidformatmall</emph>."

#: masterpage.xhp%23par_id3148485.20.help.text
msgid "Click <emph>Load</emph>."
msgstr "Klicka på <emph>Ladda</emph>."

#: masterpage.xhp%23par_id3145384.21.help.text
msgid "Under <emph>Categories</emph>, select a slide design category."
msgstr "Välj en kategori för sidformatmallar under <emph>Kategorier</emph>."

#: masterpage.xhp%23par_id3153915.26.help.text
msgid ""
"Under <emph>Templates</emph>, select a template with the design that you "
"want to apply. To preview the template, click <emph>More</emph>, and then "
"select the <emph>Preview </emph>box."
msgstr ""
"Markera en mall under <emph>Mallar</emph> med den presentationsmall som du "
"vill använda. Om du vill förhandsgranska mallen klickar du på "
"<emph>Mer</emph> och markerar rutan <emph>Förhandsgranskning</emph>."

#: masterpage.xhp%23par_id3154652.27.help.text
msgctxt "masterpage.xhp#par_id3154652.27.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: masterpage.xhp%23par_id3145115.28.help.text
msgctxt "masterpage.xhp#par_id3145115.28.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: masterpage.xhp%23par_id3150436.18.help.text
msgid ""
"To apply the slide design to all of the slides in your presentation, select "
"the <emph>Exchange background page</emph> check box, and then click "
"<emph>OK</emph>."
msgstr ""
"Lägg märke till rutan <emph>Byt bakgrundssida</emph>. Om den är markerad "
"gäller sidformatmallen som nu har valts för alla sidor i det aktuella "
"dokumentet. Om den inte är markerad gäller den nya sidformatmallen bara för "
"den aktuella sidan. Du kan alltså tilldela en enskild sida en annan "
"sidformatmall och därmed t.ex. en annan bakgrund."

#: masterpage.xhp%23par_id3151387.29.help.text
msgid ""
"To apply the slide design to the current slide only, clear the <emph>"
"Exchange background page</emph> check box, and then click <emph>OK</emph>."
msgstr ""
"Om du bara vill använda formatmallen för den aktuella sidan avmarkerar du "
"kryssrutan <emph>Byt bakgrundssida</emph> och klickar på <emph>OK</emph>."

#: masterpage.xhp%23par_id3149941.24.help.text
msgid ""
"<link href=\"text/simpress/01/05100000.xhp\" name=\"Styles and Formatting\">"
"Styles and Formatting</link>"
msgstr ""
"<link href=\"text/simpress/01/05100000.xhp\" name=\"Formatmallar och "
"formatering\">Formatmallar och formatering</link>"

#: table_insert.xhp%23tit.help.text
msgid "Including Spreadsheets in Slides"
msgstr "Infoga kalkylblad på bilder"

#: table_insert.xhp%23bm_id3154022.help.text
msgid ""
"<bookmark_value>spreadsheets;in "
"presentations</bookmark_value><bookmark_value>presentations;inserting "
"spreadsheets</bookmark_value><bookmark_value>including "
"spreadsheets</bookmark_value>"
msgstr ""
"<bookmark_value>Kalkylblad;i "
"presentationer</bookmark_value><bookmark_value>Presentationer;infoga "
"kalkylblad</bookmark_value><bookmark_value>Inkludera "
"kalkylblad</bookmark_value>"

#: table_insert.xhp%23hd_id3154022.1.help.text
msgid ""
"<variable id=\"table_insert\"><link href=\"text/simpress/guide/table_insert."
"xhp\" name=\"Including Spreadsheets in Slides\">Including Spreadsheets in "
"Slides</link></variable>"
msgstr ""
"<variable id=\"table_insert\"><link href=\"text/simpress/guide/table_insert."
"xhp\" name=\"Infoga kalkylblad på sidor\">Infoga kalkylblad på "
"sidor</link></variable>"

#: table_insert.xhp%23par_id4231086.help.text
msgid ""
"You can apply different methods to insert spreadsheet cells into your "
"Impress slides or Draw pages:"
msgstr ""
"Det finns olika metoder för att infoga kalkylbladsceller i dina Impress-"
"bilder eller Draw-sidor:"

#: table_insert.xhp%23par_id9209875.help.text
msgid ""
"Insert a native table - you enter the data into the cells and apply fancy "
"formatting using the Table Design section on the Tasks pane."
msgstr ""
"Infoga en intern tabell. Du anger data i cellerna och använder exklusiv "
"formatering med hjälp av Tabellutkast i aktivitetspanelen."

#: table_insert.xhp%23par_id3044526.help.text
msgid ""
"Insert a new table as an OLE object or insert an existing file as an OLE "
"object - you can specify the link to a file to be a live link to the latest "
"data saved in a spreadsheet file."
msgstr ""
"Infoga en ny tabell som ett OLE-objekt eller infoga en befintlig fil som ett "
"OLE-objekt. Du kan ange att länken för en fil ska vara en direktlänk till de "
"senaste data som sparats i ett tabelldokument."

#: table_insert.xhp%23par_id137333.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Enter the number of columns for the "
"new table.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Ange antalet kolumner för den nya "
"tabellen.</ahelp>"

#: table_insert.xhp%23par_id8626667.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Enter the number of rows for the new "
"table.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Ange antalet rader för den nya "
"tabellen.</ahelp>"

#: table_insert.xhp%23par_id0916200803551581.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Define the vertical alignment of "
"selected or all cell contents. Split or merge cells.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Definiera den vertikala justeringen "
"av markerat cellinnehåll eller allt cellinnehåll. Dela eller överlappa "
"celler.</ahelp>"

#: table_insert.xhp%23par_id0916200803551553.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">All selected cells are merged into "
"one cell.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Alla valda celler är sammanfattade "
"till en cell.</ahelp>"

#: table_insert.xhp%23par_id0916200803551535.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">The selected cell is split into "
"several cells. You see the Split Cells dialog box.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Den markerade cellen är delad i flera "
"celler. Dialogrutan Dela celler visas.</ahelp>"

#: table_insert.xhp%23par_id0916200803551651.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">The cell contents are align at the "
"top of the cells.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Cellernas innehåll är justerat mot "
"cellernas överkanter.</ahelp>"

#: table_insert.xhp%23par_id0916200803551697.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">The cell contents are aligned "
"vertically centered in the cells.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Cellernas innehåll är vertikalt "
"centrerat i cellerna.</ahelp>"

#: table_insert.xhp%23par_id0916200803551632.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">The cell contents are aligned at the "
"bottom of the cells.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Cellernas innehåll är justerat mot "
"cellernas underkanter.</ahelp>"

#: table_insert.xhp%23par_idN10626.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Selects the current table.</ahelp>"
msgstr "<ahelp hid=\".\" visibility=\"hidden\">Väljer aktuell tabell.</ahelp>"

#: table_insert.xhp%23par_id0916200803551734.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Choose commands for the selected or "
"all rows.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Välj kommandon för markerade rader "
"eller alla rader.</ahelp>"

#: table_insert.xhp%23par_id0916200804080035.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Distributes the height of the "
"selected or all rows to the same size. The height of the table is not "
"changed.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Fördelar markerade raders eller alla "
"raders höjd till samma storlek. Höjden på tabellen har inte ändrats.</ahelp>"

#: table_insert.xhp%23par_id0916200804080063.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">If currently no cell is selected, all "
"rows will be selected. If currently cells are selected, all rows containing "
"the selected cells will be selected.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Om ingen cell är markerad för "
"närvarande kommer alla rader att markeras. Om celler är markerade kommer "
"alla rader som innehåller de markerade cellerna att markeras.</ahelp>"

#: table_insert.xhp%23par_id091620080408008.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">If currently no cell is selected, a "
"new row will be inserted at the bottom of the table. If currently cells are "
"selected, as many new rows as the selection has will be inserted below the "
"selection.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Om ingen cell är markerad för "
"närvarande kommer en ny rad att infogas längst ned i tabellen. Om celler är "
"markerade för närvarande kommer så många nya rader som markeringen har att "
"infogas under markeringen.</ahelp>"

#: table_insert.xhp%23par_id0916200804080050.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">All rows of the current selection "
"will be deleted.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Alla rader i aktuell markering kommer "
"att raderas.</ahelp>"

#: table_insert.xhp%23par_id0916200804163012.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Choose commands for the selected or "
"all columns.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Välj kommandon för markerade kolumner "
"eller alla kolumner.</ahelp>"

#: table_insert.xhp%23par_id0916200804163092.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Distributes the width of the selected "
"or all columns to the same size. The width of the table is not "
"changed.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Fördelar markerade kolumners eller "
"alla kolumners bredd till samma storlek. Bredden på tabellen har inte "
"ändrats.</ahelp>"

#: table_insert.xhp%23par_id0916200804163046.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">If currently no cell is selected, all "
"columns will be selected. If currently cells are selected, all columns "
"containing the selected cells will be selected.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Om ingen cell är markerad för "
"närvarande kommer alla kolumner att markeras. Om celler är markerade kommer "
"alla kolumner som innehåller de markerade cellerna att markeras.</ahelp>"

#: table_insert.xhp%23par_id0916200804163128.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">If currently no cell is selected, a "
"new column will be inserted at the right border of the table. If currently "
"cells are selected, as many new columns as the selection has will be "
"inserted right of the selection.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Om ingen cell är markerad för "
"närvarande kommer en ny kolumn att infogas på den högra sidan av tabellen. "
"Om celler är markerade för närvarande kommer så många nya kolumner som "
"markeringen har att infogas till höger om markeringen.</ahelp>"

#: table_insert.xhp%23par_id0916200804163127.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">All columns of the current selection "
"will be deleted.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Alla kolumner i aktuell markering "
"kommer att raderas.</ahelp>"

#: table_insert.xhp%23par_id0916200804163151.help.text
msgid ""
"<ahelp hid=\".\" visibility=\"hidden\">Align the table within the page or "
"slide.</ahelp>"
msgstr ""
"<ahelp hid=\".\" visibility=\"hidden\">Justera tabellen inom sidan eller "
"bilden.</ahelp>"

#: table_insert.xhp%23hd_id8594317.help.text
msgid "Inserting a native table"
msgstr "Infoga en intern tabell"

#: table_insert.xhp%23par_id7184972.help.text
msgid ""
"Go to the Impress slide or Draw page where you want to insert the table."
msgstr "Gå till Impress-bilden eller Draw-sidan där du vill infoga tabellen."

#: table_insert.xhp%23par_id248115.help.text
msgid ""
"Choose <item type=\"menuitem\">Insert - Table</item> or use the Table icon "
"on the Standard toolbar to insert a table."
msgstr ""
"Välj <item type=\"menuitem\">Infoga - Tabell</item> eller använd "
"tabellsymbolen på standardverktygsraden för att infoga en tabell."

#: table_insert.xhp%23par_id2748496.help.text
msgid "Double-click the table and enter or paste the data into the cells. "
msgstr "Dubbelklicka på tabellen och skriv eller klistra in data i cellerna. "

#: table_insert.xhp%23par_id8270210.help.text
msgid ""
"Select some cell contents and right-click to open the context menu. Choose "
"commands to change the cell's contents, like font size and line spacing."
msgstr ""
"Markera en del av cellinnehållet och högerklicka för att öppna snabbmenyn. "
"Välj kommandon för att ändra cellernas innehåll, som teckenstorlek och "
"radavstånd."

#: table_insert.xhp%23par_id6820276.help.text
msgid ""
"Right-click the table border to open the table's context menu. Use the "
"table's context menu to enter a name and description for the table, or to "
"distribute the rows or columns equally, among other commands."
msgstr ""
"Högerklicka på tabellramen för att öppna tabellens snabbmeny. Använd "
"tabellens snabbmeny för att bland annat ange ett namn och en beskrivning för "
"tabellen eller för att fördela raderna eller kolumnerna jämnt."

#: table_insert.xhp%23par_id0916200803551725.help.text
msgid ""
"Select some cells and right-click to open a context menu, where you can "
"insert or delete rows and columns, among other commands. "
msgstr ""
"Markera vissa celler och högerklicka för att öppna en snabbmeny där du bland "
"annat kan infoga eller radera rader och kolumner. "

#: table_insert.xhp%23par_id091620080355171.help.text
msgid ""
"To select a rectangular area of cells, point to a cell in one corner of the "
"rectangle, hold down the mouse button, and drag the mouse to the opposite "
"corner of the rectangle, then release the mouse button. "
msgstr ""
"För att markera ett rektangulärt område celler pekar du på en cell i ett av "
"hörnen på rektangeln, håller ned musknappen och drar musen mot motsatt hörn "
"av rektangeln och släpper sedan upp musknappen. "

#: table_insert.xhp%23par_id0916200803551880.help.text
msgid ""
"To select one cell, point to that cell, hold down the mouse button, and drag "
"the mouse to the next cell and back, then release the mouse button."
msgstr ""
"För att markera en cell pekar du på cellen, håller ned musknappen och drar "
"musen till nästa cell och tillbaka igen, släpp sedan upp musknappen."

#: table_insert.xhp%23hd_id3151075.2.help.text
msgid "Inserting a new spreadsheet as an OLE object"
msgstr "Infoga ett nytt kalkylblad som ett OLE-objekt"

#: table_insert.xhp%23par_id3150715.7.help.text
msgid ""
"You can add a blank $[officename] Calc spreadsheet to a slide as an OLE "
"object."
msgstr ""
"Du kan lägga till ett tomt $[officename] Calc kalkylblad på en sida som ett "
"OLE-objekt."

#: table_insert.xhp%23par_id3150749.3.help.text
msgctxt "table_insert.xhp#par_id3150749.3.help.text"
msgid "Go to the slide where you want to insert the spreadsheet."
msgstr "Gå till den sida där du vill infoga objektet."

#: table_insert.xhp%23par_id3146313.18.help.text
msgid ""
"Choose <emph>Insert - OLE- Object</emph>. Click <emph>Create new</emph> and "
"select the %PRODUCTNAME Spreadsheet. Click OK. Click in the spreadsheet to "
"enter your data. "
msgstr ""
"Välj <emph>Infoga - OLE-objekt</emph>. Klicka på <emph>Skapa nytt</emph> och "
"välj %PRODUCTNAME kalkylblad. Klicka på OK. Klicka i kalkylblad för att ange "
"data. "

#: table_insert.xhp%23par_id2466505.help.text
msgid "Click outside the spreadsheet to view the slide."
msgstr "Klicka utanför kalkylbladet om du vill visa bilden."

#: table_insert.xhp%23par_id3148870.9.help.text
msgid ""
"To resize the spreadsheet without resizing the cells, double-click the "
"spreadsheet, and then drag a corner handle. To resize the cells of the "
"spreadsheet, click the spreadsheet, and then drag a corner handle."
msgstr ""
"Om du vill ändra storlek på tabellen utan att ändra storlek på cellerna, "
"dubbelklickar du i tabellen och drar i ett hörnhandtag. Om du vill ändra "
"storlek på cellerna i tabellen klickar du i tabellen och drar i ett "
"hörnhandtag."

#: table_insert.xhp%23hd_id3150215.11.help.text
msgid "Inserting a spreadsheet from a file"
msgstr "Infoga ett kalkylblad från en fil"

#: table_insert.xhp%23par_id3154765.19.help.text
msgid ""
"When you insert an existing spreadsheet into your slide, changes that are "
"made to the original spreadsheet file are not updated on your slide. You "
"can, however, make changes to the spreadsheet in your slide."
msgstr ""
"Om du infogar en tabell på en sida och ändrar i originalfilen kommer "
"ändringarna inte att visas på sidan. Däremot kan du göra ändringar i "
"kalkylbladet på sidan."

#: table_insert.xhp%23par_id3145112.12.help.text
msgctxt "table_insert.xhp#par_id3145112.12.help.text"
msgid "Go to the slide where you want to insert the spreadsheet."
msgstr "Gå till den sida där du vill infoga objektet."

#: table_insert.xhp%23par_id3153075.13.help.text
msgid "Choose <emph>Insert - Object - OLE Object</emph>."
msgstr "Välj <emph>Infoga - Objekt - OLE-objekt</emph>."

#: table_insert.xhp%23par_id3150391.14.help.text
msgid "Select <emph>Create from file</emph>, and click <emph>Search</emph>."
msgstr "Välj <emph>Skapa från fil</emph> och klicka på <emph>Sök</emph>."

#: table_insert.xhp%23par_id3150537.20.help.text
msgid "Locate the file you want to insert, and then click<emph> OK</emph>."
msgstr "Leta rätt på filen som ska infogas och klicka på <emph>OK</emph>."

#: table_insert.xhp%23par_id1616565.help.text
msgid ""
"Enable the <emph>Link to file</emph> checkbox to insert the file as a live "
"link."
msgstr ""
"Aktivera kryssrutan <emph>Länka till fil</emph> om du vill infoga filen som "
"en direktlänk."

#: table_insert.xhp%23par_id3155256.21.help.text
msgid ""
"The entire spreadsheet is inserted into your slide. If you want to change "
"the sheet that is displayed, double-click the spreadsheet, and then select a "
"different sheet."
msgstr ""
"Hela kalkylbladet infogas i sidan. Om du vill ändra vilken tabell som visas "
"dubbelklickar du på kalkylbladet och väljer en annan tabell."

#: table_insert.xhp%23par_id3154505.15.help.text
msgid ""
"<link href=\"text/simpress/01/05130000.xhp\" name=\"Format - Slide Layout\">"
"Format - Slide Layout</link>"
msgstr ""
"<link href=\"text/simpress/01/05130000.xhp\" name=\"Format - Slide Layout\">"
"Format - Bildlayout</link>"

#: table_insert.xhp%23par_id3150335.16.help.text
msgid ""
"<link href=\"text/shared/01/04150100.xhp\" name=\"Insert - Object - OLE "
"Object\">Insert - Object - OLE Object</link>"
msgstr ""
"<link href=\"text/shared/01/04150100.xhp\" name=\"Infoga - Objekt - OLE-"
"objekt\">Infoga - Objekt - OLE-objekt</link>"

#: individual.xhp%23tit.help.text
msgid "Creating a Custom Slide Show"
msgstr "Skapa en individuell bildskärmspresentation"

#: individual.xhp%23bm_id3146119.help.text
msgid ""
"<bookmark_value>slide shows; custom</bookmark_value><bookmark_value>custom "
"slide shows</bookmark_value><bookmark_value>starting; always with the "
"current slide</bookmark_value><bookmark_value>starting;custom slide shows</bo"
"okmark_value><bookmark_value>hiding;slides</bookmark_value><bookmark_value>sh"
"owing;hidden slides</bookmark_value><bookmark_value>hidden "
"pages;showing</bookmark_value>"
msgstr ""
"<bookmark_value>Bildskärmspresentationer; "
"anpassa</bookmark_value><bookmark_value>Individuella "
"bildskärmspresentationer</bookmark_value><bookmark_value>Starta; alltid med "
"den aktuella bilden</bookmark_value><bookmark_value>Starta;individuella bilds"
"kärmspresentationer</bookmark_value><bookmark_value>Dölja;bilder</bookmark_va"
"lue><bookmark_value>Visa;dolda bilder</bookmark_value><bookmark_value>Dolda "
"sidor;visa</bookmark_value>"

#: individual.xhp%23hd_id3146119.55.help.text
msgid ""
"<variable id=\"individual\"><link href=\"text/simpress/guide/individual.xhp\""
" name=\"Creating a Custom Slide Show\">Creating a Custom Slide "
"Show</link></variable>"
msgstr ""
"<variable id=\"individual\"><link href=\"text/simpress/guide/individual.xhp\""
" name=\"Skapa en individuell bildskärmspresentation\">Skapa en individuell "
"bildskärmspresentation</link></variable>"

#: individual.xhp%23par_id3150344.71.help.text
msgid ""
"You can create custom slide shows to meet the needs of your audience using "
"slides within the current presentation."
msgstr ""
"Du kan skapa anpassade bildskärmspresentationer, som är utformade speciellt "
"för din publik, med sidorna i den aktuella presentationen."

#: individual.xhp%23hd_id3150715.72.help.text
msgid "To create a custom slide show:"
msgstr "Så här skapar du en individuell bildskärmspresentation:"

#: individual.xhp%23par_id3153712.61.help.text
msgid "Choose <emph>Slide Show - Custom Slide Shows</emph>."
msgstr ""
"Välj <emph>Bildskärmspresentation - Individuell "
"bildskärmspresentation</emph>."

#: individual.xhp%23par_id3153966.62.help.text
msgid ""
"Click <emph>New</emph> and enter a name for your slide show in the <emph>"
"Name </emph>box."
msgstr ""
"Klicka på <emph>Ny</emph> och ange ett namn på presentationen i rutan "
"<emph>Namn</emph>."

#: individual.xhp%23par_id3150249.73.help.text
msgid ""
"Under <emph>Existing Slides</emph>, select the slides you want to add to "
"your slide show, and click the <emph>>></emph> button. Hold down Shift to "
"select a range of slides, or Ctrl to select multiple slides."
msgstr ""
"Markera de sidor som ska ingå i presentationen under <emph>Presentationens "
"sidor</emph> och klicka på <emph>>></emph>-knappen. Du kan markera flera "
"sidor i följd genom att hålla ned Skift, eller flera enstaka sidor genom att "
"hålla ned Ctrl."

#: individual.xhp%23par_id3153916.64.help.text
msgid ""
"You can change the order of the slides in your custom slide show, by "
"dragging and dropping the slides under <emph>Selected Slides</emph>."
msgstr ""
"Du kan ändra ordningen på sidorna i presentationen genom att dra och släppa "
"sidorna under <emph>Individuell presentation</emph>."

#: individual.xhp%23hd_id3151387.74.help.text
msgid "To start a custom slide show:"
msgstr "Så här startar du en individuell bildskärmspresentation:"

#: individual.xhp%23par_id3147403.75.help.text
msgid "Choose <emph>Slide Show - Custom Slide Show</emph>."
msgstr ""
"Välj <emph>Bildskärmspresentation - Individuell "
"bildskärmspresentation</emph>."

#: individual.xhp%23par_id3150538.76.help.text
msgid "Select the show you want to start from the list."
msgstr "Markera den presentation som du ska starta i listan."

#: individual.xhp%23par_id3149943.77.help.text
msgid "Click <emph>Start</emph>."
msgstr "Klicka på <emph>Starta</emph>."

#: individual.xhp%23par_id3145593.56.help.text
msgid ""
"If you want the selected custom slide show to start when you click the <emph>"
"Slide Show</emph> icon on the<emph> Presentation</emph> toolbar, or when you "
"press F5, select <emph>Use Custom Slide Show</emph>."
msgstr ""
"Om du vill att den markerade presentationen ska starta när du klickar på "
"ikonen <emph>Bildskärmspresentation</emph> på verktygsraden "
"<emph>Presentation</emph>, eller när du trycker på F5, markerar du <emph>"
"Använd individuell bildskärmspresentation</emph>."

#: individual.xhp%23hd_id3145169.78.help.text
msgid "Options for Running a Slide Show"
msgstr "Alternativ för att visa en bildskärmspresentation"

#: individual.xhp%23hd_id3150335.65.help.text
msgid "To always start a slide show from the current slide:"
msgstr "Om du alltid vill börja presentationen från den aktuella sidan:"

#: individual.xhp%23par_id3150014.66.help.text
msgid ""
"Choose <emph><switchinline select=\"sys\"><caseinline select=\"MAC\">%"
"PRODUCTNAME - Preferences</caseinline><defaultinline>Tools - "
"Options</defaultinline></switchinline> - %PRODUCTNAME Impress - "
"General</emph>."
msgstr ""
"Välj <emph><switchinline select=\"sys\"><caseinline select=\"MAC\">%"
"PRODUCTNAME – Inställningar</caseinline><defaultinline>Verktyg – "
"Alternativ</defaultinline></switchinline> – %PRODUCTNAME Impress – "
"Allmänt</emph>."

#: individual.xhp%23par_id3155932.67.help.text
msgid ""
"In the <emph>Start presentation</emph> area, select the <emph>Always with "
"current page</emph> check box."
msgstr ""
"I området <emph>Starta presentation</emph> markerar du rutan <emph>Alltid "
"med aktuell sida</emph>."

#: individual.xhp%23par_id3155372.68.help.text
msgid "Do not select this option if you want to run a custom slide show."
msgstr ""
"Du ska inte markera det här alternativet om vill köra en individuell "
"presentation."

#: individual.xhp%23hd_id3153922.69.help.text
msgid "To hide a slide:"
msgstr "Så här döljer du en sida:"

#: individual.xhp%23par_id883150344.help.text
msgid "To hide the current slide, click the Hide Slide action button."
msgstr "Klicka på Göm bild-knappen för att gömma"

#: individual.xhp%23par_id3156261.57.help.text
msgid ""
"To hide several slides, choose <emph>View - Slide Sorter</emph>, and then "
"select the slide(s) that you want to hide."
msgstr ""
"Välj <emph>Visa - Bildsortering</emph> och markera den eller de bilder som "
"du vill dölja."

#: individual.xhp%23par_id3083278.79.help.text
msgctxt "individual.xhp#par_id3083278.79.help.text"
msgid "Choose <emph>Slide Show - Show/Hide Slide</emph>."
msgstr "Välj <emph>Bildskärmspresentation - Visa diabild</emph>."

#: individual.xhp%23par_id3151264.58.help.text
msgid "The slide is not removed from your document."
msgstr "Sidan kommer inte att tas bort från dokumentet."

#: individual.xhp%23hd_id3147570.80.help.text
msgid "To show a hidden slide:"
msgstr "Så här visar du en dold sida:"

#: individual.xhp%23par_id3145210.81.help.text
msgid ""
"Choose <emph>View - Slide Sorter</emph>, and then select the hidden slide(s) "
"that you want to show."
msgstr ""
"Välj <emph>Visa - Bildsortering</emph> och markera den eller de dolda bilder "
"som du vill visa."

#: individual.xhp%23par_id3150260.59.help.text
msgctxt "individual.xhp#par_id3150260.59.help.text"
msgid "Choose <emph>Slide Show - Show/Hide Slide</emph>."
msgstr ""
"Välj <emph>Bildskärmspresentation - Visa diabild</emph> när du vill visa "
"diabilden igen."

#: footer.xhp%23tit.help.text
msgid "Adding a Header or a Footer to All Slides"
msgstr "Lägga till ett sidhuvud eller sidfot i alla bilder"

#: footer.xhp%23bm_id3153191.help.text
msgid ""
"<bookmark_value>footers;slide masters</bookmark_value><bookmark_value>slide "
"masters; headers and footers</bookmark_value><bookmark_value>headers and "
"footers; slide masters</bookmark_value><bookmark_value>inserting;headers/"
"footers in all slides</bookmark_value><bookmark_value>slide numbers on all "
"slides</bookmark_value><bookmark_value>page numbers on all "
"slides</bookmark_value><bookmark_value>date on all "
"slides</bookmark_value><bookmark_value>time and date on all "
"slides</bookmark_value>"
msgstr ""
"<bookmark_value>sidfötter;bakgrundssidor</bookmark_value><bookmark_value>bakg"
"rundssidor;sidhuvuden och sidfötter</bookmark_value><bookmark_value>"
"sidhuvuden och "
"sidfötter;bakgrundssidor</bookmark_value><bookmark_value>infoga;sidhuvuden/"
"sidfötter i alla bilder</bookmark_value><bookmark_value>bildnummer på alla "
"bilder</bookmark_value><bookmark_value>sidnummer på alla "
"bilder</bookmark_value><bookmark_value>datum på alla "
"bilder</bookmark_value><bookmark_value>tid och datum på alla "
"bilder</bookmark_value>"

#: footer.xhp%23hd_id3153191.1.help.text
msgid ""
"<variable id=\"footer\"><link href=\"text/simpress/guide/footer.xhp\" name=\""
"Adding a Header or a Footer to All Slides\">Adding a Header or a Footer to "
"All Slides</link> </variable>"
msgstr ""
"<variable id=\"footer\"><link href=\"text/simpress/guide/footer.xhp\" name=\""
"Lägga till sidhuvud eller sidfot på alla bilder\">Lägga till sidhuvud eller "
"sidfot på alla bilder</link> </variable>"

#: footer.xhp%23par_id1356547.help.text
msgid ""
"Every slide is based on a slide master. The text, pictures, tables, fields "
"or other objects that you place on the slide master are visible as a "
"background on all slides that are based on that slide master."
msgstr ""
"Varje bild baseras på en bakgrundssida. Texter, bilder, tabeller, fält eller "
"andra objekt som du placerar på bakgrundssidan, visas som bakgrund på alla "
"bilder som baseras på den bakgrundssidan."

#: footer.xhp%23par_id704672.help.text
msgid "Masters exist for slides, notes, and handouts. "
msgstr "Bakgrunder finns för alla bilder, anteckningar och flygblad. "

#: footer.xhp%23par_id8403576.help.text
msgid ""
"To edit a slide master, choose <emph>View - Master - Slide Master</emph>. "
"Click the Close Master View icon on the Master View toolbar, or choose <emph>"
"View - Normal</emph>, to leave the slide master."
msgstr ""
"Vill du redigera en bakgrundssida väljer du <emph>Visa - Bakgrund - "
"Bakgrundssida</emph>. Klicka på ikonen Stäng bakgrundsvy på verktygsraden "
"Bakgrundsvy eller välj <emph>Visa - Normal</emph> om du vill lämna "
"bakgrundssidan."

#: footer.xhp%23par_id5641651.help.text
msgid ""
"To edit a notes master, choose <emph>View - Master - Notes Master</emph>. "
"Click the Close Master View icon on the Master View toolbar, or choose <emph>"
"View - Normal</emph>, to leave the notes master."
msgstr ""
"Vill du redigera en anteckningsbakgrund väljer du <emph>Visa - Bakgrund - "
"Anteckningsbakgrund</emph>. Klicka på ikonen Stäng bakgrundsvy på "
"verktygsraden Bakgrundsvy eller välj <emph>Visa - Normal</emph> om du vill "
"lämna anteckningsbakgrunden."

#: footer.xhp%23par_id1583300.help.text
msgid ""
"To edit a handout master, click the Handout tab above the slide. Click the "
"Normal tab to leave the handout master."
msgstr ""
"Vill du redigera flygbladsbakgrund klickar du på fliken Flygblad ovanför "
"bilden. Klicka på fliken Normal om du vill lämna flygbladsbakgrunden."

#: footer.xhp%23hd_id7251808.help.text
msgid "Adding predefined header or footer objects"
msgstr "Lägger till fördefinierade objekt för sidhuvud eller sidfot"

#: footer.xhp%23par_id5015411.help.text
msgid ""
"Every type of master has some predefined areas to hold the date, footer, and "
"slide numbers. "
msgstr ""
"Varje typ av bakgrund har ett fördefinierat område som visar datum, sidfot "
"och bildnummer. "

#: footer.xhp%23par_id8217413.help.text
msgid ""
"When you switch to the master view, you can move that areas to any position "
"on the master. You can enter additional text and resize the areas. You can "
"select the contents of the areas and apply text formats. For example, you "
"can change the font size or color."
msgstr ""
"När du byter till bakgrundsvy kan du flytta de områden till valfri position "
"på bakgrunden. Du kan ange övrig text och ändra storlek på områden. Du kan "
"välja innehåll i områden och ange textformat. Du kan exempelvis ändra "
"teckenstorlek eller färg."

#: footer.xhp%23par_id7549668.help.text
msgid ""
"A predefined Header Area is available only for notes and handouts. If you "
"want a header on all slides, you can move the Footer Area on the slide "
"master to the top."
msgstr ""
"Ett fördefinierat område för sidhuvud finns bara för anteckningar och "
"flygblad. Vill du ha ett sidhuvud för alla bilder kan du flytta området för "
"sidfoten överst på bakgrundssidan."

#: footer.xhp%23par_id1829889.help.text
msgid ""
"Objects that you insert on a slide master are visible on all slides that are "
"based on that slide master."
msgstr ""
"Objekt som du infogar på en bakgrundssida kommer att synas på alla bilder "
"som baseras på den bakgrundssidan."

#: footer.xhp%23par_id8843043.help.text
msgid "Choose <emph>View - Header and Footer</emph>."
msgstr "Välj <emph>Visa - Sidhuvud och sidfot</emph>"

#: footer.xhp%23par_id1876583.help.text
msgid ""
"You see a dialog with two tab pages: <emph>Slide</emph> and <emph>Notes and "
"Handouts</emph> where you can enter contents to the predefined areas. "
msgstr ""
"En dialogruta med två fliksidor visas: <emph>Bild</emph> och <emph>"
"Anteckningar och flygblad</emph> där du kan ange innehåll för fördefinierade "
"områden. "

#: footer.xhp%23par_id4101077.help.text
msgid ""
"By default, the <emph>Date and Time</emph> checkbox is enabled, but the "
"format is set to Fixed and the text input box is empty, so no date and time "
"is visible on the slides."
msgstr ""
"Som standard är kryssrutan <emph>Datum och tid</emph> aktiverad men formatet "
"är angett som Fast och  textinmatningsrutan är tom, vilket innebär att datum "
"och tid inte syns på bilderna."

#: footer.xhp%23par_id204779.help.text
msgid ""
"By default, the <emph>Footer</emph> checkbox is enabled, but the text input "
"box is empty, so no footer is visible on the slides."
msgstr ""
"Som standard är kryssrutan <emph>Sidfot</emph> aktiverad men "
"textinmatningsrutan är tom, vilket innebär att sidfoten inte syns på "
"bilderna."

#: footer.xhp%23par_id1453901.help.text
msgid ""
"By default, the <emph>Slide number</emph> checkbox is cleared, so no slide "
"numbers are visible."
msgstr ""
"Som standard är kryssrutan <emph>Bildnummer</emph> avmarkerad, vilket "
"innebär att sidnummer inte syns."

#: footer.xhp%23par_id1445966.help.text
msgid "Enter or select the contents that should be visible on all slides."
msgstr "Ange eller välj innehåll som ska synas på alla bilder."

#: footer.xhp%23par_id1956236.help.text
msgid ""
"If you want to change the position and formatting of the master objects, "
"choose <emph>View - Master - Slide Master</emph>."
msgstr ""
"Om du vill ändra position och formatering för bakgrundsobjekt väljer du "
"<emph>Visa - Bakgrund - Bildbakgrund</emph>."

#: footer.xhp%23par_id5259559.help.text
msgid ""
"You see the slide master with areas near the bottom. You can move the areas "
", and you can select the fields and apply some formatting. You can also "
"enter some text here which will be shown next to the fields."
msgstr ""
"Bildbakgrunden med områden visas nästan längst ned. Du kan flytta områden, "
"välja fält och tillämpa viss formatering. Du kan även ange text här som "
"sedan visas bredvid fälten."

#: footer.xhp%23par_id2521439.help.text
msgid ""
"Click the Date Area and move the time and date field. Select the <date/time> "
"field and apply some formatting to change the format for the date and time "
"on all slides. The same applies to the Footer Area and the Slide Number Area."
msgstr ""
"Klicka på Datumområde och flytta fältet Tid och datum. Markera fältet "
"<date/time> och tillämpa formatering för att ändra tids- eller datumformat "
"för alla bilder.  Det här gäller även områdena sidfot och bildnummer."

#: footer.xhp%23hd_id4712057.help.text
msgid "Adding text objects as header or footer objects"
msgstr "Lägger till textobjekt som objekt för sidhuvud eller sidfot"

#: footer.xhp%23par_id3155064.16.help.text
msgid "You can add a text object anywhere on the slide master."
msgstr "Du kan lägga till ett textobjekt var som helst på bakgrundssidan."

#: footer.xhp%23par_id3148866.14.help.text
msgid "Choose <emph>View - Master - Slide Master</emph>."
msgstr "Välj <emph>Visa - Bakgrund - Bildbakgrund</emph>."

#: footer.xhp%23par_id3147295.12.help.text
msgid ""
"On the <emph>Drawing</emph> bar, select the <emph>Text</emph> icon <image id="
"\"img_id3154654\" src=\"res/commandimagelist/sc_texttoolbox.png\" width=\"0."
"222inch\" height=\"0.222inch\"><alt id=\"alt_id3154654\">Icon</alt></image>."
msgstr ""
"Välj ikonen <emph>Text</emph> <image id=\"img_id3154654\" src=\""
"res/commandimagelist/sc_texttoolbox.png\" width=\"0.222inch\" height=\"0."
"222inch\"><alt id=\"alt_id3154654\">Ikon</alt></image> på verktygsraden "
"<emph>Ritverktyg</emph>."

#: footer.xhp%23par_id3149947.10.help.text
msgid ""
"Drag in the slide master to draw a text object, and then type or paste your "
"text."
msgstr ""
"Dra på bakgrundssidan för att rita ett textobjekt, och skriv eller klistra "
"in texten."

#: footer.xhp%23par_id3155441.4.help.text
msgid "Choose <emph>View - Normal</emph> when you are finished."
msgstr "Välj <emph>Visa - Normal</emph> när du är klar."

#: footer.xhp%23par_id3150476.17.help.text
msgid ""
"You can also add fields, such as the date or page number, to a header or "
"footer by choosing <emph>Insert - Fields</emph>."
msgstr ""
"Du kan också infoga fält, som t.ex. datum eller sidnummer, i en sidfot eller "
"ett sidhuvud genom att välja <emph>Infoga - Fältkommando</emph>."

#: footer.xhp%23par_id3156320.18.help.text
msgid ""
"You can hide the header or footer on the current slide by choosing "
"<emph>Format</emph> - <link href=\"text/simpress/01/05130000.xhp\" name=\""
"Modify Layout\">Slide<emph> Layout</emph></link>, and clearing the <emph>"
"Objects on background</emph> check box."
msgstr ""
"Du kan dölja sidhuvudet eller sidfoten på den aktuella sidan genom att välja "
"<emph>Format</emph> - <link href=\"text/simpress/01/05130000.xhp\" name=\""
"Modifiera layout\">Bild<emph>layout</emph></link> och avmarkera kryssrutan "
"<emph>Objekt på bakgrunden</emph>."

#: footer.xhp%23par_id3155848.21.help.text
msgid ""
"<link href=\"text/simpress/01/04990000.xhp\" name=\"Insert Fields\">Insert "
"Fields</link>"
msgstr ""
"<link href=\"text/simpress/01/04990000.xhp\" name=\"Infoga fält\">Infoga "
"fält</link>"

#: vectorize.xhp%23tit.help.text
msgid "Converting Bitmap Images into Vector Graphics"
msgstr "Konvertera bitmapbilder till vektorgrafik"

#: vectorize.xhp%23bm_id3153415.help.text
msgid ""
"<bookmark_value>vectorizing "
"bitmaps</bookmark_value><bookmark_value>converting; bitmaps to "
"polygons</bookmark_value><bookmark_value>bitmaps; converting to vector "
"graphics</bookmark_value><bookmark_value>vector graphics;converting "
"bitmaps</bookmark_value>"
msgstr ""
"<bookmark_value>Vektorisera "
"bitmap</bookmark_value><bookmark_value>Konvertera; bitmap till "
"polygon</bookmark_value><bookmark_value>Bitmap; konvertera till "
"vektorgrafik</bookmark_value><bookmark_value>Vektorgrafik;konvertera "
"bitmap</bookmark_value>"

#: vectorize.xhp%23hd_id3153415.26.help.text
msgid ""
"<variable id=\"vectorize\"><link href=\"text/simpress/guide/vectorize.xhp\" "
"name=\"Converting Bitmap Images into Vector Graphics\">Converting Bitmap "
"Images into Vector Graphics</link></variable>"
msgstr ""
"<variable id=\"vectorize\"><link href=\"text/simpress/guide/vectorize.xhp\" "
"name=\"Omvandla bitmapbilder till vektorgrafik\">Omvandla bitmapbilder till "
"vektorgrafik</link></variable>"

#: vectorize.xhp%23par_id3155633.27.help.text
msgid ""
"A vector graphic can be resized without losing the quality of the graphic. "
"In $[officename] Draw and Impress, you can convert a bitmap image into a "
"vector graphic."
msgstr ""
"Du kan ändra storlek på vektorgrafik utan att kvaliteten försämras. I "
"$[officename] Draw och Impress kan du konvertera en bitmapsbild till "
"vektorgrafik."

#: vectorize.xhp%23par_id3151241.28.help.text
msgid "Select the bitmap image that you want to convert."
msgstr "Markera den bitmapbild som du ska omvandla."

#: vectorize.xhp%23par_id3153812.29.help.text
msgctxt "vectorize.xhp#par_id3153812.29.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: vectorize.xhp%23par_id3145118.37.help.text
msgid ""
"In $[officename] Draw, choose <emph>Modify - Convert - To Polygon</emph>."
msgstr ""
"I $[officename] Draw väljer du <emph>Ändra - Omvandla - Till polygon</emph>."

#: vectorize.xhp%23par_id3151387.38.help.text
msgid ""
"In $[officename] Impress, right-click the object, and then choose <emph>"
"Convert - To Polygon</emph>."
msgstr ""
"I $[officename] Impress högerklickar du på objektet och väljer <emph>"
"Omvandla - Till polygon</emph>."

#: vectorize.xhp%23par_id3149349.30.help.text
msgid ""
"Set the conversion options for the image, and then click <emph>OK</emph>. "
"See <link href=\"text/simpress/01/13050200.xhp\" name=\"Convert to Polygon\""
"><emph>Convert to Polygon</emph></link> for a description of the conversion "
"options."
msgstr ""
"Gör inställningar för omvandlingen av bilden och klicka på <emph>OK</emph>. "
"Se avsnittet <link href=\"text/simpress/01/13050200.xhp\" name=\"Omvandla "
"till polygon\"><emph>Omvandla till polygon</emph></link> för en beskrivning "
"av alternativen."

#: vectorize.xhp%23par_id3147371.help.text
msgid ""
"<link href=\"text/simpress/01/13050200.xhp\" name=\"Convert to Polygon\">"
"Convert to Polygon</link>"
msgstr ""
"<link href=\"text/simpress/01/13050200.xhp\" name=\"Konvertera till polygon\""
">Konvertera till polygon</link>"

#: main.xhp%23tit.help.text
msgid "Instructions for Using $[officename] Impress"
msgstr "Instruktioner för hur du använder $[officename] Impress"

#: main.xhp%23bm_id3156386.help.text
msgid ""
"<bookmark_value>$[officename] Impress "
"instructions</bookmark_value><bookmark_value>instructions; $[officename] "
"Impress</bookmark_value>"
msgstr ""
"<bookmark_value>$[officename] Impress; "
"anvisningar</bookmark_value><bookmark_value>Anvisningar; $[officename] "
"Impress</bookmark_value>"

#: main.xhp%23hd_id3156386.1.help.text
msgid ""
"<variable id=\"main\"><link href=\"text/simpress/guide/main.xhp\" name=\""
"Instructions for Using $[officename] Impress\">Instructions for Using "
"$[officename] Impress</link></variable>"
msgstr ""
"<variable id=\"main\"><link href=\"text/simpress/guide/main.xhp\" name=\""
"Anvisningar för $[officename] Impress\">Anvisningar för $[officename] "
"Impress</link></variable>"

#: main.xhp%23hd_id3150207.2.help.text
msgid "Viewing and Printing a Presentation"
msgstr "Göra och skriva ut presentation"

#: main.xhp%23hd_id3153812.3.help.text
msgid "Animated Objects and 3D Objects"
msgstr "Animerade objekt och 3D-objekt"

#: main.xhp%23hd_id3149350.5.help.text
msgid "Importing and Exporting"
msgstr "Import och export"

#: main.xhp%23hd_id3154560.6.help.text
msgid "Miscellaneous"
msgstr "Övrigt"

#: animated_gif_save.xhp%23tit.help.text
msgid "Exporting Animations in GIF Format"
msgstr "Exportera animationer i GIF-format"

#: animated_gif_save.xhp%23bm_id3149666.help.text
msgid ""
"<bookmark_value>animations; saving as "
"GIFs</bookmark_value><bookmark_value>exporting; animations to GIF "
"format</bookmark_value>"
msgstr ""
"<bookmark_value>Animationer; Spara som GIF-"
"filer</bookmark_value><bookmark_value>Exportera; animationer till GIF-"
"format</bookmark_value>"

#: animated_gif_save.xhp%23hd_id3149666.76.help.text
msgid ""
"<variable id=\"animated_gif_save\"><link href=\"text/simpress/guide/"
"animated_gif_save.xhp\" name=\"Exporting Animations in GIF Format\">"
"Exporting Animations in GIF Format</link></variable>"
msgstr ""
"<variable id=\"animated_gif_save\"><link href=\""
"text/simpress/guide/animated_gif_save.xhp\" name=\"Exportera animationer i "
"GIF-format\">Exportera animationer i GIF-format</link></variable>"

#: animated_gif_save.xhp%23par_id3150202.77.help.text
msgid "Select an animated object on your slide."
msgstr "Markera ett animerat objekt på sidan."

#: animated_gif_save.xhp%23par_id3145802.78.help.text
msgctxt "animated_gif_save.xhp#par_id3145802.78.help.text"
msgid "Choose <emph>File - Export</emph>."
msgstr "Välj <emph>Arkiv - Exportera</emph>."

#: animated_gif_save.xhp%23par_id3155064.79.help.text
msgid ""
"Select <emph>GIF - Graphics Interchange Format (.gif)</emph> in the <emph>"
"File type </emph>list."
msgstr ""
"Välj <emph>GIF - Graphics Interchange Format (.gif)</emph> i listan "
"<emph>Filformat</emph>."

#: animated_gif_save.xhp%23par_id3153963.80.help.text
msgid ""
"Click the <emph>Selection</emph> check box to export the selected object, "
"and not the entire slide."
msgstr ""
"Markera kryssrutan <emph>Markering</emph> om du bara vill exportera det "
"markerade objektet (och inte hela sidan)."

#: animated_gif_save.xhp%23par_id3150206.81.help.text
msgid ""
"Locate where you want to save the animated GIF, enter a name, and then click "
"<emph>Save</emph>."
msgstr ""
"Välj var du vill spara den animerade GIF-bilden, ange ett namn och klicka "
"sedan på <emph>Spara</emph>."

#: animated_gif_create.xhp%23tit.help.text
msgid "Creating Animated GIF Images"
msgstr "Skapa animerade GIF-bilder"

#: animated_gif_create.xhp%23bm_id3153188.help.text
msgid ""
"<bookmark_value>cross-fading; creating cross-"
"fades</bookmark_value><bookmark_value>GIF images; "
"animating</bookmark_value><bookmark_value>animated GIFs</bookmark_value>"
msgstr ""
"<bookmark_value>Övertoning; skapa "
"övertoningar</bookmark_value><bookmark_value>GIF-bilder; "
"animera</bookmark_value><bookmark_value>Animerade GIF-bilder</bookmark_value>"

#: animated_gif_create.xhp%23hd_id3153188.55.help.text
msgid ""
"<variable id=\"animated_gif_create\"><link href=\"text/simpress/guide/"
"animated_gif_create.xhp\" name=\"Creating Animated GIF Images\">Creating "
"Animated GIF Images</link></variable>"
msgstr ""
"<variable id=\"animated_gif_create\"><link href=\""
"text/simpress/guide/animated_gif_create.xhp\" name=\"Skapa animerad GIF-"
"bild\">Skapa animerad GIF-bild</link></variable>"

#: animated_gif_create.xhp%23par_id3149377.3.help.text
msgid ""
"You can animate drawing objects, text objects, and graphic objects (images) "
"on your slides to make your presentation more interesting. $[officename] "
"Impress provides you with a simple animation editor where you can create "
"animation images (frames) by assembling objects from your slide. The "
"animation effect is achieved by rotating through the static frames that you "
"create."
msgstr ""
"Du kan animera ritobjekt, textobjekt och grafiska objekt på sidorna för att "
"göra en presentation mer intressant. I $[officename] Impress finns en "
"enklare animationsredigerare som du kan använda för att skapa animationer av "
"objekten i dina sidor. Animationseffekten åstadkoms genom att varje (statisk)"
" bildruta i animationen visas under en kort period, innan den avlöses av "
"nästa bildruta."

#: animated_gif_create.xhp%23par_id3154657.57.help.text
msgid ""
"If you create a bitmap animation (animated GIF), you can assign a delay time "
"to each frame, and specify the number of times the animation is played."
msgstr ""
"Om du skapar en bitmappsanimation (animerad GIF), kan du ange ett tidsvärde "
"för varje bildruta, och ange hur många gånger som animationen ska spelas upp."

#: animated_gif_create.xhp%23hd_id3150250.58.help.text
msgid "To create an animated GIF:"
msgstr "Så här skapar du en animerad GIF:"

#: animated_gif_create.xhp%23par_id3148703.59.help.text
msgid ""
"Select an object or group of objects that you want to include in your "
"animation and choose<emph> Insert - Animated Image</emph>."
msgstr ""
"Markera ett objekt eller en grupp med objekt som ska vara med i animationen, "
"och välj <emph>Bildskärmspresentation - Animation</emph>."

#: animated_gif_create.xhp%23par_id3149601.60.help.text
msgctxt "animated_gif_create.xhp#par_id3149601.60.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: animated_gif_create.xhp%23par_id3145086.97.help.text
msgid ""
"Click the <emph>Apply Object </emph>button <image id=\"img_id3148489\" src=\""
"sd/res/get1obj.png\" width=\"0.423cm\" height=\"0.423cm\"><alt id=\""
"alt_id3148489\">Note Icon</alt></image> to add a single object or a group of "
"objects to the current animation frame."
msgstr ""
"Klicka på knappen <emph>Överta objekt</emph><image id=\"img_id3148489\" src="
"\"sd/res/get1obj.png\" width=\"4.23mm\" height=\"4.23mm\"><alt id=\""
"alt_id3148489\">Symbolen Obs</alt></image> för att lägga till ett objekt "
"till den aktuella animationsrutan."

#: animated_gif_create.xhp%23par_id3150860.98.help.text
msgid ""
"Click the <emph>Apply Objects Individually </emph>button <image id=\""
"img_id3149355\" src=\"sd/res/getallob.png\" width=\"0.423cm\" height=\"0."
"423cm\"><alt id=\"alt_id3149355\">Tip Icon</alt></image> to create a "
"separate animation frame for each of the selected objects."
msgstr ""
"Klicka på <emph>Överta objekt ett och ett</emph> <image id=\"img_id3149355\" "
"src=\"sd/res/getallob.png\" width=\"4.23mm\" height=\"4.23mm\"><alt id=\""
"alt_id3149355\">Symbolen Tips</alt></image> för att skapa en separat "
"animationsruta för varje markerat objekt."

#: animated_gif_create.xhp%23par_id3148391.61.help.text
msgid ""
"In the <emph>Animation Group </emph>area, select <emph>Bitmap object</emph>."
msgstr "Under <emph>Animationsgrupp</emph> väljer du <emph>Bitmapobjekt</emph>."

#: animated_gif_create.xhp%23par_id3154871.99.help.text
msgid ""
"Use the animation timeline to specify the duration for displaying a frame "
"and the number of times an animation sequence is presented (looping)."
msgstr ""
"Använd animationens tidslinje för att ange hur länge en bildruta ska visas "
"och hur många gånger som animationssekvensen ska repeteras."

#: animated_gif_create.xhp%23par_id3154644.62.help.text
msgid "Enter a frame number in the <emph>Image Number</emph> box (left box)."
msgstr ""
"Ange numret på en bildruta i rutan <emph>Bildnummer</emph> (vänstra rutan)."

#: animated_gif_create.xhp%23par_id3150756.63.help.text
msgid ""
"Enter the number of seconds you want the frame to display in the <emph>"
"Duration </emph>box (middle box)."
msgstr ""
"Ange hur många sekunder som bildrutan ska visas i rutan "
"<emph>Visningstid</emph> (mellersta rutan)."

#: animated_gif_create.xhp%23par_id3151182.64.help.text
msgid "Repeat the last two steps for each frame in your animation."
msgstr "Upprepa de två sista stegen för varje bildruta i animationen."

#: animated_gif_create.xhp%23par_id3151177.100.help.text
msgid ""
"You can preview your animation by using the controls to the left of the "
"<emph>Image Number </emph>box."
msgstr ""
"Du kan förhandsgranska animationen genom att använda kontrollerna till "
"vänster om rutan <emph>Bildnummer</emph>."

#: animated_gif_create.xhp%23par_id3154939.65.help.text
msgid ""
"Select the number of times you want the animation sequence to repeat in the "
"<emph>Loop count </emph>box (right box)."
msgstr ""
"Ange hur många gånger som animationen ska visas i rutan <emph>Antal "
"omgångar</emph> (rutan till höger)."

#: animated_gif_create.xhp%23par_id3145421.88.help.text
msgid ""
"Select an alignment option for the objects in the <emph>Alignment</emph> box."
msgstr ""
"Välj ett justeringsalternativ för objekten i rutan <emph>Anpassning</emph>."

#: animated_gif_create.xhp%23par_id3154285.101.help.text
msgid "Click <emph>Create</emph>."
msgstr "Klicka på <emph>Skapa</emph>."

#: 3d_create.xhp%23tit.help.text
msgid "Converting 2D Objects to Curves, Polygons, and 3D Objects"
msgstr "Konvertera 2D-objekt till kurvor, polygoner och 3D-objekt"

#: 3d_create.xhp%23bm_id3150207.help.text
msgid ""
"<bookmark_value>3D rotation objects; "
"generating</bookmark_value><bookmark_value>3D objects; "
"generating</bookmark_value><bookmark_value>3D scenes; "
"creating</bookmark_value><bookmark_value>converting; to curves, polygons, "
"3D</bookmark_value><bookmark_value>extrusion objects</bookmark_value>"
msgstr ""
"<bookmark_value>3D-rotationsobjekt; generera</bookmark_value><bookmark_value"
">3D-objekt; generera</bookmark_value><bookmark_value>3D-scener; "
"skapa</bookmark_value><bookmark_value>konvertera; till kurvor, polygoner, "
"3D</bookmark_value><bookmark_value>extrusionsobjekt</bookmark_value>"

#: 3d_create.xhp%23hd_id3150207.32.help.text
msgid ""
"<variable id=\"3d_create\"><link href=\"text/simpress/guide/3d_create.xhp\" "
"name=\"Converting 2D Objects to Curves, Polygons, and 3D Objects\">"
"Converting 2D Objects to Curves, Polygons, and 3D Objects</link></variable>"
msgstr ""
"<variable id=\"3d_create\"><link href=\"text/simpress/guide/3d_create.xhp\" "
"name=\"Konvertera 2D-objekt till kurvor, polygoner och 3D-objekt\">"
"Konvertera 2D-objekt till kurvor, polygoner och 3D-objekt</link></variable>"

#: 3d_create.xhp%23par_id3153914.33.help.text
msgid ""
"You can convert two dimensional (2D) objects to create different shapes. "
"$[officename] can convert 2D objects to the following object types:"
msgstr ""
"Du kan konvertera tvådimensionella (2D) objekt till andra typer av objekt. "
"Med $[officename] kan du konvertera 2D-objekt till följande typer av objekt:"

#: 3d_create.xhp%23par_id3150210.49.help.text
msgid "Curved object based on Bézier curves"
msgstr "Kurvobjekt som bygger på bézierkurvor."

#: 3d_create.xhp%23par_id3154762.50.help.text
msgid "Polygon object consisting of straight line segments"
msgstr "Polygonobjekt som består av raka linjesegment"

#: 3d_create.xhp%23par_id3150051.51.help.text
msgid "3D object with shading and a light source"
msgstr "3D-objekt med skuggning och en ljuskälla"

#: 3d_create.xhp%23par_id3149873.52.help.text
msgid "3D rotation object with shading and a light source"
msgstr "3D-rotationsobjekt med skuggning och en ljuskälla"

#: 3d_create.xhp%23hd_id31490481.help.text
msgid "Two types of 3D objects"
msgstr "Två typer av 3D-objekt"

#: 3d_create.xhp%23par_id31472951.help.text
msgid ""
"The Status bar displays \"3D scene selected\". The 3D scenes are built from "
"objects which have dimensions in x, y, and z coordinates. Examples are the "
"objects inserted by the 3D Objects toolbar, and rectangles, ellipses, or "
"text that got created by the Rectangle, Ellipse, or Text icons left on the "
"Drawing toolbar, or any Custom Shapes, and that got converted to 3D by using "
"the context menu \"Convert - To 3D\". These 3D scenes can be entered (for "
"example, by pressing F3), and the objects can be rotated in 3D. Microsoft "
"Office doesn't know these real 3D objects. When exporting these 3D scenes to "
"Microsoft Office formats, a snapshot of the current view will be exported as "
"a bitmap. 3D bars in charts are of this type, too."
msgstr ""
"På statusraden visas \"3D-scen har markerats\". 3D-scenerna byggs upp av "
"objekt som har koordinater i tre dimensioner: x, y och z. Exempel är objekt "
"som har infogats med verktygsraden 3D-objekt samt rektanglar, ellipser och "
"text som har skapats med motsvarande ikoner till vänster på verktygsraden "
"Teckning eller anpassade figurer som har omvandlats till 3D med snabbmenyn \""
"Omvandla – Till 3D\". Dessa 3D-scener kan läggas in (till exempel genom att "
"du trycker på F3) och objekten kan roteras i 3D. Microsoft Office kan inte "
"hantera de här 3D-objekten. När dessa 3D-scener exporteras till Microsoft "
"Office-format så exporteras en ögonblicksbild av den aktuella vyn som en "
"bitmapp. Detsamma gäller för 3D-staplar i diagram."

#: 3d_create.xhp%23par_id31506541.help.text
msgid ""
"The Status bar displays \"Shape selected\". The Custom Shapes can be viewed "
"in a 2D mode or in a 3D mode. At any time, you can switch the view between "
"the two modes. You use the Basic Shapes, Symbol Shapes, and the following "
"icons on the Drawing toolbar to create Custom Shapes. The Custom Shapes can "
"be changed using the 3D Settings toolbar. They do not form a 3D scene, they "
"cannot be illuminated by more than one light source, they show no "
"reflections, and there are some more limitations. You can convert them to a "
"3D scene, but then they are no longer Custom Shapes. Custom Shapes in 2D or "
"3D mode can be exported to and imported from Microsoft Office formats."
msgstr ""
"På statusraden visas \"Form har markerats\". Anpassade figurer kan visas i "
"2D-läge eller 3D-läge. Du kan växla mellan de här vyerna när som helst. Du "
"kan använda ikonerna för grundformer, symbolformer och de följande ikonerna "
"på verktygsraden Teckning för att skapa anpassade figurer. Anpassade figurer "
"kan ändras med verktygsraden 3D-inställningar. De utgör inte en 3D-scen, de "
"kan inte ha ljuseffekter från mer än en ljuskälla, de visar inga "
"reflektioner och det finns några ytterligare begränsningar. Du kan omvandla "
"dem till en 3D-scen, men då är de inte längre anpassade figurer. Anpassade "
"figurer i 2D- eller 3D-läge kan exporteras till och importeras från "
"Microsoft Office-format."

#: 3d_create.xhp%23hd_id3149048.34.help.text
msgid "To convert an object to a curved shape:"
msgstr ""
"Rita upp en rektangel med musen. Den har standardinställningarna för färg, "
"linjetjocklek, o.s.v. och bör nu vara markerad."

#: 3d_create.xhp%23par_id3147295.35.help.text
msgctxt "3d_create.xhp#par_id3147295.35.help.text"
msgid "Select a 2D object on the slide or page."
msgstr "Markera ett 2D-objekt på bilden eller sidan."

#: 3d_create.xhp%23par_id3150654.54.help.text
msgid "Right-click the object and choose <emph>Convert - To Curve</emph>."
msgstr "Högerklicka på objektet och välj <emph>Omvandla - Till kurva</emph>"

#: 3d_create.xhp%23par_id3145828.55.help.text
msgid ""
"To modify the shape of the object, click the <emph>Points</emph> icon<image "
"id=\"img_id1027558\" src=\"svx/res/cd015.png\" width=\"0.222inch\" height=\""
"0.222inch\"><alt id=\"alt_id1027558\">Icon</alt></image> on the "
"<emph>Drawing</emph> toolbar, and drag the handles of the object. You can "
"also drag the control points of a handle to modify the shape of the curve."
msgstr ""
"Du kan ändra objektets form genom att klicka på ikonen <emph>Punkter</emph> <"
"image id=\"img_id1027558\" src=\"svx/res/cd015.png\" width=\"0.222inch\" "
"height=\"0.222inch\"><alt id=\"alt_id1027558\">Ikon</alt></image> på "
"verktygsraden <emph>Ritverktyg</emph> och dra i objektets handtag. Du kan "
"också dra i kontrollpunkterna som hör till ett handtag för att ändra formen "
"på kurvan."

#: 3d_create.xhp%23hd_id3153738.56.help.text
msgid "To convert a 2D object to a polygon:"
msgstr "Så här konverterar du ett 2D-objekt till en polygon:"

#: 3d_create.xhp%23par_id3145241.57.help.text
msgctxt "3d_create.xhp#par_id3145241.57.help.text"
msgid "Select a 2D object on the slide or page."
msgstr "Markera ett 2D-objekt på bilden eller sidan."

#: 3d_create.xhp%23par_id3148774.59.help.text
msgid "Right-click the object and choose <emph>Convert - To Polygon.</emph>"
msgstr "Högerklicka på objektet och välj <emph>Omvandla - Till polygon</emph>"

#: 3d_create.xhp%23par_id3155368.39.help.text
msgid ""
"To modify the shape of the object, click the <emph>Points</emph> icon<image "
"id=\"img_id7219458\" src=\"svx/res/cd015.png\" width=\"0.2201inch\" height=\""
"0.2201inch\"><alt id=\"alt_id7219458\">Icon</alt></image> on the "
"<emph>Drawing</emph> toolbar, and drag the handles of the object."
msgstr ""
"Du kan ändra objektets form genom att klicka på ikonen <emph>Punkter</emph> <"
"image id=\"img_id7219458\" src=\"svx/res/cd015.png\" width=\"0.2201inch\" "
"height=\"0.2201inch\"><alt id=\"alt_id7219458\">Ikon</alt></image> på "
"verktygsraden <emph>Ritverktyg</emph> och dra i objektets handtag."

#: 3d_create.xhp%23hd_id3153919.60.help.text
msgid "To convert a 2D object to a 3D object:"
msgstr "Så här konverterar du ett 2D-objekt till ett 3D-objekt:"

#: 3d_create.xhp%23par_id3147172.62.help.text
msgctxt "3d_create.xhp#par_id3147172.62.help.text"
msgid "Select a 2D object on the slide or page."
msgstr "Markera ett 2D-objekt på bilden eller sidan."

#: 3d_create.xhp%23par_idN1088B.help.text
msgid ""
"Click the <emph>Extrusion On/Off</emph> icon<image id=\"img_id2490920\" src="
"\"res/commandimagelist/sc_extrusiontoggle.png\" width=\"0.1665inch\" height="
"\"0.1665inch\"><alt id=\"alt_id2490920\">Icon</alt></image> on the "
"<emph>Drawing</emph> bar, or right-click the object and choose <emph>Convert "
"- To 3D</emph>."
msgstr ""
"Klicka på ikonen <emph>Extrusion på/av</emph> <image id=\"img_id2490920\" "
"src=\"res/commandimagelist/sc_extrusiontoggle.png\" width=\"0.1665inch\" "
"height=\"0.1665inch\"><alt id=\"alt_id2490920\">Ikon</alt></image> på "
"verktygsraden <emph>Ritverktyg</emph> eller högerklicka på objektet och välj "
"<emph>Omvandla – Till 3D</emph>."

#: 3d_create.xhp%23par_id3148828.41.help.text
msgid ""
"To edit the properties of the 3D object, use the <emph>Line and "
"Filling</emph> toolbar and the <emph>3D Settings</emph> toolbar."
msgstr ""
"Om du vill redigera egenskaperna hos 3D-objektet använder du verktygsraden "
"<emph>Linje och fyllning</emph>och verktygsraden <emph>3D-"
"inställningar</emph>."

#: 3d_create.xhp%23par_idN108C5.help.text
msgid ""
"To convert a text object to 3D, use the <emph>Fontwork</emph> icon<image id="
"\"img_id3821222\" src=\"res/commandimagelist/sc_fontworkgalleryfloater.png\" "
"width=\"0.1665inch\" height=\"0.1665inch\"><alt id=\"alt_id3821222\""
">Icon</alt></image> on the <emph>Drawing</emph> toolbar."
msgstr ""
"Om du vill omvandla ett textobjekt till 3D använder du ikonen "
"<emph>Fontwork</emph> <image id=\"img_id3821222\" src=\""
"res/commandimagelist/sc_fontworkgalleryfloater.png\" width=\"0.1665inch\" "
"height=\"0.1665inch\"><alt id=\"alt_id3821222\">Ikon</alt></image> på "
"verktygsraden <emph>Ritverktyg</emph>."

#: 3d_create.xhp%23hd_id3145410.65.help.text
msgid "To convert a 2D object to a 3D rotation object:"
msgstr "Så här konverterar du ett 2D-objekt till ett 3D-rotationsobjekt:"

#: 3d_create.xhp%23par_id3154260.66.help.text
msgid ""
"A 3D rotation object is created by rotating the selected object around its "
"vertical axis."
msgstr ""
"Ett 3D-rotationsobjekt skapas genom att det markerade objektet roteras runt "
"sin vertikalaxel."

#: 3d_create.xhp%23par_id3147506.67.help.text
msgctxt "3d_create.xhp#par_id3147506.67.help.text"
msgid "Select a 2D object on the slide or page."
msgstr "Markera ett 2D-objekt på bilden eller sidan."

#: 3d_create.xhp%23par_id3151318.69.help.text
msgid ""
"Right-click the object and choose <emph>Convert - To 3D Rotation "
"Object</emph>"
msgstr ""
"Högerklicka på objektet och välj <emph>Omvandla - Till 3D-"
"rotationsobjekt</emph>"

#: 3d_create.xhp%23par_id3146125.70.help.text
msgid ""
"To edit the properties of the 3D object, use the Line and Filling toolbar "
"and the 3D Settings toolbar."
msgstr ""
"Om du vill redigera egenskaperna hos 3D-objektet använder du verktygsraden "
"Linje och fyllning och verktygsradens 3D-inställningar."

#: 3d_create.xhp%23par_id3149336.43.help.text
msgid ""
"You can rotate the 2D object before converting it to create a more complex "
"shape."
msgstr ""
"Du kan rotera 2D-objektet innan du omvandlar det till ett mer komplext "
"objekt."

#: select_object.xhp%23tit.help.text
msgid "Selecting Underlying Objects"
msgstr "Markera underliggande objekt"

#: select_object.xhp%23bm_id3154492.help.text
msgid ""
"<bookmark_value>objects; selecting</bookmark_value><bookmark_value>selecting;"
" hidden objects</bookmark_value><bookmark_value>covered "
"objects</bookmark_value><bookmark_value>underlying objects</bookmark_value>"
msgstr ""
"<bookmark_value>Objekt; markera</bookmark_value><bookmark_value>Markera; "
"dolda objekt</bookmark_value><bookmark_value>Täckta "
"objekt</bookmark_value><bookmark_value>Underliggande objekt</bookmark_value>"

#: select_object.xhp%23hd_id3154492.7.help.text
msgid ""
"<variable id=\"select_object\"><link href=\"text/simpress/guide/"
"select_object.xhp\" name=\"Selecting Underlying Objects\">Selecting "
"Underlying Objects</link></variable>"
msgstr ""
"<variable id=\"select_object\"><link href=\""
"text/simpress/guide/select_object.xhp\" name=\"Markera täckt objekt\">"
"Markera täckt objekt</link></variable>"

#: select_object.xhp%23par_id3159238.9.help.text
msgid ""
"To select an object that is covered by other objects, hold down <"
"switchinline select=\"sys\"><caseinline select=\"MAC\""
">Option</caseinline><defaultinline>Alt</defaultinline></switchinline> and "
"click through the objects until you reach the underlying object. To cycle "
"through the objects in reverse order, hold down <switchinline select=\"sys\""
"><caseinline select=\"MAC\""
">Option</caseinline><defaultinline>Alt</defaultinline></switchinline>+Shift "
"when you click."
msgstr ""
"Om du vill markera ett objekt som tacks av andra objekt håller du ned <"
"switchinline select=\"sys\"><caseinline select=\"MAC\""
">Alternativ</caseinline><defaultinline>Alt</defaultinline></switchinline> "
"och klickar genom objekten tills du når det underliggande objektet. För att "
"gå igenom objekten i motsatt ordning håller du ned <switchinline select=\""
"sys\"><caseinline select=\"MAC\""
">Alternativ</caseinline><defaultinline>Alt</defaultinline></switchinline>+"
"Skift när du klickar."

#: select_object.xhp%23par_id3150213.10.help.text
msgid ""
"To select an object that is covered by another object using the keyboard, "
"press Tab to cycle through the objects on the slide. To cycle through the "
"objects in reverse order, press Shift+Tab."
msgstr ""
"Om du behöver markera ett objekt som är täckt av ett annat objekt, trycker "
"du på Tabb-tangenten för att gå igenom objekten på bilden. Om du vill gå "
"igenom objekten i omvänd ordning trycker du på Skift + Tabb."

#: line_draw.xhp%23tit.help.text
msgid "Drawing Curves"
msgstr "Rita kurvor"

#: line_draw.xhp%23bm_id3149377.help.text
msgid ""
"<bookmark_value>lines; drawing</bookmark_value><bookmark_value>curves; "
"drawing</bookmark_value><bookmark_value>control points "
"definition</bookmark_value><bookmark_value>corner "
"points</bookmark_value><bookmark_value>drawing;lines</bookmark_value>"
msgstr ""
"<bookmark_value>Linjer; rita</bookmark_value><bookmark_value>Kurvor; rita</bo"
"okmark_value><bookmark_value>Kontrollpunktsdefinition</bookmark_value><bookma"
"rk_value>Hörnpunkter</bookmark_value><bookmark_value>Rita;linjer</bookmark_va"
"lue>"

#: line_draw.xhp%23hd_id3149377.3.help.text
msgid ""
"<variable id=\"line_draw\"><link href=\"text/simpress/guide/line_draw.xhp\" "
"name=\"Drawing Curves\">Drawing Curves</link></variable>"
msgstr ""
"<variable id=\"line_draw\"><link href=\"text/simpress/guide/line_draw.xhp\" "
"name=\"Rita kurvor\">Rita kurvor</link></variable>"

#: line_draw.xhp%23par_id3148868.4.help.text
msgid ""
"The <emph>Curve</emph> icon <image id=\"img_id3150205\" src=\"res/"
"commandimagelist/sc_linetoolbox.png\" width=\"0.222inch\" height=\"0."
"222inch\"><alt id=\"alt_id3150205\">Icon</alt></image> on the "
"<emph>Drawing</emph> toolbar opens a toolbar to draw Bézier curves. Bézier "
"curves are defined by a start point and an end point, which are called \""
"anchors\". The curvature of the Bézier curve is defined by control points (\""
"handles\"). Moving a control point changes the shape of the Bézier curve."
msgstr ""
"Med <emph>Kurv</emph>-verktyget <image id=\"img_id3150205\" src=\""
"res/commandimagelist/sc_linetoolbox.png\" width=\"5.64mm\" height=\"5.64mm\""
"><alt id=\"alt_id3150205\">Ikon</alt></image> kan du rita en kurvlinje som "
"består av ett eller flera linjesegment. Varje segment i en Bézierkurva "
"definieras av två datapunkter (slutpunkter) och en eller två kontrollpunkter "
"(handtag) som du kan dra i för att justera kurvans båge. En kontrollpunkt "
"ansluts till en datapunkt med en kontrollinje. Flyttar du en kontrollpunkt "
"dras kurvan mot den och kurvans form ändras."

#: line_draw.xhp%23par_id8532364.help.text
msgid ""
"Control points are only visible in \"Edit Points\" mode. Control points are "
"represented by circles, anchor points are represented by squares. The start "
"point is a little bit larger than the other anchor points."
msgstr ""
"Kontrolpunkterna syns bara i \"Redigera Punkterna\"-läget.  Kontrolpunkterna "
"visas som små ringar, ankare visas som små fyrkanter.  Startpunkten är lite "
"större än de övriga ankarna."

#: line_draw.xhp%23par_id3150210.39.help.text
msgid ""
"Bézier curve segments and straight line segments can be joined to form more "
"complex Bézier curves. Three different transitions can be applied to join "
"adjacent segments:"
msgstr "En bézierkurva är uppbyggd kring tre typer av punkter:"

#: line_draw.xhp%23par_id3154766.25.help.text
msgid ""
"A <emph>symmetrical</emph> anchor point has the same line curvature on "
"either side, and two control lines that move together as a straight line."
msgstr ""
"En symmetrisk datapunkt har samma linjeböjning på varje sida, och två "
"kontrollinjer som rör sig tillsammans som en rät linje."

#: line_draw.xhp%23par_id3149874.26.help.text
msgid ""
"A <emph>smooth</emph> anchor point may have different line curvatures on "
"either side."
msgstr ""
"En jämn datapunkt har olika linjeböjning på varje sida, och två "
"kontrollinjer som rör sig tillsammans som en rät linje."

#: line_draw.xhp%23par_id3150435.27.help.text
msgid ""
"A <emph>corner</emph> anchor point has one or two independent control lines. "
"Changing one side has no effect on the other side."
msgstr ""
"En <emph>hörnpunkt</emph> har en eller två kontrollinjer och sammanbinder "
"olika linjesegment."

#: line_draw.xhp%23hd_id46388.help.text
msgid "How to use the Curve tool"
msgstr "Hur kurv-verktyget används"

#: line_draw.xhp%23par_id3155262.5.help.text
msgid ""
"On the Drawing toolbar, open the <emph>Curves</emph> toolbar <image id=\""
"img_id3145829\" src=\"res/commandimagelist/sc_linetoolbox.png\" width=\"0."
"222inch\" height=\"0.222inch\"><alt id=\"alt_id3145829\">Icon</alt></image> "
"and select the <emph>Curve</emph><image id=\"Graphic1\" src=\"res/"
"commandimagelist/sc_bezier_unfilled.png\" width=\"0.222inch\" height=\"0."
"222inch\"><alt id=\"alt_\">Icon</alt></image> tool."
msgstr ""
"Öppna verktygsraden <emph>Kurvor</emph> och markera verktyget "
"<emph>Kurva</emph> <image id=\"img_id3145829\" src=\""
"res/commandimagelist/sc_linetoolbox.png\" width=\"5.64mm\" height=\"5.64mm\""
"><alt id=\"alt_id3145829\"></alt></image>. <image id=\"Graphic1\" src=\""
"res/commandimagelist/sc_bezier_unfilled.png\" width=\"0.222inch\" height=\"0."
"222inch\"><alt id=\"alt_\">Icon</alt></image>"

#: line_draw.xhp%23par_id3155928.6.help.text
msgid ""
"Click where you want the curve to start, and drag in the direction where you "
"want the curve to go. The control line will indicate the direction. "
msgstr ""
"Klicka där du vill att kurvan ska börja och dra en kort sträcka åt det håll "
"du vill att kurvan ska gå. Om du vill skapa ett rakt linjesegment trycker du "
"på <item type=\"keycode\">Skift</item> medan du drar."

#: line_draw.xhp%23par_id8174687.help.text
msgid ""
"Hold down <item type=\"keycode\">Shift</item> while you drag to restrict the "
"direction to a 45 degree grid."
msgstr ""
"Tryck på <item type=\"keycode\">Shift</item> samtidigt som pekaren dras.  Så "
"följer rörelserna jämna 45-graders vinklar."

#: line_draw.xhp%23par_id3148390.41.help.text
msgid "Release the mouse where the first control point should be."
msgstr "Släpp upp musknappen där första punkten läggas."

#: line_draw.xhp%23par_id3154865.22.help.text
msgid ""
"Move the pointer to where you want the curve segment to end. The curve "
"follows the pointer. "
msgstr ""
"Flytta pekaren till det ställe där kurvsegmentet ska sluta och gör något av "
"följande:"

#: line_draw.xhp%23par_id1556443.help.text
msgctxt "line_draw.xhp#par_id1556443.help.text"
msgid "Do one of the following:"
msgstr "Gör en av följande:"

#: line_draw.xhp%23par_id3151172.9.help.text
msgid ""
"Double-click on the position of the end point to finish drawing the line. "
msgstr ""
"Dubbelklicka när linjen är färdigritad. Du kan skapa en sluten figur genom "
"att dubbelklicka på linjens startpunkt."

#: line_draw.xhp%23par_id5377056.help.text
msgid "To create a closed shape, double-click the starting point of the line."
msgstr "Att skapa en slutna form, dubbelklicka på linjans startpunkt."

#: line_draw.xhp%23par_id3153919.23.help.text
msgid ""
"Click and release the mouse button to add an anchor point. Move the mouse to "
"draw the next segment."
msgstr "Klicka för att rita kurvsegmentet med den aktuella cirkelbågen."

#: line_draw.xhp%23par_id3149451.43.help.text
msgid "Click and drag in any direction to add a smooth anchor point."
msgstr ""
"Dra i en riktning för att definiera kurvans cirkelbåge, och klicka sedan för "
"att ställa in den."

#: line_draw.xhp%23hd_id2071596.help.text
msgid "How to use the Freeform Line tool"
msgstr "Hur friforms-verktyget används"

#: line_draw.xhp%23par_id4907681.help.text
msgid ""
"On the Drawing toolbar, open the <emph>Curves</emph> toolbar <image id=\""
"Graphic2\" src=\"res/commandimagelist/sc_linetoolbox.png\" width=\"0."
"222inch\" height=\"0.222inch\"><alt id=\"alt_\">Icon</alt></image> and "
"select the <emph>Freeform Line</emph><image id=\"Graphic3\" src=\"res/"
"commandimagelist/sc_freeline_unfilled.png\" width=\"0.222inch\" height=\"0."
"222inch\"><alt id=\"alt_\">Icon</alt></image> tool."
msgstr ""
"På ritningsraden, ta <emph>Curves</emph> raden <image id=\"Graphic2\" src=\""
"res/commandimagelist/sc_linetoolbox.png\" width=\"0.222inch\" height=\"0."
"222inch\"><alt id=\"alt_\">Icon</alt></image> och sedan välj <emph>Freeform "
"Line</emph><image id=\"Graphic3\" src=\""
"res/commandimagelist/sc_freeline_unfilled.png\" width=\"0.222inch\" height=\""
"0.222inch\"><alt id=\"alt_\">Icon</alt></image> verktyget."

#: line_draw.xhp%23par_id1122165.help.text
msgid ""
"Click where you want the curve to start, and keep holding the mouse button "
"down."
msgstr "Klicka där kurven ska börja.  Förtsätt tryck på knappen."

#: line_draw.xhp%23par_id5792107.help.text
msgid "Draw the freeform line as you would do with a pencil."
msgstr "Rita friformslinjan som med vanlig penna."

#: line_draw.xhp%23par_id7734916.help.text
msgid "Release the mouse button to finish the line."
msgstr "Släppknappen för att avsluta linjan."

#: printing.xhp%23tit.help.text
msgid "Printing Presentations"
msgstr "Skriva ut presentationer"

#: printing.xhp%23bm_id3153726.help.text
msgid ""
"<bookmark_value>printing; presentations</bookmark_value>      "
"<bookmark_value>slides; printing</bookmark_value>      <bookmark_value>notes;"
" printing in presentations</bookmark_value>      <bookmark_value>outlines; "
"printing</bookmark_value>      <bookmark_value>presentations; "
"printing</bookmark_value>      <bookmark_value>tiled printing of "
"slides</bookmark_value>      <bookmark_value>changing;layout for "
"handouts</bookmark_value>      <bookmark_value>handout "
"printing</bookmark_value>      <bookmark_value>layout;printing "
"handouts</bookmark_value>"
msgstr ""
"<bookmark_value>skriva ut; presentationer</bookmark_value>      "
"<bookmark_value>bilder; skriva ut</bookmark_value>      "
"<bookmark_value>anteckningar; skriva ut i presentationer</bookmark_value>"
"      <bookmark_value>dispositioner; skriva ut</bookmark_value>      "
"<bookmark_value>presentationer; skriva ut</bookmark_value>      "
"<bookmark_value>skriva ut bilder sida vid sida</bookmark_value>      "
"<bookmark_value>ändra;layout för flygblad</bookmark_value>      "
"<bookmark_value>flygblad, skriva ut</bookmark_value>      "
"<bookmark_value>layout;skriva ut flygblad</bookmark_value>"

#: printing.xhp%23hd_id3153726.1.help.text
msgid ""
"<variable id=\"printing\"><link href=\"text/simpress/guide/printing.xhp\" "
"name=\"Printing Presentations\">Printing Presentations</link></variable>"
msgstr ""
"<variable id=\"printing\"><link href=\"text/simpress/guide/printing.xhp\" "
"name=\"Skriva ut presentationer\">Skriva ut presentationer</link></variable>"

#: printing.xhp%23hd_id3154486.2.help.text
msgid "Default printer settings"
msgstr "Standardinställningar för utskrift"

#: printing.xhp%23par_id3156385.3.help.text
msgid ""
"To set the default printing options for $[officename] Impress, choose <emph>"
"Tools - Options - %PRODUCTNAME Impress - Print</emph>."
msgstr ""
"Om du vill ange standardalternativ för utskrifter i $[officename] Impress "
"väljer du <emph>Verktyg - Alternativ - %PRODUCTNAME Impress - Skriv "
"ut</emph>."

#: printing.xhp%23hd_id3153914.5.help.text
msgid "Setting printer options for the current presentation"
msgstr "Ange skrivaralternativ för den aktuella presentationen"

#: printing.xhp%23par_id3154651.6.help.text
msgctxt "printing.xhp#par_id3154651.6.help.text"
msgid "Choose <emph>File - Print</emph>."
msgstr "Välj <emph>Arkiv - Skriv ut</emph>."

#: printing.xhp%23par_id3149870.7.help.text
msgid ""
"Click the <emph>%PRODUCTNAME Impress</emph> or the <emph>Options</emph> tab "
"page, and then select the printer options."
msgstr ""
"Klicka på <emph>%PRODUCTNAME Impress</emph> eller på fliken "
"<emph>Alternativ</emph> och välj skrivaralternativ."

#: printing.xhp%23par_id3150431.8.help.text
msgid ""
"These settings override the default printer options in <emph>Tools - Options "
"- %PRODUCTNAME Impress - Print</emph> for the current print job only."
msgstr ""
"De här inställningarna kommer att användas (för den aktuella utskriften) i "
"stället för standardalternativen i <emph>Verktyg - Alternativ - %PRODUCTNAME "
"Impress - Skriv ut</emph>."

#: printing.xhp%23hd_id4555192.help.text
msgid "Choosing a print layout for handouts"
msgstr "Att väjla en utskriftsuppställning för flygblad"

#: printing.xhp%23par_id7197790.help.text
msgctxt "printing.xhp#par_id7197790.help.text"
msgid "Choose <item type=\"menuitem\">File - Print</item>."
msgstr "Välj <item type=\"menuitem\">Arkiv - Skriv ut</item>."

#: printing.xhp%23par_id1104159.help.text
msgid ""
"On the <emph>General</emph> tab page of the <emph>Print</emph> dialog, "
"select the \"Handouts\" entry from the Document listbox."
msgstr ""
"Markera posten \"Flygblad\" i listrutan Dokument på fliken "
"<emph>Allmänt</emph> i dialogrutan <emph>Skriv ut</emph>."

#: printing.xhp%23par_id9354533.help.text
msgid "Select the number of slides to print per page of paper."
msgstr "Välj antal presentationssidor som ska skrivas ut per sida."

#: printing.xhp%23hd_id6556596.help.text
msgid "Defining print options for handouts"
msgstr "Definera inställningarna för flygbladen"

#: printing.xhp%23par_id6744285.help.text
msgid "Click the Handout tab."
msgstr "Välj Flygbladsfliken"

#: printing.xhp%23par_id996734.help.text
msgid ""
"Choose <emph>Insert - Page Number</emph> to open the <emph>Header and "
"Footer</emph> dialog box."
msgstr ""
"Välj <emph>Infoga - Sidnummer</emph> för att öppna dialogrutan <emph>"
"Sidhuvuds och sidfots</emph>."

#: printing.xhp%23par_id6752220.help.text
msgid ""
"Click <emph>Notes and Handouts</emph> to enter the header and footer text "
"for handouts."
msgstr ""
"Välj <emph>Anteckningar och Flygblad</emph> för att redigera flygbladets "
"sidhuvud och sidfot."

#: printing.xhp%23par_id5703909.help.text
msgid ""
"You see four areas on this dialog with check boxes for Header, Date and "
"time, Footer, and Page number. These four areas correspond to the four areas "
"in the corners of the handout master view."
msgstr ""
"Fyra zoner i rutan syns med kryssrutor till Sidhuvudet, Datum och tiden, "
"Sidfoten, och Sidnumret.  Samtliga fyra områden motsvarar de fyra områden i "
"hörnen till flygbladets mall."

#: printing.xhp%23par_id4984282.help.text
msgid ""
"Enter text for header, footer, and date. Check the <emph>Page number</emph> "
"box, if you want to number the handout pages. Ensure the <emph>Header</emph> "
"check box is enabled if you want your header text to be printed."
msgstr ""
"Skriv texten till sidhuvudet, sidfoten och datum och tiden. Kryss "
"<emph>Sidnummer</emph>-rutan, i så fall det ska finnas numrering på "
"sidorna.   Bekräft att <emph>Sidhuvudet</emph>-rutan är markerad i så fall "
"att även sidhuvudet ska skivas ut."

#: printing.xhp%23par_id816064.help.text
msgid "Click <emph>Apply to All</emph>."
msgstr "Välj <emph>Samtliga</emph>."

#: printing.xhp%23par_id863063.help.text
msgid ""
"The fields in the handout master view on screen are not updated, but the "
"text that you entered will be printed."
msgstr "Fälten på mallbilden är inte aktuella dock texten ska skrivas ut."

#: printing.xhp%23hd_id5036164.help.text
msgid "Printing handouts or notes"
msgstr "Skriva ut flygblad"

#: printing.xhp%23par_id2901394.help.text
msgctxt "printing.xhp#par_id2901394.help.text"
msgid "Choose <item type=\"menuitem\">File - Print</item>."
msgstr "Välj <item type=\"menuitem\">Arkiv - Skriv ut</item>."

#: printing.xhp%23par_id5674611.help.text
msgid "Click the Document listbox and select the type of contents to print."
msgstr ""
"Klicka på listrutan Dokument och välj vilken typ av innehåll som ska skrivas "
"ut."

#: printing.xhp%23par_id1308023.help.text
msgid ""
"Select <emph>Handouts</emph> or <emph>Notes</emph> and select the number of "
"slides to print on each page of paper."
msgstr ""
"Välj <emph>Flygblad</emph> eller <emph>Anteckningar</emph> samt antal "
"presentationssidor ska skrivas ut per blad."

#: printing.xhp%23par_id6821192.help.text
msgid ""
"If you want another layout of the slides on the printed paper pages, use the "
"mouse to move the slides around on the Handout view."
msgstr ""
"Om det ska vara en annan uppsättning på de utskriva sidorna så flytta "
"bilderna i flygbladsläget."

#: printing.xhp%23hd_id3151389.11.help.text
msgid "Printing a range of slides"
msgstr "Skriva ut vissa sidor"

#: printing.xhp%23par_id3146318.12.help.text
msgid "Choose <emph>View - Slide Sorter</emph>."
msgstr "Välj <emph>Visa - Bildsortering</emph>."

#: printing.xhp%23par_id3166465.13.help.text
msgid "Hold down Shift, and click the range of slides that you want to print."
msgstr "Håll ned Skift-tangenten och klicka på de sidor som du vill skriva ut."

#: printing.xhp%23par_id3157875.14.help.text
msgctxt "printing.xhp#par_id3157875.14.help.text"
msgid "Choose <emph>File - Print</emph>."
msgstr "Välj <emph>Arkiv - Skriv ut</emph>."

#: printing.xhp%23par_id3150746.16.help.text
msgid "In the <emph>Range and copies</emph> area, click <emph>Slides</emph>."
msgstr ""
"I området <emph>Intervall och kopior</emph> klickar du på "
"<emph>Bilder</emph>."

#: printing.xhp%23par_id3154561.17.help.text
msgid "Enter the slide numbers you want to print, and click <emph>OK</emph>."
msgstr ""
"När sidnumren för de markerade sidorna visas i rutan <emph>Sidor</emph> "
"klick på <emph>OK</emph>."

#: animated_slidechange.xhp%23tit.help.text
msgid "Animating Slide Transitions"
msgstr "Animerade bildväxlingar"

#: animated_slidechange.xhp%23bm_id3153820.help.text
msgid ""
"<bookmark_value>cross-fading; slides</bookmark_value><bookmark_value>slide "
"transitions; applying effects</bookmark_value><bookmark_value>animated slide "
"transitions</bookmark_value><bookmark_value>transition "
"effects</bookmark_value><bookmark_value>deleting; slide transition "
"effects</bookmark_value><bookmark_value>effects;animated slide "
"transitions</bookmark_value>"
msgstr ""
"<bookmark_value>Övertoning; "
"bilder</bookmark_value><bookmark_value>Bildväxlingar; använda "
"effekter</bookmark_value><bookmark_value>Animerade bildväxlingar</bookmark_va"
"lue><bookmark_value>Övergångseffekter</bookmark_value><bookmark_value>Ta "
"bort; övergångseffekter</bookmark_value><bookmark_value>Effekter;animerade "
"bildväxlingar</bookmark_value>"

#: animated_slidechange.xhp%23hd_id3153820.46.help.text
msgid ""
"<variable id=\"animated_slidechange\"><link href=\"text/simpress/guide/"
"animated_slidechange.xhp\" name=\"Animating Slide Transitions\">Animating "
"Slide Transitions</link></variable>"
msgstr ""
"<variable id=\"animated_slidechange\"><link href=\""
"text/simpress/guide/animated_slidechange.xhp\" name=\"Animerade "
"diabildsväxlingar\">Animerade diabildsväxlingar</link></variable>"

#: animated_slidechange.xhp%23par_id3150049.67.help.text
msgid "You can apply a special effect that plays when you display a slide."
msgstr ""
"Du kan använda en specialeffekt som spelas upp när du visar en sida under "
"presentationen."

#: animated_slidechange.xhp%23hd_id3153811.68.help.text
msgid "To apply a transition effect to a slide"
msgstr "Så här använder du en övergångseffekt på en sida:"

#: animated_slidechange.xhp%23par_id3145086.50.help.text
msgid ""
"In <emph>Normal</emph> view, select the slide that you want to add the "
"transition effect to."
msgstr ""
"Gå till <emph>Normalvy</emph> och markera den bild som du ska använda "
"övergångseffekten på."

#: animated_slidechange.xhp%23par_id3150655.70.help.text
msgid "On the <emph>Tasks</emph> pane, click <emph>Slide Transition</emph>."
msgstr "Klicka på <emph>Bildväxling</emph> i <emph>aktivitetspanelen</emph>."

#: animated_slidechange.xhp%23par_id3154554.52.help.text
msgctxt "animated_slidechange.xhp#par_id3154554.52.help.text"
msgid "Select a slide transition from the list."
msgstr "Markera en bildväxling i listan."

#: animated_slidechange.xhp%23par_id3149022.74.help.text
msgid "You can preview the transition effect in the document window."
msgstr "Du kan förhandsvisa övergångseffekten i dokumentfönstret."

#: animated_slidechange.xhp%23hd_id3147562.75.help.text
msgid "To apply the same transition effect to more than one slide"
msgstr "Så här använder du samma övergångseffekt på fler än en sida:"

#: animated_slidechange.xhp%23par_id3150263.48.help.text
msgid ""
"In <emph>Slide Sorter</emph> view, select the slides that you want to add "
"the transition effect to."
msgstr ""
"Gå till <emph>Bildsortering</emph> och markera den bild som du ska använda "
"övergångseffekten på."

#: animated_slidechange.xhp%23par_id3148826.49.help.text
msgid ""
"If you want, you can use the <emph>Zoom</emph> toolbar <image id=\""
"img_id3151172\" src=\"res/commandimagelist/sc_zoom.png\" width=\"0.222inch\" "
"height=\"0.222inch\"><alt id=\"alt_id3151172\">Icon</alt></image> to change "
"the view magnification for the slides."
msgstr ""
"Om du vill kan du använda verktygsraden <emph>Zooma</emph> <image id=\""
"img_id3151172\" src=\"res/commandimagelist/sc_zoom.png\" width=\"0.222inch\" "
"height=\"0.222inch\"><alt id=\"alt_id3151172\">Ikon</alt></image> för att "
"ändra förstoringsgraden för bilderna."

#: animated_slidechange.xhp%23par_id3154269.78.help.text
msgid "On the Tasks pane, click Slide Transition."
msgstr "Klicka på Bildväxling i aktivitetspanelen."

#: animated_slidechange.xhp%23par_id3154102.79.help.text
msgctxt "animated_slidechange.xhp#par_id3154102.79.help.text"
msgid "Select a slide transition from the list."
msgstr "Markera en bildväxling i listan."

#: animated_slidechange.xhp%23par_id3153785.53.help.text
msgid ""
"To preview the transition effect for a slide, click the small icon "
"underneath the slide on the <emph>Slides Pane</emph>."
msgstr ""
"Om du vill förhandsgranska växlingen till en bild klickar du på den lilla "
"ikonen under bilden i <emph>Bildruta</emph>."

#: animated_slidechange.xhp%23hd_id3149341.83.help.text
msgid "To remove a transition effect"
msgstr "Så här tar du bort en övergångseffekt:"

#: animated_slidechange.xhp%23par_id3151287.84.help.text
msgid ""
"In <emph>Slide Sorter</emph> View, select the slides that you want to remove "
"the transition effect from."
msgstr ""
"In <emph>Gå till Bildsortering</emph>, och markera de bilder som du vill "
"använda övergångseffekten på."

#: animated_slidechange.xhp%23par_id3146930.85.help.text
msgid ""
"Choose <emph>No Transition </emph>in the listbox on the <emph>Tasks</emph> "
"pane."
msgstr ""
"Välj <emph>Ingen bildväxling</emph> i listrutan i "
"<emph>aktivitetspanelen</emph>."

#: animated_slidechange.xhp%23par_id3149300.60.help.text
msgid ""
"<link href=\"text/simpress/01/06040000.xhp\" name=\"Slide Transition\">Slide "
"Transition</link>"
msgstr ""
"<link href=\"text/simpress/01/06040000.xhp\" name=\"Diabildsväxling\""
">Diabildsväxling</link>"

#: animated_objects.xhp%23tit.help.text
msgid "Animating Objects in Presentation Slides"
msgstr "Animera objekt i presentationsbilder"

#: animated_objects.xhp%23bm_id3150251.help.text
msgid ""
"<bookmark_value>objects; moving along "
"paths</bookmark_value><bookmark_value>connecting; paths and "
"objects</bookmark_value><bookmark_value>paths; moving objects "
"along</bookmark_value><bookmark_value>motion "
"paths</bookmark_value><bookmark_value>deleting;animation "
"effects</bookmark_value><bookmark_value>effects;applying to/removing from "
"objects</bookmark_value><bookmark_value>animation effects</bookmark_value><bo"
"okmark_value>animations;editing</bookmark_value><bookmark_value>custom "
"animation</bookmark_value>"
msgstr ""
"<bookmark_value>Objekt; flytta längs "
"banor</bookmark_value><bookmark_value>Förbinda; sökvägar och "
"objekt</bookmark_value><bookmark_value>Banor; flytta objekt längs</bookmark_v"
"alue><bookmark_value>rörelsebanor</bookmark_value><bookmark_value>Ta "
"bort;animationseffekter</bookmark_value><bookmark_value>Effekter;använda "
"till/ta bort från objekt</bookmark_value><bookmark_value>animationseffekter</"
"bookmark_value><bookmark_value>animationer;redigera</bookmark_value><bookmark"
"_value>anpassad animation</bookmark_value>"

#: animated_objects.xhp%23hd_id3150251.31.help.text
msgid ""
"<variable id=\"animated_objects\"><link href=\"text/simpress/guide/"
"animated_objects.xhp\" name=\"Animating Objects in Slides\">Animating "
"Objects in Presentation Slides</link> </variable>"
msgstr ""
"<variable id=\"animated_objects\"><link href=\""
"text/simpress/guide/animated_objects.xhp\" name=\"Animating Objects in "
"Slides\">Animera objekt i presentationsbilder</link> </variable>"

#: animated_objects.xhp%23par_id3150214.32.help.text
msgid "You can apply preset animation effects to objects on your slide. "
msgstr ""
"Du kan använda fördefinierade animationseffekter på objekt på sidan. De "
"fördefinierade effekterna är samma effekter som du kan använda för "
"övergångar mellan sidor."

#: animated_objects.xhp%23hd_id3154762.70.help.text
msgid "To apply an animation effect to an object: "
msgstr "Så här använder du en animationseffekt på ett objekt:"

#: animated_objects.xhp%23par_id3146964.33.help.text
msgid ""
"On a slide in <emph>Normal</emph> view, select the object you want to "
"animate."
msgstr ""
"Öppna en bild i <emph>Normalvy</emph> och markera det objekt som ska "
"animeras."

#: animated_objects.xhp%23par_id3149875.35.help.text
msgid ""
"Choose <emph>Slide Show - Custom Animation</emph>, click <emph>Add</emph>, "
"and then select an animation effect."
msgstr ""
"Välj <emph>Bildskärmspresentation - Animation</emph> och välj sedan en "
"animation."

#: animated_objects.xhp%23par_id3166462.71.help.text
msgid ""
"In the <emph>Custom Animation</emph> dialog, click a tab page to choose from "
"a category of effects. Click an effect, then click <emph>OK</emph>."
msgstr ""
"Klicka på en flik med effekter i dialogrutan <emph>Anpassad animation</emph>"
". Klicka på en effekt, och klicka sedan på <emph>OK</emph>."

#: animated_objects.xhp%23par_id3156060.51.help.text
msgid "To preview the animation, click the <emph>Play</emph> button."
msgstr "Klicka på <emph>Spela upp</emph> för att förhandsgranska animationen."

#: animated_objects.xhp%23hd_id2476577.help.text
msgid "To apply and edit a motion path effect:"
msgstr "Så här tillämpar och redigerar du en rörelsebaneeffekt:"

#: animated_objects.xhp%23par_id4217047.help.text
msgid ""
"An object can be animated to move along a motion path. You can use "
"predefined or your own motion paths."
msgstr ""
"Ett objekt kan animeras och röra sig längs med en rörelsebana. Du kan "
"använda fördefinierade eller egna rörelsebanor."

#: animated_objects.xhp%23par_id2629474.help.text
msgid ""
"If you select \"Curve\", \"Polygon\", or \"Freeform Line\", the dialog "
"closes and you can draw your own path. If the drawing is finished and not "
"canceled, the created path is removed from the document and inserted as a "
"motion path effect."
msgstr ""
"Väljer du \"Kurva\", \"Polygon\" eller \"Frihandslinjer\", stängs "
"dialogrutan och du kan rita din egen bana. Om ritningen avslutas och inte "
"avbryts, tas den skapade banan bort från dokumentet och infogas som en "
"rörelsebaneeffekt."

#: animated_objects.xhp%23par_id8069704.help.text
msgid " <emph>Editing motion paths</emph> "
msgstr " <emph>Redigera rörelsebanor</emph> "

#: animated_objects.xhp%23par_id4524674.help.text
msgid ""
"If the Custom Animation Panel is visible, the motion paths of all effects of "
"the current slide are drawn as a transparent overlay on the slide. All paths "
"are visible all the time, therefore animations with consecutive paths can be "
"created easily. "
msgstr ""
"Om panelen Anpassad animation visas, ritas alla effekter för rörelsebanor i "
"aktuell bild som genomskinlig överläggning på bilden. Alla banor är synliga "
"hela tiden och därför kan du enkelt skapa animeringar med banor i rad. "

#: animated_objects.xhp%23par_id4396801.help.text
msgid ""
"A motion path can be selected by clicking on the path. A selected path will "
"support handles, it can be moved and resized like a shape. A double click on "
"a path starts the point edit mode. The point edit mode can also be started "
"by <item type=\"menuitem\">Edit - Points</item> or by pressing <item type=\""
"keycode\">F8</item>."
msgstr ""
"Välj rörelsebana genom att klicka på banan. En markerad bana stöder hantag "
"och den kan röras och ändras precis som en figur. Dubbelklicka på en bana "
"och punktredigeringsläge startas. Punktredigeringsläget kan även startas "
"genom<item type=\"menuitem\">Redigera - Punkter</item> eller genom att "
"trycka på <item type=\"keycode\">F8</item>."

#: animated_objects.xhp%23hd_id3148387.76.help.text
msgid "To remove an animation effect from an object:"
msgstr "Så här tar du bort en animationseffekt från ett objekt:"

#: animated_objects.xhp%23par_id3148774.77.help.text
msgid ""
"On a slide in <emph>Normal</emph> view, select the object from which to "
"remove the effect."
msgstr ""
"Öppna en bild i <emph>Normalvy</emph> och markera objektet vars effekt ska "
"tas bort."

#: animated_objects.xhp%23par_id3155372.78.help.text
msgid "Choose <emph>Slide Show - Custom Animation</emph>."
msgstr "Välj <emph>Bildskärmspresentation - Effekt</emph>."

#: animated_objects.xhp%23par_id3153718.80.help.text
msgid "Click <emph>Remove</emph>."
msgstr ""
"Den första posten, <emph>Ingen effekt</emph>, är markerad. Klicka på "
"<emph>Tilldela</emph>."

#: show.xhp%23tit.help.text
msgid "Showing a Slide Show"
msgstr "Visar bilderna"

#: show.xhp%23bm_id5592516.help.text
msgid ""
"<bookmark_value>running slide shows</bookmark_value><bookmark_value>showing;"
"slide shows</bookmark_value><bookmark_value>slide shows; "
"starting</bookmark_value><bookmark_value>presentations; "
"starting</bookmark_value><bookmark_value>starting; slide "
"shows</bookmark_value><bookmark_value>automatic slide "
"shows</bookmark_value><bookmark_value>slide "
"transitions;automatic</bookmark_value><bookmark_value>automatic slide "
"transition</bookmark_value>"
msgstr ""
"<bookmark_value>Köra bildskärmspresentationer</bookmark_value><bookmark_value"
">Visa;bildskärmspresentationer</bookmark_value><bookmark_value>Bildskärmspres"
"entationer; starta</bookmark_value><bookmark_value>Presentationer; "
"starta</bookmark_value><bookmark_value>Starta; "
"bildskärmspresentationer</bookmark_value><bookmark_value>Automatiska bildskär"
"mspresentationer</bookmark_value><bookmark_value>Bildväxlingar;automatiska</b"
"ookmark_value><bookmark_value>Automatiska bildväxlingar</bookmark_value>"

#: show.xhp%23hd_id4901272.help.text
msgid ""
"<variable id=\"show\"><link href=\"text/simpress/guide/show.xhp\" name=\""
"Showing a Slide Show\">Showing a Slide Show</link></variable>"
msgstr ""
"<variable id=\"show\"><link href=\"text/simpress/guide/show.xhp\" name=\"Att "
"visa diabilder\">Att visa diabilder</link></variable>"

#: show.xhp%23par_id9636829.help.text
msgid ""
"Different ways exist to start a slide show. Once a slide show is running, "
"you can take control pressing keys or clicking the mouse buttons."
msgstr ""
"Flera sätt finns att börja visa diabilderna.  Då en visning är påbörjat så "
"kan den styrs med tangenten eller musknappen."

#: show.xhp%23par_id7076937.help.text
msgid ""
"By default, a slide show always starts with the first slide. You advance "
"manually through slides up to the last slide. You can change these settings."
msgstr ""
"Det förvalda värdet är att börja alltid med den första diabilden.  Stiga för "
"hand genom resten ändå till sistan.  Dessa inställningar kan ändras."

#: show.xhp%23hd_id9954527.help.text
msgid "Running a Slide Show"
msgstr "Visning av diabilder"

#: show.xhp%23par_id6860255.help.text
msgid "Choose <emph>Slide Show - Slide Show</emph> to run the show."
msgstr ""
"Välj <emph>Bildskärmspresentation - Bildskärmspresentation</emph> för att "
"köra presentationen."

#: show.xhp%23par_id4199957.help.text
msgid ""
"If you want all shows to start from the current slide instead of the first "
"slide, choose <emph><switchinline select=\"sys\"><caseinline select=\"MAC\">%"
"PRODUCTNAME - Preferences</caseinline><defaultinline>Tools - "
"Options</defaultinline></switchinline> - %PRODUCTNAME Impress - "
"General</emph> and click <emph>Always with current page</emph>."
msgstr ""
"Om du vill att alla presentationer ska börja från och med den aktuella "
"bilden istället för den första bilden så väljer du <emph><switchinline "
"select=\"sys\"><caseinline select=\"MAC\">%PRODUCTNAME – "
"Inställningar</caseinline><defaultinline>Verktyg – "
"Alternativ</defaultinline></switchinline> – %PRODUCTNAME Impress – "
"Allmänt</emph> och klickar på <emph>Alltid den aktuella bilden</emph>."

#: show.xhp%23par_id3209936.help.text
msgid "Click to advance to the next effect or to the next slide."
msgstr "Tryck på knappen för att visa den nästa effekten eller diabilden."

#: show.xhp%23par_id8702658.help.text
msgid ""
"Press <item type=\"keycode\">Esc</item> to abort the show before the end."
msgstr "Tryck på <item type=\"keycode\">Esc</item> för att avbryta visningen."

#: show.xhp%23par_id3741264.help.text
msgid ""
"Many more keys are available to <link href=\"text/simpress/04/01020000.xhp\">"
"control a slide show</link>. You can also right-click to open a context menu "
"with useful commands."
msgstr ""
"Flera val finns  <link href=\"text/simpress/04/01020000.xhp\">att styra "
"visningen</link>.  Höger-klicka för att se en sammanhangsmeny med nyttiga "
"funktioner."

#: show.xhp%23hd_id5694143.help.text
msgid "Showing an automatic slide show (kiosk mode)"
msgstr "Visningen körs automatiskt (kiosk-läget)"

#: show.xhp%23par_id5829645.help.text
msgid ""
"For an automatic change to the next slide, you must assign a slide "
"transition to each slide. "
msgstr ""
"Övergång mellan bilderna kan ske automatiskt.  Välj en övergång till varenda "
"bild."

#: show.xhp%23par_id2361522.help.text
msgid ""
"On the Task Pane, click <emph>Slide Transition</emph> to open that tab page."
msgstr "I Uppgiftsrutan välj <emph>Bildövergång</emph> för att få fram fliken."

#: show.xhp%23par_id9168980.help.text
msgid ""
"In the <emph>Advance slide</emph> area, click <emph>Automatically "
"after</emph>, and select a time duration."
msgstr ""
"På <emph>Nästa bild</emph> rutan, välj <emph>automatiskt efter</emph> och "
"sedan välj en tid."

#: show.xhp%23par_id9766533.help.text
msgid "Click <emph>Apply to All Slides</emph>."
msgstr "Välj <emph>Ändra samtliga bilder</emph>."

#: show.xhp%23par_id6081728.help.text
msgid ""
"You can assign a different time for every slide to advance to the next "
"slide. The <link href=\"text/simpress/guide/rehearse_timings.xhp\">rehearse "
"timings</link> feature can assist you to get the timing right."
msgstr ""
"Varenda bild kan få egen tid innan nästa bilden visas.   <link href=\""
"text/simpress/guide/rehearse_timings.xhp\">Visa tempo</link> funktionen "
"hjälper med att få lagom tid mellan bilderna."

#: show.xhp%23par_id9219641.help.text
msgid ""
"To advance to the first slide, after all slides have been shown, you must "
"set the slide show to repeat automatically."
msgstr ""
"Att visa första bilden då alla andra har visats redan, automatiskt "
"upprepning måste väljas."

#: show.xhp%23par_id3174230.help.text
msgid "Choose <emph>Slide Show - Slide Show Settings</emph>."
msgstr "Välj <emph>Visning - Inställningar för visningar</emph>."

#: show.xhp%23par_id1336405.help.text
msgid ""
"In the Type area, click <emph>Auto</emph> and select a pause time between "
"shows."
msgstr ""
"I Sort-rutan, välj <emph>Auto</emph> och sedan välj pausen mellan "
"visningarna."

#: show.xhp%23par_id4959257.help.text
msgid ""
"When you create a new slide show using the <link href=\"text/shared/autopi/"
"01050000.xhp\">Presentation Wizard</link>, you can select the duration of "
"slides and of the pause, on the third wizard page."
msgstr ""
"Då en ny visning skapas med hjälp av  <link href=\""
"text/shared/autopi/01050000.xhp\">Presentationsguiden</link> väntan mellan "
"bilderna kan välja på guidens tredje sidan."

#: show.xhp%23hd_id1906491.help.text
msgid "Running a slide show from a file"
msgstr "Visa bilderna ur fil"

#: show.xhp%23par_id4799340.help.text
msgid ""
"You can start %PRODUCTNAME from a command prompt, followed by the parameter <"
"item type=\"literal\">-show</item> and an Impress filename. For example, to "
"start the file <item type=\"literal\">filename.odp</item> from the command "
"prompt, enter the following command:"
msgstr ""
"%PRODUCTNAME kan börjas även från kommandoprompten, med tillägg av  <item "
"type=\"literal\">-show</item> och sedan namnet till Impress-filen. Till "
"exempel, för att visa filen <item type=\"literal\">filename.odp</item> från "
"kommandoraden skriv:"

#: show.xhp%23par_id1502121.help.text
msgid "<item type=\"literal\">soffice -show filename.odp</item>"
msgstr "<item type=\"literal\">soffice -show filename.odp</item>"

#: show.xhp%23par_id8266853.help.text
msgid ""
"This assumes that soffice is in the program path of your system, and that <"
"item type=\"literal\">filename.odp</item> is located in the current "
"directory."
msgstr ""
"Med förutsättning att soffice finns i systemmets sögväg, och att <item type="
"\"literal\">filename.odp</item> finns i den aktuella mappan."

#: line_edit.xhp%23tit.help.text
msgid "Editing Curves"
msgstr "Redigera kurvor"

#: line_edit.xhp%23bm_id3150441.help.text
msgid ""
"<bookmark_value>curves; editing</bookmark_value><bookmark_value>editing; curv"
"es</bookmark_value><bookmark_value>splitting;curves</bookmark_value><bookmark"
"_value>closing;shapes</bookmark_value><bookmark_value>deleting;points</bookma"
"rk_value><bookmark_value>converting;points</bookmark_value><bookmark_value>po"
"ints;adding/converting/deleting</bookmark_value>"
msgstr ""
"<bookmark_value>kurvor; redigera</bookmark_value><bookmark_value>redigera; "
"kurvor</bookmark_value><bookmark_value>dela "
"upp;kurvor</bookmark_value><bookmark_value>sluta;figurer "
"</bookmark_value><bookmark_value>ta bort;punkter</bookmark_value><bookmark_va"
"lue>konvertera;punkter</bookmark_value><bookmark_value>punkter;lägga "
"till/konvertera/ta bort</bookmark_value>"

#: line_edit.xhp%23hd_id3150441.10.help.text
msgid ""
"<variable id=\"line_edit\"><link href=\"text/simpress/guide/line_edit.xhp\" "
"name=\"Editing Curves\">Editing Curves</link></variable>"
msgstr ""
"<variable id=\"line_edit\"><link href=\"text/simpress/guide/line_edit.xhp\" "
"name=\"Redigera kurvor\">Redigera kurvor</link></variable>"

#: line_edit.xhp%23par_id3150342.11.help.text
msgid ""
"A curved line segment consists of two data points (endpoints) and two "
"control points (handles). A control line connects a control point to a data "
"point. You can change the shape of a curve by converting a data point to a "
"different type, or by dragging the control points to a different location."
msgstr ""
"Ett kurvlinjesegment består av två datapunkter (slutpunkter) och två "
"kontrollpunkter (handtag). En kontrollpunkt ansluts till en datapunkt med en "
"kontrollinje. Du kan ändra formen på en kurva genom att konvertera en "
"datapunkt till en annan typ av punkt, eller genom att dra kontrollpunkterna "
"till andra platser."

#: line_edit.xhp%23par_id3145252.16.help.text
msgid ""
"You can also modify the properties of the line by selecting the line and "
"choosing <emph>Format - Line</emph>."
msgstr ""
"Du kan också ändra linjens egenskaper genom att markera linjen och välja "
"<emph>Format - Linje</emph>."

#: line_edit.xhp%23par_id3153711.help.text
msgid ""
"<image id=\"img_id3149018\" src=\"res/commandimagelist/"
"sc_toggleobjectbeziermode.png\" width=\"0.222inch\" height=\"0.222inch\"><"
"alt id=\"alt_id3149018\">Icon</alt></image>"
msgstr ""
"<image id=\"img_id3149018\" src=\""
"res/commandimagelist/sc_toggleobjectbeziermode.png\" width=\"0.222inch\" "
"height=\"0.222inch\"><alt id=\"alt_id3149018\">Ikon</alt></image>"

#: line_edit.xhp%23par_id3155959.54.help.text
msgid ""
"To view the data points and control points of a curved line, select the "
"line, and then click the <emph>Points</emph> icon on the Drawing bar. The "
"data points are represented by squares and the control points by circles. A "
"control point might overlay a data point."
msgstr ""
"Du kan granska de datapunkter och kontrollpunkter som hör till en kurva "
"genom att markera linjen och klicka på ikonen <emph>Punkter</emph> på "
"verktygsraden Ritverktyg. Datapunkterna representeras av fyrkanter och "
"kontrollpunkterna av cirklar. En kontrollpunkt kan ligga över en datapunkt."

#: line_edit.xhp%23hd_id3145587.55.help.text
msgid "To adjust a curved line segment:"
msgstr "Så här justerar du ett kurvlinjesegment:"

#: line_edit.xhp%23par_id3151241.51.help.text
msgctxt "line_edit.xhp#par_id3151241.51.help.text"
msgid ""
"Select a curved line, and then click the <emph>Points </emph>icon on the "
"<emph>Drawing</emph> Bar."
msgstr ""
"Markera en kurvlinje och klicka på ikonen <emph>Redigera punkter</emph> på "
"verktygsraden <emph>Ritverktyg</emph>."

#: line_edit.xhp%23par_id3150213.56.help.text
msgctxt "line_edit.xhp#par_id3150213.56.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: line_edit.xhp%23par_id3153810.12.help.text
msgid ""
"Drag a data point to resize the line. If a control point overlies the data "
"point, drag the control point until you can see the data point, and then "
"drag the data point."
msgstr ""
"Du kan ändra linjens storlek genom att dra i datapunkterna. Om en "
"kontrollpunkt ligger över en datapunkt drar du kontrollpunkten tills du kan "
"se datapunkten."

#: line_edit.xhp%23par_id3149872.13.help.text
msgid ""
"Drag a control point. The curve pulls in the direction that you drag the "
"control point."
msgstr "Dra en kontrollpunkt. Kurvan böjs i den riktning du drar punkten i."

#: line_edit.xhp%23hd_id3150431.57.help.text
msgid "To split a curved line:"
msgstr "Så här delar du upp en kurvlinje:"

#: line_edit.xhp%23par_id3150395.58.help.text
msgid "You can only split a curved line that has three or more data points."
msgstr "Du kan bara dela upp en linje som har tre datapunkter eller fler."

#: line_edit.xhp%23par_id3151392.59.help.text
msgctxt "line_edit.xhp#par_id3151392.59.help.text"
msgid ""
"Select a curved line, and then click the <emph>Points </emph>icon on the "
"<emph>Drawing</emph> Bar."
msgstr ""
"Markera en kurvlinje och klicka på ikonen <emph>Redigera punkter</emph> på "
"verktygsraden <emph>Ritverktyg</emph>."

#: line_edit.xhp%23par_id3149941.60.help.text
msgid ""
"Select a data point, and then click the <emph>Split Curve </emph>icon on the "
"<emph>Edit Points</emph> Bar."
msgstr ""
"Markera en datapunkt och klicka på ikonen <emph>Dela upp kurva</emph> på "
"verktygsraden <emph>Redigera punkter</emph>."

#: line_edit.xhp%23hd_id3150655.61.help.text
msgid "To create a closed shape:"
msgstr "Så här skapar du en sluten figur:"

#: line_edit.xhp%23par_id3150743.62.help.text
msgctxt "line_edit.xhp#par_id3150743.62.help.text"
msgid ""
"Select a curved line, and then click the <emph>Points </emph>icon on the "
"<emph>Drawing</emph> Bar."
msgstr ""
"Markera en kurvlinje och klicka på ikonen <emph>Redigera punkter</emph> på "
"verktygsraden <emph>Ritverktyg</emph>."

#: line_edit.xhp%23par_id3153080.63.help.text
msgid ""
"On the <emph>Edit Points</emph> Bar, click the<emph> Close Bézier</emph> "
"icon."
msgstr ""
"Klicka på ikonen <emph>Slut Bézier</emph> på verktygsraden <emph>Redigera "
"punkter</emph>."

#: line_edit.xhp%23hd_id3145162.15.help.text
msgid "To convert a data point on a curved line:"
msgstr "Så här gör du för att omvandla en datapunkt på en kurva:"

#: line_edit.xhp%23par_id3150336.64.help.text
msgctxt "line_edit.xhp#par_id3150336.64.help.text"
msgid ""
"Select a curved line, and then click the <emph>Points </emph>icon on the "
"<emph>Drawing</emph> Bar."
msgstr ""
"Markera en kurvlinje och klicka på ikonen <emph>Redigera punkter</emph> på "
"verktygsraden <emph>Ritverktyg</emph>."

#: line_edit.xhp%23par_id3155925.14.help.text
msgid "Click the data point you want to convert, and do one of the following:"
msgstr "Klicka på den datapunkt som du vill omvandla och gör något av följande:"

#: line_edit.xhp%23par_id3145241.65.help.text
msgid ""
"To convert the data point to a smooth point, click the <emph>Smooth "
"Transition</emph> icon on the <emph>Edit Points</emph> Bar."
msgstr ""
"Du kan konvertera datapunkten till en jämn punkt genom att klicka på ikonen "
"<emph>Jämn övergång</emph> på verktygsraden <emph>Redigera punkter</emph>."

#: line_edit.xhp%23par_id3145299.66.help.text
msgid ""
"To convert the data point to a symmetrical point, click the <emph>Symmetric "
"Transition</emph> icon on the <emph>Edit Points</emph> Bar."
msgstr ""
"Du kan konvertera datapunkten till en symmetrisk punkt genom att klicka på "
"ikonen <emph>Symmetrisk övergång</emph> på verktygsraden <emph>Redigera "
"punkter</emph>."

#: line_edit.xhp%23par_id3145348.67.help.text
msgid ""
"To convert the data point to a corner point, click the <emph>Corner "
"Point</emph> icon on the <emph>Edit Points</emph> Bar."
msgstr ""
"Du kan konvertera datapunkten till en hörnpunkt genom att klicka på ikonen "
"<emph>Hörnpunkt</emph> på verktygsraden <emph>Redigera punkter</emph>."

#: line_edit.xhp%23hd_id3150471.68.help.text
msgid "To add a data point:"
msgstr "Så här lägger du till en datapunkt:"

#: line_edit.xhp%23par_id3155373.69.help.text
msgctxt "line_edit.xhp#par_id3155373.69.help.text"
msgid ""
"Select a curved line, and then click the <emph>Points </emph>icon on the "
"<emph>Drawing</emph> Bar."
msgstr ""
"Markera en kurvlinje och klicka på ikonen <emph>Redigera punkter</emph> på "
"verktygsraden <emph>Ritverktyg</emph>."

#: line_edit.xhp%23par_id3156256.70.help.text
msgid ""
"On the <emph>Edit Points</emph> Bar, click the<emph> Insert Points</emph> "
"icon."
msgstr ""
"Klicka på ikonen <emph>Infoga punkter</emph> på verktygsraden <emph>Redigera "
"punkter</emph>."

#: line_edit.xhp%23par_id3083280.71.help.text
msgid ""
"Click the line where you want to add the point, and drag a short distance."
msgstr ""
"Klicka på linjen på det ställe där punkten ska läggas till och dra med musen "
"en kort sträcka."

#: line_edit.xhp%23par_id3154643.72.help.text
msgid ""
"If a data point does not have a control point, select the data point, and "
"then click the <emph>Convert to Curve</emph> icon on the <emph>Edit "
"Points</emph> Bar."
msgstr ""
"Om en datapunkt inte har en motsvarande kontrollpunkt, markerar du "
"datapunkten och klickar på ikonen <emph>Konvertera till kurva</emph> på "
"verktygsraden <emph>Redigera punkter</emph>."

#: line_edit.xhp%23hd_id3151186.73.help.text
msgid "To delete a data point:"
msgstr "Så här tar du bort en datapunkt:"

#: line_edit.xhp%23par_id3153624.74.help.text
msgctxt "line_edit.xhp#par_id3153624.74.help.text"
msgid ""
"Select a curved line, and then click the <emph>Points </emph>icon on the "
"<emph>Drawing</emph> Bar."
msgstr ""
"Markera en kurvlinje och klicka på ikonen <emph>Redigera punkter</emph> på "
"verktygsraden <emph>Ritverktyg</emph>."

#: line_edit.xhp%23par_id3150261.75.help.text
msgid "Click the point you want to delete."
msgstr "Klicka på den punkt som ska tas bort."

#: line_edit.xhp%23par_id3143230.76.help.text
msgid ""
"On the <emph>Edit Points</emph> Bar, click the<emph> Delete Points</emph> "
"icon."
msgstr ""
"Klicka på ikonen <emph>Ta bort punkter</emph> på verktygsraden <emph>"
"Redigera punkter</emph>."

#: line_edit.xhp%23par_id3151174.52.help.text
msgid ""
"<link href=\"text/shared/main0227.xhp\" name=\"Edit Points bar\">Edit Points "
"bar</link>"
msgstr ""
"<link href=\"text/shared/main0227.xhp\" name=\"Verktysraden Redigera "
"punkter\">Verktygsraden Redigera punkter</link>"

#: text2curve.xhp%23tit.help.text
msgid "Converting Text Characters into Drawing Objects"
msgstr "Konvertera texttecken till ritobjekt"

#: text2curve.xhp%23bm_id3150717.help.text
msgid ""
"<bookmark_value>text; converting to "
"curves</bookmark_value><bookmark_value>characters; converting to "
"curves</bookmark_value><bookmark_value>sign conversion to "
"curves</bookmark_value><bookmark_value>converting; text to "
"curves</bookmark_value><bookmark_value>draw objects;converting text "
"to</bookmark_value><bookmark_value>curves;converting text to</bookmark_value>"
msgstr ""
"<bookmark_value>Text; konvertera till "
"kurvor</bookmark_value><bookmark_value>Tecken; konvertera till "
"kurvor</bookmark_value><bookmark_value>Teckenkonvertering till "
"kurvor</bookmark_value><bookmark_value>Konvertera; text till "
"kurvor</bookmark_value><bookmark_value>Ritobjekt; konvertera text "
"till</bookmark_value><bookmark_value>Kurvor; konvertera text "
"till</bookmark_value>"

#: text2curve.xhp%23hd_id3150717.3.help.text
msgid ""
"<variable id=\"text2curve\"><link href=\"text/simpress/guide/text2curve.xhp\""
" name=\"Converting Text Characters into Drawing Objects\">Converting Text "
"Characters into Drawing Objects</link></variable>"
msgstr ""
"<variable id=\"text2curve\"><link href=\"text/simpress/guide/text2curve.xhp\""
" name=\"Konvertera texttecken till ritobjekt\">Konvertera texttecken till "
"ritobjekt</link></variable>"

#: text2curve.xhp%23par_id3155960.21.help.text
msgid ""
"You can convert text characters into curves that you can edit and resize as "
"you would any drawing object. Once you convert text into a drawing object, "
"you can no longer edit the content of the text."
msgstr ""
"Du kan konvertera texttecken till kurvor. Du kan sedan redigera och ändra "
"storlek på kurvorna, precis som vilket annat ritobjekt som helst. När du har "
"konverterat texten till ritobjekt kan du inte längre ändra textens innehåll."

#: text2curve.xhp%23hd_id3153965.22.help.text
msgid "To convert text into a drawing object:"
msgstr "Så här konverterar du text till ritobjekt:"

#: text2curve.xhp%23par_id3146963.4.help.text
msgid "Select the text that you want to convert, and do one of the following:"
msgstr "Markera den text som du vill konvertera och gör något av följande:"

#: text2curve.xhp%23par_id3149053.5.help.text
msgid "In $[officename] Draw, choose <emph>Modify - Convert - To Curve</emph>."
msgstr ""
"I $[officename] Draw väljer du <emph>Ändra - Omvandla - Till kurva</emph>."

#: text2curve.xhp%23par_id3150395.23.help.text
msgid ""
"In $[officename] Impress, right-click the border of the text object, and "
"then choose <emph>Convert - To Curve</emph>."
msgstr ""
"I $[officename] Impress högerklickar du på inramningen till textobjektet och "
"väljer <emph>Omvandla - Till kurva</emph>."

#: text2curve.xhp%23par_id3150746.6.help.text
msgid ""
"If your text contains more than one character, the converted text becomes a "
"grouped object. Double-click the group to edit individual objects. Press Esc "
"when finished."
msgstr ""
"Om texten består av fler än ett tecken blir den konverterade texten ett "
"grupperat objekt. Dubbelklicka på gruppen om du vill redigera enskilda "
"objekt. Tryck på Esc när du är färdig."

#: text2curve.xhp%23par_id3150336.7.help.text
msgid ""
"Now, click the <emph>Points</emph> icon on the <emph>Drawing</emph> bar. "
"Click the object. You can see all the Bézier points of the object. On the "
"<emph>Edit Points</emph> bar, you can find various icons for editing, "
"inserting and deleting points."
msgstr ""
"Klicka på ikonen <emph>Punkter</emph> på verktygsraden <emph>Ritobjekt</emph>"
". Klicka på objektet. Alla Bézierpunkter på objektet visas. På verktygsraden "
"<emph>Redigera punkter</emph> finns olika typer av ikoner som du använder "
"när du redigerar, infogar och tar bort punkter."

#: keyboard.xhp%23tit.help.text
msgid "Using Shortcut Keys in $[officename] Impress "
msgstr "Använda kortkommandon i $[officename] Impress "

#: keyboard.xhp%23bm_id3154702.help.text
msgid "<bookmark_value>accessibility; $[officename] Impress</bookmark_value>"
msgstr "<bookmark_value>tillgänglighet; $[officename] Impress</bookmark_value>"

#: keyboard.xhp%23hd_id3154702.1.help.text
msgid ""
"<variable id=\"keyboard\"><link href=\"text/simpress/guide/keyboard.xhp\" "
"name=\"Using Shortcut Keys in $[officename] Impress\">Using Shortcut Keys in "
"$[officename] Impress</link></variable>"
msgstr ""
"<variable id=\"keyboard\"><link href=\"text/simpress/guide/keyboard.xhp\" "
"name=\"Använda kortkommandon i $[officename] Impress\">Använda kortkommandon "
"i $[officename] Impress</link></variable>"

#: keyboard.xhp%23par_id3148610.11.help.text
msgid ""
"You can use the keyboard to access $[officename] Impress commands as well as "
"to navigate through the workspace. $[officename] Impress uses the same "
"shortcut keys as $[officename] Draw to create <link href=\"text/sdraw/guide/"
"keyboard.xhp\" name=\"drawing objects\">drawing objects</link>."
msgstr ""
"Du kan använda tangentbordet för att utföra kommandon i $[officename] "
"Impress eller för att navigera i arbetsområdet. $[officename] Impress "
"använder samma kortkommandon som $[officename] Draw för att skapa <link href="
"\"text/sdraw/guide/keyboard.xhp\" name=\"ritobjekt\">ritobjekt</link>."

#: keyboard.xhp%23hd_id3149602.18.help.text
msgid "Selecting placeholders"
msgstr "Markera platshållare"

#: keyboard.xhp%23par_id3150212.10.help.text
msgid ""
"$[officename] Impress <emph>AutoLayouts</emph> use placeholders for slide "
"titles, text, and objects. To select a placeholder, press <item type=\""
"keycode\">Ctrl+Enter</item>. To move to the next placeholder, press <item "
"type=\"keycode\">Ctrl+Enter</item> again."
msgstr ""
"<emph>AutoLayout</emph> i $[officename] Impress använder platshållare för "
"rubriker, textobjekt och grafiska element. Du markerar en platshållare genom "
"att trycka på <item type=\"keycode\">Ctrl+Retur</item>. Du markerar nästa "
"platshållare genom att trycka på <item type=\"keycode\">Ctrl+Retur</item> en "
"gång till."

#: keyboard.xhp%23par_id3166467.9.help.text
msgid ""
"If you press <item type=\"keycode\">Ctrl+Enter</item> after you reach the "
"last placeholder in a slide, a new slide is inserted after the current "
"slide. The new slide uses the same layout as the current slide."
msgstr ""
"Om du trycker på <item type=\"keycode\">Ctrl+Retur</item> efter att du har "
"kommit till den sista platshållaren på en bild, infogas en ny bild i "
"dokumentet efter den aktuella bilden. Den nya sidan har samma layout som den "
"aktuella sidan."

#: keyboard.xhp%23hd_id3157871.8.help.text
msgid "During a Slide Show"
msgstr "Visa en presentation"

#: keyboard.xhp%23par_id3150650.7.help.text
msgid "To start a slide show, press <item type=\"keycode\">Ctrl+F2</item>."
msgstr ""
"Du startar en bildskärmspresentation genom att trycka på <item type=\""
"keycode\">Ctrl+F2</item>."

#: keyboard.xhp%23hd_id3149354.5.help.text
msgid "Advance to the next slide or to the next animation effect"
msgstr "Gå till nästa sida eller nästa animationseffekt"

#: keyboard.xhp%23par_id3148728.4.help.text
msgid "<item type=\"keycode\">Spacebar</item>"
msgstr "<item type=\"keycode\">Blanksteg</item>"

#: keyboard.xhp%23hd_id3153035.19.help.text
msgid "Advance to the next slide without playing object animation effects"
msgstr "Gå till nästa sida utan att använda objektanimationer"

#: keyboard.xhp%23par_id3155263.20.help.text
msgid ""
"<item type=\"keycode\"><switchinline select=\"sys\"><caseinline select=\""
"MAC\">Option</caseinline><defaultinline>Alt</defaultinline></switchinline>+Pa"
"geDown</item>"
msgstr ""

#: keyboard.xhp%23hd_id3154558.3.help.text
msgid "Return to previous slide"
msgstr "Gå tillbaka till föregående sida"

#: keyboard.xhp%23par_id3145590.2.help.text
msgid ""
"<item type=\"keycode\"><switchinline select=\"sys\"><caseinline select=\""
"MAC\">Option</caseinline><defaultinline>Alt</defaultinline></switchinline>+Pa"
"geUp</item>"
msgstr ""

#: keyboard.xhp%23hd_id3153003.12.help.text
msgid "Go to a specific slide"
msgstr "Gå till en viss sida"

#: keyboard.xhp%23par_id3154501.13.help.text
msgid ""
"Type the page number of the slide, and then press <item type=\"keycode\""
">Enter</item>."
msgstr ""
"Skriv bildens sidnummer och tryck på <item type=\"keycode\">Retur</item>."

#: keyboard.xhp%23hd_id3150337.14.help.text
msgid "Slide Sorter"
msgstr "Bildsortering"

#: keyboard.xhp%23par_id3153732.21.help.text
msgid ""
"When you first switch to Slide Sorter, press <item type=\"keycode\""
">Enter</item> to change the keyboard focus to the workspace. Otherwise, "
"press <item type=\"keycode\">F6</item> to navigate to the workspace, and "
"then press <item type=\"keycode\">Enter</item>. "
msgstr ""
"När du byter till Bildsortering för första gången, kan du trycka på <item "
"type=\"keycode\">Retur</item> för att byta tangentbordsfokus till "
"arbetsområdet. Du kan också trycka på <item type=\"keycode\">F6</item> för "
"att navigera till arbetsområdet och sedan trycka på <item type=\"keycode\""
">Retur</item>. "

#: keyboard.xhp%23hd_id3149882.22.help.text
msgid "Selecting and deselecting slides"
msgstr "Markera och avmarkera sidor"

#: keyboard.xhp%23par_id3155930.15.help.text
msgid ""
"Use the arrow keys to navigate to the slide that you want to select, and "
"then press the <item type=\"keycode\">Spacebar</item>. To add to the "
"selection, use the arrow keys to navigate to the slide(s) that you want to "
"add, and press <item type=\"keycode\">Spacebar</item> again. To deselect a "
"slide, navigate to the slide, and then press <item type=\"keycode\""
">Spacebar</item>."
msgstr ""
"Använd piltangenterna för att navigera till den sida som du vill markera och "
"tryck på <item type=\"keycode\">Mellanslag</item>. Om du vill utöka "
"markeringen, använder du piltangenterna för att gå till de bilder som du "
"vill ta med och trycker på <item type=\"keycode\">Mellanslag</item> igen. Om "
"du vill avmarkera en bild, navigerar du till bilden och trycker på <item "
"type=\"keycode\">Mellanslag</item>."

#: keyboard.xhp%23hd_id3145248.23.help.text
msgid "Copying a slide:"
msgstr "Kopiera en sida:"

#: keyboard.xhp%23par_id3156060.16.help.text
msgid ""
"Use the arrow keys to navigate to the slide that you want to copy, and then "
"press <item type=\"keycode\">Ctrl+C</item>."
msgstr ""
"Använd piltangenterna för att navigera till den bild som du vill kopiera och "
"tryck på <item type=\"keycode\">Ctrl+C</item>."

#: keyboard.xhp%23par_id3148769.24.help.text
msgid ""
"Move to the slide where you want to paste the copied slide, and then press <"
"item type=\"keycode\">Ctrl+V</item>."
msgstr ""
"Gå till den bild där du vill kopiera in bilden och tryck på <item type=\""
"keycode\">Ctrl+V</item>."

#: keyboard.xhp%23par_id3148388.25.help.text
msgctxt "keyboard.xhp#par_id3148388.25.help.text"
msgid ""
"Select <emph>Before </emph>or <emph>After</emph> the current slide, and then "
"click <emph>OK</emph>."
msgstr ""
"Välj att infoga sidan <emph>Innan</emph> eller <emph>Efter</emph> den "
"aktuella sidan och klicka på <emph>OK</emph>."

#: keyboard.xhp%23hd_id3155367.26.help.text
msgid "Moving a slide:"
msgstr "Flytta en sida:"

#: keyboard.xhp%23par_id3155987.27.help.text
msgid ""
"Use the arrow keys to navigate to the slide that you want to move, and then "
"press <item type=\"keycode\">Ctrl+X</item>."
msgstr ""
"Använd piltangenterna för att navigera till den sida som du vill kopiera och "
"tryck på <item type=\"keycode\">Ctrl+X</item>."

#: keyboard.xhp%23par_id3147171.28.help.text
msgid ""
"Navigate to the slide where you want to move the slide, and then press <item "
"type=\"keycode\">Ctrl+V</item>."
msgstr ""
"Gå till den bild dit du vill flytta den kopierade bilden och tryck på <item "
"type=\"keycode\">Ctrl+V</item>."

#: keyboard.xhp%23par_id3083282.29.help.text
msgctxt "keyboard.xhp#par_id3083282.29.help.text"
msgid ""
"Select <emph>Before </emph>or <emph>After</emph> the current slide, and then "
"click <emph>OK</emph>."
msgstr ""
"Välj att infoga sidan <emph>Innan</emph> eller <emph>Efter</emph> den "
"aktuella sidan och klicka på <emph>OK</emph>."

#: rehearse_timings.xhp%23tit.help.text
msgid "Rehearse Timings of Slide Changes"
msgstr "Visa en presentation med tidtagning"

#: rehearse_timings.xhp%23bm_id3145253.help.text
msgid ""
"<bookmark_value>presentations;rehearse "
"timings</bookmark_value><bookmark_value>rehearse "
"timings</bookmark_value><bookmark_value>timings; rehearse "
"timings</bookmark_value><bookmark_value>automatic slide changes;rehearse "
"timings</bookmark_value><bookmark_value>recording;display times for "
"slides</bookmark_value>"
msgstr ""
"<bookmark_value>Presentationer; tidtagning</bookmark_value><bookmark_value>Ti"
"dtagning</bookmark_value><bookmark_value>Längd; kontrollera "
"längd</bookmark_value><bookmark_value>Automatiska bildväxlingar; "
"tidtagning</bookmark_value><bookmark_value>Registrera; visningstider för "
"bilder</bookmark_value>"

#: rehearse_timings.xhp%23hd_id3145253.17.help.text
msgid ""
"<variable id=\"rehearse_timings\"><link href=\"text/simpress/guide/"
"rehearse_timings.xhp\" name=\"Rehearse Timings of Slide Changes\">Rehearse "
"Timings of Slide Changes</link></variable>"
msgstr ""
"<variable id=\"rehearse_timings\"><link href=\""
"text/simpress/guide/rehearse_timings.xhp\" name=\"Visa en presentation med "
"tidtagning\">Visa en presentation med tidtagning</link></variable>"

#: rehearse_timings.xhp%23par_id3155446.1.help.text
msgid ""
"$[officename] assists you in defining the right rehearse timings for "
"automatic slide changes. "
msgstr ""
"Med $[officename] kan du få hjälp med att anpassa längden på automatiska "
"diabildsväxlingar."

#: rehearse_timings.xhp%23par_id3153963.16.help.text
msgid ""
"Prepare the slides, start the show using a special icon, tell your imaginary "
"audience what you want to tell for the first slide, then advance to the next "
"slide and so on. $[officename] records the display time for each slide, so "
"the next time you play the show with automatic slide changes, the timing "
"will be as recorded."
msgstr ""
"Skapa sidorna, starta presentationen med en särskild ikon och håll "
"presentationen som du tänker hålla den för en riktig publik. När du byter "
"sida sparas visningslängden för varje sida så att du kan köra presentationen "
"automatiskt nästa gång."

#: rehearse_timings.xhp%23hd_id3146317.2.help.text
msgid "To record a show with rehearse timings"
msgstr "Så här spelar du in visningslängden på sidor"

#: rehearse_timings.xhp%23par_id3149874.4.help.text
msgid "Open a presentation, and switch to <emph>Slide Sorter</emph> View."
msgstr "Öppna en presentation och växla till <emph>Bildsortering</emph>."

#: rehearse_timings.xhp%23par_id3150651.6.help.text
msgid ""
"Start the show with the <emph>Rehearse Timings</emph> icon <image id=\""
"img_id3156396\" src=\"res/commandimagelist/sc_rehearsetimings.png\" width=\""
"0.222inch\" height=\"0.222inch\"><alt id=\"alt_id3156396\">Icon</alt></image>"
" in the Slide View bar. You see the first slide, and a timer in the bottom "
"corner."
msgstr ""
"Starta presentationen med ikonen <emph>Bildskärmspresentation med "
"tidtagning</emph> <image id=\"img_id3156396\" src=\""
"res/commandimagelist/sc_rehearsetimings.png\" width=\"0.222inch\" height=\"0."
"222inch\"><alt id=\"alt_id3156396\">Ikon</alt></image> på raden Bildvy. Den "
"första sidan visas med ett stoppur längst ned."

#: rehearse_timings.xhp%23par_id3145590.8.help.text
msgid ""
"When it's time to advance to the next slide, click the timer. To keep the "
"default setting for this slide, click the slide, but not the timer. Continue "
"for all slides in your presentation."
msgstr ""
"När det är dags att gå vidare till nästa sida klickar du på stoppuret. Om du "
"vill behålla standardinställningen för bilden, klickar du på bilden, men "
"inte på stoppuret. Fortsätt på samma sätt med alla sidor i presentationen."

#: rehearse_timings.xhp%23par_id3150333.10.help.text
msgid ""
"$[officename] has recorded the display time for each slide. Save your "
"presentation."
msgstr ""
"$[officename] har sparat visningslängden för alla bilder. Spara "
"presentationen."

#: rehearse_timings.xhp%23par_id3145248.12.help.text
msgid ""
"If you want the whole presentation to auto-repeat, open the menu <emph>Slide "
"Show - Slide Show Settings</emph>. Click <emph>Auto</emph> and "
"<emph>OK</emph>."
msgstr ""
"Om du vill att hela presentationen ska repeteras automatiskt, öppnar du "
"dialogrutan <emph>Bildskärmspresentation - Presentationsinställningar</emph>"
". Klicka på <emph>Auto</emph> och sedan på <emph>OK</emph>."

#: rehearse_timings.xhp%23par_id3150935.13.help.text
msgid ""
"<link href=\"text/simpress/01/06080000.xhp\" name=\"Slide Show Settings\">"
"Slide Show Settings</link>"
msgstr ""
"<link href=\"text/simpress/01/06080000.xhp\" name=\""
"Presentationsinställningar\">Presentationsinställningar</link>"

#: move_object.xhp%23tit.help.text
msgid "Moving Objects"
msgstr "Flytta objekt"

#: move_object.xhp%23bm_id3146121.help.text
msgid ""
"<bookmark_value>objects;moving in "
"slides</bookmark_value><bookmark_value>moving;objects in "
"slides</bookmark_value>"
msgstr ""
"<bookmark_value>Objekt; flytta i "
"bilder</bookmark_value><bookmark_value>Flytta; objekt på "
"bilder</bookmark_value>"

#: move_object.xhp%23hd_id3146121.5.help.text
msgid ""
"<variable id=\"move_object\"><link href=\"text/simpress/guide/move_object."
"xhp\" name=\"Moving Objects\">Moving Objects</link></variable>"
msgstr ""
"<variable id=\"move_object\"><link href=\"text/simpress/guide/move_object."
"xhp\" name=\"Flytta objekt\">Flytta objekt</link></variable>"

#: move_object.xhp%23par_id3149667.6.help.text
msgid ""
"You can move selected objects in your slide by dragging them, using the "
"arrow keys, or by copying the objects and pasting them in another location."
msgstr ""
"Du kan flytta markerade objekt på en diabild genom att dra dem, genom att "
"använda piltangenterna eller genom att klippa ut objekten och klistra in dem "
"på en annan plats."

#: move_object.xhp%23par_id3145799.7.help.text
msgid "The arrow keys let you move objects more precisely than with the mouse."
msgstr ""
"Om du använder piltangenterna kan du flytta objekten mycket mer exakt än med "
"musen."

#: layer_move.xhp%23tit.help.text
msgid "Moving Objects to a Different Layer"
msgstr "Flytta objekt till en annan nivå"

#: layer_move.xhp%23bm_id3150752.help.text
msgid ""
"<bookmark_value>objects; moving in "
"layers</bookmark_value><bookmark_value>layers; moving "
"objects</bookmark_value><bookmark_value>moving; between "
"layers</bookmark_value>"
msgstr ""
"<bookmark_value>Objekt; flytta i "
"nivåer</bookmark_value><bookmark_value>Nivåer; flytta "
"objekt</bookmark_value><bookmark_value>Flytta; mellan nivåer</bookmark_value>"

#: layer_move.xhp%23hd_id3150752.18.help.text
msgid ""
"<variable id=\"layer_move\"><link href=\"text/simpress/guide/layer_move.xhp\""
" name=\"Moving Objects to a Different Layer\">Moving Objects to a Different "
"Layer</link></variable>"
msgstr ""
"<variable id=\"layer_move\"><link href=\"text/simpress/guide/layer_move.xhp\""
" name=\"Flytta objekt till annan nivå\">Flytta objekt till annan "
"nivå</link></variable>"

#: layer_move.xhp%23par_idN10622.help.text
msgctxt "layer_move.xhp#par_idN10622.help.text"
msgid "Drawings in %PRODUCTNAME Draw support layers."
msgstr "Ritobjekt i stödnivåer i %PRODUCTNAME Draw."

#: layer_move.xhp%23par_id3148488.19.help.text
msgid "Click and hold the object until its edges flash."
msgstr ""
"Klicka på objektet och håll ned musknappen tills objektets kanter börjar "
"blinka."

#: layer_move.xhp%23par_id3145587.20.help.text
msgid "Drag the object to the name tab of the layer you want to move it to."
msgstr ""
"Dra objektet till fliken som hör till den nivå dit du vill flytta objektet."

#: layer_move.xhp%23par_id3148868.21.help.text
msgid "Release the object."
msgstr "Släpp upp musknappen."

#: arrange_slides.xhp%23tit.help.text
msgid "Changing the Slide Order"
msgstr "Ändra bildordningen"

#: arrange_slides.xhp%23bm_id3149499.help.text
msgid ""
"<bookmark_value>slides; "
"arranging</bookmark_value><bookmark_value>presentations; arranging "
"slides</bookmark_value><bookmark_value>changing;order of slides</bookmark_val"
"ue><bookmark_value>arranging;slides</bookmark_value><bookmark_value>ordering;"
"slides</bookmark_value>"
msgstr ""
"<bookmark_value>Bilder; "
"placera</bookmark_value><bookmark_value>Presentationer; placera "
"bilder</bookmark_value><bookmark_value>Ändra; "
"bildordningen</bookmark_value><bookmark_value>Arrangera; "
"bilder</bookmark_value><bookmark_value>Ordna; bilder</bookmark_value>"

#: arrange_slides.xhp%23hd_id3149499.21.help.text
msgid ""
"<variable id=\"arrange_slides\"><link href=\"text/simpress/guide/"
"arrange_slides.xhp\" name=\"Changing the Slide Order\">Changing the Slide "
"Order</link></variable>"
msgstr ""
"<variable id=\"arrange_slides\"><link href=\""
"text/simpress/guide/arrange_slides.xhp\" name=\"Ordna dior på diabordet\">"
"Ordna dior på diabordet</link></variable>"

#: arrange_slides.xhp%23par_id3151242.44.help.text
msgctxt "arrange_slides.xhp#par_id3151242.44.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: arrange_slides.xhp%23par_id3143233.40.help.text
msgid ""
"Choose <emph>View - Slide Sorter</emph>, select one or more slides, and then "
"drag the slides to another location. To select multiple slides, hold down "
"shift and click on the slides. To create a copy of a selected slide, hold "
"down Ctrl while you drag. The mouse pointer changes to a plus sign. You can "
"also drag a copy of a slide into another open $[officename] Impress document."
msgstr ""
"Välj <emph>Visa - Bildsortering</emph>, markera en eller flera bilder och "
"dra dem till en annan plats. Du kan markera flera sidor samtidigt genom att "
"hålla ned Skift när du klickar. Om du vill kopiera den markerade sidan "
"håller du Ctrl-tangenten ned när du drar sidan. Muspekaren ändras till ett "
"plustecken. You can also drag a copy of a slide into another open "
"$[officename] Impress document."

#: arrange_slides.xhp%23par_id3153072.45.help.text
msgid ""
"Choose <emph>View - Outline</emph>, select a slide, and then drag the slide "
"to another location."
msgstr ""
"Välj <emph>Visa - Disposition</emph>, markera en eller flera sidor och dra "
"sidorna till en annan plats."

#: arrange_slides.xhp%23par_id3150391.46.help.text
msgid ""
"Choose <emph>View - Normal</emph> or <emph>Notes</emph>, select the slide "
"preview on the <emph>Slides Pane</emph>, and then drag the slide preview to "
"another location."
msgstr ""
"Välj <emph>Visa - Normal</emph> eller <emph>Anteckningar</emph>, välj "
"förhandsvisning av bilden i <emph>Bildrutan</emph> och dra sedan "
"förhandsvisningen till en annan plats."

#: arrange_slides.xhp%23par_id3153079.23.help.text
msgid ""
"To temporarily remove a slide from your presentation, go to <emph>Slide "
"Sorter</emph>, right-click the slide, and then choose <emph>Show/Hide "
"Slide</emph>. The number of the hidden slide is crossed out. To show the "
"slide, right-click the slide, and then choose <emph>Show/Hide Slide</emph>."
msgstr ""
"Om du temporärt vill ta bort en bild från presentationen går du till "
"<emph>Bildsortering</emph>, högerklickar på bilden och väljer sedan <emph>"
"Visa bild</emph>. Den dolda bildens nummer är överstruken. Om du vill visa "
"bilden igen högerklickar du på den och väljer <emph>Visa bild</emph>."

#: print_tofit.xhp%23tit.help.text
msgid "Printing a Slide to Fit a Paper Size"
msgstr "Anpassa utskriften till ett visst pappersformat"

#: print_tofit.xhp%23bm_id3155067.help.text
msgid ""
"<bookmark_value>fitting to pages; individual "
"slides</bookmark_value><bookmark_value>pages; fitting to printed "
"pages</bookmark_value><bookmark_value>printing; fitting to "
"paper</bookmark_value>"
msgstr ""
"<bookmark_value>Anpassa till sidor; enskilda "
"bilder</bookmark_value><bookmark_value>sidor; anpassa till "
"utskrift</bookmark_value><bookmark_value>utskrift; anpassa till "
"papper</bookmark_value>"

#: print_tofit.xhp%23hd_id3155067.1.help.text
msgid ""
"<variable id=\"print_tofit\"><link href=\"text/simpress/guide/print_tofit."
"xhp\" name=\"Printing a Slide to Fit a Paper Size\">Printing a Slide to Fit "
"a Paper Size</link></variable>"
msgstr ""
"<variable id=\"print_tofit\"><link href=\"text/simpress/guide/print_tofit."
"xhp\" name=\"Anpassa utskrift till papperssida\">Anpassa utskrift till "
"papperssida</link></variable>"

#: print_tofit.xhp%23par_id3154704.3.help.text
msgid ""
"You can reduce the size of a slide when you print, so that the slide can fit "
"on a printed page."
msgstr ""
"Du kan förminska en diabilds storlek när du skriver ut så att diabilden får "
"plats på en utskriven sida."

#: print_tofit.xhp%23par_id3154658.4.help.text
msgid "Open the document that you want to print."
msgstr "Öppna det dokument du vill skriva ut."

#: print_tofit.xhp%23par_id3145384.5.help.text
msgid ""
"In <emph>Normal View</emph>, choose <emph>Format - Page</emph>, and then "
"click the <emph>Page</emph> tab."
msgstr ""
"Välj <emph>Format - Sida</emph> i <emph>Normalvy</emph> och klicka sedan på "
"fliken <emph>Sida</emph>."

#: print_tofit.xhp%23par_id3148871.6.help.text
msgid ""
"In <emph>Layout settings </emph>area, select the <emph>Fit object to paper "
"format</emph> check box."
msgstr ""
"Under <emph>Layoutinställningar</emph> markerar du kryssrutan <emph>Anpassa "
"objekt till pappersformat</emph>."

#: print_tofit.xhp%23par_id3153811.7.help.text
msgid "In the <emph>Paper format</emph> area, select a <emph>Format</emph>."
msgstr "Välj ett <emph>Format</emph> under <emph>Pappersformat</emph>."

#: print_tofit.xhp%23par_id3150431.8.help.text
msgid ""
"Click <emph>OK</emph>. The slide is resized to fit the printed page, while "
"maintaining the relative positions of the objects on the slide."
msgstr ""
"Klicka på <emph>OK.</emph> Storleken på objekten skalas nu och anpassas till "
"den nya sidstorleken. De relativa positionerna är desamma."

#: line_arrow_styles.xhp%23tit.help.text
msgid "Loading Line and Arrow Styles"
msgstr "Ladda linje- och pilstilar"

#: line_arrow_styles.xhp%23bm_id3145253.help.text
msgid ""
"<bookmark_value>line styles;loading</bookmark_value>      "
"<bookmark_value>lines;about line ends</bookmark_value>      "
"<bookmark_value>arrows;loading arrow styles</bookmark_value>      "
"<bookmark_value>styles;arrow and line styles</bookmark_value>      "
"<bookmark_value>loading;arrow and line styles</bookmark_value>"
msgstr ""
"<bookmark_value>linjestilar;läsa in</bookmark_value>      "
"<bookmark_value>linjer;om linjeslut</bookmark_value>      "
"<bookmark_value>pilar;läsa in linjeslut</bookmark_value>      "
"<bookmark_value>stilar;linjer och linjeslut</bookmark_value>      "
"<bookmark_value>läsa in;linje- och linjeslutstilar</bookmark_value>"

#: line_arrow_styles.xhp%23hd_id3145253.48.help.text
msgid ""
"<variable id=\"line_arrow_styles\"><link href=\"text/simpress/guide/"
"line_arrow_styles.xhp\" name=\"Loading Line and Arrow Styles\">Loading Line "
"and Arrow Styles</link></variable>"
msgstr ""
"<variable id=\"line_arrow_styles\"><link href=\""
"text/simpress/guide/line_arrow_styles.xhp\" name=\"Ladda linje- och "
"pilstilar\">Ladda linje- och pilstilar</link></variable>"

#: line_arrow_styles.xhp%23par_id3154017.49.help.text
msgid ""
"You can use styles to organize similar line and arrow types. $[officename] "
"provides a few standard style files that you can load and use in your "
"document. If you want, you can add or delete elements from a style file, or "
"even create a custom style file."
msgstr ""
"Med formatmallar kan du strukturera likartade linjer och linjeslut. I "
"$[officename] finns ett par standardformatmallar som du kan hämta och "
"använda i dokumenten. Om du vill kan du lägga till eller ta bort element "
"från en formatmall eller skapa egna formatmallar."

#: line_arrow_styles.xhp%23hd_id3154485.50.help.text
msgid "To load a line styles file:"
msgstr "Så här laddar du en linjestiltabell:"

#: line_arrow_styles.xhp%23par_id3156382.58.help.text
msgid ""
"Choose <emph>Format - Line</emph>, and then click the <emph>Line "
"Styles</emph> tab."
msgstr ""
"Välj <emph>Format - Linje</emph> och klicka på fliken <emph>Linjeslut</emph>."

#: line_arrow_styles.xhp%23par_id3154705.51.help.text
msgid "Click the <emph>Load Line Styles</emph> button."
msgstr "Klicka på knappen <emph>Ladda linjestiltabell</emph>."

#: line_arrow_styles.xhp%23par_id3145588.52.help.text
msgid ""
"Locate the file containing the line styles that you want to load, and then "
"click <emph>OK</emph>. The file has the format [filename].sod."
msgstr ""
"Leta rätt på filen som innehåller de formatmallar som ska läggas till och "
"klicka på <emph>OK</emph>. Filen har formatet [filnamn].sod."

#: line_arrow_styles.xhp%23par_id3151240.53.help.text
msgid ""
"To save a line styles file, click the <emph>Save Line Styles</emph> button, "
"enter a filename, and then click <emph>OK</emph>."
msgstr ""
"Om du vill spara en linjestiltabell klickar du på knappen <emph>Spara "
"linjestiltabell</emph>, anger ett filnamn och klickar på <emph>OK</emph>."

#: line_arrow_styles.xhp%23hd_id3154765.54.help.text
msgid "To load an arrow styles file:"
msgstr "Så här läser du in en linjesluttabell:"

#: line_arrow_styles.xhp%23par_id3153070.59.help.text
msgid ""
"Choose <emph>Format - Line</emph>, and then click the <emph>Arrow "
"Styles</emph> tab."
msgstr ""
"Välj <emph>Format - Linje</emph> och klicka på fliken <emph>Linjeslut</emph>."

#: line_arrow_styles.xhp%23par_id3149054.55.help.text
msgid "Click the <emph>Load Arrow Styles</emph> button."
msgstr "Klicka på knappen <emph>Ladda linjesluttabell</emph>."

#: line_arrow_styles.xhp%23par_id3150391.56.help.text
msgid ""
"Locate the file containing the arrow styles that you want to load, and then "
"click <emph>OK</emph>. The file has the format [filename].soe."
msgstr ""
"Leta rätt på filen som innehåller de linjeslutstilar som ska läggas till och "
"klicka på <emph>OK</emph>. Filen har formatet [filnamn].soe."

#: line_arrow_styles.xhp%23par_id3166465.57.help.text
msgid ""
"To save an arrow styles file, click the <emph>Save Arrow Styles</emph> "
"button, enter a filename, and then click <emph>OK</emph>."
msgstr ""
"Om du vill spara en linjeslutsfil klickar du på knappen <emph>Spara "
"linjeslut</emph>, anger ett filnamn, och klickar sedan på <emph>OK</emph>."

#: line_arrow_styles.xhp%23par_id3145822.help.text
msgid ""
"<link href=\"text/shared/01/05200000.xhp\" name=\"Format - Line\">Format - "
"Line</link>"
msgstr ""
"<link href=\"text/shared/01/05200000.xhp\" name=\"Format - Linje\">Format - "
"Linje</link>"

#: layer_new.xhp%23tit.help.text
msgid "Inserting Layers"
msgstr "Infoga nivåer"

#: layer_new.xhp%23bm_id3148797.help.text
msgid ""
"<bookmark_value>layers; inserting and "
"editing</bookmark_value><bookmark_value>inserting; "
"layers</bookmark_value><bookmark_value>changing;layer "
"properties</bookmark_value>"
msgstr ""
"<bookmark_value>Nivåer; infoga och "
"redigera</bookmark_value><bookmark_value>Infoga; "
"nivåer</bookmark_value><bookmark_value>Ändra;nivåegenskaper</bookmark_value>"

#: layer_new.xhp%23hd_id3148797.9.help.text
msgid ""
"<variable id=\"layer_new\"><link href=\"text/simpress/guide/layer_new.xhp\" "
"name=\"Inserting Layers\">Inserting Layers</link></variable>"
msgstr ""
"<variable id=\"layer_new\"><link href=\"text/simpress/guide/layer_new.xhp\" "
"name=\"Infoga nivåer\">Infoga nivåer</link></variable>"

#: layer_new.xhp%23par_idN10614.help.text
msgctxt "layer_new.xhp#par_idN10614.help.text"
msgid "Drawings in %PRODUCTNAME Draw support layers."
msgstr "Ritobjekt i stödnivåer i %PRODUCTNAME Draw."

#: layer_new.xhp%23par_idN10643.help.text
msgid "Right-click the layer tab area at the bottom."
msgstr "Högerklicka på nivåfliken längst ned."

#: layer_new.xhp%23par_id3153418.11.help.text
msgid "Choose <emph>Insert Layer</emph>."
msgstr "Välj <emph>Redigera - Nivå - Infoga</emph>."

#: layer_new.xhp%23par_id3155068.12.help.text
msgid "Type a name for the layer in the <emph>Name </emph>box."
msgstr "Skriv nivåns namn i rutan <emph>Namn</emph>."

#: layer_new.xhp%23par_id3156382.15.help.text
msgid "In the <emph>Properties </emph>area, set the options for the layer."
msgstr "Under <emph>Egenskaper</emph> anger du den nya nivåns egenskaper."

#: layer_new.xhp%23par_id3153964.13.help.text
msgid ""
"Click <emph>OK</emph>. The new layer automatically becomes the active layer."
msgstr ""
"Klicka på OK. Den nya nivån är automatiskt den aktuella nivån, så att "
"samtliga nu ritade objekt ligger på den nya nivån."

#: layer_new.xhp%23par_id3154658.16.help.text
msgid ""
"To change the properties of a layer, click the name tab of the layer, and "
"then choose <emph>Format - Layer</emph>."
msgstr ""
"Om du vill ändra egenskaperna för en nivå, klicka du på fliken som hör till "
"nivån och väljer <emph>Redigera - Nivå - Ändra</emph>."

#: layer_new.xhp%23par_id3153814.17.help.text
msgid ""
"You cannot change the name of or delete a predefined <item type=\""
"productname\">%PRODUCTNAME</item> Draw layer."
msgstr ""
"Det går inte att ändra namn på eller ta bort en fördefinierad <item type=\""
"productname\">%PRODUCTNAME</item> Draw-nivå."

#: page_copy.xhp%23tit.help.text
msgid "Copying Slides From Other Presentations"
msgstr "Kopiera bilder från andra presentationer"

#: page_copy.xhp%23bm_id3146971.help.text
msgid ""
"<bookmark_value>copying; slides</bookmark_value><bookmark_value>slides; "
"copying between documents</bookmark_value><bookmark_value>pages; "
"copying</bookmark_value><bookmark_value>inserting; slides from "
"files</bookmark_value><bookmark_value>pasting;slides from other "
"presentations</bookmark_value>"
msgstr ""
"<bookmark_value>Kopiera, bilder</bookmark_value><bookmark_value>Bilder, "
"kopiera mellan dokument</bookmark_value><bookmark_value>Sidor, "
"kopiera</bookmark_value><bookmark_value>Infoga, bilder från "
"filer</bookmark_value><bookmark_value>Klistra in, bilder från andra "
"presentationer</bookmark_value>"

#: page_copy.xhp%23hd_id3146971.1.help.text
msgid ""
"<variable id=\"page_copy\"><link href=\"text/simpress/guide/page_copy.xhp\" "
"name=\"Copying Slides From Other Presentations\">Copying Slides From Other "
"Presentations</link></variable>"
msgstr ""
"<variable id=\"page_copy\"><link href=\"text/simpress/guide/page_copy.xhp\" "
"name=\"Kopiera sidor från andra presentationer\">Kopiera sidor från andra "
"presentationer</link></variable>"

#: page_copy.xhp%23par_id3149378.7.help.text
msgid ""
"You can insert slides from another presentation into the current "
"presentation. You can also copy and paste slides between presentations."
msgstr ""
"Du kan infoga sidor från en annan presentation i den presentation du arbetar "
"med. Du kan också kopiera och klistra in sidor från en presentation till en "
"annan."

#: page_copy.xhp%23hd_id3153418.8.help.text
msgid "To insert a slide from another presentation:"
msgstr "Så här infogar du en sida från en annan presentation:"

#: page_copy.xhp%23par_id3149018.3.help.text
msgid "Open a presentation, and choose <emph>View - Normal</emph>."
msgstr "Öppna en presentation och välj <emph>Visa - Normal</emph>."

#: page_copy.xhp%23par_id3154702.9.help.text
msgid "Choose <emph>Insert - File</emph>."
msgstr "Välj <emph>Infoga - Fil</emph>."

#: page_copy.xhp%23par_id3159238.10.help.text
msgid ""
"Locate the presentation file containing the slide that you want to insert, "
"and click <emph>Insert</emph>."
msgstr ""
"Leta rätt på presentationen med den sida som du ska infoga, och klicka sedan "
"på <emph>Infoga</emph>."

#: page_copy.xhp%23par_id3148837.4.help.text
msgid ""
"Click the plus sign next to the icon for the presentation file, and then "
"select the slide(s) that you want to insert."
msgstr ""
"Klicka på plustecknet intill presentationsfilens ikon och markera de "
"diabilder som du vill infoga."

#: page_copy.xhp%23par_id3148869.11.help.text
msgctxt "page_copy.xhp#par_id3148869.11.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: page_copy.xhp%23hd_id3154651.12.help.text
msgid "To copy and paste slides between presentations:"
msgstr "Så här kopierar du sidor mellan presentationer:"

#: page_copy.xhp%23par_id3153812.13.help.text
msgid "Open the presentations that you want to copy and paste between."
msgstr "Öppna de presentationer som du vill kopiera mellan."

#: page_copy.xhp%23par_id3153073.14.help.text
msgid ""
"In the presentation containing the slide(s) that you want to copy, "
"choose<emph> View - Slide Sorter</emph>."
msgstr ""
"I den presentation som innehåller bilderna du ska kopiera väljer du <emph>"
"Visa - Bildsortering</emph>."

#: page_copy.xhp%23par_id3147401.5.help.text
msgid "Select the slide(s), and then choose<emph> Edit - Copy</emph>."
msgstr "Markera diabilderna och välj <emph>Redigera - Kopiera</emph>."

#: page_copy.xhp%23par_id3147298.15.help.text
msgid ""
"Change to the presentation where you want to paste the slide(s), and then "
"choose <emph>View - Normal</emph>."
msgstr ""
"Byt till den presentation där bilderna ska klistras in och välj <emph>Visa - "
"Normal</emph>."

#: page_copy.xhp%23par_id3156401.16.help.text
msgid ""
"Select the slide that you want the copied slide to follow, and then choose "
"<emph>Edit - Paste</emph>."
msgstr ""
"Markera den sida som ska ligga före den inkopierade sidan och välj <emph>"
"Redigera - Klistra in</emph>."

#: page_copy.xhp%23par_id3150655.6.help.text
msgid ""
"<link href=\"text/simpress/01/04110000.xhp\" name=\"Insert - File\">Insert - "
"File</link>"
msgstr ""
"<link href=\"text/simpress/01/04110000.xhp\" name=\"Infoga - Fil\">Infoga - "
"Fil</link>"

#: change_scale.xhp%23tit.help.text
msgid "Zooming With the Keypad"
msgstr "Zooma med tangentbordet"

#: change_scale.xhp%23bm_id3149018.help.text
msgid ""
"<bookmark_value>zooming;keyboard</bookmark_value><bookmark_value>keyboard; "
"zooming</bookmark_value>"
msgstr ""
"<bookmark_value>Zooma;tangentbord</bookmark_value><bookmark_value>Tangentbord"
"; zooma</bookmark_value>"

#: change_scale.xhp%23hd_id3149018.10.help.text
msgid ""
"<variable id=\"change_scale\"><link href=\"text/simpress/guide/change_scale."
"xhp\" name=\"Zooming With the Keypad\">Zooming With the "
"Keypad</link></variable>"
msgstr ""
"<variable id=\"change_scale\"><link href=\"text/simpress/guide/change_scale."
"xhp\" name=\"Zooma med tangentbordet\">Zooma med "
"tangentbordet</link></variable>"

#: change_scale.xhp%23par_id3148487.11.help.text
msgid ""
"You can use the keypad to quickly enlarge or reduce the view on your slide."
msgstr ""
"Du kan använda det numeriska tangentbordet för att snabbt förstora eller "
"förminska visningen av en sida."

#: change_scale.xhp%23par_id3149501.12.help.text
msgid "To zoom in, press the Plus Sign."
msgstr "Om du vill zooma in trycker du på plustecknet."

#: change_scale.xhp%23par_id3148837.16.help.text
msgid "To zoom out, press the Minus Sign."
msgstr "Om du vill zooma ut trycker du på minustecknet."

#: change_scale.xhp%23par_id7954954.help.text
msgid ""
"If you are using a mouse with a scroll wheel, you can hold down Ctrl and "
"turn the wheel to change the zoom factor in all main modules of %PRODUCTNAME."
msgstr ""
"Om du använder en mus med hjul kan du hålla ner Ctrl och rulla hjulet för "
"att zooma in eller ut i alla huvudmoduler i %PRODUCTNAME."

#: change_scale.xhp%23par_id3145116.14.help.text
msgid ""
"<link href=\"text/simpress/04/01020000.xhp\" name=\"Shortcut keys for "
"presentations\">Shortcut keys for presentations</link>"
msgstr ""
"<link href=\"text/simpress/04/01020000.xhp\" name=\"Kortkommandon för "
"presentationer\">Kortkommandon för presentationer</link>"

#: layer_tipps.xhp%23tit.help.text
msgid "Working With Layers"
msgstr "Arbeta med nivåer"

#: layer_tipps.xhp%23bm_id3154013.help.text
msgid ""
"<bookmark_value>layers;working with</bookmark_value><bookmark_value>locking l"
"ayers</bookmark_value><bookmark_value>hiding;layers</bookmark_value><bookmark"
"_value>unlocking layers</bookmark_value><bookmark_value>showing;hidden "
"layers</bookmark_value><bookmark_value>selecting;layers</bookmark_value>"
msgstr ""
"<bookmark_value>Nivåer;arbeta med</bookmark_value><bookmark_value>Spärra nivå"
"er</bookmark_value><bookmark_value>Dölja;nivåer</bookmark_value><bookmark_val"
"ue>Låsa upp nivåer</bookmark_value><bookmark_value>Visa;dolda "
"nivåer</bookmark_value><bookmark_value>Välja;nivåer</bookmark_value>"

#: layer_tipps.xhp%23hd_id3154013.14.help.text
msgid ""
"<variable id=\"layer_tipps\"><link href=\"text/simpress/guide/layer_tipps."
"xhp\" name=\"Working With Layers\">Working With Layers</link></variable>"
msgstr ""
"<variable id=\"layer_tipps\"><link href=\"text/simpress/guide/layer_tipps."
"xhp\" name=\"Arbeta med nivåer\">Arbeta med nivåer</link></variable>"

#: layer_tipps.xhp%23par_idN10706.help.text
msgctxt "layer_tipps.xhp#par_idN10706.help.text"
msgid "Drawings in %PRODUCTNAME Draw support layers."
msgstr "Ritobjekt i stödnivåer i %PRODUCTNAME Draw."

#: layer_tipps.xhp%23hd_id3154018.18.help.text
msgid "Selecting a layer"
msgstr "Välja en nivå"

#: layer_tipps.xhp%23par_id3154484.15.help.text
msgid ""
"To select a layer, click the name tab of the layer at the bottom of the "
"workspace."
msgstr ""
"Du kan välja en nivå genom att klicka på nivåns namnflik längst ned till "
"vänster i arbetsområdet."

#: layer_tipps.xhp%23par_idN10767.help.text
msgid "To edit the properties of a layer, double-click a layer tab."
msgstr ""
"Du kan redigera egenskaperna för en nivå genom att dubbelklicka på nivåns "
"flik."

#: layer_tipps.xhp%23hd_id3155445.19.help.text
msgid "Hiding layers"
msgstr "Dölja nivå"

#: layer_tipps.xhp%23par_id3154702.22.help.text
msgctxt "layer_tipps.xhp#par_id3154702.22.help.text"
msgid "Select a layer, and then choose <emph>Format - Layer</emph>."
msgstr "Markera en nivå och klicka på <emph>Redigera - Nivå - Ändra</emph>"

#: layer_tipps.xhp%23par_id3145587.23.help.text
msgid ""
"In the <emph>Properties </emph>area, clear the <emph>Visible </emph>check "
"box."
msgstr ""
"Under <emph>Egenskaper</emph> avmarkerar du kryssrutan <emph>Synlig</emph>."

#: layer_tipps.xhp%23par_id3153912.24.help.text
msgctxt "layer_tipps.xhp#par_id3153912.24.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: layer_tipps.xhp%23par_id3154762.25.help.text
msgid ""
"In the name tab of the layer, the text color of the name changes to blue."
msgstr "Färgen på texten som visar nivåns namn ändras till blå."

#: layer_tipps.xhp%23par_id3156396.16.help.text
msgid ""
"You can make a layer visible or invisible by clicking on its tab while "
"holding down the Shift key."
msgstr ""
"Du kan göra en nivå synlig eller osynlig genom att hålla ned Skift när du "
"klickar på nivåns flik."

#: layer_tipps.xhp%23hd_id3146322.26.help.text
msgid "Showing hidden layers"
msgstr "Visa dolda nivåer"

#: layer_tipps.xhp%23par_id3157871.27.help.text
msgid "Select a hidden layer, and then choose <emph>Format - Layer</emph>."
msgstr "Välj en dold nivå och klicka på <emph>Redigera - Nivå - Ändra</emph>."

#: layer_tipps.xhp%23par_id3149352.28.help.text
msgid ""
"In the <emph>Properties </emph>area, select the <emph>Visible </emph>check "
"box."
msgstr ""
"Under <emph>Egenskaper</emph> markerar du kryssrutan <emph>Synlig</emph>."

#: layer_tipps.xhp%23par_id3153036.29.help.text
msgctxt "layer_tipps.xhp#par_id3153036.29.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: layer_tipps.xhp%23hd_id3154554.20.help.text
msgid "Locking layers"
msgstr "Spärra nivå"

#: layer_tipps.xhp%23par_id3150864.17.help.text
msgctxt "layer_tipps.xhp#par_id3150864.17.help.text"
msgid "Select a layer, and then choose <emph>Format - Layer</emph>."
msgstr "Välj en nivå och klicka på <emph>Redigera - Nivå - Ändra</emph>."

#: layer_tipps.xhp%23par_id3150336.30.help.text
msgid ""
"In the <emph>Properties</emph> area, select the <emph>Locked </emph>check "
"box."
msgstr ""
"Under <emph>Egenskaper</emph> markerar du kryssrutan <emph>Spärrad</emph>."

#: layer_tipps.xhp%23par_id3153730.31.help.text
msgctxt "layer_tipps.xhp#par_id3153730.31.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: layer_tipps.xhp%23par_id3149883.32.help.text
msgid "You cannot edit objects on a locked layer."
msgstr "Det går inte att redigera objekt på en spärrad nivå."

#: layer_tipps.xhp%23hd_id3145244.33.help.text
msgid "Unlocking layers"
msgstr "Låsa upp nivåer"

#: layer_tipps.xhp%23par_id3145354.34.help.text
msgid "Select a locked layer, and then choose <emph>Format - Layer</emph>."
msgstr ""
"Välj en spärrad nivå och klicka på <emph>Redigera - Nivå - Ändra</emph>."

#: layer_tipps.xhp%23par_id3148393.35.help.text
msgid ""
"In the <emph>Properties</emph> area, clear the <emph>Locked </emph>check box."
msgstr ""
"Under <emph>Egenskaper</emph> avmarkerar du kryssrutan <emph>Spärrad</emph>."

#: layer_tipps.xhp%23par_id3150467.36.help.text
msgctxt "layer_tipps.xhp#par_id3150467.36.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: background.xhp%23tit.help.text
msgid "Changing the Slide Background Fill"
msgstr "Ändra bakgrundsfyllningen för en sida"

#: background.xhp%23bm_id3150199.help.text
msgid ""
"            <bookmark_value>backgrounds; changing</bookmark_value>"
"            <bookmark_value>slide masters; changing "
"backgrounds</bookmark_value>            <bookmark_value>slides;changing "
"backgrounds</bookmark_value>        "
msgstr ""
"            <bookmark_value>Bakgrunder; "
"ändra</bookmark_value><bookmark_value>Bildbakgrunder; ändra "
"bakgrunder</bookmark_value><bookmark_value>Bilder;ändra "
"bakgrunder</bookmark_value>        "

#: background.xhp%23hd_id3150199.33.help.text
msgid ""
"            <variable id=\"background\">                <link href=\"text/"
"simpress/guide/background.xhp\" name=\"Changing the Slide Background Fill\">"
"Changing the Slide Background Fill</link>            </variable>        "
msgstr ""
"            <variable id=\"background\"><link href=\""
"text/simpress/guide/background.xhp\" name=\"Ändra bakgrundsfyllningen för en "
"sida\">Ändra bakgrundsfyllningen för en sida</link></variable>        "

#: background.xhp%23par_id3155067.34.help.text
msgid ""
"You can change the background color or the background fill of the current "
"slide or all of the slides in your document. For a background fill, you can "
"use hatching, a gradient, or a bitmap image."
msgstr ""
"Du kan ändra bakgrundsfyllningen eller fyllningens färg för den aktuella "
"sidan eller för alla sidor i dokumentet. Du kan använda skrafferingar, "
"gradienter eller bitmappar som bakgrunder."

#: background.xhp%23par_id3148701.36.help.text
msgid ""
"If you want to change the background fill for all of the slides, choose "
"<emph>View - Master - Slide Master</emph>. To change the background fill of "
"a single slide, choose <emph>View - Normal</emph>."
msgstr ""
"Om du vill ändra bakgrundsfyllningen i alla bilderna väljer du <emph>Visa - "
"Bakgrund - Bildbakgrund</emph>. Om du endast vill ändra bakgrunden i en bild "
"väljer du <emph>Visa - Normal</emph>."

#: background.xhp%23par_id624713.help.text
msgid ""
"            <ahelp hid=\".\" visibility=\"hidden\">Click Set Background "
"Picture for Slide in the context menu of a slide in Normal view to select a "
"bitmap file. This file is used as a background picture.</ahelp>        "
msgstr ""
"            <ahelp hid=\".\" visibility=\"hidden\">Klicka på Ange "
"bakgrundsbild för bilden i snabbmenyn i normalvyn, och välj en bitmappfil. "
"Den här filen används som bakgrundsbild.</ahelp>        "

#: background.xhp%23hd_id3150534.49.help.text
msgid "To use a color, gradient, or hatching pattern for the slide background"
msgstr "Så här använder du en färg, gradient eller skraffering för bakgrunden:"

#: background.xhp%23par_id3149942.50.help.text
msgctxt "background.xhp#par_id3149942.50.help.text"
msgid ""
"Choose <emph>Format - Page</emph>, and then click on the "
"<emph>Background</emph> tab."
msgstr ""
"Välj <emph>Format - Sida</emph> och klicka på fliken <emph>Bakgrund</emph>."

#: background.xhp%23par_id3148725.51.help.text
msgid "In the <emph>Fill </emph>area, do one of the following:"
msgstr "Under <emph>Fyllning</emph> gör du något av följande:"

#: background.xhp%23par_id3153040.52.help.text
msgctxt "background.xhp#par_id3153040.52.help.text"
msgid "Select <emph>Color</emph>, and then click a color in the list."
msgstr "Klicka på <emph>Färg</emph> och klicka på en färg i listan."

#: background.xhp%23par_id3150866.53.help.text
msgid ""
"Select <emph>Gradient</emph>, and then click a gradient style in the list."
msgstr "Klicka på <emph>Färggradient</emph> och klicka på en gradient i listan."

#: background.xhp%23par_id3150338.54.help.text
msgid ""
"Select <emph>Hatching</emph>, and then click a hatching style in the list."
msgstr ""
"Klicka på <emph>Skraffering</emph> och klicka på en skrafferingsstil i "
"listan."

#: background.xhp%23par_id3150021.55.help.text
msgctxt "background.xhp#par_id3150021.55.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: background.xhp%23hd_id3145244.56.help.text
msgid "To use an image for the slide background"
msgstr "Så här använder du en sida som bakgrund:"

#: background.xhp%23par_id3148394.57.help.text
msgid ""
"You can display an entire image as a slide background, or you can tile the "
"image to produce a patterned background."
msgstr ""
"Du kan använda en bild som bakgrund till en sida, eller repetera bilden och "
"skapa ett bakgrundsmönster."

#: background.xhp%23par_id3156064.58.help.text
msgctxt "background.xhp#par_id3156064.58.help.text"
msgid ""
"Choose <emph>Format - Page</emph>, and then click on the "
"<emph>Background</emph> tab."
msgstr ""
"Välj <emph>Format - Sida</emph> och klicka på fliken <emph>Bakgrund</emph>."

#: background.xhp%23par_id3145356.59.help.text
msgid ""
"In the <emph>Fill </emph>area, select <emph>Bitmap</emph>, and then click an "
"image in the list."
msgstr ""
"Välj <emph>Bitmap</emph> under <emph>Fyllning</emph> och klicka på en bild i "
"listan."

#: background.xhp%23par_id3150757.60.help.text
msgid ""
"If you want to use a custom image for the slide background, close the <emph>"
"Page Setup </emph>dialog, and then choose <emph>Format - Area</emph>. Click "
"the <emph>Bitmaps </emph>tab, and then click <emph>Import</emph>. Locate the "
"image you want to import and click <emph>Open</emph>. When you return to the "
"<emph>Background </emph>tab, the image you imported will be in the <emph>"
"Bitmap </emph>list."
msgstr ""
"Om du vill använda en egen bild som bakgrund, stänger du dialogrutan <emph>"
"Ställ in sida</emph> och väljer <emph>Format - Yta</emph>. Klicka på fliken "
"<emph>Bitmapmönster</emph> och klicka på <emph>Import</emph>. Leta rätt på "
"den bildfil du vill importera och klicka på <emph>Öppna</emph>. När du "
"kommer tillbaka till fliken <emph>Bakgrund</emph> finns den importerade "
"bilden med i listan <emph>Bitmap</emph>."

#: background.xhp%23par_id3153151.61.help.text
msgctxt "background.xhp#par_id3153151.61.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: background.xhp%23par_id3150263.62.help.text
msgid ""
"To display the entire image as the background, clear the <emph>Tile </emph>"
"check box in the <emph>Position </emph>area, and then select "
"<emph>AutoFit</emph>."
msgstr ""
"Om du vill använda hela bilden som bakgrund avmarkerar du kryssrutan <emph>"
"Sida vid sida</emph> under <emph>Position</emph> och markerar "
"<emph>Anpassa</emph>."

#: background.xhp%23par_id3149756.63.help.text
msgid ""
"To tile the image on the background, select <emph>Tile</emph>, and set the "
"<emph>Size</emph>, <emph>Position</emph>, and <emph>Offset</emph> options "
"for the image."
msgstr ""
"Om du vill repetera bilden och skapa ett mönster markerar du <emph>Sida vid "
"sida</emph> och anger alternativen <emph>Storlek</emph>, "
"<emph>Position</emph> och <emph>Förskjutning</emph>."

#: background.xhp%23par_id3154934.64.help.text
msgctxt "background.xhp#par_id3154934.64.help.text"
msgid "Click <emph>OK</emph>."
msgstr "Klicka på <emph>OK</emph>."

#: background.xhp%23par_id3158403.47.help.text
msgid "This modification is only valid for the current presentation document."
msgstr ""
"Den här ändringen av formatmallen gäller bara för det aktuella "
"presentationsdokumentet."

#: background.xhp%23par_idN10820.help.text
msgid "To save a new slide master as a template"
msgstr "Så här sparar du en ny bakgrundssida som en mall"

#: background.xhp%23par_idN10827.help.text
msgid ""
"Choose <emph>View - Master - Slide Master</emph> to change to the slide "
"master."
msgstr ""
"Välj <emph>Visa - Bakgrund - Bildbakgrund</emph> om du vill ändra "
"bakgrundssidan."

#: background.xhp%23par_idN1082F.help.text
msgid ""
"Choose <emph>Format - Page</emph> to change the slide background, or choose "
"other formatting commands. Objects that you add here will be visible on all "
"slides that are based on this slide master."
msgstr ""
"Välj<emph>Format - Sida</emph> om du vill ändra bakgrundssidan eller välj "
"andra formateringskommandon. Objekt som du lägger till här kommer att synas "
"på alla bilder som baseras på denna bildbakgrund."

#: background.xhp%23par_idN10837.help.text
msgid "Choose <emph>View - Normal</emph> to close the master view."
msgstr "Välj <emph>Visa - Normal</emph> när du vill stänga bakgrundsvyn."

#: background.xhp%23par_idN1083F.help.text
msgid ""
"Choose <emph>File - Templates - Save</emph> to save the document as a "
"template."
msgstr ""
"Välj <emph>Arkiv - Mallar - Spara</emph> om du vill spara dokumentet som en "
"mall."

#: background.xhp%23par_idN10847.help.text
msgid ""
"Enter a name for the template. Do not change the category from \"My "
"Templates\". Click OK."
msgstr ""
"Ange ett namn på dokumentmallen. Du ska inte ändra kategorin från Mina "
"mallar. Klicka på OK."

#: background.xhp%23par_idN1084A.help.text
msgid ""
"Now you can use the Presentation Wizard to open a new presentation based on "
"your new template."
msgstr ""
"Nu kan du använda Presentationsguiden för att öppna en ny presentation som "
"baseras på den nya mallen."

#: gluepoints.xhp%23tit.help.text
msgid "Using Gluepoints"
msgstr "Använda fästpunkter"

#: gluepoints.xhp%23bm_id0919200803534995.help.text
msgid "<bookmark_value>glue points;using</bookmark_value>"
msgstr "<bookmark_value>fästpunkter;använda</bookmark_value>"

#: gluepoints.xhp%23par_idN1065F.help.text
msgid ""
"<variable id=\"gluepoints\"><link href=\"text/simpress/guide/gluepoints.xhp\""
">Using Gluepoints</link></variable>"
msgstr ""
"<variable id=\"gluepoints\"><link href=\"text/simpress/guide/gluepoints.xhp\""
">Använda fästpunkter</link></variable>"

#: gluepoints.xhp%23par_id0919200803040964.help.text
msgid ""
"In Impress and Draw, you can connect each two shapes with a line called a <"
"link href=\"text/simpress/02/10100000.xhp\">connector</link>. When you draw "
"a connector between shapes, the connector will be attached to a gluepoint on "
"each shape. Each shape has some default gluepoints, and the positions of the "
"default gluepoints depend on the specific shape. You can add your own custom "
"gluepoints to a shape and then attach connectors to the custom gluepoints."
msgstr ""
"I Impress och Draw kan du ansluta två former med en linje som kallas en <"
"link href=\"text/simpress/02/10100000.xhp\">förbindelse</link>. När du ritar "
"en förbindelse mellan former kommer förbindelsen fästas mot en fästpunkt i "
"varje form. Varje form har vissa standardfästpunkter och placeringen av "
"dessa beror på den specifika formen. Du kan lägga till egna "
"standardfästpunkter till en form och sedan fästa förbindelser till dessa."

#: gluepoints.xhp%23par_id0919200803041099.help.text
msgid "To add and edit gluepoints"
msgstr "Lägga till och redigera fästpunkter"

#: gluepoints.xhp%23par_id091920080304108.help.text
msgctxt "gluepoints.xhp#par_id091920080304108.help.text"
msgid "Do one of the following:"
msgstr "Gör något av följande:"

#: gluepoints.xhp%23par_id0919200803041082.help.text
msgid "Click the <emph>Glue Point</emph> icon on the Drawing toolbar."
msgstr "Klicka på ikonen <emph>Fästpunkt</emph> på verktygsraden Rita."

#: gluepoints.xhp%23par_id0919200803041186.help.text
msgid "Choose <item type=\"menuitem\">Edit - Glue Points</item>."
msgstr "Välj <item type=\"menuitem\">Redigera - Fästpunkter</item>."

#: gluepoints.xhp%23par_id0919200803041160.help.text
msgid ""
"Click the <emph>Insert Glue Point</emph> icon on the Gluepoints toolbar."
msgstr ""
"Klicka på ikonen <emph>Infoga fästpunkt</emph> på verktygsraden Fästpunkter."

#: gluepoints.xhp%23par_id0919200803041115.help.text
msgid "Click inside the shape where you want to add the new gluepoint."
msgstr "Klicka inuti formen där du vill lägga till den nya fästpunkten."

#: gluepoints.xhp%23par_id0919200803041133.help.text
msgid ""
"If the shape is filled, you can click anywhere inside the shape. If the "
"shape is unfilled, you can click the border to insert a glue point. Once "
"inserted, you can drag the glue point to another position inside the shape."
msgstr ""
"Om formen är fylld kan du klicka var som helst innanför formen. Om formen "
"inte är fyll kan du klicka på kanten för att infoga en fästpunkt. När "
"fästpunkten är infogad kan du dra den till en annan position innanför formen."

#: gluepoints.xhp%23par_id0919200803041250.help.text
msgid ""
"With the four icons next to the <emph>Insert Glue Point</emph> icon, you "
"choose the directions which will be permitted for a connector at this "
"gluepoint. You can choose one or more directions for a particular gluepoint."
msgstr ""
"Med de fyra ikonerna bredvid ikonen <emph>Infoga fästpunkt</emph> väljer du "
"de riktningar som du vill tillåta för förbindelsen vid den här fästpunkten. "
"Du kan välja en eller flera riktningar för en viss fästpunkt."

#: gluepoints.xhp%23par_id0919200803041298.help.text
msgid ""
"If the <emph>Glue Point Relative</emph> icon is active, the gluepoint moves "
"when you resize the object to keep its position relative to the object "
"borders."
msgstr ""
"Om ikonen <emph>Relativ fästpunktsplacering</emph> är aktiv rör sig "
"fästpunkten när du ändrar storlek på objektet för att dess placering ska "
"vara relative till objektets kanter."

#: gluepoints.xhp%23par_id0919200803041223.help.text
msgid ""
"If the <emph>Glue Point Relative</emph> icon is not active, the icons next "
"to it are no longer grayed out. With these icons you can decide where a "
"gluepoint will be placed when the size of the object is changed."
msgstr ""
"Om ikonen <emph>Relativ fästpunktsplacering</emph> inte är aktiv är ikonerna "
"bredvid den inte nedtonade. Med dessa ikoner kan du avgöra var en fästpunkt "
"ska placeras när storleken på objektet har ändrats."

#~ msgid ""
#~ "<item type=\"keycode\"><switchinline select=\"sys\"><caseinline select=\"MAC\"
#~ "">Option</caseinline><defaultinline>Alt</defaultinline></switchinline>+PageDo"
#~ "wn</item>"
#~ msgstr ""
#~ "<item type=\"keycode\"><switchinline select=\"sys\"><caseinline select=\"MAC\"
#~ "\\\\\\\\">Alternativ</caseinline><defaultinline>Alt</defaultinline></switchin"
#~ "line>+PgDn</item>"

#~ msgid ""
#~ "<item type=\"keycode\"><switchinline select=\"sys\"><caseinline select=\"MAC\"
#~ "">Option</caseinline><defaultinline>Alt</defaultinline></switchinline>+PageUp"
#~ "</item>"
#~ msgstr ""
#~ "<item type=\"keycode\"><switchinline select=\"sys\"><caseinline select=\"MAC\"
#~ "\\\\\\\\">Alternativ</caseinline><defaultinline>Alt</defaultinline></switchin"
#~ "line>+PgUp</item>"
