Optischer Randausgleich
Sie können gepackte Archive mit der letzten veröffentlichten Scribus-Version bei Sourceforge herunterladen.
Dank Anduin.net gibt es auch ein anonymes SVN-Repositorium, das stündlich aktualisiert wird. Die Verwendung dieses Codes wird nur jenen empfohlen, die immer auf dem allerletzten Stand sein wollen und dabei auch Instabilitäten nicht scheuen.
Der Scribus-1.4-Zweig. Dieser Zweig enthält den Code für die aktuell stabile Version (1.4.x).
Scribus 1.5svn – der experimentelle Zweig. Dieser Zweig enthält den Code für die experimentelle Version (1.5svn). Dieser Code kann hochgradig instabil sein, nicht funktionieren oder sich nicht einmal kompilieren lassen!
Sobald Sie den Quellcode haben, können Sie mit den CMake-Anweisungen fortfahren.
scribus-doc-1.4.0+r17300/doc/de/toolbox.html 0000644 0001750 0001750 00000006360 10673051435 017301 0 ustar malex malexThis is wholly my own personal selection, based fairly narrowly on how capable I find these applications to work with Scribus for print. If you disagree, I most certainly will listen to a well reasoned argument. Be prepared though! Part of my day job is to evaluate similar commercial applications for clients. Some of these apps have been tested within the limitations of modern PC hardware. Example: Telling Xnview to create 10,000 thumbnails at once. So in alphabetical order:
One of the challenges with PDF and EPS viewers on Linux, is that Scribus creates high end PS level 3, PDF 1.4 and PDF 1.6 in the future. Sometimes these features are beyond the capabilities of some open source viewers. Some of these features are necessary for reliable commercial printing and only supported in commercial pre-press or DTP tools. Four years of working with Scribus has led me to the strongly held conclusion that the following three viewers are the most reliable at displaying PS/EPS/PDF created by Scribus:
pstoedit and epstool. For more detailed notes and hints: GSview. I consider it an essential tool for DTP on Linux.If any other PDF or EPS viewer you choose cannot display PDFs from Scribus, but they do view properly in Acrobat Reader 5+, file a bug with the upstream author. I cannot stress this enough. In virtually all cases I have tested, it is a limitation of the viewing application. Scribus PDFs are tested daily with specialist pre-press software to validate their adherence to the published PDF specifications.
scribus-doc-1.4.0+r17300/doc/de/toolbox2.html 0000644 0001750 0001750 00000005067 10673051435 017366 0 ustar malex malexEin weiterer nützlicher PDF-Betrachter, der sich für Scribus eignet, ist GSview – eigentlich ein grafischer Betrachteraufsatz für Ghostscript. Die jüngste Version (4.8) mit Ghostscript ab Version 7.07 kooperiert sehr ordentlich und kann nicht nur PS nach PDF umwandeln, sondern auch EPS, PS und PDF-Dateien anzeigen und konvertieren – neben anderen Funktionen. Die Version 4.3 ist die erste, die wirklich gut unter Linux funktioniert (ursprünglich war sie für ein anderes Betriebssystem entwickelt worden). Weitere Einzelheiten finden sich unter GSview und Scribus.
KPDF ab 3.4/XPDF: Die in KDE 3.4 enthaltene KPDF-Version zeigt mir, daß es die Entwickler offensichtlich "kapiert haben". Auf XPDF 3.x basierend, zeigt sie viele nette Ansätze und ist offenbar recht flott bei der Darstellung im Vergleich zu den verschiedenen Reader-Versionen von Adobe. Dies sage ich nicht als KDE-Jünger, sondern nachdem es eine Zeitlang benutzt habe. Hier noch der Hinweis, daß Sie in den "Einstellungen" nachschauen und in den Leistungsoptionen "Aggresiv" aktivieren sollten, falls Sie über den erforderlichen Arbeitsspeicher verfügen, denn das beschleunigt die Darstellung erheblich. Trotzdem mögen Sie auf XPDF ab Version 3.00 von FooLabs nicht verzichten wollen, denn es enthält Kommandozeilenwerkzeuge zur Umwandlung von PDF nach PS. Um dafür zu sorgen, daß Xpdf ordentlich eingebettete Schriftarten in allen PDF-Dokumenten korrekt darstellt (nicht nur jene aus Scribus), sollten Sie in den XPDF-Handbuchseiten (man pages) nachlesen, wie man die Font-Pfade in der .xpdfrc-Datei richtig einstellt. Andernfalls werden eingebettete Schriftarten u. U. nicht richtig angezeigt. Eine bekannte Einschränkung ist die fehlende Unterstützung für Transparenzen in von Scribus erzeugten PDF-Dokumenten.
scribus-doc-1.4.0+r17300/doc/de/readme.html 0000644 0001750 0001750 00000022721 11707342137 017050 0 ustar malex malexHier finden Sie einen Überblick über die wesentlichen Erweiterungen von Scribus 1.4 im Vergleich zur letzten offiziell stabilen Version 1.3.3.14.
Beachten Sie, daß sich das Dateiformat geändert hat und nicht rückwärtskompatibel ist. Sie können daher Dateien aus Version 1.4 nicht mit 1.3.3.14 oder einer früheren Version öffnen.
/opt und 1.4 nach /usr/local oder $home/bin zu installieren. Wenn Sie Scribus aus dem Quellcode kompilieren, können Sie dazu -DCMAKE_INSTALL_PREFIX:PATH= verwenden, um das Zielverzeichnis festzulegen. Auf anderen Plattformen können Sie das Zielverzeichnis während des Installationsprozesses der Binärpakete auswählen.Die Portierung auf Version 4 des Qt-Toolkits war eine der größten Herausforderungen bei der Entwicklung von Version 1.4, doch der Aufwand hat sich gelohnt, denn er hat es uns ermöglicht, endlich Versionen für Mac OS X und OS/2 bzw. eComStation anzubieten, die hinsichtlich ihrer Funktionalität nicht mehr hinter den Linux- und Windows-Pendants zurückstehen.
|
Optischer Randausgleich |
 |
Boolsche Pfadoperationen |
 |
Das Ersetzen von Füllfarben |
 |
Editor für Renderrahmen |
 |
Adobe-Illustrator-Import |
 |
Der neue Bildmanager |
Viel Arbeit wurde auf zahllose große und kleine Verbesserungen der Bedienbarkeit überall im Programm verwendet, z.B.:
This module is the Python interface for Scribus. It provides functions to control scribus and to manipulate objects on the canvas. Each function is documented individually below. A few things are common across most of the interface. Most functions operate on frames. Frames are identified by their name, a string - they are not real Python objects. Many functions take an optional (non-keyword) parameter, a frame name. Many exceptions are also common across most functions. These are not currently documented in the docstring for each function.
Details of what exceptions each function may throw are provided on the function's documentation.
| class NameExistsError(ScribusException) |
|
Methods inherited from exceptions.Exception:
|
| class NoDocOpenError(ScribusException) |
|
Methods inherited from exceptions.Exception:
|
| class NoValidObjectError(ScribusException) |
|
Methods inherited from exceptions.Exception:
|
| class NotFoundError(ScribusException) |
|
Methods inherited from exceptions.Exception:
|
| class ScribusException(exceptions.Exception) |
Methods inherited from exceptions.Exception:
|
| class WrongFrameTypeError(ScribusException) |
|
Methods inherited from exceptions.Exception:
|
changeColor("name", c, m, y, k)
Changes the color "name" to the specified CMYK value. The color value is defined via four components c = Cyan, m = Magenta, y = Yellow and k = Black. Color components should be in the range from 0 to 255.
May raise NotFoundError if the named color wasn't found.
May raise ValueError if an invalid color name is specified.closeDoc()
Closes the current document without prompting to save.
May throw NoDocOpenError if there is no document to closecreateBezierLine(list, ["name"]) -> string
Creates a new bezier curve and returns its name. The points for the bezier curve are stored in the list "list" in the following order:
[x1, y1, kx1, ky1, x2, y2, kx2, ky2...xn. yn, kxn. kyn]
In the points list, x and y mean the x and y coordinates of the point and kx and ky meaning the control point for the curve. The coordinates are given in the current measurement units of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name for further access to that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.
May raise ValueError if an insufficient number of points is passed or if the number of values passed don't group into points without leftovers.createEllipse(x, y, width, height, ["name"]) -> string
Creates a new ellipse on the current page and returns its name. The coordinates are given in the current measurement units of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name for further referencing of that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.createImage(x, y, width, height, ["name"]) -> string
Creates a new picture frame on the current page and returns its name. The coordinates are given in the current measurement units of the document. "name" should be a unique identifier for the object because you need this name for further access to that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.createLayer(layer)
Creates a new layer with the name "name".
May raise ValueError if the layer name isn't acceptable.createLine(x1, y1, x2, y2, ["name"]) -> string
Creates a new line from the point(x1, y1) to the point(x2, y2) and returns its name. The coordinates are given in the current measurement unit of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name for further access to that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.createPathText(x, y, "textbox", "beziercurve", ["name"]) -> string
Creates a new pathText by merging the two objects "textbox" and "beziercurve" and returns its name. The coordinates are given in the current measurement unit of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name for further access to that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.
May raise NotFoundError if one or both of the named base object don't exist.createPolyLine(list, ["name"]) -> string
Creates a new polyline and returns its name. The points for the polyline are stored in the list "list" in the following order: [x1, y1, x2, y2...xn. yn]. The coordinates are given in the current measurement units of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name for further access to that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.
May raise ValueError if an insufficient number of points is passed or if the number of values passed don't group into points without leftovers.createPolygon(list, ["name"]) -> string
Creates a new polygon and returns its name. The points for the polygon are stored in the list "list" in the following order: [x1, y1, x2, y2...xn. yn]. At least three points are required. There is no need to repeat the first point to close the polygon. The polygon is automatically closed by connecting the first and the last point. The coordinates are given in the current measurement units of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name for further access to that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.
May raise ValueError if an insufficient number of points is passed or if
the number of values passed don't group into points without leftovers.createRect(x, y, width, height, ["name"]) -> string
Creates a new rectangle on the current page and returns its name. The coordinates are given in the current measurement units of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name to reference that object in future. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.createText(x, y, width, height, ["name"]) -> string
Creates a new text frame on the actual page and returns its name. The coordinates are given in the actual measurement unit of the document (see UNIT constants). "name" should be a unique identifier for the object because you need this name for further referencing of that object. If "name" is not given Scribus will create one for you.
May raise NameExistsError if you explicitly pass a name that's already used.currentPage() -> integer
Returns the number of the current working page. Page numbers are counted from 1 upwards, no matter what the displayed first page number of your document is.defineColor("name", c, m, y, k)
Defines a new color "name". The color Value is defined via four components:
c = Cyan, m = Magenta, y = Yellow and k = Black. Color components should be in the range from 0 to 255.
May raise ValueError if an invalid color name is specified.deleteColor("name", "replace")
Deletes the color "name". Every occurence of that color is replaced by the color "replace". If not specified, "replace" defaults to the color "None" - transparent.
deleteColor works on the default document colors if there is no document open. In that case, "replace", if specified, has no effect.
May raise NotFoundError if a named color wasn't found.
May raise ValueError if an invalid color name is specified.deleteLayer("layer")
Deletes the layer with the name "layer". Nothing happens if the layer doesn't exists or if it's the only layer in the document.
May raise NotFoundError if the layer can't be found.
May raise ValueError if the layer name isn't acceptable.deleteObject(["name"])
Deletes the item with the name "name". If "name" is not given the currently selected item is deleted.deletePage(nr)
Deletes the given page. Does nothing if the document contains only one page. Page numbers are counted from 1 upwards, no matter what the displayed first page number is.
May raise IndexError if the page number is out of rangedeleteText(["name"])
Deletes any text in the text frame "name". If there is some text selected, only the selected text will be deleted. If "name" is not given the currently selected item is used.deselectAll()
Deselects all objects in the whole document.docChanged(bool)
Enable/disable save icon in the Scribus icon bar and the Save menu item. It's useful to call this procedure when you're changing the document, because Scribus won't automatically notice when you change the document using a script.fileDialog("caption", ["filter", "defaultname" ,haspreview, issave]) -> string with filename
Shows a File Open dialog box with the caption "caption". Files are filtered with the filter string "filter". A default filename or file path can also supplied, leave this string empty when you don't want to use it. A value of True for haspreview enables a small preview widget in the FileSelect box. When the issave parameter is set to True the dialog acts like a "Save As" dialog otherwise it acts like a "File Open Dialog". The default for both of the opional parameters is False.
The filter, if specified, takes the form 'comment (*.type *.type2 ...)'.
For example 'Images (*.png *.xpm *.jpg)'.
Refer to the Qt-Documentation for QFileDialog for details on filters.
Example: fileDialog('Open input', 'CSV files (*.csv)')
Example: fileDialog('Save report', defaultname='report.txt', issave=True)getActiveLayer() -> string
Returns the name of the current active layer.getAllObjects() -> list
Returns a list containing the names of all objects on the current page.getAllStyles() -> list
Return a list of the names of all paragraph styles in the current document.getAllText(["name"]) -> string
Returns the text of the text frame "name" and of all text frames which are linked with this frame. If this textframe has some text selected, the selected text is returned. If "name" is not given the currently selected item is used.getColor("name") -> tuple
Returns a tuple (C, M, Y, K) containing the four color components of the color "name" from the current document. If no document is open, returns the value of the named color from the default document colors.
May raise NotFoundError if the named color wasn't found.
May raise ValueError if an invalid color name is specified.getColorAsRGB("name") -> tuple
Returns a tuple (R,G,B) containing the three color components of the color "name" from the current document, converted to the RGB colour space. If no document is open, returns the value of the named color from the default document colors.
May raise NotFoundError if the named color wasn't found. May raise ValueError if an invalid color name is specified.
getColorNames() -> list
Returns a list containing the names of all defined colors in the document. If no document is open, returns a list of the default document colors.getColumnGap(["name"]) -> float
Returns the column gap size of the text frame "name" expressed in points. If "name" is not given the currently selected item is used.getColumns(["name"]) -> integer
Gets the number of columns of the text frame "name". If "name" is not given the currently selected item is used.getCornerRadius(["name"]) -> integer
Returns the corner radius of the object "name". The radius is expressed in points. If "name" is not given the currently selected item is used.getFillColor(["name"]) -> string
Returns the name of the fill color of the object "name". If "name" is not given the currently selected item is used.getFillShade(["name"]) -> integer
Returns the shading value of the fill color of the object "name". If "name" is not given the currently selected item is used.getFont(["name"]) -> string
Returns the font name for the text frame "name". If this text frame has some text selected the value assigned to the first character of the selection is returned. If "name" is not given the currently selected item is used.getFontNames() -> list
Returns a list with the names of all available fonts.getFontSize(["name"]) -> float
Returns the font size in points for the text frame "name". If this text frame has some text selected the value assigned to the first character of the selection is returned. If "name" is not given the currently selected item is used.getGuiLanguage() -> string
Returns a string with the -lang value.getHGuides() -> list
Returns a list containing positions of the horizontal guides. Values are in the document's current units - see UNIT_<type> constants.getImageName(["name"]) -> string
Returns the filename for the image in the image frame. If "name" is not given the currently selected item is used.getImageScale(["name"]) -> (x,y)
Returns a (x, y) tuple containing the scaling values of the image frame "name". If "name" is not given the currently selected item is used.getLayers() -> list
Returns a list with the names of all defined layers.getLineEnd(["name"]) -> integer (see constants)
Returns the line cap style of the object "name". If "name" is not given the currently selected item is used. The cap types are:
CAP_FLAT, CAP_ROUND, CAP_SQUAREgetLineColor(["name"]) -> string
Returns the name of the line color of the object "name". If "name" is not given the currently selected item is used.getLineJoin(["name"]) -> integer (see contants)
Returns the line join style of the object "name". If "name" is not given the currently selected item is used. The join types are:
JOIN_BEVEL, JOIN_MITTER, JOIN_ROUNDgetLineShade(["name"]) -> integer
Returns the shading value of the line color of the object "name". If "name" is not given the currently selected item is used.getLineSpacing(["name"]) -> float
Returns the line spacing ("leading") of the text frame "name" expressed in points. If "name" is not given the currently selected item is used.getLineStyle(["name"]) -> integer (see constants)
Returns the line style of the object "name". If "name" is not given the currently selected item is used. Line style constants are:
LINE_DASH, LINE_DASHDOT, LINE_DASHDOTDOT, LINE_DOT, LINE_SOLIDgetLineWidth(["name"]) -> integer
Returns the line width of the object "name". If "name" is not given the currently selected Item is used.getPageItems() -> list
Returns a list of tuples with items on the current page. The tuple is:
(name, objectType, order) E.g. [('Text1', 4, 0), ('Image1', 2, 1)]
means that object named 'Text1' is a text frame (type 4) and is the first at
the page...getPageMargins()
Returns the page margins as a (left, right, top, bottom) tuple in the current units. See UNIT_<type> constants and getPageSize().getPageSize() -> tuple
Returns a tuple with page dimensions measured in the document's current units.
See UNIT_<type> constants and getPageMargins()getPosition(["name"]) -> (x,y)
Returns a (x, y) tuple with the position of the object "name". If "name" is not given the currently selected item is used. The position is expressed in the actual measurement unit of the document - see UNIT_<type> for reference.getRotation(["name"]) -> integer
Returns the rotation of the object "name". The value is expressed in degrees, and clockwise is positive. If "name" is not given the currently selected item is used.getSelectedObject([nr]) -> string
Returns the name of the selected object. "nr" if given indicates the number of the selected object, e.g. 0 means the first selected object, 1 means the second selected Object and so on.getSize(["name"]) -> (width,height)
Returns a (width, height) tuple with the size of the object "name". If "name" is not given the currently selected item is used. The size is expressed in the current measurement unit of the document - see UNIT_<type> for reference.getText(["name"]) -> string
Returns the text of the text frame "name". If this text frame has some text selected, the selected text is returned. All text in the frame, not just currently visible text, is returned. If "name" is not given the currently selected item is used.getLineColor(["name"]) -> string
Returns the name of the line color of the object "name".If "name" is not given the currently selected item is used.getTextLength(["name"]) -> integer
Returns the length of the text in the text frame "name". If "name" is not given the currently selected item is used.getLineShade(["name"]) -> integer
Returns the shading value of the line color of the object "name". If "name" is not given the currently selected item is used.getUnit() -> integer (Scribus unit constant)
Returns the measurement units of the document. The returned value will be one of the UNIT_* constants:
UNIT_INCHES, UNIT_MILLIMETERS, UNIT_PICAS, UNIT_POINTS.getVGuides()
See getHGuides.getXFontNames() -> list of tuples
Returns a larger font info. It's a list of the tuples with:
[ (Scribus name, Family, Real name, subset (1|0), embed PS (1|0), font file), (...), ... ]Scribus internal.gotoPage(nr)
Moves to the page "nr" (that is, makes the current page "nr"). Note that gotoPage doesn't (curently) change the page the user's view is displaying, it just sets the page that script commands will operates on.
May raise IndexError if the page number is out of range.groupObjects(list)
Groups the objects named in "list" together. "list" must contain the names of the objects to be grouped. If "list" is not given the currently selected items are used.haveDoc() -> bool
Returns true if there is a document open.insertText("text", pos, ["name"])
Inserts the text "text" at the position "pos" into the text frame. Text must be UTF encoded (see setText() as reference) The first character has an index of 0. "name" If "name" is not given the currently selected Item is used.
May throw IndexError for an insertion out of bounds.isLayerPrintable("layer") -> bool
Returns whether the layer "layer" is printable or not, a value of True means that the layer "layer" can be printed, a value of False means that printing the layer "layer" is disabled.
May raise NotFoundError if the layer can't be found.
May raise ValueError if the layer name isn't acceptable.isLayerPrintable("layer") -> bool
Returns whether the Layer "layer" is visible or not, a value of True means that the layer "layer" is visible, a value of False means that the layer "layer" is invisible.
May raise NotFoundError if the layer can't be found.
May raise ValueError if the layer name isn't acceptable.isLocked(["name"]) -> bool
Returns true if is the object "name" locked. If "name" is not given the currently selected item is used.isPDFBookmark(["name"]) -> bool
Returns true if the text frame "name" is a PDF bookmark. If "name" is not given the currently selected item is used.
May raise WrongFrameTypeError if the target frame is not a text frame.
linkTextFrames("fromname", "toname")
Link two text frames. The frame named "fromname" is linked to the frame named "toname". The target frame must be an empty text frame and must not link to or be linked from any other frames already.
May throw ScribusException if linking rules are violated.loadImage("filename" [, "name"])
Loads the picture "picture" into the image frame "name". If "name" is not given the currently selected item is used.
May raise WrongFrameTypeError if the target frame is not an image frameloadStylesFromFile("filename")
Loads paragraph styles from the Scribus document at "filename" into the current document.lockObject(["name"]) -> bool
Locks the object "name" if it's unlocked or unlock it if it's locked. If "name" is not given the currently selected item is used. Returns true if locked.messageBox("caption", "message", icon=ICON_NONE, button1=BUTTON_OK|BUTTONOPT_DEFAULT, button2=BUTTON_NONE, button3=BUTTON_NONE) -> integer
Displays a message box with the title "caption", the message "message", and an icon "icon" and up to 3 buttons. By default no icon is used and a single button, OK, is displayed. Only the caption and message arguments are required, though setting an icon and appropriate button(s) is strongly recommended. The message text may contain simple HTML-like markup.
Returns the number of the button the user pressed. Button numbers start at 1.
For the icon and the button parameters there are predefined constants available with the same names as in the Qt Documentation. These are the BUTTON_* and ICON_* constants defined in the module. There are also two extra constants that can be binary-ORed with button constants:
BUTTONOPT_DEFAULT Pressing enter presses this button.
BUTTONOPT_ESCAPE Pressing escape presses this button.
Usage examples:
result = messageBox('Script failed',
'This script only works when you have a text frame selected.',
ICON_ERROR)
result = messageBox('Monkeys!', 'Something went ook! <i>Was it a monkey?</i>',
ICON_WARNING, BUTTON_YES|BUTTONOPT_DEFAULT,
BUTTON_NO, BUTTON_IGNORE|BUTTONOPT_ESCAPE)
Defined button and icon constants:
BUTTON_NONE, BUTTON_ABORT, BUTTON_CANCEL, BUTTON_IGNORE, BUTTON_NO,
BUTTON_NOALL, BUTTON_OK, BUTTON_RETRY, BUTTON_YES, BUTTON_YESALL,
ICON_NONE, ICON_INFORMATION, ICON_WARNING, ICON_CRITICAL.messagebarText("string")
Writes the "string" into the Scribus message bar (status line). The text
must be UTF8 encoded or 'unicode' string(recommended).moveObject(dx, dy [, "name"])
Moves the object "name" by dx and dy relative to its current position. The
distances are expressed in the current measurement unit of the document (see
UNIT constants). If "name" is not given the currently selected item is used.
If the object "name" belongs to a group, the whole group is moved.moveObjectAbs(x, y [, "name"])
Moves the object "name" to a new location. The coordinates are expressed in
the current measurement unit of the document (see UNIT constants). If "name"
is not given the currently selected item is used. If the object "name"
belongs to a group, the whole group is moved.newDoc(size, margins, orientation, firstPageNumber,
unit, facingPages, firstSideLeft) -> bool
Creates a new document and returns true if successful. The parameters have the
following meaning:
size = A tuple (width, height) describing the size of the document. You can
use predefined constants named PAPER_<paper_type> e.g. PAPER_A4 etc.
margins = A tuple (left, right, top, bottom) describing the document
margins
orientation = the page orientation - constants PORTRAIT, LANDSCAPE
firstPageNumber = is the number of the first page in the document used for
pagenumbering. While you'll usually want 1, it's useful to have higher
numbers if you're creating a document in several parts.
unit: this value sets the measurement units used by the document. Use a
predefined constant for this, one of: UNIT_INCHES, UNIT_MILLIMETERS,
UNIT_PICAS, UNIT_POINTS.
facingPages = FACINGPAGES, NOFACINGPAGES
firstSideLeft = FIRSTPAGELEFT, FIRSTPAGERIGHT
The values for width, height and the margins are expressed in the given unit
for the document. PAPER_* constants are expressed in points. If your document
is not in points, make sure to account for this.
example: newDoc(PAPER_A4, (10, 10, 20, 20), LANDSCAPE, 1, UNIT_POINTS,
FACINGPAGES, FIRSTPAGERIGHT)newDocDialog() -> bool
Displays the "New Document" dialog box. Creates a new document if the user accepts the settings. Does not create a document if the user presses cancel. Returns true if a new document was created.newPage(where [,"template"])
Creates a new page. If "where" is -1 the new Page is appended to the document, otherwise the new page is inserted before "where". Page numbers are counted from 1 upwards, no matter what the displayed first page number of your document is. The optional parameter "template" specifies the name of the template page for the new page.
May raise IndexError if the page number is out of rangeobjectExists(["name"]) -> bool
Test if an object with specified name really exists in the document. The optional parameter is the object name. When no object name is given, returns True if there is something selected.openDoc("name")
Opens the document "name".
May raise ScribusError if the document could not be opened.pageCount() -> integer
Returns the number of pages in the document.getPageSize() -> tuple
Returns a tuple with page dimensions measured in the document's current units.
See UNIT_<type> constants and getPageMargins()progressReset()
Cleans up the Scribus progress bar previous settings. It is called before the new progress bar use. See progressSet.progressSet(nr)
Set the progress bar position to "nr", a value relative to the previously set progressTotal. The progress bar uses the concept of steps; you give it the total number of steps and the number of steps completed so far and it will display the percentage of steps that have been completed. You can specify the total number of steps with progressTotal(). The current number of steps is set with progressSet(). The progress bar can be rewound to the beginning with progressReset(). [based on info taken from Trolltech's Qt docs]progressTotal(max)
Sets the progress bar's maximum steps value to the specified number. See progressSet.redrawAll()
Redraws all pages.rendeFont("name", "filename", "sample", size, format="PPM") -> bool
Creates an image preview of font "name" with given text "sample" and size. Image is saved into "filename". Returns true when success. The optional "format" argument specifies the image format to generate, and supports any format allowed by QPixmap.save(). Common formats are PPM, JPEG, PNG and XPM.
May raise NotFoundError if the specified font can't be found. May raise ValueError if an empty sample or filename is passed.
replaceColor("name", "replace")
Every occurence of the color "name" is replaced by the color "replace".
May raise NotFoundError if a named color wasn't found.
May raise ValueError if an invalid color name is specified.Scribus internal.rotateObject(rot [, "name"])
Rotates the object "name" by "rot" degrees relatively. The object is rotated by the vertex that is currently selected as the rotation point - by default, the top left vertext at zero rotation. Positive values mean counter clockwise rotation when the default rotation point is used. If "name" is not given the currently selected item is used.rotateObjectAbs(rot [, "name"])
Sets the rotation of the object "name" to "rot". Positive values mean counter clockwise rotation. If "name" is not given the currently selected item is used.saveDoc()
Saves the current document with its current name, returns true if successful. If the document has not already been saved, this may bring up an interactive save file dialog.
If the save fails, there is currently no way to tell.saveDocAs("name")
Saves the current document under the new name "name" (which may be a full or relative path).
May raise ScribusError if the save fails.savePageAsEPS("name")
Saves the current page as an EPS to the file "name".
May raise ScribusError if the save failed.scaleGroup(factor [,"name"])
Scales the group the object "name" belongs to. Values greater than 1 enlarge the group, values smaller than 1 make the group smaller e.g a value of 0.5 scales the group to 50 % of its original size, a value of 1.5 scales the group to 150 % of its original size. The value for "factor" must be greater than 0. If "name" is not given the currently selected item is used.
May raise ValueError if an invalid scale factor is passed.scaleImage(x, y [, "name"])
Sets the scaling factors of the picture in the image frame "name". If "name" is not given the currently selected item is used. A number of 1 means 100 %.
May raise WrongFrameTypeError if the target frame is not an image frameselectObject("name")
Selects the object with the given "name".selectText(start, count, ["name"])
Selects "count" characters of text in the text frame "name" starting from the character "start". Character counting starts at 0. If "count" is zero, any text selection will be cleared. If "name" is not given the currently selected item is used.
May throw IndexError if the selection is outside the bounds of the text.selectionCount() -> integer
Returns the number of selected objects.sentToLayer("layer" [, "name"])
Sends the object "name" to the layer "layer". The layer must exist. If "name" is not given the currently selected item is used.
May raise NotFoundError if the layer can't be found.
May raise ValueError if the layer name isn't acceptable.setActiveLayer("name")
Sets the active layer to the layer named "name".
May raise NotFoundError if the layer can't be found.
May raise ValueError if the layer name isn't acceptable.setColumnGap(size, ["name"])
Sets the column gap of the text frame "name" to the value "size". If "name" is not given the currently selected item is used.
May throw ValueError if the column gap is out of bounds (must be positive).setColumns(nr, ["name"])
Sets the number of columns of the text frame "name" to the integer "nr". If "name" is not given the currently selected item is used.
May throw ValueError if number of columns is not at least one.setCornerRadius(radius, ["name"])
Sets the corner radius of the object "name". The radius is expressed in points. If "name" is not given the currently selected item is used.
May raise ValueError if the corner radius is negative.setCursor()
[UNSUPPORTED!] This might break things, so steer clear for now.setDocType(facingPages, firstPageLeft)
Sets the document type. To get facing pages set the first parameter to FACINGPAGES, to switch facingPages off use NOFACINGPAGES instead. If you want to be the first page a left side set the second parameter to FIRSTPAGELEFT, for a right page use FIRSTPAGERIGHT.setFillColor("color", ["name"])
Sets the fill color of the object "name" to the color "color". "color" is the name of one of the defined colors. If "name" is not given the currently selected item is used.setFillShade(shade, ["name"])
Sets the shading of the fill color of the object "name" to "shade". "shade" must be an integer value in the range from 0 (lightest) to 100 (full Color intensity). If "name" is not given the currently selected Item is used. May raise ValueError if the fill shade is out of bounds.setFont("font", ["name"])
Sets the font of the text frame "name" to "font". If there is some text selected only the selected text is changed. If "name" is not given the currently selected item is used.
May throw ValueError if the font cannot be found.setFontSize(size, ["name"])
Sets the font size of the text frame "name" to "size". "size" is treated as a value in points. If there is some text selected only the selected text is changed. "size" must be in the range 1 to 512. If "name" is not given the currently selected item is used.
May throw ValueError for a font size that's out of bounds.setGradientFill(type, "color1", shade1, "color2", shade2, ["name"])
Sets the gradient fill of the object "name" to type. Color descriptions are the same as for setFillColor() and setFillShade(). See the constants for available types (FILL_<type>).setHGuides(list)
Sets horizontal guides. Input parameter must be a list of guide positions measured in the current document units - see UNIT_<type> constants.
Example: setHGuides(getHGuides() + [200.0, 210.0] # add new guides without any lost
setHGuides([90,250]) # replace current guides entirelysaveDocAs("author", "info", "description") -> bool
Sets the document information. "Author", "Info", "Description" are strings.setLayerPrintable("layer", printable)
Sets the layer "layer" to be printable or not. If is the printable set to false the layer won't be printed.
May raise NotFoundError if the layer can't be found.
May raise ValueError if the layer name isn't acceptable.setLayerVisible("layer", visible)
Sets the layer "layer" to be visible or not. If is the visible set to false the layer is invisible.
May raise NotFoundError if the layer can't be found.
May raise ValueError if the layer name isn't acceptable.setLineEnd(endtype, ["name"])
Sets the line cap style of the object "name" to the style "cap".
If "name" is not given the currently selected item is used. There are predefined constants for "cap" - CAP_<type>.setLineColor("color", ["name"])
Sets the line color of the object "name" to the color "color". If "name" is not given the currently selected item is used.setLineJoin(join, ["name"])
Sets the line join style of the object "name" to the style "join". If "name" is not given the currently selected item is used. There are predefined constants for join - JOIN_<type>.setLineShade(shade, ["name"])
Sets the shading of the line color of the object "name" to "shade". "shade" must be an integer value in the range from 0 (lightest) to 100 (full color intensity). If "name" is not given the currently selected item is used.
May raise ValueError if the line shade is out of bounds.setLineSpacing(size, ["name"])
Sets the line spacing ("leading") of the text frame "name" to "size". "size" is a value in points. If "name" is not given the currently selected item is used.
May throw ValueError if the line spacing is out of bounds.setLineStyle(style, ["name"])
Sets the line style of the object "name" to the style "style". If "name" is not given the currently selected item is used. There are predefined constants for "style" - LINE_<style>.setLineWidth(width, ["name"])
Sets line width of the object "name" to "width". "width" must be in the range from 0.0 to 12.0 inclusive, and is measured in points. If "name" is not given the currently selected item is used.
May raise ValueError if the line width is out of bounds.setMargins(lr, rr, tr, br)
Sets the margins of the document, Left(lr), Right(rr), Top(tr) and Bottom(br) margins are given in the measurement units of the document - see UNIT_<type> constants.setMultiLine("namedStyle", ["name"])
Sets the line style of the object "name" to the named style "namedStyle". If "name" is not given the currently selected item is used.
May raise NotFoundError if the line style doesn't exist.setPDFBookmark("toggle", ["name"])
Sets wether (toggle = 1) the text frame "name" is a bookmark nor not. If "name" is not given the currently selected item is used.
May raise WrongFrameTypeError if the target frame is not a text frame.
setRedraw(bool)
Disables page redraw when bool = False, otherwise redrawing is enabled. This change will persist even after the script exits, so make sure to call setRedraw(True) in a finally: clause at the top level of your script.setScaleImageToFrame(scaletoframe, proportional=None, name=<selection>)
Sets the scale to frame on the selected or specified image frame to `scaletoframe'. If `proportional' is specified, set fixed aspect ratio scaling to `proportional'. Both `scaletoframe' and `proportional' are boolean.
May raise WrongFrameTypeError.
setStyle("style" [, "name"])
Apply the named "style" to the object named "name". If is no object name given, it's applied on the selected object.setText("text", ["name"])
Sets the text of the text frame "name" to the text of the string "text". Text must be UTF8 encoded - use e.g. unicode(text, 'iso-8859-2'). See the FAQ for more details. If "name" is not given the currently selected item is used.setTextAlignment(align, ["name"])
Sets the text alignment of the text frame "name" to the specified alignment. If "name" is not given the currently selected item is used. "align" should be one of the ALIGN_ constants defined in this module - see dir(scribus).
May throw ValueError for an invalid alignment constant.setTextColor("color", ["name"])
Sets the text color of the text frame "name" to the color "color". If there is some text selected only the selected text is changed. If "name" is not given the currently selected item is used.setTextShade(shade, ["name"])
Sets the shading of the text color of the object "name" to "shade". If there is some text selected only the selected text is changed. "shade" must be an integer value in the range from 0 (lightest) to 100 (full color intensity). If "name" is not given the currently selected item is used.setTextStroke("color", ["name"])
Set "color" of the text stroke. If "name" is not given the currently selected item is used.setUnit(type)
Changes the measurement unit of the document. Possible values for "unit" are defined as constants UNIT_<type>.
May raise ValueError if an invalid unit is passed.setVGuides()
See setHGuides.sizeObject(width, height [, "name"])
Resizes the object "name" to the given width and height. If "name" is not given the currently selected item is used.messagebarText("string")
Writes the "string" into the Scribus message bar (status line). The text must be UTF8 encoded or 'unicode' string(recommended).textFlowsAroundFrame("name" [, state])
Enables/disables "Text Flows Around Frame" feature for object "name". Called with parameters string name and optional boolean "state". If "state" is not passed, text flow is toggled.traceText(["name"])
Convert the text frame "name" to outlines. If "name" is not given the currently selected item is used.unGroupObjects("name")
Destructs the group the object "name" belongs to.If "name" is not given the currently selected item is used.unlinkTextFrames("name")
Remove the specified (named) object from the text frame flow/linkage. If the frame was in the middle of a chain, the previous and next frames will be connected, eg 'a->b->c' becomes 'a->c' when you unlinkTextFrames(b)'
May throw ScribusException if linking rules are violated.valueDialog(caption, message [,defaultvalue]) -> string
Shows the common 'Ask for string' dialog and returns its value as a string
Parameters: window title, text in the window and optional 'default' value.
Example: valueDialog('title', 'text in the window', 'optional')Das von den Toten auferstandene Krita, eine Anwendung aus der KDE Office Suite, ist mittlerweile ein wunderbares Programm, das auf das natürliche Malen am Computer spezialisiert ist. Es verwendet das digitale Äquivalent eines Pinsels auf dem Bildschirm, und es verfügt über innovative und höchst interessante Funktionen, etwa die Möglichkeit, den Trocknungsprozeß von echten Farben zu emulieren, oder Werzeuge zum präzisen Bearbeiten von Pinselstrichen. Dies alleine wäre schon Grund genug, es Ihrem Werkzeugkasten für gelegentliche künstlerische Arbeiten hinzuzufügen.
Für Scribus-Anwender ist darüber hinaus jedoch die große Zahl der unterstützten Bildformate und Farbräume interessant. Krita kann nicht nur im RGB-Farbraum arbeiten, sondern auch in CMYK, Graustufen (bis zu 16 Bit) und L*a*b. Dazu verwendet es wie Scribus littlecms. Krita bietet eine vollständige und einfache Umwandlung von RGB nach CMYK. Außerdem kann es 16-Bit-Bilder in 8-Bit-Bilder umwandeln, so daß man sie in Scribus verwenden kann (Scribus wird 16 Bit und vielleicht noch größere Farbtiefen in der Zukunft unterstützen).
Beachten Sie:
 |
"Umbruchkontrolle für Abkürzungen" ist ein spezielles Plug-in, das geschützte Leerzeichen vor oder nach Abkürzungen einfügt.
Die Handhabung hängt von den typographischen Regeln einer Sprache ab. Im Tschechischen, Polnischen und Slowakischen ist es beispielweise unzulässing, Konjunktionen, die nur aus einem Wort bestehen, am Ende einer Zeile stehen zu lassen, die länger als 25 Zeichen ist. Ein verbreitetes Problem sind Maß- und Gewichtangaben, bei denen aus offensichtlichen Gründen, ein geschütztes Leerzeichen zwischen der Zahl und der verwendeten Einheit stehen sollte. Darüber hinaus sollten Abkürzungen für akdemische Titel und militärische Rangbezeichnungen nicht vom Namen ihrer Träger getrennt werden.
Auch wenn Scribus nicht jeden nationalen Standard berücksichtigen kann, hat sich einer der Scribus-Entwickler , Petr Vaněk, entschlossen, Scribus-Anwendern ein Plug-in zur Verfügung zu stellen, das leicht an die eigenen Bedürfnisse angepaßt werden kann.
Der Screenshot enthält einen Beispieltext, der eine Abkürzung vor dem Anwenden des Plug-ins zeigt.
Textbeispiel vor dem Ausführen des Plug-ins
 |
Derselbe Text, nachdem ein geschütztes Leerzeichen eingefügt wurde. Das rot markierte Wort "Mr" steht nun in der nächsten Zeile, weil das normale Leerzeichen durch ein geschütztes ersetzt wurde.
Textbeispiel nach dem Ausführen des Plug-ins
 |
Führen Sie Extras > Umbruchkontrolle für Abkürzungen aus.
Die Umbruchkontrolle für Abkürzungen in Scribus
 |
Der Dialog für die Umbruchkontrolle
 |
Die Umbruchkontrolle arbeitet mit einer systemweiten Konfigurationsdatei namens scribus-short-words.rc, die unter Linux und Unix normalerweise unter $prefix/lib/scribus/plugins gespeichert ist (was das tatsächliche Verzeichnis ist, hängt davon ab, wie Sie oder Ihr Distributor Scribus installiert haben.). Die Konfigurationsdatei ist selbsterklärend. Sie besteht aus einer Liste von Abkürzungen in einer bestimmten Sprache. Vor oder nach der Abkürzung befindet sich eine Abkürzung. Abkürzungen und Leerzeichen werden durch Kommas getrennt. Der Platz des Leerzeichens zeigt dem Plug-in an, ob vor oder nach der Abürzung ein geschütztes Leerzeichen eingefügt werden soll. Jede Zeile der Konfigurationsdatei muß mit der Sprache beginnen, für die sie bestimmt ist, z.B. en für Englisch oder cs für Tschechisch:
# English stuff START here en=Dr. ,Dr ,Mr. ,Mr ,Mrs. ,Mrs ,Ms. ,Ms ,Prof. ,Prof ,Rev. ,Rev , en= Kg, kg, g, mg, oz, lb, cwt, km, Km, m, cm, mm, # Czech short words START here ## hanging conjunctions cs=K ,k ,S ,s ,V ,v ,Z ,z ,O ,o ,U ,u ,I ,i ,A , ## physics and math cs= kg, g, m, cm, mm, l, hl, s, %,
Wenn Sie eigene Abkürzungslisten verwenden wollen, z.B. für eine neue Sprache, erzeugen Sie selbst eine Konfigurationsdatei und speichern diese als scribus-short-words.rc im ~/.scribus-Verzeichnis. Selbstverständlich können Sie auch die ursprüngliche Konfigurationsdatei ersetzen und Ihre Version systemweit zur Verfügung stellen.
Der Autor brennt darauf, die globale Konfigurationsdatei Ihren Wünschen entsprechend zu erweitern. Teilen Sie ihm Abkürzungen und Standards aus Ihrer Sprache mit.
Short Words for Scribus Copyright 2003, 2004 Petr Vaněk, <petr@yarpen.cz>
This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Document Copyright © 2004 Petr Vaněk, Maciej Hanski, under the opencontent.org license included with these documents with Elected Option IV
scribus-doc-1.4.0+r17300/doc/de/color1.html 0000644 0001750 0001750 00000006763 10673051435 017021 0 ustar malex malexIn Scribus gibt es verschiedene Methoden, um Farben zu erzeugen, zu importieren and zu bearbeiten. Welche dieser Methoden Sie anwenden, hängt davon ab, ob Sie Farben aus einem anderen Scribus-Dokument oder einer importierten Datei, etwa im EPS- oder SVG-Format, replizieren müssen. Darüber hinaus verfügt Scribus über ein spezielles Plug-in, nämlich das Farbrad, das es Ihnen ermöglicht, Farbharmonien zu erzeugen und deren Wirkung auf Farbenblinde zu überprüfen.
Fangen wir mit den Farbpaletten an:
Standardmäßig enthält Scribus eine Handvoll sehr nützlicher Farbpaletten, die als Ausgangsbasis für das Erzeugen eigener Paletten dienen können. Es empfiehlt sich, die Unterschiede zwischen dem RGB- und dem CMYK-Farbmodell zu verstehen, und ich rate Ihnen, das Farbmanagement richtig zu konfigurieren, wenn Sie CMYK-Farbpaletten verwenden. Wie Sie wissen, können CMYK-Farben nicht direkt auf einem Computerbildschirm wiedergegeben werden, sondern sie werden simuliert. Das Farbmanagement ermöglicht, wenn es richtig eingestellt ist, eine korrektere Farbwiedergabe, und zwar so, wie die Farben aussehen, wenn mit CMYK-Tinten gedruckt wird. Beachten Sie, daß die meisten Tinten- und Laserdrucker in die Kategorie der sogenannten RGB-Geräte gehören, genau wie Monitore. Das liegt daran, daß ihre Treiber RGB-Werte erwarten, die dann mit Hilfe des Treibers oder einer Kombination aus Treiber und Firmware intern von RGB nach CMYK umgerechnet werden.
Sie können eine Standardpalette für alle Dokumente auswählen, wenn Sie alle offenen Scribus-Dateien schließen und dann dann eine Palette im Farbdialog auswählen.
 |
Im Farbdialog können Sie Farben aus anderen Scribus-Dokumenten oder aus Dateien in den Vektorformaten EPS, PostScript oder AI (Adobe Illustrator®) importieren. Das gilt auch für Schmuckfarben, die eine besondere Form benannter Farben darstellen.
Aus manchen unterstützen Dateien läßt sich keine Farbe importieren, selbst wenn sie auf Postscript basieren. Warum? Nicht alle Programme speichern DSC-Kommentare (Document Structure Convention) korrekt und verwenden inkompatible proprietäre Erweiterungen, die nicht dem PostScript-Standard entsprechen.
scribus-doc-1.4.0+r17300/doc/de/toolbox14.html 0000644 0001750 0001750 00000005215 10673051435 017444 0 ustar malex malexFür Anwender von BSD-, Linux- oder Unix-Systemen ist LProf ein grundlegendes Werzeug, um ein verläßliches Farbmanagement in Scribus sicherzustellen. Warum ist das so?
LProf ist das einzige grafische Werkzeug für *nix-Systeme, um ICC-Geräteprofile anzulegen. Es funktioniert auch unter Windows und bald ebenfalls unter Mac OS X. Vereinfacht dargestellt ist LProf ein Programm, mit dem Sie ein ICC-Profil eines Gerätes, etwa Ihres Monitors, anlegen können, womit die vom Farbmanagement gesteuerte Darstellung von Farben am Bildschirm präziser wird. Stellen Sie sich ein Geräteprofil als einen Satz Brillen vor, die es Ihren Augen wie durch Zauberhand ermöglichen, mit perfekter Fabrbbalance zu sehen. In Scribus kann die Verwendung des korrekten Monitorprofils erheblich zur korrekten Vorhersage über die tatsächlich im Druck erscheinende Farbe beitragen, wenn die PDF-Datei auf einem PostScript-Drucker oder im kommerziellen Druck ausgegeben wird. Ohne ein Profil ihres eigenen Bildschirms – kein Monitor gleicht dem anderen – können Sie nicht sicher sein, daß die Farben im Druck auch nur annähernd mit dem übereinstimmen, was Sie am Bildschirm sehen.
LProf bietet Ihnen eine einfache Schritt-für-Schritt-Methode an, um ein Profil zu erzeugen, das Sie anschließend in Scribus verwenden können. Sie sollten sich wirklich die paar Minuten Zeit nehmen, die notwendig sind, um ein Profil anzulegen und es in den Scribus-Voreinstellungen auszuwählen. LProf kann außerdem Profile für Ihren Scanner oder Ihre Digitalkamera erzeugen. Ein Blick die Dokumentation für LProf liefert Ihnen weitere und tiefergehende Informationen über dessen Möglichkeiten.
Mit der zur Zeit erhältlichen Version (0.11.4) ist es noch nicht möglich, Kalibrierungsgeräte zu verwenden. Dieses Feature ist momentan in Arbeit, und die Aussichten sind gut: Ab der nächsten Version können Sie Geräte wie X-Rite DTP94, EyeOne Display 2 und EyeOne Display LT zum Messen direkt am Bildschirm unter Windows und Linux verwenden.
Unter Mac OS X können Sie statt dessen das mitgelieferte ColorSync-Applet zum Anlegen eines Monitorprofils nutzen. Wenn Sie Windows verwenden und Photoshop, Indesign oder Illustrator installiert haben, tut Adobe Gamma entsprechende Dienste.
 |
Erfolgreiche Softare-Entwicklung ist ohne ausgiebiges Testen fast unmöglich, und für Scribus trifft dies selbstverständlich ebenso zu. Testen bedeutet, das Programm zu benutzen, insbesondere die Entwicklerversionen. Wenn Fehler entdeckt worden sind, müssen sie den Entwicklern mitgeteilt werden, damit diese wissen, daß etwas nicht funktioniert oder wenigstens zu funktionieren scheint, wie es soll, so daß der Fehler behoben werden kann. Manchmal kann die Fehlerbehebung schlicht in einer Aktualisierung der Dokumentation bestehen. Darüber hinaus müssen die Entwickler natürlich wissen, welche Funktionen Anwender benötigen, und wenn eine bestimmte Funktion fehlt oder wenn jemand eine großartige Idee hat, sollte er es dem Scribus-Team mitteilen.
Ob nun Fehlerbericht oder Wunsch, die Prozedur ist in allen Fällen dieselbe. Es gibt eine spezielle Softwaregattung namens »Bug Tracking System«, die es Entwicklern erlaubt, Fehlerberichte und sogenannte »RFEs« (requests for enhancement) zu verfolgen und zu diskutieren. Das Scribus-Team hat sich für das Mantis-System entschieden. Wenn Sie also helfen wollen, Scribus zu verbessern oder unbedingt eine Funktion benötigen, sollten Sie lernen, wie man das System benutzt.
Besuchen Sie die Anmeldungsseite. Sie werden eine Seite sehen, die in etwa wie folgt aussieht:
 |
Geben Sie einen Benutzernamen, Ihre E-Mail-Adresse und die eingeblendeten Ziffern ein. Dann klicken Sie auf »Signup« und warten Sie, bis Ihr Nutzerkonto bestätigt wurde und Sie ein Paßwort per E-Mail erhalten haben. Sie können Ihre persönlichen Einstellungen jederzeit unter »My account« ändern, wenn Sie eingeloggt sind. Am besten nehmen Sie sich ein bißchen Zeit, um sich mit den verschiedenen Optionen vertraut zu machen und zu entscheiden, ob Sie für Sie von Nutzen sind.
Wenn etwas nicht funktioniert wie erwartet, oder falls Sie glauben, Sie hätten die Idee des Jahrhunderts, fangen Sie bitte nicht gleich an, neue Einträge zu machen, denn es ist nicht auszuschließen, daß jemand schon über dasselbe Problem gestolpert ist oder dieselbe Idee hatte. Wir empfehlen, folgende fünf Schritte zu beachten, um sicherzustellen, daß Ihr Eintrag nicht umgehend als »Duplicate« oder »No change required« geschlossen wird..
 |
Sie werden bemerken, daß Mantis verschiedene Farben benutzt, um den Status eines Berichts anzuzeigen. Die Farben bedeuten im einzelnen:
| Neu | Feedback | Akzeptiert | Bestätigt | Zugewiesen | Gelöst | Geschlossen |
Um einen Eintrag zu tätigen, müssen Sie auf »Report Issue« in Ihrem Browser klicken. Ihnen wird jetzt eine große Zahl von Feldern für Einträge präsentiert:
 |
Wenn Sie mit den Formalitäten fertig sind, können Sie endlich anfangen, Ihren Bericht zu schreiben:
 |
Sie sind nun fast fertig, aber vielleicht möchten Sie noch eine Datei hochladen, zum Beispiel einen Bildschirmschnappschuß oder eine Scribus-Datei. Klicken Sie in diesem Fall auf »Search« oder geben Sie den Pfad zu der Datei oder eine URL ein.
 |
Wenn Sie nicht möchten, daß außer den Entwicklern andere Ihren Bericht sehen, z.B. weil eine Beispieldatei vertrauliche Daten enthält, können Sie dem Bericht Status »Private«. In diesem Fall wird nur eine Handvoll Menschen, nämlich die Entwickler, die Daten zu Gesicht bekommen.
Sobald alles zu Ihrer Zufriedenheit eingetragen ist, klicken Sie »Submit Report«. Das war’s schon.
Wenn Sie eingeloggt sind, können Sie sich eine übersichtlichere Ansicht des Bugtrackers anzeigen lassen. Klicken Sie dazu auf »My view«, und Mantis zeigt Ihnen eine besser strukturierte Übersicht der zuletzt geänderten Einträge:
 |
This article shows you how to write Get Text plugins for Scribus. Plugins are dynamic loaded libraries in "so" format. Get Text Plugins are used to import formatted text from all kinds of file formats into a Scribus text frame.
Wait here for a while! Maybe you are at the edge of reinventing the wheel - so join the mailing-list or visit #scribus channel at irc.freenode.net. Your topic will be discussed and you'll get support too. We cannot stop you to write anything you want - sure. :)))
Now let's describe the source code. MYIMPORTER_H declaration is the standard way to ensure only one insertion of the header file. Scribus.h is required to access Scribus objects. The function GetText() is called when a user has selected to import a file that has a file extenison which matches one in the QStringList returned by FileExtensions(). FileFormatName() should return the name for the file format this importer works on f.e. "Text files" for plain text importer.
If your plugin is the only plugin for the file format return a QStringList with format's file extensions. If there already is an importer for the format you are also creating an importer for do not return file extensions but an empty QStringList. The most common and used plugin for a file format should return file extensions. Other more rarely used plugins should not return extensions. These plugins can be used by selecting them in the file dialog of Get Text.
#include "myimporter.h" #include <qstring.h> #include <qstringlist.h> QString FileFormatName() { return QObject::tr("Nothing to import"); } QStringList FileExtensions() { // QStringList list("htm"); list << "html" << "php"; return list; return QStringList(); } void GetText(QString filename, QString encoding, bool textOnly, gtWriter *writer) { }
The importnothingplugin-1.0.tar.bz2 from http://docs.scribus.net can be used as a basis of your own get text plugin.
Text can be appended to a text frame with gtWriter::append() methods. append(QString text) appends text formatted with the style of the text frame. append(QString text, gtStyle *style) will use the style given as a parameter.
gtStyle, gtParagraphStyle and gtFrameStyle can be used to set the style for imported text. The easiest way to get started is to use gtWriter's getDefaultStyle() method to get the text frame's current style and then use the gtFrameStyle returned to create new styles.
gtStyle works on character styles and can be used inside a paragraph style. gtParagraphStyle creates a paragraph style in Scribus and can be used to apply a paragraph style to the text when importing. gtFrameStyle gives a possibility to change the default style of the text frame. Relation between these three classes is: gtStyle works as a base class. gtParagraphStyle extends gtStyle and gtFrameStyle extends gtParagraphStyle. They all have a gtFont object that can be obtained with getFont() method. gtFont object can be used to set some character based formatting. See the header files: gtfont.h, gtstyle.h, gtparagraphstyle.h and gtframestyle.h to get a better idea of the interfaces.
There is also one helper class gtMeasure with static methods to convert length units to points which is the default unit scribus uses internally. For example converting 25 millimeters to points one can use gtMeasure's method i2d() (int to double): gtMeasure::i2d(25, MM). Second parameter tells the unit from where the conversion to points is done. All the possible units are defined as an enumeration Unit (see file gtmeasure.h).
#include <gtparagraphstyle.h> #include <gtframestyle.h> #include <gtmeasure.h> ... void GetText(QString filename, QString encoding, bool textOnly, gtWriter *writer) { /***** Create Paragraph Styles *************************************************/ gtFrameStyle* fstyle = writer->getDefaultStyle(); gtParagraphStyle* firstPara = new gtParagraphStyle(*fstyle); firstPara->setName("First Paragraph"); firstPara->getFont()->setSize(12.0); firstPara->setLineSpacing(14.4); gtParagraphStyle* trailingPara = new gtParagraphStyle(*firstPara); trailingPara->setName("Traling Paragraph"); trailingPara->setFirstLineIndent(gtMeasure::i2d(15, MM)); /***** Import Text *************************************************************/ writer->append("Lorem ipsum dolor sit amet, consectetuer adipiscing elit. ", firstPara); QString currentWeight = firstPara->getFont()->getWeight(); firstPara->getFont()->setWeight(BOLD); // from enum FontWeight (gtfont.h) writer->append("Ut a sapien.", firstPara); // import with a bold font firstPara->getFont()->setWeight(currentWeight); writer->append(" Aliquam aliquet purus molestie dolor. Integer quis eros ut " "erat posuere dictum. Curabitur dignissim. Integer orci. Fusce " "vulputate lacus at ipsum. Quisque in libero nec mi laoreet " "volutpat.\n", firstPara); // 2nd Paragraph writer->append("Aliquam eros pede, scelerisque quis, tristique cursus, placerat " "convallis, velit. Nam condimentum. Nulla ut mauris. Curabitur " "adipiscing, mauris non dictum aliquam, arcu risus dapibus diam, nec " "sollicitudin quam erat quis ligula. Aenean massa nulla, " "volutpat eu, accumsan et, fringilla eget, odio. Nulla placerat porta " "justo. Nulla vitae turpis. Praesent lacus.", trailingPara); delete firstPara; delete trailingPara; } ...
Now after right clicking on a text frame, choosing "Get Text..." and selecting our just built importer and opening some file we get a text frame with the sample text formatted correctly.
 |
If you have any questions send mail to Riku Leino (IRC nick:Tsoots) tsoots at gmail.com, register for Scribus mailing list or join the irc channel #scribus at irc.freenode.net.
scribus-doc-1.4.0+r17300/doc/de/cms2.html 0000644 0001750 0001750 00000023123 10673051435 016453 0 ustar malex malexUm eine gute Farbvorschau zu erhalten, müssen die folgenden Schritte ausgeführt werden:
Die Eingabegeräte (Scanner, Digitalkameras etc.) müssen präzise kalibriert sein. Genaueres finden Sie unter "Linux-Farbwerkzeuge". Am allerwichtigsten ist jedoch ein präzise kalibrierter Monitor und dessen Farbprofil.
Ein erster Vorschlag ist, sich von allzu viel Bildschirmschmuck zu verabschieden. Vielleicht schätzen Sie einen Desktop mit allerlei Schickschnack, und zweifellos sind KDE und Gnome großartige Umgebungen. Scribus mag es jedoch schlicht – keine Animationen, keine ausgefallenen Grafiken. Für die besten Ergebnisse bei der Kalibrierung wählen Sie als Farbe Ihres Desktops am besten ein neutrales Grau oder eine helle Farbe ohne Verlauf oder aufwendige Hintergründe. Dies erlaubt Ihrem Auge, die Farbbalance von Bildern besser zu beurteilen. Das gleiche gilt für GIMP und andere Grafikprogramme. Wenn ich Monitore für Photoshop mit (teurer) Hardware kalibriere, ist dies immer der erste Schritt. Unser Ziel ist es, so genau wie möglich die später gedruckte Farbe zu imitieren.
Kalibrierung bedeutet, den Monitor in einen bestimmten Zustand zu versetzen. Die meisten Monitore benutzen standardmäßig eine Farbtemperatur von 9300 k oder Kelvin, was für genaue Farbwiedergabe zu "kalt" oder bläulich ist. Für Ihren Monitor schlage ich 6500 k als Ausgangspunkt vor, was ziemlich genau dem natürlichen Sonnenlicht entspricht. Zunächst werden Sie den Eindruck haben, daß Ihr Monitor einen Gelbstich hat, aber Ihre Augen werden sich schnell anpassen. 9300 k, die Voreinstellung der meisten Monitore, ist eine gute Einstellung, wenn Sie mit einer Textverarbeitung arbeiten, aber die Farben wirken ausgewaschen und sie werden weniger ausgewogen dargestellt, wenn Weiß einen Blaustich hat.
Jeder Arbeitsfarbraum basiert auf bestimmten Einstellungen Ihres Monitors. Gamma und Farbtemperatur Ihres Monitors sollten den Spezifikationen des Arbeitsfarbraums entsprechen. Adobe® RGB und Bruce RGB legen beispielsweise 6500 k und einen Gammawert von 2,2, was für Monitore an Intel-basierten PCs recht verbreitet ist und auch die Empfehlung für Anwender darstellt, die farbkritische Bilder bearbeiten.
Es ist wichtig, das CMYK-Zielgerät (den Drucker) richtig anzusprechen, indem man ein Profil verwendet, das für die Papersorte und das Ausgabegerät geeignet ist. Druckerprofile hängen sehr stark vom Ausgabemedium ab. Zeitungspapier und andere ungestrichene Papiersorten haben eine gräuliche Farbe, so daß ihr "Gamut" (der Farbumfang) kleiner ist. Darauf lassen sich nicht so prächtige Farben drucken wie auf gestrichenes Papier oder gar Fotopapier. Ein einzelner Drucker kann ohne weiteres ein Dutzend oder mehr Profile im Einsatz haben, und das nur wegen Unterschieden in der Papierfarbe und der Farbasorption.
Und wie bekomme ich jetzt Profile für meine Hardware?
Einige Profile sind "generisch" und stammen vom Hersteller. Diese Profile stammen aus Meßstichproben der Hersteller. Immer mehr Hersteller gehen dazu über, diese Dateien zusammen mit der Software auszuliefern, die dem Gerät beiliegt. Obwohl diese Profile "von der Stange" selten genau sind, stellen sie doch einen guten Ausgangspunkt dar. Besuchen Sie die Website des Herstellers und schauen sie nach, ob es ein Profil für Ihr Gerät gibt. Eine andere Sorte "generischer" Profile sind standardisierte Druckprofile. Es handelt sich dabei um CMYK-Profile der Druckindustrie wie SWOP, FOGRA, ECI und anderen Standardisierungsgremien im Druckbereich.
Linux-Farbwerkzeuge
Monitor-Gamma: Gamma, um es einmal stark vereinfacht auszudrücken, ist ein Wert, der die Helligkeit der Grauwerte darstellt. Ein korrekt eingestellter Gammwert ist ein wichtiger erster Schritt auf dem Weg zu einer guten Farbbalance, bevor man versucht ein genaues Profil anzulegen. Das Programm LProf ist gut dazu geeignet, Ihnen bei den korrekten Einstellungen zu helfen
Die nächste Stufe der Präzision ist ein von Ihnen selbst mit Hilfe einer Kalibrierungssoftware wie LProf erstelltes Profil. Hier finden Sie weitere Einzelheiten zur Monitorkalibrierung Interessanterweise war ein auf diese Weise erstelltes Profil einem anderen, das mit teurer Kalibrierungssoft- und -hardware unter Windows 200 erstellt wurde, sehr ähnlich.
Am genauesten läßt sich ein Monitorprofil mit einem Kalibrierungsgerät anlegen. Dabei handelt es sich im Grunde genommen um eine besondere Kamera, die Farbe mißt. Ein Programm sendet dabei bestimmte Referenzfarben an den Monitor, die dann vom Kalibrierungsgerät gelesen werden und das dann ein Profil erstellt. Es gibt noch keine Linux-Treiber für die verbreiteten Spider oder Kolorimeter, aber sobald die entsprechenden Treiber geschrieben sind, kann das Kalibrierungsprogramm diese Geräte verwenden. Anwender, die mit einem Kolorimeter Profile unter Windows angelegt haben, können probieren, diese zu verwenden, vorausgesetzt, die Monitoreinstellungen sind dieselben und der Linux-Treiber ändert die Farbwerte Ihres Monitors nicht sehr stark. Es ist immerhin einen Versuch wert!. Meine mit einem Kolorimeter erzeugten Profile funktionieren sehr gut mit Scribus. Wenn das Farbmanagement aktiviert ist, sehen die Farben fast genauso aus wie in Photoshop 6 – eine nicht eben geringe Leistung von Scribus und littlecms!
Farbmanagement-Einstellungen in Scribus
Systemprofile: Hier sehen Sie die auf Ihrem System verfügbaren Profile. Damit Scribus Profile verwenden kann, müssen sie nach
$prefix/share/Scribus/profilesverschoben werden. Sie können sie aber auch in irgendein Verzeichnis kopieren und dieses in Scribus in den Programmeinstellungen mitteilen. Farbprofile – *.icm und *.icc – funktionieren plattformübergreifend, weswegen Profile, die unter Windows oder Mac OS erstellt wurden, mit Hilfe von littlecms auch unter Linux verwendet werden können. Ich empfehle dringend, die Adobe-Profile herunterzuladen, wenn Sie plattformübergreifend im kommerziellen Druck arbeiten, denn die meisten gut eingerichteten DTP-Workstations und die meisten Druckereien können mit diesen Profilen umgehen. Die Adresse finden Sie auf der Link-Seite.
Die Abbildung oben ist ein guter Ausgangspunkt, um zu erklären, welche Rolle littlecms in Scribus spielt. In diesem Fall wurden die Bilder im Dokument mit einer Digitalkamera der mittleren Preisklasse aufgenommen. Die Kamera stellt die Farbbalance automatisch ein und paßt die Ausgabe für den sRGB-Farbraum an. Darum ist es sinnvoll, die Einstellung bei sRGB zu belassen. Wären die Bilder eingescannt worden, hätte man ein Profil verwenden müssen, das für den Scanner angelegt wurde.
Füllfarben können im RGB- (Rot, Grün, Blau) oder CMYK-Farbmodell (Cyan, Magenta, Gelb and K, also Schwarz – diese vier Farben beschreiben die Tinten, die im Offsetdruck oder in Farbdruckern verwendet werden) angegeben werden. In unserem Fall verwenden wir ein paar einfache RGB-Farben, die wir später einem "Soft-Proof" im CMYK-Farbraum des Druckers unterziehen. Im gewählten Beispiel handelt es sich um den Druckprozeß US SWOP auf gestrichenem Papier, um brillante Farben zu gewährleisten.
Es ist sinnvoll, Ihren Geräteprofilen einen aussagekräftigen Namen zu geben. Das D226500mon.icm-Monitorprofil ist beispielsweise mit Lprof erstellt worden. Der Gammawert ist 2,2, die Farbtemperatur 6500 k, und D steht für Tageslicht (daylight). Auch das Umgebungslicht beeinflußt Ihre Farbwahrnehmung, machmal sogar ganz erheblich, je nach der Lichtquelle. Der Name "Sony 17" entstand als Beschreibung, als das Monitorprofil mit Hilfe von Qmonitorprofiler aus dem littlecms-Paket angelegt wurde.
Farbmanagement aktivieren aktiviert das Farbmanagement für das ganze Dokument. Scribus speichert diese Einstellung zusammen mit dem Dokument. Wenn Sie ein Dokument mit aktivem Farbmanagement speichern und schließen, dauert das Öffnen etwas länger, denn Scribus muß nicht nur die Datei öffnen, sondern auch noch littlecms die Profile lesen und zwischen den Farbräumen konvertieren lassen. Farbumwandlungen erfordern mehrfache Gleitkomma-Operationen, haben Sie also etwas Geduld. Littlecms war bisher ausgesprochen stabil und enthielt nur ein paar kleinere Fehler beim Umgang mit Profilen. Es gibt die Möglichkeit, die Druckerfarbe am Bildschirm zu simulieren. Farben außerhalb des Farbbereichs markieren zeigt alle Farben, die nicht gedruckt werden können, weil sie außerhalb des Gamut liegen, in einer Warnfarbe an. Derart markierte Farben sehen im Druck meist dunkler oder heller aus oder die Farbe ändert sich ganz. Die letzte Option, Tiefenkompensierung benutzen, ermöglicht es, Schatten in Farbbildern darzustellen. Sie müssen ein wenig experimentieren, ob diese Einstellung die Qualität verbessert.
scribus-doc-1.4.0+r17300/doc/de/psd.html 0000644 0001750 0001750 00000014640 10673051435 016401 0 ustar malex malexAdobe Photoshop ist eines der bekanntesten Computerprogramme überhaupt. Es ist im professionellen Grafikbereich weit verbreitet, sowohl für den Druck als auch für das Internet. Obwohl ich gerne mit Open-Source-Anwendungen wie Cinepaint, GIMP oder Krita arbeite und deren Entwicklung unterstütze, kann man doch manchmal nicht auf Photoshop verzichten, vor allem im Druckbereich.
Einer der Gründe für seine Leistungsfähigkeit ist das native PSD-Dateiformat. Eine PSD-Datei kann nicht nur Bilddaten enthalten, sondern stellt vielmehr eine Art Container, in dem unter anderem Metadaten, Kamerainformationen, Text, Vektordaten und mehr gespeichert werden können. Die meisten anderen Programme bieten nur einen Teil der Photoshop-Funktionen.
 |
Erstens, wenn Sie eine native Photoshop-Datei vorliegen haben, verwenden Sie sie auf jeden Fall. Achten Sie darauf, daß das richtige ICC-Profil eingebettet ist. In Photoshop geschieht dies mit Bild > Modus > In Profil umwandeln.
Um Ihre Chancen für einen erfolgreichen EPS-Import zu erhöhen, sollten Sie auf drei Dinge achten:
Es gibt zwei Methoden, EPS-Dateien zu importieren, und beide haben ihre Vor-und Nachteile. Die erste und oft bevorzugte Methode ist, EPS-dateien als native Vektorobjekte zu importieren. Die zweite ist, eine Datei einfach in einen Bildrahmen zu laden, genauso wie es bei GIMP oder Photoshop der Fall ist. Das heißt, das Bild wird gerastert oder in eine Bilddatei umgewandelt. Man muß abwägen, welche Methode man anwendet, was teilweise an der Natur der EPS-Formats liegt. Wie im Fall des PDF-Formats sind die meisten, wenn nicht sogar alle EPS-Dateien nicht für Weiterbearbeitung gedacht, sondern es handelt sich um ein Austauschformat. Wenn Sie jedoch als native Scribus-Objekte importiert werden, kann ein Teil des Inhalts bearbeitet und verlustfrei skaliert werden.
Eine meiner bevorzugten Methoden, EPS-Dateien zu importieren, sieht wie folgt aus: Schließen Sie alle Scribus-Dokumente. Gehen Sie dann auf Datei > Importieren > EPS/PS-Dateien importieren und wählen Sie die Datei aus. Scribus erstellt nun eine Seite in den Dimensionen der importierten Datei. Speichern Sie die Datei als Scribus-Dokument und schließen Sie diese.
Öffnen Sie das Zieldokument und erstellen Sie eine neue Ebene. Importieren Sie dann das gespeicherte Dokument auf die neue Ebene. Dadurch wird verhindert, daß eines der importierten Elemente mit anderen in Konflikt gerät, und außerdem können Sie die Grafik präzise plazieren.
Scribus kann EPS-Dateien importieren, die Rastergrafiken enthalten. Dies funktioniert jedoch sehr viel besser mit einer Ghostscript-Version ab 8.50, und es gibt einige Einschränkungen:
Wenn Sie eine EPS-Datei in Scribus importieren möchten, die eine Mischung aus Text, Bitmap- und Vektorbildern enthält, ist dies wahrscheinlich Ihre einzige Option. Wenn die Fonts korrekt eingebettet sind, funktioniert diese Methode normalerweise sehr zuverlässig. CMYK-Farben, die in der EPS-Datei definiert sind, bleiben zuverlässig erhalten. Beim Import ignoriert Scribus eingebettete TIF- oder PICT-Vorschaubilder und generiert eine eigene niedrigauflösende Vorschau. Wenn Sie nichts sehen, deutet dies auf ein Importproblem hin, das genauer untersucht werden muß. Beim PDF-Export wird die EPS-Datei von Ghostscript neu gerendert, weil sie in die PDF-Datei eingebettet wird. Seien Sie also nicht überrascht, wenn der PDF-Export lange dauert oder die Speicherauslastung stark ansteigt.
Um eine EPS-Datei als Bild zu importieren,
Eine EPS-Datei als natives Scribus-Objekt zu importieren, hat, wenn es möglich ist, einige Vorteile. Zunächst handelt es sich um reine Vektordaten, so daß die Dateigrößen beim Export ziemlich klein sind. Als Vektoren haben sie außerdem keine Bildaufösung, so daß sie beliebig vergrößert werden können, ohne ihre Schärfe zu verlieren. Außerdem können Sie die grafischen Elemente wie Linien, Polygone und Kurven mit den Scribus-Vektorwerkzeugen bearbeiten.
Um eine EPS-Datei als natives Scribus-Objekt zu importieren, gehen Sie wie folgt vor:
Wie oben erwähnt, schwankt die Exportqualität anderer Anwendungen erheblich. Einige Programme mögen es unglücklicherweise, ihre eigenen Spezialitäten einzubauen. Der erste Schritt, einen fehlgeschlagenen Import zu überprüfen, ist das Öffnen der Datei in GSView. Drücken Sie die Taste M, um die Ghostscript-Meldungen zu lesen, während es versucht, die Datei zu öffnen. Wenn das Öffnen fehlschlägt, können die Meldungen manchmal etwas kryptisch erscheinen, aber sie sind hilfreich, um herauszufinden, was das Problem ist.
Was können Sie mit Scribus tun? Was ist ein DTP-Programm?
Grundsätzlich ist Scribus kein Textverarbeitungsprgramm. Es wichtig, dieses Konzept zu verstehen. Scribus gehört zur Familie der Layoutprogramme, besser bekannt als DTP-Programme. Scribus bietet Anwendern ein große Flexibilität beim genauen Plazieren von Objekten wie Bildern oder Logos. Diese kurze Einführung soll dazu dienen, einem Einsteiger eine Vorstellung davon zu vermitteln, was Scribus kann. Sie hat nicht den Zweck, alle Funktionen zu erläutern, sondern soll nur eine einfache Übersicht sein, damit Sie schnell anfangen und produktiv werden können.
Mit Scribus können Sie:
Bei Anfängern, die zum ersten Mal mit DTP-Anwendungen wie Scribus in Berührung kommen, stellt sich anfangs sehr leicht Frustration ein. Die Benutzeroberfläche scheint auf den ersten Blick halbwegs vertraut, aber wenn man anfängt, funktioniert nicht alles so, wie man es erwartet. Sie sollten nicht erwarten, ein neues Dokument zu öffnen und gleich lostippen zu können. Um ein Programm wie Scribus optimal nutzen zu können, muß man das Konzept des "Workflow" in der DTP-Welt verstehen. Auf den ersten Blick erscheint dies etwas obskur, doch am Ende wird es sich lohnen.
Teil der Herausforderung, wenn man lernt, mit Scribus umzugehen, ist, daß man nicht nur lernt, ein Programm zu bedienen, sondern Desktop Publishing lernen muß, das seinen eigenen Regeln folgt. Es gibt feine Unterschiede zu Textverarbeitungsprogrammen oder Texteditoren. Glücklicherweise hat Scribus einen eingebauten Story Editor. Wenn Sie diesen verwenden, anstatt direkt in Textrahmen zu arbeiten, wird Ihre Produktivität, etwa durch das Erstellen und Anwenden von Stilen, erheblich steigern.
Workflow bedeutet in der DTP-Welt sowohl, Dateien zusammenzustellen, als auch, von vornherein zu planen, wo und wie das Dokument gedruckt werden soll. Wenn Sie beispielsweise vorhaben, eine Firmenbroschüre zu produzieren, wollen Sie diese bestimmt in einer Druckerei drucken lassen. Daher wäre es ein schwerer Fehler, wenn Sie glaubten, Sie könnten die niedrigauflösenden JPEG-Dateien von Ihrer Website in Scribus verwenden. Web und Druck haben verschiedene Zwecke. Grafiken von einer Website sind fast immer unbrauchbar für den professionellen Druck. Sie benötigen sehr viel höhere Auflösungen in Bilddateien. Die Dateigröße sollte nur eine untergeordnete Rolle spielen, wenn es um professionellen Druck geht. Ein typisches Bild auf einer Website hat meist eine Auflösung von 72–96 DPI, während Sie für gute Ergebnisse im Druck 200–300 DPI benötigen. Scribus kann PDF-Dateien mit einer Auflösung von bis zu 4000 DPI exportieren.
Ein einfacher DTP-Workflow:
Beim kommerziellen Druck kann dies noch weitaus kompexer sein. Nach meiner Erfahrung sind jedoch ähnliche Vorgehensweisen sinnvoll und erhöhen die Produktivität außerordentlich.
Schließlich berücksichtigt das Worlflow-Konzept auch die vielen möglichen Optionen für den PDF-Export oder das Drucken. Sie finden ausführliche Informationen zu diesem Thema im Kapitel über den PDF-Export. Scribus verfügt über fortgeschrittene Druckfunktionen, die für eine Desktop-Anwendung ungewöhnlich sind. Stellen Sie sicher, daß die Tooltips aktiviert sind, um allgemeine Informationen zu diesem Thema zu erhalten, oder lesen Sie das Kapitel zum Thema Drucken sorgfältig durch, um diese zu verstehen.
Anfängern möchte ich empfehlen, Scribus zu starten und nebenher in der Dokumentation zu blättern, vor allem, was die anspruchsvolleren Themen angeht. Lesen Sie alles sorgfältig durch, schreiben Sie auf, was Sie nicht verstehen, und stellen Sie dann Ihre Fragen auf der Mailingliste ein oder fragen Sie im IRC nach.
Bevor Sie sich auf ein Projekt stürzen, ist es manchmal sinnvoller, den Computer erst einmal ausgeschaltet zu lassen. Nehmen Sie einen Zeichenblock zur Hand, und fertigen Sie eine einfache Skizze Ihres künftigen Layouts an. Auch ich habe Stift und Papier wiederentdeckt. Während einer Urlaubsreise, bei der ich nicht immer Zugang zu einem Computer hatte, habe ich festgestellt, daß sich meine Schreibfertigkeiten verschlechtert hatte, weil ich nur noch selten mit der Hand schreibe. Als Konsequenz habe ich ganze 8 Seiten an einem Nachmittag vollgeschrieben, was mehr ist als das, was ich in drei Nächten hätte schreiben können. Warum? Weil ich mich ganz auf den Inhalt konzentrieren konnte. Ich schlage vor, Sie tun dasselbe. Scribus zeigt seine Stärken, wenn alle Einzelteile zum Schluß zu Ihrem Meisterwerk zusammengeführt werden.
Wenn Text nun ein wichtiger Bestandteil Ihres Dokumentes ist, starten Sie die Textverarbeitung oder den Texteditor Ihrer Wahl, um den Text zu verfassen. Dadurch können Sie sich auf den Inhalt konzentrieren. Hier arbeiten Textverarbeitungsprogramme manchmal gegen Sie. Sie haben vielleicht schon gemerkt, wie oft Sie sich mit dem Formatieren des Textes vom Inhalt ablenken lassen (mir geht es genauso). Ich muß hier keine Eulen nach Athen tragen, indem ich die Vorteile unformatierten Textes aufzähle. In der Linux-/UNIX-Welt ist dies eine Selbstverständlichkeit, aber für Umsteiger von Windows oder OS X dürte dies nicht Ihren Gewohnheiten entsprechen. Speichern Sie unformatierten Text, Sie werden eines Tages dafür dankbar sein. Eine andere Möglichkeit ist es, Dateien aus OpenOffice.org 1.x und 2.x (OASIS), und zwar Textdateien and Grafiken, zu importieren.
Als nächstes müssen Sie über Zeichnungen, Fotos und andere Objekte nachdenken, die Teil Ihres Dokuments werden sollen.
wie Fotos stammen aus Programmen wie GIMP, Krita oder Adobe Photoshop. Es können auch Bilder aus einer Digitalkamera oder einer Scanneranwendung wie XSane oder Kooka sein. Bitmap-Bilder bestehen aus Pixeln oder Punkten und liegen meist in einem komprimierten Format wie JPEG, TIFF, PNG oder BMP vor. Als Bildformate in Scribus bevorzuge und empfehle ich entweder PNG für Dinge wie Screenshots oder TIFF. TIFF-Dateien sind normalerweise sehr zuverlässig im DTP und sollten für hochauflösende Fotos verwendet werden.
stammen aus Programmen wie Inkscape, OpenOffice.org Draw, Adobe Illustrator, Corel Draw, Sketch, oder Xfig. Diese erzeugen Zeichnungen, die in Kurvendaten gespeichert werden, so daß sie beliebig skaliert werden können. Der Import in Scribus funktioniert am besten mit EPS-Dateien (Encapsulated Postscript) oder im SVG-Format (Scalable Vector Graphics). Der Vorteil ist, daß Scribus diese Dateien als native Vektorobjekte importiert und sie daher entsprechend bearbeitet werden können. Der Importfilter kann fast alle Dateien der W3C-Testsuite importieren, ausgenommen diejenigen, die Multimedia-Funktionen enthalten oder Scripting verwenden.
Einer der Gründe, warum wir die jeweils neueste Ghostscript-Version empfehlen, sind die ständigen Verbesserungen beim Import von EPS- und PostScript-Dateien, die dann in Scribus als native Vektorobjekte bearbeitet werden können. Dies kann sehr nützlich sein, wenn importierte Dateien nachbearbeitet werden müssen oder wenn Sie das Original nicht mehr haben.
Eine andere Möglichkeit, Dateien in Scribus zu importieren, ist das PDF-Format. Scribus verwendet Ghostscript, um ein hochauflösendes Bild und eine niedrigauflösende Vorschau zu erzeugen. Dies ist vor allem für Bilder und Zeichnungen geeignet. Wenn Sie nur den Text aus einer PDF-Datei benötigen, öffnen Sie die Datei im Adobe Reader oder KPDF und kopieren Sie ihn aus der Zwischenablage. Beachten Sie, daß Sie nur eine Seite einer PDF-Datei importieren können, und daß es (noch) nicht möglich ist, Dateien in diesem Format zu bearbeiten.
Wenn sie alles beisammen haben, ist es Zeit, mit der Arbeit in Scribus zu beginnen. Anwendern anderer DTP-Programme dürfte die Benutzeroberfläche vertraut und angenehm vorkommen.
scribus-doc-1.4.0+r17300/doc/de/toolbox1.html 0000644 0001750 0001750 00000015764 10673051435 017372 0 ustar malex malexAdobe Reader® 7 is in my experience one of the essential tools to have when using Scribus. Although mostly a simple viewer, it has some advanced features which no other PDF viewer has in the Linux,*nix world: full support for JavaScript with a PDF (You did not know a PDF was scriptable? Scribus is unique in the Linux/*nix world for the ability to create scriptable interactive PDF forms) and detailed information which is embedded in the PDF, but viewable only in Adobe Reader.
Moreover, while PDF is a published standard, Adobe invented PostScript on which PDF is based and has a commercial incentive to promote PDF on all platforms.
We highly recommend upgrading to the latest Adobe Reader 7. Simply put, there is nothing else more capable of rendering PDF correctly. Whatever your objections were to older versions (and there were some substantial ones), this latest version 7 amelorates the vast majority of them. It is far more stable, bug free and now has a modern look and feel. Any PDF rendering issues with Scribus exported PDF in other viewers should be cross-checked with Reader 7 before reporting bugs to us. We are aware of one color mismatch with RGB images and transparency in PDF 1.4. Yes, this has been duly reported as a bug to Adobe too.
Details: As soon there is an extended graphics state parameter dictionary present which contains any transparency related setting, AcroReader switches into CMYK mode showing incorrect colours. My local printer confirmed this strange behaviour even with files not generated by scribus, its clearly a bug from Adobe.
Right away, getting the preferences right in Reader is important to ensure the default preferences to set improve the reliability for our purposes with Scribus. There are a many preferences in Reader 7. The page display part is the most important.
 |
This dialog is very important to set up properly for optimized viewing Scribus created PDFs.
Display Edge to Edge will give you a larger viewing area to view your PDF.
Ensure Smooth Text, Smooth Line Art and Smooth Images are enabled as they apply a bit of anti-aliasing when viewing. If you send someone a Scribus created PDF and they complain the text or gradients) look like barbed wire or are "banded", advise the user to enable these settings which are commonly available on all later versions of Acrobat Reader - regardless of platform. There are other cross- platform fonts hints in the PDF Export Options section. Cool Type is a feature specific for making PDF readable on LCD laptop screens. It is a way of adjusting the anti-aliasing and sub-pixel rendering. Otherwise, leave it unchecked.
If you are creating Scribus files with transparency effects and export PDF 1.4 (PDF 1.3 does not support transparency), you can enable Show Transparency Grid.
 |
The other options are mostly for the web browser plug-in. I find splash screens a bother, so I leave that unchecked.
 |
Next, looking at the Reader window above, there are 3 features which can be useful:
 |
This shows the document size, date of creation and creating application. This information is automatically embedded. Scribus can optionally add author and document title. In addition, this shows Dublin Core RDF (Resource Definition Format) and document security strength.
Document Security. Scribus has the ability to encrypt a document with specific user rights. If you enable Security in the PDF export dialog, when you export PDF 1.3, encryption is 40 bit strength.
 |
If you export a PDF 1.4 file, encryption is 128 bit strength:
 |
Annotations are non-printing notes which Scribus can optionally embed within a PDF. This is really simple. Create a text frame. Then add your notes and right click, select PDF Options and check "Is PDF Annotation".
For other "hidden" features, read through the online help, which is actually a PDF. Beginning with page 10, there are a number of less well known features, including the console command line options. The command line options are specific to Linux/Unix and include some neat options to export PDF into PostScript. There also hints on settings specific to Acrobat Reader in ~/Xdefaults.
Advanced Settings - Fortunately, Adobe enabled a graphical UI choice for enabling/disabling local fonts. Document > Use Local Fonts . What this choice does is enable Acrobat to use locally installed fonts which are named in the PDF, if it can find them in your font path.
I recommend you set this to disable for use with Scribus. Why? As is often the case, PDFs you create in Scribus will be sent to other users who are not running on Linux. What you will want in this case is realistic view without your fonts. Thus, the only reliable way of ensuring your doc will view properly anywhere is to embed the fonts. You can subset them in the font preferences panel to save file size. This particularly important when using the Ghostscript fonts, like the Nimbus family. Acrobat Reader does a poor job of simulating them with its own built-in multi-master fonts.
scribus-doc-1.4.0+r17300/doc/de/old/ 0000755 0001750 0001750 00000000000 11716561673 015507 5 ustar malex malex scribus-doc-1.4.0+r17300/doc/de/old/prepress.html 0000644 0001750 0001750 00000002231 11707344721 020227 0 ustar malex malexFor service bureaus, printers, magazine publishers and other pre-press providers who are unfamiliar with Scribus, the notes available in the Pre-Press and Scribus PDF from http://docs.scribus.net are meant to address your concerns.
Direct Link: http://docs.scribus.net/content/en/pdfs/pre-press.pdfThis is currently an updated working draft, but it has much relevant information on Scribus created PDFs. This will updated with more information and test results as we have more information on hand.
Moreover, members of the Scribus Team offer commercial support for printers, pre-press bureaus and other institutions who are implementing Scribus in their production. You can contact them at http://scribus.biz
scribus-doc-1.4.0+r17300/doc/de/old/javascriptpdf.html 0000644 0001750 0001750 00000003551 11707344721 021232 0 ustar malex malexScribus verfügt verfügt über eine ziemlich vollständige Unterstützung für interaktive PDF-Features. Außer Acrobat Professional bietet möglicherweise kein anderes Programm mehr im Bereich PDF-Forumlare, PDF-Präsentationen und anderer interaktiver Elemente. Sie können JavaScript im "Aktion"-Reiter des Feldeigenschaftendialoges auswählen und dort auch bearbeiten. Am besten lassen sich die Funktionen in einem PDF-Tutorium mit eingebetteten JavaScript nachvollziehen:
Das "JavaScripting-PDF" auf http://docs.scribus.net ist eine Schritt-für-Schritt-Anleitung für Anfänger, die PDF-Dateien mit JavaScript erweitern möchten:
http://docs.scribus.net/content/en/pdfs/javascriptpdf.pdf
Nach der Lektüre dieses PDF-Tutoriums zeigt Ihnen das nächste Kapitel, PDF-Formulare, Schritt für Schritt, wie man webbasierte PDF-Formulare (mit einem PHP-Codebeispiel) zum Lesen der übertragenen Daten erstellt.
Das Tutorium sollte im Acrobat Reader 5.x oder höher und außerhalb eines Browsers betrachtet werden. Normalerweise sollten Sie die Datei einem Rechtsklick und dem Befehl Speichern unter herunterladen können. Andere PDF-Betrachter bieten keine JavaScript-Unterstützung, so daß die Datei nicht korrekt anzeigt wird.
Zum Schluß ein guter Link, unter dem Sie Code-Beispiele finden: http://www.accesspdf.com/article.php/20050510131850979. Hier wird gezeigt, wie die pdftk-Werkzeuge mit Hilfe eines HTML-Frontends zum Ausfüllen eines PDF-Formulars verwendet werden.
scribus-doc-1.4.0+r17300/doc/de/old/fonts4.html 0000644 0001750 0001750 00000010675 11707344721 017614 0 ustar malex malexNehmen wir an, Sie haben irgendwo eine Auswahl von Schriftarten heruntergeladen und installiert. Quer durch alle Dokumentationen, Mailing-Listen und IRC-Channels taucht überall die Frage nach guten Schriftarten auf: Woran erkenne ich sie? Wie kann ich sie beurteilen? Nachfolgend gibt es eine kleine Checkliste, die Sie benutzen können. Sie ist nicht völlig narrensicher und gibt natürlich keine Garantie:
Eine sehr nützliche Funktion in KDE 3.3+ nennt sich KioFonts-Slave und kann die Metadaten von Schriftarten abrufen, um diese dann im Konqueror anschauen und auswerten zu lassen. Zur Einschätzung einer Schriftart setze ich dieses Hilfsmittel stets als erstes ein. Um es zu benutzen, brauchen Sie lediglich den Konqueror zu starten, in ein Verzeichnis mit Schriftarten zu wechseln und die Symbolansicht zu aktivieren, so daß die Vorschaugrafiken im Hintergrund erzeugt werden. Wenn Sie dann den Mauszeiger über das Symbol einer bestimmten Schriftart halten, werden weitere Informationen sichtbar. Alternativ können Sie auch darauf rechtsklicken und Öffnen mit ... KfontView wählen.
 |
In obigem Beispiel gibt es eine Reihe von Hinweisen auf möglicherweise problematische Schriftarten. Zunächst fehlt die Vorschau, was auf ein internes Problem hindeutet. Von mehr als zwei Dutzend Schriftarten ohne Vorschau hatte fast jede Druck-/Export-Schwierigkeiten in Scribus. Als nächstes fehlt die Herstellerangabe, was darauf hindeuten kann, daß es sich um die mäßige Klonkopie eines hochqualitativen Originals handelt.
Unten sehen Sie eine gute Schriftart von einem namhaften und zuverlässigen Hersteller, bei der korrekte Metadaten angezeigt werden.
 |
Scribus bietet Ihnen einige hilfreiche und leicht zu benutzende Dialoge, um Schriften für die Verwendung in Scribus zu verwalten. Außerdem macht es das Einstellen der globalen Schrifteinstellungen und -ersetzungen leicht. In den neuen Einstellungen für Fonts können Sie:
Auf den ersten Blick erscheint die Angelegenheit etwas verwirrend, weil einige Optionen ausgegraut sind. Wie wir noch sehen werden, steckt jedoch eine gewisse Logik dahinter. Einer der Hauptgründe ist, zu verhindern, daß Schriften entfernt werden, die im aktuellen Dokument verwendet werden.
Öffnen Sie Scribus, ohne daß ein Dokument geöffnet ist. Dann gehen Sie zu Datei > Allgemeine Einstellungen > Schriften. Sie sehen ein Fenster mit mehreren Reitern. Wählen Sie den Reiter Zusätzliche Schriften aus.
 |
In dem oben gezeigten Dialog können Sie zusätzliche Pfade für Schriften hinzufügen, die nicht den Systempfaden entsprechen. In unserem Beispiel haben wir ein Verzeichnis hinzugefügt, das nur für ein Projekt verwendet wird. Nachdem Sie OK geklickt haben, wird Scribus diese Pfade hinzufügen, und die Schriften stehen sofort für neue Dokumente zur Verfügung. Beachten Sie, daß Scribus auch in dem Verzeichnis, in dem ein Dokument gespeichert ist, automatisch nach neuen Schriften sucht.
Wenn Sie ein Scribus-Dokument öffnen, überprüft es, ob alle Schriften, die in dem Dokument verwendet werden, verfügbar sind. Falls eine Schrift auf Ihrem Rechner fehlt, haben Sie die Möglichkeit, diese beim Öffnen des Dokuments zu ersetzen. Sie können diese Einstellung im Reiter Schriftersetzung weiter anpassen. Hier können Sie die Standardersetzung ändern.
Dieser Reiter zeigt die systemweit verfügbaren Schriften sowie die vom Anwender zusätzlich hinzugefügten Schriften in anderen Verzeichnissen. Sie können auch einstellen, welche Schriften in Scribus verwendet werden und welche Schriften bei der PostScript-Ausgabe eingebettet werden.
Indem es der *nix-Philosophie "Ein Werkzeug für jede Aufgabe" folgt, erledigt KSnapshot eine Aufgabe wirklich ausgezeichnet, nämlich Bildschirmschnappschüsse ("Screenshots") anzufertigen, selbst im Vergleich zu GIMP, das über eine gute und vergleichbare Funktion verfügt. KSnapshot ist schnell und erzeugt perfekte Bildschrimschnappschüsse, die standardmäßig als 32-Bit-PNG-Dateien, dem meiner Meinung nach besten Format für Aufnahmen dieser Art, gespeichert werden. Verwenden Sie niemals JPEG für Bilschirmschnappschüsse, die Sie für den Druck verwenden möchten. Für ungefähr 95% aller Schnappschüsse, die ich sowohl für das Web als auch für den Druck erzeugt habe, wurde KSnapshot verwendet. Wie gesagt, es gibt andere. Dies ist halt meine persönliche Wahl, und es funktioniert.
 |
CUPS, GIMP-Print und Scribus gemeinsam ermöglichen unter Linux ein ausgezeichnetes Druckergebnis, soweit sie richtig installiert und konfiguriert sind. Scribus gibt Ihnen sogar die Möglichkeit, CUPS direkt aus dem Programm heraus "anzusteuern".
Vergewissern Sie sich zunächst, daß die richtigen Entwicklerbibliotheken von CUPS installiert sind, bevor Sie Scribus kompilieren. Bei Redhat heißen diese zum Beispiel "cups-devel". Nähere Einzelheiten finden Sie in der Datei BUILDING inklusive Quelltext.
Daneben gibt es für viele Linux-Distributionen optionale Gimp-Print-Treiber. Diese Treiber sind nicht allein für Gimp bestimmt, sondern können von beliebigen Programmen genutzt werden, um eine genauere Drucksteuerung und in manchen Fällen deutlich bessere Ergebnisse beim Fotodruck zu erzielen. Oft ist es so, daß Tintenstrahldrucker unter Linux gleich von mehr als einem Treiber unterstützt werden - typischerweise von einem IJS-Treiber und Gimp-Print. Der Unterschied liegt meist in einigen zusätzlichen Optionen - oft zulasten der Druckgeschwindigkeit. Die nächste Version der Gimp-Print-Treiber wird übrigens unter dem Namen Gutenprint erscheinen, um Verwechselungen vorzubeugen.
Das CUPS-Bedienfeld in Scribus mit dem regulären IJS-Modul plus Ghostscript-Treiber:
 |
http://localhost:631 ein, wenn die Online-Benutzeroberfläche von CUPS eingesetzt werden soll. 2. Verwenden Sie den Druckmanager von KDE; er ist die einzige Option, die Ihnen vollen Zugriff auf alle Funktionen von CUPS erlaubt.Die Abbildung unten zeigt den Unterschied bei installiertem GIMP-Print-Plugin.
 |
Der Hauptunterschied liegt darin, daß GIMP-Print über differenziertere Einstellungen zur Farbdichte verfügt. Nicht selten ist er langsamer als andere Treiber, doch wichtiger ist die Qualität der Ausgabe. Sie können auch KPrinter einsetzen, kombiniert mit anderen Programmen, die ohne CUPS arbeiten - und dennoch zu einer hohen Druckqualität gelangen. So verfügt etwa der Acrobat Reader (der erst seit Linux-Version 7.0.5 CUPS erkennt) über ein Befehlszeilenfenster, in dem sich KPrinter aufrufen läßt. Auf diese Weise können Sie - wenn alle Einstellungen korrekt sind - PDF-Dokumente mit hoher Auflösung drucken, die an Qualität Scribus gleichkommen.
Bezüglich CUPS möchte ich Ihnen empfehlen, sich erst einen Drucker für den Alltagsgebrauch mit dem IJS- oder einem normalen KPrinter-Treiber einzurichten und dann eine zweite Druckerinstanz mit GIMP-Print hinzuzufügen, damit Sie eine schnellere Ausgabemöglichkeit für alltägliche Drucksachen wie Texte usw. haben.
Hier sind meine Erfahrungen, die ich mit einigen "echten" PostScript-Druckern unter Scribus gemacht habe:
Wenn Sie einen echten PostScript-Drucker unter Linux verwenden, insbesondere wenn es ein komplexeres Gerät mit mehreren Papierfächern ist, mit Sortierfunktion oder Feineinstellungen für die Grafik und Druckauflösung, dann haben Sie idealerweise die PPD-Datei von der Treiber-CD Ihres Druckers. Ist das nicht der Fall, dann versuchen Sie eine aktuelle Version von der Webseite des Herstellers herunterzuladen. Benutzen Sie anschließend das Hilfsprogramm cupstestppd, um die Datei zu überprüfen. Dies ist ein sehr wichtiger Schritt.
Ein großer Teil der Druckertreiber werden als ausführbare Windows-Programme (*.exe) geliefert. Bekanntlich sind viele dieser von HP nichts weiter als selbstextrahierende WinZip-Dateien. Jede aktuellere WINE-version kann sie leicht öffnen. Danach sollten Sie die Datei auf jeden Fall mit "cupstestppd" prüfen, um sicherzugehen, daß sie der PPD-Spezifikation entspricht. Sollten dabei Fehler auftreten, und kleinere gibt es öfter, finden Sie hier die aktuelle Spezifikation:
http://partners.adobe.com/public/developer/ps/index_specs.htmlcupstestppd ist ein Befehlszeilen-Hilfsprogramm, das sich ganz einfach einsetzen läßt, um die Korrektheit von PPD-Dateien zu überprüfen. Was ist eine PPD-Datei? Eine PPD-Datei ist eine speziell formatierte Textdatei, mit der Sie unter Linux, MacOSX und Windows einen echten PostScript-Drucker installieren können. Unter Linux wird sie in Kombination mit foomatic und CUPS für alle Drucker eingesetzt, um sämtliche Fähigkeiten des jeweiligen Druckers anzuzeigen. Das Befehlszeilenprogramm überprüft, ob die Datei den Spezifikationen für PPD-Dateien entspricht. Bei Problemen gibt sie Hinweise, wie sich diese lösen lassen. Am effektivsten ist "cupstestppd", wenn die PPD-Datei des Geräteherstellers unter Linux verwendet wird.
scribus-doc-1.4.0+r17300/doc/de/old/fonts5.html 0000644 0001750 0001750 00000010332 11707344721 017603 0 ustar malex malexBestandteil von Scribus ist ein sehr schönes und zugleich wirksames Beispiel, das zeigt, was sich mit dem Python-Scripter in Scribus anstellen läßt. Das Skript namens "Font Sampler", geschrieben von Steve Callcott, ist ein Hilfsmittel zum Erzeugen eines nett gemachten Kataloges mit all Ihren Schriftarten, den Sie auch ausdrucken und heften können - oder einfach als PDF-Datei zum Nachschlagen verwenden. So lassen sich auch gelegentlich, und zwar relativ leicht, beschädigte Schriftarten oder solche entdecken, denen wichtige Zeichenelemente fehlen und die beim Druck problematisch werden könnten, was besonders für hochqualitative bzw. geschäftliche Drucksachen von Belang ist.
Was Sie für den Einsatz dieses Scripter-Moduls benötigen:
Das Starten des Moduls ist kinderleicht:
Nun, je nach Anzahl Ihrer Schriftarten, Schriftartentypen und Arbeitsgeschwindigkeit bzw. -speicher Ihres Rechners, dauert es u.U einige Zeit, bis das Skript läuft. 700 oder mehr Schriftarten benötigen auf einem Pentium 4 leicht einige Minuten. Vergessen Sie dabei nicht, daß die Skripte nicht nur sämtliche Schriftarten durchkämmen, sondern wie von Geisterhand Seiten hinzufügen und selbständig gestalten. Falls Ihnen dabei der Speicher knapp wird, weil Sie sehr viele Schriftarten haben (in einer Größenordnung von mehr als 1000), dann sollten Sie die Arbeit besser in Untermengen aufteilen.
Betrachten Sie die Darstellungen links und rechts. Auf der linken Seite sehen Sie eine namhafte Type1-Schriftart von hoher Qualität. Auf der rechten Seite ist eine Freeware-Schriftart aus einem Fehlerbericht dargestellt. Wenn - wie oben - einige Zeichenelemente fehlen, deutet das nicht immer auf eine eine beschädigte Schriftart hin. Einige spezielle Schriftarten wie Symbolschriften, Dingbats und manche nicht-lateinische Schriftarten bringen u.U. ein sehr ähnliches Resultat, doch sind solche Ergebnisse eher bei einer normalen Schriftart ein Hinweis auf mögliche Schwierigkeiten.
Wenn die Konsole geöffnet ist, zeigt Scribus dort die Schriftarten an, die beim Laden ausfallen, und dann wiederum jene, denen bei Benutzung bestimmte Zeichenelemente fehlen oder die beschädigt sind. Die selbe Schriftart erscheint u.U. mehrere Male, während Scribus mittels Freetype nach vorhandenen Zeichenelementen sucht. Dies ist eine gute Sache™ Fehlerhafte Schriftarten bringen Scribus zum Absturz oder verursachen beim Export oder Druck andere böse Überraschungen. scribus-doc-1.4.0+r17300/doc/de/old/install3.html 0000644 0001750 0001750 00000011371 11707344721 020122 0 ustar malex malex
Um Scribus auf Ihrem System zu installieren, entpacken Sie bitte das heruntergeladene Archiv mit den Quelldateien. Geben Sie dann im Basisverzeichnis der Scribus-Quelldateien folgendes in die Konsole ein:
Den Befehl make install müssen Sie stets als Benutzer mit root-Rechten ausführen, es sei denn, Sie haben ./configure mit der Option --prefix=[dir] aufgerufen, um ein anderes Verzeichnis festzulegen. Das folgende Beispiel zeigt, wie Sie Scribus in Ihr home-Verzeichnis installieren können. (Mehr Informationen als in der folgenden Zeile finden Sie im Kapitel Parallel Install, wo behandelt wird, wie sich mehr als eine Version von Scribus gleichzeitig installieren lassen.)
Wenn Sie beim Ausführen von ./configure eine Warnmeldung erhalten, müssen Sie die Versionen von autoconf und automake überprüfen, indem Sie eingeben:
Wenn sie nicht wenigstens den Versionen entsprechen, die im Kapitel Requirements genannt werden, müssen Sie eventuell - je nach Ihrer Distribution - angeben, daß eine höhere Version verwendet werden soll, und zwar etwa so:
Nachdem Sie diese beiden Befehl ausgeführt haben, vergleichen Sie bitte erneut die Versionsnummern. Wenn sie immer noch nicht den erforderlichen entsprechen, bleibt Ihnen nur, diese Programme zu aktualisieren; jedoch enthalten die meisten Distributionen eine ausreichend hohe Version.
Über die Kommandozeile können Sie Scribus mit folgenden Optionen aufrufen:
Ausgabe:
Standardmäßig befindet sich die ausführbare Scribus-Datei in /usr/local/bin. Die Dokumentation befindet sich in /usr/local/lib/scribus/doc.
Außerdem gibt es noch eine desktop.config-Datei namens scribus.desktop, die als Menükürzel oder als Schnellstarter auf dem Desktop dienen kann. Kopieren Sie die Datei einfach aus dem Installationverzeichnis auf Ihren KDE-Desktop, dort können Sie dann Scribus starten. Wenn Sie die Datei auf den Desktop gezogen haben, müssen Sie noch dafür sorgen, daß sie "ausführbar" ist. Mit einem Rechtsklick können Sie prüfen, ob das entsprechende Kontrollkästchen aktiviert ist. Diese Datei entspricht den jüngsten Spezifikationen von www.freedesktop.org.
Da Scribus autoconf verwendet, sollten Sie - sofern Sie die korrekten Versionen der Entwickler-Bibliotheken besitzen - kaum Probleme beim Kompilieren haben. Falls es dennoch zu Schwierigkeiten kommt, wenden Sie sich bitte an die Scribus-Mailingliste oder unseren IRC-Channel. Beachten Sie hierzu das Kapitel Community Resources in diesem Handbuch.
Zuguterletzt:
liefert zusätzliche Informationen für den Anfang.
scribus-doc-1.4.0+r17300/doc/de/old/machints2.html 0000644 0001750 0001750 00000012312 11707344721 020255 0 ustar malex malexAnmerkung des Autors: Diese Tips beruhen auf Ratschlägen und Hinweisen, die uns Martin Costabel freundlicherweise überlassen hat. Bei der Betreuung des Fink-Pakets für Scribus hat er schier Unglaubliches geleistet, und ebenso unterstützt er die Benutzer von Fink über die Mailingliste.
Installieren Sie die erforderlichen Bibliotheken. Diese dürften am einfachsten zu bekommen sein, indem Sie fink install scribus eingeben und abbrechen, sobald alle erforderlichen Komponenten installiert sind und Fink damit beginnt, Scribus zu kompilieren. Eine Liste mit den notwendigen Paketen finden Sie in der Fink-Datei scribus.info unter "Depends" und "BuildDepends". Die aufgeführten Abhängigkeiten werden automatisch aufgelöst und von Fink installiert.
Abhängigkeiten
Abhängigkeiten beim Selbstkompilieren
Einrichten der Umgebung:
Wenn Sie tcsh als Shell benutzen:
Wenn Sie bash als Shell benutzen:
Dann kann folgendes eingegeben werden:
Es ist nicht erforderlich, autoconf und automake unter Fink zu installieren, da diese bereits in MacOSX 10.3 integriert sind. Nun das obligatorische configure wie folgt:
--with-extra-includes=/sw/include
--with-pythondir=/System/Library/Frameworks/Python.framework/Versions/2.3/
Bevor sich nun make eingeben läßt, werden noch die Patches benötigt, welche gemäß "PatchScript" in der Fink-Datei scribus.info ausgeführt werden.
Die erste Gruppe Patches hilft dabei, die richtigen Header- und Bibliotheken-Versionen von FreeType (jene von Fink, denn Apples X11 hat eine veraltete FreeType-Version) sowie die richtige Version von Python (der von MacOSX) zu ermitteln:
Die zweite Gruppe Patches ist notwendig, um die Plug-ins zu erstellen. Keine optimale Lösung, es geht vermutlich auch anders.
Dann kann folgendes eingegeben werden:
Dies installiert Scribus nach /usr/local, wodurch Konflikte mit einer anderen, von Fink installierten Version vermieden werden, die sich in /sw befindet.
Stellen Sie sich vor, Sie hätten Scribus bereits 1x Installiert. Das ist gar nicht so unwahrscheinlich, denn wegen seiner Qualität und Brauchbarkeit ist Scribus ja bereits in vielen Distributionen enthalten. :)
Und dann käme der Tag X - der Tag, an dem Sie zufällig lesen, daß die CVS-Version von Scribus das absolute Super-Feature enthält! Sie wollen die Version unbedingt ausprobieren, befürchten aber Probleme mit ungetestetem Code usw., weshalb ein Austausch gegen das stabile Paket, das ja installiert ist, nicht in Frage kommt.
Nehmen wir an, Sie hatten Scribus von Ihrer bevorzugten Distribution installiert (rpm, deb usw. - je nach Distribution) oder von Quelldateien (tar.gz - meist nach /usr/local) gebildet, und Sie besitzen nun eine brandheiße Kopie vom CVS-Server. Führen Sie folgende Schritte als normaler Benutzer durch, nicht als root.
Erstellen Sie (mit dem Dateimanager ihrer Wahl) ein Installationsverzeichnis für das neue Scribus, z.B.:
Dann wechseln Sie in das Verzeichnis des heruntergeladenen und entpackten CVS-Pakets:
Geben Sie ein: (nur für CVS nötig)
Jetzt kommt das Wichtigste. Sie müssen als Ziel das Installationsverzeichnis für das CVS-Scribus angeben, damit das Paket aus Ihrer Distribution oder ein standardmäßig installiertes tar.gz-Paket nicht überschrieben wird:
Danach kommt das klassische:
Wenn das erledigt ist, können Sie die neue Version starten, indem Sie eingeben: ~/scribus_cvs/bin/scribus
Die Verwendung von CJK (Chinesisch, Japanisch, Koreanisch) in Scribus ist möglich. Abgesehen von Codierungen für KOIR-8, die hinzugekommen sind, hat sich tatsächlich nicht viel getan, um CJK-Schriftarten zu unterstützen - noch nicht! Allerdings berichten einige Anwender von Fortschritten, insbesondere bei der Nutzung exportierter PDF-Dateien für kommerzielle Druckaufträge. Da Unicode von Qt ohnehin bestens unterstützt wird, ist die Arbeit schon teilweise getan. Ein weiteres Stück davon sollte in der nächsten Scribus-Generation bewältigt sein, so daß wesentlich mehr nicht-lateinische Schriften unterstützt werden. Bleiben Sie also auf dem Laufenden!
Mit zunehmender Anwendungserfahrung ist mir deutlich geworden, daß DTP zu einem Bereich gehört, wo plattformübergreifende Aspekte eine größere Rolle spielen als bei den meisten anderen Anwendungsarten. Zwar ist PDF dabei sehr hilfreich, doch früher oder später kommt es zu Überraschungen.
Schauen Sie sich die Web Links zum Thema plattformübergreifende Werkzeuge und Downloads an.
Für diejenigen, die Scribus unter Windows 2000 oder Windows XP verwenden möchten, gibt es eine Windows-Version: http://windows.scribus.net.
scribus-doc-1.4.0+r17300/doc/de/old/machints1.html 0000644 0001750 0001750 00000006500 11707344721 020256 0 ustar malex malexAnmerkung des Autors: Diese Tips beruhen auf Ratschlägen und Hinweisen, die uns Martin Costabel freundlicherweise überlassen hat. Bei der Betreuung des Fink-Pakets für Scribus hat er schier Unglaubliches geleistet, und ebenso unterstützt er die Benutzer von Fink über die Mailingliste. Einige dieser Tips sind für Leute mit DTP-Erfahrung gedacht, die weniger mit den Launen von X11 bzw. dessen Umgang mit Schriftarten vertraut sind.
Es gibt zwei Möglichkeiten – beide gleichermaßen einfach:
Je nach dem, was Sie installiert haben und wie schnell Ihre Internetverbindung ist, kann es nur wenige Minuten dauern oder sich zu einem langen Download ausweiten, bis die benötigten Bibliotheken installiert sind. Wenn Sie Scribus-Binärdateien installieren, werden die Abhängigkeiten von Fink automatisch aufgelöst. Für die empfohlenen Pakete gilt das nicht, so daß Sie Fink anweisen müssen, diese für Sie zu installieren.
Für Scribus gelten folgende Abhängigkeiten:
Empfohlen, aber nicht absolut notwendig:
Ich würde das Paket der gimp-freefonts nicht unbedingt mit Scribus verwenden, obwohl sie in anderen Anwendungen vielleicht tadellos funktionieren.
Darüber hinaus unterstützt Scribus OpenType-Schriftarten, jedoch nicht im DFONT-Format, das MacOSX verwendet. Sie können fondu als Hilfsmittel einsetzen, um Schriftarten mit "Resource-Forks" (d.h. unsichtbaren Zusatzinformationen) in ein Format umzuwandeln, das auch X11 versteht.
Neuere X-Window-Systeme mit sogenanntem fontconfig-System nutzen ein persönliches Schriftarten-Verzeichnis, meist in einem versteckten Verzeichnis namens .fonts. Scribus ist in der Lage, dieses und andere Verzeichnisse, die Type-1-(PC)- oder TrueType/OpenType-Schriftarten enthalten, zu benutzen. Scribus benötigt für Type 1-Schriftarten keine .afm-Dateien, es reichen die .pfm-Dateien. Die Schriftarten-Eigenschaften bekommt Scribus via Freetype2.
Wenn Sie die aktuellste SVN-Version kompilieren möchten, schauen Sie bitte hier: Mac OSX/Fink & SVN
Bisher haben wir die Grundlagen des Farbmanagements behandelt und beschrieben, wie man es aktiviert und konfiguriert. Nun können wir erwägen, PDF/X-3-Dateien für den professionellen Druck auszugeben. PDF/X-3 ist der neueste und fortschrittlichste ISO-Standard für PDF-Dateien, und Scribus unterstützt diesen Standard vollständig. Scribus war die erste DTP-Anwendung, die in der Lage war, PDF/X-3-Dateien auszugeben.
Der größte Vorteil von PDF/X-3 ist die meist genauere Farbumwandlung von RGB zum CMYK-Farbraum des Druckers. Diese Genauigkeit wird erreicht, indem man bis zum Schluß im RGB-Farbraum arbeitet und den RIP (Raster Image Processor) des Druckers die Umwandlung von RGB nach CMYK durchführen läßt. Der Nachteil ist, daß bisher nur sehr neue oder aktualisierte RIPs PDF/X-3 unterstützen, auch wenn andere RIPs möglicherweise mit früheren PDF/X-Versionen arbeiten können. Da der RIP detaillierte Informationen über den genauen Farbumfang und dessen Möglichkeiten enthält, erwartet man in den meisten Fällen eine präzisere Umwandlung. Es ist nicht ausgeschlossen, in PDF/X-3-Dateien CMYK-Bilder zu verwenden, aber idealerweise benutzt man so lange wie möglich RGB-Farben.
PDF/X-3 hat zwei große Nachteile: Erstens können Dateien keine Transparenzen enthalten. PDF/X-3 basiert auf PDF 1.3, das keine Transparenzen unterstützt. Zweitens: Die geringe, aber stetig wachsende Zahl der Druckereien, die PDF/X-3 verarbeiten kann. Falls Sie sich nicht sicher sind, fragen Sie nach. Meine Tests zeigen sehr verläßliche Resultate, die Farbabweichungen sind minimal.
Ein weiteres Problem ist das Auswählen des richtigen Druckerprofils. Dafür gibt es zwei Lösungswege: Entweder Sie besorgen sich ein Profil für die gewählte Papiersorte von ihrer Druckerei oder Sie verwenden einen verbreiteten Druckstandard wie SWOP, ECI oder andere. Wenn Sie PDF/X-3 verwenden, müssen Sie mit Ihrer Druckerei zusammenarbeiten, aber dadurch können Sie die Farbgenauigkeit deutlich verbessern. Wie immer empfehlen wir ein Gespräch mit der Drucker im voraus. Wenn die Auskünfte unbefriedigend sind, suchen Sie sich einen anderen Drucker. Im Druckgeschäft herrscht starker Wettbewerb, weshalb sich fast immer Alternativen finden.
Erfahrungen aus der Praxis
Der Autor dieser Zeilen hat Scribus mit eingeschaltetem Farbmanagement mit zahlreichen Bildern getestet. Es handelte sich dabei um hochauflösende RGB- und CMYK-Bilder, die unter Windows 2000 mit den neuesten Farbmangementwerkeugen, Photoshop 6 und kalibrierten professionellen DTP-Monitoren vorbereitet wurden und von denen anschließend auf PostScript_level-3-Druckern Proofs erstellt wurden. Die Bilder wurden als Titelfotos für ein Magazin benutzt, das jährlich mehr als eine Million Exemplare verkauft. Indem die gleichen Druckerprofile wie bei der Herstellung der Zeitschrift eingesetzt wurden, konnten littlecms und Scribus eine bemerkenswert genaue Vorschau erzeugen, wenn man bedenkt, daß beide noch relativ jung sind. Die Präzison von littlecms hat sich in jeder Version seit 1.1 verbessert, besonders was die absolut farbmetrische Render-Priorität angeht. Seit Version 1.11 unterstützt littlecms Tiefenkompensierung, die in Scribus verwendet werden kann. Damit läßt sich der Kontrast in Fotos verbessern.
Wenn PDF-Dateien im Acrobat Reader 4.05 geöffnet werden, kann es manchmal zu Farbverschiebungen kommen. Dies ist ein Fehler in dieser Acrobat-Version. In späteren Versionen ist dieses Problem behoben, wie überhaupt die Farbdarstellung verbessert wurden. Im Acrobat Reader ab Version 7 werden auch die PDF-Formulare, die Sie mit Scribus erstellen können, richtig wiedergegeben.
Fazit
Anhand eines Beispiel haben wir beschrieben, wie die Farbamanagement-Strategie für ein Dokument aussehen kann. Wenden Sie ein Profil auf eine Bilddatei an und wählen Sie die richtige Render-Priorität zur Umwandlung in ein anderes Farbmodell aus. In unserem Beispiel teilt Scribus littlecms mit, daß es eine Uwandlung in zwei Schritten vornehmen soll, damit Ihr Monitor Bilder und Farben mit ausreichender Genauigkeit so darstellt, wie sie gedruckt aussehen, wenn Sie die Option "Druckerfarben auf dem Bildschirm simulieren" aktivieren.
Die Integration eines einfachen, aber effektiven Farbmanagements in Scribus ist ein ehrgeiziges und nach Meinung des Autors in der Open-Source-Welt erstmaliges Unterfangen, dem Endanwender Farbmanagement zu ermöglichen. Solche Werkzeuge finden sich für gewöhnlich in High-End-Pre-Press-Anwendungen. Für die Open-Source-Szene war dies lange ein unbekanntes Territorium, und deshalb sind Kommentare und Vorschläge zu diesem Dokument ebenso wie Erfahrungsberichte zum Thema Farbmanagement willkommen. Sie sollten auch wissen, daß diese Technik von Grafikindustrie weiterhin verbessert wird.
Haben Sie Geduld – Farbmanagement ist eine junge Technik, die ständig verbessert wird. Es dauert seine Zeit, die Theorie zu verstehen, bevor man praktische Resultate erzielen kann.
Danksagung:
Martí Maria; Entwickler von littlecms. Ohne ihn wäre all dies nicht möglich.
scribus-doc-1.4.0+r17300/doc/de/old/gsfont.html 0000644 0001750 0001750 00000013304 11707344721 017667 0 ustar malex malexWenn Ghostscript eine Datei nicht rendern/importieren/konvertieren kann, liegt eine der häufigsten Ursachen darin, daß Ghostscript die Schriftarten nicht findet, die zur Darstellung von EPS bzw. PS nötig sind. Dies ist weder eine Schwäche noch ein Fehler von Ghostscript, denn alle EPS/PS-Interpreter müssen auf die richtigen Schriftarten zugreifen können, die PostScript ihnen vorgibt. Genau das kann sicher auch der Fall sein, wenn Sie versuchen EPS/PS-Dateien nach Scribus zu importieren. Einige Anwendungen betten die Schriftarten nicht korrekt ein, weshalb diese dann extern bereitgestellt werden müssen.
Wenn Ghostcript eine Schriftart nicht finden kann, erscheint in der Konsole gewöhnlich eine Fehlermeldung wie:
gs -h AFPL Ghostscript 8.50 (2004-12-10) Copyright (C) 2004 artofcode LLC, Benicia, CA. All rights reserved. blah blah bah... invalidfont Current allocation mode is local Last OS error: No such file or directory und so weiter...
Der Fehler invalidfont bedeutet, daß a) Ghostscript die Schriftart(en) nicht finden kann, daß b) Ghostscript keinerlei Schriftarten finden kann, oder daß c) eine Schriftart im System beschädigt oder verstümmelt ist.
Die Lösung:
$GS_SRC_DIR/toolbin/genfontmap.psDieses kann benutzt werden, um eine Fontmap-Datei zu erstellen – dasselbe machen übrigens jene furchterregenden Perl-Skripte, die im Internet zu finden sind. Diese Ghostscript-Datei muß sich nicht automatisch in Ihrer Distribution befinden, weshalb wir uns hier auf das noch gepackte tar-Quellvereichnis (für eine parallele GS-Installation) beziehen. Benutzen Sie möglichst ein genfontmap.ps der von Ihnen verwendeten Ghostscript-Version. Andere funktionieren möglicherweise nicht korrekt. Dies ist ein weiterer guter Grund, weshalb Sie sich eine neuere Version von Ghostscript beschaffen sollten.
d$ gs -q -sFONTPATH=/usr/local/share/fonts/TrueType ${HOME}/build/ghostscript-8.31/toolbin/genfontmap.ps
% This Fontmap generated by genfontmap.ps
(AndaleMono) (/usr/local/share/fonts/TrueType/AndaleMo.TTF) ;
(Arial-Black) (/usr/local/share/fonts/TrueType/AriBlk.TTF) ;
(Arial-BoldItalicMT) (/usr/local/share/fonts/TrueType/Arialbi.TTF) ;
(Arial-BoldMT) (/usr/local/share/fonts/TrueType/Arialbd.TTF) ;
... bla bla bla ...
(Utopia-Regular) (putr.pfa) ;
(Verdana) (/usr/local/share/fonts/TrueType/Verdana.TTF) ;
(Verdana-Bold) (/usr/local/share/fonts/TrueType/Verdanab.TTF) ;
(Verdana-BoldItalic) (/usr/local/share/fonts/TrueType/Verdanaz.TTF) ;
(Verdana-Italic) (/usr/local/share/fonts/TrueType/Verdanai.TTF) ;
(Webdings) (/usr/local/share/fonts/TrueType/Webdings.TTF) ;
(ZapfChancery-MediumItalic) /URWChanceryL-MediItal ;
(ZapfDingbats) /Dingbats ;
genfontmap completed OK. 42 new fonts added.
Sie leiten also die Standardausgabe um oder übertragen (mittels kopieren/einfügen) alles aus der % This Fontmap..-Zeile in einen Texteditor, um die Fontmap zu speichern. Kopieren die erstellte FontMap-Datei ins Schriftarten-Verzeichnis und fügen das Verzeichnis dann Ihrer GS_LIB-Umgebungsvariablen hinzu:
Die genaue Pfadbezeichnung kann variieren.
$ gs -q -sFONTPATH=/usr/local/share/fonts/TrueType ${HOME}/build/ghostscript-8.50/toolbin/genfontmap.ps > /tmp/Fontmap
$ sudo cp /tmp/Fontmap /usr/local/share/fonts/Truetype
$ export GS_LIB=/usr/local/share/fonts/TrueType:$GS_LIB
Nun können Sie Scribus von der Konsole aus starten. GhostScript wird die Schriftarten finden und die EPS/PS-Dateien problemlos importieren.
Alternativ können Sie Ihre GS-lib/Fontmap editieren und die neue Fontmap als Quelle eintragen – oder Sie hängen die neuen Fontmap-Einträge an Ihre bestehende lib/Fontmap an.
Obwohl sich die Ghostscript-Dokumentation größte Mühe gibt, einen anderen Anschein zu erwecken, werden TrueType-Schriften von Ghostscript gut unterstützt und sind einfach zu verwenden.
Ganz wichtig ist hierbei, daß die Verzeichnisse, die in der GS_FONTPATH-Umgebungsvariablen und im -sFONTPATH-Argument stehen, alle Schriftart-Typen enthalten dürfen, die unterstützt werden – und nicht allein PostScript-Schriftarten, wie es die Dokumentation darstellt.
$ export GS_FONTPATH=$MY_FONT_DIR:$HOME/.fonts $ scribus
Der EPS-Import in Scribus ist verknüpft mit dem Schriftarten-Pfad von Ghostscript. Wenn GS die Schriftarten nicht findet, so werden sie kommentarlos ersetzt. Wenn Sie das nicht möchten, sorgen Sie also unbedingt dafür, daß GS diese finden kann.
Es ist zu empfehlen, daß Sie für Ihre Schriftarten-Verzeichnisse Fontmap-Dateien erstellen und diese der GS_LIB-Umgebungsvariablen hinzufügen, denn hierdurch kann GS seine Schriftarten künftig schneller laden. Tests haben bestätigt, daß – sobald GS informiert ist, wo sich die Schriftarten befinden – der EPS-Import in Scribus munter auf lokale Schriftarten zugreift, um dort eine passende zu finden, die von EPS gewünscht, jedoch nicht eingebettet wurde.
scribus-doc-1.4.0+r17300/doc/de/old/scprinters.html 0000644 0001750 0001750 00000003562 11707344721 020570 0 ustar malex malexWenn Sie Ihr Meisterwerk vollendet haben, ist der nächste Schritt manchmal, es in einer Druckerei drucken zu lassen.
Zuallererst natürlich die Fähigkeit, PDF-Dateien ohne Umwandlung in ein anderes Format zu verarbeiten. Eine Umwandlung wird nicht empfohlen, da dies eine schlechtere Druckqualität zur Folge haben könnte. Im idealen Fall kann eine Druckerei Scribus-Dateien verarbeiten, aber das ist nicht zwingend notwendig. Am wichtigsten ist der richtige Umgang mit neueren PDF-Versionen ohne weitere Formatumwandlung.
Die folgende Liste ist nicht erschöpfend, aber es handelt sich um Druckereien, die an der Entwicklung von Scribus beteiligt waren und/oder ihre Bereitschaft gezeigt haben, native Scribus-Dateien oder von Scribus erzeugte PDF-Dateien zu verarbeiten.
Mardigrafe in Montreal – kann native Scribus-Dateien verarbeiten. Texte können in Englisch, Französisch, Deutsch, Italienisch, Russisch und Spanisch bearbeitet werden.
Cape Cod Ink in Massachusetts. Kann viele Arten von Druckaufträgen erledigen, auch kurzfristig. Kann auf Anfrage native Scribus-Dateien verarbeiten.
Digital Print Center in Konstanz – ein Spezialist für Digitaldruck und Database-Publishing.
Wenn Sie Druckereien kennen, die in der Liste genannt werden sollten, senden Sie eine E-Mail an mrdocs at scribus.info.
scribus-doc-1.4.0+r17300/doc/de/old/toolbox11.html 0000644 0001750 0001750 00000004722 11707344721 020223 0 ustar malex malexDie unten genannten Programme gehören zur Kategorie der Vektorisierungs- oder "Tracing"-Werkzeuge. Wenn Sie häufig mit eingescannten Bildern arbeiten, empfehle ich ihnen, alle zu verwenden. Sie haben einige gemeinsame Funktionen, indem sie Bitmapgrafiken öffnen und sie in Vektordaten umwandeln können. Dies kann etwa wünschenswert sein, wenn Zeichnungen oder Gemälde mit großer Genauigkeit wiedergegeben werden sollen. Ich empfehle alle Programme, weil sie unterschiedliche Algorithmen zur Umwandlung verwenden.
Autotrace/FrontLine: Kann ImageMagick zum Umwandeln in verschiedene Formate verwenden. Frontline ist eine grafische Benutzeroberfläche, die GTK verwendet, um die zahlreichen Kommandozeilenoptionen zugänglich zu machen.
Delineate: Eine auf Java basierende Benutzeroberfläche für Autotrace und Potrace. Erfreulicherweise kann es direkt nach SVG umwandeln.
Potrace: Arbeitet nur in schwarzweiß, aber es verfügt über eine sehr gute Vektorisierungsroutine. Für Potrace gibt es eine grafische Benutzeroberfläche, die Qt3 verwendet.
Pstoedit: Unterscheident sich geringfügig von den übrigen Programmen, da es auf die Umwandlung von Postscript in Vektordaten spezialisiert ist. Es ist ein Plug-in für GSview.
Inkscape: Verwendet Potrace, um Bitmaps zu vektorisieren. Es ermöglicht Umwandlungen in Schwarzweiß und Farbe und verfügt über eine Vorschau. In aktuellen Entwicklerversionen ist ein "Farbeimer"-Füllwerkzeug enthalten, das vielfältige Möglichkeiten zum interaktiven Vektorisieren ausgewählter Bildbereiche bietet. Diese Funktion wird Bestandteil von Version 0.46 sein.
Wenn Sie Bilder vektorisieren, sollten Sie bedenken, daß es viele Optionen gibt, dies zu tun. Daher müssen Sie manchmal ein wenig experimentieren, besonders wenn die Vorlage komplex ist. Erwarten Sie keine perfekten Ergebnisse. Als ich es das erste Mal probiert habe, mußte ich ein bißchen tüfteln, um ein Scribus-Logo, das als EPS-Datei mit einer eingebettetem Bitmapdatei vorlag, in eine reine SVG-Grafik für den Import in Scribus umzuwandeln.
mit Dank an Maciej Hanski, der dies freundlicherweise aus dem polnischen Original (mit GNU-Lizenz für freie Dokumentation) übersetzt hat.
Die Beispieldatei scribusformphp.tar.gz, ein Tarball-Archiv mit PHP-Datei und einem Beispieldokument, ist erhältlich unter http://docs.scribus.net
Einer der größten Vorteile von Scribus ist die Möglichkeit, PDF-Formulare mit eingebetteten JavaScript-Skripten (als Adobe-eigene Version, beschrieben in der Adobe Javascript-Referenz unter http://partners.adobe.com/asn/developer/pdfs/tn/5186AcroJS.pdf) zu erstellen.
Es ist recht einfach, mit Scribus ein neues Formular zu erstellen. Als erstes klicken wir auf die Schaltfläche "Neues Dokument" oder wählen im Menü unter Datei den Punkt Neu.
 |
Nachdem wir das Gitternetz (Menü Ansicht -> Gitter ein) aktiviert haben, wird es uns dabei helfen, die Formularfelder korrekt auf der Seite auszurichten. Für den Titel und die Feldbezeichnungen benötigen wir einige Textrahmen - Nur wenige Klicks auf die Schaltfläche [ab], und alle Textrahmen erscheinen im Nu.
 |
Wenn unsere Rahmen mit Text gefüllt sind, können wir ihre Eigenschaften über die Eigenschaften-Palette ändern, die sich im Menü unter Werkzeuge befindet.
 |
 |
Das gerade aktive Element des Formulars hat einen Rahmen mit rotem Rand; Sie können ein Element aktivieren, indem Sie auf die Schaltfläche "Auswählen" (die mit dem Pfeilkreuz) und dann auf das gewünschte Element klicken.
 |
Wenn Sie auf ein Element rechtsklicken, aktivieren Sie ein neues Menü. Wir wählen Feldeigenschaften und definieren Feldnamen (wir brauchen die Feldnamen für unser PHP-Skript, wohin das Formular gesendet wird), Feldtypen (z.B. Zahl, Zeit, Datum) sowie Aktionen, die bei bestimmten Ereignissen ausgeführt werden sollen (Mouse-Enter, Mouse-Exit, onBlur - also beim Verlassen des Elements - usw.).
 |
Hier definieren wir das Feld No als Zahl. Der Acrobat Reader wird danach nichts anderes als gültige Eingabe akzeptieren.
 |
Hier definieren wir nun selbst ein Kontrollskript für das Feld Name: Nach Änderung des Feldinhalts wird ein akustisches Signal ertönen, und es erscheint eine Warnmeldung (nicht sehr anspruchsvoll, ich weiß, doch immerhin ausreichend, um die Möglichkeiten von PDF zu zeigen). Scribus hat einen eigenen einfachen Texteditor, mit dem wir das Skript als separate Datei speichern können. Selbstdefinierte Skripte lassen sich nicht nur auf Formularfeld-Ebene, sondern auch als globale Skripte anlegen (Bearbeiten -> JavaScripts).
 |
Wenn das Skript gespeichert und der Editor geschlossen ist, erscheint der Skript-Inhalt unter Feldeigenschaften.
 |
Wir müssen noch festlegen, an welchen URL der Inhalt des Formulars gesendet wird (Ein einfaches PHP-Skript an der Zieladresse wird die empfangenen Daten formatieren und darstellen). Unter "Eigenschaften" wählen wir für die Schaltfläche den Aktionstyp Submit form/Formular abschicken und geben die Adresse unseres PHP-Skripts ein: scribus_test.php. Schließlich markieren wir noch das Kästchen Daten als HTML übertragen (die andere Möglichkeit, als FDF-Daten, wäre etwas ganz anderes), und damit sind wir nun fertig.
 |
Das einzige, was noch zu tun bleibt, ist der Export des Dokuments nach PDF: Menüauswahl Datei -> Export... ->; Export nach PDF....
Wir wählen Acrobat 5.0 als Dateiformat aus und speichern das Dokument.
 |
Das Ergebnis unserer Arbeit kann von hier heruntergeladen und getestet werden: http://docs.scribus.net. Damit das Formular übermittelt werden kann, müssen wir es in einem Browserfenster öffnen, wobei Netscape 4.* oder Mozilla die sichersten sind (Kontrollieren Sie die Plugins von Mozilla, um zu sehen, ob das Acrobat Reader-Plugin aktiviert ist. Falls nicht, müssen Sie es mit Mozillas Plugin-Verzeichnis symbolisch verlinken. In meinem Fall hier heißt Mozillas Plugin-Verzeichnis /usr/lib/mozilla-1.3/plug-in, und das hiermit zu verlinkende Plugin heißt /usr/local/Acrobat5/Browsers/intellinux/nppdf.so).
Mein ganz persönlicher Eindruck: Scribus ist als Werkzeug für die Arbeit mit PDF-Formularen komfortabler zu bedienen als Adobe Acrobat 5.0 (der einzigen Version, mit der ich gearbeitet habe). Es ist wesentlich einfacher, mit Scribus ein Dokumentenlayout zu gestalten, denn Acrobat gestattet nur das Bearbeiten existierender Dokumente, ein völlig neues Erstellen ist damit nicht möglich. Scribus stellt uns die volle Kontrolle über das Endergebnis zur Verfügung und läßt uns viel mehr Freiheit beim Ändern eines Dokumentenlayouts. Außerdem lassen sich Scribus-Dateien sogar mit einem simplen Texteditor bearbeiten, denn sein Dateiformat basiert völlig auf XML.
Maciej Hanski - 22.10.2003
Einige nützliche PDF/JavaScript-Links:
Einige nützliche CGI/PHP-Links:
Die Programme, die Sie benötigen, um Scribus zu kompilieren, sind:
Die Abhängigkeiten zum Kompilieren und zur Verwendung von Scribus sind:
Scribus läuft in jeder Desktopumgebung und benötigt kein KDE, aber Drag’n’drop funktioniert nur in KDE.
Falls das Farbmanagement nicht funktioniert, müssen Sie zusätzlich mindestens ein RGB- und ein CMYK-Profil installieren. Anderenfalls werden die Farbmanagement-Optionen ausgeblendet oder ausgegraut. Normalerweise installiert Scribus ein RGB- and ein CMYK-Profil, und zwar nur, um das Farbmanagement zu aktivieren, aber aufgrund ihrer Lizenzpolitik (v.a. Debian) befinden sich die Profile u.U. in einem separaten Paket.
Unsere Tests legen nahe, die korrekten "-march="-CXXFLAGS zu setzen, weil dies die Scribus-Performance erhöht. Wenn Sie beispielsweise einen Duron- or Athlon-Prozessor einsetzen, ist export CXXFLAGS="-march=athlon" von Nutzen. Überprüfen Sie, ob die von Ihnen verwendete Distribution diese Parameter für Sie setzt. Weitere Informationen erhalten Sie per:
Detaillierte Hinweise finden Sie in der Datei BUILDING, und Paketierer für Distributionen sollten einen Blick in die Datei PACKAGING werfen.
In Version 1.3.3.6 haben wir erstmals Unterstützung für CMake als Alternative zu den traditionellen Autotools angeboten. Wir waren damit so zufrieden, daß Scribus seit Version 1.3.5 nur noch dieses Build-System verwendet und die Autotools nicht mehr funktionieren. Siehe die CMake-Anleitung.
linkTextFrames("fromname", "toname")
Link two text frames. The frame named "fromname" is linked to the frame named "toname". The target frame must be an empty text frame and must not link to or be linked from any other frames already.
May throw ScribusException if linking rules are violated.
loadImage("filename" [, "name"])
Loads the picture "picture" into the image frame "name". If "name" is not given the currently selected item is used.
May raise WrongFrameTypeError if the target frame is not an image frame
scaleImage(x, y [, "name"])
Sets the scaling factors of the picture in the image frame "name". If "name" is not given the currently selected item is used. A number of 1 means 100 %.
May raise WrongFrameTypeError if the target frame is not an image frame
setCornerRadius(radius, ["name"])
Sets the corner radius of the object "name". The radius is expressed in points. If "name" is not given the currently selected item is used.
May raise ValueError if the corner radius is negative.
setFillColor("color", ["name"])
Sets the fill color of the object "name" to the color "color". "color" is the name of one of the defined colors. If "name" is not given the currently selected item is used.
setFillShade(shade, ["name"])
Sets the shading of the fill color of the object "name" to "shade". "shade" must be an integer value in the range from 0 (lightest) to 100 (full Color intensity). If "name" is not given the currently selected Item is used.
May raise ValueError if the fill shade is out of bounds.
setGradientFill(type, "color1", shade1, "color2", shade2, ["name"])
Sets the gradient fill of the object "name" to type. Color descriptions are the same as for setFillColor() and setFillShade(). See the constants for available types (FILL_<type>).
setLineCap(captype, ["name"])
Sets the line cap style of the object "name" to the style "cap". If "name" is not given the currently selected item is used. There are predefined constants for "cap" - CAP_<type>.
setLineColor("color", ["name"])
Sets the line color of the object "name" to the color "color". If "name" is not given the currently selected item is used.
setMultiLine("namedStyle", ["name"])
Sets the line style of the object "name" to the named style "namedStyle". If "name" is not given the currently selected item is used.
May raise NotFoundError if the line style doesn't exist.
setLineJoin(join, ["name"])
Sets the line join style of the object "name" to the style "join". If "name" is not given the currently selected item is used. There are predefined constants for join - JOIN_<type>.
setLineShade(shade, ["name"])
Sets the shading of the line color of the object "name" to "shade". "shade" must be an integer value in the range from 0 (lightest) to 100 (full color intensity). If "name" is not given the currently selected item is used.
May raise ValueError if the line shade is out of bounds.
setLineStyle(style, ["name"])
Sets the line style of the object "name" to the style "style". If "name" is not given the currently selected item is used. There are predefined constants for "style" - LINE_<style>.
setLineWidth(width, ["name"])
Sets line width of the object "name" to "width". "width" must be in the range from 0.0 to 12.0 inclusive, and is measured in points. If "name" is not given the currently selected item is used.
May raise ValueError if the line width is out of bounds.
traceText(["name"])
Convert the text frame "name" to outlines. If "name" is not given the currently selected item is used.
unlinkTextFrames("name")
Remove the specified (named) object from the text frame flow/linkage. If the frame was in the middle of a chain, the previous and next frames will be connected, eg 'a->b->c' becomes 'a->c' when you unlinkTextFrames(b)'
May throw ScribusException if linking rules are violated.
Die Kompetenz und Flexibilität von Scribus beim PDF-Export ist eines seiner hervorstechenden Merkmale. Hier all seine Funktionen vollständig zu dokumentieren, das würde fast ein gesondertes Kapitel nötig machen. Ich empfehle Ihnen, diesen Einführungsteil aufmerksam zu lesen, um sich mit allen PDF-Funktionen und Möglichkeiten vertraut zu machen, wobei Sie sich zugleich einige der von Scribus erstellten PDF-Dokumente anschauen sollten, die im Download-Bereich von www.scribus.net verfügbar sind.
Die Plattformunabhängigkeit von PDF macht es Scribus-Anwendern möglich, einige potenzielle Hürden zu überwinden, die Linux und DTP eigen sind. Scribus exportiert zuverlässig und in hoher Qualität ein "druckreifes" PDF-Ergebnis. Darin enthalten sind die neuen Besonderheiten der PDF-Version 1.4, ein ISO-konformes PDF/X-3 sowie PDFs mit ICC-Farbmanagement, dank Little CMS. Falls Ihre Druckerei sich skeptisch zeigt, verweisen Sie bitte auf Scribus Druckvorstufe. Das ist ein PDF-Dokument zum Herunterladen, in dem Druckvorstufen-Tests mit Scribus dargelegt sind, ergänzt durch weitere Zusatzinformationen.
Wenn Scribus nur hochauflösende PDFs bester Handelssorte erzeugte, so würde das allein schon reichen, es ein großartiges Anwendungsprogramm zu nennen. Ein Plus ist seine einfach zu nutzende Vielseitigkeit: Es erstellt Präsentationen á la Powerpoint oder internetfähige, interaktive PDF-Formblätter für den Elektronischen Dokumentenaustausch, und es kann mittels JavaScript bestimmte Elemente innerhalb der PDF-Datei steuern. Scribus verfügt über weitere benutzerfreundliche Funktionen wie Anmerkungen, Lesezeichen - und falls erwünscht oder benötigt: Dokumentensicherheit.
Während PDF in gewisser Hinsicht einen proprietären Standard darstellt, ist es außerdem auf quasi jeder Computer-Plattform weitreichend verfügbar. Darüber hinaus ist es bestens dokumentiert. Das Benutzerhandbuch zu PDF 1.5 umfaßt lediglich 1.100 Seiten. Die Fähigkeiten von PDF in Scribus ermöglicht die Neuorientierung eines Dokuments. Ein Dokument kann erstellt werden für den Druck, zum Herunterladen aus dem Netz oder für Präsentationszwecke wie bei StarOffice Impress oder MS PowerPoint. Daß dies beim DTP als ein Zukunftstrend gelten kann, zeigt sich darin, daß eben diese Strategie sowohl in Adobes InDesign 2.0+ wie auch in den neuen PDF-Fähigkeiten von Quark Xpress 6 und Adobe Illustrator 10+ zu finden ist. Beim elektronischen Publishing und der Druckvorstufen-Produktion haben beide eine Vielzahl von PDF-Verbesserungen erfahren, wodurch die Beschränkungen von HTML bzw. des traditionellen PostScript oftmals aufgehoben werden.
Die besten Bildschirm- oder Druckergebnisse erzielen Sie mit der neuesten Version des Acrobat Reader 5.0.8 für Linux bzw. Version 6.0+ auf anderen Plattformen, soweit verfügbar. Tests haben gezeigt, daß der Linux-Version einiges an Funktionalität fehlt, insbesondere bei den JavaScript-Fähigkeiten der Versionen 4.05 und 5.0.8 unter Linux. Einige dieser Fehler sind beim Acrobat Reader 5.0.5+ auf dem Apple Macintosh oder unter Win32 nicht vorhanden.
Eine der Herausforderungen bei PDF- und EPS-Betrachterprogrammen unter Linux ist, daß Scribus hochqualitative Dokumente in PostScript-Level 3 und PDF 1.4 erstellt, deren Leistungsvermögen die meisten freien (Open Source) Betrachterprogramme überfordert. Einige dieser Funktionen werden nur von kommerziellen Druckvorstufen- oder DTP-Programmen unterstützt. Nach mehr als zweijähriger Arbeit mit Scribus bin ich zu dem Schluß gekommen, daß folgende 3 Betrachterprogramme zur Darstellung von PS/EPS/PDF-Dokumenten, die von Scribus erzeugt wurden, am zuverlässigsten sind:
pstoedit und epstool. Weitere Einzelheiten und Tipps finden Sie hier: GSview. Ich betrachte es als ein für Linux unerläßliches Programm.Wenn Sie irgendeinen anderen PDF- oder EPS- Betrachter verwenden, der die von Scribus erzeugten PDF-Dateien nicht darstellen kann, diese jedoch im Acrobat Reader einwandfrei zu sehen sind, schreiben Sie dem Programmautor einen Fehlerbericht. In praktisch allen Fällen, die ich getestet habe, liegt die Beschränkung beim Betrachterprogramm. Scribus-PDFs werden täglich mit spezieller Druckvorstufen-Software getestet, um die Einhaltung der offiziellen PDF-Spezifikationen zu überprüfen.
scribus-doc-1.4.0+r17300/doc/de/faq2.html 0000644 0001750 0001750 00000011753 10673051435 016446 0 ustar malex malexWarum verwendet Scribus Qt und kein anderes Toolkit??
Als Franz Schmid das Projekt gestartet hat, verwendete er zunächst Python. Aus Performancegründen hat er sich entschieden, Scribus nach C++ zu portieren. Das Toolkit mit der umfangreichsten Dokumentation war zu dieser Zeit Qt 2.2. Die erste Version, die Qt2 verwendet hat, war 0.3 (2001). Scribus wurde nach der Veröffentlichung auf Qt 3 portiert. Ab Version 1.3.5 wird Scribus Qt4 benutzen. Nach obenWoher stammt der Name "Scribus"?
Als Franz Schmid das Projekt gestartet hat, lautete der Arbeitstitel "Open Page", aber er hielt ihn für zu allgemein. Scribus ist von der lateinischen Bezeichnung für Schreiber im alten Rom (Scriba) abgeleitet. Dieses Wort hat sich in vielen Sprachen erhalten, etwa im englischen "scribe" oder im deutschen "Schreiber". Scribus wird entweder englisch oder lateinisch ausgesprochen.
Nach obenWarum gibt es keine Importfilter für QuarkXPress, InDesign oder andere kommerzielle DTP-Anwendungen?
Es gibt verschiedene Gründe für fehlende Importfilter für die Dateiformate kommerzieller DTP-Anwendungen
Wie kann mit Leuten zusammenarbeiten, die ein anderes Programm für das Seitenlayout verwenden?
Verwenden Sie EPS, SVG oder PDF als Austauschformat. PDF-Dateien, die mit Scribus erzeugt wurden, können problemlos von kommerziellen Programmen importiert werden. Der SVG-Import ist hervorragend für Vektorgrafiken geeignet. Scribus kann EPS-Dateien importieren, wenn Sie sich an die Spezifikationen halten. Das gilt auch für Schmuckfarben in DCS-2.0-Dateien. Das Handbuch enthält detaillierte Informationen zu diesen Themen.
Nach obenGibt es einen Microsoft-Publisher-Importfilter oder wird es einen geben?
Es gibt keinen, und es wird wahrscheinlich vom Scribus-Team auch keiner bereitgestellt. Genau wie bei InDesign und QuarkXPress ist das Dateiformat nicht dokumentiert und schwer, vielleicht gar nicht zu entschlüsseln. Selbst zwischen unterschiedlichen Publisher-Versionen ist ein reibungsloser Austausch von *.pub-Dateien problematisch.
Nach obenEin Teil der Scribus-Community trifft sich online im IRC (Internet Relay Chat). Manche werden diese Art von Support eher ungewöhnlich finden, aber unserer Erfahrung nach funktioniert er ausgesprochen gut. Normalerweise ist mindestens ein Mitglied des Scribus-Teams oder ein erfahrener Anwender »anwesend«. Die beste Zeit, um Fragen zu stellen, ist normalerweise der Abend in der mitteleuropäischen Zeitzone (MEZ). Viele denken, wenn sie IRC hören, an sogenannte Flame wars oder widerwärtigen Streit, aber #scribus ist wirklich ein freundlicher und angenehmer Kanal. Beleidigungen und Pöbeleien werden hier nicht geduldet. Eine gute deutschsprachige Einführung zum Thema IRC finden Sie beim OpenSUSE-Projekt.
Wenn Sie den Kanal zum erstenmal betreten, sagen Sie einfach »Hi« oder »Hallo« und stellen Sie Ihre Frage. Natürlich kann es (wie im richtigen Leben) nicht schaden, wenn Sie sich kurz vorstellen. Am besten probieren Sie es zunächst auf englisch, aber es gibt unter den Anwesenden zahlreiche, die auch andere Sprachen beherrschen. Deutsch und Französisch sind normalerweise kein Problem.
Es hilft bei der Problemlösung, wenn man mehr erfährt als: »Etwas ist schiefgegangen, und jetzt funktioniert Scribus nicht, wie es soll.«
IRC eignet sich sehr gut für verzögerungsfreie Kommunikation, aber manchmal sind kompetente Anwesende mit anderen Dingen beschäftigt (z.B. damit, Scribus zu programmieren …). Manche Entwickler sind 24 Stunden lang ununterbrochen eingeloggt – man nennt dies »Idling«, d.h. sie sind gar nicht an Ihrem Computer und schalten sich u.U. erst später in die Kommunikation ein. Das bedeutet natürlich nicht, daß sie tagelang auf eine Antwort warten müßten. Darüber hinaus gibt es in #scribus einen freundlichen sogenannten »Bot« mit dem Namen mrscribe, der Nachrichten weiterleiten kann. Mehr zu diesem Helferlein weiter unten.
Zum mindesten sollten Sie die Suchfunktion des Hilfebrowsers einmal benutzt haben, um zu sehen, ob Ihr Problem mit Hilfe der Online-Doukmentation gelöst werden kann. Wie Sie feststellen werden, hat das Scribus-Team sehr viel Arbeit in das Schreiben und das Übersetzen der Dokumentation gesteckt (auch wenn sie noch immer nicht ganz vollständig ist). Diese Mühe haben wir uns gemacht, um Ihnen zu helfen.
MrScribe ist unser netter »Bot«. Bots sind nützliche Programme im IRC, mit deren Hilfe sich manche Aufgabe erleichtern läßt. Er steckt auch voller nützlicher Informationen und zeigt den ihm einprogrammierten Humor der Scribus-Entwickler. Unter http://supybot.com/ erfahren Sie mehr über MrScribe.
Nachdem wir seit Jahren rund um die Uhr im IRC vertreten sind, sehen wir uns imstande, Ihnen guten Gewissens ein paar Programme zur Nutzung dieses Mediums zu empfehlen:
Wenn Ihre Frage zu Ihrer Zufriedenheit beantwortet ist, müssen Sie den Kanal nicht gleich wieder verlassen. #scribus ist nicht nur für Entwickler oder fortgeschrittene Anwender gedacht, sondern auch Anfänger sind eingeladen, sich in die Konversation einzuschalten. Außerdem ist #scribus insofern eine Rarität, als hier auch über Gott und die Welt geplaudert wird und sehr viele Späßchen gemacht werden. »off-topic is on-topic« heißt das selbstironische Motto …
Entwicker erkennen Sie meist, daran, daß sie Operator-Status haben (wenn Ihr IRC-Programm das anzeigen kann). Übrigens ist der IRC-Kanal einer jener Orte, an denen die Entwickler sehr viel über die Probleme der Anwender erfahren, und diese Erfahrungen fließen direkt in die Entwicklung ein. Manchmal wird sogar der Programmcode im Zuge einer laufenden IRC-Diskussion angepaßt!
Für Sie kann die passive Anwesenheit den Vorteil haben, daß Sie etwas über die allerneuesten Funktionen erfahren oder nützliche Tricks von den Scribus-Gurus lernen können. Wenn Ihnen danach ist, legen Sie also einfach die Füße hoch und genießen Sie es …
http://scribus-forum.de/news.php – ein sehr aktives und hilfsbereites Forum zu allen Fragen rund um Scribus.
Open DTP – ein deutschsprachiges Forum über alle möglichen Fragen zu Seitenlayout und Freien Grafikanwendungen. Es wird unterhalten von dem seit langem aktiv zu Scribus beitragenden Thomas Zastrow.
Pour les francophones, trois de l’équipe parlent français. Nous vous demandons d’abord d’essayer en anglais, mais français marche aussi sur IRC et sur la liste. Il y a plusieurs francophones souvent sur le canal. Il y a aussi un forum dedié à Scribus sur Linuxgraphic.org.
Русскоязычный сайт о работе с графикой в Linux: http://www.linuxgraphics.ru
Die folgenden Erläuterungen wurden freundlicherweise bereitgestellt vom Betreuer unserer Debian-Pakete, Oleksandr Moskalenko <malex at tagancha.org>. Bitte richten Sie Fragen, die Scribus unter Debian betreffen, direkt an vorgenannte Mailadresse.
Wichtig: Benutzen Sie APT, denn auf diesem Wege installieren Sie Debian-Pakete ordnungsgemäß als Binär- und/oder Quelldateien. Falls Sie vorhaben, sich von Quelltexten selbst ein Paket zu erstellen, stellen Sie bitte sicher, daß dpkg-dev installiert ist.
Die Scribus-Pakete für Debian GNU/Linux werden von Oleksandr (Alex) Moskalenko (malex at tagancha.org) erstellt. Bitte schreiben Sie mir eine eMail, wenn Sie Fragen haben, die nicht unter das Debian- oder Scribus-BTS (Bug Tracking System) fallen oder Sie etwas zu dieser Seite anmerken möchten.
Wenn Sie bei der Scribus-Entwicklung gern auf dem Laufenden bleiben wollen, verwenden Sie bitte Versionen aus einem Upstream-Repository (also Entwickler-Originale), denn ich kann Scribus nur über einen Sponsor nach Debian hochladen, und es braucht meist Wochen, bis er dort erscheint. Aus diesem Grunde sind die offiziellen Pakete meist deutlich älter als jene, die via Upstream-Repository verfügbar sind. Um den von Ihnen entdeckten Fehler zu testen, nehmen Sie bitte ein Paket aus einem Upstream-Verzeichnis, denn vielleicht ist er in dem neuen Paket ja schon beseitigt. Das nennt sich "Scribus magic™", eine Art Zauberei. Bitte beachten Sie, daß jedes unten aufgeführte Repository hinsichtlich Backup und zusätzlicher Übertragungsrate (falls nötig) absolut GLEICH ist. Und jedes enthält Pakete für Debian mit Status "stable, testing & unstable" sowie für die Ubuntu-Distributionen Hoary und Breezy.
Fügen Sie folgende Zeilen in Ihre /etc/apt/sources.list:
Debian stable
Debian testing
Debian unstable
Ubuntu Hoary
Ubuntu Breezy
Sobald die Zeilen für die relevanten Quellen eingetragen sind, können Sie
die Paket-Datenbank aktualisieren:
oder
Alternativ können Sie eine von Ihnen bevorzugte grafische "apt-get"-Bedienoberfläche wie den Synaptic Package Manager verwenden (Vergessen Sie dort bitte nicht, mit "Reload Package List" die Paketliste neu zu laden. Es ist dasselbe wie der "update"-Befehl von apt-get und muß ausgeführt werden, bevor Ihnen neue Pakete aus diesen Repositories zur Verfügung stehen).
Das Paket "scribus" steht für die "stable"-Serie der Version 1.2.xcvs, während Ihnen das Paket "scribus-cvs" die Möglichkeit gibt, die neue Serie 1.3cvs auszuprobieren, die schon ziemlich stabil ist und deutlich mehr zu bieten hat als Version 1.2. Das Paket "scribus-cvs" installiert sich im Dateisystem nach /usr/local und kann parallel zum scribus-Paket existieren, weshalb Sie beide zugleich installiert haben und sogar gleichzeitig ausführen können. Stellen Sie aber bitte KEINE Fehlerberichte über das 1.3er scribus-cvs-Paket (oder überhaupt irgendeines aus den Upstream-Repositories) in das Debian- oder Ubuntu-BTS. Benutzen Sie das Distributions-BTS nur für Paketversionen, die zu dieser Distribution gehören. Wenn Sie mit Scribus ein Problem haben, das nichts mit der Debian-Paketerstellung zu tun hat, dann ist es viel besser, Sie benutzen das Scribus-BTS, um Fehler zu melden. Gehen Sie zu http://bugs.scribus.net/ - und viel Spaß!
Die nachfolgenden Anweisungen haben sich für die x86-Architektur meist als veraltet erwiesen - durch die neuen Repositories. Falls Sie andere Hardware (als x86) einsetzen oder gern ein optimiertes Paket erstellen möchten, sind diese Anweisungen immer noch von Nutzen. Sie können mir Pakete für andere Architekturen zuschicken, und ich werde sie ins Repository stellen.
Besuchen Sie bitte Scribus Wiki, und Sie bekommen Tipps von Endbenutzern.
Diese Anleitung ist zum Teil auch hier erhältlich:
http://www.debian.org/doc/FAQ/ch-pkg_basics.en.htmlUnter Abschnitt 6.13 finden Sie "How do I install a source package?" und unter 6.14 "How do I build binary packages from a source package?"
Viel Freude mit Scribus!
scribus-doc-1.4.0+r17300/doc/de/settings1.html 0000644 0001750 0001750 00000047147 11707342137 017545 0 ustar malex malexIm Datei-Menü finden Sie zwei ähnliche Einträge, nämlich Dokumenteinstellungen und Allgemeine Einstellungen. Jeder der beiden startet einen Dialog zum Ändern verschiedener Einstellungen und des Verhaltens von Scribus:
Die Sprache, in der Scribus startet, ist normalerweise die des Betriebssystems bzw. der Desktop-Umgebung. Wenn für diese keine Scribus-Übersetzung zur Verfügung steht, startet Scribus in amerikanischem Englisch. Für Deutsch gibt es drei Sprachvarianten: reformierte, herkömmliche und Schweizer Orthographie. Die Sprache der Benutzeroberfläche wirkt sich auch auf andere Bereiche aus, so auf die Sprachversion dieser Online-Hilfe, der Silbentrennung, der Rechtschreibprüfung, des Beispieltextes u.v.m. Der Wechsel der Sprachversion erfordert keinen Neustart von Scribus, sondern wird sofort wirksam.
Das Thema ist zunächst das Ihres Betriebssystems bzw. Ihrer Desktop-Umgebung, aber hier können Sie auch ein anderes für Scribus auswählen. Dabei ist die Auswahl je nach Betriebssystem verschieden. Sie können auch die Schriftgröße in Menüs und Dialogen ändern, und die übrigen Einstellungen im oberen Teil des Reiters sollten selbsterklärend sein.
Die verschiedenen »Pfade« bezeichnen einige Standardverzeichnisse, die Scribus zusätzlich zu den voreingestellten oder statt dieser verwendet. Der Pfad zu Scripts legt das Verzeichnis fest, in dem Scribus standardmäßig nach Python-Programmen sucht, wenn Sie Script > Script ausführen in der Menüleiste wählen.
 |
In den Allgemeinen Einstellungen legen Sie im »Dokument«-Reiter fest, welche Werte für Dokumente gelten sollen, wenn Sie Datei > Neu klicken. In den Dokumenteinstellungen tun Sie dasselbe für das aktuelle Dokument. Die Einstellungen unter »Seitenformat« sollten selbsterklärend sein. Zusätzlich zur (von den Spracheinstellungen abhängigen) Standardgröße und benutzerdefinierten Abmessungen bietet Scribus eine große Zahl an standardisierten Papierformaten. Die Optionen for das »Dokumentlayout« haben bei manchen Anwendern für Irritationen gesorgt. Hier legen Sie fest, wieviele Seiten nebeneinander angelegt werden, was auch für die PDF-Ausgabe wichtig ist. Sie legen nicht fest, wie eine einzelne Seite aufgeteilt wird, d.h. wenn Ihr Seitenformat A4 ist und Sie »4fach gefaltet« wählen, werden immer vier A4-Seiten nebeneinander angeordnet und nicht eine A4-Seite in vier Bereiche unterteilt. »Doppelseite« ist das typische Layout für ein Buch oder eine Zeitschrift, weshalb hier die Voreinstellung für die erste Seite »Rechte Seite« lautet (denn die erste Seite ist so gut wie immer eine rechte Seite).
 |  Hier sehen Sie ein Beispiel für ein doppelseitiges Dokumentlayout mit einer ersten rechten Seite. Wenn Sie diese Datei auf einem Bürodrucker ausdrucken, wird jede Seite einzeln gedruckt. |
Um Unterreiter »Ränder« finden Sie sogenannte Standard-Layouts, die allerdings nicht für ein Einzelblatt-Dokumentlayout zur Verfügung stehen, weil sie in diesem Fall sinnlos wären. Es handelt sich dabei um mit mathematischen Methoden berechnete Seitenränder, die sich im Laufe der Jahrhunderte vor allem im Buchdruck bewährt haben. Nachfolgend sehen Sie die Unterschiede zwischen den verschiedenen Modellen, demonstriert an der rechten Seite eines doppelseitigen Dokumentes:
 Gutenberg |  Zeitschrift |  Fibonacci |  Goldener Schnitt |  Neunerteilung |
Bitte beachten Sie, daß Änderungen des Seitenformates und des Standardlayouts in einem existierenden Dokument nur auf neue Seiten angewandt werden. Um diese Einstellung für bereits vorhandene Seiten zu ändern, müssen Sie jede Seite einzeln markieren und dann den Menüpunkt Seite > Eigenschaften der Seite bearbeiten aufrufen.
Im Reiter »Anschnitt« legen Sie die Beschnittzugabe nach den Vorgaben Ihrer Druckerei fest.
In diesem Bereich können Sie weit mehr als nur Hilfslinieneinstellungen treffen. Hilfslinien können entweder über oder unter Dokumentinhalten liegen. Unter »Einrasten« legen Sie fest, ab welcher Entfernung Objekte von Hilfslinien »eingefangen« werden, wenn die entsprechende Funktion aktiviert wurde, und wie weit der Mauszeiger von Objektanfassern entfernt sein darf, um sie zu bewegen. Damit Änderungen unter »Einrasten« wirksam werden, müssen Sie Scribus neu starten.
Weiterhin legen Sie hier die Farben von Hilfslinien, Seitenrandlinien, des Seitenrasters und des Grundlinienrasters fest, außerdem die Werte für das Grundlinienraster:
 |
Standardmäßig werden Hilfslinien und Seitenrandlinien angezeigt, aber dies können Sie hier ändern. Die beiden Seitenraster (Gitter) werden in der Voreinstellung nicht angezeigt – in der Abbildung rechts wurden die Standardfarben geändert, so daß Sie die Unterschiede zu den Standardeinstellungen sehen können: Seitenränder in rot, Seitenrandlinien in blau, das große Seitenraster in grün und das kleine in magenta. Im unteren Bereich des Dialogs legen Sie die Einstellungen für das Grundlinienraster fest. Über letzteres erfahren Sie mehr im Kapitel über Textrahmen. |
 |
Hier finden Sie die Standardeinstellungen für verschiedene typographische Funktionen, nämlich die Werte für hochgestellte und tiefgestellte Zeichen, Unter- und Durchstreichungen, künstliche Kapitälchen und den automatischen Zeilenabstand. Diese Angaben sind alle in Prozent, da Sie sich auf die jeweilige Schriftgröße beziehen.
Beachten Sie, daß der Prozentwert unter »Automatischer Zeilenabstand« den Wert zusätzlich zur Schriftgröße bezeichnet, 20% also eigentlich 120% bedeutet.
 |
Im Reiter »Werkzeuge« können Sie die Standardeinstellungen für die verschiedenen Rahmentypen ändern. Was sie im einzelnen bedeuten, wird deutlich, wenn Sie die Abschnitte zu den Rahmentypen gelesen haben. Darüber hinaus finden Sie hier Einstellungen zu Vergrößerungsstufen und zu diversen objektbezogenen Aktionen.
 |
 |
 |
 |
 | |
|  |
Siehe dazu den Abschnitt Silbentrennung.
Siehe dazu die Dokumentation zur Schriftenverwaltung. Diese sollten Sie unbedingt lesen, um Probleme in Druckerei zu vermeiden.
Siehe dazu die Abschnitte über die Druckwerkzeuge.
Siehe dazu die Dokumentation zum Farbmanagement.
Siehe dazu die PDF-Dokumentation.
Außer zum Speichern zusätzlicher Informationen über ein Objekt ist dieser Teil des Dialogs v.a. im Zusammenhang mit dem Erstellen eines Inhaltsverzeichnisses von Nutzen.
Diese beiden Unterdialoge sind aufeinander bezogen, und eine der beiden Funktionen finden Sie hier beschrieben.
 |
Hier sehen Sie die zugeordneten Tastaturkürzel, die sich jederzeit ändern lassen. Außerdem können Sie auch neue Kürzel eingeben. Neu festgelegte Kürzel können Sie in eine XML-Datei exportieren, die sich auf einem anderen Computer benutzen läßt. Die Dateiendung einer solchen Datei lautet *.ksxml. Es handelt sich dabei um eine Unicode-Datei, die plattformübergreifend funktionieren sollte, abgesehen davon, daß Macs eine Options- und eine Metataste besitzen, während Linux, UNIX, OS/2, eComStation und Windows alle dieselben PC-Tastaturen verwenden.
In Bibliotheken speichern Sie Objekte aller Art, die Sie häufiger benötigen. Bibliotheken können entweder mit einem Dokument oder als separate Dateien gespeichert werden, die von anderen Dokumenten oder Anwendern genutzt werden. Die Endung einer solchen Datei ist *.scs. Hier können Sie festlegen, ob Objekte aus der Zwischenablage automatisch in die Standardbibliothek kopiert werden, ob diese auch nach einem Neustart zur Verfügung stehen sollen und wieviele Objekte eine einzelne Bibliothek enthalten darf.
Die meisten Einträge in hier dürften selbsterklärend sein. Je nachdem wie groß Ihr Monitor ist, können Sie hier Ihre Arbeitsfläche anpassen. Wenn Sie beispielsweise mit einem sehr großen Monitor arbeiten, können Sie Scribus ein Dokument in Originalgröße anzeigen lassen. Den Vergrößerungsfaktor können Sie unter Werkzeuge > Vergrößerung einstellen.
 |
Im Reiter »Farben« können Sie die Farben für bestimmte Bildschirmfeatures wie Seitenrandlinien, oder Steuerzeichen festlegen. In den Dokumenteinstellungen können Sie hier nur die »Füllfarbe« einer Seite, d.h. die Bildschirmfarbe einer Seite auswählen. Diese Farbe wird nicht gedruckt und dient dazu, den Druck auf farbigem Papier zu simulieren.
Hier stellen Sie den Speicherort für Ghostscript und andere externe Programme ein. Wenn Sie Ghostscript vor Scribus installiert haben, findet Scribus das Programm normalerweise automatisch. Falls Sie eine Fehlermeldung erhalten, die besagt, daß EPS-Dateien nicht importiert werden können, obwohl Sie Ghostscript installiert haben, können Sie hier das richtige Verzeichnis eingeben.
Linux, UNIX, OS/2, eComStation and Windows:
 |
Der Bildschirmschnappschuß wurde unter Linux erstellt und gilt prinzipiell auch für andere UNIX-Systeme. Siehe auch die Informationen zu Windows sowie OS/2 und eComStation. Zusätzliche Informationen zu Ghostscript finden Sie hier.
Mac OS X
 |
Hier sehen Sie die empfohlenen Einstellungen für Mac OS X, vorausgesetzt, Sie haben das Ghostscript-Framework korrekt installiert.
Bildbearbeitungsprogramm
Sie sind nicht auf GIMP beschränkt, sondern können jedes andere Bildbearbeitungsprogramm wie Krita oder Photoshop aus Scribus heraus starten. Weil GIMP jedoch das populärste Open-Source-Bildbearbeitungsprogramm ist, finden Sie es voreingestellt.
Webbrowser
Hier legen Sie fest, welchen Browser Sie verwenden möchten, wenn Sie einen externen Link in dieser Dokumentation anklicken oder auf externe Ressourcen aus dem Hilfe-Menü zugreifen.
Render Frames
Siehe dazu den Abschnitt über Renderrahmen.
 |
Hier finden Sie verschiedene textbezogene Einstellungen, die selbsterklärend sind.
Dieser Bereich dient nur zu Ihrer Information. Sie können hier u.a. feststellen, ob sich alle Plug-ins aktivieren ließen. Wenn letzteres nicht der Fall ist, kann dies an einer fehlenden Programmbibliothek liegen.
Siehe dazu die Dokumentation zur Umbruchkontrolle.
Siehe dazu die Scripter-Dokumentation.
Siehe dazu den Abschnitt über die Dokumentinformation.
Die Konfigurationsdateien von Scribus sind in einem versteckten Verzeichnis namens .scribus gespeichert. Dieses befindet sich je nach Betriebssystem an einem anderen Ort:
/home/username/.scribusUser/username/.scribusX:\SCRIBUS-1.4.x-OS2-date\scribus\.scribusC:\Dokumente und Einstellungen/username/.scribusInnerhalb dieses Verzeichnisses gibt es u.a. die Dateien scribus140.rc, checkfonts.xml (in der die Einstellungen für Schriften gespeichert sind) sowie prefs140.xml. Alle diese Dateien sind XML-Dateien, so daß Sie deren Inhalt mit einem Texteditor betrachten und bearbeiten können. Wenn Sie Python installiert haben, finden Sie dort auch eine Datei mit dem Namen scripter.rc, in der die zuletzt verwendeten Scripts gespeichert werden. Darüber hinaus gibt es zusätzliche Unterverzeichnisse, die weitere Scribus-Daten enthalten. Wenn sich Scribus plötzlich unerwartet oder fehlerhaft verhält, kann es hilfreich sein, das Verzeichnis .scribus umzubenennen, aber es nicht zu löschen. Siehe dazu die Informationen zur Problembehebung.
Siehe auch
Installieren Sie Ghostscript für Windows – Ghostscript 8.7+ oder höher werden empfohlen. Dieses Programm benötigen Sie für den import von EPS- und PDF-Dateien sowie den Strichode-Generator.
Nach der Installation finden Sie auf Ihrem System zwei ausführbare Ghostscript-Dateien. Die richtige *.exe-Datei, die sie in den Allgemeinen Einstellungen unter »Externe Tools« für Ghostscript eintragen müssen, ist gswin32c.exe, nicht gswin32.exe. In den allermeisten Fällen wird Scribus ein installiertes Ghostscript von alleine finden. Bedenken Sie, daß Sie Ghostscript nicht zwangsläufig benötigen. Ohne gs stehen Ihnen lediglich weniger Funktionen zur Verfügung. Wenn Sie Ghostcript nicht installiert haben, wird eine Warnung angezeigt, die Ihnen hilft, es herunterzuladen, aber das ist lediglich ein Angebot.
Falls Sie die Option »Zusätzliche Schriften« während der Installation wählen, werden auf Ihrem Rechner zusätzlich zwei Sammlungen mit hochwertigen Freien Schriften installiert. Die eine enthält die URW-Fonts aus Ghostscript. Darunter sind 45 Schriftschnitte enthalten, die kompatibel mit den typischen PostScript-Druckerschriften sind. Die andere besteht aus der Vera-Familie von Bitstream, die unter Linux sehr weit verbreitet ist und auch von eingen Vorlagen verwendet wird.
Beim ersten Start oder wenn ein neu eingerichteter Benutzer Scribus zum erstenmal startet, kann es eine Weile dauern, bis das Programm benutzt werden kann, weil Scribus erst ein Verzeichnis sämtlicher installierten Schriften anlegt. Spätere Neustarts verlaufen wesentlich schneller.
Im Startmenü finden Sie einen zweiten Eintrag namens »Scribus -console«. Damit wird ein Windows-Kommandozeilenfenster geöffnet, in dem jede gefundene und geladene Schriftdatei ebenso angezeigt wird wie Schriftdateien, die von Scribus wegen Fehlerhaftigkeit zurückgewiesen wurden. In manchen Fällen werden auch andere Probleme angezeigt. Schriftduplikate werden nicht geladen, selbst wenn sie verschiedene Dateinamen haben.
scribus-doc-1.4.0+r17300/doc/de/topten.html 0000644 0001750 0001750 00000021210 10673051435 017113 0 ustar malex malexDies sind unsere zehn besten Tips für den Umgang mit Scribus in irgendeiner Reihenfolge:
.scribus in Ihrem Home-Verzeichnis beispielsweise in .scribusbak um. Öffnen Sie Scribus erneut, und Stellen Sie unter Datei > Allgemeine Einstellungen Scribus so ein, wie Sie es benötigen. Schließen Sie Scribus erneut, und kopieren Sie den Ordner in ein anderes Verzeichnis. Falls Sie dann irgendwann feststellen, daß sich Scribus seltsam verhält, löschen Sie Ihr .scribus-Verzeichnis, und kopieren die gesicherte Kopie zurück. Dies ist besonders wichtig, wenn Sie viele Tastaturkürzel festgelegt haben. |
| 8,5in/3 | teilt 8,5 Zoll durch 3 |
| pagewidth/4 | teilt die Seitenhöhe durch 4 (funktioniert in Punkt) |
| width*2 | verdoppelt die Breite des ausgewählten Objekts |
| 5in+2p | addiert 2 picas zu 5 Zoll |
Initial document: Paul F. Johnson, 26 Feb. 2004, Version: 0.04
Revised: Craig Ringer, 16 Aug. 2005, Version: 0.05 (text encodings, exceptions, who to send patches to)
Revised: Peter Linnell, 06 Sept. 2005, Version: 0.06 (more text encodings stuff from recent discussions)
This document is intended as a guide to all Scribus developers and contributors. It is aimed to be simple to use, as well as to keep the source code simple to understand and maintain.
All code should be documented clearly.
Prior to any method, the following should be there
There should be something similar prior to the class definitions.
In preference, all details should be in English. This includes comments.
Unless a comment occupies a single line, // should be used in preference to /* */
All variables should begin in lower case letters. If the variable has more than one part to it, then the second part should begin in a capital letter. For example int foo and int fooBar. Under no circumstances should an underscore (_) be used.
Variables should be clear in their naming. The exception to this is in a for loop. In preference, these should be in English. We are in the process of converting and altering the current ones to fit in with this.
Any temporary variables (such as those used in a for loop or those only used within a scope), should only be declared where they are needed and not used in a global scope. If there is a condition at the start of a method, any variables required should be declared, but nothing else. For example
void foo::bar(f *b) { int j; string g = b->passed_in; double fg, m, c; which_string(g, &j); if (j == true) return; // rest of the code }
should not have the double variables declared. It is arguable if g should be declared, but in this example, it doesn't matter.
If a variable is not required, don't create it. In the example above, there is no requirement for g to be used.
In class definitions
With the exception of the access declarations, a single tab should be used prior to all method and variable definitions. There should be no tabs prior to access declarations. There is a tab prior to Q_Object.
In the main code
There should be a tab at the start of every line. With any conditional line, there should be an opening brace by itself. On the next line down, there should be another tab prior to any code. The close brace should be underneath the open brace.
Always make a conditional logical. This may sound silly, but look at the following example
int foobar(bool m) { if (m == true) { somethingA(1); somethingB(1); somethingC(1); } else { somethingA(0); somethingB(0); somethingC(0); } }
This can be re-written to make things clearer
int foobar(bool m) { int c = m == true ? 1 : 0; somethingA(c); somethingB(c); somethingC(c); }
A lot simpler to see and will usually optimize far better.
Ternary conditionals (?) should be used in preference to if / else. These are usually far quicker to process the code once compiled.
Depending on what is being performed, switch statements should be avoided. There is usually a simpler way to avoid them. For example
int b; string s; switch (f) { case 1 : b = 4; s = "four"; break; case 2 : b = 8; s = "eight"; break; case 3 : b = 12; s = "twelve"; }
can be re-written as
int b = f * 4; char *number[] = {"four", "eight", "twelve"}; size_t no = sizeof(number) / sizeof(*number); s = number(f);
The switch has gone and the code generated runs far faster and as the conditions don't need to be created, will optimize far better. Note: when using the QObject::tr() function, this method of using char* may not always work properly. An alternative is to use QString number[] = {"four", "eight", "twelve"}; etc.
Obviously for more complex switch conditions, the above can't be used.
Formatting should look like this:
if (fred == 5) { // something // something }
Switch formatting should look like this:
switch (f) { case 0: if (fred == 1) { // something // more // ok } else { if (jimmy == 0) { // hi // code } // something here } break; }
Simple to read and simple to see where the conditional ends.
Under NO circumstances should you have a line such as:
if (foo == bar) { somethingA(0); }
This should be written as:
If braces are not required, don't use them. For example, braces wouldn't be needed here
In for loops, preincrements should be used (++a rather than a++). Under ARM processors and x64 processors (not sure about ia64) ++a requires half the number of clock cycles than the post processor style. In some circumstances, ++a is far more efficient under ia32. It is even more efficient when used with iterators. Post increments should be used in the following sort of code:
if (b == true) { m->wibble(c); m->wobble(c++); }
There should be a space after:
if (a == true) - there is a space either side of the == conditional)Prior to an open bracket or after a close bracket:
Templates for both types and classes are fine to be used. The project recommends using g++ 3.x which fully support templates and template classes. Please remember the overhead involved in using templates!
When using templates, please remember the following:
Unless you really know what you're doing and more over, what the code is doing, do not attempt to do any code optimization. In a lot of respects, optimization is a "black art".
Code such as a = b = c = 0; is more efficient (through the compiler) than a=0; b=0; c=0;
Careful thought about how the code works is usually far more beneficial than attempting any of the "tricks" currently employed.
Any large scale changes should be approved of first. Sometimes a small change can have large side effects.
Multiple separate lines containing calls to Qt methods are far less efficient than multiple calls contained in a for loop.
QString fred = QString("bob") is not the same as QString fred("bob"). The first one creates an additional temporary that's then thrown away. That's slow, and should generally be avoided.
In constructors, it is somewhat faster to use:
Fred::Fred() : ParentClass(), argument1("initialValue"), argument2(INITIAL_VALUE) { }
than
Fred::Fred() : ParentClass() { argument1 = "initialvalue"; argument2 = INITIAL_VALUE; }
for much the same reasons as outlined above. It's best to initialize the members in the same order that they're listed in the class declaration.
Due to the unavailability of exceptions (see below), we're using Q_CHECK_PTR to check allocations. This means that you get an abort with a useful message when an allocation fails, rather than an unexplained segfault.
int *m = new int[2048]; Q_CHECK_PTR(m);
All calls to new should ideally be trapped. This is not currently implemented in current releases. The preferred method would be:
#include <new> try { m = new int[2048]; } catch(bad_exception) { cout << "memory allocation to m failed - <method name<" << endl; exit(EXIT_FAILURE); }
As there are many calls in Scribus to new, these will have a wrapper around.
For users of Qt who compile their own, they will need to include in the ./configure script that they want to throw C++ exceptions. Failure to do so will result in the catches not catching and possibly Scribus failing to run.
Currently (for v3.2 - v3.4), KDE recommend Qt is compiled without exceptions. This is a bad idea as it means trapping bad memory allocations cannot be caught using the preferred method. As most distributions follow this recommendation, that means we (Scribus) can't expect to be able to rely on exceptions.
Text encodings need to be handled carefully. Strange errors can result if you treat UTF-8 text as latin-1, for example. These issues are often hard to track down, so careful coding is important. A detailed treatment of text encodings won't fit here, but some information will be provided elsewhere in the documentation. This is an early version of this part of the text; feedback would be appreciated.
The first thing you need to understand is that Qt's QString, and most other Qt classes, know their own encoding and take care of text encoding issues for you, so they can be treated as "just text" when passing them around inside Scribus and to other Qt classes. It's only at the interfaces between byte-oriented and "text"-oriented code that care is required. These interfaces can be tricky to spot (the implicit conversion of a QString to a QCString or char*, for example, is easily missed) so caution and careful reading of API documentation is required.
While there is no real substitute for understanding text encodings, some of the most important rules to follow are:
Always construct a QString from a byte string using one of the QString::fromblah(...) methods. You should never use QString(char*) or QString(QCString). You need to determine what encoding the byte string you're working with is in and use the correct call, by examining the documentation for the system / library you are calling. There is generally no way to tell what encoding a string is in by examining the string - at best this is guesswork. Do not assume a string is utf-8 or latin-1, since even if it works for you, in some locales it will not. For data read from the OS or C libraries, you generally want QString::fromLocal8Bit(...). If in doubt, ask somebody.
Similarly, you should always use the appropriate QString conversion methods when converting QStrings to byte strings (e.g. QCString, QByteArray, or char*). Note that such conversions may happen automatically, so watch out for implicit conversions. If sending data to system calls or C libraries you'll generally want QString::local8Bit() but you should check to confirm that's correct for the specific call you're making. Some win32 calls, for example, expect UCS-2 (wchar) data, and some C libraries will expect UTF-8 strings to be passed to some methods.
You should absolutely never do this:
QString blah = anotherQString.utf8();
The above code:
QCString; thenQString(QCString) constructor for blah;QString(QCString) decodes the passed QCString according to the default byte string locale set in qt which is usually latin-1 (don't rely on that; it should change to depend on locale at some point.).Thus, you end up doing a lot of pointless work encoding and decoding the string, and to top it off probably mangle it by decoding a utf-8 string as latin-1. You usually won't notice this, because you probably only send ASCII data thorough, and thus the bug will only turn up much later from people in other locales who use other text encodings. These issues tend to be a pain to track down.
For similar reasons, when you're reading or writing a QTextStream, remember to call QTextStream::setEncoding(...) before reading/writing any data. Use operator<< with QStrings, but WriteRawBytes(...) when writing byte strings that are already in the correct encoding. Byte strings in other encodings should be converted to QString or transcoded using QTextCodec. Do not just assume the QTextStream should write out UTF-8. The correct encoding will depend on where the data is going / coming from. For example, a plain text file for the user to edit should be in their local text encoding. If you're not sure, ask someone.
Don't convert a QString to a byte string when writing to a QTextStream - the QTextStream does that for you in operator<< . For example:
QTextStream ts(&file); // In this case we know we want to write out UTF-8 to this file, not write in // the local 8-bit byte string encoding. ts.setEncoding(QTextStream::UnicodeUTF8); ts << someQString.utf8();
as that's the same error as in the previous example, just written a different way. Instead, you should omit the .utf8().
The best way to handle text encodings is to convert 8-bit byte strings to QString or another "safe" class as early as possible in input, and convert to 8-bit byte strings as late as possible on output. Above all else, do it only once and watch out for implicit conversions. You should think about encodings whenever passing text across any interface that wants byte-oriented strings rather than QStrings. Remember to read the documentation of the APIs you're using to determine how they behave with text encodings, and if you're not sure, ask somebody.
It is strongly recommended that you read http://doc.trolltech.com/3.3/i18n.html for more coverage of this issue, especially the section "Support for Encodings". You should also read Achtung! Binary and Character data.
Please use:
"<qt>" + tr("text for translation") + "</qt>"
not this:
tr("<qt>text for translation</qt>")
it's really annoying to translators.
If you are writing a class which is not inherited from QObject or any Qt class, you cannot use inherited tr() method. If you are using something like:
QObject::tr("text for translation")
replace it with:
QObject::tr("text for translation", "describe what is it related")
An example from the scripter:
QObject::tr("Item is not text frame", "scripter error")
It helps translators with context and it tells them what they are translating too, though in some cases strings are generic in nature.
There's another issue related to translations, though it's more for encoding correctness etc: Please don't use:
tr( QString("blah %1").arg(something) )
or otherwise use a QString inside a tr(...) . Doing so causes an
implicit conversion to `const char*', in which the QString converts to a
latin-1 byte string. If some characters cannot be represented in latin-1
they're replaced with `?' . The correct usage is:
tr("blah %1","context").arg("something")
... exploiting the fact that tr(...) returns a QString and that you can chain calls to QString::arg. That avoids any implicit conversions, and will avoid a whole class of weird encoding bugs.
If you really have to translate text that can't be represented in latin-1, you need to use QObject::trUtf8(...). If you want to translate a string with "Δ" (uppercase delta) in it, for example, we could try:
tr("Δ is %1", "context")
but that's wrong, not portable, may not compile, or worse might have different results on different systems. We must use escaped byte strings rather than including a unicode or extended latin-1 char directly in source. The UTF-8 byte sequence for that character is \xce\x94, so we could try:
tr("\xce\x94 is %1", "context")
but that's also wrong, as that unicode byte sequence will be interpreted as latin-1 and you'll get a mangled result. You must instead use:
trUtf8("\xce\x94 is %1", "context")
Similarly, if you wanted to include the © (copyright) symbol, which exists in latin-1 as well, you could use either:
tr("something \xa9 someone", "context")
or
trUtf8("something \xc2\xa9 someone", "context")
Don't cast a pointer to an int, it causes portability issues where sizeof(int) != sizeof(void*). You might want to find another way to do what you're trying to achieve.
Code patches should be sent to Franz, Craig Bradney, or Paul. Documentation patches should be sent to Peter and Craig Bradney. This is subject to change. Scripting matters should be addressed to Petr and Craig Ringer.
Patches should be in plain text. diff -u old_file.cpp new_file.cpp >difference.diff is the best way of sending them. Please do not send patches to the main list. Remember to use -u (unified diff) as other types of diff are painful to use.
Please ensure that when you have changed something you put a comment immediately before the change. Ensure you put a date and who made the change and what the change is for. Make sure that the comments include the original line of code. Over time, these will be weeded out, but it useful to see what has been altered.
Send a single diff for each file altered. It makes committing the changes far more simple for us!
Please use the current functions and refer to the Plugin howto for further information.
All code called from the main Scribus application has to be encompassed within an extern "C" { ... }; to enable the plugin to work.
Ensure that all the code is documented and follows the coding guidelines set out above.
Wie schon im vorherigen Kapitel angesprochen, gehört sie zu den Herausforderungen für eine fortschrittliche DTP-Anwendung wie Scribus, nämlich die Fähigkeit, etwas zu erzeugen, was ich gern als "anspruchsvolle" PostScript- oder PDF-Funktionen bezeichne. Die Druckvorschau in Scribus ist schon etwas besonderes, da sie mehr kann als nur einen Bildschirmabzug Ihres Dokuments zu liefern. Scribus erzeugt seine Druckvorschau de facto durch Ausgabe einer tempörären PS-Datei und verwendet dabei einige der speziellen "devices" von Ghostscript. Zeigen Sie beim Starten der Druckvorschau etwas Geduld, denn Scribus und Ghostscript haben im Hintergrund viel zu leisten. Die neueren Ghostscript-Versionen ab 8.x sind übrigens deutlich weniger eingeschränkt, wenn fortschrittliches PS in seinen Variationen dargestellt werden soll. Bei der Druckvorschau haben Sie außerdem die Möglichkeit, die einzelnen Tinten als CMYK-Farben anzuzeigen.
Die Druckvorschaufunktion kann Ihnen dabei helfen, Bilder oder grafische Elemente zu identifizieren, die sich mit Ihren vorhandenen Druckeinstellungen vielleicht nicht gut direkt drucken lassen. Dies ist meist von den Fähigkeiten Ihres Drucksystems abhängig, und ebenso davon, welche Arten fortschrittlicher Merkmale und Funktionen Ihre Dokumente enthalten. Zu den Merkmalen und Funktionen, die unter bestimmten Druckeinstellungen problematisch sein können, zählen Farbverläufe, die Transparenz und komplexes Maskieren ... um nur einige zu nennen. Die Druckvorschau kann auch praktisch sein, um vorab zu sehen, welche Farbverschiebungen auftreten könnten, wenn im CMYK-Modus gedruckt wird.
Anmerkung: Da die Druckvorschau auf PS3 (PostScript-Level 3) basiert, gibt es einige Fälle, in denen der Bildschirminhalt nur über das PDF-Format (ab Version 1.4 ) exportiert werden kann, insbesondere wenn Transparenz oder Farbverlauf-Effekte betroffen sind. Hier haben wir abermals einen Fall, wo eine neuere Ghostscript-Version von Vorteil ist.
 |
Die meisten dieser Optionen sind für fortgeschrittenes CMYK oder den kommerziellen Druck bestimmt. Die ersten beiden Kästchen sind für jeden Anwender von Nutzen.
u2fyK
=l'\犼%F~ # )ϻ8?^}K hä(/GwxXT/E; NHzzfq4= x%S7/{6fV;RWt[ W{h* U|̐ @ W]nOsesFwN^{Vf #vGi[?NƚSSS!t/2lnpjn\a
wt\Smի)?OmνVi{1c4(Ũ^Fɵ* 3+F st v&\ MД-Ejx)+8AZ(ƽ- ` DK S(' /jq6N/>Z(E(Jk=6ʚRq_at& N&?d*;w$ _9AP C ZBɇ,@98ǼWөƕ~==#uzO3|lQ k3ou:*)v{P`of
Wg;YGۘZ ä2w>-&8̦irO8>#^qRt4M;?/IWΪ 0庾t VB6բ܋h\&4j2)m5;|'|9aH ^̈́ϿuYE1rRI1|4칣G[uϳCh2$t;Kb/`Ue==-ƺ|ڧ _
kӶ}}⤨O6<*= !Gg> C jQ6E
Z9,,.Z_:擺ZYqp v7ЅP6wCc!-';08
|(*X,6칣G[I"q\Ayȩ?{t.* )؝C2|429?Y\+rzQ'lx$UgZ]ڣ z [ tS;sO2Ka,7x&-JU-̶5G߮Qya,
u rVO `*SH>xᶣC 0 .@O0Q~V]]
% = hT]ejcmDC dtvekDd+]g6 @ 6iŨŢf+jS2 @ WXx#M"W A! 5<=qgyaχ:x+.(=X,#ÅWҵSn;$So B+p8*7mi [ bنG?]S BF`p qBo D+3'FoD^6*ϟ}_ڣ\$ Lp'pjZl,*}lPhUU/k3K iX7x6hF]qRLE}jSSnA% V5:]HqKc٧ MV5r%"ߕ˱)Bv~Brv!P5iZX\hШ(J7=T;Mzdݞ &(Zͫnvvz5,M dt& $~d[rU UUk a 8):9c1!d#ÛkM;OK|uxA^^V-B{`^<0ms)nF̕!Bx" b02"L6($^ZF/Q:%l8
o
vJ 'p.6641F/vv? ۅVή1l@zJ[C\W?`(]_e䢻y˶7._NJEnmX8|>0L7HV-8'mDwe{ /[xaڅ7i#`~"cacl>76= fi[韛 rD.)n=T !wؗzj0Ld,B6nlf4Q2bQV1/mQUL2uyeҩZ,
? a r ;rnR9Q(,ʧr$uZopB/ D ̗3O5FWתF
ި*aAkK4B5nlnk4]}sKl6tű<+χGϏ6V>cBpZXPy -^jϘD!hf8n4B z D в fktQnߓ겪iJ$#xq&dȷ媧 }R%m܍]ʲ=.KkɷdJ"ʧ>ϒU֊Ά4MKO'g62wwNӴ = @ eh]A|]ϋOc[!][2YvY"#SH*ZKɩ
LOMswbJ gw$dZISR·G&ߔ>εڿvkh^{T>Ȱj
F㝼258F妜Nge#" B Zء̭]Bd0?+_o
śil43LU+^lk=H>2tiqn`|#ѳ-$3x?ϲ r JkDNԣT,p ] > V. ؉NBZ"؉hM^"ؔ"h;{;;v#D >,Zì\͏&% l $ `2^'1 ) = 0 ;&^nrKW B f}Jӿ}Kf
Kژ}z]ϯw]YJb7bg)FBHlHӴ~ݝ4-2A\| z-arU}_^X3pa߳RQJ?`py0,B
$'r }. 2p6v&skr#-9葯y1: nsc<+o1s?+Ks|{c]\)aO3Mj1|>`iJä;KA#=6̹0g0fkܔm
Gz $ rD7 jOA/s;d?ԪC? qhUYjtggr zAV͜R Sv"r2 B z D [# = @@ {ݹ= YNSnnZHtv(sr`D`SB > Ox#`'ssX@ Gt/or7fqb `{ #> `.NdzYlJ B srrqoZ / zExJBRA#ٻ&g0B.t)
&\_BGf *t4 B ^p;
nce*(iF%*p+f
l! 8$u~L'=1O3yl)*x=^𪪾PfJ
> z @ ʘNƾn[<ɰ~64*_Oҏ膦!Pyz5ٍ74jʻ9ahωD- z t`(&VheFW#S@_i 3{s6F!! \Mzxi$$ $[V i#l/;w~' U
6fѲl4Ý@ub#v[^CQe5ayedg³J{o~t|m iبQLF 8"aSq {\`]NGYL-:`v$&UĀw '
/J~OOb K}9?lDƋ%GKDmJ<:_ f4R2{ix;¤y7݊ (`&ƉZZ V 2.Pw.A(g& F ˶dJc`-}9K $&Q
gƠY㴂Ā i1̞\\eip A^mq5cNy$:TjaHQy ; p
Zk 8j(WMt2b `3ERFol؞aX>Q((h8T ~Dt АR;xU "
$&;rk;a.$E8QXPB o
C.ΟɟE"; xs_Q8{{Bٸ
1t{WO./^|mC ;=Ogli$_'?)vwwUf?7֔2
>ltITl*
+iu;{dXV][~ӝؿ.fQPI/m]f]U: ds3}
B쁜71crM0LUyuKE˘.5b%~EV}kTc_6ӛzeQxA~z< c=嚩[MlozvqӢk[߽
$= Q ʫoϹBau⒒
묣pQ, C){[ߋ @y<+57tM˺i@W&<'H =c]P[4B>113"Le UUx|;TĭEcmP,K(R|֬GΕk5UeEdllwۿA1֭#
8mmϚ
sBr3iwKHPG&r! {D Ewmxzƍd[Uzz ٺ9lm v1̞}c6m*9XY
GY/\w77v(RdiCh$fM7EfHku Zcm˛]RZjՖ>'<+
S5
Z ɗ~^ȧZjon(Y Z
) 7kvg18?t}7.,&Zn[gD 4u5(7d
#EIf BP-et,/H5ul&H wlteNH|hx]+**0 ֳv]2C!0=3*?4> mZèOA
zX ,F e B rirɹw!*ٸ~ [L{ O]R{qteX`=&KnGT($(l]r ҒcG{_Kyuvl1Iҙ;*ʫEPg:6pw }Ut`l}?Om
Ra|<fzl6^bBUApJ]<3 "QC4+7)hgwyi,/5gS0}eaQW#Im\D^]US/ ԑk~ً_g himm #ϟT a4T֒iUCKOQA,5Nt]6J| _Tѹ"z {sX(DmzmBhkmyE .ƹ@
ĿO~P7@F7ȮbPc3[>Oh&%XDՍd e-- 5 Uu|l6 ŚlLjlĴˈT4Xz ~DM:1^!hSWj7u1<0Ip߱ƵO:U}c
@%6#@vܳ{-FZR30ح5mej)T WU2pרjeV(&r|k*f5lfiHNλ`J"XrJ cb~5C=vbv$`caPۋجᴇIoAj" f#of9x* YXN|6MA,=.JXM&MMX
`nMe "3 -Â bxQ@-瓕O?b<)Fh^Yx΅C
kdj
$bL̴fSss
FggWx.Hd12pQXYiȥ62.'e(o/\Ge ,fRTWAZj1fyՎs(]] ˘ 5Q1+NN#FSGYHl Ep; rH5=0"Nޘ ro vkSf1\SX&BMb7isOrR R m<қKP<|lG6 jug5{pƃƒ3i뮪em XZ5㥕1gP53mN>OeL9f ^Xl*oOTTKSÍeOhl|wP4KJ+?-ЙS0FBl?$yUAjTumT5CiͲ`+w
cڙ0Ke]# yG :{i53a݅`aέq~M.éZMRT2Ͱq3ϋ$`}rјFE,U(-[6gbBsgctMfczZ$AmlѨ \
Uk}jW|&yhbьQ
x
ި$6dN5%"nŤfdŧ2Y~jDB@Y] L