# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR Free Software Foundation, Inc.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: 2001-02-09 01:25+0100\n"
"PO-Revision-Date: 2002-03-16 17:23CET\n"
"Last-Translator: Stefan Asserhäll <stefan.asserhall@telia.com>\n"
"Language-Team: Svenska <sv@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 0.9.6\n"

#: index.docbook:7
#, no-c-format
msgid "&MCOP;: Object Model and Streaming"
msgstr "&MCOP;: objektmodell och strömmar"

#: index.docbook:11
#, no-c-format
msgid "Overview"
msgstr "Översikt"

#: index.docbook:13
#, no-c-format
msgid "&MCOP; is the standard &arts; uses for:"
msgstr "&MCOP; är standarden som &arts; använder för:"

#: index.docbook:17
#, no-c-format
msgid "Communication between objects."
msgstr "Kommunikation mellan objekt."

#: index.docbook:17
#, no-c-format
msgid "Network transparency."
msgstr "Nätverkstransparens."

#: index.docbook:17
#, no-c-format
msgid "Describing object interfaces."
msgstr "Beskriva objektgränssnitt."

#: index.docbook:17
#, no-c-format
msgid "Language independancy."
msgstr "Språkoberoende."

#: index.docbook:43
#, no-c-format
msgid ""
"One major aspect of &MCOP; is the <emphasis>interface description "
"language</emphasis>, &IDL;, in which many of the &arts; interfaces and "
"<acronym>API</acronym>s are defined in a language independent way."
msgstr ""
"En viktig del av &MCOP; är "
"<emphasis>gränssnittsbeskrivningsspråket</emphasis>, &IDL;, som används "
"för att definiera många av &arts; programmeringsgränssnitt och andra "
"gränssnitt på ett språkoberoende sätt."

#: index.docbook:49
#, no-c-format
msgid ""
"To use &IDL; interfaces from C++, is compiled by the &IDL; compiler into C++ "
"code. When you implement an interface, you derive from the skeleton class "
"the &IDL; compiler has generated. When you use an interface, you do so using "
"a wrapper. This way, &MCOP; can use a protocol if the object you are talking "
"to is not local - you get network transparency."
msgstr ""
"För att använda ett &IDL;-gränssnitt från C++, kompileras det med &IDL; "
"kompilatorn till C++ kod. När du implementerar ett gränssnitt, härleder "
"du från stomklassen som &IDL; kompilatorn har skapat. När man använder "
"ett gränssnitt gör man det med ett omgärdande skal. På det här sättet "
"kan &MCOP; använda ett protokoll om objektet du pratar med inte är lokalt "
"- man får nätverkstransparens."

#: index.docbook:58
#, no-c-format
msgid ""
"This chapter is supposed to describe the basic features of the object model "
"that results from the use of &MCOP;, the protocol, how do use &MCOP; in C++ "
"(language binding), and so on."
msgstr ""
"Det här kapitlet är ämnat att beskriva de grundläggande funktionerna i "
"objektmodellen som är resultatet av att använda &MCOP;, protokollet, hur "
"&MCOP; används med C++ (språkbindning), och så vidare."

#: index.docbook:68
#, no-c-format
msgid "Interfaces and &IDL;"
msgstr "Gränssnitt och &IDL;"

#: index.docbook:70
#, no-c-format
msgid ""
"Many of the services provided by &arts;, such as modules and the sound "
"server, are defined in terms of <acronym>interfaces</acronym>. Interfaces "
"are specified in a programming language independent format: &IDL;."
msgstr ""
"Mycket av den service som tillhandahålls av &arts;, som modulerna och "
"ljudservern definieras i form av <acronym>gränssnitt</acronym>"
". Gränssnitt specificeras i ett programspråksoberoende format: &IDL;."

#: index.docbook:77
#, no-c-format
msgid ""
"This allows many of the implementation details such as the format of "
"multimedia data streams, network transparency, and programming language "
"dependencies, to be hidden from the specification for the interface. A tool, "
"&mcopidl;, translates the interface definition into a specific programming "
"language (currently only C++ is supported)."
msgstr ""
"Det här tillåter att många av implementeringsdetaljerna som formatet på "
"multimediadataflöden, nätverkstransparens och programspråksoberoende "
"döljs för specifikationen av gränssnittet. Ett verktyg, &mcopidl;, "
"översätter gränssnittsdefinitionen till ett specifikt programspråk (för "
"närvarande stöds enbart C++)."

#: index.docbook:86
#, no-c-format
msgid ""
"The tool generates a skeleton class with all of the boilerplate code and "
"base functionality. You derive from that class to implement the features you "
"want."
msgstr ""
"Verktyget skapar en stomklass med all standardkod och grundläggande "
"funktionalitet. Man härleder från den här klassen för att implementera "
"de funktioner man vill ha."

#: index.docbook:92
#, no-c-format
msgid ""
"The &IDL; used by &arts; is similar to that used by <acronym>CORBA</acronym>"
" and <acronym>DCOM</acronym>."
msgstr ""
"Det &IDL; som används av &arts; liknar det som används av "
"<acronym>CORBA</acronym> och <acronym>DCOM</acronym>."

#: index.docbook:97
#, no-c-format
msgid "&IDL; files can contain:"
msgstr "&IDL;-filer kan innehålla:"

#: index.docbook:101
#, no-c-format
msgid "C-style #include directives for other &IDL; files."
msgstr "C-stil #include-direktiv för andra &IDL;-filer."

#: index.docbook:101
#, no-c-format
msgid "Definitions of enumerated and struct types, as in C/C++."
msgstr "Definitioner av uppräkningstyper och struct-typer, som i C/C++."

#: index.docbook:101
#, no-c-format
msgid "Definitions of interfaces."
msgstr "Definitioner av gränssnitt."

#: index.docbook:121
#, no-c-format
msgid ""
"In &IDL;, interfaces are defined much like a C++ class or C struct, albeit "
"with some restrictions. Like C++, interfaces can subclass other interfaces "
"using inheritance. Interface definitions can include three things: streams, "
"attributes, and methods."
msgstr ""
"I &IDL; definieras gränssnitt på ett sätt som påminner mycket om en C++ "
"klass eller C-struct, dock med vissa begränsningar. Som i C++, så kan "
"gränssnitt vara underklasser till andra gränssnitt med arv. "
"Gränssnittsdefinitioner kan innehålla tre saker: Strömmar, egenskaper och "
"metoder."

#: index.docbook:130
#, no-c-format
msgid "Streams"
msgstr "Strömmar"

#: index.docbook:132
#, no-c-format
msgid ""
"Streams define multimedia data, one of the most important components of a "
"module. Streams are defined in the following format:"
msgstr ""
"Strömmar definierar multimediadata, en av de viktigaste komponenterna i en "
"modul. Strömmar definieras med följande format:"

#: index.docbook:137
#, no-c-format
msgid ""
"[ async ] in|out [ multi ] <replaceable>type</replaceable> stream "
"<replaceable>name</replaceable> [ , <replaceable>name</replaceable> ] ;"
msgstr ""
"[ async ] in|out [ multi ] <replaceable>typ</replaceable> stream "
"<replaceable>namn</replaceable> [ , <replaceable>namn</replaceable> ] ;"

#: index.docbook:141
#, no-c-format
msgid ""
"Streams have a defined direction in reference to the module, as indicated by "
"the required qualifiers in or out. The type argument defines the type of "
"data, which can be any of the types described later for attributes (not all "
"are currently supported). Many modules use the stream type audio, which is "
"an alias for float since that is the internal data format used for audio "
"stream. Multiple streams of the same type can defined in the same definition "
"uisng comma separated names."
msgstr ""
"Strömmar har en definierad riktning i förhållande till modulen, som anges "
"av de nödvändiga bestämningarna in eller out. Typargumentet definierar "
"datatypen, som kan vara vilken som helst av typerna för egenskaper som "
"beskrivs senare (alla stöds inte än). Många moduler använder strömtypen "
"audio, som är ett alias för float eftersom det är det interna "
"dataformatet för ljudströmmar. Flera strömmar av samma typ kan ingå i "
"samma definition med namn separerade med kommatecken."

#: index.docbook:151
#, no-c-format
msgid ""
"Streams are by default synchronous, which means they are continuous flows of "
"data at a constant rate, such as <acronym>PCM</acronym> audio. The async "
"qualifier specifies an asynchronous stream, which is used for non-continuous "
"data flows. The most common example of an async stream is &MIDI; messages."
msgstr ""
"Strömmar är normalt synkrona, vilket betyder att de är kontinuerliga "
"dataflöden med en konstant hastighet, som <acronym>PCM</acronym>-ljud. "
"Bestämningen async anger en asynkron ström, som används för "
"icke-kontinuerliga dataflöden. Det vanligaste exemplet på en asynkron "
"ström är &MIDI;-meddelanden."

#: index.docbook:159
#, no-c-format
msgid ""
"The multi keyword, only valid for input streams, indicates that the "
"interface supports a variable number of inputs. This is useful for "
"implementing devices such as mixers that can accept any number of input "
"streams."
msgstr ""
"Nyckelordet multi, som bara är giltigt för indataströmmar, anger att "
"gränssnittet stöder ett variabelt antal ingångar. Det här är "
"användbart för att implementera enheter som en mixer som kan ta emot "
"vilket antal indataströmmar som helst."

#: index.docbook:169
#, no-c-format
msgid "Attributes"
msgstr "Egenskaper"

#: index.docbook:171
#, no-c-format
msgid ""
"Attributes are data associated with an instance of an interface. They are "
"declared like member variables in C++, and can can use any of the primitive "
"types boolean, byte, long, string, or float. You can also use user-defined "
"struct or enum types as well as variable sized sequences using the syntax "
"sequence&lt;type&gt;. Attributes can optionally be marked readonly."
msgstr ""
"Egenskaper är data som hör ihop med en instans av ett gränssnitt. De "
"deklareras som medlemsvariabler i C++, och kan använda vilken som helst av "
"de primitiva typerna boolean, byte, long, string, eller float. Du kan också "
"använda egendefinierade struct- eller uppräkningstyper samt sekvenser av "
"variabel storlek med syntaxen sekvens&lt;typ&gt;. Egenskaper kan valfritt "
"markeras som skrivskyddade."

#: index.docbook:183
#, no-c-format
msgid "Methods"
msgstr "Metoder"

#: index.docbook:185
#, no-c-format
msgid ""
"As in C++, methods can be defined in interfaces. The method parameters are "
"restricted to the same types as attributes. The keyword oneway indicates a "
"method which returns immediately and is executed asynchronously."
msgstr ""
"Som i C++, kan metoder definieras i gränssnitt. Metodparametrarna är "
"begränsade till samma typer som egenskaperna. Nyckelordet oneway anger en "
"metod som returnerar omedelbart och körs asynkront."

#: index.docbook:196
#, no-c-format
msgid "Standard Interfaces"
msgstr "Standardgränssnitt"

#: index.docbook:198
#, no-c-format
msgid ""
"Several standard module interfaces are already defined for you in &arts;, "
"such as <interfacename>StereoEffect</interfacename>, and "
"<interfacename>SimpleSoundServer</interfacename>."
msgstr ""
"Flera gränssnitt för standardmoduler är redan definierade åt dig i "
"&arts;, som <interfacename>StereoEffect</interfacename>, och "
"<interfacename>SimpleSoundServer</interfacename>."

#: index.docbook:207
#, no-c-format
msgid "Example"
msgstr "Exempel"

#: index.docbook:209
#, no-c-format
msgid ""
"A simple example of a module taken from &arts; is the constant delay module, "
"found in the file "
"<filename>kdemultimedia/arts/modules/artsmodules.idl</filename>. The "
"interface definition is listed below."
msgstr ""
"Ett enkelt exempel på en modul taget från &arts; är modulen med konstant "
"fördröjning, som finns i filen "
"<filename>kdemultimedia/arts/modules/artsmodules.idl</filename>. "
"Gränssnittsdefinitionen anges nedan:"

#: index.docbook:216
#, no-c-format
msgid ""
"interface Synth_CDELAY : SynthModule {\n"
"        attribute float time;\n"
"        in audio stream invalue;\n"
"        out audio stream outvalue;\n"
"};"
msgstr ""
"interface Synth_CDELAY : SynthModule {\n"
"        attribute float time;\n"
"        in audio stream invalue;\n"
"        out audio stream outvalue;\n"
"};"

#: index.docbook:224
#, no-c-format
msgid ""
"This modules inherits from <interfacename>SynthModule</interfacename>. That "
"interface, defined in <filename>artsflow.idl</filename>, defines the "
"standard methods implemented in all music synthesizer modules."
msgstr ""
"Modulen ärver <interfacename>SynthModule</interfacename>. Det "
"gränssnittet, som finns i <filename>artsflow.idl</filename>, definierar "
"alla standardmetoder som implementeras i alla syntesmoduler."

#: index.docbook:231
#, no-c-format
msgid ""
"The CDELAY effect delays a stereo audio stream by the time value specified "
"as a floating point parameter. The interface definition has an attribute of "
"type float to store the delay value. It defines two input audio streams and "
"two output audio streams (typical of stereo effects). No methods are "
"required other than those it inherits."
msgstr ""
"CDELAY-effekten fördröjer ett stereoljudflöde med tidsvärdet som anges "
"som en flyttalsparameter. Gränssnittsdefinitionen har ett attribut av typen "
"float för att lagra fördröjningsvärdet. Det definierar två indata- och "
"två utdataströmmar (typiskt för stereoeffekter). Inga metoder krävs "
"förutom de ärvda."

#: index.docbook:244
#, no-c-format
msgid "More About Streams"
msgstr "Mer om strömmar"

#: index.docbook:246
#, no-c-format
msgid "This section covers some additional topics related to streams."
msgstr ""
"Det här avsnittet täcker en del ytterligare ämnesområden som hör ihop "
"med strömmar."

#: index.docbook:251
#, no-c-format
msgid "Stream Types"
msgstr "Strömtyper"

#: index.docbook:253
#, no-c-format
msgid ""
"There are various requirements for how a module can do streaming. To "
"illustrate this, consider these examples:"
msgstr ""
"Det finns olika krav för hur en modul kan hantera flöden. För att "
"illustrera detta, betrakta följande exempel:"

#: index.docbook:258
#, no-c-format
msgid "Scaling a signal by a factor of two."
msgstr "Skala en signal med en faktor två."

#: index.docbook:258
#, no-c-format
msgid "Performing sample frequency conversion."
msgstr "Utför frekvenskonvertering av samplingar."

#: index.docbook:258
#, no-c-format
msgid "Decompressing a run-length encoded signal."
msgstr "Packa upp en runlength-kodad signal."

#: index.docbook:258
#, no-c-format
msgid ""
"Reading &MIDI; events from <filename "
"class=\"devicefile\">/dev/midi00</filename> and inserting them into a stream."
msgstr ""
"Läs &MIDI;-händelser från <filename "
"class=\"devicefile\">/dev/midi00</filename> och infoga dem i en ström."

#: index.docbook:286
#, no-c-format
msgid ""
"The first case is the simplest: upon receiving 200 samples of input the "
"module produces 200 samples of output. It only produces output when it gets "
"input."
msgstr ""
"Det första fallet är det enklaste: när modulen tar emot 200 "
"indatasamplingar producerar den 200 utdatasamplingar. Den producerar bara "
"utdata när den får indata."

#: index.docbook:292
#, no-c-format
msgid ""
"The second case produces different numbers of output samples when given 200 "
"input samples. It depends what conversion is performed, but the number is "
"known in advance."
msgstr ""
"Det andra fallet producerar olika antal utdatasamplingar när den får 200 "
"indatasamplingar. Det beror på vilken konvertering som utförs, men antalet "
"är känt i förväg."

#: index.docbook:298
#, no-c-format
msgid ""
"The third case is even worse. From the outset you cannot even guess how much "
"data 200 input bytes will generate (probably a lot more than 200 bytes, "
"but...)."
msgstr ""
"Det tredje fallet är ännu värre. Från utdata kan man inte ens gissa hur "
"mycket data som skapas av 200 indatabyte (förmodligen mycket mer än 200 "
"byte, men...)."

#: index.docbook:304
#, no-c-format
msgid ""
"The last case is a module which becomes active by itself, and sometimes "
"produces data."
msgstr ""
"Det sista fallet är en modul som aktiveras av sig själv, och ibland skapar "
"data."

#: index.docbook:309
#, no-c-format
msgid ""
"In &arts;s-0.3.4, only streams of the first type were handled, and most "
"things worked nicely. This is probably what you need most when writing "
"modules that process audio. The problem with the other, more complex types "
"of streaming, is that they are hard to program, and that you don't need the "
"features most of the time. That is why we do this with two different stream "
"types: synchronous and asynchronous."
msgstr ""
"I &arts;s-0.3.4, hanterades bara strömmar av den första typen, och de "
"flesta saker fungerade bra. Det här är troligen vad du behöver mest när "
"du skriver moduler som behandlar ljud. Problemen med de andra, mer komplexa "
"sorternas flöden, är att de är svåra att programmera, och att man inte "
"behöver funktionerna för det mesta. Det här är orsaken vi gör detta med "
"två olika sorters strömtyper: synkrona och asynkrona."

#: index.docbook:318
#, no-c-format
msgid "Synchronous streams have these characteristics:"
msgstr "Synkrona strömmar har följande egenskaper:"

#: index.docbook:322
#, no-c-format
msgid "Modules must be able to calculate data of any length, given enough input."
msgstr ""
"Moduler måste kunna beräkna data av vilken längd som helst, med "
"tillräckligt mycket indata."

#: index.docbook:322
#, no-c-format
msgid "All streams have the same sampling rate."
msgstr "Alla strömmar har samma samplingsfrekvens."

#: index.docbook:322
#, no-c-format
msgid ""
"The <function>calculateBlock()</function> function will be called when "
"enough data is available, and the module can rely on the pointers pointing "
"to data."
msgstr ""
"Funktionen <function>calculateBlock()</function> anropas när tillräckligt "
"med data är tillgängligt, och modulen kan lita på att pekarna anger data."

#: index.docbook:322
#, no-c-format
msgid "There is no allocation and deallocation to be done."
msgstr "Det finns ingen allokering eller avallokering att göra."

#: index.docbook:351
#, no-c-format
msgid "Asynchronous streams, on the other hand, have this behaviour:"
msgstr "Asynkrona strömmar, å andra sidan, beter sig så här:"

#: index.docbook:355
#, no-c-format
msgid ""
"Modules may produce data sometimes, or with varying sampling rate, or only "
"if they have input from some filed escriptor. They are not bound by the rule "
"<quote>must be able to satisfy requests of any size</quote>."
msgstr ""
"Moduler kan producera data ibland, eller med olika samplingsfrekvens, eller "
"bara om de får indata från någon fil. De måste inte följa regeln "
"<quote>måste kunna hantera begäran av vilken storlek som helst</quote>."

#: index.docbook:355
#, no-c-format
msgid "Asynchronous streams of a module may have entirely different sampling rates."
msgstr "Asynkrona strömmar för en modul kan ha helt skilda samplingsfrekvenser."

#: index.docbook:355
#, no-c-format
msgid ""
"Outgoing streams: there are explicit functions to allocate packets, to send "
"packets - and an optional polling mechanism that will tell you when you "
"should create some more data."
msgstr ""
"Utgående strömmar: det finns särskilda funktioner för att allokera "
"paket, att skicka paket och en valfri mekanism för att fråga efter data "
"som talar om när mer data ska skapas."

#: index.docbook:355
#, no-c-format
msgid ""
"Incoming streams: you get a call when you receive a new packet - you have to "
"say when you are through with processing all data of that packet, which must "
"not happen at once (you can say that anytime later, and if everybody has "
"processed a packet, it will be freed/reused)"
msgstr ""
"Inkommande strömmar: ett anrop skickas när ett nytt paket tas emot. Man "
"måste tala om när man är färdig med att behandla all data i det paketet, "
"och detta får inte ske omedelbart (man kan tala om det när som helst "
"senare, och om alla har behandlat ett paket, kommer det att "
"frigöras/återanvändas)."

#: index.docbook:389
#, no-c-format
msgid ""
"When you declare streams, you use the keyword <quote>async</quote> to "
"indicate you want to make an asynchronous stream. So, for instance, assume "
"you want to convert an asynchronous stream of bytes into a synchronous "
"stream of samples. Your interface could look like this:"
msgstr ""
"När strömmar deklareras, används nyckelordet <quote>async</quote> för "
"att ange att strömmen ska vara asynkron. Så anta till exempel att du vill "
"konvertera en asynkron ström av byte till en synkron ström av samplingar. "
"Gränssnittet skulle då kunna se ut så här:"

#: index.docbook:396
#, no-c-format
msgid ""
"interface ByteStreamToAudio : SynthModule {\n"
"    async in byte stream indata;   // the asynchonous input sample stream\n"
"\n"
"    out audio stream left,right;   // the synchronous output sample streams\n"
"};"
msgstr ""
"interface ByteStreamToAudio : SynthModule {\n"
"    async in byte stream indata;   // den asynkrona indatasamplingen\n"
"\n"
"    out audio stream left,right;   // de synkrona utdatasamplingarna\n"
"};"

#: index.docbook:407
#, no-c-format
msgid "Using Asynchronous Streams"
msgstr "Att använda asynkrona strömmar"

#: index.docbook:409
#, no-c-format
msgid ""
"Suppose you decided to write a module to produce sound asynchronously. Its "
"interface could look like this:"
msgstr ""
"Antag att du har bestämt dig för att skriva en modul som skapar asynkront "
"ljud. Dess gränssnitt kan se ut så här:"

#: index.docbook:414
#, no-c-format
msgid ""
"interface SomeModule : SynthModule\n"
"{\n"
"    async out byte stream outdata;\n"
"};"
msgstr ""
"interface SomeModule : SynthModule\n"
"{\n"
"    async out byte stream outdata;\n"
"};"

#: index.docbook:421
#, no-c-format
msgid ""
"How do you send the data? The first method is called <quote>push "
"delivery</quote>. With asynchronous streams you send the data as packets. "
"That means you send individual packets with bytes as in the above example. "
"The actual process is: allocate a packet, fill it, send it."
msgstr ""
"Hur skickar man data? Den första metoden kallas "
"<quote>tryckleverans</quote>. Med asynkrona strömmar skickar man data som "
"paket. Det betyder att individuella paket skickas som i exemplet ovan. Den "
"verkliga processen är: allokera ett paket, fyll det, skicka det."

#: index.docbook:429
#, no-c-format
msgid "Here it is in terms of code. First we allocate a packet:"
msgstr "Här följer det i form av kod. Först allokerar vi ett paket:"

#: index.docbook:433
#, no-c-format
msgid "DataPacket&lt;mcopbyte&gt; *packet = outdata.allocPacket(100);"
msgstr "DataPacket&lt;mcopbyte&gt; *packet = outdata.allocPacket(100);"

#: index.docbook:437
#, no-c-format
msgid "The we fill it:"
msgstr "Vi fyller det:"

#: index.docbook:441
#, no-c-format
msgid ""
"// cast so that fgets is happy that it has a (char *) pointer\n"
"char *data = (char *)packet-&gt;contents;\n"
"\n"
"// as you can see, you can shrink the packet size after allocation\n"
"// if you like\n"
"if(fgets(data,100,stdin))\n"
"    packet-&gt;size = strlen(data);\n"
"else\n"
"    packet-&gt;size = 0;"
msgstr ""
"// typkonvertera så att fgets får en (char *) pekare\n"
"char *data = (char *)packet-&gt;contents;\n"
"\n"
"// som du ser, kan du krympa paketstorleken efter allokeringen\n"
"// om du vill\n"
"if(fgets(data,100,stdin))\n"
"    packet-&gt;size = strlen(data);\n"
"else\n"
"    packet-&gt;size = 0;"

#: index.docbook:453
#, no-c-format
msgid "Now we send it:"
msgstr "Nu skickar vi det:"

#: index.docbook:457
#, no-c-format
msgid "packet-&gt;send();"
msgstr "packet-&gt;send();"

#: index.docbook:461
#, no-c-format
msgid ""
"This is quite simple, but if we want to send packets exactly as fast as the "
"receiver can process them, we need another approach, the <quote>pull "
"delivery</quote> method. You ask to send packets as fast as the receiver is "
"ready to process them. You start with a certain amount of packets you send. "
"As the receiver processes one packet after another, you start refilling them "
"with fresh data, and send them again."
msgstr ""
"Det här är mycket enkelt, men om vi vill skicka paket precis så snabbt "
"som mottagaren kan hantera dem, behövs ett annat sätt, metoden med "
"<quote>dragleverans</quote>. Man begär att skicka paket så snabbt som "
"mottagaren är klar att behandla dem. Man börjar med en viss mängd paket "
"som skickas. Medan mottagaren behandlar paket efter paket, börjar man fylla "
"i dem med färsk data, och skickar dem igen."

#: index.docbook:470
#, no-c-format
msgid "You start that by calling setPull. For example:"
msgstr "Du startar det genom att anropa setPull. Till exempel:"

#: index.docbook:474
#, no-c-format
msgid "outdata.setPull(8, 1024);"
msgstr "outdata.setPull(8, 1024);"

#: index.docbook:478
#, no-c-format
msgid ""
"This means that you want to send packets over outdata. You want to start "
"sending 8 packets at once, and as the receiver processes some of them, you "
"want to refill them."
msgstr ""
"Det här betyder att du vill skicka paket via outdata. Du vill börja med "
"att skicka 8 paket på en gång, och när mottagaren behandlar några av "
"dem, vill du fylla dem igen."

#: index.docbook:484
#, no-c-format
msgid ""
"Then, you need to implement a method which fills the packets, which could "
"look like this:"
msgstr ""
"Därefter behöver du implementera en metod som fyller paketen, som skulle "
"kunna se ut så här:"

#: index.docbook:489
#, no-c-format
msgid ""
"void request_outdata(DataPacket&lt;mcopbyte&gt; *packet)\n"
"{\n"
"    packet-&gt;size = 1024;  // shouldn't be more than 1024\n"
"    for(int i = 0;i &lt; 1024; i++)\n"
"        packet-&gt;contents[i] = (mcopbyte)'A';\n"
"    packet-&gt;send();\n"
"}"
msgstr ""
"void request_outdata(DataPacket&lt;mcopbyte&gt; *packet)\n"
"{\n"
"    packet-&gt;size = 1024;  // ska inte vara mer än 1024\n"
"    for(int i = 0;i &lt; 1024; i++)\n"
"        packet-&gt;contents[i] = (mcopbyte)'A';\n"
"    packet-&gt;send();\n"
"}"

#: index.docbook:499
#, no-c-format
msgid ""
"Thats it. When you don't have any data any more, you can start sending "
"packets with zero size, which will stop the pulling."
msgstr ""
"Det är allt. När du inte har mer data, kan du börja skicka paket med "
"storleken noll, som stoppar dragleveranserna."

#: index.docbook:504
#, no-c-format
msgid ""
"Note that it is essential to give the method the exact name "
"<methodname>request_<replaceable>streamname</replaceable></methodname>."
msgstr ""
"Observera att det är väsentligt att ge metoden exakt namnet "
"<methodname>request_<replaceable>strömnamn</replaceable></methodname>."

#: index.docbook:509
#, no-c-format
msgid ""
"We just discussed sending data. Receiving data is much much simpler. Suppose "
"you have a simple ToLower filter, which simply converts all letters in "
"lowercase:"
msgstr ""
"Vi beskrev just att skicka data. Att ta emot data är mycket enklare. Antag "
"att du har ett enkelt filter, ToLower, som helt enkelt konverterar alla "
"bokstäver till små:"

#: index.docbook:515
#, no-c-format
msgid ""
"interface ToLower {\n"
"    async in byte stream indata;\n"
"    async out byte stream outdata;\n"
"};"
msgstr ""
"interface ToLower {\n"
"    async in byte stream indata;\n"
"    async out byte stream utdata;\n"
"};"

#: index.docbook:522
#, no-c-format
msgid "This is really simple to implement; here is the whole implementation:"
msgstr ""
"Det här är verkligt enkelt att implementera. Här är hela "
"implementationen:"

#: index.docbook:526
#, no-c-format
msgid ""
"class ToLower_impl : public ToLower_skel {\n"
"public:\n"
"    void process_indata(DataPacket&lt;mcopbyte&gt; *inpacket)\n"
"    {\n"
"        DataPacket&lt;mcopbyte&gt; *outpacket = "
"outdata.allocPacket(inpacket-&gt;size);\n"
"\n"
"        // convert to lowercase letters\n"
"        char *instring = (char *)inpacket-&gt;contents;\n"
"        char *outstring = (char *)outpacket-&gt;contents;\n"
"\n"
"        for(int i=0;i&lt;inpacket-&gt;size;i++)\n"
"            outstring[i] = tolower(instring[i]);\n"
"\n"
"        inpacket-&gt;processed();\n"
"        outpacket-&gt;send();\n"
"    }\n"
"};\n"
"\n"
"REGISTER_IMPLEMENTATION(ToLower_impl);"
msgstr ""
"class ToLower_impl : public ToLower_skel {\n"
"public:\n"
"    void process_indata(DataPacket&lt;mcopbyte&gt; *inpacket)\n"
"    {\n"
"        DataPacket&lt;mcopbyte&gt; *outpacket = "
"outdata.allocPacket(inpacket-&gt;size);\n"
"\n"
"        // omvandla till små bokstäver\n"
"        char *instring = (char *)inpacket-&gt;contents;\n"
"        char *outstring = (char *)outpacket-&gt;contents;\n"
"\n"
"        for(int i=0;i&lt;inpacket-&gt;size;i++)\n"
"            outstring[i] = tolower(instring[i]);\n"
"\n"
"        inpacket-&gt;processed();\n"
"        outpacket-&gt;send();\n"
"    }\n"
"};\n"
"\n"
"REGISTER_IMPLEMENTATION(ToLower_impl);"

#: index.docbook:548
#, no-c-format
msgid ""
"Again, it is essential to name the method "
"<methodname>process_<replaceable>streamname</replaceable></methodname>."
msgstr ""
"Återigen är det väsentligt att ge metoden namnet "
"<methodname>process_<replaceable>strömnamn</replaceable></methodname>."

#: index.docbook:553
#, no-c-format
msgid ""
"As you see, for each arriving packet you get a call for a function (the "
"<function>process_indata</function> call in our case). You need to call the "
"<methodname>processed()</methodname>"
" method of a packet to indicate you have processed it."
msgstr ""
"Som du kan se, så får du ett anrop till en funktion för varje paket som "
"anländer (<function>process_indata</function> i vårt fall). Du måste "
"anropa metoden <methodname>processed()</methodname> för ett paket för att "
"ange att du har behandlat det."

#: index.docbook:560
#, no-c-format
msgid ""
"Here is an implenetation tip: if processing takes longer (&ie; if you need "
"to wait for soundcard output or something like that), don't call processed "
"immediately, but store the whole data packet and call processed only as soon "
"as you really processed that packet. That way, senders have a chance to know "
"how long it really takes to do your work."
msgstr ""
"Här är ett implementeringstips: Om det tar lång tid att behandla data "
"(dvs. om du måste vänta på utmatning till ljudkortet eller något "
"sådant), anropa inte processed omedelbart, utan lagra hela datapaketet och "
"anropa processed bara när du verkligen har behandlat paketet. På detta "
"sätt, har avsändarna en chans att veta hur lång tid det verkligen tar att "
"utföra arbetet."

#: index.docbook:568
#, no-c-format
msgid ""
"As synchronization isn't so nice with asynchronous streams, you should use "
"synchronous streams wherever possible, and asynchronous streams only when "
"necessary."
msgstr ""
"Eftersom synkronisering inte är så trevlig med asynkrona strömmar, ska "
"man använda synkrona strömmar så ofta det är möjligt, och asynkrona "
"bara om det är nödvändigt."

#: index.docbook:577
#, no-c-format
msgid "Default Streams"
msgstr "Förvalda strömmar"

#: index.docbook:579
#, no-c-format
msgid ""
"Suppose you have 2 objects, for example an AudioProducer and an "
"AudioConsumer. The AudioProducer has an output stream and AudioConsumer has "
"an input one. Each time you want to connect them, you will use those 2 "
"streams. The first use of defaulting is to enable you to make the connection "
"without specifying the ports in that case."
msgstr ""
"Antag att du har två objekt, till exempel en AudioProducer och en "
"AudioConsumer. AudioProducer har en utdataström och AudioConsumer har en "
"indataström. Varje gång du vill förbinda dem, använder du de här två "
"strömmarna. Den första användningen av förval är att låta dig "
"upprätta förbindelsen utan att ange portarna i det här fallet."

#: index.docbook:587
#, no-c-format
msgid ""
"Now suppose the teo objects above can handle stereo, and each have a "
"<quote>left</quote> and <quote>right</quote> port. You'd still like to "
"connect them as easily as before. But how can the connecting system know "
"which output port to connect to which input port? It has no way to correctly "
"map the streams. Defaulting is then used to specify several streams, with an "
"order. Thus, when you connect an object with 2 default output streams to "
"another one with 2 default input streams, you don't have to specify the "
"ports, and the mapping will be done correctly."
msgstr ""
"Antag nu att de två objekten ovan kan hantera stereo, och båda har en "
"<quote>vänster</quote> och <quote>höger</quote> port. Du skulle "
"fortfarande vilja kunna koppla ihop dem lika lätt som tidigare. Men hur kan "
"förbindelsesystemet veta vilken utgång som ska kopplas till vilken "
"ingång? Det har inget sätt att koppla ihop strömmarna korrekt. Förval "
"används då för att ange flera strömmar med en viss ordning. På så "
"sätt, om du ansluter ett objekt med två förvalda utdataströmmar till ett "
"annat med två förvalda indataströmmar, behöver du inte ange portarna, "
"och förbindelserna görs på ett riktigt sätt."

#: index.docbook:598
#, no-c-format
msgid ""
"Of course, this is not limited to stereo. Any number of streams can be made "
"default if needed, and the connect function will check that the number of "
"defaults for 2 object match (in the required direction) if you don't specify "
"the ports to use."
msgstr ""
"Det här är förstås inte begränsat till stereo. Vilket antal strömmar "
"som helst kan göras förvalda om det behövs, och anslutningsfunktionen "
"kontrollerar att antalet förval för två objekt passar ihop (med de "
"angivna riktningarna) om du inte anger portarna som ska användas."

#: index.docbook:605
#, no-c-format
msgid ""
"The syntax is as follows: in the &IDL;, you can use the default keyword in "
"the stream declaration, or on a single line. For example:"
msgstr ""
"Syntaxen är den följande: I &IDL; kan du använda nyckelordet default i "
"strömdeklarationen, eller på en ensam rad. Till exempel:"

#: index.docbook:610
#, no-c-format
msgid ""
"interface TwoToOneMixer {\n"
"    default in audio stream input1, input2;\n"
"    out audio stream output;\n"
"};"
msgstr ""
"interface TwoToOneMixer {\n"
"    default in audio stream input1, input2;\n"
"    out audio stream output;\n"
"};"

#: index.docbook:617
#, no-c-format
msgid ""
"In this example, the object will expect its two input ports to be connected "
"by default. The order is the one specified on the default line, so an object "
"like this one:"
msgstr ""
"I det här exemplet kommer objektet att förvänta sig att dess två "
"indataportar ska anslutas med förval. Ordningen är den som anges på "
"raden, så ett objekt som det här:"

#: index.docbook:623
#, no-c-format
msgid ""
"interface DualNoiseGenerator {\n"
"    out audio stream bzzt, couic;\n"
"    default couic, bzzt;\n"
"};"
msgstr ""
"interface DualNoiseGenerator {\n"
"    out audio stream bzzt, couic;\n"
"    default couic, bzzt;\n"
"};"

#: index.docbook:630
#, no-c-format
msgid ""
"Will make connections from <quote>couic</quote> to <quote>input1</quote>, "
"and <quote>bzzt</quote> to <quote>input2</quote> automatically. Note that "
"since there is only one output for the mixer, it will be made default in "
"this case (see below). The syntax used in the noise generator is useful to "
"declare a different order than the declaration, or selecting only a few "
"ports as default. The directions of the ports on this line will be looked up "
"by &mcopidl;, so don't specify them. You can even mix input and output ports "
"in such a line, only the order is important."
msgstr ""
"skapar automatiskt en förbindelse från <quote>couic</quote> till "
"<quote>input1</quote>, och <quote>bzzt</quote> till <quote>input2</quote> "
"Observera att eftersom det bara finns en utgång för mixern, kommer den att "
"vara förvald i det här fallet (se nedan). Syntaxen som används i "
"brusgeneratorn är användbar för att ange en annan ordning än i "
"deklarationen, eller för att välja bara några få portar som förval. "
"Riktningen på portarna på den här raden slås upp av &mcopidl;, så ange "
"dem inte. Du kan till och med blanda in- och utportar på en sådan här "
"rad, bara ordningen spelar roll."

#: index.docbook:642
#, no-c-format
msgid "There are some rules that are followed when using inheritance:"
msgstr "Det finns några regler som följs när arv används:"

#: index.docbook:646
#, no-c-format
msgid ""
"If a default list is specified in the &IDL;, then use it. Parent ports can "
"be put in this list as well, whether they were default in the parent or not."
msgstr ""
"Om en förvalslista anges i &IDL; så måste den användas. En förälders "
"portar kan också ingå i listan, vare sig de var förval i föräldern "
"eller inte."

#: index.docbook:646
#, no-c-format
msgid ""
"Otherwise, inherit parent's defaults. Ordering is parent1 default1, parent1 "
"default2..., parent2 default1... If there is a common ancestor using 2 "
"parent branches, a <quote>virtual public</quote>-like merging is done at "
"that default's first occurrence in the list."
msgstr ""
"Annars ärvs förälderns förval. Ordningen är förälder1 förval1, "
"förälder1 förval2..., förälder2 förval1... Om det finns en gemensam "
"förfader som använder två föräldragrenar, görs en hopslagning som "
"liknar <quote>virtual public</quote> vid förvalets första plats i listan."

#: index.docbook:646
#, no-c-format
msgid ""
"If there is still no default and a single stream in a direction, use it as "
"default for that direction."
msgstr ""
"Om det fortfarande inte finns något förval och en enda ström i en viss "
"riktning, så används den som förval för den riktningen."

#: index.docbook:676
#, no-c-format
msgid "Attribute change notifications"
msgstr "Ändringsmeddelanden för egenskaper"

#: index.docbook:681
#, no-c-format
msgid ""
"Attribute change notifications are a way to know when an attribute changed. "
"They are a bit comparable with &Qt;'s or Gtk's signals and slots. For "
"instance, if you have a &GUI; element, a slider, which configures a number "
"between 0 and 100, you will usually have an object that does something with "
"that number (for instance, it might be controlling the volume of some audio "
"signal). So you would like that whenever the slider is moved, the object "
"which scales the volume gets notified. A connection between a sender and a "
"receiver."
msgstr ""
"Ändringsmeddelanden för egenskaper är ett sätt att veta när en egenskap "
"ändras. De kan i viss utsträckning jämföras med en &Qt;- eller "
"Gtk-signal eller slot. Om du till exempel har ett grafiskt element, ett "
"skjutreglage, som ställer in ett tal mellan 0 och 100, har du oftast ett "
"objekt som gör något med talet (det kan till exempel kontrollera volymen "
"på någon ljudsignal). Så du skulle vilja att så fort skjutreglaget "
"flyttas ska objektet som ställer in volymen bli underrättat. En "
"förbindelse mellan en sändare och mottagare."

#: index.docbook:692
#, no-c-format
msgid ""
"&MCOP; deals with that by being able to providing notifications when "
"attributes change. Whatever is declared as <quote>attribute</quote> in the "
"&IDL;, can emit such change notifications, and should do so, whenever it is "
"modified. Whatever is declared as <quote>attribute</quote> can also receive "
"such change notifications. So for instance if you had two &IDL; interfaces, "
"like these:"
msgstr ""
"&MCOP; hanterar detta genom att kunna ge meddelanden när egenskaper "
"ändras. Allt som deklareras som <quote>attribute</quote> i &IDL; kan avge "
"sådana ändringsmeddelanden, och ska göra det, när de än ändras. Allt "
"som deklareras som <quote>attribute</quote> kan också ta emot sådana "
"ändringsmeddelanden. Så om du till exempel har två &IDL;-gränssnitt som "
"de här"

#: index.docbook:701
#, no-c-format
msgid ""
"interface Slider {\n"
"         attribute long min,max;\n"
"         attribute long position;\n"
" };\n"
" interface VolumeControl : Arts::StereoEffect {\n"
"     attribute long volume; // 0..100\n"
" };"
msgstr ""
"interface Slider {\n"
"         attribute long min,max;\n"
"         attribute long position;\n"
" };\n"
" interface VolumeControl : Arts::StereoEffect {\n"
"     attribute long volume; // 0..100\n"
" };"

#: index.docbook:711
#, no-c-format
msgid ""
"You can connect them using change notifications. It works using the normal "
"flowsystem connect operation. In this case, the C++ code to connect two "
"objects would look like this:"
msgstr ""
"kan du förbinda dem med ändringsmeddelanden. Det fungerar med det normala "
"flödessystemets anslutningsoperation. I det här fallet, ser C++ koden som "
"ansluter två objekt ut så här:"

#: index.docbook:717
#, no-c-format
msgid ""
"#include &lt;connect.h&gt;\n"
"using namespace Arts;\n"
"[...]\n"
"connect(slider,\"position_changed\",volumeControl,\"volume\");"
msgstr ""
"#include &lt;connect.h&gt;\n"
"using namespace Arts;\n"
"[...]\n"
"connect(slider,\"position_changed\",volumeControl,\"volume\");"

#: index.docbook:724
#, no-c-format
msgid ""
"As you see, each attribute offers two different streams, one for sending the "
"change notifications, called "
"<function><replaceable>attributename</replaceable>_changed</function>, and "
"one for receiving change notifications, called "
"<function>attributename</function>."
msgstr ""
"Som du kan se, erbjuder varje egenskap två olika strömmar, en för att "
"skicka ändringsmeddelanden, som heter "
"<function><replaceable>egenskapsnamn</replaceable>_changed</function>, och "
"en för att ta emot ändringsmeddelanden, som heter "
"<function>egenskapsnamn</function>."

#: index.docbook:758
#, no-c-format
msgid ""
"It is important to know that change notifications and asynchronous streams "
"are compatible. They are also network transparent. So you can connect a "
"change notification of a float attribute of a &GUI; widget has to an "
"asynchronous stream of a synthesis module running on another computer. This "
"of course also implies that change notifications are <emphasis>not "
"synchronous</emphasis>, this means, that after you have sent the change "
"notification, it may take some time until it really gets received."
msgstr ""
"Det är viktigt att veta att ändringsmeddelanden och asynkrona strömmar "
"passar ihop. De är också nätverkstransparenta. Så du kan ansluta en "
"flyttalsegenskaps ändringsmeddelande för en grafisk komponent till en "
"asynkron ström för en syntesmodul som kör på en annan dator. Det här "
"betyder förstås också att ändringsmeddelanden <emphasis>inte är "
"synkrona</emphasis>, vilket betyder att det kan ta tid innan de verkligen "
"tas emot efter du har skickat dem."

#: index.docbook:771
#, no-c-format
msgid "Sending change notifications"
msgstr "Att skicka ändringsmeddelanden"

#: index.docbook:773
#, no-c-format
msgid ""
"When implementing objects that have attributes, you need to send change "
"notifications whereever an attribute changes. The code for doing this looks "
"like this:"
msgstr ""
"När du implementerar objekt som har egenskaper, måste du skicka "
"ändringsmeddelanden så snart en egenskap ändras. Koden för att göra "
"detta ser ut så här:"

#: index.docbook:779
#, no-c-format
msgid ""
"void KPoti_impl::value(float newValue)\n"
" {\n"
"     if(newValue != _value)\n"
"     {\n"
"         _value = newValue;\n"
"         value_changed(newValue); // &lt;- send change notification\n"
"     }\n"
" }"
msgstr ""
"void KPoti_impl::value(float newValue)\n"
" {\n"
"     if(newValue != _value)\n"
"     {\n"
"         _value = newValue;\n"
"         value_changed(newValue); // &lt;- skicka ändringsmeddelande\n"
"     }\n"
" }"

#: index.docbook:790
#, no-c-format
msgid ""
"It is strongly recommended to use code like this for all objects you "
"implement, so that change notifications can be used by other people. You "
"should however void sending notifications too often, so if you are doing "
"signal processing, it is probably the best if you keep track when you sent "
"your last notification, so that you don't send one with every sample you "
"process."
msgstr ""
"Det rekommenderas varmt att använda kod som den här för alla objekt som "
"du implementerar, så att ändringsmeddelanden kan användas av andra. Du "
"bör dock undvika att skicka meddelanden för ofta, så om du gör "
"signalbehandling är det troligen bäst att hålla reda på när du skickade "
"ditt senaste meddelande, så att du inte skickar ett för varje sampling."

#: index.docbook:802
#, no-c-format
msgid "Applications for change notifications"
msgstr "Tillämpningar för ändringsmeddelanden"

#: index.docbook:804
#, no-c-format
msgid ""
"It will be especially useful to use change notifications in conjunction with "
"scopes (things that visualize audio data for instance), gui elements, "
"control widgets, and monitoring. Code using this is in <filename "
"class=\"directory\">kdelibs/arts/tests</filename>, and in the experimental "
"artsgui implementation, which you can find under <filename "
"class=\"directory\">kdemultimedia/arts/gui</filename>."
msgstr ""
"Det kommer att vara särskilt användbart att använda ändringsmeddelanden "
"tillsammans med mätare (objekt som till exempel visualiserar ljuddata), "
"grafiska gränssnitt, styrelement och monitorer. Kod som använder det här "
"finns i <filename class=\"directory\">kdelibs/arts/tests</filename>, och i "
"den experimentella artsgui-implementeringen, som du hittar i <filename "
"class=\"directory\">kdemultimedia/arts/gui</filename>."

#: index.docbook:823
#, no-c-format
msgid "The <literal role=\"extension\">.mcoprc</literal> file"
msgstr "Filen <literal role=\"extension\">.mcoprc</literal>"

#: index.docbook:825
#, no-c-format
msgid ""
"The <literal role=\"extension\">.mcoprc</literal> file (in each user's home "
"directory) can be used to configure &MCOP; in some ways. Currently, the "
"following is possible:"
msgstr ""
"Filen <literal role=\"extension\">.mcoprc</literal> (i varje användares "
"hemkatalog) kan användas för att anpassa &MCOP; i viss mån. För "
"närvarande är följande möjligt:"

#: index.docbook:831
#, no-c-format
msgid "GlobalComm"
msgstr "GlobalComm"

#: index.docbook:831
#, no-c-format
msgid ""
"The name of an interface to be used for global communication. Global "
"communication is used to find other objects and obtain the secret cookie. "
"Multiple &MCOP; clients/servers that should be able to talk to each other "
"need to have a GlobalComm object which is able to share information between "
"them. Currently, the possible values are <quote>Arts::TmpGlobalComm</quote> "
"to communicate via <filename "
"class=\"directory\">/tmp/mcop-<replaceable>username</replaceable></filename>"
" directory (which will only work on the local computer) and "
"<quote>Arts::X11GlobalComm</quote> to communicate via the root window "
"properties on the X11 server."
msgstr ""
"Namnet på ett gränssnitt som ska användas för global kommunikation. "
"Global kommunikation används för att hitta andra objekt och hämta den "
"hemliga kakan. Alla &MCOP; klienter/servrar som ska kunna kommunicera med "
"varandra måste ha ett GlobalComm-objekt för att kunna dela information. "
"För närvarande är de möjliga värdena <quote>Arts::TmpGlobalComm</quote>"
" för att kommunicera via katalogen <filename "
"class=\"directory\">/tmp/mcop-<replaceable>användarnamn</replaceable>"
"</filename> (som bara fungerar på den lokala datorn) och "
"<quote>Arts::X11GlobalComm</quote> för att kommunicera via "
"rotfönsteregenskaperna på X11-servern."

#: index.docbook:831
#, no-c-format
msgid "TraderPath"
msgstr "TraderPath"

#: index.docbook:831
#, no-c-format
msgid ""
"Specifies where to look for trader information. You can list more than one "
"directory here, and separate them with commas, like"
msgstr ""
"Anger var handlarinformation ska hittas. Du kan ange mer än en katalog "
"här, och separera dem med kommatecken."

#: index.docbook:831
#, no-c-format
msgid "ExtensionPath"
msgstr "ExtensionPath"

#: index.docbook:831
#, no-c-format
msgid ""
"Specifies from which directories extensions (in the form of shared "
"libraries) are loaded. Multiple values can be specified comma seperated."
msgstr ""
"Anger från vilka kataloger utökningar (i form av delade bibliotek) laddas. "
"Flera värden kan separeras med kommatecken."

#: index.docbook:876
#, no-c-format
msgid "An example which uses all of the above is:"
msgstr "Ett exempel som använder allt det ovanstående är:"

#: index.docbook:880
#, no-c-format
msgid ""
"# $HOME/.mcoprc file\n"
"GlobalComm=Arts::X11GlobalComm\n"
"\n"
"# if you are a developer, it might be handy to add a directory in your home\n"
"# to the trader/extension path to be able to add components without\n"
"# installing them\n"
"TraderPath=\"/opt/kde2/lib/mcop\",\"/home/joe/mcopdevel/mcop\"\n"
"ExtensionPath=\"/opt/kde2/lib\",\"/home/joe/mcopdevel/lib\""
msgstr ""
"# $HOME/.mcoprc file\n"
"GlobalComm=Arts::X11GlobalComm\n"
"\n"
"# om du är en utvecklare kan det vara bekvämt att lägga till en katalog i "
"din\n"
"# hemkatalog till TraderPath/ExtensionPath sökvägarna för att kunna "
"lägga\n"
"# till komponenter utan att installera dem\n"
"TraderPath=\"/opt/kde2/lib/mcop\",\"/home/joe/mcopdevel/mcop\"\n"
"ExtensionPath=\"/opt/kde2/lib\",\"/home/joe/mcopdevel/lib\""

#: index.docbook:894
#, no-c-format
msgid "&MCOP; for <acronym>CORBA</acronym> Users"
msgstr "&MCOP; för <acronym>CORBA</acronym>-användare"

#: index.docbook:896
#, no-c-format
msgid ""
"If you have used <acronym>CORBA</acronym> before, you will see that &MCOP; "
"is much the same thing. In fact, &arts; prior to version 0.4 used "
"<acronym>CORBA</acronym>."
msgstr ""
"Om du har använt <acronym>CORBA</acronym> tidigare, kommer du att märka "
"att &MCOP; är mycket likt. I själva verket så använde &arts; "
"<acronym>CORBA</acronym> innan version 0.4."

#: index.docbook:902
#, no-c-format
msgid ""
"The basic idea of <acronym>CORBA</acronym> is the same: you implement "
"objects (components). By using the &MCOP; features, your objects are not "
"only available as normal classes from the same process (via standard C++ "
"techniques) - they also are available to remote servers transparently. For "
"this to work, the first thing you need to do is to specify the interface of "
"your objects in an &IDL; file - just like <acronym>CORBA</acronym> &IDL;. "
"There are only a few differences."
msgstr ""
"Den grundläggande idén med <acronym>CORBA</acronym> är likadan: man "
"implementerar objekt (komponenter). Genom att använda funktionerna i &MCOP; "
"är objekt inte bara tillgängliga som normala klasser från samma process "
"(via standardmässiga C++ tekniker), utan de är också transparent "
"tillgängliga för en fjärrserver. För att detta ska fungera, är det "
"första du måste göra att specificera gränssnittet för dina objekt i en "
"&IDL;-fil, precis som för <acronym>CORBA</acronym>-&IDL;. Det finns bara "
"ett fåtal skillnader."

#: index.docbook:913
#, no-c-format
msgid "<acronym>CORBA</acronym> Features That Are Missing In &MCOP;"
msgstr "<acronym>CORBA</acronym>-funktioner som saknas i &MCOP;"

#: index.docbook:916
#, no-c-format
msgid ""
"In &MCOP; there are no <quote>in</quote> and <quote>out</quote> parameters "
"on method invocations. Parameters are always incoming, the return code is "
"always outgoing, which means that the interface:"
msgstr ""
"I &MCOP; finns det inga <quote>in</quote> och <quote>out</quote> parametrar "
"för metodanrop. Parametrar är alltid ingående, och returvärdet är "
"alltid utgående, vilket betyder att gränssnittet:"

#: index.docbook:922
#, no-c-format
msgid ""
"// CORBA idl\n"
"interface Account {\n"
"  void deposit( in long amount );\n"
"  void withdraw( in long amount );\n"
"  long balance();\n"
"};"
msgstr ""
"// CORBA idl\n"
"interface Account {\n"
"  void deposit( in long amount );\n"
"  void withdraw( in long amount );\n"
"  long balance();\n"
"};"

#: index.docbook:931
#, no-c-format
msgid "is written as"
msgstr "skrivs som"

#: index.docbook:935
#, no-c-format
msgid ""
"// MCOP idl\n"
"interface Account {\n"
"  void deposit( long amount );\n"
"  void withdraw( long amount );\n"
"  long balance();\n"
"};"
msgstr ""
"// MCOP idl\n"
"interface Account {\n"
"  void deposit( long amount );\n"
"  void withdraw( long amount );\n"
"  long balance();\n"
"};"

#: index.docbook:944
#, no-c-format
msgid "in &MCOP;."
msgstr "i &MCOP;."

#: index.docbook:948
#, no-c-format
msgid ""
"There is no exception support. &MCOP; doesn't have exceptions - it uses "
"something else for error handling."
msgstr ""
"Det finns inget stöd för undantag. &MCOP; har inte undantag, det använder "
"något annat för felhantering."

#: index.docbook:953
#, no-c-format
msgid ""
"There are no union types and no typedefs. I don't know if that is a real "
"weakness, something one would desperately need to survive."
msgstr ""
"Det finns inga union-typer och inga typdefinitioner. Jag vet inte om det är "
"en verklig svaghet, något man desperat behöver för att överleva."

#: index.docbook:958
#, no-c-format
msgid "There is no support for passing interfaces or object references"
msgstr "Det finns inget stöd för att skicka gränssnitt eller objektreferenser"

#: index.docbook:965
#, no-c-format
msgid "<acronym>CORBA</acronym> Features That Are Different In &MCOP;"
msgstr "<acronym>CORBA</acronym>-funktioner som är annorlunda i &MCOP;"

#: index.docbook:968
#, no-c-format
msgid ""
"You declare sequences as "
"<quote>sequence<replaceable>type</replaceable></quote> in &MCOP;. There is "
"no need for a typedef. For example, instead of:"
msgstr ""
"Du deklarerar sekvenser som "
"<quote>sequence<replaceable>typ</replaceable></quote> i &MCOP;. Det finns "
"inget behov av en typdefinition. Till exempel, istället för:"

#: index.docbook:974
#, no-c-format
msgid ""
"// CORBA idl\n"
"struct Line {\n"
"    long x1,y1,x2,y2;\n"
"};\n"
"typedef sequence&lt;Line&gt; LineSeq;\n"
"interface Plotter {\n"
"    void draw(in LineSeq lines);\n"
"};"
msgstr ""
"// CORBA idl\n"
"struct Line {\n"
"    long x1,y1,x2,y2;\n"
"};\n"
"typedef sequence&lt;Line&gt; LineSeq;\n"
"interface Plotter {\n"
"    void draw(in LineSeq lines);\n"
"};"

#: index.docbook:985
#, no-c-format
msgid "you would write"
msgstr "skulle du skriva"

#: index.docbook:989
#, no-c-format
msgid ""
"// MCOP idl\n"
"struct Line {\n"
"    long x1,y1,x2,y2;\n"
"};\n"
"interface Plotter {\n"
"    void draw(sequence&lt;Line&gt; lines);\n"
"};"
msgstr ""
"// MCOP idl\n"
"struct Line {\n"
"    long x1,y1,x2,y2;\n"
"};\n"
"interface Plotter {\n"
"    void draw(sequence&lt;Line&gt; lines);\n"
"};"

#: index.docbook:1002
#, no-c-format
msgid "&MCOP; Features That Are Not In <acronym>CORBA</acronym>"
msgstr "&MCOP;-funktioner som inte finns i <acronym>CORBA</acronym>"

#: index.docbook:1004
#, no-c-format
msgid ""
"You can declare streams, which will then be evaluated by the &arts; "
"framework. Streams are declared in a similar manner to attributes. For "
"example:"
msgstr ""
"Du kan deklarera strömmar, som sedan behandlas av &arts; grundstomme. "
"Strömmar deklareras på ett sätt som liknar egenskaper. Till exempel:"

#: index.docbook:1010
#, no-c-format
msgid ""
"// MCOP idl\n"
"interface Synth_ADD : SynthModule {\n"
"    in audio stream signal1,signal2;\n"
"    out audio stream outvalue;\n"
"};"
msgstr ""
"// MCOP idl\n"
"interface Synth_ADD : SynthModule {\n"
"    in audio stream signal1,signal2;\n"
"    out audio stream outvalue;\n"
"};"

#: index.docbook:1018
#, no-c-format
msgid ""
"This says that your object will accept two incoming synchronous audio "
"streams called signal1 and signal2. Synchronous means that these are streams "
"that deliver x samples per second (or other time), so that the scheduler "
"will guarantee to always provide you a balanced amount of input data (&eg; "
"200 samples of signal1 are there and 200 samples signal2 are there). You "
"guarantee that if your object is called with those 200 samples signal1 + "
"signal2, it is able to produce exactly 200 samples to outvalue."
msgstr ""
"Det här betyder att ditt objekt kommer att acceptera två inkommande "
"synkrona ljudströmmar som kallas signal1 och signal2. Synkron betyder att "
"de är strömmar som levererar x samplingar per sekund (eller annan tid), "
"så att schemaläggaren alltid garanterar att du får en balanserad mängd "
"indata (t.ex. 200 samplingar av signal1 finns och 200 samplingar av signal2 "
"finns). Du garanterar att om ditt objekt anropas med de här 200 "
"samplingarna av signal1 + signal2, så kan det skapa precis 200 samplingar "
"utdata."

#: index.docbook:1032
#, no-c-format
msgid "The &MCOP; C++ Language Binding"
msgstr "&MCOP;-bindningen till C++ språket"

#: index.docbook:1034
#, no-c-format
msgid "This differs from <acronym>CORBA</acronym> mostly:"
msgstr "Det här skiljer sig från <acronym>CORBA</acronym> i huvudsak angående:"

#: index.docbook:1038
#, no-c-format
msgid ""
"Strings use the C++ <acronym>STL</acronym> <classname>string</classname> "
"class. When stored in sequences, they are stored <quote>plain</quote>, that "
"means they are considered to be a primitive type. Thus, they need copying."
msgstr ""
"Strängar använder C++ <acronym>STL</acronym>-klassen "
"<classname>string</classname>. När de lagras i sekvenser, lagras de  "
"<quote>enkelt</quote>, vilket betyder att de anses vara en primitiv typ. "
"Därför behöver de kopieras."

#: index.docbook:1038
#, no-c-format
msgid "longs are plain long's (expected to be 32 bit)."
msgstr "long är enkla long (förväntas vara 32 bitar)."

#: index.docbook:1038
#, no-c-format
msgid ""
"Sequences use the C++ <acronym>STL</acronym> <classname>vector</classname> "
"class."
msgstr ""
"Sekvenser använder C++ <acronym>STL</acronym>-klassen "
"<classname>vector</classname>."

#: index.docbook:1038
#, no-c-format
msgid ""
"Structures are all derived from the &MCOP; class "
"<classname>Type</classname>, and generated by the &MCOP; &IDL; compiler. "
"When stored in sequences, they are not stored <quote>plain</quote> , but as "
"pointers, as otherwise, too much copying would occur."
msgstr ""
"Strukturer härleds alla från  &MCOP; klassen <classname>Type</classname>, "
"och skapas av &MCOP; &IDL;-kompilatorn. När de lagras i sekvenser, lagras "
"de inte <quote>enkelt</quote>, utan som pekare, eftersom annars skulle för "
"mycket kopiering uppstå."

#: index.docbook:1074
#, no-c-format
msgid "Implementing &MCOP; Objects"
msgstr "Att implementera &MCOP;-objekt"

#: index.docbook:1076
#, no-c-format
msgid ""
"After having them passed through the &IDL; compiler, you need to derive from "
"the <classname>_skel</classname> class. For instance, consider you have "
"defined your interface like this:"
msgstr ""
"Efter att ha skickat dem genom &IDL;-kompilatorn, måste du härleda från "
"klassen <classname>_skel</classname>. Antag till exempel att du har "
"definierat gränssnittet så här:"

#: index.docbook:1082
#, no-c-format
msgid ""
"// MCOP idl: hello.idl\n"
"interface Hello {\n"
"    void hello(string s);\n"
"    string concat(string s1, string s2);\n"
"    long sum2(long a, long b);\n"
"};"
msgstr ""
"// MCOP idl: hello.idl\n"
"interface Hello {\n"
"    void hello(string s);\n"
"    string concat(string s1, string s2);\n"
"    long sum2(long a, long b);\n"
"};"

#: index.docbook:1091
#, no-c-format
msgid ""
"You pass that through the &IDL; compiler by calling "
"<userinput><command>mcopidl</command> "
"<parameter>hello.idl</parameter></userinput>, which will in turn generate "
"<filename>hello.cc</filename> and <filename>hello.h</filename>"
". To implement it, you need to define a C++-class that inherits the skeleton:"
msgstr ""
"Du skickar det genom &IDL;-kompilatorn genom att anropa "
"<userinput><command>mcopidl</command> "
"<parameter>hello.idl</parameter></userinput>, som i sin tur skapar "
"<filename>hello.cc</filename> och <filename>hello.h</filename>. För att "
"implementera det, behöver du en C++ klass som ärver stommen:"

#: index.docbook:1099
#, no-c-format
msgid ""
"// C++ header file - include hello.h somewhere\n"
"class Hello_impl : virtual public Hello_skel {\n"
"public:\n"
"    void hello(const string&amp; s);\n"
"    string concat(const string&amp; s1, const string&amp; s2);\n"
"    long sum2(long a, long b);\n"
"};"
msgstr ""
"// C++ deklarationsfil - infoga hello.h någonstans\n"
"class Hello_impl : virtual public Hello_skel {\n"
"public:\n"
"    void hello(const string&amp; s);\n"
"    string concat(const string&amp; s1, const string&amp; s2);\n"
"    long sum2(long a, long b);\n"
"};"

#: index.docbook:1109
#, no-c-format
msgid "Finally, you need to implement the methods as normal C++"
msgstr "Till sist måste du implementera metoderna som vanlig C++."

#: index.docbook:1113
#, no-c-format
msgid ""
"// C++ implementation file\n"
"\n"
"// as you see string's are passed as const string references\n"
"void Hello_impl::hello(const string&amp; s)\n"
"{\n"
"    printf(\"Hello '%s'!\\n\",s.c_str());\n"
"}\n"
"\n"
"// when they are a returncode they are passed as \"normal\" strings\n"
"string Hello_impl::concat(const string&amp; s1, const string&amp; s2)\n"
"{\n"
"    return s1+s2;\n"
"}\n"
"\n"
"long Hello_impl::sum2(long a, long b)\n"
"{\n"
"    return a+b;\n"
"}"
msgstr ""
"// C++ implementeringsfil\n"
"\n"
"// som du ser skickas strängar som konstanta strängreferenser\n"
"void Hello_impl::hello(const string&amp; s)\n"
"{\n"
"    printf(\"Hello '%s'!\\n\",s.c_str());\n"
"}\n"
"\n"
"// när de är ett returvärde skickas de som \"normala\" strängar\n"
"string Hello_impl::concat(const string&amp; s1, const string&amp; s2)\n"
"{\n"
"    return s1+s2;\n"
"}\n"
"\n"
"long Hello_impl::sum2(long a, long b)\n"
"{\n"
"    return a+b;\n"
"}"

#: index.docbook:1134
#, no-c-format
msgid ""
"Once you do that, you have an object which can communicate using &MCOP;. "
"Just create one (using the normal C++ facilities to create an object):"
msgstr ""
"När du väl har gjort detta, har du ett objekt som kan kommunicera med "
"&MCOP;. Skapa bara ett (med de normala C++ faciliteterna för att skapa ett "
"objekt):"

#: index.docbook:1139
#, no-c-format
msgid "Hello_impl server;"
msgstr "Hello_impl server;"

#: index.docbook:1143
#, no-c-format
msgid "And as soon as you give somebody the reference"
msgstr "Och så fort du ger någon referensen"

#: index.docbook:1147
#, no-c-format
msgid ""
"string reference = server._toString();\n"
"    printf(\"%s\\n\",reference.c_str());"
msgstr ""
"string reference = server._toString();\n"
"    printf(\"%s\\n\",reference.c_str());"

#: index.docbook:1152
#, no-c-format
msgid "and go to the &MCOP; idle loop"
msgstr "och går till  &MCOP;:s väntesnurra"

#: index.docbook:1156
#, no-c-format
msgid "Dispatcher::the()-&gt;run();"
msgstr "Dispatcher::the()-&gt;run();"

#: index.docbook:1160
#, no-c-format
msgid "People can access the thing using"
msgstr "kan alla komma åt objektet med"

#: index.docbook:1164
#, no-c-format
msgid ""
"// this code can run anywhere - not necessarily in the same process\n"
"// (it may also run on a different computer/architecture)\n"
"\n"
"    Hello *h = Hello::_fromString([the object reference printed above]);"
msgstr ""
"// den här koden kan köra var som helst - inte nödvändigtvis i samma "
"process\n"
"// (den kan också köra på en annan dator/arkitektur)\n"
"\n"
"    Hello *h = Hello::_fromString([objektreferensen som skrevs ut ovan]);"

#: index.docbook:1171
#, no-c-format
msgid "and invoke methods:"
msgstr "och anropa metoder:"

#: index.docbook:1175
#, no-c-format
msgid ""
"if(h)\n"
"        h-&gt;hello(\"test\");\n"
"    else\n"
"        printf(\"Access failed?\\n\");"
msgstr ""
"if(h)\n"
"        h-&gt;hello(\"test\");\n"
"    else\n"
"        printf(\"Åtkomst misslyckades?\\n\");"

#: index.docbook:1186
#, no-c-format
msgid "&MCOP; Security Considerations"
msgstr "Säkerhetshänsyn för &MCOP;"

#: index.docbook:1188
#, no-c-format
msgid ""
"Since &MCOP; servers will listen on a <acronym>TCP</acronym> port, "
"potentially everybody (if you are on the Internet) may try to connect &MCOP; "
"services. Thus, it is important to authenticate clients. &MCOP; uses the "
"md5-auth protocol."
msgstr ""
"Eftersom en &MCOP;-server lyssnar på en <acronym>TCP</acronym>-port, kan "
"potentiellt sett alla (om du är ansluten till Internet) försöka att "
"ansluta till en &MCOP;-service. Därför är det viktigt att identifiera "
"klienter. &MCOP; använder md5-auth protokollet."

#: index.docbook:1195
#, no-c-format
msgid ""
"The md5-auth protocol does the following to ensure that only selected "
"(trusted) clients may connect to a server:"
msgstr ""
"Protokollet md5-auth gör följande för att försäkra att bara utvalda "
"(pålitliga) klienter kan ansluta till en server:"

#: index.docbook:1200
#, no-c-format
msgid "It assumes you can give every client a secret cookie."
msgstr "Det antar att du kan ge varje klient en hemlig kaka."

#: index.docbook:1200
#, no-c-format
msgid ""
"Every time a client connects, it verifies that this client knows that secret "
"cookie, without actually transferring it (not even in a form that somebody "
"listening to the network traffic could find it out)."
msgstr ""
"Varje gång en klient ansluter, verifierar den att den här klienten känner "
"till den hemliga kakan, utan att verkligen skicka den (inte ens på en form "
"som någon som lyssnar på nätverkstrafik kan ta reda på)."

#: index.docbook:1217
#, no-c-format
msgid ""
"To give each client the secret cookie, &MCOP; will (normally) put it in the "
"<filename class=\"directory\">mcop</filename> directory (under <filename "
"class=\"directory\">/tmp/mcop-<envar>USER</envar>/secret-cookie</filename>"
"). Of course, you can copy it to other computers. However, if you do so, use "
"a secure transfer mechanism, such as <command>scp</command> (from "
"<application>ssh</application>)."
msgstr ""
"För att ge varje klient den hemliga kakan, lägger &MCOP; (normalt) den i "
"<filename class=\"directory\">mcop</filename> katalogen (i <filename "
"class=\"directory\">/tmp/mcop-<envar>USER</envar>/secret-cookie</filename>"
"). Du kan förstås kopiera den till andra datorer. Men om du gör det, "
"använd då en säker överföringsmekanism, som <command>scp</command> "
"(från <application>ssh</application>)."

#: index.docbook:1227
#, no-c-format
msgid "The authentication of clients uses the following steps:"
msgstr "Identifieringen av klienter använder följande steg:"

#: index.docbook:1231
#, no-c-format
msgid "[SERVER] generate a new (random) cookie R"
msgstr "[SERVER] skapa en ny (slumpmässig) kaka R"

#: index.docbook:1231
#, no-c-format
msgid "[SERVER] send it to the client"
msgstr "[SERVER] skicka den till klienten"

#: index.docbook:1231
#, no-c-format
msgid "[CLIENT] read the \"secret cookie\" S from a file"
msgstr "[KLIENT] läs den \"hemliga kakan\" S från en fil"

#: index.docbook:1231
#, no-c-format
msgid ""
"[CLIENT] mangle the cookies R and S to a mangled cookie M using the MD5 "
"algorithm"
msgstr "[KLIENT] behandla kakorna R och S för att skapa kakan M med MD5-algoritmen"

#: index.docbook:1231
#, no-c-format
msgid "[CLIENT] send M to the server"
msgstr "[KLIENT] skicka M till servern"

#: index.docbook:1231
#, no-c-format
msgid ""
"[SERVER] verify that mangling R and S gives just the same thing as the "
"cookie M received from the client. If yes, authentication is successful."
msgstr ""
"[SERVER] verifiera att behandling av R och S ger precis samma sak som kakan "
"M som togs emot från klienten. Om detta stämmer har identifieringen "
"lyckats."

#: index.docbook:1273
#, no-c-format
msgid "This algorithm should be secure, given that"
msgstr "Den här algoritmen bör vara säker, under förutsättning att"

#: index.docbook:1277
#, no-c-format
msgid "The secret cookies and random cookies are <quote>random enough</quote> and"
msgstr "De hemliga och slumpmässiga kakorna är <quote>slumpmässiga nog</quote> och"

#: index.docbook:1277
#, no-c-format
msgid ""
"The MD5 hashing algorithm doesn't allow to find out the <quote>original "
"text</quote>, that is the secret cookie S and the random cookie R (which is "
"known, anyway), from the mangled cookie M."
msgstr ""
"MD5-algoritmen inte tillåter att <quote>originaltexten</quote> kan "
"avgöras, det vill säga den hemliga kakan S och den slumpmässiga kakan R "
"(som är känd ändå), från den behandlade kakan M."

#: index.docbook:1294
#, no-c-format
msgid ""
"The &MCOP; protocol will start every new connection with an authentication "
"process. Basically, it looks like this:"
msgstr ""
"&MCOP;-protokollet startar varje ny förbindelse med en "
"identifieringsprocess. Översiktligt ser den ut så här:"

#: index.docbook:1299
#, no-c-format
msgid ""
"Server sends a ServerHello message, which describes the known authentication "
"protocols."
msgstr ""
"Servern skickar meddelandet ServerHello, som beskriver de kända "
"indentifieringsprotokollen."

#: index.docbook:1299
#, no-c-format
msgid "Client sends a ClientHello message, which includes authentication info."
msgstr ""
"Klienten skickar meddelandet ClientHello, som innehåller "
"identifieringsinformation."

#: index.docbook:1299
#, no-c-format
msgid "Server sends an AuthAccept message."
msgstr "Servern skickar meddelandet AuthAccept."

#: index.docbook:1321
#, no-c-format
msgid ""
"To see that the security actually works, we should look at how messages are "
"processed on unauthenticated connections:"
msgstr ""
"För att se att säkerheten verkligen fungerar, bör vi titta på hur "
"meddelanden behandlas för oidentifierade förbindelser:"

#: index.docbook:1326
#, no-c-format
msgid ""
"Before the authentication succeeds, the server will not receive other "
"messages from the connection. Instead, if the server for instance expects a "
"<quote>ClientHello</quote> message, and gets an mcopInvocation message, it "
"will drop the connection."
msgstr ""
"Innan identifieringen lyckas, tar inte servern emot andra meddelanden från "
"anslutningen. Istället, om servern till exempel förväntar sig meddelandet "
"<quote>ClientHello</quote>"
", och får meddelandet mcopInvocation, så kopplar den ner förbindelsen."

#: index.docbook:1326
#, no-c-format
msgid ""
"If the client doesn't send a valid &MCOP; message at all (no &MCOP; magic in "
"the message header) in the authentication phase, but something else, the "
"connection is dropped."
msgstr ""
"Om klienten inte skickar ett giltigt &MCOP;-meddelande alls (inget magiskt "
"värde &MCOP; i meddelandehuvudet) i identifieringsfasen, utan något annat, "
"så kopplas förbindelsen ner."

#: index.docbook:1326
#, no-c-format
msgid ""
"If the client tries to send a very very large message (&gt; 4096 bytes in "
"the authentication phase, the message size is truncated to 0 bytes, which "
"will cause that it isn't accepted for authentication) This is to prevent "
"unauthenticated clients from sending &eg; 100 megabytes of message, which "
"would be received and could cause the server to run out of memory."
msgstr ""
"Om klienten försöker skicka ett mycket mycket stort meddelande (&gt; 4096 "
"byte) under identifieringsfasen, kapas meddelandestorleken till 0 byte, "
"vilket gör att det inte accepteras som identifiering. Det här är till "
"för att förhindra att oidentifierade klienter skickar t.ex. ett 100 Mibyte "
"meddelande, som skulle tas emot och kunna orsaka att servern får slut på "
"minne."

#: index.docbook:1326
#, no-c-format
msgid ""
"If the client sends a corrupt ClientHello message (one, for which "
"demarshalling fails), the connection is dropped."
msgstr ""
"Om klienten skickar ett felaktigt ClientHello meddelande (ett där "
"avkodningen misslyckas), så kopplas förbindelsen ner."

#: index.docbook:1326
#, no-c-format
msgid ""
"If the client send nothing at all, then a timeout should occur (to be "
"implemented)."
msgstr ""
"Om klienten inte skickar något alls, ska en tidsgräns överskridas (ännu "
"inte implementerat)."

#: index.docbook:1373
#, no-c-format
msgid "&MCOP; Protocol Specification"
msgstr "&MCOP; protokollspecifikation"

#: index.docbook:1376
#, no-c-format
msgid "Introduction"
msgstr "Inledning"

#: index.docbook:1378
#, no-c-format
msgid ""
"It has conceptual similarities to <acronym>CORBA</acronym>, but it is "
"intended to extend it in all ways that are required for real time multimedia "
"operations."
msgstr ""
"Den har begreppsmässiga likheter med <acronym>CORBA</acronym>, men är "
"avsett för att kunna utökas på alla sätt som krävs för "
"multimediaoperationer i realtid."

#: index.docbook:1384
#, no-c-format
msgid ""
"It provides a multimedia object model, which can be used for both: "
"communication between components in one adress space (one process), and "
"between components that are in different threads, processes or on different "
"hosts."
msgstr ""
"Den tillhandahåller en multimediaobjektmodell, som både kan användas för "
"kommunikation mellan komponenter i ett adressrum (en process), och mellan "
"komponenter som finns i olika trådar, processer eller på olika "
"värddatorer."

#: index.docbook:1391
#, no-c-format
msgid ""
"All in all, it will be designed for extremely high performance (so "
"everything shall be optimized to be blazingly fast), suitable for very "
"communicative multimedia applications. For instance streaming videos around "
"is one of the applications of &MCOP;, where most <acronym>CORBA</acronym> "
"implementations would go down to their knees."
msgstr ""
"Totalt sett, kommer den att konstrueras för extremt hög prestanda (så att "
"allt ska optimeras för att vara våldsamt snabbt), lämpligt för mycket "
"kommunikationsintensiva multimediaprogram. Att till exempel skicka runt "
"video är en av tillämpningarna för &MCOP;, där de flesta "
"<acronym>CORBA</acronym>-implementeringar skulle gå på knäna."

#: index.docbook:1399
#, no-c-format
msgid "The interface definitions can handle the following natively:"
msgstr "Gränssnittsdefinitionerna kan hantera följande själv:"

#: index.docbook:1403
#, no-c-format
msgid "Continous streams of data (such as audio data)."
msgstr "Kontinuerliga dataflöden (som ljuddata)."

#: index.docbook:1403
#, no-c-format
msgid "Event streams of data (such as &MIDI; events)."
msgstr "Händelseflöden av data (som &MIDI;-händelser)."

#: index.docbook:1403
#, no-c-format
msgid "Real reference counting."
msgstr "Riktig referensräkning."

#: index.docbook:1423
#, no-c-format
msgid "and the most important <acronym>CORBA</acronym> gimmicks, like"
msgstr "och de viktigaste <acronym>CORBA</acronym>-knepen, som"

#: index.docbook:1427
#, no-c-format
msgid "Synchronous method invocations."
msgstr "Synkrona metodanrop."

#: index.docbook:1427
#, no-c-format
msgid "Asynchronous method invocations."
msgstr "Asynkrona metodanrop."

#: index.docbook:1427
#, no-c-format
msgid "Constructing user defined data types."
msgstr "Konstruera användardefinierade datatyper."

#: index.docbook:1427
#, no-c-format
msgid "Multiple inheritance."
msgstr "Multipla arv."

#: index.docbook:1427
#, no-c-format
msgid "Passing object references."
msgstr "Skicka objektreferenser."

#: index.docbook:1462
#, no-c-format
msgid "The &MCOP; Message Marshalling"
msgstr "&MCOP;:s meddelandekodning"

#: index.docbook:1464
#, no-c-format
msgid "Design goals/ideas:"
msgstr "Konstruktionsmål/idéer:"

#: index.docbook:1468
#, no-c-format
msgid "Marshalling should be easy to implement."
msgstr "Kodning ska vara enkelt att implementera."

#: index.docbook:1468
#, no-c-format
msgid "Demarshalling requires the receiver to know what type he wants to demarshall."
msgstr "Avkodning kräver att mottagaren vet vilken typ som ska avkodas."

#: index.docbook:1468
#, no-c-format
msgid ""
"The receiver is expected to use every information - so skipping is only in "
"the protocol to a degree that:"
msgstr ""
"Mottagaren förväntas använda all information, så möjlighet att hoppa "
"över data finns bara i protokollet såtillvida att:"

#: index.docbook:1468
#, no-c-format
msgid ""
"If you know you are going to receive a block of bytes, you don't need to "
"look at each byte for an end marker."
msgstr ""
"Om man vet att ett block av data kommer att tas emot, behöver man inte "
"titta på varje del efter en slutmarkör."

#: index.docbook:1468
#, no-c-format
msgid ""
"If you know you are going to receive a string, you don't need to read it "
"until the zero byte to find out it's length while demarshalling, however,"
msgstr ""
"Om man vet att en sträng kommer att tas emot, behöver man inte läsa till "
"en noll-byte för att ta reda på dess längd vid avkodning, men, "

#: index.docbook:1468
#, no-c-format
msgid ""
"If you know you are going to receive a sequence of strings, you need to look "
"at the length of each of them to find the end of the sequence, as strings "
"have variable length. But if you use the strings for something useful, "
"you'll need to do that anyway, so this is no loss."
msgstr ""
"Om man vet att en sekvens av strängar kommer att tas emot måste man titta "
"på längden för var och en av dem för att ta reda på slutet för "
"sekvensen, eftersom strängar har variabel längd. Men om strängarna "
"används för någonting nyttigt, måste det göras i alla fall, så det "
"här är ingen förlust."

#: index.docbook:1468
#, no-c-format
msgid "As little overhead as possible."
msgstr "Så lite extra kostnad som möjligt."

#: index.docbook:1525
#, no-c-format
msgid "Marshalling of the different types is show in the table below:"
msgstr "Kodningen av de olika typerna visas i tabellen nedan:"

#: index.docbook:1531
#, no-c-format
msgid "Type"
msgstr "Typ"

#: index.docbook:1531
#, no-c-format
msgid "Marshalling Process"
msgstr "Kodningsprocess"

#: index.docbook:1531
#, no-c-format
msgid "Result"
msgstr "Resultat"

#: index.docbook:1539
#, no-c-format
msgid "void"
msgstr "void"

#: index.docbook:1539
#, no-c-format
msgid ""
"<type>void</type> types are marshalled by omitting them, so nothing is "
"written to the stream for them."
msgstr ""
"typen <type>void</type> kodas genom att utelämna den, så ingenting skrivs "
"till strömmen för den."

#: index.docbook:1539
#, no-c-format
msgid "<entry></entry>"
msgstr "<entry></entry>"

#: index.docbook:1539
#, no-c-format
msgid "long"
msgstr "long"

#: index.docbook:1539
#, no-c-format
msgid ""
"is marshalled as four bytes, the most significant byte first, so the number "
"10001025 (which is 0x989a81) would be marshalled as:"
msgstr ""
"kodas som fyra byte, med den mest signifikanta först, så att talet "
"10001025 (som är 0x989a81) skulle kodas som:"

#: index.docbook:1539
#, no-c-format
msgid "0x00 0x98 0x9a 0x81"
msgstr "0x00 0x98 0x9a 0x81"

#: index.docbook:1539
#, no-c-format
msgid "enums"
msgstr "uppräkningstyper"

#: index.docbook:1539
#, no-c-format
msgid "are marshalled like <type>long</type>s"
msgstr "kodas som <type>long</type>"

#: index.docbook:1539
#, no-c-format
msgid "byte"
msgstr "byte"

#: index.docbook:1539
#, no-c-format
msgid "is marshalled as a single byte, so the byte 0x42 would be marshalled as:"
msgstr "kodas som en enda byte, så 0x42 skulle kodas som:"

#: index.docbook:1539
#, no-c-format
msgid "0x42"
msgstr "0x42"

#: index.docbook:1539
#, no-c-format
msgid "string"
msgstr "sträng"

#: index.docbook:1539
#, no-c-format
msgid ""
"is marshalled as a <type>long</type>"
", containing the length of the following string, and then the sequence of "
"characters strings must end with one zero byte (which is included in the "
"length counting)."
msgstr ""
"kodas som en <type>long</type>, som innehåller längden på den "
"efterföljande strängen, och sedan sekvensen av tecken. Strängar måste "
"sluta med en noll-byte (som ingår i längdberäkningen)."

#: index.docbook:1539
#, no-c-format
msgid "include the trailing 0 byte in length counting!"
msgstr "inklusive den sista 0 byten i längdräkningen!"

#: index.docbook:1539
#, no-c-format
msgid "<quote>hello</quote> would be marshalled as:"
msgstr "<quote>hello</quote> skulle kodas som:"

#: index.docbook:1539
#, no-c-format
msgid "0x00 0x00 0x00 0x06 0x68 0x65 0x6c 0x6c 0x6f 0x00"
msgstr "0x00 0x00 0x00 0x06 0x68 0x65 0x6c 0x6c 0x6f 0x00"

#: index.docbook:1539
#, no-c-format
msgid "boolean"
msgstr "boolean"

#: index.docbook:1539
#, no-c-format
msgid ""
"is marshalled as a byte, containing 0 if <returnvalue>false</returnvalue>"
" or 1 if <returnvalue>true</returnvalue>, so the boolean value "
"<returnvalue>true</returnvalue> is marshalled as:"
msgstr ""
"kodas som en byte, som innehåller 0 om <returnvalue>false</returnvalue> "
"eller 1 om <returnvalue>true</returnvalue>, så att det booleska värdet "
"<returnvalue>true</returnvalue> kodas som:"

#: index.docbook:1539
#, no-c-format
msgid "0x01"
msgstr "0x01"

#: index.docbook:1539
#, no-c-format
msgid "float"
msgstr "flyttal"

#: index.docbook:1539
#, no-c-format
msgid ""
"is marshalled after the four byte IEEE754 representation - detailed docs how "
"IEEE works are here: <ulink "
"url=\"http://twister.ou.edu/workshop.docs/common-tools/numerical_comp_guide/n"
"cg_math.doc.html\">"
"http://twister.ou.edu/workshop.docs/common-tools/numerical_comp_guide/ncg_mat"
"h.doc.html</ulink> and here: <ulink "
"url=\"http://java.sun.com/docs/books/vmspec/2nd-edition/html/Overview.doc.htm"
"l\">"
"http://java.sun.com/docs/books/vmspec/2nd-edition/html/Overview.doc.html</uli"
"nk>. So, the value 2.15 would be marshalled as:"
msgstr ""
"kodas med fyra-byte IEEE754 representationen, detaljerad dokumentation om "
"hur IEEE fungerar finns här: <ulink "
"url=\"http://twister.ou.edu/workshop.docs/common-tools/numerical_comp_guide/n"
"cg_math.doc.html\">http://twister.ou.edu/workshop.docs/ common-tools/ "
"numerical_comp_guide/ ncg_math.doc.html</ulink> och här: <ulink "
"url=\"http://java.sun.com/docs/books/vmspec/2nd-edition/html/Overview.doc.htm"
"l\">http://java.sun.com/docs/books/ vmspec/ 2nd-edition/ html/ "
"Overview.doc.html</ulink>. Så värdet 2,15 skulle kodas som:"

#: index.docbook:1539
#, no-c-format
msgid "0x9a 0x99 0x09 0x40"
msgstr "0x9a 0x99 0x09 0x40"

#: index.docbook:1539
#, no-c-format
msgid "struct"
msgstr "struct"

#: index.docbook:1539
#, no-c-format
msgid ""
"A structure is marshalled by marshalling it's contents. There are no "
"additional prefixes or suffixes required, so the structure"
msgstr ""
"En struktur kodas genom att koda dess innehåll. Det krävs inga ytterligare "
"prefix eller suffix, så att strukturen"

#: index.docbook:1539
#, no-c-format
msgid ""
"struct test {\n"
"    string name;        // which is \"hello\"\n"
"    long value;         // which is 10001025  (0x989a81)\n"
"};"
msgstr ""
"struct test {\n"
"    string name;        // som är \"hello\"\n"
"    long value;         // som är 10001025  (0x989a81)\n"
"};"

#: index.docbook:1539
#, no-c-format
msgid "would be marshalled as"
msgstr "skulle kodas som:"

#: index.docbook:1539
#, no-c-format
msgid ""
"0x00 0x00 0x00 0x06   0x68 0x65 0x6c 0x6c\n"
"0x6f 0x00 0x00 0x98   0x9a 0x81"
msgstr ""
"0x00 0x00 0x00 0x06   0x68 0x65 0x6c 0x6c\n"
"0x6f 0x00 0x00 0x98   0x9a 0x81"

#: index.docbook:1539
#, no-c-format
msgid "sequence"
msgstr "sekvens"

#: index.docbook:1539
#, no-c-format
msgid ""
"a sequence is marshalled by listing the number of elements that follow, and "
"then marshalling the elements one by one."
msgstr ""
"En sekvens kodas genom att lista antalet element som följer, och sedan koda "
"elementen ett efter ett."

#: index.docbook:1539
#, no-c-format
msgid ""
"So a sequence of 3 longs a, with a[0] = 0x12345678, a[1] = 0x01 and a[2] = "
"0x42 would be marshalled as:"
msgstr ""
"Så en sekvens med tre \"long a\", med a[0] = 0x12345678, a[1] = 0x01 och "
"a[2] = 0x42 skulle kodas som"

#: index.docbook:1539
#, no-c-format
msgid ""
"0x00 0x00 0x00 0x03   0x12 0x34 0x56 0x78\n"
"0x00 0x00 0x00 0x01   0x00 0x00 0x00 0x42"
msgstr ""
"0x00 0x00 0x00 0x03   0x12 0x34 0x56 0x78\n"
"0x00 0x00 0x00 0x01   0x00 0x00 0x00 0x42"

#: index.docbook:1638
#, no-c-format
msgid ""
"If you need to refer to a type, all primitive types are referred by the "
"names given above. Structures and enums get own names (like Header). "
"Sequences are referred as *<replaceable>normal type</replaceable>"
", so that a sequence of longs is <quote>*long</quote> and a sequence of "
"Header struct's is <quote>*Header</quote>."
msgstr ""
"Om du behöver hänvisa till en typ, anges alla primitiva typer med namnen "
"som finns ovan. Strukturer och uppräkningstyper får sina egna namn (som "
"Header). Sekvenser benämns som *<replaceable>normal typ</replaceable>, så "
"att en sekvens av long är <quote>*long</quote> och en sekvens av Header "
"struct:ar är <quote>*Header</quote>."

#: index.docbook:1649
#, no-c-format
msgid "Messages"
msgstr "Meddelanden"

#: index.docbook:1651
#, no-c-format
msgid "The &MCOP; message header format is defined as defined by this structure:"
msgstr "Formatet på &MCOP;:s meddelandehuvud definieras av den här strukturen:"

#: index.docbook:1656
#, no-c-format
msgid ""
"struct Header {\n"
"    long magic;          // the value 0x4d434f50, which is marshalled as "
"MCOP\n"
"    long messageLength;\n"
"    long messageType;\n"
"};"
msgstr ""
"struct Header {\n"
"    long magic;          // värdet 0x4d434f50, som kodas som MCOP\n"
"    long messageLength;\n"
"    long messageType;\n"
"};"

#: index.docbook:1664
#, no-c-format
msgid "The possible messageTypes are currently"
msgstr "De möjliga meddelandetyperna är för närvarande"

#: index.docbook:1668
#, no-c-format
msgid ""
"mcopServerHello\t\t= 1\n"
" mcopClientHello\t\t= 2\n"
" mcopAuthAccept\t\t\t= 3\n"
" mcopInvocation\t\t\t= 4\n"
" mcopReturn\t\t\t\t= 5\n"
" mcopOnewayInvocation   = 6"
msgstr ""
"mcopServerHello\t= 1\n"
" mcopClientHello\t= 2\n"
" mcopAuthAccept\t\t= 3\n"
" mcopInvocation\t\t= 4\n"
" mcopReturn\t\t= 5\n"
" mcopOnewayInvocation\t= 6"

#: index.docbook:1677
#, no-c-format
msgid "A few notes about the &MCOP; messaging:"
msgstr "Lite information om &MCOP;:s meddelandehantering:"

#: index.docbook:1682
#, no-c-format
msgid "Every message starts with a Header."
msgstr "Varje meddelande börjar med ett huvud."

#: index.docbook:1682
#, no-c-format
msgid ""
"Some messages types should be dropped by the server, as long as the "
"authentication is not complete."
msgstr ""
"Vissa meddelandetyper ska ignoreras av servern, innan identifiering är "
"färdig."

#: index.docbook:1682
#, no-c-format
msgid ""
"After receiving the header, the protocol (connection) handling can receive "
"the message completely, without looking at the contents."
msgstr ""
"Efter att huvudet tagits emot, kan protokollhanteringen (anslutningen) ta "
"emot meddelandet i sin helhet, utan att titta på innehållet."

#: index.docbook:1704
#, no-c-format
msgid ""
"The messageLength in the header is of course in some cases redundant, which "
"means that this approach is not minimal regarding the number of bytes."
msgstr ""
"Meddelandelängden i huvudet är förstås redundant i vissa fall, vilket "
"gör att metoden inte alltid är minimal med avseende på antal byte."

#: index.docbook:1710
#, no-c-format
msgid ""
"However, it leads to an easy (and fast) implementation of non-blocking "
"messaging processing. With the help of the header, the messages can be "
"received by protocol handling classes in the background (non-blocking), if "
"there are many connections to the server, all of them can be served "
"parallel. You don't need to look at the message content, to receive the "
"message (and to determine when you are done), just at the header, so the "
"code for that is pretty easy."
msgstr ""
"Detta ger dock en enkel (och snabb) implementering för behandling av "
"meddelanden som inte blockerar. Med hjälp av huvudet kan meddelanden tas "
"emot av protokollhanteringsklasser i bakgrunden (utan blockering), om det "
"finns många anslutningar till servern kan alla behandlas parallellt. Man "
"behöver inte titta på meddelandets innehåll för att ta emot ett "
"meddelande (och avgöra när man är klar), bara på huvudet, så koden för "
"detta är ganska enkel."

#: index.docbook:1720
#, no-c-format
msgid ""
"Once a message is there, it can be demarshalled and processed in one single "
"pass, without caring about cases where not all data may have been received "
"(because the messageLength guarantees that everything is there)."
msgstr ""
"När ett meddelande väl finns på plats, kan det avkodas och behandlas i "
"ett enda steg, utan att bry sig om fall där all data kanske inte tagits "
"emot (eftersom meddelandelängden garanterar att allt är på plats)."

#: index.docbook:1730
#, no-c-format
msgid "Invocations"
msgstr "Anrop"

#: index.docbook:1732
#, no-c-format
msgid ""
"To call a remote method, you need to send the following structure in the "
"body of an &MCOP; message with the messageType = 1 (mcopInvocation):"
msgstr ""
"För att anropa en fjärrmetod, måste man skicka följande struktur i ett "
"&MCOP;-meddelande med messageType = 1 (mcopInvocation):"

#: index.docbook:1737
#, no-c-format
msgid ""
"struct Invocation {\n"
"    long objectID;\n"
"    long methodID;\n"
"    long requestID;\n"
"};"
msgstr ""
"struct Invocation {\n"
"    long objectID;\n"
"    long methodID;\n"
"    long requestID;\n"
"};"

#: index.docbook:1745
#, no-c-format
msgid ""
"after that, you send the parameters as structure, &eg; if you invoke the "
"method string concat(string s1, string s2), you send a structure like"
msgstr ""
"därefter skickas parametrarna som en struktur, t.ex. om man anropar metoden "
"\"string concat(string s1, string s2)\", skickas strukturen"

#: index.docbook:1750
#, no-c-format
msgid ""
"struct InvocationBody {\n"
"    string s1;\n"
"    string s2;\n"
"};"
msgstr ""
"struct InvocationBody {\n"
"    string s1;\n"
"    string s2;\n"
"};"

#: index.docbook:1758
#, no-c-format
msgid ""
"if the method was declared to be oneway - that means asynchronous without "
"return code - then that was it. Otherwise, you'll receive as answer the "
"message with messageType = 2 (mcopReturn)"
msgstr ""
"om metoden deklarerades som envägs, vilket betyder asynkront utan "
"returvärde, är det allt. Annars får man ett meddelande som svar med "
"messageType = 2 (mcopReturn)."

#: index.docbook:1764
#, no-c-format
msgid ""
"struct ReturnCode {\n"
"    long requestID;\n"
"    &lt;resulttype&gt; result;\n"
"};"
msgstr ""
"struct ReturnCode {\n"
"    long requestID;\n"
"    &lt;resulttype&gt; result;\n"
"};"

#: index.docbook:1772
#, no-c-format
msgid ""
"where &lt;resulttype&gt; is the type of the result. As void types are "
"omitted in marshalling, you can also only write the requestID if you return "
"from a void method."
msgstr ""
"där &lt;resulttype&gt; är typen för resultatet. Eftersom void-typer "
"utelämnas vid kodning, kan man också bara ange requestID om man returnerar "
"från en void-metod."

#: index.docbook:1778
#, no-c-format
msgid "So our string concat(string s1, string s2) would lead to a returncode like"
msgstr "Så vår \"string concat(string s1, string s2)\" skulle ge en returkod som"

#: index.docbook:1783
#, no-c-format
msgid ""
"struct ReturnCode {\n"
"    long   requestID;\n"
"    string result;\n"
"};"
msgstr ""
"struct ReturnCode {\n"
"    long   requestID;\n"
"    string result;\n"
"};"

#: index.docbook:1793
#, no-c-format
msgid "Inspecting Interfaces"
msgstr "Inspektera gränssnitt"

#: index.docbook:1795
#, no-c-format
msgid ""
"To do invocations, you need to know the methods an object supports. To do "
"so, the methodID 0, 1, 2 and 3 are hardwired to certain functionalities. "
"That is"
msgstr ""
"För att göra anrop, måste man känna till metoderna som ett objekt "
"stöder. För att göra detta, är methodID 0, 1, 2 och 3 hårdkodade för "
"vissa funktioner. Det vill säga"

#: index.docbook:1801
#, no-c-format
msgid ""
"long _lookupMethod(MethodDef methodDef);\t\t\t\t// methodID always 0\n"
"string _interfaceName();\t\t\t\t\t\t\t\t// methodID always 1\n"
"InterfaceDef _queryInterface(string name);\t\t\t\t// methodID always 2\n"
"TypeDef _queryType(string name);\t\t\t\t\t\t// methodID always 3"
msgstr ""
"long _lookupMethod(MethodDef methodDef);\t// methodID alltid 0\n"
"string _interfaceName();\t\t\t// methodID alltid 1\n"
"InterfaceDef _queryInterface(string name);\t// methodID alltid 2\n"
"TypeDef _queryType(string name);\t\t// methodID alltid 3"

#: index.docbook:1808
#, no-c-format
msgid "to read that, you of course need also"
msgstr "för att läsa detta, behövs förstås också"

#: index.docbook:1812
#, no-c-format
msgid ""
"struct MethodDef {\n"
"\tstring  methodName;\n"
"\tstring  type;\n"
"\tlong    flags;        // set to 0 for now (will be required for "
"streaming)\n"
"\tsequence&lt;ParamDef&gt; signature;\n"
"};\n"
"\n"
"struct ParamDef {\n"
"\tstring name;\n"
"\tlong   typeCode;\n"
"};"
msgstr ""
"struct MethodDef {\n"
"\tstring  methodName;\n"
"\tstring  type;\n"
"\tlong    flags;        // nu satt till 0 (krävs för strömmar)\n"
"\tsequence&lt;ParamDef&gt; signature;\n"
"};\n"
"\n"
"struct ParamDef {\n"
"\tstring name;\n"
"\tlong   typeCode;\n"
"};"

#: index.docbook:1826
#, no-c-format
msgid ""
"the parameters field contains type components which specify the types of the "
"parameters. The type of the returncode is specified in the MethodDef's type "
"field."
msgstr ""
"parameterfältet innehåller typkomponenter som anger typerna för "
"parametrar. Typen för returkoden anges i typfältet för MethodDef."

#: index.docbook:1832
#, no-c-format
msgid ""
"Strictly speaking, only the methods <methodname>_lookupMethod()</methodname>"
" and <methodname>_interfaceName()</methodname>"
" differ from object to object, while the "
"<methodname>_queryInterface()</methodname> and "
"<methodname>_queryType()</methodname> are always the same."
msgstr ""
"För att vara strikt, är det bara metoderna "
"<methodname>_lookupMethod()</methodname> och "
"<methodname>_interfaceName()</methodname> som varierar från objekt till "
"objekt, medan <methodname>_queryInterface()</methodname> och "
"<methodname>_queryType()</methodname> alltid är likadana."

#: index.docbook:1840
#, no-c-format
msgid ""
"What are those methodIDs? If you do an &MCOP; invocation, you are expected "
"to pass a number for the method you are calling. The reason for that is, "
"that numbers can be processed much faster than strings when executing an "
"&MCOP; request."
msgstr ""
"Vad är ett sådant här methodID? Om man gör ett &MCOP;-anrop, förväntas "
"man skicka numret för metoden som anropas. Orsaken till detta är att "
"nummer kan behandlas mycket snabbare än strängar när en &MCOP;-begäran "
"körs."

#: index.docbook:1847
#, no-c-format
msgid ""
"So how do you get those numbers? If you know the signature of the method, "
"that is a MethodDef that describes the method, (which contains name, type, "
"parameter names, parameter types and such), you can pass that to "
"_lookupMethod of the object where you wish to call a method. As "
"_lookupMethod is hardwired to methodID 0, you should encounter no problems "
"doing so."
msgstr ""
"Så hur skaffar man sig ett sådant här nummer? Om man känner till "
"signaturen för metoden, dvs. en MethodDef som beskriver den (som "
"innehåller namn, typ, parameternamn, parametertyper och liknande), så kan "
"man skicka den till _lookupMethod för objektet där man vill anropa en "
"metod. Eftersom _lookupMethod är hårdkodad till methodID 0, ska det inte "
"vara några problem att göra detta."

#: index.docbook:1856
#, no-c-format
msgid ""
"On the other hand, if you don't know the method signature, you can find "
"which methods are supported by using _interfaceName, _queryInterface and "
"_queryType."
msgstr ""
"Om man å andra sidan inte känner till metodens signatur, kan man ta reda "
"på vilka metoder som stöds genom att använda _interfaceName, "
"_queryInterface och _queryType."

#: index.docbook:1864
#, no-c-format
msgid "Type Definitions"
msgstr "Typdefinitioner"

#: index.docbook:1866
#, no-c-format
msgid ""
"User defined datatypes are described using the "
"<structname>TypeDef</structname> structure:"
msgstr ""
"Användardefinierade datatyper beskrivs med strukturen "
"<structname>TypeDef</structname>:"

#: index.docbook:1871
#, no-c-format
msgid ""
"struct TypeComponent {\n"
"\tstring type;\n"
"\tstring name;\n"
"};\n"
"\n"
"struct TypeDef {\n"
"\tstring name;\n"
"\n"
"\tsequence&lt;TypeComponent&gt; contents;\n"
"};"
msgstr ""
"struct TypeComponent {\n"
"\tstring type;\n"
"\tstring name;\n"
"};\n"
"\n"
"struct TypeDef {\n"
"\tstring name;\n"
"\n"
"\tsequence&lt;TypeComponent&gt; contents;\n"
"};"

#: index.docbook:1888
#, no-c-format
msgid "Why &arts; Doesn't Use &DCOP;"
msgstr "Varför &arts; inte använder &DCOP;"

#: index.docbook:1890
#, no-c-format
msgid ""
"Since &kde; dropped <acronym>CORBA</acronym>"
" completely, and is using &DCOP; everywhere instead, naturally the question "
"arises why &arts; isn't doing so. After all, &DCOP; support is in "
"<classname>KApplication</classname>, is well-maintained, supposed to "
"integrate greatly with libICE, and whatever else."
msgstr ""
"Eftersom &kde; släppt <acronym>CORBA</acronym> helt och hållet, och "
"istället använder &DCOP; överallt, uppstår förstås frågan varför "
"inte &arts; också gör det. Trots allt finns &DCOP;-stöd i "
"<classname>KApplication</classname>, underhålls väl, förväntas "
"integreras utmärkt med libICE, och allt möjligt annat."

#: index.docbook:1898
#, no-c-format
msgid ""
"Since there will be (potentially) a lot of people asking whether having "
"&MCOP; besides &DCOP; is really necessary, here is the answer. Please don't "
"get me wrong, I am not trying to say <quote>&DCOP; is bad</quote>"
". I am just trying to say <quote>&DCOP; isn't the right solution for "
"&arts;</quote> (while it is a nice solution for other things)."
msgstr ""
"Eftersom det (möjligtvis) kommer att finnas många som frågar om det "
"verkligen är nödvändigt att ha &MCOP; förutom &DCOP;, så finns svaret "
"här. Missförstå mig inte, jag försöker inte säga att <quote>"
"&DCOP; är dåligt</quote>. Jag försöker bara säga <quote>"
"&DCOP; är inte rätt lösning för &arts;</quote> (medan det är en bra "
"lösning för andra saker)."

#: index.docbook:1907
#, no-c-format
msgid ""
"First, you need to understand what exactly &DCOP; was written for. Created "
"in two days during the &kde;-TWO meeting, it was intended to be as simple as "
"possible, a really <quote>lightweight</quote> communication protocol. "
"Especially the implementation left away everything that could involve "
"complexity, for instance a full blown concept how data types shall be "
"marshalled."
msgstr ""
"Först måste man förstå exakt vad &DCOP; skrevs för. Skapat på två dar "
"under mötet &kde;-TWO, var det avsett att vara så enkelt som möjligt, ett "
"verkligt <quote>lättviktigt</quote> kommunikationsprotokoll. I synnerhet "
"utelämnade implementeringen allt som kunde innebära komplexitet, till "
"exempel ett fullständigt koncept angående hur datatyper ska kodas."

#: index.docbook:1916
#, no-c-format
msgid ""
"Even although &DCOP; doesn't care about certain things (like: how do I send "
"a string in a network-transparent manner?) - this needs to be done. So, "
"everything that &DCOP; doesn't do, is left to &Qt; in the &kde; apps that "
"use &DCOP; today. This is mostly type management (using the &Qt; "
"serialization operator)."
msgstr ""
"Fastän &DCOP; inte bryr sig om vissa saker (som hur man skickar en sträng "
"på ett nätverkstransparent sätt), måste detta göras. Så allt som inte "
"&DCOP; gör överlämnas till &Qt; i &kde;-programmen som använder &DCOP; "
"idag. Det här är i huvudsak typhantering (som använder  &Qt;:s "
"serialiseringsoperator)."

#: index.docbook:1924
#, no-c-format
msgid ""
"So &DCOP; is a minimal protocol which perfectly enables &kde; applications "
"to send simple messages like <quote>open a window pointing to "
"http://www.kde.org</quote> or <quote>your configuration data has "
"changed</quote>. However, inside &arts; the focus lies on other things."
msgstr ""
"Så &DCOP; är ett minimalt protokoll som gör det helt möjlig för "
"&kde;-program att skicka enkla meddelanden som <quote>öppna ett fönster "
"som pekar på http://www.kde.org</quote> eller <quote>dina inställningar "
"har ändrats</quote>. Inne i &arts; fokuseras dock på andra saker."

#: index.docbook:1931
#, no-c-format
msgid ""
"The idea is, that little plugins in &arts; will talk involving such data "
"structures as <quote>midi events</quote> and <quote>songposition "
"pointers</quote> and <quote>flow graphs</quote>."
msgstr ""
"Idén är att små insticksmoduler i &arts; ska kommunicera med sådana "
"datastrukturer som <quote>midi-händelser</quote> och "
"<quote>sångpositionspekare</quote> och <quote>flödesgrafer</quote>."

#: index.docbook:1937
#, no-c-format
msgid ""
"These are complex data types, which must be sent between different objects, "
"and be passed as streams, or parameters. &MCOP; supplies a type concept, to "
"define complex data types out of simpler ones (similar to structs or arrays "
"in C++). &DCOP; doesn't care about types at all, so this problem would be "
"left to the programmer - like: writing C++ classes for the types, and make "
"sure they can serialize properly (for instance: support the &Qt; streaming "
"operator)."
msgstr ""
"Detta är komplexa datatyper, som måste skickas mellan olika objekt, och "
"hanteras som strömmar, eller parametrar. &MCOP; tillhandahåller ett "
"typkoncept för att definiera komplexa datatyper från enklare (liknande "
"struct:ar och fält i C++). &DCOP; bryr sig inte om typer alls, så det här "
"problemet skulle lämnas till programmeraren, som att skriva C++ klasser "
"för typerna, och försäkra sig om att de går att serialisera på ett "
"riktigt sätt (till exempel stöd för &Qt;:s serialiseringsoperator)."

#: index.docbook:1947
#, no-c-format
msgid ""
"But that way, they would be inaccessible to everything but direct C++ "
"coding. Specifically, you could not design a scripting language, that would "
"know all types plugins may ever expose, as they are not self describing."
msgstr ""
"Men på det sättet skulle de inte vara tillgängliga för något annat än "
"direkt kodning i C++. I synnerhet skulle man inte kunna skapa ett "
"skriptspråk som skulle kunna känna till alla typer som en insticksmodul "
"kan göra tillgängliga, eftersom de inte skulle vara självbeskrivande."

#: index.docbook:1954
#, no-c-format
msgid ""
"Much the same argument is valid for interfaces as well. &DCOP; objects don't "
"expose their relationships, inheritance hierarchies, etc. - if you were to "
"write an object browser which shows you <quote>what attributes has this "
"object got</quote>, you'd fail."
msgstr ""
"Samma argument gäller också gränssnitt i stor utsträckning. "
"&DCOP;-objekt gör inte sina förhållanden, arvhierarkier, etc. "
"tillgängliga. Om man skulle skriva en objektbläddrare som skulle visa "
"<quote>vilka egenskaper har det här objektet</quote>, skulle man misslyckas."

#: index.docbook:1962
#, no-c-format
msgid ""
"While Matthias told me that you have a special function "
"<quote>functions</quote> on each object that tells you about the methods "
"that an object supports, this leaves out things like attributes "
"(properties), streams and inheritance relations."
msgstr ""
"Även om Matthias talade om för mig att man har en speciell funktion "
"<quote>functions</quote> för varje objekt som informerar om vilka metoder "
"som objektet stöder, utelämnar detta saker som egenskaper, strömmar och "
"arvrelationer."

#: index.docbook:1969
#, no-c-format
msgid ""
"This seriously breaks applications like &artsbuilder;. But remember: &DCOP; "
"was not so much intended to be an object model (as &Qt; already has one with "
"<application>moc</application> and similar), nor to be something like "
"<acronym>CORBA</acronym>, but to supply inter-application communication."
msgstr ""
"Det här gör att program som aRts-byggaren inte skulle fungera alls. Men "
"kom ihåg, det var inte meningen att &DCOP; skulle vara en objektmodell "
"(eftersom &Qt; redan har en med <application>moc</application> och "
"liknande), inte heller vara något som <acronym>CORBA</acronym>, utan "
"tillhandahålla kommunikation mellan program."

#: index.docbook:1977
#, no-c-format
msgid ""
"Why &MCOP; even exists is: it should work fine with streams between objects. "
"&arts; makes heavily use of small plugins, which interconnect themselves "
"with streams. The <acronym>CORBA</acronym> version of &arts; had to "
"introduce a very annoying split between <quote>the SynthModule "
"objects</quote>, which were the internal work modules that did do the "
"streaming, and <quote>the <acronym>CORBA</acronym> interface</quote>, which "
"was something external."
msgstr ""
"Orsaken att &MCOP; överhuvudtaget finns är att det måste fungera bra med "
"strömmar mellan objekt. &arts; använder många små insticksmoduler, som "
"förbinds med strömmar. <acronym>CORBA</acronym>-versionen av &arts; var "
"tvungen att introducera en besvärande uppdelning mellan "
"<quote>SynthModule-objekt</quote>, som var de interna arbetsmodulerna som "
"skapade strömmar, och <quote><acronym>CORBA</acronym>-gränssnitt</quote>, "
"som var något externt."

#: index.docbook:1987
#, no-c-format
msgid ""
"Much code cared about making interaction between <quote>the SynthModule "
"objects</quote> and <quote>the <acronym>CORBA</acronym> interface</quote> "
"look natural, but it didn't, because <acronym>CORBA</acronym> knew nothing "
"at all about streams. &MCOP; does. Look at the code (something like "
"<filename>simplesoundserver_impl.cc</filename>). Way better! Streams can be "
"declared in the interface of modules, and implemented in a natural looking "
"way."
msgstr ""
"Mycket kod bekymrade sig om att åstadkomma att växelverkan mellan "
"<quote>SynthModule-objekt</quote> och "
"<quote><acronym>CORBA</acronym>-gränssnittet</quote> såg naturlig ut, men "
"den gjorde aldrig det, eftersom <acronym>CORBA</acronym> inte kände till "
"något alls om strömmar. &MCOP; gör det. Titta på koden (någonting i "
"stil med <filename>simplesoundserver_impl.cc</filename>). Åtskilligt "
"bättre! Strömmar kan deklareras i modulernas gränssnitt, och "
"implementeras på ett sätt som ser naturligt ut."

#: index.docbook:1998
#, no-c-format
msgid ""
"One can't deny it. One of the reasons why I wrote &MCOP; was speed. Here are "
"some arguments why &MCOP; will definitely be faster than &DCOP; (even "
"without giving figures)."
msgstr ""
"Man kan inte förneka det. En av orsakerna att jag skrev  &MCOP; var "
"snabbhet. Här är några argument varför &MCOP; definitivt kommer att vara "
"snabbare än &DCOP; (även utan att ange siffror)."

#: index.docbook:2005
#, no-c-format
msgid "An invocation in &MCOP; will have a six-<quote>long</quote>-header. That is:"
msgstr ""
"Ett anrop i &MCOP; kommer att ha ett huvud med sex <quote>long</quote>. Det "
"vill säga:"

#: index.docbook:2010
#, no-c-format
msgid "magic <quote>MCOP</quote>"
msgstr "magiskt värde <quote>MCOP</quote>"

#: index.docbook:2010
#, no-c-format
msgid "message type (invocation)"
msgstr "meddelandetyp (anrop)"

#: index.docbook:2010
#, no-c-format
msgid "size of the request in bytes"
msgstr "storlek på begäran i byte"

#: index.docbook:2010
#, no-c-format
msgid "request ID"
msgstr "ID för begäran"

#: index.docbook:2010
#, no-c-format
msgid "target object ID"
msgstr "ID för målobjektet"

#: index.docbook:2010
#, no-c-format
msgid "target method ID"
msgstr "ID för målmetoden"

#: index.docbook:2019
#, no-c-format
msgid ""
"After that, the parameters follow. Note that the demarshalling of this is "
"extremely fast. You can use table lookups to find the object and the method "
"demarshalling function, which means that complexity is O(1) [ it will take "
"the same amount of time, no matter how many objects are alive, or how many "
"functions are there ]."
msgstr ""
"Efter detta följer parametrarna. Observera att avkoda det här går extremt "
"fort. Man kan använda tabelluppslagningar för att hitta "
"avkodningsfunktionen för objektet och metoden, vilket betyder att "
"komplexiteten är O(1) [det tar lika lång tid oberoende av hur många "
"objekt som finns, och hur många funktioner som finns]."

#: index.docbook:2027
#, no-c-format
msgid "Comparing this to &DCOP;, you'll see, that there are at least"
msgstr "Om det här jämförs med  &DCOP;, ser du att det finns åtminstone"

#: index.docbook:2031
#, no-c-format
msgid "a string for the target object - something like <quote>myCalculator</quote>"
msgstr ""
"en sträng för målobjektet - någonting i stil med "
"<quote>myCalculator</quote>"

#: index.docbook:2031
#, no-c-format
msgid "a string like <quote>addNumber(int,int)</quote> to specify the method"
msgstr "en sträng som liknar <quote>addNumber(int,int)</quote> för att ange metoden"

#: index.docbook:2031
#, no-c-format
msgid ""
"several more protocol info added by libICE, and other DCOP specifics I don't "
"know"
msgstr ""
"ytterligare protokollinformation tillagd av libICE, och andra DCOP-specifika "
"saker som jag inte känner till"

#: index.docbook:2040
#, no-c-format
msgid ""
"These are much more painful to demarshall, as you'll need to parse the "
"string, search for the function, &etc;."
msgstr ""
"De här är mycket svårare att avkoda, eftersom man måste tolka strängen, "
"leta efter funktionen, etc."

#: index.docbook:2045
#, no-c-format
msgid ""
"In &DCOP;, all requests are running through a server "
"(<application>DCOPServer</application>). That means, the process of a "
"synchronous invocation looks like this:"
msgstr ""
"Med &DCOP; skickas alla anrop genom en server "
"(<application>DCOPServer</application>). Det betyder att hanteringen av ett "
"synkront anrop ser ut så här:"

#: index.docbook:2051 index.docbook:2090
#, no-c-format
msgid "Client process sends invocation."
msgstr "Klientprocessen skickar anrop."

#: index.docbook:2051
#, no-c-format
msgid ""
"<application>DCOPserver</application> (man-in-the-middle) receives "
"invocation and looks where it needs to go, and sends it to the "
"<quote>real</quote> server."
msgstr ""
"<application>DCOPserver</application>"
" (mannen i mitten) tar emot anropet och ser efter vart det ska ta vägen, "
"och skickar det till den <quote>riktiga</quote> servern."

#: index.docbook:2051 index.docbook:2090
#, no-c-format
msgid "Server process receives invocation, performs request and sends result."
msgstr "Serverprocessen tar emot anropet, utför begäran och skickar resultatet."

#: index.docbook:2051
#, no-c-format
msgid ""
"<application>DCOPserver</application> (man-in-the-middle) receives result "
"and ... sends it to the client."
msgstr ""
"<application>DCOPserver</application> (mannen i mitten) tar emot resultatet "
"och ... skickar det till klienten."

#: index.docbook:2051 index.docbook:2090
#, no-c-format
msgid "Client decodes reply."
msgstr "Klienten avkodar svaret."

#: index.docbook:2086
#, no-c-format
msgid "In &MCOP;, the same invocation looks like this:"
msgstr "I &MCOP; ser samma anrop ut så här:"

#: index.docbook:2110
#, no-c-format
msgid ""
"Say both were implemented correctly, &MCOP;s peer-to-peer strategy should be "
"faster by a factor of two, than &DCOP;s man-in-the-middle strategy. Note "
"however that there were of course reasons to choose the &DCOP; strategy, "
"which is namely: if you have 20 applications running, and each app is "
"talking to each app, you need 20 connections in &DCOP;, and 200 with &MCOP;. "
"However in the multimedia case, this is not supposed to be the usual setting."
msgstr ""
"Antag att båda är riktigt implementerade. &MCOP;:s icke-hierarkiska "
"strategi bör vara snabbare med en faktor två, än &DCOP;:s man i "
"mitten-strategi. Observera dock att det förstås fanns orsaker att välja "
"&DCOP;-strategin, som är att om du har 20 program som kör, och varje "
"program pratar med varje annat program, så behöver man 20 anslutningar med "
"&DCOP;, och 200 med &MCOP;. I fallet med multimedia är det dock inte "
"meningen att detta ska vara ett vanligt scenario."

#: index.docbook:2120
#, no-c-format
msgid ""
"I tried to compare &MCOP; and &DCOP;, doing an invocation like adding two "
"numbers. I modified testdcop to achieve this. However, the test may not have "
"been precise on the &DCOP; side. I invoked the method in the same process "
"that did the call for &DCOP;, and I didn't know how to get rid of one "
"debugging message, so I used output redirection."
msgstr ""
"Jag försökte jämföra &MCOP; och &DCOP;, med att göra ett anrop som "
"adderar två tal. Jag ändrade testdcop för att åstadkomma detta. Testen "
"var dock kanske inte precis på &DCOP;-sidan. Jag anropade metoden i samma "
"process som gjorde anropet till &DCOP;, och jag visste inte hur man blev av "
"med ett avlusningsmeddelande, så jag använde omdirigering av utmatningen."

#: index.docbook:2128
#, no-c-format
msgid ""
"The test only used one object and one function, expect &DCOP;s results to "
"decrease with more objects and functions, while &MCOP;s results should stay "
"the same. Also, the <application>dcopserver</application> process wasn't "
"connected to other applications, it might be that if many applications are "
"connected, the routing performance decreases."
msgstr ""
"Testen använde bara ett objekt och en funktion, så resultaten för &DCOP; "
"förväntas minska med fler objekt och funktioner, medan resultaten för "
"&MCOP; bör förbli likadana. Dessutom var inte "
"<application>dcopserver</application>"
"-processen ansluten till andra program, och det kanske är så att om många "
"program är anslutna så minskar överföringsprestanda."

#: index.docbook:2136
#, no-c-format
msgid ""
"The result I got was that while &DCOP; got slightly more than 2000 "
"invocations per second, &MCOP; got slightly more than 8000 invocations per "
"second. That makes a factor of 4. I know that &MCOP; isn't tuned to the "
"maximum possible, yet. (Comparision: <acronym>CORBA</acronym>, as "
"implemented with mico, does something between 1000 and 1500 invocations per "
"second)."
msgstr ""
"Resultatet jag fick var att medan &DCOP; fick lite mer än 2000 anrop per "
"sekund, fick &MCOP; något mer än 8000 anrop per sekund. Det betyder en "
"faktor 4. Jag vet att &MCOP; inte är avstämd för den maximalt möjliga "
"hastigheten än. (Som jämförelse: <acronym>CORBA</acronym>, med "
"mico-implementeringen, klarar något mellan 1000 och 1500 anrop per sekund)."

#: index.docbook:2145
#, no-c-format
msgid ""
"If you want <quote>harder</quote> data, consider writing some small "
"benchmark app for &DCOP; and send it to me."
msgstr ""
"Om du vill ha <quote>riktigare</quote> data, fundera på att skriva något "
"litet mätprogram för &DCOP; och skicka det till mig."

#: index.docbook:2150
#, no-c-format
msgid ""
"<acronym>CORBA</acronym>"
" had the nice feature that you could use objects you implemented once, as "
"<quote>seperate server process</quote>, or as <quote>library</quote>. You "
"could use the same code to do so, and <acronym>CORBA</acronym> would "
"transparently descide what to do. With &DCOP;, that is not really intended, "
"and as far as I know not really possible."
msgstr ""
"<acronym>CORBA</acronym>"
" hade den trevliga funktionen att man kunde använda objekt som man "
"implementerat, som <quote>separat serverprocess</quote>, eller som "
"<quote>bibliotek</quote>. Man kunde använda samma kod för att göra det, "
"och <acronym>CORBA</acronym> bestämde transparent vad som skulle göras. "
"Med &DCOP;, är det inte riktigt meningen, och så vitt jag vet inte "
"egentligen möjligt."

#: index.docbook:2159
#, no-c-format
msgid ""
"&MCOP; on the other hand should support that from the beginning. So you can "
"run an effect inside &artsd;. But if you are a wave editor, you can choose "
"to run the same effect inside your process space as well."
msgstr ""
"&MCOP; å andra sidan ska stöda detta från början. Så man kan köra en "
"effekt inne i &artsd;. Men för en vågformseditor kan man välja att köra "
"samma effekt inne i processen också."

#: index.docbook:2165
#, no-c-format
msgid ""
"While &DCOP; is mostly a way to communicate between apps, &MCOP; is also a "
"way to communicate inside apps. Especially for multimedia streaming, this is "
"important (as you can run multiple &MCOP; objects parallely, to solve a "
"multimedia task in your application)."
msgstr ""
"Där &DCOP; i huvudsak är ett sätt att kommunicera mellan program, är "
"&MCOP; också ett sätt att kommunicera inne i program. Särskilt för "
"multimediaflöden är detta viktigt (eftersom man kan köra flera "
"&MCOP;-objekt i parallell, för att lösa en multimediauppgift i ett "
"program)."

#: index.docbook:2172
#, no-c-format
msgid ""
"Although &MCOP; does not currently do so, the possibilities are open to "
"implement quality of service features. Something like <quote>that &MIDI; "
"event is really really important, compared to this invocation</quote>. Or "
"something like <quote>needs to be there in time</quote>."
msgstr ""
"Fastän &MCOP; inte gör det för närvarande, är möjligheterna öppna att "
"implementera servicekvalitetsfunktioner. Någonting i stil med att "
"<quote>den där &MIDI;-händelsen är verkligen riktigt viktig, jämfört "
"med det här anropet</quote>. Eller någonting som <quote>"
"måste vara där i tid</quote>."

#: index.docbook:2179
#, no-c-format
msgid ""
"On the other hand, stream transfer can be integrated in the &MCOP; protocol "
"nicely, and combined with <acronym>QoS</acronym> stuff. Given that the "
"protocol may be changed, &MCOP; stream transfer should not really get slower "
"than conventional <acronym>TCP</acronym> streaming, but: it will be easier "
"and more consistent to use."
msgstr ""
"Å andra sidan kan strömöverföringar integreras i &MCOP;-protokollet på "
"ett trevligt sätt, och kombineras med <acronym>QoS</acronym>-grejor. Under "
"förutsättning att protokollet kan ändras, bör inte &MCOP; "
"strömöverföringar verkligen bli långsammare än en konventionell "
"<acronym>TCP</acronym>-ström, men de kommer att vara enklare och mer "
"konsekventa att använda."

#: index.docbook:2187
#, no-c-format
msgid ""
"There is no need to base a middleware for multimedia on &Qt;. Deciding so, "
"and using all that nice &Qt;-streaming and stuff, will easily lead to the "
"middleware becoming a &Qt;-only (or rather &kde;-only) thing. I mean: as "
"soon as I'll see the GNOMEs using &DCOP;, too, or something like that, I am "
"certainly proven wrong."
msgstr ""
"Det finns ingen anledning att basera mellanprogram för multimedia på &Qt;. "
"Genom att bestämma sig för det, och använda allt de där trevliga "
"&Qt;-strömmarna och andra saker, kan det lätt leda till att mellanprogram "
"bara blir en sak för &Qt;-(eller i själva verket bara &kde;). Jag menar "
"att om jag någonsin ser att GNOME också använder &DCOP;, eller någonting "
"liknande, är det förstås bevisat att jag har fel."

#: index.docbook:2195
#, no-c-format
msgid ""
"While I do know that &DCOP; basically doesn't know about the data types it "
"sends, so that you could use &DCOP; without using &Qt;, look at how it is "
"used in daily &kde; usage: people send types like "
"<classname>QString</classname>, <classname>QRect</classname>, "
"<classname>QPixmap</classname>, <classname>QCString</classname>, ..., "
"around. These use &Qt;-serialization. So if somebody choose to support "
"&DCOP; in a GNOME program, he would either have to claim to use "
"<classname>QString</classname>,... types (although he doesn't do so), and "
"emulate the way &Qt; does the streaming, or he would send other string, "
"pixmap and rect types around, and thus not be interoperable."
msgstr ""
"Fastän jag vet att &DCOP; i grunden inte känner till de datatyper som det "
"skickar, så att man skulle kunna använda &DCOP; utan &Qt;, se hur det "
"används i daglig &kde;-användning: man skickar runt typer som "
"<classname>QString</classname>, <classname>QRect</classname>, "
"<classname>QPixmap</classname>, <classname>QCString</classname>, .... De "
"här använder &Qt;:s-serialisering. Så om någon väljer att stöda &DCOP; "
"i ett GNOME-program, måste han antingen ange att han använder "
"<classname>QString</classname>,... typer (även om han inte gör det), och "
"emulera sättet som &Qt; använder för strömmar, eller så skulle han "
"skicka runt andra sträng-, pixmap- och rect-typer, och på så sätt ändå "
"inte kunna fungera ihop med &kde;-program."

#: index.docbook:2208
#, no-c-format
msgid ""
"Well, whatever. &arts; was always intended to work with or without &kde;, "
"with or without &Qt;, with or without X11, and maybe even with or without "
"&Linux; (and I have even no problems with people who port it to a popular "
"non-free operating systems)."
msgstr ""
"Nå, hur som helst var alltid &arts; avsett att fungera med eller utan "
"&kde;, med eller utan &Qt;, med eller utan X11, och kanske till och med med "
"eller utan &Linux; (och jag har inte ens några invändningar mot personer "
"som anpassar det till operativsystem som inte är fria)."

#: index.docbook:2215
#, no-c-format
msgid ""
"It is my position that non-&GUI;-components should be written "
"non-&GUI;-dependant, to make sharing those among wider amounts of developers "
"(and users) possible."
msgstr ""
"Min inställning är att komponenter som inte ingår i ett grafiskt "
"gränssnitt ska skrivas oberoende av detta, för att möjliggöra att de "
"delas mellan ett större antal utvecklare (och användare)."

#: index.docbook:2221
#, no-c-format
msgid ""
"I see that using two <acronym>IPC</acronym> protocols may cause "
"inconveniences. Even more, if they are both non-standard. However, for the "
"reasons given above, switching to &DCOP; is no option. If there is "
"significant interest to find a way to unite the two, okay, we can try. We "
"could even try to make &MCOP; speak <acronym>IIOP</acronym>, then we'd have "
"a <acronym>CORBA</acronym> <acronym>ORB</acronym> ;)."
msgstr ""
"Jag inser att använda två <acronym>IPC</acronym>-protokoll kan vara "
"obekvämt. Dessutom är båda två inte standardiserade. Av orsakerna som "
"angivits ovan är det inte möjligt att byta till &DCOP;. Om det finns ett "
"betydligt intresse av att hitta ett sätt att förena de två, så kan vi "
"försöka. Vi skulle till och med kunna försöka få &MCOP; att prata "
"<acronym>IIOP</acronym>, då skulle vi ha en <acronym>CORBA</acronym> "
"<acronym>ORB</acronym> ;)."

#: index.docbook:2230
#, no-c-format
msgid ""
"I talked with Matthias Ettrich a bit about the future of the two protocols, "
"and we found lots of ways how things could go on. For instance, &MCOP; could "
"handle the message communication in &DCOP;, thus bringing the protocols a "
"bit closer together."
msgstr ""
"Jag pratade en del med Matthias Ettrich om framtiden med de två "
"protokollen, och vi fann många sätt som saker kunde gå vidare. &MCOP; "
"skulle till exempel kunna hantera meddelandekommunikationen i &DCOP;, och "
"på så sätt föra protokollen närmare varandra."

#: index.docbook:2237
#, no-c-format
msgid "So some possible solutions would be:"
msgstr "Några möjliga lösningar skulle vara:"

#: index.docbook:2241
#, no-c-format
msgid ""
"Write an &MCOP; - &DCOP; gateway (which should be possible, and would make "
"interoperation possible) - note: there is an experimental prototype, if you "
"like to work on that."
msgstr ""
"Skriva en portal mellan &MCOP; och &DCOP; (vilket bör vara möjligt, och "
"skulle möjliggöra samkörning). Observera att det finns en experimentell "
"prototyp, om du skulle vilja arbeta med det."

#: index.docbook:2241
#, no-c-format
msgid ""
"Integrate everything &DCOP; users expect into &MCOP;, and try to only do "
"&MCOP; - one could add an <quote>man-in-the-middle-option</quote>"
" to &MCOP;, too ;)"
msgstr ""
"Integrera allt &DCOP;-användare förväntar sig i &MCOP;, och försöka "
"bara använda &MCOP; - man skulle kunna lägga till en <quote>man i "
"mitten</quote> möjlighet i &MCOP; också ;)"

#: index.docbook:2241
#, no-c-format
msgid ""
"Base &DCOP; on &MCOP; instead of libICE, and slowly start integrating things "
"closer together."
msgstr ""
"Basera  &DCOP; på &MCOP; istället för libICE, och långsamt börja "
"integrera saker tätare tillsammans."

#: index.docbook:2266
#, no-c-format
msgid ""
"However, it may not be the worst possibility to use each protocol for "
"everything it was intended for (there are some big differences in the design "
"goals), and don't try to merge them into one."
msgstr ""
"Den sämsta möjligheten är kanske inte att använda varje protokoll för "
"allt det som det var avsett för (det finns några stora skillnader i målen "
"med deras konstruktion), och inte försöka slå ihop dem till ett."
