Inkscape to Scribus

I have a project where it is necessary that the
perfect bound book cover be laid out in Inkscape
and then finished off in Scribus to get the
needed CMYK color map and pdf x/1-a:2001 format.

My first of many questions is: given the current
states of Inkscape 0.91 and Scribus 1.5.x (pick
your poison, I have both 1.5.0 and 0.5.1), what is
the optimal file format for making the
transfer from Inkscape to Scribus: svg,
pdf or tiff?

All answers appreciated as usual.

Ugly l and L with the Robot font

Hi everyone,

I wrote a document in Scribus using the Roboto font
<https://www.google.com/fonts/specimen/Roboto>. When I export it in pdf
everything seems fine in Evince, but some friends of mine are
complaining about ugly l and L when they open it with Adobe Reader on
Windows.

Searching on the internet I found that the problem seems related to
hinting, but I wasn't able to understand if I must change the font or
there is a way to solve maintaining the font I chose.

I use Scribus 1.4.5 on Arch Linux.

Thank you very much for your support.

Yours,
Giulio

boilerplate &amp; messagebox syntax

I have had a few of the scripts shipped with the scribus 1.5.* versions freeze Scibus because the message box has no buttons to dismiss it.

So I looked at some of the other sample scripts and was able to modify the 'ExtractText.py' script to avoid this...

Scribus • erreur de police de caractère à l'impression

[ Translate ]

Bonjour, j'ai un soucis avec l'envoi de fichiers pour un imprimeur que je ne parviens pas
à comprendre. Il me renvoit ceci après avoir reçu mon fichier:

"les textes/caractères
convertis en tracés et/ou incorporés dans le document pdf,
sinon il ne sera pas possible de procéder à l'impression."


Mais quand je fais l'enregistrement (l'export en pdf) J'ai bien ça d'inscrit dans scribus, les polices sont vectorisées non?

Image

sauriez-vous me dire ce qui m'échappe? Parce que là je nage...

Statistiques: Posté par daciap — 03 Sep 2015, 22:17


Image Frame with PDF : problem with file path

Dear All,

I've been struggling to get the image frame widget working with pdf files and I think I might have find a bug I would like to report.

On my computer, it seems that if in the file path there are accents (special character) the widget will say ...

eliminating color sets.

I have two of the Glaxy color sets in a
particular file. I want to get rid of one of
them which has over 1,000 swatches. There is a
facility for a merging in a set but
none that I see for getting rid of a set once it
is merged in.

I can work in 1.5.0 or 1.6.0 if necessary.

Splitting a large document into several smaller documents?

I run Scribus 1.4.2 on a computer with 8 GB of RAM. However, it is extremely laggy. It wasn't always this way. The document got slower and slower as it got bigger. Right now, the document is around 300 pages long, and it takes 5-10 seconds to change ju...

Splitting a large document into several smaller documents?

I run Scribus 1.4.2 on a computer with 8 GB of RAM. However, it is
extremely laggy. It wasn't always this way. The document got slower and
slower as it got bigger. Right now, the document is around 300 pages
long, and it takes 5-10 seconds to change just ONE character in the
document.

It seems clear to me that the lag I experience is a direct result of the
length of the document. Because the document consists of one very long
linked text frame, it has been suggested that those linked frames are
the cause of the problem and that I may be able to fix it by splitting
the document up into smaller chunks.

The problem is that I've already invested a lot of time into this
project. Is there a way I can split the document up easily without
typesetting everything from scratch? One suggestion was to make multiple
copies of the document and delete all unwanted pages from each copy to
form the desired chunks. However, I found that deleting pages doesn't
affect the text of the document. When I delete a page

How to quickly highlight text/image objects on a certainpart of a page

So I'd love to be able to say choose the lower half of a page with the
mouse, click-drag and it would highlight all the text/image/object boxes I
have designated in that portion. I'd like to do this so I can move or tweek
or cut or copy etc...

I usually just click on one object at a time holding the shift key.

Is there a faster way to do this that I'm missing?

Thanks,
/Kunda

Erste Hilfe • Wie benutzt man den Zauberstab?

[ Translate ]

Hallo,
ich habe nirgends? gefunden, wie man exakt den "Zauberstab" (Eigenschaften übertragen) oben in der Toolleiste benutzt.
Kann mir da jemand bitte erklären? :danke:

Gruß,
chilissimo

Statistik: Verfasst von chilissimo — Di 1. Sep 2015, 16:40 — Antworten 3 — Zugriffe 40


Replace carriage returns with blank spaces

Hello everyone,

I copied a pdf text into my scribus file so it has a lot of carriage returns. I want to replace those carriage returns with blank spaces. Normally, when I use InDesign I make use of GREP. I have explored the 'Search/Replace' settings bu...

Erste Hilfe • Mehrere Zeilen einrücken

[ Translate ]

Hallo zusammen,

ich bin jetzt schon mehrmals auf dasselbe Problem gestoßen, das ich (vermutlich mangels DTP-Erfahrung) bislang nicht einmal ansatzweise lösen konnte.

Ich möchte ein Layout für Text der folgenden Form erstellen:

Code:

Afrika    Ein Kontinent, der im Süden von
          Europa liegt
         
Europa    Anderer Kontinent, der zwischen
          Asien und Atlantik liegt


Was ist der beste Weg, dieses Layout umzusetzen? Mit mehreren Textboxen ist es natürlich möglich, aber dann muss ich alles verschieben, wenn sich in einer Textbox etwas ändert. Mit Tabulatoren, die ich bei den Paragraph Styles einstellen kann, kann ich meines Wissens nach nur einzelne Zeilen einrücken, also sieht das ganze mit Tabulator so aus:

Code:

Afrika    Ein Kontinent, der im Süden von
Europa liegt

Europa    Anderer Kontinent, der zwischen
Asien und Atlantik liegt


So eine Anordnung ist ja relativ häufig, daher hoffe ich, dass ich irgendeine Möglichkeit übersehen habe.

Vielen Dank für die Hilfe!

P.S.: Ich habe diese Frage erst in einem anderen deutschen Forum gestellt, da es mir bei Google zuerst angezeigt wurde. Es scheint aber leider seit geraumer Zeit inaktiv zu sein, daher bitte ich das Doppelt-Posten zu entschuldigen.

Statistik: Verfasst von someone — Mo 31. Aug 2015, 17:33 — Antworten 3 — Zugriffe 43


Erste Hilfe • Rand im Textrahmen

[ Translate ]

Hallo bin noch ziemlich neu bei Scribus, deswegen habe ich schon wieder eine Frage :)

Wie im Dateianhag zu sehen ist steht die Schrift am Rande des Textrahmens, was in diesem konkreten Fall nicht besonders gut aussieht. Deshalb möchte ich gerne wissen, wie ich die Schrift einrücken kann, damit zwischen dem Rand des Textrahmens und dem Textanfang eine weisse Fläche zu sehen ist.

Dateianhang.png

Statistik: Verfasst von sblumberg — So 30. Aug 2015, 06:38 — Antworten 4 — Zugriffe 52


Erste Hilfe • Cover konvertieren

[ Translate ]

Hallo allerseits,

ich habe ein Front- und Backcover in Scribus erstellt und möchte es ins mobi oder epub Format konvertieren. Kann mir jemand erklären wie das geht oder ob es überhaupt geht?

MfG
sblumberg

Statistik: Verfasst von sblumberg — So 30. Aug 2015, 00:06 — Antworten 7 — Zugriffe 61


How do I make hyper-links both clickable and visible in a pdf generated in Scribus 1.4.5

I have been trying to follow the instructions in the wiki on how to do this
using Method A.
If I make them a pdf annotation they are clickable just not visible in the
pdf if I make them a pdf bookmark they are visible but not clickable. I
see they seem to be mutually exclusive operations.
So how do you normally do this?
Do I have to insert the text twice and make one an annotation and the other
a bookmark. I have never done this before so some idea of the best way to
do this would be appreciated.

I am using Scribus 1.4.5 in Mepis 12
Thanks

OpenType alternate glyph support

Regarding issue #1413

<http://bugs.scribus.net/view.php?id=1413>

I'm curious to see what the status of this is. I migrated to InDesign
from Scribus because I use a couple of fonts (FF Zwo and Mister K) that
make heavy use of alternate glyphs and ligatures respectively.

I'd love to move back to Scribus, but specifically with Zwo I use
alternate glyphs for the following characters: 2, 3, 4, < at >, a, g, u. So
entering them in manually would be quite a chore beyond a few words.

It looks like there was talk of a 1,000 GBP bounty, but it doesn't seem
as if anything actually materialized. I'd love to throw some cash at
this feature, but before going down that road I was wondering:

- Are there any Scribus developers who would be interested in working on
this feature? If so, have they set a price they'd like to see?

- Has a list of requirements and acceptance criteria been compiled? Has
the time required to implement this been estimated yet? It looks like
two interrelated, but separate, features wer

letters uppercase I and lowercase l pdf problems

https://forums.adobe.com/thread/300106?tstart=0

This has been a known issue/bug in Adobe Acrobat for a long time as the
above post from 2008 shows. Just google fat characters or such and acrobat
and see results. I have been a graphic designer since 1992 and have to
deal with this on a weekly basis. If the document prints fine from a
postscript 2/3 printer then you should be OK barring any other problems.

Maynard

On Fri, Aug 28, 2015 at 5:00 AM, <scribus-request-rGrgPyRx504ZpDxWM7x1sV6hYfS7NtTn< at >public.gmane.org> wrote:

Ink coverage control : over 330%

Hi.
I regularly get complaints from my printers that ink coverage exceeds 330%.
I usually export as pdf 1.5, with a target profile of iso coated v2
300%. However as pdf 1.5 doesn't embed the profile it can be tricky.
I tried pdf x/3, but the lack of transparency support is a real issue,
as I have a log of PNG images and mainly use Scribus to convert these
rgb files to cmyk press-ready files.
Are there options to control the ink coverage within Scribus ?
(I'm using Linux and free software, so Acrobat pro and other high end
tools such as Callas are not an option.)

export problems in PDF

Hello,

We are running Scribus 1.4.5 and we experience a problem when we export
in PDF. The "l" letter always appears in extra-bold when we use acrobat
reader to view the pdf file.

Would you know how to fix this?
Many thanks.

Catherine

Same repository installs different versions of scribus1.5.0 / 1.5.1

Hi all,

something really weired happens with the launchpad scribus-ppa
repository. I have it in the sources-list on two computers, one of them
running Kubuntu 14.04 Trusty, the other one Kubuntu 15.04 Vivid.

"scribus-ng" installs 1.5.0 (as intended) on the trusty-machine, while
the same package, also labeled as 1.5.0, installs 1.5.1-svn on the vivid
machine.

I would like to have 1.5.0 on both computers. Can i use the "trusty"
repository on the vivid-Computer?

Thanks

Thorsten

Community generated UI/UX mockups

Hey all,

Check out the work of our friend Martin, http://goo.gl/2VfHMo

There is an .svg file created in inkscape for any UI designers that would
like to modify/augment the work he's done already.

Cheers,
/Kunda

Tutorien / Anleitungen • Retro-Plakette mit Band

[ Translate ]

Heute übersetze ich ein weiteres Tutorial von GarryP. Es wird diesmal etwas umfangreich, aber es lohnt sich auf jeden Fall. Plane ein bisschen mehr Bastelzeit ein.

Vorbereitung
Wie immer müssen wir ein bisschen vorbereiten, bevor wir mit dem Basteln loslegen können.
Als erstes benötigst du diese Schrift --> Fundamental Brigade.ttf (bei dafont.com). Installiere die Schriftart global auf deinen Rechner oder entpacke sie in einen Ordner, den du für dieses Tutorial einrichtest.

Und wir müssen ein paar Farben unserer Farbpalette hinzufügen:

Öffne Scribus ohne Dokument. Jetzt kannst du im Menü Bearbeiten - Farben aufrufen.
Klicke auf "Neu"
Gib deiner neuen Farbe einen Namen
Wähle als Farbmodell RGB
Stelle die Farbwerte ein.
Beispiel: Plakette

Wiederhole die Schritte für jede der folgenden Farben.
Gib deiner Palette einen neuen Namen und speichere sie.
Schließe den Farben - Assitenten mit OK.

Plakette: R 55 - G 69 - B 72
Sterne: R 166 - G 166 - B 166
Plaketten-Text: R 204 - G 204 - B 204
Band: R 55 - G 200 - B 171
farben-anlegen.png

farbe-anlegen2.png


Plakette und Hintergrund
Als erstes gestaltet du die Form der Plakette.
Wähle in der Symbolleiste das Polygon-Werkzeug :polygon: . Stelle in den Eigenschaften die folgenden Werte ein:
  • Ecken: 13
  • Rotation: 0
  • Aktiviere die Option "Faktor übernehmen"
  • Faktor: -10 %
Bestätige die Einstellungen mit OK
plakette1.png


Ziehe nun mit dem Tool eine Form auf. Im Eigenschaften Fenster Register XYZ stellst du die Breite auf 200pt und die Höhe auf 200pt.
Wähle Register Farben. Stelle die Linie auf keine Farbe, die Füllung auf Farbe Plakette

Rufe erneut das Polygon-Werkzeug :polygon: auf. Behalte alle Einstellungen bei. Füge nur noch eine Rotation hinzu. Stelle die Rotation auf 13 ein.

Ziehe ein weiteres Polygon auf. Stelle auch bei diesem Polygon die Höhe und Breite auf 200 pt ein. Wechsele in das Register Farben. Stelle die Linien Farbe auf keine und die Füllfarbe auf Band.
Dein Ergebnis sollte nun so aussehen:
plakette2.png


Nun legst du die Plakette und den Hintergrund übereinander. Markiere beide Polygone und öffne über Menü Fenster das Ausrichten-Tool.
Richte sie vertikal und horizontal zentriert aus.
Sollte das Grüne Polygon nun unter das Graue Polygon gerutscht sein, dann ist das nicht schlimm. Deaktiviere die Markierung klicke nur das obere Polygon an. Wähle Menü Objekt - Anordnung - Weiter nach hinten
Markiere beide Polygone, Gruppiere sie über Menü Objekt - Gruppieren
plakette3.png


Plakette Linien und Text
Schiebe die Polygon-Gruppe nun etwas zur Seite, sodass du ein wenig Platz hast.
Aktiviere in der Symbolleiste die Standardform :form: . Wähle die Form Ellipse aus.
Ziehe nun einen Kreis auf. Im Eigenschaften Fenster - Register XYZ stellst du die Höhe und Breite auf 140 pt ein.
Wechsele in das Register Farben. Wähle als Linienfarbe "Plaketten-Text".|

Öffne Menü Objekt - Transformation.
Füge die Option Skalieren hinzu. Der Kreis soll auf 90 % skaliert werden - aus der Mitte heraus - Eine Kopie.
plakette5.png


Hebe alle Markierungen auf und aktiviere den kleineren Kreis von beiden. Im Eigenschaften Fenster wählst du Register Linien. Als Linientyp wählst du die achte Linie von oben (die ist gepunktet).
plakette6.png


Aktiviere nur den kleineren Kreis. Wähle Menü Objekt - Transformation
Wähle die Option Skalieren aus. Der Kreis soll auf 70 % skaliert werden - aus der Mitte heraus - eine Kopie.
Dein Ergebnis sollte jetzt ungefähr so aussehen:
plakette7.png


Jetzt kommen wir zum Text. Öffne einen Textrahmen in der Größe des großen Kreises. Schreibe den Text "100% MADE WITH" (ohne Anführungszeichen) hinein.
Formatiere den Text über das Eigenschaften Fenster Register Text: Schriftart: Fundamental Brigade, Größe 16 pt.
Wechsele in die Textfarbe und färbe den Text mit der Farbe "Plaketten-Text" ein.

Aktiviere nun den Textrahmen und den kleinen Kreis. Wähle im Menü Objekt - Text an Pfad ausrichten. Dein Ergebnis sollte nun ungefähr so aussehen:
plakette8.png


Der Text steht jetzt ein wenig Kopf, das richten wir aber ganz schnell über das Eigenschaften Fenster. Wähle Register Text - Eigenschaften des Pfadtextes. Stelle dort die Anfangsposition auf 152 pt ein. (korrigiere die Angabe, je nachdem, wie sich der Text bei dir ausrichtet).
Markiere alle Kreise und den Text und gruppiere alles.
plakette9.png


Schiebe nun die Text/Kreis-Gruppe über die Polygon-Gruppe. Richte den Text/Kreis horizontal und vertikal zentriert an der Polygongruppe aus. Gruppiere anschließend alle Gruppen zu einer.
plakette10.png


Sterne
Kommen wir nun zu den drei Sternen für unsere Plakette.
Öffne das Polygon-Tool :polygon: - Eigenschaften.
Stelle 5 Ecken ein. Rotation 0, Faktor auf -52 %.
Klicke auf OK.
Ziehe nun ein Polygon auf. Stelle im Eigenschaftenfenster - Register XYZ die Höhe und Breite auf 30 pt.
plakette11.png


Wechsele in das Register Farben. Stelle die Linienfarbe auf "keine" ein und die Füllfarbe auf "Sterne".
Damit hast du die Basis für alle Sterne fertig.
Aktiviere den Stern und wähle Menü - Objekt - Transformation.
Füge die Option "Skalieren" hinzu. Skaliere den Stern auf 70 %.
Öffne erneut die Options-Liste und füge eine Rotation hinzu. Stelle die Rotation auf 10 % ein. Lasse 1 Kopie erstellen.
plakette12.png


Aktiviere nur den kleinen Stern und platziere ihn rechts neben dem größeren Stern.
Wähle im Menü - Objekt - duplizieren. Aktiviere den neuen Stern.
Im Eigenschaften Fenster klickst du im Register XYZ auf den Pfeil: vertikal spiegeln. Platziere diesen Stern nun auf die linke Seite des größeren Sterns.
Schiebe die Sterne auch ein wenig zur Seite, denn für das nächste Objekt brauchen wir ein wenig Platz.
plakette13.png


Das Band
Nun kommen wir zum Haupt-Teil des Tutorial - Dem Band. Ich hoffe du bleibst noch ein wenig um diesen Teil auch noch zu Basteln :)
Zunächst bauen wir den Hauptteil des Bandes. Aktiviere die Standardformen und wähle die Kreisform aus. :form:
Ziehe eine Ellipse mit einer Breite von 400pt und einer Höhe von 100pt auf.
Aktiviere Menü Objekt - Transformation.
Wähle die Option Umsetzung aus dem Optionsmenü.
Stelle die vertikale Umsetzung auf 50 pt ein. Es soll eine Kopie generiert werden.
plakette14.png


Markiere beide Ellipsen und wähle im Menü Objekt - Polygone kombinieren.
Öffne nun unter den Standardformen :form: ein Dreieck mit Spitze nach unten zeigend.
Stelle die Größe im Eigenschaften Fenster ein: Breite 200 pt, Höhe 600 pt.

Deaktiviere alles und aktiviere das lange Dreieck.
Drücke Shift und klicke die kombinierten Ellipsen an.
Aktiviere das Ausrichten-Fenster. Richte am zuletzt aktivieren Objekt horizontal zentriert aus und vertikal oben.
plakette15.png


Deaktiviere alle Objekte. Aktiviere dann erst das Dreieck, dann mit Shift die kombinierte Ellipse.
Wähle im Menü Objekt - Pfadwerkzeuge - Pfadoperationen.
In der Box Operation wähle Schnittmenge.
plakette16.png


Klicke das Rest-Polygon an und wähle Objekt - Polygone teilen. Lösche das untere Polygon.
Nun haben wir das Teil, welches wir für unser Band brauchen.
Aktiviere das Band und wähle Objekt - Duplizieren. Schiebe das Duplikat erst einmal an die Seite, wir werden es später benötigen.
Füge ein Textfeld ein. Schreibe "SCRIBUS" (ohne Anführungsstriche) hinein.
Formatiere das Textfeld über das Eigenschaften Fenster - Register Text.
Schriftart: Fundamental Brigade in Schriftgröße 40 pt.
Im Text-Register Erweiterte Einstellungen erweiterst du den Abstand zwischen den Buchstaben um 8 % (Dies ist nur notwendig, weil die Schriftart sehr eng zusammen liegt. Verwendest du eine andere Schriftart, brauchst du diese Einstellung wahrscheinlich nicht vorzunehmen).
plakette17.png


Aktiviere den Textrahmen und das Polygon. Wähle Menü Objekt - Text an Pfad ausrichten.
Der Text hängt jetzt ein wenig komisch um den Textrahmen. Stelle in den Eigenschaften des Pfadtextes die Anfangsposition auf 295 pt und den Abstand zur Kurve auf -30 pt, um den Text richtig anzeigen zu lassen.
plakette18.png


Ändere nun die Textfarbe deines Textrahmens in Weiß. Stelle in den Texteffekten den Textumriss ein. Klicke auf das Umriss-Symbol, um ihn zu erzeugen, klicke noch einmal auf das Symbol, bis sich ein kleines Fenster öffnet. Stelle die Umrissdicke auf 2 %.
plakette19.png


Aktiviere nun die Kopie des Polygon, die wir zuvor an die Seite geschoben haben. Aktiviere das Eigenschaften Fenster - Register Farben. Wähle als Füllfarbe "Band" und als Linienfarbe "Plakette".
Ziehe die Schrift über das Polygon. Zentriere die Schrift horizontal und vertikal darauf. Gruppiere die beiden Objekte.
plakette20.png


Knicke des Bandes
Du hast es fast geschafft, wir haben nun fast alles zusammen für unsere Plakette mit Band. Aber eine Kleinigkeit fehlt noch. Wir benötigen die kleinen Knicke für das Band.
Füge eine Standardform Rechteck ein :form: . Stelle im Eigenschaften Fenster die Größe auf Breite 40 pt, Höhe 50 pt.
Klicke doppelt auf die Form, um das Fenster Pfade bearbeiten zu aktivieren.
Klicke im Fenster Pfade bearbeiten auf das Symbol Knoten hinzufügen. Klicke auf die Mitte der rechten Seite auf die Linie, um dort einen Knoten einzufügen.
Verschiebe den Knoten nun auf X-Position 25 pt und Y Position 25pt. Beende anschließend die Bearbeitung.
plakette21.png


Aktiviere im Eigenschaften Fenster das Register Farbe und färbe das Polygon ein: Linienfarbe: Plakette, Füllfarbe: Band.
Für den nächsten Schritt solltest du die Ansicht etwas vergrößern. Klicke hierzu in der Statusleiste auf die Lupe mit dem "+". Denn nun basteln wir die Schattierung :)

Aktiviere die Standardform und wähle das Dreieck, welches mit der Spitze nach rechts zeigt. Füge es ein und stelle die Größe im Eigenschaften Fenster - Register XYZ auf Breite 20 pt und Höhe 2,5 pt.
Wechsele in das Register Farbe und fülle das Dreieck mit Farbe "Plakette". Stelle die Linienfarbe auf "keine" ein.

Wähle Menü Objekt - Mehrfach duplizieren. Wechsele in das Register Zeilen und Spalten. Stelle 20 Zeilen ein.
plakette22.png


Markiere alle Dreiecke und gruppiere sie. Ziehe die Gruppe über das Polygon und richte die Gruppe zum Polygon horizontal links und vertikal zentriert aus.
plakette23.png


Deaktiviere die Gruppe. Füge ein weiteres Dreieck ein. Breite: 15 pt, Höhe 10 pt. Wechsele in das Register Farben. Wähle Füllfarbe: "Plakette" Linienfarbe "keine".
Richte das kleine Dreieck an der Gruppe mit den Dreiecken aus. Links Seite und unten.
plakette24.png


Gruppiere alles und rotiere es über das Eigenschaften Fenster - Register XYZ auf 350°. Dupliziere die Gruppe und spiegele sie anschließend horizontal. Das Ergebnis sollte so aussehen:
plakette25.png


Plakette mit Band zusammensetzen
Kommen wir jetzt zum spannenden Ende des Tutorials und fügen alles zusammen.
Zuerst stellen wir das Band fertig.

Schiebe die beiden zuvor erstellen Polygone unter das Mittelstück vom Band (Objekt - Anordnung - In den Hintergrund). Die untere Ecke muss mit der Spitze des dunklen Dreiecks abschließen. Gruppiere anschließend das komplette Band und bringe die Gruppe über Objekt - Anordnung - in den Vordergrund.
plakette26.png


Hole nun die Plakette hervor. Platziere das Band zentriert darüber.
Aktivere nun die Sterne. Löse die Gruppe, und markiere sie alle. Rufe das Ausrichten-Tool auf. Wechsle in das Register Verteilen. Fügen nun einen horizontalen Abstand von 2 pt ein. Kicke auf horizontal verteilen.
plakette27.png


Gruppiere die Sterne wieder und setze sie über dem Band unter den gebogenen Text. Fertig ist deine Retro-Plakette mit Band.

fertig.png


ich wünsche allen viel Spaß beim Nachbasteln.

Dieses Tutorial wurde von GarryP auf http://forums.scribus.net veröffentlich. Das Tutorial im Original findest du hier → http://forums.scribus.net/index.php/topic,1531.0.html
Mit seiner freundlichen Erlaubnis durfte ich das Tutorial auf Deutsch übersetzen. Weitere Tutorien von GarryP findest du auf http://http://forums.scribus.net/index.php?board=11.0

Creative Commons Lizenzvertrag
Dieses Werk ist lizenziert unter einer Creative Commons Namensnennung - Weitergabe unter gleichen Bedingungen 4.0 International Lizenz.

Statistik: Verfasst von Anke — Sa 22. Aug 2015, 13:33 — Antworten 0 — Zugriffe 72


compiling 1.5.1

I use jluc's script to compile 1.51 (soon to be
1.6.0!) Two anomalies appear. First after
compiling via the script when I use the result I
get a fistful of messages concerning png files not
found. However the program runs ok with pngs
in place. One of the pngs allegedly not found is
the splash screen.

Second the splash screen never changes. It always
claims to be version 20339 released on July 25,
2015.

One of the many virtues of Jluc's script is that
alterations to fit individual needs are segregated
at the top. So here is my prologue taken from the
script that I run (ignore word wraparounds by my
mail program):
--------------------------
#!/bin/sh

# maksvn script creates folders for out of source build
# has command line options for really clean
#build, creating diffs and for svn update
# has various inline options to EDIT to fit your environnement

# sourcepath, qt library and destination folders can be set to user conveninence
# Note :sourcepath will later contain both the 'svn' subfolder
# and th

r20342 by jghali - msvc project update

jghali:
msvc project update
Modified
trunk/Scribus/win32/vc11/barcodegenerator/barcodegenerator.vcxproj trunk/Scribus/win32/vc11/barcodegenerator/barcodegenerator.vcxproj.filters

r20340 by craig - Barcode generator: 2 updates. Split the type selection combo into two, and from Terry, thread the rendering for speed

craig:
Barcode generator: 2 updates. Split the type selection combo into two, and from Terry, thread the rendering for speed
Modified
trunk/Scribus/scribus/plugins/barcodegenerator/CMakeLists.txt trunk/Scribus/scribus/plugins/barcodegenerator/barcodegenerator.cpp trunk/Scribus/scribus/plugins/barcodegenerator/barcodegenerator.h trunk/Scribus/scribus/plugins/barcodegenerator/barcodegenerator.ui

page size issue in pdf

Hi all,

I have created a document with 210mm x 280mm with 3mm bleed on all sides

When I created pdf without crop marks. Pdf page size is 215.9mm x 279.4mm

Why width of the pdf takes the bleed size also? Is there any way to fix
this.

As same as if I create PDF with crop marks. Pdf page size is 215.9mm x
279.4mm (bottom left of the page crop mark appears, whereas in all other
sides there is no crop mark, as well as on right side page cropped)

Please some one help me to fix this.

Regards,

Srikrishnan

It's been a while since I last posted a tutorial so I thought I'd make something a bit different. This...

Finally, +Garry Patchett delivers yet another fantastic #tutorial  on how to create a magazine frontpage in #Scribus  
Hillarious mockup with shoutouts to the Infamous Monsters of FOSSLAND

#inkscape   #gimp   #b3d

Garry Patchett originally shared:
It's been a while since I last posted a tutorial so I thought I'd make something a bit different. This one shows you how to create a parody of a magazine cover from beginning to end. I hope people find it useful.

How to make a parody magazine cover - Scribus Wiki
Introduction. This tutorial will show you how to make a parody of a "Famous Monsters of Filmland" magazine cover. The tutorial is very long and you should already know how to: Create text frames and change basic text formatting. Create image frames and change scaling.

r20338 by jghali - put back sliders and spinboxes side by side in color editor + transform sliders in real color sliders

jghali:
put back sliders and spinboxes side by side in color editor + transform sliders in real color sliders
Modified
trunk/Scribus/Scribus.pro trunk/Scribus/resources/translations/scribus.fr.ts trunk/Scribus/scribus/CMakeLists.txt trunk/Scribus/scribus/ui/cmykfw.cpp trunk/Scribus/scribus/ui/cmykfw.h trunk/Scribus/scribus/ui/cmykfwbase.ui trunk/Scribus/win32/vc11/scribus-main/Scribus.vcxproj trunk/Scribus/win32/vc11/scribus-main/Scribus.vcxproj.filters

Thanks to a contributor we now have better HiRes support for #Scribus on OSX (committed to 1.5.1 trunk...

Thanks to a contributor we now have better HiRes support for #Scribus on OSX (committed to 1.5.1 trunk). What is missing are HiRes icons. 
https://github.com/scribusproject/scribus/pull/20

#collaborate   #opensource  

Better HiRes support by LiamHD · Pull Request #20 · scribusproject/scribus
Add basic HiRes support on Mac OS.

r20333 by jghali - #13184: "View rulers" setting not retained across session

jghali:
#13184: "View rulers" setting not retained across session
Modified
branches/Version14x/Scribus/scribus/prefs.cpp branches/Version14x/Scribus/scribus/prefsmanager.cpp branches/Version14x/Scribus/scribus/reformdoc.cpp branches/Version14x/Scribus/scribus/scribus.cpp branches/Version14x/Scribus/scribus/scribusview.cpp branches/Version14x/Scribus/scribus/tabdisplay.cpp branches/Version14x/Scribus/scribus/tabdisplay.ui

r20332 by craig - #13301 for hi res on OSX, and new pro/ts files

craig:
#13301 for hi res on OSX, and new pro/ts files
Modified
trunk/Scribus/OSX-package/inputs/Info.plist trunk/Scribus/Scribus.app/Contents/Info.plist trunk/Scribus/Scribus.pro trunk/Scribus/resources/translations/scribus.af.ts trunk/Scribus/resources/translations/scribus.ar.ts trunk/Scribus/resources/translations/scribus.bg.ts trunk/Scribus/resources/translations/scribus.br.ts trunk/Scribus/resources/translations/scribus.ca.ts trunk/Scribus/resources/translations/scribus.cs_CZ.ts trunk/Scribus/resources/translations/scribus.cy.ts trunk/Scribus/resources/translations/scribus.da_DK.ts trunk/Scribus/resources/translations/scribus.de.ts trunk/Scribus/resources/translations/scribus.de_1901.ts trunk/Scribus/resources/translations/scribus.de_CH.ts trunk/Scribus/resources/translations/scribus.el.ts trunk/Scribus/

r20326 by fschmid - WIP to fix Bug #12297 Color Code Master Pages like in Layers dialog

fschmid:
WIP to fix Bug #12297 Color Code Master Pages like in Layers dialog
Modified
trunk/Scribus/scribus/canvas.cpp trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format.cpp trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format_save.cpp trunk/Scribus/scribus/scpage.cpp trunk/Scribus/scribus/scpage.h trunk/Scribus/scribus/scribus.cpp trunk/Scribus/scribus/ui/margindialog.cpp trunk/Scribus/scribus/ui/margindialog.h trunk/Scribus/scribus/ui/pagepalette_masterpages.cpp trunk/Scribus/scribus/ui/pagepalette_pages.cpp trunk/Scribus/scribus/ui/pagepalette_pages.h

Scribus 1.5.1 Font Preview

The Font preview in 1.5.1 has several columns
marked a through f. Where are these
columns defined? Based on the content "a" is the
font type symbol,"b" is the same spelled out, and
"f" is the owner of the font, system or user.
What about the rest?

Preview of the new PhotoFlow GUI

Preview of the new PhotoFlow GUI

Recently I've been busy re-writing the GUI layout, in the hope of improving the overall usability.
In particular, I have decided to abandon the idea of putting the tools controls in separate dialogs, in favor of grouping them in a side panel.

In the new layout, the layer list appears now on the left of the preview area. When the user double-clicks on the layer's name, the corresponding GUI controls are added to another panel on the right of the preview area.

One can also quickly access the opacity and blend mode of the selected layer in the top part of the layer list.

I'm planning to release the new GUI interface in the next few days. This new release will only differ in the GUI interface, while the tools will remain unchanged. The re-writing of the GUI is completely done, but I still need to check that all tools look OK in the new layout.

I'll also post a detailed description of the new GUI as soon as it gets released.

Once this will be done, I'll go back to improve the editing tools. I have few ideas for the RAW development, in particular:
- auto-exposure (based on a target % of clipped pixels)
- LMMSE demosaicing
- chromatic aberrations corrections (automatic, manual and lensfun-based)


Thank you, thank you, THANK YOU!

May all the blessings of the Digiverse shower upon you in a beautiful,
though less ominous, Matrix-like rain of code!

Srsly—though I'm certainly late to the party, as a sometime graphic
designer frustrated with profit-driven commercial companies, I just wanted
to voice my appreciation for the effort and vision that the Scribus team
has evidently undertaken to date (and, we hope, continues to do). I have
not yet investigated the software itself, but I'm eager to find out what it
can do, and (I hope) whether it can supplant the shiny-flashy,
subscription-based stuff I'm presently forced to use for work.

Which shall remain nameless. As if you don't all know who I mean. Grrrr....

Just THANK YOU for doing this service for humanity.

Cheers & good coding to you all.

Ben

#Scribus  receives long needed #arabic  localization patch

#Scribus  receives long needed #arabic  localization patch 
Thanks Khalid!

0013296: Translation to Arabic - Mantis Issue Tracker for Scribus
View Issue Details [ Jump to Notes ], [ Issue History ] [ Print ]. ID, Project, Category, View Status, Date Submitted, Last Update. 0013296, Scribus, Translation, public, 2015-08-14 16:47, 2015-08-14 16:58. Reporter, khalidaou. Assigned To. Priority, normal, Severity, text, Reproducibility ...

+Bjarne Svanberg is the author of https://github.com/bjarnesvanberg/Scribus-Data-Merger It's data merge...

+Bjarne Svanberg is the author of https://github.com/bjarnesvanberg/Scribus-Data-Merger It's data merge tool that will help you populate a #Scribus file using #python  with data from a CSV file.

Check out his work.  

bjarnesvanberg/Scribus-Data-Merger
Scribus-Data-Merger - Data merge tool that will help you populate a scribus file with data from a CSV file

Linux - 7 months later

Linux - 7 months later

After installing Ubuntu on an old Windows XP laptop, I began to use it for light tasks from web browsing to YouTube surfing. It ran MUCH better so I decided to do more and installed a few graphics open source programs such as DarkTable(Lightroom alternative), Scribus(InDesign), Inkscape(Illustrator), and Gimp(Photoshop). With a little bit of a learning curve with the different user interfaces, I am slowly becoming more comfortable with them and would have no problem using it on my main PC.... If more programs were supported for Linux. I haven't had any major crashes so far and like how it just works. I have even installed Linux Mint on an old iMac and it runs smooth on it. If you have an old system or want to try something new, I recommend giving Linux a try. 

Bonus: Here is a photo I took of Max, drew a quick title in Inkscape, edited in DarkTable, and exported with ease. Developers... if you see this and have worked on Linux apps, THANK YOU!

#Linux   #LinuxMint   #Ubuntu   #Developer   #Inkscape   #DarkTable   #Scribus   #Gimp  


Here's a little experiment that I made using Scribus, GIMP and a bit of Javascript. It's a first attempt...

We aren't sure how this one got by the goalie but here is another cool experiment by +Garry Patchett using #Scribus to simulate a old-time newspaper frontpage.

EDIT: Grammer

Garry Patchett originally shared:
Here's a little experiment that I made using Scribus, GIMP and a bit of Javascript. It's a first attempt at making a reasonable facsimile of an old scanned newspaper front page. Old-timers might be able to guess which movie it was inspired by. (Can you spot all of the references?)


Feedback zum Forum • indexierung in suchmaschinen

[ Translate ]

das forum lässt sich sehr schlecht über suchmaschinen finden.

ich möchte hier eine diskussion starten, über massnahmen die wir treffen können, um besser dort aufgelistet werden.

es geht nicht darum irgendein SEO-scheiss zu diskutieren, nur den deutschsprachige scribus users die zurzeit beste platform anbieten zu können :-)

also, meine erste frage: wurde diese seite bei google gemeldet?

ciao
a.l.e

Statistik: Verfasst von a.l.e — Do 13. Aug 2015, 16:45 — Antworten 8 — Zugriffe 143


Interesting discussion happening on #Github related to #Scribus  automation via #python  between berteh...

Interesting discussion happening on #Github related to #Scribus  automation via #python  between berteh & bjarnesvanberg concerning the directions of ScribusGenerator and Scribus-Data-Merge 
http://goo.gl/wb10K8

#collaborate    #OpenSource  

How does this differ from Scribus Generator? · Issue #1 · bjarnesvanberg/Scribus-Data-Merger
https://github.com/berteh/ScribusGenerator

Andreas Vox creates RTL branch on ScribusCTL project. He committed a fixed version of moceap's RTL patch...

Andreas Vox creates RTL branch on ScribusCTL project. He committed a fixed version of moceap's RTL patch. He also explains how he wants to go in a different direction: 

"I plan to keep this branch as a reference but will not merge it back into master, since the chosen approach will make it difficult to realize the other goals of CTL. More details in issue #3 (https://github.com/andreas-vox/ScribusCTL/issues/3#issuecomment-128344149)."

Last Workable RTL patch (need little work) by moceap · Pull Request #6 · andreas-vox/ScribusCTL · GitHub

Erste Hilfe • HHIILLLFFEEE!!! Scribus verändert Formatierung von .odt Datei

[ Translate ]

Hallo zusammen!

Ich bin am Verzweifeln und meine Zeit läuft mir schön langsam unter den Fingern davon. Ich erstelle ein Lehrwerk in Scribus, dass ev. in Druck gehen soll. So jetzt hab ich schon Stunden bzw. sicher bereits Wochen damit Verbracht mich in Scribus einzulesen. Die guten Tipps mit eigenen Textdateien (.odt) zu erstellen hab ich dann auch in open Office umgesetzt. Layout steht auch. So jetzt will ich diese Dateien mit Aufzählungszeichen einfügen und Scribus übernimmt mir diese Eingaben leider nicht. WAS MACHE ICH FALSCH?? Ich danke für eure Hilfe :danke: Ich kann und mag bald nicht mehr. Muss das Ding aber fertig bringen.

DANKE

Statistik: Verfasst von muehlimaria — Mi 12. Aug 2015, 15:17 — Antworten 9 — Zugriffe 130


Font fury

I prepared a cover using some ordinary fonts.
Liberation Serif Regular shows up in scribus 1.5.0
and on the cover pdf on my computer. Most fonts
are not subsetted. But when the cover was printed
for many lines of text all the characters are
just rectangles. Scribus finds these fonts (all
of the Liberation family) in my home directory in
the directory .fonts. But they also appear
in /usr/share/fonts. Deja Vu fonts come through
OK.

Will subsetting these fonts embed them into the
pdf file?

Proofs cost money. How can I be sure that the
fonts are in the pdf file before I ship it to the
printer?

Silly Magazine cover - messing around with Inkscape and some off-beat images I've found.  Lot of insetting...

+Larry Anderson check out https://github.com/aoloe/scribus-newsletter/issues/3 perhaps you'd like to help brainstorm ?

Larry Anderson originally shared:
Silly Magazine cover - messing around with Inkscape and some off-beat images I've found.  Lot of insetting, clipping paths and some effect filters.  Anyone got a zine the need content for, I'd be interested in whipping something up.  :-)


Layout • Sprachen und Silbentrennung und andere Probleme

[ Translate ]

Hallo und einen schönen Sonntag,

bei meiner Suche nach einer Lösung zu meinem Problem bin ich auf dieses Forum gestoßen, da ich sonst nichts weiter gefunden habe und mir der Beitrag hier: http://www.scribus-forum.de/viewtopic.php?t=229 nicht geholfen hat, habe ich mal die Mühe auf mich genommen, mich zu registrieren.

Ich nutze Ubuntu 14.04 LTS und Scribus 1.4.5

Da ich die Silbentrennung nutzen möchte wollte ich die Sprache für den Absatzstil einstellen, jedoch habe ich da keinerlei Auswahlmöglichkeit für eine Sprache. Zwar steht dort Sprache aber wenn ich drauf klicke erhalte ich keine Auswahlmöglichkeit. Somit ist klar das die Silbentrennung nicht funktionieren kann. Obwohl ich mir so eine Datei runter geladen: hyphdeOLD.dic und entsprechend der Anleitung im Scribus Wiki ins usr/... - Verzeichnis kopiert.

Wie kann ich das Problem lösen?

Zudem verschwinden ständig die Zeichen Einstellung (Schriftart) für meinen Absatzstil, woran kann das liegen?

Statistik: Verfasst von scribusnutzer88 — So 9. Aug 2015, 15:16 — Antworten 2 — Zugriffe 99


I was playing around with this fitness magazine cover experiment yesterday but when I came back to it...

+Garry Patchett showing us another experiment he has created with #Scribus

Garry Patchett originally shared:
I was playing around with this fitness magazine cover experiment yesterday but when I came back to it today I didn't know whether I still liked it. There are bits that I like but there's something about it which I just can't put my finger on. What does anyone else think? Do you like it or loathe it? Can you figure out what's wrong with it?


I'm back from vacation ! I've already started to work on the next G'MIC release (which wil be numbered...

I'm back from vacation ! I've already started to work on the next G'MIC release (which wil be numbered 1.6.5.2), and posted today new pre_release binaries, available by default from http://gmic.eu/download.shtml.

Also, we've recently received enough donations to renew our domain name and the web hosting space for the next year. So, thanks again dear Friends for your support ! Now, we are back to work with the goal of building an essential free tool for image processing and libre graphics :)

On the road to G'MIC 1.6.5.2 - G'MIC -

Remember Berteh from a previous post about Scribus Generator? The same fellow just submitted a patch...

Remember Berteh from a previous post about Scribus Generator? The same fellow just submitted a patch for review that is a proof of concept to enable running #Scribus   #python   #scripts  via the CLI. Woot! Hopefully this will kickstart development on Scribus Scripter2! 

Here is the patch: http://goo.gl/3kLmBR 

add support for command line arguments to be passed on to python script (-py option) by berteh · Pull Request #19 · scribusproject/scribus
adding 2 options to pass arguments to python script run in Scribus from command line (to be used with -py and -g), after short discussion with a-l-e on irc. --python-arg A...

Tutorien / Anleitungen • Comic-Texteffekt

[ Translate ]

Comic – Texteffekt
von GarryP

Dieses kleine Tutorial zeigt dir, wie du einen simplen aber effektvollen Comic-Buch Texteffekt mit Scribus gestaltest.

Bevor es losgeht, solltest du dir die Schriftart SF-Comic Script Bold herunterladen. Du findest sie im Internet unter http://www.dafont.com/sf-comic-script.font (Lizenz: frei für den persönlichen Gebrauch). Nach der Installation sollte die Schriftart in Scribus auswählbar sein.
Möchtest du die Schriftart nicht global installieren, kannst du sie auch in einen speziellen Ordner ablegen, den du für dieses Tutorial anlegst. Speichere das Scribus-Dokument in diesen Ordner direkt nach dem Erstellen.

Schritt 1

  • Öffne ein neues Dokument mit Scribus. Ich habe für diesen Effekt eine DIN A5 Vorlage im Querformat gewählt.
  • Damit wir gleich im Tutorial alle Objekte sehen können, ist es wichtig den Hintergrund der Seite zu färben. Füge ein Rechteck über die gesamte Seite ein und färbe es in Blau.
  • Öffne Menü Fenster – Ebene
  • Füge eine neue Ebene ein, auf der du den Effekt gleich gestaltest. Schließe das Fenster anschließend wieder.
bild1.png



Schritt 2
Füge einen schönen großen Textrahmen auf deinem Dokument ein. Schreibe dein Wort hinein. Bei kurzen Wörtern wirkt der Effekt besser als bei langen.
Formatiere den Text auf ca. 100pt in Schriftart SF Comic Script Bold.
bild2.png



Schritt 3
Jetzt änderst du die Beschaffenheit des Textrahmens, sodass wir den Text weiter bearbeiten können.
Aktiviere den Textrahmen. Wähle nun nacheinander:
Menü – Objekt – Umwandeln in – Umriss (aktiviere erneut den Text)
Menü – Objekt – Gruppe auflösen
Menü – Objekt – Polygone kombinieren (aktiviere erneut den Text)

Menü – Objekt – Mehrfach duplizieren, erstelle 3 Kopien, die du um 2 pt vertikal versetzt.
bild3.png




Schritt 4
Du hast nun 4 Kopien die wir nun bearbeiten. Im Eigenschaftenfenster Register XYZ kannst du jeder Kopie einen aussagekräftigen Namen geben. Ich habe jetzt die Ebenen von Oben nach unten wie folgt benannt:
  1. bunt
  2. weißhinterbund
  3. schatten
  4. weißhinterschatten
Die Namen verraten dir jetzt auch schon, wie die Kopien bearbeitet werden
bild4.png



Schritt 5
Aktiviere die Kopie „weißhinterschatten“. Aktiviere im Eigenschaftenfenster Register Farben.
Wähle Füllfarbe und Linienfarbe weiß.
Aktiviere das Register Linien und stelle die Linienbreite auf 3 pt ein.
bild5.png


Aktiviere die Kopie „weißhinterbunt“. Aktiviere im Eigenschaftenfenster Register Farben.
Wähle Füllfarbe Weiß, Linienfarbe Weiß.

Aktiviere die Kopie „bunt“. Aktiviere im Eigenschaftenfenster Register Farben.
  • Wähle als Füllung einen Verlauf Senkrecht.
  • Aktiviere das vordere Dreieck und wähle Farbe Rot.
  • Aktiviere das hintere Dreieck und wähle Farbe Gelb.
  • Wähle als Linienfarbe Schwarz.
bild6.png


Dein Ergebnis sollte bis jetzt so aussehen:

bild7.png



Schritt 6
Nun müssen wir unsere Kopien nur noch zusammensetzen.

Beginne mit der Schatten-Kopie. Zunächst setzt du sie über Menü Objekt – Anordnung – in den Vordergrund.
Schiebe sie anschließend über die Kopie „weißhinterschatten“. Ungefähr so:
bild8,.png


Aktiviere die Kopie „weißhinterbunt“. Setze sie über Menü Objekt – Anordnung – in den Vordergrund.
Schiebe sie anschließend über die Kopie „schatten“. Ungefähr so:
bild9.png


Aktiviere zum Schluss die Kopie „bunt“. Setze sie über Menü Objekt – Anordnung – in den Vordergrund.
Schiebe sie nun über die Kopie „weißhinterbunt“. Ungefähr so:
bild10.png


Somit haben wir alle Kopien übereinander gelegt und damit einen tollen Comic-Effekt erzielt.
Sollten deine Kopien nicht so schön übereinander liegen, kannst du sie im Anschluss ganz einfach verschieben.
Aktiviere über Menü Fenster – Dokumentenstruktur.
Es öffnet sich ein kleines Fenster, in dem alle Objekte des Dokuments enthalten sind. Da wir unsere Kopien so schön benannt haben, kannst du nun ganz einfach die Kopie im Fenster anklicken, die du noch einmal verschieben möchtest. Über die Pfeiltasten auf deiner Tastatur kannst du sie in alle Richtungen verschieben.
Ich empfand z. B. Den weißen Untergrund zu stark, also habe ich ihn ein wenig nach links verschoben.
bild11.png



Viel Spaß beim Nachbasteln!

Dieses Tutorial wurde von GarryP auf http://forums.scribus.net veröffentlich. Das Tutorial im Original findest du hier → http://forums.scribus.net/index.php/topic,1412.0.html
Mit seiner freundlichen Erlaubnis durfte ich das Tutorial auf Deutsch übersetzen. Weitere Tutorien von GarryP findest du auf http://http://forums.scribus.net/index.php?board=11.0

Statistik: Verfasst von Anke — Mi 5. Aug 2015, 13:46 — Antworten 3 — Zugriffe 120


After some really great feedback to my original "Circus" spread I've made some changes:

+Garry Patchett refines his work based on feedback from the #scribus community. Awesome. 

Garry Patchett originally shared:
After some really great feedback to my original "Circus" spread I've made some changes:
* The "Admit One" ticket has been removed. (It wasn't doing anything useful and created a colour problem.)
* The photo of the girl has been removed. (She wasn't adding anything to the design and was a bit distracting.)
* The "angled sidebar" has been moved to the middle of the page and rotated back a bit.
* The "sidebar" has also been given a swirly background pattern with a slight gradient to give it a bit more interest.
* The dog has been removed and the pull quote has been moved over. (By removing the girl, the ticket and the dog there's now just one visual "pull" to the whole spread.)
* The kicker at the top of the first page has been given its own gradiant background to stop it being a uniform colour.
* All three blocks of colour have been given one rounded corner to make them look less "severe" and keep them visually similar.
* Some other minor changes have also been made.

Many thanks to everyone who gave suggestions and comments. They were very useful and interesting. (Any mistakes and/or problems with this version of the spread are totally of my own doing and shouldn't reflect badly on the people who have given advice.)

While this spread isn't finished - I could probably keep tweaking it for days - I think I'll move onto something else, but any further comments will be appreciated and may affect future experiments.


L'avancement ces derniéres semaines a été un petit peu ralentie. En effet, je suis partie 3 jours à…

[ Translate ]

L'avancement ces derniéres semaines a été un petit peu ralentie. En effet, je suis partie 3 jours à Genève pour rencontrer d'autres membres de l'équipe aux RMLL. Ça n'a pas été inutil bien au contraire puisque ça m'a permis de voir les gens avec qui je travail et de pouvoir discuter de toute cela directement ce qui est bien plus facile et plus agréable qu'IRC. Ça m'a permis de rencontrer également des utilisateurs de scribus pour voir ce dont ils ont besoin par exemple. On en a donc profiter pour décidé ce qui devrait être fait dans la deuxième partie de mes GSoC mais j'y reviendrais par la suite. Au niveau programmation. Tout d'abord, comme je l'avais prédit dans mon article d'il y a deux semaines, j'ai finis le travail sur le undo/redo pour le gradient de transparence. J'ai d'ailleurs remarqué que certains options sont ici parce qu'elles font partie du gradient pannel mais en réalité, elles sont inutils dans le cas de la transparence. C'est un petit peu perturbant. La deuxiéme a été pour la création des courbes de bézier. Dans ce cas l'astuce a été de déplacer la création du undo au bon endroit (une fois l'objet entièrement créer) puis de supprimer les undos inutiles créer par d'autres fonctions durant le processus de création. J'ai ensuite réctifié le undo pour l'ajustement de la frame de texte à la hauteur du texte et la duplication. Pour cela, il suffisait de regrouper plusieurs actions en une seul. Par la suite, je me uis mis au undo/redo pour l'action "Transform" dans le menu objet. Celui ci à d'étrange qu'il permet une rotation par exemple sans pour autant utilisé la fonction normal de rotation. Cela complique le code pour pas grand chose à mon avis mais bon, c'est un autre sujet.Ce undo m'a demandé un peu de temps puisque l'action de base utilise "adjustitemSize". C'est une fonction utilisant beaucoup de sous fonction. Je ne me suis donc jamais risqué à créer un undo pour cette fonction puisque ceci s'avére en général pas nécessaire. Cependant, cela finis par me causé des problèmes de positionnement lors du undo/redo. Finalement, j'ai réussis à les contrer grace a la fonction moveTo en sauvegardant la position de départ et en applicant le bon déplacement à la fin du undo. Je me suis trompé un moment sans comprendre d'ou venait le problème en faisant le adjustitemsize après le déplacement ce qui me faisait un décalage que je ne comprennais pas. Maintenant tout fonctionne correctement. Toujours en continuant de chercher des problèmes de undo, je suis tomber sur des crash de scribus lorsque l'on utilisait le undo pour le changement de niveau des calques. En effet, il y avait une confusion entre deux identifiant différent que l'on donne aux calques dans le code. Leurs niveau et leur Id propre. Maintenant, je n'ai plus eu de crash à ce niveau là. Enfin, j'ai ajouté un undo correct pour le changement de code dans une render frame et pour le changement de page d'un pdf que l'on souhaite afficher dans une frame d'image. Il n'y a pas grand chose d'intéressant à ce niveau là puisque ce sont des undos tout ce qu'il y a de plus normal. Le plus dure est de trouvé le undo concerné et sa position comme d'habitude. Enfin, le undo pour l'édition des polygones, des arc et des spirals. Ceux ci ont de multiples options de nombre de coté, de longueur et d'angle et l'on ne pouvait pas revenir sur ces modifications. Maintenant cela est donc possible. Pendant ces modifications, j'ai eu de droles de suprises parce que certains undo n'utilise pas d'identifiant unique. Au moins, maintenant je fais plus attention à ce genre de problème que j'en rencontré une autre fois par la suite. J'ai également profité des RMLL et de diiscution avec pygmee pour empeché le undo lors de la création de certaines frames (comme les courbes) et pour améliorer la sélection après un undo ou un redo. Toutes les modifications cité précédement sont donc maintenant dans le trunk grace à MrB :-) Suite à une remarque de cezaryece, j'ai également corrigé un bug qui apparaissait lorsque l'on demandait d'effacer le contenue d'une frame de texte. Le bug se trouvait dans la gestion même du undo et je ne comprend pas vraiment pourquoi celui ci avait lieu... Un autre problème avait lieux lors du undo/redo de la conversion en contour. Le problème étant la création d'un trop grand nombre de undo alors que certains étaient inutil. En pour finir le travail sur le undo: l'option connect to path. Celle ci n'avait aucun undo et faisait partie d'un plugin. En effet, même dans ceux ci il faut traiter le undo. Ce qui n'est pas forcement facile puisque un plugin se veut séparer mais le undo est dans le code base. J'attend que ces derniers changement soit commité pour pouvoir demander à tout le monde de tester le undo pour me faire remaqué les endroit que j'ai oublié. Pendant ce temps, il a été décidé durant les RMLL de mettre en place un multiple import d'image. Il est donc possible (dans ma branch seulement pour le moment) de créer une frame d'image, sélectionner: importer une image puis de sélectionner plusieurs images. Si une seul image est sélectionné, il n'y a pas de changement par rapport à d'habitude. Mais il est aussi possible de sélectionner plusieurs images et dans ce cas, une liste des images apparait à coté du curseur. Il est possible de changer d'image avec tab ou shift + tab. Si on click sur une frame d'image, l'image sélectionné est importé dans la frame, sinon, il est possible de créer une frame directement avec l'image importé dedans. Je vous laisse donc jugé de l'efficacité de cette technique. Tant que je travaillais sur les images, j'ai ajouté la possibilité de remettre à zero une frame d'image qui n'a pas une image valide comme le reportait un bug de ale. Et pour finir, je me suis attelé à faire du panneau d'historique un panneau dockable. Donné le nom au panneau est un peu étrange mais cela fonctionne pour notre cas. Maintenant, je travail un peu sur le undo specifique et les bugs qui me sont assigné et je devrais bientôt commencer mon travail sur le panneau de recherche qui n'est vraiment pas très "user friendly". A bientot pour plus de nouvelles

This article is in english as non-french speakers asked informations about style management in…

[ Translate ]

This article is in english as non-french speakers asked informations about style management in scribus. During RMLL, I meet a lot of people who are using scribus or are working to improve it (or both) and we spoke about style management in Scribus. It is a point that should really be improve in next scribus version (even if, as far as I know, it is not planed in 1.6 release). In this article, I will only speak about charactere style and paragraphe style, not about local modification of style which is another topic. The problem is : When you apply a character style to a word in a paragraph (example : bold). Then, you apply a paragraph style : size font = 16 (instead of 12 by default). You can notice that the word in bold keep a font size of 12. Of course, it is not a correct behaviour. If you ask for information about this issue on IRC, people will answer: This is because even if you don't change the font size in the character style, the value is 12 so the font size of your word is 12. In fact, if you look into the code, it is a wrong answer. You can also see that it is a wrong answer if you look at the .sla file. The value of 12 is not saved in the style. The only place where the value of 12 is saved is in the default character style. So, what happen exactly? first, we have to notice that a paragraph style can have character style component. The font size is a good example as it appear in paragraphe style and in character style. So, if you apply a paragraph style and then you apply a character style, the selected text must have 2 character style. On the selected word, we expect that the apply order is : default paragraph style -> default character style -> paragraph style -> character style but it is not the case because a letter can have only ONE character style and this character style have a paragraph style (yes, you read correctly in Scribus, it is not a paragraph style which have a character style but the opposite). When I saw this, I thought : ok, in this case, when I apply a paragraph style, I just have to check if the value in the character style is a real value. If it is not (it is an inherited value from default character style), I will add the value of the character style I want to apply from paragraph style. Not to hard to understand? But in fact, all values are inherited value. Some of them inherited from default character style but other inherit from the character style I applied. Why? Because when you create a style and you apply it in two different word. You can't set the value directly to these word. Otherwise, they will not be updated if you change the character style. And it is the same behaviour when you apply character style from paragraph style. In a nutshell, when you apply a paragraph style, all words in the paragraph have an empty character style with the character style of this paragraph style as parent and when you apply character style, you change this parent to the character style you are applying. (character style is stronger than character style from paragraph style). by the way, I thing that this empty style is not empty if you apply inline style modification...

For me, all this problem appear because in scribus now it is not a paragraph style which contain a character style but the opposit. I thought about two solutions : we can enable style to have many parent. In this case we will not have more problem but, as pygmee noticed, user will need to define priority between style. It can be really confusing and I don't know any programm working in this way. The other solution is to change style definiation to make paragraph style owning character style and applying the priority like I defined it previously. In this instance, a word will have his own character style and the character style from his paragraph style. But it may be really hard to do this as it will involved a lot of modification in the scribus code base. First, we will need to redefined how it is apply but also, as there is another character style, we will need to take it into account when we export the textframe to pdf. Good luck to the guy which will do this work.

Voila quelques jours que je n'ai pas écris. Je voulais attendre d'avoir finis la tache sur laquelle…

[ Translate ]

Voila quelques jours que je n'ai pas écris. Je voulais attendre d'avoir finis la tache sur laquelle je travaillais pour vous tenir au courant de l'avancement. J'ai donc résolues quelques petits undo/redo : la rotation d'une image, le passage entre les mode : échelle réel et adapté à la taille de la frame, (donc les changements de résolutions de l'image) et pour finir, le undo/redo pour le changement d’échelle des flèches aux extrémité des lignes. Jusque là, tout ce qu'il y a de plus normal même si des fois, ça fait bien réfléchir pour comprendre pourquoi quelque chose qui semble bon en théorie ne l'est pas en pratique. J'ai donc fait ceci en une demi journée environ. La majeur parties du temps restant depuis jeudi dernier, j'ai donc travaillé sur le undo/redo pour les gradients. Depuis le début de mon travail sur scribus, c'est le patch qui m'a demandé le plus de temps et qui était aussi le plus pénible à faire. La pénibilité viens du fait qu'il m'a demandé de mettre en place de nombreux undo/redo élémentaire donc pour une seul variables. Cela n'a rien de bien compliqué mais il faut créer des getters/setters, une fonction de undo/redo et faire en sorte que celui ci soit appelé et que le changement de variables se fasse bien avec les setters. Vous me direz, c'est un peu ce que je fais déjà depuis le début. Mais cette fois, j'ai du le faire de cette façon pour 42 variables différentes juste pour les gradients. Impossible de faire cela automatiquement puisque les méthodes appelées change de nom entre les fonction vu que la variables change et que le type change. Il est peut être possible de faire cela avec des commande préprocesseur mais comme je l'ai dis dans un autre article, je trouve cela pas très pratique étant donné que le code de scribus est très peut commenté, j'aime bien pouvoir trouver les fonctions à l'aide d'un grep -nri . Heureusement, il n'y avait pas que cela a faire. Même si c'est pénible, ce n'est pas ce qui m'a pris tout se temps. Dans les gradients, certains ne fonctionnent qu'en interaction avec le canvas (zone d'affichage). Il m'a donc fallut ajouter un undo pour les actions de dragage de points. Ici aussi, un très grand nombre de variables sont en jeu et la plupart sont des variables de meshpoints. J'ai donc dans un premier temps ajouter les meshpoint dans les undoObject pour pouvoir faire une restauration directement sur ce genre d'objet. Malheureusement, je me suis rendu compte qu'en procédant de cette façon, le undo est enregistré à chaque déplacement d'un point, ou plutôt pendant son déplacement. Donc si on fait traversé tout l'écran au point, on remplie entièrement la pile de undo. Ce n'est donc pas envisageable. Le problème est donc : comment regrouper toutes ces actions en une seul. J'ai pensé à créer un UndoTransaction (qui est l'objet utilisé pour regroupé des actions dans un cas normal) déclaré en global ou en attribue du canvas. Ce n'est pas très jolie. Finalement, j'ai choisie d'enregistré la valeur du meshPoint sur lequel on viens de cliquer et lorsque l'on relâche le clic, on enregistre le points de départ et le points d'arrivé pour crée le undo. Il se trouve que c'est plutôt efficace même si du coup, les modifications pour ajouter des undo sur les meshpoints se trouve inutile. J'ai donc supprimé ces modifications. Il existe un deuxième type de canvas du même genre pour les gradients que j'ai donc traité exactement de la même façon. Pour que tout fonctionne correctement, il faut aussi ne pas prendre en compte cette action si aucun mouvement n'a lieux. Car pour changer la couleur du points par exemple, il faut le sélectionner. Il serait dommage de créer une action supplémentaire inutile. Un autre problème : le changement de mode du canvas. Lorsque le passait sur les gradient mesh. Il y a un changement de mode qui ne reviens pas avec le undo. Scribus finis donc par buguer. J'ai essayé toute sorte de chose sans succès. Finalement, ce n'est pas très beau mais j'ai ajouter un undo au changement de mode mais seulement pour certains mode. Après cela il faut passé par une petite étape de débogage. On fait pas autant de copié coller sans se trompé dans les modifications à apporter. Souvent les erreurs sont minim donc encore plus dure à trouver. Ouf, me voila content tout semble fonctionner correctement. Pour l'instant mes tests se sont porté sur l'intérieur des polygones. Pour les bordures, je me suis donc rendu compte qu'il manquait une fonction de mise à jour du panel. Ce qui empêchait de faire un undo/redo correct et en réalité, cela apportait aussi des erreur lors des changements de sélection. j'ai donc ajouté cette fonction et ajouter les undo/redo pour ces gradients de la même façon que ce que j'avais fait précédemment. Ouf. Finis... C'est ce que je me suis dis. Malheureusement, il reste un petit onglets permettant de bouger le vecteur de gradients. J'ai donc commencer par le undo/redo qui suivait l’apparition de ce panneau. Encore une fois, cela demande un grand nombre de setter/getter mais finalement ça se fait. J'ai donc pris toutes les fonctions de ce panneau un par un pour les ajouter. Ensuite, le canvas encore une fois. J'ai encore procédé comme précédemment. La différence étant : la dernier fois je pouvais sauvegarder un meshpoint. Cette fois, je dois sauvegarder individuellement une trentaine de variables pour les prendre en compte dans un undo final. Ce n'est vraiment pas jolie mais je ne vois pas comment traiter cela autrement. Avec une autre idée, je l'aurai sûrement appliqué également pour les premiers canvas. Pfiou. Voila que les gradients sont finis!!! Et j'en suis bien content. C'est le plus gros patch que j'ai fais en nombre de ligne ... Malheureusement, je sais qu'il me reste les gradients se trouvant dans l’onglet transparency du PP... Travail de demain??? Cette après midi, j'ai donc changé un peu et travaillé sur le bug reporté par cezaryece : correction du undo pour la suppression de lettre. Et oui, quand on supprime des lettres et qu'on les fait revenir, le style de ces lettres est perdu. Pour corriger cela, il faut donc enregistrer le style courant du caractère et regrouper tout cela en une seul action. Jusque là, pas de souci. Le plus gros problème est pour regrouper les actions en une seul. Puisque je crée une action a chaque fois que le style change, il faut que les nouvelles actions puisse s'ajouter à ce undotransaction. J'ai galéré un moment pour créer une action pour une chaîne consécutive avec un même style. Après avoir galéré un moment, je me suis rendu compte que c'était impossible car on ne sait jamais si ce qu'on vient de supprimé se trouve avant la chaîne ou après la chaîne. Mais après réflexion, cela importe peu. Seul l'état courant compte et peut importe ce qui est déjà supprimé. Je me content donc de regarder si le dernier mot supprimé est du même style. Si c'est ça, j'ajoute la lettre, sinon je crée une action. Et maintenant tout fonctionne. Il ne reste plus qu'a commiter tout ça maintenant :-) Bonne nuit à tous.

Voila beaucoup de travail en deux jours !! Je vais donc essayer de ne pas trop m'éterniser. Pour les…

[ Translate ]

Voila beaucoup de travail en deux jours!! Je vais donc essayer de ne pas trop m'éterniser. Pour les petits undo/redo, je me suis mis au changement de la fonction d'affichage : Le changement de résolution. C'est un undo tout ce qu'il y a de plus classique mais j'ai perdu un peu de temps dessus à cause d'une mauvaise écriture de l'identifiant de l'action. C'est vraiment bête mais au moins je ferai plus attention les prochaines fois. Ensuite, le undo/redo de l'affichage des images. On peut en effet choisir d'avoir seulement le nom de l'image en aperçu et non pas l'image elle même. Cette fois ici, rien de bien compliqué, ce n'est qu'une variable à changer. Un petit peu différent ensuite, lorsque l'on utilisait la symétrie pour une image, celle-ci était enregistrée comme deux actions. J'ai donc regroupé ces taches. En regardant de plus près, j'ai également supprimé une boucle for. En effet, une boucle for (uint a = 0; a < docSelectionCount; ++a) avec docSelectionCount!=0 et docSelectionCount < 2, la boucle n'est pas vraiment utile. Le group/Ungroup undo/redo ... Je pense que cette action mériterait un article a elle toute seul. Le fonctionnement de base que j'ai utilisé est le même que celui qui était précédemment : pour le undo de groupé, on sélectionne l'item de sortie et on ungroup, pour le redo, on sélectionne tous les items et on group. Ce qui est bien dans la nouvelle façon de faire c'est que c'est symétrique pour le undo/redo de group et de ungroup donc une seul fonction de restauration est nécessaire. Le premier problème que j'ai eu est que le undo/redo fonctionne pour le grouping, mais le undo/redo/undo ne fonctionne plus. En effet, le polygone résultant du groupement est un nouveau à chaque fois, donc on a perdu son adresse/Id entre temps. Ici, je suis donc dans le même cas que le undo/redo implémenté avant. Pour corriger ce problème, j'ai donc changé l'adresse de ce polygone au fur et à mesure de sa création et de sa suppression. Maintenant, on peut donc faire autant de undo/redo que l'on veut, il n'y a pas de problème. En jouant avec, j'ai finalement trouvé un autre bug : Si on group, puis ungroup et qu'on fait fait deux undo, le deuxième ne fonctionne plus. J'ai mis un moment à comprendre l'erreur mais pour ça, il faut comprendre un peu le fonctionnement du undo dans Scribus. En fait, lors d'un undo/redo, on sauvegarde l'objet sur lequel on exécute l'action et à côté, tout le reste dont on a besoin. Si l'on dit que l'action s'effectue sur un objet et que cet objet est supprimé, on a une fonction permettant de remplacer dans toutes les actions de undo, l'ancien objet par le nouveau. Jusque là tout fonctionne parfaitement. Cependant, si l'objet supprimé n'est pas l'objet sur lequel on a effectué une action mais est tout de même un objet dont on a besoin pour le undo, comment faire? Pour prendre un exemple concret, lorsque l'on groupe 3 polygones, il faut sauvegarder toutes ces informations. Lequel des 3 est le polygone sur lequel on a effectué une action? Vous voyez donc qu'il faut forcément sauvegarder un objet sans que celui ci soit l'objet sur lequel on a appliqué l'action. Le problème est donc : Comment remplacer l'adresse de cette objet lors d'une suppression puis d'un retour? Pour l'instant, je ne vois que deux solutions : On peut faire une fonction qui remplace également l'objet dans les objet nécessaires au undo. Cette idée me semble correct, mais un peu lourde parce que pour un PageItem* par exemple (suppression d'une frame), on pourrait la remplacer, mais dans le cas d'une liste de PageItem? Ou de pair de PageItem? Il faudrait détecté si l'objet que l'on a peut contenir des PageItem* pour pouvoir les parcourir en profondeur. La deuxième solution serait de revoir un peu plus le fonctionnement du undo redo et des objets en général dans scribus. Il faudrait pour cela un numéro unique par objet. Ainsi, lors d'un undo/redo, on sauvegarde ce numéro plutôt que l'objet (il faut donc des fonctions permettant de trouver l'objet a partir de ce numéro également). Ainsi, lorsque l'on recrée un objet, il faut pouvoir lui attribué le numéro de l'objet précédemment supprimé. Il est impossible de faire cela avec un pointeur, même si ce numéro est unique, mais avec un Id, ça serait faisable. Après, il est peut être possible de combiner les deux : mettre un Id que pour les objets supprimés/recréés et cette Id à pour valeur l'adresse de la première version de l'objet? Quoi qu'il en soit, je préfère attendre que tous les undos fait jusqu’à présent soient regroupé avant de me lancer là dedans. À réfléchir ....

Pour revenir au group/ungroup, j'en ai aussi profité pour faire un peu de nettoyage dans la fonction. Certaines boucles qui me semblaient inutiles ont donc disparu.

Autre correction de undo/redo, le changement de forme disponible dans le panneau de propriété dans l'onglet forme. Lorsqu'on l'utilisait et qu'on faisait un undo, tout n'était pas comme avant et l'arrondissement d'angle n'était jamais disponible. Voila qui est corrigé. Pour finir avec les options, j'ai ajouté également un undo à l'arrondissement d'angle. Encore une fois, ce n'était qu'un changement de variable et une séléction à changer.

Une autre grosse tache à été de mettre tous ces patchs dans le trunk. Oui, voila qui est fait, deux de mes branches ont été pushé. Ça fait plaisir que ça puisse être utilisé et ça me permet d'avoir des retours. D'ailleurs, les bugs n'ont pas tardé à ressortir. Pour le undo de la création de gabarit par exemple, j'avais pas testé le undo en ayant quitté le mode gabarit. Ça a donc planté. En fait, je pensais avoir essayé mais cliquer sur la croix rouge de la fenêtre gabarit ferme la fenêtre sans quitter le mode pour autant. Plutot êtrange comme comportement. Enfin, celui là a vite été corrigé. Un autre : Pour le text undo, si on ajoute un style sur deux styles différents et qu'on le défait, seul un des styles de départ reste ( et c'est celui qui est appliqué). J'ai donc fait en sorte qu'une action soit créée à chaque fois que l'on change de style et j'ai regroupé le tout dans une seule action. Maintenant, le plus dur : faire en sorte que moins d'actions soient créées. J'avais mis cela de coté parce que c'est un même undo qui traite le changement de style, l'augmentation de taille et tout ce qui va avec. Mais en m'inspirant du travail de cezaryece, j'ai finalement ajouté une variable à la fonction contenant le undo. Ainsi, lorsque j'appelle cette fonction qui applique le nouveau style, il y a un nouvel argument qui explique quelle est l'action qui est effectuée. En utilisant cela, je peux donc enregistrer dans mes événements un nom précis ainsi, en regardant le vrai nom de l'action précédente, je sais si je dois recréer une action ou compléter la précédente. Le problème que j'ai eu est que ma fonction qui me retourne un pointeur vers le dernier état du undo (donc la tache sur le haut de la pile), me renvoyait une valeur incorrecte. Enfin c'est ce qu'il m'a semblé puisqu'en réalité cette valeur était correcte mais c'est la valeur de la "boite" regroupant mes actions. Et oui, puisque je dois créer plusieurs actions, j'ai aussi besoin d'une boite pour les contenir. Finalement, j'ai donc réussis en détectant cette boite et en allant chercher mes différents états directement dans celle-ci. C'est un peu lourd à faire mais ça fonctionne très bien. Il a donc fallut changer également l'attribution de ce nom exact de la tache lors du clic de souris ou lorsqu’on presse une flèche pour que ce soit correct. Il reste plus qu'à commiter ces patches et tout sera bien :-)

Quand on commence avec git, il y a toujours des choses qui paraissent un peu bizarre ou qui ne se…

[ Translate ]

Quand on commence avec git, il y a toujours des choses qui paraissent un peu bizarre ou qui ne se passent pas comme prévu. Si ça peut aider les autres, voici comment je fais pour créer un patch. Pour partir sur les mêmes bases, j'ai ajouter une adresse à mon git : trunk. Dans ce repo se trouve les mêmes fichiers que sur le svn. Cela permet d'avoir une base de référence pour le diff. Pour ajouter ce git :

git remote add trunk git@scribus.net:trunk.git

Supposons que le diff que l'on souhaite est pour la branch Layout:

git checkout layout

Pour ne pas avoir de souci, il vaut mieux que tout ce qui est fait soit déjà pusher dans le repo:

git push

puis, faire un rebase (mettre ses propres commit comme étant les derniers a avoir été ajouté) :

git pull --rebase trunk svn

si il y a des conflis, il faudra donc aller dans le document signalé pour changer les problèmes. Si vous utilisez gitk, en allant à la tête de la branch, on voit très clairement ou il y a des problèmes. Un fois ces problème réglé :

git add "mes fichiers modifiés" git rebase --continue

il peut arrivé que l'on vous dises que rien n'a été changé, ça veut souvent dire que les modifications ont déjà eu lieu dans un commit précédent, il suffit donc de faire :

git rebase --skip

Une fois que tout ceci c'est bien passé, il faut refusionner la nouvelle branch avec l'ancienne, sinon il sera impossible de pusher le changement et donc de récupérer d'autres éventuel changement. :

git merge origin Layout git push

Voila donc une belle branch avec toutes les sources dedans et les notres en haut de la pile. En plus, on est sur qu'il n'y aura pas de conflit. Maintenant, il faut regarder l'adresse (adresse1) du dernier commit de notre branch Layout (le commit de merge normalement) et l'adresse du dernier commit exécuté dans le trunk (adresse2). On peut avoir cette adresse dans gitk le champ : Id SHA1 ou dans la console directement avec git log. L'adresse est la suite du genre : 27ea33fce51cb6f7e4084746c78a2559dded4e59. Une fois ces adresse récupérés :

git diff adresse2 adresse1 > monpatch.diff

Et pour l'appliquer au svn, il suffit de se mettre dans le bon dossier et d'utiliser :

patch -p1 < monpatch.diff

Le tour est joué.

J'ai un peu de retard dans mes articles alors voici un peu de lecture. Cette fois ci, ce n'est pas…

[ Translate ]

J'ai un peu de retard dans mes articles alors voici un peu de lecture. Cette fois ci, ce n'est pas vraiment un undo/redo que j'ai fais mais plutot une options ajouter à celui ci. Pour pouvoir avoir un meilleur workflow, j'avais ajouter la resélection d'un élément lorsque celui ci est supprimé puis recrée via le undo. Cette fois ci, pour pouvoir voir au sont les changements effectué par le undo, j'ai fais en sorte de cadrer l'écran de scribus sur le changement. Le problème est surtout que l'on ne peut pas généralisé une tel chose. En effet, lorsque l'on crée un calque par exemple, sur quoi doit on déplacer le cadre? Il n'y a pas de page ou de frame spécifique. J'ai donc fait en sorte de centrer correctement l'écran dans la majeur partie des cas mais il faudra tout de même faire attention lors de chaque undo pour que le positionnement corresponde. J'ai également corrigé un crash de scribus dans le fonctionnement même du undo. J'avais remarqué ce bug depuis un moment mais impossible de le corrigé. En effet, si on crée un polygone par exemple puis que l'on appuie sur ctrl-z, celui ci disparaît, on a donc le document de départ. Il est donc normal que lorsque l'on presse de nouveau ctrl-z, rien ne se passe. Cependant, si on va dans édition, le undo est encore cliquable et si l'on clique dessus, scribus plante en nous disant gentiment : scribus crashed due to signal#11 ce qui se traduit par "Haaaaaaaaaaa qu'est ce que tu fais? je coupe tout!!". Enfin bref, pas super. En triturant le code, j'ai a un endroit une variable, si je la met à false, le undo n'est jamais accepté, si je la met à true puis a false en cliquant sur un bouton, le undo reste accessible. Impossible donc de le désactivé. Puisque je n'ai pas réussis à réparer cela, je me suis contenté de faire en sorte que rien ne se produise lors d'un tel clic. C'est toujours mieux qu'un crash. Une fois ceci fait, je me suis remis à un vrai undo : le coller. Et oui, le copier dans le text n'est pas pris en compte, ou plutôt ne l'était pas. J'ai donc corrigé cela et j'en ai profiter pour prendre également en compte l'ajout des inline frame. Ces ajouts se sont donc passés sans aucun souci. Ce matin, je me suis donc mis à la création d'un diff correct pour pouvoir appliquer une de mes branch (Layout) dans le code de scribus. Ça permettra ainsi de voir si tout fonctionne correctement. Pour ne pas tout mélanger, je vais donc expliquer tout cela dans mon prochain article.

Using Python and Cheetah for generating code from RelaxNG

And here is part 2! After my disappointment with XQuery, I looked at a template engine for Python. While Python can do some basic templating itself, Cheetah is much more powerful. So here’s an example for a Cheetah template: // Generated file, do not edit! \#ifndef ${c.name.upper()}_H \#define ${c.name.upper()}_H class ${c.name} { // properties #for […]

C'est parti pour les nouvelles. Je n'ai pas fait d'article non pas parce que j'ai rien fais mais…

[ Translate ]

C'est parti pour les nouvelles. Je n'ai pas fait d'article non pas parce que j'ai rien fais mais surtout par flemme. Ça prend toujours un peu de temps à écrire quand même :-). Comme précédemment, j'ai continué à travailler mercredi sur le texte undo. Après avoir traité le style de caractère, je me suis mis au style de paragraphe (en toute logique). Il m'a fallut un peu de temps pour trouver ou est ce qu'il fallait ajouter le code mais et surtout trouver tous les endroits ou il fallait le prendre en compte en fonction de ce qui est sélectionner (du texte ou une frame entiére). J'en ai donc profiter pour faire mieux fonctionner le undo/redo pour le style de caractére. Encore une fois, ça a mis en place de nombreux undo qui n'était pas visé à ce moment là. Ce qui m'a permit finalement d'avancer très vite dans la mise en place du undo/redo pour le text. Après avoir travailler sur l'ajout de style, il a donc fallut se mettre à la suppression de style. Il est assez perturbant de devoir traiter des fonctions qui font presque la même chose. Sans toutefois faire exactement pareil. Mais j'ai un peu de mal à voir la différentes puisque ce sont des fonctions non déclarer directement mais définie par des commande préprocesseur. Certe, ça permet d'avoir un code très court mais je trouve que ça nuis réellement à la lisibilité du code. Après c'est une question de point de vu. L'étape suivant a été pour les colonnes et les distances (entre les colonnes ou entre le texte et le bord de la frame). Globalement, ce n'était que des changement de variables donc dans ces cas, c'est le undo le plus basique qu'il soit. Pas beaucoup de difficulté. J'en ai aussi profiter pour supprimer une partie de code (il était exécuté ici, puis juste au dessous à travers une autre fonction). Et pour finir, le undo sur la longeur d'une tabulation. Il m'a pour cela suffit de changer la fonction utilisé pour en appeler une qui fait la même chose mais qui possède le undo en plus. Vu comme cela, on a l'impression qu'il reste plein de choses à faire mais j'ai testé les autres options que l'on peut utiliser sur les frames de textes (pendant une bonne heure pour tout essayer) et tous sont traité par le undo. C'est pas génial? :-)

Maintenant que le text undo est finis, je me suis mis à parcourir le bug tracker pour voir tous les bugs qui sont associé à mon sujet. C'est assez marrant de voir que certains sont donc maintenant résolu (dans ma version au moins). Le premier était une demande pour un undo sur le texte. Voilà qui est finit. La deuxième demande que j'ai vu était lors de la copy d'une page. Certains objet se retrouvaient dupliquer lors d'un undo/redo. En constatant cela, j'ai donc remarquer que ça venait d'une action de undo/redo ajouter à la pile de undo alors qu'elle ne le devrait pas. J'ai donc ajouter deux lignes pour indiquer qu'il ne fallait pas se souvenir des actions undo/redo dans une certaines partie du programme. Tout fonctionne correctement mais comme j'utilisais le widget : plan du document, pour voir si il y avait une duplication, j'ai remarqué qu'en ajoutant ces lignes, la mise à jour du widget ne se faisait plus lors du redo. Zut !!. J'ai beau avoir parcourue une bonne partie des fonction causant ce problème, je n'ai pas trouvé celle qui faisait la mise à jour nécessaire. J'ai donc opté pour appelé directement la fonction de mise à jour du widget en question. Il ne semble donc plus y avoir de problème pour moi en tout cas. Entre temps, on m'a indiqué sur IRC, un bug : Il n'y a pas d'avertissement lors de la suppression d'une page ou d'un gabarie. C'est donc un problème puisque le undo n'était apparemment pas disponible. Vu que tous les problèmes de création et de suppression sont maintenant réparé, c'est un bug que l'on peu oublier. Enfin, le dernier bug que j'ai traité est un undo inexistant : placer au dessous, placer au dessous, placer en haut ... Outre le fait que la fonction me semble très compliqué pour pas grand chose (il me semble même avoir vu des boucles for sur un list ou l'on a mis un seul élément dans tous les cas ...) J'ai finalement ajouter cette fonctionnalité en utilisant seulement la sélection. Toutes ces fonctions ayant le même fonctionnement, mettre en place une fonction c'est comme toutes les mettre en place. Aujourd'hui, je vais donc pouvoir continuer à parcourir le bug tracker pour ajouter toutes les fonctionnalités qui semble être les plus importantes pour les utilisateurs.

Voila une autre journée de travail passée. J'ai donc continué à travailler sur le text undo. C'est…

[ Translate ]

Voila une autre journée de travail passée. J'ai donc continué à travailler sur le text undo. C'est donc composé de plein de petit undo à ajouter. J'ai commencé avec le remplacement de texte. Ça se résume en le regroupement d'une action de suppression puis une action d'ajout. Il suffisait donc de trouver ou ajouter ces quelques lignes. J'ai ensuite continué avec le undo/redo des textes d'exemple (lorem ipsum). Le principe est exactement le même que pour l'ajout de texte puisque le undo se fait bien sur le texte et non sur la génération d'un texte aléatoire. Encore une fois, il a suffit de trouver où est ce qu'il fallait ajouter cette action. Après, je me suis attaqué aux caractères spéciaux comme les tabulations ou même les guillemets et des choses comme ça. La prise en compte était encore à un autre endroit mais toujours le même principe. Enfin, je me suis mis à l'import de texte ou l'ajout de texte. Cette partie est plutôt compliquée car on passe par de multiples objets différents et par des plugins pour arriver finalement au même point que les autres : l'insertion de texte encore une fois. Pour l'import de texte, il fallait en plus prendre en compte la suppression du texte précédent. Malheureusement j'ai commencé en regardant la mauvaise action ce qui m'a fait perdre un peu de temps. J'ai d'ailleurs trouvé une fonction qui ne sert à rien du moins en apparence. C'est assez étrange quand on tombe sur des choses comme ça. Ensuite, l'effacement de frame puisqu'il existe un bouton pour cela. Ce n'est pas bien différent de la suppression de texte. Et pour finir, j'ai commencé avec les styles de caractère. Ici, ça c'est un peu corsé. Pour commencer facilement, j'ai regardé pour le changement de taille de police. Il est donc normal de tomber sur une fonction setfontsize(). J'ai donc pensé que la gestion du undo devrait se trouver dans cette fonction malheureusement, même grep ne me trouvait pas cette fonction. C'est plutôt déroutant au début. J'ai finis par comprendre que la classe utilisant cette fonction est créée en grande partie par des commandes préprocesseur pour automatiser la déclaration de fonction. Finalement, ce n'est donc pas ici qu'il faut ajouter le undo. Finalement, j'ai ajouté la modification de style dans une fonction de scribusdoc.cpp . En ajoutant cela, de très nombreuses fonctionnalités de undo/redo pour le texte ont été disponibles. Il est dommage que je ne puisse pas choisir le nom du undo de cette façon là. Du coup le nom est un peu général mais au moins de nombreux undo/redo sont disponibles. Je regarderai peut-être par la suite si on peut changer le nom mais ça reste un détail à mon avis. Finalement là ou je pensais passer au moins deux semaines, je devrais pouvoir avancer suffisamment déjà d'ici la fin de la semaine. On verra donc par la suite ce que le code me réserve ...

1) What i have learnt

    a) RelaxNG compact syntax.
    b) Basics of python and cheetah templating.
    c) XML save already implemented in scribus.
    d) Specific Qt libraries.   
   
2) The present situation

    a) Code generation is in place - C++ code that compiles and works.
    b) Implemented saveasxml option - generates xml for the document, for testing.
    c) Figured out collections and subclasses.
    d) can save basic xml
       
        .) Document information, margins, bleeds.
        .) Empty Pages and Master Pages elements.
        .) PageItems and object attributes.
      
       Generated xml matches with the sla format.

3) Difficulties

    a) Had to change the Constructors of existing classes, so as to work along with the new code.
    b) Lots of time spent on Debugging ( but its always this way with code ).
   

Le travail d'aujourd'hui s'est séparé en deux phases. Ce matin, j'ai essayé tant bien que mal de…

[ Translate ]

Le travail d'aujourd'hui s'est séparé en deux phases. Ce matin, j'ai essayé tant bien que mal de maitriser git. J'ai donc voulu "rebase" mes différentes branches. Ça à déjà demandé un peu de temps puis j'ai voulu "pusher" ces branches mais là, git n'a rien voulu savoir. Impossible de le faire. Je suis donc passé à la suite et malex m'a débloqué ce soir (dans la journée pour lui) en me permettant de pusher quand même mes branches. J'ai l'impression que c'est un peu le bazar dans le repo git mais ça devrai allé par la suite... Le deuxième travail que j'ai fais aujourd'hui a été de commencer le undo pour le texte. Je pense avoir bien commencé puisque la suppression et l'ajout de texte sont maintenant pris en compte. Le plus dur est bien sur la premiére fonctionnalité puisque je ne savais pas exactement de ou partir ni comment partir. Pour la suppression, j'ai commencé avec la suppression du texte séléctionné. Naïvement, je sauvegarde le texte et la position ainsi je sais quoi ajouter et quoi enlevé ainsi que ou se trouve cette information. Jusque là tout semblait bien. Cependant, la suppression en appuyant sur delete par exemple est prise en compte comme la selection de la lettre suivante puis sa suppression. Donc en faisant comme cela, si on laisse appuyé sur del, on ajoute une action par lettre. Ça remplie vite la pile de undo et ça ralentie beaucoup la suppression. J'ai donc suivie les conseils de cezariece qui sont de traité cela en gardant en mémoire l'action précédente, si c'est la même, on se contente d'éditer cette action, sinon on en crée une nouvelle. Pour cela, j'ai donc commencé par créer une fonction qui me permet de récupérer l'action précédente. Pour savoir si cette action est exactement la même que celle que je vais faire, j'ai ajouter un couple (ETEA, val) avec la méthode set qui sert à ajouter des information au undo que l'on enregistre. J'ai fais cela plutot que d'ajouter une variable à undomanager car cela évite d'ajouter de partout des initialisations ou remises à zero de cette variables. Une autre chose qu'il m'a fallut prendre en compte, pour l'ajout comme pour la suppression : Si on supprime une lettre, puis qu'on de déplace d'une case avant et qu'on en supprime une autre. On a bien deux fois une suppression de caractére. Cependant, on ne peut pas avoir qu'une seul action car on ne peut pas définir cette état avec une seul position. Il faut donc dans ce cas remettre ETEA à zero pour qu'une nouvelle action soit créée. Ça fait toujours moins de remise à zero qu'avec une variable ou il aurait fallut remettre a zéro dans chaque undo existant. Maintenant la suite. Ce n'est pas les actions sur le text qui manquent, je ne risque pas de m'ennuyer.

Cette fois, je vais faire un résumé de mes deux jours de travail ( oui c'est le week-end mais quand…

[ Translate ]

Cette fois, je vais faire un résumé de mes deux jours de travail ( oui c'est le week-end mais quand on a du retard, il faut savoir le rattrapper). Ce travail a principalement consisté à finir de mettre en place le undo pour la création de gabarit. Vendredi soir, j'avais de disponible une version que je pensais correcte dans la théorie mais en pratique ça ne fonctionnait pas correctement. J'ai donc passé mon samedi matin a torturé dans tous les sens le code que j'avais fait, à regarder l'id de tous mes éléments pour voir si tout correspondait mais tout semblait correct. En désespoir, j'ai donc demandé sur IRC si quelqu'un avait une idée du problème. MrB et vox_ m'ont donc donné des pistes pour ma recherche. Tout d'abord, en ouvrant le panneau "plan du document", j'ai remarqué que le polygone que je testais existait bien. Donc le undo fonctionne mais l'affichage se fait mal. Ainsi, contrairement au problème que j'avais eu pour la création d'une page, si je n'avais rien cela ne venait vraiment pas des ID. De plus, quand je ferme le fichier puis l'ouvre de nouveau, le polygone apparaît correctement. Je me suis donc lancé dans la recherche d'un problème d'affichage. C'est donc dans une fonction que je n'ai pas encore touché qu'il y a un problème. En regardant dans la fonction de restauration d'un item, je finis par faire apparaître correctement le polygone en utilisant : adjustItemSize(). Cette fois que tout fonctionne, j'explique ma solution à MrB et _vox qui me disent que cette fonction n'est déjà pas super propre. Il vaut mieux éviter de l'utiliser. (Comme dit _vox, c'est un peu un sortilège voodoo, on le lance sans trop savoir mais ça fonctionne). En creusant un peu, j'ai fini par trouver que c'est un problème de OwnPage. C'était là la première idée de MrB mais je ne savais pas du tout quelle valeur mettre ou quelle fonction appeler et les tests que j'ai fait était resté infructueux. Mais cette fois, j'ai exactement la valeur qu'il faut et tout fonctionne correctement. Voilà donc la fin de l'épisode : undo/redo pour la création de gabarit. Il ne me reste plus qu'à pusher tout cela dans mon repo et c'est partit comme prévu pour le text undo.

Making a good start is half task done

The Project Manager


This project upon completion will totally change how big books are handled in scribus.


When I chose this project for gsoc, it seemed to me that it would be easy when i saw its description on scribus-gsoc-ideas page. But during a discussion on irc, malex told me that this project cant be fully completed by 2 of us even in a year. I was still not sure. But I now know that the scope of this project is too big and proper planning is required to make it successful. 


There were a lot of things to be done before I could actually start coding. Presently, PM(project manager) is going to be coded as a new app which will be launched when a book has to be handled.
A new file format sla2(project description file) is to be made using xml to store shared attributes.  Before that invercity mailed me to discuss use cases, so i looked up use cases in some books (never heard of it before). I saw scribus  user-documentation to see how scribus works in detail. I learnt how to make gui using qt-designer by making ui files to make some base gui to code upon. After that JLuc told me to make some api and basic function names to be used in PM which i did. I also made project description file (data types that should be added to sla2 ) after MrB gave me some hints. I tried to add new files to scribus repo but compilation error occured and i tried solving the problem myself and by asking at qt and c++ irc nodes but with  little help. I am trying to learn basic cmake.Before that I learnt git and added some testing branches to the repo. I learnt how xml is parsed presently in scribus and which classes and functions are there for importing and parsing masterpages and styles.
Since there are a lot of new things to be learnt, it is difficult to start coding right off. Though I coded some sample load/save code in testing branches at git.


Problems that occurred.


When adding a new file to scribus repo, scribus does not compile. Throws an error ---> undefined reference to newClass>function. Maybe that file needs to be added to sources list somewhere.


Things I did

1.Project Definition file
2.API
3.Learnt XML
4.Learnt git.
5.Learnt qt designing using qt designer
6.Browsed scribus code for
a)existing import functions for masterdoc and styles
b)how present sla is parsed
7.Making primitive use cases.
8.Examining the present sla to see how the xml format is designed in scribus and how are attributes stored presently.
9.Learnt making a new app in qt.
10.Learning cmake.
11.Made some primitive code for saving/loading xml.

Hier, j'ai passé la journée à travailler sur la création_de_page. En réalité, j'ai voulu commencer…

[ Translate ]

Hier, j'ai passé la journée à travailler sur la #créationdepage. En réalité, j'ai voulu commencer avec la création de gabarit. Il est assez perturbant de remarquer que la suppression est très bien prise en compte par le #undo/redo mais pas la création. En cherchant un peu, j'ai compris que la suppression est prise en compte car elle peut être traitée comme la suppression d'une simple page (ou le undo/redo existe déjà) alors que la création est un peu différente et rien n'existe à ce niveau là. J'ai d'abord cherché pendant une bonne partie de la matinée s'il n'était pas possible de changer la façon dont est créée une page pour l'adapter au gabarit. Finalement, ça m'avait l'air plus compliqué que de repartir de zéro. Cependant, je me retrouve une fois de plus confronté au problème de page que j'ai expliqué hier. C'est à dire, si on crée une page/gabarit, qu'on ajoute quelque chose puis que l'on défait les deux actions et les refait, la deuxième n'est plus pris en compte. Voyant à quel point ceci est important, je suis donc revenu sur le problème d'hier pour ensuite l'appliquer au cas des gabarits. Pour les simples pages, il m'a donc fallut revenir dans les fonctions gérant le undo/redo pour réparer ce problème. En gros, lorsque l'on crée le polygone, puis le défait, on enregistre que celui ci était sur telle page donc on enregistre aussi la page dans les actions. Ensuite, on supprime cette page. Pour que cela fonctionne encore, on crée un faux objet pour remplacer la page et on enregistre un id de cet objet pour pouvoir le retrouver. Ensuite, on remplace dans la liste des undo, la page par le nouvel objet à chaque fois qu'elle apparaît et lors du redo, on remplace de nouveau le faux objet par la nouvelle page créée. Plutôt astucieux mais apparemment, tous les objets n'étaient pas pris en compte. La liste des redo par exemple n'était pas affectée. Maintenant, le undo/redo pour la création d'une page est totalement opérationnel et donc l'import de page également. Je voulais attendre d'avoir fait de même avec la #créationdegabarit, malheureusement, j'ai pour l'instant des erreurs inexpliquées. Je vais donc travailler dessus aujourd'hui en espérant que tout soit résolu très bientôt. Bonne journée :-)

Depuis ma reprise, j'ai refait une partie du travail perdu ce week-end. j'ai donc ajouté les trois…

[ Translate ]

Depuis ma reprise, j'ai refait une partie du travail perdu ce week-end. j'ai donc ajouté les trois #undo/redo sur les options. C'est assez surprenant de remarquer que ça avance très vite lorsque tout se passe tel qu'on le veut. Il m'a ici suffit de localiser où se trouvait la fonction gérant ces fonctionnalités, d'ajouter un groupement de l'action dans le cas d'une sélection multiple puis d'ajouter la valeur de l'option à une nouvelle tache undo/redo. Pour les trois options tout s'est donc bien déroulé. Pour la 4ème action, il semblerait que le bug n'existe plus puisque nous n'arrivons pas à reproduire le problème. Il a donc été mis de côté. Une fois ces taches faites, je me suis remis sur le undo que j'avais commencé avant la panne de mon ordinateur. L'#import de page. Il apparaît que le undo était en fait terminé. Ce qui n'est pas plus mal. Je suis en revanche tombé sur un problème de undo pour la création d'une page. Ce n'est donc pas directement lié à la liste de délivrables qui me sont attribués mais vu que je travaille sur le undo, ça serait vraiment super si on pouvait avoir un undo 100% fonctionnel à la fin de l'été. Sinon, j'aurais encore mes week-ends pour travailler dessus ^^. Le problème est lorsque l'on crée une page, puis un polygone, que l'on revient sur ces deux actions puis que l'on fait un redo sur ces deux actions, la deuxième action n'est pas prise en compte pour le redo. J'ai d'abord supposé que le problème venait de la création de la page. En effet, un polygone est lié à la page à laquelle il appartient. Ainsi lorsqu'elle est supprimée, c'est une autre qui est créée à la place lors du redo. Mais après quelques recherches, il se trouve que ce problème est pourtant traité. J'ai donc finis par remarquer que la fonction restore() qui est normalement appelée lors d'un undo ne l'est pas dans ce cas là. Je n'ai absolument aucune idée du pourquoi et il faudra donc regarder de plus près l'intérieur du fonctionnement du undo pour comprendre le problème. Puisque je ne suis pas en avance dans ma réalisation, je vais pour l'instant le noter de côté, réaliser les autres taches qui me sont directement associé et j'espère pouvoir corriger cela sur le temps qu'il pourrait me rester à la fin des GSoC. C'est partit maintenant pour la création de master page puis ce sera le tour du texte.

Pendant l'indisponibilité de mon pc, je n'ai bien sur pas avancé autant que je l'aurais voulu.…

[ Translate ]

Pendant l'indisponibilité de mon pc, je n'ai bien sur pas avancé autant que je l'aurais voulu. Cependant, j'en ai profité pour faire une liste des #undo/redo inexistant ou fonctionnant mal. J'ai également réalisé un petit tutorial pour expliquer comment réaliser un undo/redo pour Scribus ci dessous. N'hésitez donc pas à aider à son développement :-)

Qu'est ce qu'un undo/redo?

Comme leurs noms l'indiquent, un undo permet de revenir en arrière sur une action et le redo permet de refaire une action annulée précédement.

Comment fonctionne un undo/redo?

Lorsque l'on effectue une action, notre programme mémorise les informations nécessaires pour défaire et refaire une telle action. Ces informations sont mises dans une pile ainsi, lorsque l'on appuie sur CTRL + Z, la dernière action est dépilée, les informations enregistrées permettent de supprimer la dernière action et à la place cette action est ajoutée à la pile des redo. Le fonctionnement du redo est identique à celui du undo.

Comment est-ce mis en place à travers Scribus?

Bien sur, tout le système de gestion des undo/redo existe déjà. Pour mettre en place une telle action, la seule chose à faire est de dire quelles sont les informations dont on a besoin dans notre pile pour pouvoir revenir en arrière et effectuer de nouveau cette action. Puis il faut écrire la fonction appellée pour effectuer ces changements.

Concrètement prenons l'exemple simple du verrouillage de guide:

"void ScribusDoc::lockGuides(bool isLocked) { if (GuideLock == isLocked) return; GuideLock = isLocked; if (UndoManager::undoEnabled()) { QString name; if (isLocked) name = Um::LockGuides; else name = Um::UnlockGuides; SimpleState (star)ss = new SimpleState(name, "", Um::ILockGuides); ss->set("GUIDE_LOCK", isLocked); undoManager->action(this, ss); } }"

Toute la partie relative au undo se trouve dans la condition : undoEnabled(). En effet, on ne veut pas prendre en compte ces informations si le undo est désactivé. Il faut savoir que le undo désactivé peut l'être par le programme et non par l'utilisateur. Lorsqu'on presse CTRL + Z, le undo est désactivé par scribus tant que l'action de retour n'est pas effectuée. Sinon, en faisant appelle à une fonction déjà existante pour revenir en arrière, on enregistrerait une nouvelle action de undo alors que ce n'est pas le but ici. Bref, il faut toujours encadrer ces informations dans une condition UndoManager::undoEnabled().

Ensuite, on est ici dans un cas simple, c'est à dire un cas où les seules variables qu'on a besoin de stocker sont des int, float, boolean, ... des variables standards. Je vous parlerai des autres cas plus tard. Dans ces cas là, on peut utiliser un objet SimpleState pour stocker les informations. Ses trois parametres sont le nom (celui qui apparait à côté de undo lorsque l'on clic sur édition), sa description et une image correspondant à ce undo. Pour connaitre la liste des noms et des images déjà existants, il faut aller voir dans undomanager.cpp. On utilise ici Um:: au lieu de UndoManager:: mais les deux sont équivalents. Si vous souhaitez ajouter un nom ou une image à ceux disponibles, c'est donc dans undomanager.cpp et undomanager.h qu'il faut aller l'ajouter. Ensuite, pour ajouter une valeur à retenir, il suffit d'utiliser set() comme dans l'exemple précédent. Les arguments sont le nom que l'on donne à la variable et la valeur associée. Il faut avoir au moins une variable parmi celles entrées, qui soit unique pour savoir quelle est l'action qui est ciblée lors du undo. On trouve souvent dans le code:

"ss->set("ACTIONNAME","actionname");"

Simplement pour savoir le nom de l'action même si la valeur de la variable n'a aucune importance.

Enfin, pour que l'action soit enregistrée:

"undoManager->action(this, ss);"

la première variable doit être l'objet ciblé par le undo (pas forcément this) et le deuxième argument est l'objet contenant toutes les autres informations.

Cette fois, l'action est donc ajoutée à la pile de undo. Il faut ensuite la prendre en considération. Lorsqu'on demande un undo, la fonction appellée est la fonction restore se trouvant dans l'objet qu'on a passé en premier argument de undoManager->action(). Bien souvent la fonction restore() est déjà écrite (je n'ai pas encore eu l'occasion de voir un autre cas), en s'aidant des exemples au dessus, vous devriez avoir quelque chose du genre :

" else if (ss->contains("UNGROUP")) restoreUngrouping(ss, isUndo); " Comme je vous l'ai dit, il faut avoir une variable unique dans notre simpleState pour pouvoir detecter quelle est l'action qu'on veut traiter. Cette variable est ici "UNGROUP". Bien souvent, l'action à effectuer fait plus de deux lignes donc, pour ne pas surcharger la fonction restore(), on crée une fonction qui se charge du restore spécifique, ici restoreUngrouping().

Voici un cas simple du restore spécifique : " if (isUndo) GuideLock = !ss->getBool("GUIDELOCK"); else GuideLock = ss->getBool("GUIDELOCK"); " Pour récupérer la variable, on utilise donc get() avec comme paramètre le nom de la variable. On peut utiliser également getInt, getBool, getFloat, ... puis on effectue les actions qu'on souhaite. On peut aussi voir qu'il y a deux types d'action. Celles dans le cas où isUndo est vrai et le cas où c'est faux. Cela permet juste de différencier le comportement de undo (isUndo = true) et de redo (isUndo = false)

Vous savez maintenant faire un undo.

Comment faire lorsque l'on doit se souvenir d'un objet et pas seulement d'un int/bool/float...?

Un autre objet que simpleState existe dans un cas comme ça : ScItemState<Class>

Exemple : "ScItemState<PageItem(star)> (star)is = new ScItemState<PageItem(star)>(Um::ChangeShapeType, "", Um::IBorder);"

Il prend les mêmes arguments qu'un SimpleState mais on peut, en plus, lui donner le type d'un objet qu'on veut qu'il stocke. On ne peut donc stocker qu'un seul objet mais c'est mieux que pas du tout. Cet objet a une methode : setItem() qui permet de lui passer cet objet. On peut toujours utiliser la methode set() pour lui passer autant de int/float/string ... que l'on veut tant qu'il ne reçois qu'un objet. Pour passer cette restriction, il faudra donc utiliser des list ou des pair.

De cette façon, on peut traiter une grande partie des undo/redo.

Lorsque je fais mon action, j'ai plusieurs actions ajoutées à ma pile de undo.

En effet, si on avait une action de déplacement décomposée en un déplacement vertical et un déplacement horizontal, lorsqu'on bougerait une forme, on aurait deux actions ajoutées à notre pile de undo. Et il faut donc enlever ces actions intermédiaires une par une pour avoir un undo complet (si la liste des actions intermédiaires n'a pas dépassé la taille maximum de la pile. Dans ce cas, on ne pourra pas revenir entièrement en arrière). Deux solutions s'offrent à nous dans un cas comme celui ci: Si en effectuant tous les undo intermédiaires, on atteint bien la position de départ, on peut regrouper toutes les actions en une seule de la façon suivante: " //démarrer le regroupement UndoTransaction(star) activeTransaction = new UndoTransaction(undoManager->beginTransaction(Um::Group + "/" + Um::Selection, Um::IGroup, Um::Delete, tooltip, Um::IDelete));

//finir le regroupement if (activeTransaction) { activeTransaction->commit(); delete activeTransaction; activeTransaction = NULL; } " Tout ce qui est au milieu est regroupé en une seule action. Les arguments à entrer lors de la création d'une transaction sont : la cible de l'action (selection/page/...), l'image correspondante, le nom de l'action(celui qui apparait dans le programme), une description et l'image correspondante. L'autre possibilité, plutôt utilisé lorsque toutes les actions intermédiaires n'ont pas une action undo dédiée, c'est de supprimer de la liste toutes les actions intermédiaires en encadrant le code de:

"undoManager->setUndoEnabled(false); //mon code undoManager->setUndoEnabled(true);"

puis de créer une action à ajouter à la pile de undo qui permet de prendre en compte tous les changements liés à cette action. Il n'y a pas à se poser la question, "est ce que lors de l'appel de setUndoEnabled(false), le undo était déjà indisponible? Parce que dans ce cas, setUndoEnabled(true) le rendrait disponible alors qu'il ne l'était pas normalement...". Ceci est gérer tout seul par la fonction, il suffit de bien penser. Dés que j'utilise un setUndoEnabled(false), il faut bien utiliser setUndoEnabled(true) à la fin pour que tout soit remis dans l'ordre. En pratique, on peut utiliser les deux techniques citées précédemment de façon combinée. C'est-à-dire, si un undo est bien géré, on garde ce undo dans la liste et on ajoute seulement ceux qui sont mal gérés puis on regroupe toutes ces actions en une seule. C'est souvent le moyen que je trouve le plus efficace mais libre à vous de faire ce qui vous parrait le mieux.

Je crois avoir fait un petit tour des différents fonctionnements du undo. Le plus dur maintenant est de trouver et comprendre les fonctions dans lesquelles il faut ajouter le undo et de corriger les bugs que l'ont peut découvrir en faisant des testes tordus.

Voila un moment que je n'ai pas donné état de mon avancement. Plusieurs contretemps m'ont empêché…

[ Translate ]

Voila un moment que je n'ai pas donné état de mon avancement. Plusieurs contretemps m'ont empêché d'avancer comme je l'aurais voulu. Tout d'abord, j'étais en partiel pendant deux semaines (même si ce n'est pas le nombre d'heure de révision ou de partiels qui m'ont pris beaucoup de temps), mais surtout, le ventilateur de mon ordinateur a rendu l'âme. Ubuntu est plutôt gourmand en utilisation du processeur donc mon ordinateur surchauffait très très vite. A peine 15 minutes après son démarrage, j'étais dans l'obligation de l'éteindre sinon il s'éteignait tout seul. Ensuite, je me suis fait volé un ordinateur. Dans ces conditions, il est donc difficile d'avancer correctement. J'ai donc attendu patiemment mon retour en France pour faire une réparation. J'espère donc ne plus avoir de problème de ce genre par la suite. Au niveau de l'avancement , j'avais fait il y a un moment une toute petite modification pour que lors de la suppression d'un élément , si on effectue un undo, l'élément (ou le groupe d'élément) soit sélectionné par défaut. Cela permet d'avoir un meilleur workflow. Si on supprime sans faire exprès un élément puis qu'on le fait revenir, on peut continuer de travailler directement sur cet élément sans avoir à faire une resélection. Vu que c'est un changement mineur, je n'avais donc pas pris la peine de faire un article complet sur ce changement. Deuxième changement que j'aurais aimé finir mais j'ai malheureusement été interrompu par ce problème de ventilateur, l' #importation de page. Lors de l'importation d'une page (sans insertion), les propriétés de la page sont chargées et appliquées mais ne sont pas remises correctement lors d'un undo. J'ai donc ajouté cette propriété. Malheureusement, cette partie de #undo/redo prend place dans les plugins de chargement de fichier. Il existe en réalité un plugin par version puisque le format des fichiers a évolué. Je n'ai implémenté ce changement que pour le chargement de la version 1.5 . Peut être que je regarderai pour les autres type de fichiers si on me fait remarquer que c'est important et qu'il y a des bugs à ce niveau là ou si j'ai suffisamment de temps pour faire ça par la suite. Malheureusement, l'indisponibilité de mon pc ne m'a pas encore permis de tester si cela crée des bugs lors de l'importation d'une page d'un fichier d'une version antérieur. Même si ceci ne devrait pas avoir lieu. Lors de l'implémentation de cette fonctionnalité, j'ai donc travaillé avec un fichier test que j'avais utilisé par le passé et, surprise, je pouvais observer un autre comportement étrange : une zone de texte qui apparaît dans la liste des undo mais qui ne peut être supprimé par celui ci. Après de multiples tests, j'ai donc compris que cet élément est verrouillé. Ainsi, il ne peut être supprimé même pas par un undo. Ce genre de bug ne se voit presque pas puisque normalement le verrouillage est appliqué, alors qu'ici, le verrouillage est créé en même temps que l'élément. En gros, dans le premier cas, si on crée un élément et qu'on applique un verrouillage, lors du undo, on enlève le verrouillage puis on enlève l'élément, ainsi tout se passe bien. Alors qu'ici, l'élément est créé avec le verrouillage, cette action n'apparaît donc pas dans la liste des actions undo et n'est donc pas enlevé avant de vouloir enlevé l'élément. Vous me suivez? J'ai donc utilisé la fonction ayant déjà un undo pour appliquer le verrouillage et regrouper toutes les étapes d'import d'une page dans une seule action undo. Cela parait plus logique puisque cela ne correspond qu'à une seule action de l'utilisateur. Lors de l'arrêt de mon travail, je regardais l'importation de page avec insertion. Ce cas pose encore problème mais je n'ai donc pas encore pu le traiter. J'espère pouvoir me remettre au boulot le plus rapidement possible...

Un petit peu d'avancement. Corriger et améliorer les actions undo/redo, c'est aussi prendre en…

[ Translate ]

Un petit peu d'avancement. Corriger et améliorer les actions #undo/redo, c'est aussi prendre en compte les bug reportés à ce sujet. Ici, j'ai donc traité un bug sur des modifications d'une figure importée depuis un fichier #EPS. C'est pour le moment la correction qui m'a demandé le plus de temps pour trouver la source du problème. En effet, même après avoir localisé la fonction où avait lieu ce problème, il m'a fallu descendre dans les fonctions pour localiser précisément le bug et apporter une correction. Je n'aime pas trop toucher aux fonctions de base de Scribus. Parce qu'elles sont de base justement, elles sont utilisées un peu partout et il m'est difficile de mesurer toutes les conséquences d'un tel changement. Mais bon, il arrive comme dans ce cas que l'on ait pas le choix. Pour être plus précis sur ce bug, il est ici question d'un plateau de Go que l'on veut redimensionner. Lorsqu'on le redimensionne puis qu'on annule le #redimensionnement, seul le quadrillage n'est pas redimensionné. J'ai donc fait des tests en dessinant des "lines" et il n'y a pourtant aucun problème de ce côté là. Ce n'est que par la suite que j'ai compris que les lignes utilisées pour les cases ne sont pas des "lines" mais des "polyline". Les polylines sont les objets utilisés pour tracer quelque chose à main levée par exemple. Pourtant, en traçant quelque chose à main levée, il n'y a pas de problème non plus à moins que tous mes points soient vraiment alignés. Finalement, je trouve que le problème viens du fait que j'ai un objet de largeur nul!!! En allant plus loin, vous pouvez voir que si vous tracez un polygone et que vous alignez tous les points, vous ne pourrez pas changer la dimension de la "ligne" ainsi créée. Le problème de fond est donc d'avoir des objets dont une des dimensions est nulle. Vous remarquerez qu'en partant d'un problème de undo/redo avec un fichier EPS, on se retrouve en réalité avec un problème dans le redimensionnement de n'importe quelle figure de taille nulle. Normalement, il est impossible d'avoir un objet de taille nulle. Si vous sélectionnez un objet et que vous mettez sa taille à 0 dans le panneau de propriété, celui ci reviendra directement à 1. Donc pour avoir une figure de taille nulle, il faut aligner manuellement tous les points de la figure. Il m'a donc fallu faire un choix. Soit je corrige le bug en traitant les cas de taille nulle dans le redimensionnement, soit je remonte à la source et je fais en sorte que la taille d'une figure ne puisse pas être nulle. Malheureusement, la taille est changée manuellement (et pas seulement à partir d'un setWidth) un peu partout dans le code. Changer cela obligerait à faire d'importante modification dans tout le code sans pouvoir en mesurer toutes les conséquences. C'est pour cela que j'ai opté pour un changement seulement dans le redimensionnement. Finalement, ces quelques lignes me permettent de finir la correction des problèmes de undo/redo liés aux figures qui étaient connus. Un nouveau sujet va pouvoir être commencé!!

Code generation from RelaxNG

Anyone who has looked at a Scribus preferences file (scribus.rc) will be aware that the sheer amount of settings is daunting. There’s a C++ file named prefsstructs.h that defines on 470 lines of code 29 data structures too hold various settings. And these are just dumb structs, without any code to read/write to XML (or […]

5 jours sans nouvelles, mais je suis encore là. Bien sur, je n'ai pas que Scribus à faire ce qui…

[ Translate ]

5 jours sans nouvelles, mais je suis encore là. Bien sur, je n'ai pas que Scribus à faire ce qui explique en partie ma pause mais aussi, je me suis confronté au #textundo fait pas cezaryece que je dois _exporter entre la version 1.4 et la version 1.5. Maintenant que j'ai vu ça de plus près, ça me parait beaucoup plus dur. Je ne m'attendais pas à ce qu'il y ait autant de différences entre les deux versions. Heureusement, JGhali m'a donné une piste pour commencer, ce que je ne tarderai pas à exploiter. Pour faire une petite pause dans ce travail, je me suis donc lancé dans l'opposé du patch précédent: le undo/redo pour la dissociation de polygone. Cette fois ci, l'approche est beaucoup plus simple puisqu'il suffit de d'appliquer les méthodes déjà existantes de combinaison pour le undo et de dissociation pour le redo. En effet, il n'y a pas de problème de perte d'information. En faisant différents tests, je me suis rendu compte qu'un mauvais #undo/redo pouvait causer assez rapidement des problèmes de segfault dans scribus. Ce qui ne fait pas souvent plaisir à l'utilisateur. En effet, le undo précédent est basé sur ce qu'il doit y avoir à la fin d'une action. Or si le undo suivant ne remet pas exactement comme c'était précédemment, certaines actions réalisées dans le undo ne sont plus possible. J’espère que je ne vous ai pas perdu avec ça ^^. Revenons au undo/redo sur lequel je travaille. Seul point restant à regarder : les données nécessaires pour effectuer les actions. La première idée à été de faire comme dans le patch précédent : sauvegarder les items utilisés. En faisant de cette façon, du premier coup d’œil tout se passe plutôt bien. Je joue un peu avec pour montrer comme ça marche bien à ma copine et bam... bug. J'ai d'autres polygones qui apparaissent si je fais undo/redo/undo/redo. Après réflexion, c'est logique puisque je sauvegarde un item mais que ceux ci sont recréés à chaque fois que je fais une dissociation de polygones. Donc la référence vers l'ancien item n'est plus bonne. Finalement, j'ai pu faire fonctionner ce undo/redo en utilisant la position des polygones dans la liste d'item puisque les objets créés ou supprimés le sont toujours au même endroit de la liste. Maintenant, il va falloir se remettre au texte undo... Plus de nouvelles bientôt...

Et voila un *nouveau patch de fini*. Il m'aura donc fallut _toute l'après-midi_ pour en venir à…

[ Translate ]

Et voila un nouveau patch de fini. Il m'aura donc fallut toute l'après-midi pour en venir à bout. Finalement, j'ai opté pour deux actions dans le undo. La suppression des polygones (cette action est déjà gérée, autant en profiter) et différentes manipulations sur les différents #polygones. Vu que j'avais bien compris le fonctionnement pour le undo, il a été assez facile de le refaire dans cette nouvelle condition. Seul problème, lorsque je fais plusieurs #undo/redo à la suite, ça plante ... Vraiment pas très sympa comme comportement. Je regarde donc où est ce que ça plante (merci gdb) et je me rends compte que je n'ai pas le bon nombre de points dans mes polygones. En remontant petit à petit, je comprends qu'il y a des points ajoutés lors de la fusion et qu'il faut que je les supprime. Cette fois, le nombre de points est bon mais .. ça plante toujours. Il m'a malheureusement fallut un peu de temps pour me rendre compte que lors de la sélection des polygones à fusionner, je ne les sélectionnais pas dans le bon ordre, ça finissait par mélanger les points donc c'était pas génial. Cette fois, tout à l'air de fonctionner à merveille pour ce qui est de mon undo/redo en tout cas. Par contre, il reste un truc qui me dérange (et que j'ai repéré avant même de changer le code), si je combine au moins 3 polygones, que je fait un undo puis que je ferme le fichier, j'ai une erreur de segmentation à la fermeture. Ok, c'est juste à la fermeture mais n'empêche que c'est pas génial. Je vais donc voir où est l'erreur et apparemment,_ on fait des deletes sur chaque élément d'une liste mais plusieurs éléments sont identiques_. Je commence donc par faire un petit hack pour ne pas faire de delete si l'élément est identique mais, une fois fini, je ne suis toujours pas satisfait. C'est bien, ça fonctionne mais il doit bien y avoir un souci derrière pour qu'il y ait plusieurs fois le même élément. Je retourne donc dans mon code et je me rends compte que c'est lors du undo de la suppression qu'il y a un problème. En effet, si je crée 5 polygones, que je les combine et que je fais un undo, je me retrouve avec 5 fois chacun des polygones dans la liste des items. Plutôt étrange comme comportement mais du coup, ça se rattache un peu à mon projet puisque c'est un bug de undo. C'est reparti pour corriger cette erreur. En lisant un peu le code, je trouve à un endroit : pour chaque élément à supprimer, mettre cette liste ainsi que l'id de l'élément sur la page. Pourquoi pas, mais on n'a pas l'id de l'élément dans la liste des éléments à supprimer (que j'ai donc ajouté par la suite). Ensuite, lors du redo, on recrée chaque élément de la liste et on les met à la position "id" sur la page. Oula, on recrée tous les éléments pour chaque élément. Il semble donc y avoir un problème. Bien sur, c'est pas souvent qu'on supprime plein d'éléments et qu'on joue avec le undo donc c'est possible que ça passe inaperçu mais il faut bien réparer ça quand même. Je supprime donc cette boucle pour recréer seulement l'élément défini par l'id. J'aurais bien aimé discuter de ça avec quelqu'un qui connaît mieux le code mais il est un peu tard donc personne n'est vraiment dispo. Peut-être plus tard. Quoi qu'il en soit, il y a maintenant un Undo/Redo opérationnel et amélioré pour la #combinaisondepolygones.

On m'annonce maintenant que mon dépôt git est disponible, je vais donc pouvoir commencer à uploader ces différents patchs pour ma version, youpiiiiiii :-)

Nouvelle étape, *mise en place du undo/redo pour l'association_de_polygones*. Je dis bien mise en…

[ Translate ]

Nouvelle étape, mise en place du #undo/redo pour l'#associationdepolygones. Je dis bien mise en place puisqu'il n'y a aucune trace de undo dans la fonction qui gère l'association. Comme toujours, je commence par quelques tests pour voir ce qui fonctionne ou ne fonctionne pas. Je remarque donc que les actions effectuées dans ce cas et qui n'ont aucun undo sont les "map" sur les "poline" et l'ajout de points pour le premier polygone ( qui représente le polygone fusionnés). À ce niveau là, deux choix s'offrent à moi. Soit j'ajoute un undo pour chacune de ces actions, soit j'applique "dissocier les polygones" au polygone résultant. Avec la deuxième solution, seuls les points ont été fusionnés dans le nouveau polygone. Si on attribue, par exemple, une couleur différente à chaque polygone, celles ci disparaissent en fusionnant mais ne reviennent pas en les dissociant. Le undo ne serait donc que partiel. Je commence donc avec l'autre solution. J'ajoute un undo pour les "poline.map" et un undo pour l'ajout de points à la forme finale. Je combine ça dans une seule action pour avoir en appuyant sur ctrl-z : recréer tous les polygones supprimés, supprimer tous les points ajoutés dans ma forme finale et restaurer les paramètres de départ, appliquer la transformation inverse à tous les polygones recréés. Jusque là, c'est parfait, j'ai un undo fonctionnel. Un autre problème se pause, je ne fait pas que un undo mais un undo/redo. Or le redo ne fonctionne pas. En effet, j'applique de nouveau mes "poline.map" mais je n'ajoute plus mes points pour les regrouper dans un seul polygone... Je pourrais simplement ré-appliquer "associer les polygones" mais je n'ai nul part dans mes undo enregistrés tous les polygones au même endroit et en ajoutant cette action, certaines autres actions enregistrées comme la suppression des polygones en trop ou l'application du poline.map se ferait deux fois. Décidément ce n'est pas la bonne solution. Je suis donc reparti pour créer plutôt une action spécifique pour l'association de polygones en utilisant autre chose qu'un simpleState pour enregistrer l'action.

Plus de nouvelles bientôt

Ceux qui ne sont pas allés voir de plus près la candidature peuvent se demander ce qui va être fait…

[ Translate ]

Ceux qui ne sont pas allés voir de plus près la candidature peuvent se demander ce qui va être fait durant ce projet. En réalité, il y a beaucoup de petites améliorations possibles qui, regroupées, amélioreraient grandement l'ergonomie de Scribus. Pendant tout cet été, je vais me concentrer sur ce qui est #Undo/redo (ctrl-z si ça vous parle plus). Bien sur, je pourrais me contenter de mettre sur ce blog ce qui est fait et comment c'est réalisé mais je pense que toute la démarche pour arriver à la mise en place du Undo/Redo correspondant est intéressant et je vous passe le temps de recherche dans le code.

Je vais prendre ici l'exemple du premier Undo/redo sur lequel j'ai travaillé. En réalité, j'ai fait ça la semaine dernière, avant l'annonce officielle de Google.

Lorsque l'on #créeuneforme, on peut ensuite double cliquer dessus pour voir apparaître une fenêtre "Points". Dans cette fenêtre, il y a ,entre autres, des boutons pour faire tourner ou redimensionner la forme. Malheureusement, le Undo ne marche pas très bien (Heureusement pour moi, ça me fait du boulot :-)). Pour faire le undo, il faut 4 étapes ce qui remplit la file de undo qui est limitée plutôt rapidement. Donc c'est pas bon. La première idée a donc été de regrouper toutes ces actions en une seule. Mais en faisant des tests, je me suis rendu compte que certaines actions enregistrées en undo étaient en trop puisque la forme n'était pas à la même place à la fin du undo. Retour à la case départ ... Pour comprendre un peu mieux, j'ai cherché qu'est ce qui créait les undo. Finalement, j'ai répertorié deux actions sur les "PoLine" et un "moveItem". Ces actions étaient donc en trop. Pour corriger ça, j'ai encapsulé toute la fonction (jusqu'au undo créé spécialement pour cette action) en désactivant le undo et en l'activant à la fin. Cette fois, tout fonctionne. Mais je me dit : "le undo doit être activé pour que la suite fonctionne or, je l'active à tous les coups juste avant en mettant la valeur de undoEnable sur true". J'essaie donc de sauvegarder la valeur de undo au début de la fonction puis de mettre la valeur du "undoEnable" sur cette valeur à la fin de la fonction. Cette fois, ça ne marche plus ... En cherchant un peu, je comprends que si on met la valeur de "undoEnable" deux fois sur false, il faut le mettre deux fois sur true pour qu'il soit de nouveau activé. Je peux donc revenir à ma solution précédente. Au final, ce changement m'aura pris quelques heures pour trois pauvres petites lignes. Ça m'a au moins permis de comprendre certains principes utilisés dans le undo pour la suite. Il fallait bien commencer quelque part et heureusement que celui ci était plutôt facile. Merci d'avoir lu et n'hésitez pas à me dire si certains passages vous parraissent un peu flou.

Avec l'été arrivent les *Google Summer of Code* (GSoC). Pour ceux qui ne connaissent pas, c'est un…

[ Translate ]

Avec l'été arrivent les Google Summer of Code (#GSoC). Pour ceux qui ne connaissent pas, c'est un été à s'amuser en codant pour un projet libre et en étant payé par Google. C'est pas génial? Je vous conseille de regarder http://www.google-melange.com si vous êtes intéressés.

Ce blog permettra donc de suivre tout au long de l'été mon évolution dans le projet. Disons que c'est à la fois une façon de partager ce que je fais et un outil pour enregistrer mes actions. Il est bien plus facile de faire un rapport sur tout ce qui a été fait depuis le début quand tout est déjà enregistré quelque part.

En réalité, la décision de participer à ce programme a été prise il y a 1 mois déjà... Petit récapitulatif de ce qu'il s'est passé depuis le début : - le 16 Mars, Google publie la liste des projets libres candidats pour les GSoC. En gros, près de 180 projets libres demandent à avoir des étudiants pour offrir de nouvelles fonctionnalités ou être perfectionnés. On a donc une vingtaine de jours pour préparer une candidature. Après deux jours à regarder tous les projets proposés plus ou moins en détail, je choisis de m'orienter vers #Scribus. C'est un #DTP (logiciel pour la publication assistée par ordinateur). C'est ce logiciel que j'ai utilisé toute l'année pour réaliser le CdV (hebdomadaire de Télécom Bretagne), il permet donc de faire tout ce qui est mise en page et réalisation de pdf prêt à être imprimé. Certains connaîtront peut être mieux InDesign de Adobe mais Scribus a l'avantage d'être libre, de fonctionner sur beaucoup d'OS et personnellement, je préfère son utilisation à celle d'InDesign mais c'est une question de goût. Enfin bref ... Je me perds un petit peu. Pour en revenir aux GSoC, pendant ces dernières semaines, j'ai donc discuté régulièrement avec l'équipe de Scribus sur IRC pour préparer une candidature sur le sujet : Usability improvements . Vous pouvez retrouver ma candidature ici : http://wiki.scribus.net/canvas/GSoC2012ImproveUsabilityChelen - 6 Avril : Il faut avoir envoyé une candidature sur le site "melange" de Google. Comme tout était déjà rédigé sur le wiki de Scribus, je me suis contenté de mettre un lien vers la vraie candidature. Après cette date, il est toujours possible de modifier la candidature mais il est bien d'être déjà un peu fixé sur ce qu'on va/veut faire. Pendant ces semaines, j'ai donc travaillé un peu sur le code de Scribus pour fournir des petits patchs. Bien sûr, c'est un pré-requis pour que la candidature soit prise en compte vu que c'est le meilleur moyen de savoir si le candidat sera capable de trouver ce qu'il veut dans le code dès qu'il aura besoin d'y toucher. C'est aussi le meilleur moyen pour le candidat d'être un peu plus familier avec le code de Scribus et de voir comment ça fonctionne. -20 Avril : Les décisions sont prises, les annonces officielles devraient se faire sous peu. Bien sûr, il n'était pas facile de fixer le projet. Tout d'abord, parce que ce n'est pas forcément un travail auquel nous sommes habitués. Aussi, parce que ce projet est déjà bien avancé et que l'on a toujours un peu peur de raconter n'importe quoi quand on ne maîtrise pas le sujet. Et puis on n'a pas encore une grande connaissance de Scribus et de son code donc on ne sait pas toujours ce qui est le plus demandé par les utilisateurs. Au final, me voila accepté pour participer à ces GSoC. Elles commenceront officiellement le 21 Mai si mes souvenirs sont bons et dureront tout l'été. Comme j'ai quelques semaines tranquilles en ce moment, je pense m'y mettre de suite. Quand on s'amuse, on ne fait pas attention à ces détails :-).

Voilà donc un petit résumé de ces dernières semaines. Je vous tiendrais au courant de son avancement et en avant pour un été de codage :-)

The Summer of Code 2012 is on! We are happy to announce that the Scribus Team has been accepted into the illustrious Google Summer of Code program once again. It’s an honor to be a part of the premier Open Source hackathon that has many talented students from around the World work on the Open […]

Scribus 1.4.0 Released

Scribus 1.4.0 Released After almost 4 years of intensive work, the Scribus Team (http://www.scribus.net) has released the new stable version 1.4.0 of the Open Source desktop publishing program Scribus. Given this is the first major stable release in some time, this document outlines improvements over the last number of versions, rather than since just the […]

Happy Birthday Scribus

It is hard to believe Scribus is almost an adolescent. Just yesterday, Scribus turned ten years old, with the first bits of code written by Franz Schmid in December 2000. A few months later, it was linked on Freshmeat and then, well… it kind of had a life of its own. I googled DTP and […]

Millionaires!

I just paid the occasional visit to our download page on Sourceforge, and something seems to have escaped my attention earlier: We have become millionaires! Well, at least download millionaires, as our stable 1.3.3.x has been downloaded more than 1.2 million times since we made Scribus available on SF c. two years ago. Not bad […]

Reminiscencing on GSoC 2009

It was a beautiful beginning of Summer. The Google Summer of Code was on and it was glorious and fun, or at least everyone expected it to be after our previous two years in the program went so well. There was no reason to worry. We had all our ducks lined up in a row […]

Good things can happen (especially if you work on them)

Now that 1.3.5(1) is released, development has regained speed. Here’s a short overview of what has happened recently in 1.5svn and Scribus in general: Scribus founder Franz Schmid returned from his well-deserved break with a big bang, the latter being experimental code to embed 3D objects in Scribus-created PDFs. Franz also wrote import filters for […]

Time to Say “Thank You”

We all know the saying “sometimes life gets in our way,” meaning that something didn’t work as expected. Scribus is no different, although in our case one major fact of “life getting in our way” was newly born (or soon-to-be-born Update: useradd -groups vanek,boys -c "23.07.09 7:00am; 3.2kg, 0.5m" filip) babies, meaning an all-out positive […]