natgillin/translations-raw huggingface dataset:
Forespørgsel på LAN for tilgængelige printere,
Querying the LAN for available printers,
Basal -, Digest - og Certifikat- godkendelse,
Basic, Digest, and Certificate Authentication,
Adgangskontrol baseret på IP - adresser, netadresser, netmasker, vært - og domænenavne,
Access Control based on IP addresses, net addresses, netmasks, host- and domain names,
og 128- Bit TLS eller SSL3 kryptering af udskriftsdata, for at forhindre hemmelige lyttere eller i det mindste at gøre det meget sværere.
and 128-Bit TLS or SSL3 encryption of print data, to prevent eavesdropping, or at least make it much more difficult.
Dette gør & kdeprint; en meget mere robust og troværdig løsning end at bruge den ærværdige LPD.
This makes & kdeprint; a much more robust and reliable solution than using the venerable LPD.
Hvordan får man adgang til & kdeprint;
How to access & kdeprint;
Du får adgang til & kdeprint; eller dele af den på fire forskellige måder:
You get access to & kdeprint;, or parts of it, in four different ways:
Gennem dine programmer: hvis du kalder udskriftsdialogen (enten Fil Udskriv...) eller knappen med den lille printerikon på; dette åbner udskriftsdialogen.
through your applications: if you call the printing dialogue (either File Print...) or the button with the little printer icon on it; this opens the printing dialogue.
gennem den skrevne kommando kprinter i et terminal eller et & konsole; - vindue eller fra Kør kommando... mini - CLI - vinduet: dette åbner også udskriftsdialogen.
through the typed command kprinter in a terminal or a & konsole; window or from the Run Command... mini- CLI window: this also opens the printing dialogue.
fra - knappen ved at starte & kcontrol;, og så gå til System Udskriftshåndtering. Dette åbner for & kdeprint; - administration som en del af & kcontrolcenter; og også tillader dig at skifte til andre dele af & kcontrol;
from the button, starting & kcontrol;, and then go to System Printing Manager. This opens the & kdeprint; administration which is part of the & kcontrolcenter; and also lets you switch to other parts of the & kcontrol;
fra en kommandolinje (konsole; eller mini - CLI) skrives kcmshell printmgr. Dette åbner kun & kdeprint; - delen af & kcontrol; for at ændre din opsætning
from a command line (konsole; or mini- CLI) type kcmshell printmgr. This opens just the & kdeprint; part of & kcontrol; to change your settings
& kprinter; - dialogen der vil blive startet fra Kør kommando... - vinduet
& kprinter; dialogue to be started from Run Command... window
Start af & kprinter; - dialogen fra et Kør kommando... - vindue.
Starting the & kprinter; dialogue from a Run Command... window.
Her er en & kivio; - tegning af & kprinter; - dialogen som den kommer frem efter den er startet... Du kan altid tilføje en ny printer ved at klikke på den lille Guide - knap (markeret rød/ gul i denne tegning).
Here is a & kivio; drawing of the & kprinter; dialogue as it pops up after being started... You can always add a new printer by clicking on the small Wizard button (marked red/ yellow in this drawing).
kprinter; - dialog startet (kivio; kladdetegning)
kprinter; dialogue started (kivio; draft drawing)
Noget teoretisk baggrundsmateriale om: & CUPS;, IPP, & PostScript; og Ghostscript
Some Theoretical Background: & CUPS;, IPP, & PostScript; and Ghostscript
Formålet med dette kapitel er at give en smule af den teoretiske baggrund for udskrift i almindelighed og for & CUPS; i særdeleshed. Hvis du ikke har brug for dette vil du måske hellere skippe frem til næste kapitel. Jeg vil regne med du kommer tilbage til dette kapitel på et eller andet tidspunkt alligevel, for sommetider har man brug for lidt ekstra teori for at løse et praktisk problem.
This chapter aims to give a bit of theoretical background to printing in general, and to & CUPS; especially. If you are not in need of this, you might like to skip ahead to the next chapter. Chances are you will come back to this chapter at some point anyway, because sometimes one needs extra theory to solve a practical problem.
Basalt om udskrift
Basics About Printing
Udskrift er et af de mere komplicerede kapitler i IT - teknologi.
Printing is one of the more complicated chapters in IT technology.
Tidligere i historien måtte enhver udvikler af et program, der skulle kunne producere udskriveligt materiale ud, også selv skrive sine egne printer- drivere. Dette var temmelig kompliceret, fordi forskellige programmer har forskellige filformater. Selv programmer med det samme formål, for eksempel, tekstbehandlingsprogrammer, forstår ofte ikke hinandens formater. Der var derfor ingen fælles grænseflade for alle printere, og derfor understøttede programmørerne ofte kun nogle få udvalgte modeller.
Earlier on in history, every developer of a program that was capable of producing printable output had to write his own printer drivers too. That was quite complicated, because different programs have different file formats. Even programs with the same purpose, for example: word processors, often do not understand each other 's formats. There was therefore no common interface to all printers, hence the programmers often supported only a few selected models.
Når en ny enhed kom på markedet var det nødvendigt at programforfatterne skulle skrive en ny driver, hvis de ønskede deres program skulle understøtte den. Det var også umuligt for fabrikanter at sørge for at deres enhed var understøttet af noget som helst program i hele verden (selvom der var langt færre end i dag).
A new device appearing on the market required the program authors to write a new driver if they wanted their program to support it. Also for manufacturers, it was impossible to make sure their device was supported by any program known to the world (although there were far fewer than today).
Det at skulle understøtte ti programmer og et dusin printere betød, at en systemadministrator skulle håndtere 120 drivere. Så udviklingen af forenede grænseflader mellem programmer og printere blev et påtrængende behov.
Having to support ten application programs and a dozen printers, meant a system administrator had to deal with 120 drivers. So the development of unified interfaces between programs and printers became an urgent need.
Fremkomsten af Sidebeskrivelsessprog, som beskriver den grafiske repræsentation af blæk og toner papirark (eller andre uddata enheder som skærme fotosættere, & etc;) i på en fælles måde udfyldte et stort tomrum.
The appearance of Page Description Languages, describing the graphical representation of ink and toner on sheets of paper (or other output devices, like monitors, photo typesetters, & etc;) in a common way, was a move that filled a big gap.
En sådan udvikling var & PostScript; af Adobe. Det betød at en programmør kunne koncentrere sig om at få programmet til at lave en & PostScript; - sprog beskrivelse af udskriftssiden, mens udskriftsenhed- udviklerne kunne fokusere på at få deres enheder til at forstå & PostScript;.
One such development was & PostScript; by Adobe. It meant that an application programmer could concentrate on making his program generate a & PostScript; language description of his printable page, while printing device developers could focus on making their devices & PostScript; literate.
Naturligvis kom der med tiden en udvikling af andre beskrivelsesmetoder. De vigtigste konkurrenter til & PostScript; var PCL (Print Control Language, fra & Hewlett- Packard;), ESC/ P (fra Epson) og GDI (Graphical Device Interface fra & Microsoft;).
Of course, over time, there came the development of other description methods. The most important competitors to & PostScript; were PCL (Print Control Language, from & Hewlett-Packard;), ESC/ P (from Epson) and GDI (Graphical Device Interface from & Microsoft;).
Fremkomsten af disse sidebeskrivelsessprog gjorde livet nemmere og hjalp udviklingen for alle. Men det faktum at der stadig var forskellige, inkompatible og konkurrerende sidebeskrivelsessprog gør livet svært nok endda for brugere, administratorer, udviklere og fabrikanter.
The appearance of these page description languages made life easier, and facilitated further development for everybody. Yet the fact that there still remained different, incompatible, and competing page description languages keeps life for users, administrators, developers and manufacturers difficult enough.
& PostScript; i hukommelsen - Bitmaps på papiret
& PostScript; in memory - Bitmaps on Paper
& PostScript; er den mest brugte i professionel printmiljøer såsom PrePress og udskriftsservice industrier. Indenfor & UNIX; og & Linux; domænerne, er & PostScript; den dominerende standard som et PDL. Her genererer næsten alle programmer en & PostScript; - repræsentation af dens sider når du trykket på Udskriv - knappen. Lad os kigge på et simpelt eksempel på (hjemmelavet) & PostScript; - kode. Følgende listning beskriver to simple tegninger:
& PostScript; is most heavily used in professional printing environments such as PrePress and printing service industries. In the & UNIX; and & Linux; domains, & PostScript; is the predominant standard as a PDL. Here, nearly every program generates a & PostScript; representation of its pages once you push the Print button. Let us look at a simple example of (hand-made) & PostScript; code. The following listing describes two simple drawings:
& PostScript; - kode
& PostScript; Code
Dette beder den imaginære & PostScript; - pen om at tegne en sti af en bestemt form, og så udfylde den med forskellige afskygninger af gråt. Den første del oversættes til mere forståeligt engelsk som Gå til koordinat (100, 100), tegn en linje med længde 50 opad; så en derfra til højre, så ned igen, og til sidst lukkes denne del af. Udfyld nu den tegnede form med 70% grå.
This tells the imaginary & PostScript; pen to draw a path of a certain shape, and then fill it with different shades of grey. The first part translates into more comprehensive English as Go to coordinate (100,100), draw a line with length 50 upward; then one from there to the right, then down again, and finally close this part. Now fill the drawn shape with 70% darkness grey.
Fremvist & PostScript;
Rendered & PostScript;
eksempel fremvist som et billede.
example rendered as an image.
& PostScript; kan naturligvis være meget mere kompliceret end dette simplistiske eksempel. Det er et fuldt udviklet programmeringssprog med mange forskellige operatorer og funktioner. Du kan endog skrive & PostScript; - programmer der beregner Pi' s værdi, formatere en disk eller skriver til en fil. Hovedværdien og styrken ved & PostScript; er imidlertid i evnen til at beskrive layout af grafiske objekter på en side: den kan også skalere, spejle, translatere, transformere, rotere og forvrænge alt du kan forestille dig på et stykke papir -- såsom bogstaver i forskellige skrifttyperepræsentationer, figurer, forme, skygger, farver, linjer, prikker, raster...
Of course, & PostScript; can be much more complicated than this simplistic example. It is a fully fledged programming language with many different operators and functions. You may even write & PostScript; programs to compute the value of Pi, format a hard disk or write to a file. The main value and strength of & PostScript; however lies in the field to describe the layout of graphical objects on a page: it also can scale, mirror, translate, transform, rotate and distort everything you can imagine on a piece of paper -- such as letters in different font representations, figures, shapes, shades, colours, lines, dots, raster...
En & PostScript; - fil er en repræsentation af en eller flere sider der skal udskrives, beskrevet på en relativ abstrakt måde. Ideelt set er det meningen at siderne skal beskrives uafhængigt af enheden. & PostScript; er ikke direkte synlig; det lever kun på disken og i RAM som en indkodet repræsentation af fremtidige udskrifter.
A & PostScript; file is a representation of one or more pages to be printed, in a relatively abstract way. Ideally, it is meant to describe the pages in a device-independent way. & PostScript; is not directly visible; it only lives on hard disks and in RAM as a coded representation of future printouts.
Raster- billeder på papirark
Raster Images on Paper Sheets
Det du ser på et stykke papir er næsten altid et rasterbillede. Selv om din hjerne får dig til at se en linje: så tag et godt forstørrelsesglas og du vil opdage masser af små prikker... (Et eksempel på det modsatte er linjer der er tegnede med pen- plottere). Og det er det eneste som nutidens printeres markeringsmaskiner kan putte på papir: simple prikker i forskellige farve, størrelse og resolution til at lave et fuldstændigt sidebillede komponeret af forskellige bitmap- mønstre.
What you see on a piece of paper is nearly always a raster image. Even if your brain suggests to you that your eyes see a line: take a good magnifying glass and you will discover lots of small dots... (One example to the contrary are lines that have been drawn by pen plotters). And that is the only thing that the marking engines of today 's printers can put on paper: simple dots of different colours, size and resolution, to make up a complete page image composed of different bitmap patterns.
Forskellige printere skal have rasterbilledet tilberedt på forskellig måde. Hvis du tænker på en inkjet- enhed: afhængig af dens resolution, antallet af blækpatroner (de meget gode har brug for 7 slags blæk, mens en billigere måske vil bruge 3), antallet af tilgængelige dyser (nogle printhoveder har mere ned 100!) der fordeler blæk samtidigt, dithering- algoritmen der bruges og mange andre ting, er det endelige rasterformat og overførselsrækkefølge til markeringsmaskinen stærkt afhængig af den nøjagtige model der bruges.
Different printers need the raster image prepared in different ways. Thinking about an inkjet device: depending on its resolution, the number of inks used (the very good ones need 7 different inks, while cheaper ones might only use 3), the number of available jets (some print heads have more than 100!) dispensing ink simultaneously, the dithering algorithm used, and many other things, the final raster format and transfer order to the marking engine is heavily dependent on the exact model used.
I et tidligere liv af Linje Printer Dæmon, printere, var det maskiner der hamrede rækker af ASCII - tekst mekanisk på lange medier, foldet som en zig- zag papir slange, trukket fra kartonfelte nedenunder bordet... Sikke en forskel til i dag!
Back in the early life of the Line Printer Daemon, printers were machines that hammered rows of ASCII text mechanically on to long media, folded as a zig-zag paper snake, drawn from a cardboard box beneath the table... What a difference from today!
RIP: Fra & PostScript; til raster
RIP: From & PostScript; to Raster
Før de endelige rasterbilleder bliver putte på papir skåret ud i ark, skal de beregnes på en eller anden måde ud fra deres abstrakte & PostScript; - repræsentation. Dette er en meget beregnings- intensiv proces. Den kaldes Raster Imaging Process, eller hyppigere RIP).
Before the final raster images are put on paper cut-sheets, they have to be calculated somehow out of their abstract & PostScript; representation. This is a very computing-intensive process. It is called the Raster Imaging Process, more commonly RIP).
Med & PostScript; - printere bliver RIP - ning sørget for i selve enheden. Du sender blot en & PostScript; - fil til den. Raster Imaging Processor (også kaldet RIP) indeni printeren er ansvarlig for (og specialiseret til) at udfylde opgaven at fortolke & PostScript; - sidebeskrivelserne og putte rasterbilledet på papir.
With & PostScript; printers the RIP -ping is taken care of by the device itself. You just send the & PostScript; file to it. The Raster Imaging Processor (also called the RIP) inside the printer is responsible (and specialized) to fulfill quite well this task of interpreting the & PostScript; -page descriptions and put the raster image on paper.
Mindre & PostScript; - enheder har en hardware - RIP indbygget, den skåret i silicon, på en særlig chip. Store professionelle printere har ofte deres RIP implementeret som en software - RIP indeni en dedikeret hurtig & UNIX; - kørt computer, ofte en Sun SPARC Solaris eller en & SGI; & IRIX; maskine.
Smaller & PostScript; devices have a hardware- RIP built in; it is etched in silicon, on a special chip. Big professional printers often have their RIP implemented as a software- RIP inside a dedicated fast & UNIX; run computer, often a Sun SPARC Solaris or a & SGI; & IRIX; machine.
Ghostscript er en software RIP
Ghostscript as a Software RIP
Men hvad sker der hvis du ikke er så heldig at du har en & PostScript; - printer tilgængelig?
But what happens, if you are not lucky enough to have a & PostScript; printer available?
Du bliver nødt til at gøre RIP - ningen før udskriftsdata sendes til markeringsmaskinerne. Du må selv fordøje & PostScript; genereret af dit program på værtsmaskinen (udskriftsklienten). Du bliver nødt til at vide hvordan nøjagtige rasterformat for målprinterens markeringsmaskine skal komponeres.
You need to do the RIP -ing before you send the print data to the marking engine. You need to digest the & PostScript; generated by your application on the host machine (the print client) itself. You need to know how the exact raster format of the target printer 's marking engine must be composed.
Med andre ord, da du ikke kan regne med at printeren selv kan forstå og fortolke & PostScript;, bliver problemet en hel del mere kompliceret. Du har brug for programmel der prøver at løse de involverede problemer for dig.
In other words, as you ca n't rely on the printer to understand and interpret the & PostScript; itself, the issue becomes quite a bit more complicated. You need software that tries to solve for you the issues involved.
Dette er nøjagtigt hvad den allestedsnærværende & ghostscript; - pakke gør for mange & Linux;, * BSD og andre & UNIX; maskiner der har brug for at udskrive til ikke- PostScript; printere: & ghostscript; er en & PostScript; - fortolker, en programmeret RIP der er i stand til at køre mange forskellige enheder.
This is exactly what the omnipresent & ghostscript; package is doing for many & Linux;, *BSD and other & UNIX; boxes that need to print to non-PostScript; printers: & ghostscript; is a & PostScript; interpreter, a software RIP capable of running many different devices.
Drivere og Filtre i almindelighed
Drivers and Filters in General
For at producere rastede bitmaps fra & PostScript; inddata bruges filter - begrebet af & ghostscript;. Der er mange forskellige filtre i & ghostscript;, nogle af dem specialiseret til en bestemt model af en printer. & ghostscript; - filter til bestemte enheder er ofte blevet udviklet uden samtykke eller støtte fra vedkommende der fremstillede enheden. Uden adgang til specifikationerne og dokumentation, var det en pinefuld proces at 'reverse engineer' protokoller og dataformater.
To produce rasterised bitmaps from & PostScript; input, the concept of filters is used by & ghostscript;. There are many different filters in & ghostscript;, some of them specialised for a certain model of printer. & ghostscript; filterspecializedin devices have often been developed without the consent or support of the manufacturer concerned. Without access to the specifications and documentation, it was a very painstaking process to reverse engineer protocols and data formats.
Ikke alle & ghostscript; - filtre virker lige godt for deres printere. Men nogen af de nyere som stp - filtret for Gimp - printprojektet, producerer fremragende resultater der fører til fotografisk kvalitet der er på lige fod eller endog bedre end deres & Microsoft; & Windows; driver- modstykker.
Not all & ghostscript; filters work equally well for their printers. Yet, some of the newer ones, like the stp Filter of the Gimp Print project, produce excellent results leading to photographic quality on a par or even superior to their & Microsoft; & Windows; driver counterparts.
& PostScript; er det de fleste programmer producerer til udskrift i & UNIX; og & Linux;. Filtre er de sande arbejdsheste for et vilkårligt udskriftssystem der. Det er dem der egentlig producerer de rigtige bitmaps fra en vilkårlig & PostScript; - inddata for ikke- PostScript; målmaskiner.
& PostScript; is what most application programs produce for printing in & UNIX; and & Linux;. Filters are the true workhorses of any printing system there. Essentially they produce the right bitmaps from any & PostScript; input for non-PostScript; target engines.
Drivere og filtre og underliggende programmer for CUPS
Drivers and Filters and Backends in CUPS
& CUPS; bruger sine egne filtre selvom filtersystemet er baseret på Ghostscript. Filtrene pstoraster og imagetoraster filters er nemlig direkte afledt fra Ghostscript- kode. & CUPS; har re- organiseret og strømlinjet hele mekanikken i denne gamle kode og organiseret den i nogle få klare adskilte moduler.
& CUPS; uses its own filters, though the filtering system is based on Ghostscript. Namely the pstoraster and the imagetoraster filters are directly derived from Ghostscript code. & CUPS; has reorganised and streamlined the whole mechanics of this legacy code and organised it into a few clear and distinct modules.
Denne næste tegning (lavet ved hjælp af & kivio;) giver et overblik over filtrene og de undeliggende programmer for & CUPS; og hvordan de passer sammen. Flydningen er ovenfra og ned. De underliggende programmer er specielle filtre: de konverterer ikke data til et andet format, men de sender de parate filer til printeren. Der er forskellige underliggende programmer for forskellige overførselsprotokoller.
This next drawing (done with the help of & kivio;) gives an overview of the filters and backends inside & CUPS; and how they fit together. The flow is from top to bottom. Backends are special filters: they do n't convert date to a different format, but they send the ready files to the printer. There are different backends for different transfer protocols.
Køer og udskriftsdæmoner
Spoolers and Printing Daemons
Foruden den tunge del med at filteropgaven til at generere en udskrifts- parat bitmap, vil udskriftsprogrammel altid behøve en kø- mekanisme: dette er for at sætte forskellige jobs op i rækkefølge fra forskellige brugere til forskellige printere og forskellige filtre og sende dem til deres mål på efter hinanden. Udskriftsdæmonen tager sig af alt dette.
Besides the heavy part of the filtering task to generate a print-ready bitmap, any printing software needs to use a SPOOLing mechanism: this is to line up different jobs from different users for different printers and different filters and send them accordingly to the destinations. The printing daemon takes care of all this.
Denne dæmon sørger for husorden: den er også ansvarlig for jobkontrollen: brugere skal have lov til at annullere, stoppe, genstarte & etc; deres jobs (men ikke andre menneskers jobs) og så videre.
This daemon is keeping the house in order: it is also responsible for the job control: users should be allowed to cancel, stop, restart, & etc; their jobs (but not other peoples 's jobs) and so on.
Ekskursion: Hvordan CUPS bruger styrken i & PPD; er
Excursion: How CUPS uses the power of & PPD; s
Nu da du ved hvordan en & PostScript; - sprogfil (som beskriver sidelayout på en måde der stort set er enhedsuafhængig) går over til at blive til et rasterbillede, vil du måske spørge: Nuvel, der er forskellige slags raster- uddataenheder: for det første er de forskellige i opløsning; så kan der være forskellige papirstørrelser (dupleks udskrift, pamfletter, hullet eller klipset uddata med forskellige ark af farvet papir der bliver taget fra forskellige bakker & etc;). Hvordan passer dette ind i modellen med enhedsuafhængig & PostScript;?
Now that you know how a & PostScript; language file (which describes the page layout in a largely device independent way) is transformed into a Raster Image, you might ask: Well, there are different kinds of raster output devices: first they differ in their resolution; then there are the different paper sizes; it goes on with many finishing options (duplex prints, pamphlets, punched and stapled output with different sheets of coloured paper being drawn from different trays, & etc;). How does this fit into our model of device-independent & PostScript;?