Um eine Tabelle zu erstellen muss man einiges an Vorwissen haben.
Die Breite einer Tabelle wird in Rtf in Twips angegeben. Ca. 57 Twips ergeben 1 Millimeter.
Bei der Spaltenbreite wird immer von der Tabelle ganz links bis zum rechten Rand gerechnet. Die Breiten eventuell vorangehender Spalten werden von der Spaltenbreite abgezogen.
Das ist also ein ganz anderes Verhalten als man ist in beispielsweise Word gewohnt ist.
| Bereite Spalte A | ||
| Breite Spalte B | ||
| Anzeige Spalte B | ||
Wenn ich also die Spaltenbreite von Spalte A als 50mm definiere und die Spaltenbreite von Spalte B als 80mm definiere, bekomme ich als Resultat eine 50mm breite Spalte A gefolgt von einer (80-50) 30mm breiten Spalte B.
Wenn ich Spalte C auf 150mm definiere, dann ist die Breite (150-80) = 70mm
Ich definiere also immer den rechten Rand einer Spalte. Wie breit diese ist, hängt davon ab wie viel Platz die Vorgänger in Anspruch nehmen. Mit etwas Mathematik kann man aber das ganze auch so umrechnen, dass man die Spaltenbreite definiert und sich den rechten Rand ausrechnen lässt.
Dann müssen wir wissen, dass man bei einer Tabelle im RTF immer folgende Struktur einhalten muss.
- Beginne mit Tabelle
- Beginne mit Zeile
- Erstelle Zelle, erstelle Zelle, …
- Beende Zeile
- Beginne Zeile…
- Beende Zeile
- Beende Tabelle
Hält man diese Struktur nicht ein, sieht man keine Tabelle im Formular.
Und der Befehl „Erstelle Zelle“ besteht in Wahrheit auch aus mehreren Befehlen.
- Beginne Zelle
- Fülle Inhalt
- Beende Zelle
Für die meisten Fälle reicht es eine Zelle mit einfachem Text zu befüllen. Für den Fall bietet das rtf Modul eine vereinfachte Funktion an. Manchmal muss man aber komplexere Inhalte, wie Grafiken einsetzen, dann muss man leider wirklich auch die Zelle in Einzelschritten erzeugen.
Genug Theorie. Lass uns eine zunächst leere Tabelle erstellen.
def generateRtf():
R = rtf.RtfText()
sWidth = str(getTotalWidth()) #Breite als String
sDepth = str(getTotalDepth()) #Tiefe als String
R.TableStart()
R.TableEnd()
R.Close()
generateRtf()
Nun erstellen wir uns eine zunächst leere Zeile.
def generateRtf():
R = rtf.RtfText()
sWidth = str(getTotalWidth()) #Breite als String
sDepth = str(getTotalDepth()) #Tiefe als String
R.TableStart()
R.TableStartRow()
R.TableEndRow()
R.TableEnd()
In die Zeile können wir nun eine Zelle schreiben. Wir nehmen den Kurzbefehl, da wir nur „einfachen Text“ haben.
def generateRtf():
R = rtf.RtfText()
sWidth = str(getTotalWidth()) #Breite als String
sDepth = str(getTotalDepth()) #Tiefe als String
R.TableStart()
R.TableStartRow()
R.CellText(SPA_Rand, „Breite“)
R.TableEndRow()
R.TableEnd()
Hier habe ich eine Variable „SPA_Rand“ verwendet (Spalte A, rechter Rand). Diese hat aber noch keinen Wert. Den Wert müssen wir erst einstellen. Hier brauchen wir einen Wert in Twips.
Ich definiere die Variable möglichst weit oben im Skript.
import kkp
import rtf
twipsToMM = 57
SPA_Rand = 60 * twipsToMM
So kann ich einfach 60 mm definieren und Python rechnet mir das dann in Twips um.
Dann schauen wir uns das Ergebnis doch einmal an.
Jetzt erstellen wir uns eine zweite Spalte. Und da die erstelle Spalte den rechten Rand bei 60 MM hat, sagen wir einfach mal die 2. Spalte soll den rechten Rand bei 100 MM haben (damit ist die 2. Spalte dann also nur noch 40 MM breit)
import kkp
import rtf
twipsToMM = 57
SPA_Rand = 60 * twipsToMM
SPB_Rand = 100 * twipsToMM
…
def generateRtf():
R = rtf.RtfText()
sWidth = str(getTotalWidth()) #Breite als String
sDepth = str(getTotalDepth()) #Tiefe als String
R.TableStart()
R.TableStartRow()
R.CellText(SPA_Rand, „Breite“)
R.CellText(SPB_Rand, sWidth)
R.TableEndRow()
R.TableEnd()
R.Close()
Und das können wir dann auch mit der zweiten Zeile machen.
def generateRtf():
R = rtf.RtfText()
sWidth = str(getTotalWidth()) #Breite als String
sDepth = str(getTotalDepth()) #Tiefe als String
R.TableStart()
R.TableStartRow()
R.CellText(SPA_Rand, „Breite“)
R.CellText(SPB_Rand, sWidth)
R.TableEndRow()
R.TableStartRow()
R.CellText(SPA_Rand, „Ausladung“)
R.CellText(SPB_Rand, sDepth)
R.TableEndRow()
R.TableEnd()
R.Close()
Und dann basteln wir uns mal den mathematischen Trick, um nicht den rechten Rand sondern die jeweilige Spaltenbreite anzugeben.
import kkp
import rtf
twipsToMM = 57
SPA_Breite = 60 #mm
SPB_Breite = 40 #mm
SPA_Rand = SPA_Breite * twipsToMM
SPB_Rand = SPB_Breite * twipsToMM + SPA_Rand
Als nächsten möchten wir die Zahlen in der zweiten Spalte rechtbündig ausrichten.
Dafür bietet das rtf Modul gewisse Variablen an, die wir in der Funktion CellText verwenden können.
def generateRtf():
R = rtf.RtfText()
sWidth = str(getTotalWidth()) #Breite als String
sDepth = str(getTotalDepth()) #Tiefe als String
R.TableStart()
R.TableStartRow()
R.CellText(SPA_Rand, „Breite“)
R.CellText(SPB_Rand, sWidth , rtf.PY_RTF_ALIGN_RIGHT)
R.TableEndRow()
R.TableStartRow()
R.CellText(SPA_Rand, „Ausladung“)
R.CellText(SPB_Rand, sDepth , rtf.PY_RTF_ALIGN_RIGHT)
R.TableEndRow()
R.TableEnd()
R.Close()
Als nächstes möchten wir unserer Tabelle noch eine Kopfzeile geben. Das ist dann wichtig, wenn diese auf jeder neuen Seite wiederholt werden soll.
def generateRtf():
R = rtf.RtfText()
sWidth = str(getTotalWidth()) #Breite als String
sDepth = str(getTotalDepth()) #Tiefe als String
R.TableStart()
R.TableStartRowHeader()
R.CellText(SPA_Rand, „Name“ , rtf.PY_RTF_ALIGN_CENTER)
R.CellText(SPB_Rand, „Wert“ , rtf.PY_RTF_ALIGN_CENTER)
R.TableEndRow()
R.TableStartRow()
R.CellText(SPA_Rand, „Breite“)
R.CellText(SPB_Rand, sWidth , rtf.PY_RTF_ALIGN_RIGHT)
R.TableEndRow()
R.TableStartRow()
R.CellText(SPA_Rand, „Ausladung“)
R.CellText(SPB_Rand, sDepth , rtf.PY_RTF_ALIGN_RIGHT)
R.TableEndRow()
